Stage H2O shared-v1.1 13457/13457

H2O/shared-v1.1/script/v1_0_snapshot/script/provenance/previous-run/script/run-full.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -u
+base="$HOME/Datasets/uni-hoi-h2o-full-20260930-w4-c10-d10"
+raw="$HOME/Datasets/Hand-Datasets-Raw/H2O"
+cd "$HOME/Projects/uni-hoi-dataset" || exit 1
+mkdir -p "$base/scratch"
+export TMPDIR="$base/scratch" PYTHONUNBUFFERED=1
+for n in 1 2 3 4; do test -s "$raw/raw/data/subject${n}_v1_1.tar.gz" || exit 2; done
+test ! -e "$base/full.status" || exit 3
+cg=$(awk -F: '$1=="0" {print $3}' /proc/self/cgroup)
+if [[ -f "/sys/fs/cgroup$cg/cpu.max" ]]; then
+    read -r quota period < "/sys/fs/cgroup$cg/cpu.max"
+else
+    quota=max
+    period=controller_disabled
+fi
+printf 'START=%s\nWORKERS=4 CODEC_THREADS=10 DECODE_THREADS=10 DEPTH_THREADS=4 SUBJECTS=1,2,3,4 CASA=false\nCPU_LIMIT=none\nCGROUP=%s\nCPU_MAX=%s %s\n' "$(date -Is)" "$cg" "$quota" "$period" > "$base/full.status"
+if [[ "$quota" != max ]]; then
+    printf 'EXIT=4 ERROR=UNEXPECTED_CPU_QUOTA\n' >> "$base/full.status"
+    exit 4
+fi
+/usr/bin/time -v .venv/bin/python "$base/frozen-code/scripts/convert_h2o_v1.0.py" --root "$raw" --out "$base" --release-id shared-v1.0 --workers 4 --codec-threads 10 --decode-threads 10 --depth-threads 4 --mano-dir "$HOME/Projects/WiLoR/mano_data" > "$base/full.log" 2>&1
+code=$?
+printf 'EXIT=%s END=%s\n' "$code" "$(date -Is)" >> "$base/full.status"
+if [[ -f "/sys/fs/cgroup$cg/cpu.stat" ]]; then cat "/sys/fs/cgroup$cg/cpu.stat" >> "$base/full.status"; fi
+exit "$code"

H2O/shared-v1.1/script/v1_0_snapshot/script/provenance/previous-run/script/warehouse_v1_0.py

@@ -0,0 +1,934 @@
+"""Shared I/O for CONTRACT.md v1.0. No annotation synthesis."""
+import argparse
+from contextlib import contextmanager
+from functools import lru_cache
+import hashlib
+import json
+import math
+import os
+import shlex
+from pathlib import Path
+import pickle
+import random
+import shutil
+import subprocess
+import tempfile
+import time
+
+import numpy as np
+from PIL import Image
+import torch
+
+SCHEMA_PATH = next(p for p in (Path(__file__).resolve().parents[1] / 'docs/schema.json',
+                               Path(__file__).resolve().parents[1] / 'doc/schema.json') if p.is_file())
+SCHEMA = json.loads(SCHEMA_PATH.read_text())
+RAW_ROOT = Path.home() / 'Datasets/Hand-Datasets-Raw'
+
+
+def json_write(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + '\n')
+
+
+def jsonl_write(path, rows):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w') as out:
+        for row in rows:
+            out.write(json.dumps(row, ensure_ascii=False, allow_nan=False) + '\n')
+
+
+def sha256(path):
+    with Path(path).open('rb') as f:
+        return hashlib.file_digest(f, 'sha256').hexdigest()
+
+
+def locator(path, member=None, data=None, **extra):
+    result = {'file': str(Path(path).resolve())}
+    if member is not None:
+        result['member'] = member
+    if data is not None:
+        result['sha256'] = hashlib.sha256(data).hexdigest()
+    return result | extra
+
+
+def source(method='Copy source annotation; normalize storage only'):
+    return {'kind': 'format_conversion', 'method': method}
+
+
+def run(args, **kwargs):
+    return subprocess.run(args, check=True, stderr=subprocess.PIPE, **kwargs)
+
+
+@lru_cache(maxsize=1)
+def ffversion():
+    return run(['ffmpeg', '-version'], stdout=subprocess.PIPE).stdout.decode().splitlines()[0]
+
+
+def probe(path):
+    return json.loads(run(['ffprobe', '-v', 'error', '-select_streams', 'v:0',
+                           '-show_streams', '-of', 'json', str(path)],
+                          stdout=subprocess.PIPE).stdout)['streams'][0]
+
+
+def decode_args(path, pixel_format):
+    threads = os.environ.get('HAND_WAREHOUSE_FFMPEG_THREADS', '1')
+    return ['ffmpeg', '-v', 'error', '-nostdin', '-filter_threads', threads, '-threads', threads, '-noautorotate',
+            '-i', str(path), '-map', '0:v:0', '-vsync', '0', '-threads', threads,
+            '-f', 'rawvideo', '-pix_fmt', pixel_format]
+
+
+def decoded_digest(path, pixel_format):
+    start = time.monotonic()
+    with tempfile.TemporaryFile() as err:
+        proc = subprocess.Popen(decode_args(path, pixel_format) + ['pipe:1'],
+                                stdout=subprocess.PIPE, stderr=err)
+        digest, size = hashlib.sha256(), 0
+        with proc.stdout:
+            while chunk := proc.stdout.read(1024 * 1024):
+                digest.update(chunk)
+                size += len(chunk)
+        if proc.wait():
+            err.seek(0)
+            raise RuntimeError(err.read().decode(errors='replace'))
+    return digest.hexdigest(), size, time.monotonic() - start
+
+
+def video_frames(path, pixel_format, shape, dtype):
+    frame_bytes = int(np.prod(shape)) * np.dtype(dtype).itemsize
+    with tempfile.TemporaryFile() as err:
+        proc = subprocess.Popen(decode_args(path, pixel_format) + ['pipe:1'], stdout=subprocess.PIPE, stderr=err)
+        completed = False
+        try:
+            while True:
+                data = proc.stdout.read(frame_bytes)
+                if not data:
+                    break
+                if len(data) != frame_bytes:
+                    raise ValueError('truncated decoded video frame')
+                yield np.frombuffer(data, dtype=dtype).reshape(shape)
+            if proc.wait():
+                err.seek(0)
+                raise ValueError(err.read().decode(errors='replace'))
+            completed = True
+        finally:
+            proc.stdout.close()
+            if not completed and proc.poll() is None:
+                proc.terminate()
+            proc.wait()
+
+
+def storage(path, profile, parameters, source_lossy):
+    info = probe(path)
+    if info['codec_name'] == 'h264':
+        frames = json.loads(run(['ffprobe', '-v', 'error', '-threads', '1', '-select_streams', 'v:0',
+            '-show_entries', 'frame=key_frame', '-of', 'json', str(path)], stdout=subprocess.PIPE).stdout)['frames']
+        parameters = parameters | {'keyframe_indices': [i for i, f in enumerate(frames) if f['key_frame']]}
+    return {'profile': profile, 'codec': info['codec_name'],
+            'pixel_format': info['pix_fmt'], 'encoded_size': [info['width'], info['height']],
+            'decoder': {'name': 'ffmpeg', 'version': ffversion(), 'autorotate': False,
+                        'color_space': info.get('color_space', 'unknown'),
+                        'color_range': info.get('color_range', 'unknown'),
+                        'color_primaries': info.get('color_primaries', 'unknown'),
+                        'color_transfer': info.get('color_transfer', 'unknown')},
+            'encoder_parameters': {'version': ffversion()} | parameters,
+            'source_lossy': source_lossy, 'storage_fps': 30, 'timebase_role': 'index_only'}
+
+
+def encode_raw(raw, target, width, height, pixel_format, profile, codec='ffv1', extra=(), threads=1):
+    start = time.monotonic()
+    run(['ffmpeg', '-v', 'error', '-nostdin', '-filter_threads', '1', '-y', '-f', 'rawvideo',
+         '-pixel_format', pixel_format, '-video_size', f'{width}x{height}', '-framerate', '30',
+         '-i', str(raw), '-an', '-c:v', codec, '-threads', str(threads), *extra, str(target)])
+    digest, size, decode_seconds = decoded_digest(target, pixel_format)
+    if size != Path(raw).stat().st_size or digest != sha256(raw):
+        raise ValueError(f'lossless roundtrip failed: {target}')
+    config = storage(target, profile, {'name': codec, 'arguments': list(extra), 'threads': threads}, False)
+    return config, {'bytes': target.stat().st_size, 'encode_seconds': time.monotonic() - start - decode_seconds,
+                    'decode_seconds': decode_seconds, 'decoded_sha256': digest, 'all_frames_exact': True}
+
+
+def measure_rgb_access(video, raw, width, height, count):
+    index = count // 2
+    start = time.monotonic()
+    data = run(decode_args(video, 'rgb24') +
+               ['-vf', f'select=eq(n\\,{index})', '-frames:v', '1', 'pipe:1'],
+               stdout=subprocess.PIPE).stdout
+    with raw.open('rb') as inp:
+        inp.seek(index * width * height * 3)
+        if data != inp.read(width * height * 3):
+            raise ValueError('exact indexed RGB read failed')
+    return {'random_access_strategy': 'decode from first keyframe; select exact presentation index',
+            'random_frame_index': index, 'random_frame_read_seconds': time.monotonic() - start}
+
+
+def jpeg_sample_indices(sequence, camera, count):
+    seed = int.from_bytes(hashlib.sha256(f'{sequence}/{camera}/20260920'.encode()).digest()[:8], 'big')
+    indices = {0, count - 1, count // 4, count // 2, 3 * count // 4}
+    indices.update(random.Random(seed).sample([i for i in range(count) if i not in indices],
+                                            min(count, 16) - len(indices)))
+    return sorted(indices), seed
+
+
+def check_jpeg_copy(target, paths, hashes, size, sequence, camera, full):
+    packets = json.loads(run(['ffprobe', '-v', 'error', '-select_streams', 'v:0',
+        '-show_packets', '-show_data_hash', 'sha256', '-of', 'json', str(target)],
+        stdout=subprocess.PIPE).stdout)['packets']
+    if [p['data_hash'].split(':', 1)[1].lower() for p in packets] != hashes:
+        raise ValueError('JPEG packet hashes/order/count differ')
+    info = probe(target)
+    if [info['width'], info['height']] != list(size):
+        raise ValueError('JPEG container dimensions differ')
+    indices, seed = jpeg_sample_indices(sequence, camera, len(paths))
+    if full:
+        indices = list(range(len(paths)))
+    select = '+'.join(f'eq(n\\,{i})' for i in indices)
+    frame_bytes = size[0] * size[1] * 3
+    # Spool selected frames to disk, keeping RAM bounded for full-view audits.
+    with tempfile.TemporaryFile() as decoded:
+        run(decode_args(target, 'rgb24') + ([] if full else ['-vf', 'select=' + select]) + ['pipe:1'], stdout=decoded)
+        decoded.seek(0)
+        for i in indices:
+            expected = run(decode_args(paths[i], 'rgb24') + ['pipe:1'], stdout=subprocess.PIPE).stdout
+            if len(expected) != frame_bytes or decoded.read(frame_bytes) != expected:
+                raise ValueError(f'JPEG decoded pixels differ at frame {i}')
+        if decoded.read(1):
+            raise ValueError('JPEG selected pixel count differs')
+    return {'policy': 'jpeg-packets-all-rgb-sample16/v1', 'seed': seed,
+            'selected_frame_indices': indices, 'pixel_frames_checked': len(indices),
+            'packet_frames_checked': len(paths), 'jpeg_packets_exact': True,
+            'packet_count_order_dimensions_exact': True, 'sampled_pixels_exact': True,
+            'all_frames_exact': len(indices) == len(paths), 'full_view_audit': full}
+
+
+def rgb_video(paths, target, work, video=None, count=None, sequence="", camera="", full_jpeg=False,
+              ffv1_first=False, codec_threads=1):
+    """JPEG packet proof plus deterministic pixels; re-encodings compare all pixels."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    raw = work / 'rgb.raw'
+    packets = []
+    has_missing = video is None and any(p is None for p in paths)
+    if has_missing:
+        present = next((p for p in paths if p is not None), None)
+        if present is None:
+            raise ValueError('no source RGB image to establish the pixel format/grid')
+        original = probe(present)
+        width, height = original['width'], original['height']
+        with raw.open('wb') as dest:
+            for path in paths:
+                if path is None:
+                    dest.write(bytes(width * height * 3))
+                else:
+                    with Image.open(path) as im:
+                        if im.mode != 'RGB' or im.size != (width, height):
+                            raise ValueError('source RGB grid/type changes within view')
+                    run(decode_args(path, 'rgb24') + ['pipe:1'], stdout=dest)
+        lossy, count = 'unknown', len(paths)
+        input_args = None
+    elif video is None:
+        if not paths:
+            raise ValueError('RGB timeline must contain existing source images')
+        suffix = paths[0].suffix.lower()
+        if suffix not in ('.jpg', '.jpeg', '.png'):
+            raise ValueError('unsupported source RGB format')
+        images = work / 'rgb_source'
+        images.mkdir()
+        dimensions = None
+        for i, path in enumerate(paths):
+            with Image.open(path) as im:
+                if im.mode != 'RGB' or (dimensions is not None and dimensions != im.size):
+                    raise ValueError('RGB must be homogeneous 8-bit RGB, with no silent color/size conversion')
+                dimensions = im.size
+                if im.format == 'PNG' and path.read_bytes()[24] != 8:
+                    raise ValueError('high bit depth RGB needs a registered schema')
+            dest = images / f'{i:08d}{suffix}'
+            shutil.copyfile(path, dest)
+            packets.append(sha256(path))
+        width, height = dimensions
+        input_args = ['-framerate', '30', '-i', str(images / ('%08d' + suffix))]
+        count = len(paths)
+        original = probe(paths[0])
+        lossy = suffix in ('.jpg', '.jpeg')
+    else:
+        original = probe(video)
+        if int(original.get('bits_per_raw_sample') or 8) > 8 or any(
+                x in original.get('pix_fmt', '') for x in ('10', '12', '16', 'f32')):
+            raise ValueError('high bit depth RGB needs a registered schema')
+        width, height = original['width'], original['height']
+        input_args = ['-i', str(video)]
+        lossy = 'unknown'
+    limits = ['-frames:v', str(count)] if count else []
+    records = []
+    if video is None and not has_missing and suffix in ('.jpg', '.jpeg'):
+        start = time.monotonic()
+        try:
+            run(['ffmpeg', '-v', 'error', '-nostdin', '-y', *input_args, '-map', '0:v:0',
+                 *limits, '-c:v', 'copy', '-an', str(target)])
+            encode_seconds = time.monotonic() - start
+            validation = check_jpeg_copy(target, paths, packets, (width, height), sequence, camera, full_jpeg)
+            cfg = storage(target, 'mkv/mjpeg_copy/v1', {'stream_copy': True}, lossy)
+            cfg['decoder']['source_color_metadata'] = {k: original.get(k, 'unknown') for k in
+                ('color_space', 'color_range', 'color_primaries', 'color_transfer')}
+            records.append(validation | {'profile': cfg['profile'], 'bytes': target.stat().st_size,
+                'encode_seconds': encode_seconds, 'validation_seconds': time.monotonic() - start - encode_seconds})
+            return cfg, [width, height], records, count
+        except (subprocess.CalledProcessError, ValueError) as exc:
+            records.append({'profile': 'mkv/mjpeg_copy/v1', 'rejected': str(exc)})
+            target.unlink(missing_ok=True)
+    if not has_missing:
+        threads = os.environ.get('HAND_WAREHOUSE_FFMPEG_THREADS', '1')
+        run(['ffmpeg', '-v', 'error', '-nostdin', '-y', '-threads', threads, '-noautorotate',
+             *input_args, '-map', '0:v:0', *limits, '-vsync', '0', '-threads', threads,
+             '-f', 'rawvideo', '-pix_fmt', 'rgb24', str(raw)])
+    frame_bytes = width * height * 3
+    actual, remainder = divmod(raw.stat().st_size, frame_bytes)
+    if remainder or not actual or (count is not None and actual != count):
+        raise ValueError('source RGB frame count mismatch')
+    expected_hash = sha256(raw)
+    can_copy = video is not None
+    if can_copy:
+        start = time.monotonic()
+        try:
+            run(['ffmpeg', '-v', 'error', '-nostdin', '-y', *input_args, '-map', '0:v:0',
+                 *limits, '-c:v', 'copy', '-an', str(target)])
+            digest, size, seconds = decoded_digest(target, 'rgb24')
+            if digest != expected_hash or size != raw.stat().st_size:
+                raise ValueError('stream-copy RGB bytes/order/count mismatch')
+            cfg = storage(target, 'mkv/source_copy/v1',
+                          {'stream_copy': True}, lossy)
+            if video:
+                cfg['storage_fps'] = original.get('avg_frame_rate')
+                cfg['preserve_source_pts'] = True
+            records.append({'profile': cfg['profile'], 'all_frames_exact': True,
+                            'decoded_sha256': digest,
+                            'bytes': target.stat().st_size, 'decode_seconds': seconds,
+                            'encode_seconds': time.monotonic() - start - seconds})
+            records[-1].update(measure_rgb_access(target, raw, width, height, actual))
+            return cfg, [width, height], records, actual
+        except (subprocess.CalledProcessError, ValueError) as exc:
+            records.append({'profile': 'stream_copy', 'rejected': str(exc)})
+            target.unlink(missing_ok=True)
+    candidates = []
+    for profile, codec, params in [
+        ('mkv/ffv1_rgb/v1', 'ffv1', ['-level', '3', '-pix_fmt', 'bgr0']),
+        ('mkv/h264_rgb_lossless/v1', 'libx264rgb', ['-crf', '0', '-preset', 'medium', '-g', '30'])]:
+        path = work / (codec + '.mkv')
+        try:
+            cfg, record = encode_raw(raw, path, width, height, 'rgb24', profile, codec, params,
+                                     codec_threads if codec == 'ffv1' else 1)
+            cfg['source_lossy'] = lossy
+            cfg['decoder']['source_color_metadata'] = {k: original.get(k, 'unknown') for k in
+                ('color_space', 'color_range', 'color_primaries', 'color_transfer')}
+            record['profile'] = profile
+            record.update(measure_rgb_access(path, raw, width, height, actual))
+            records.append(record)
+            candidates.append((path.stat().st_size, path, cfg))
+            if ffv1_first and codec == 'ffv1':
+                break  # Keep the H.264 fallback only if the preferred exact encoder fails.
+        except subprocess.CalledProcessError as exc:
+            records.append({'profile': profile, 'rejected': exc.stderr.decode(errors='replace')})
+    if not candidates:
+        raise ValueError('no supported lossless RGB encoder')
+    _, chosen, cfg = min(candidates, key=lambda x: x[0])
+    shutil.move(chosen, target)
+    return cfg, [width, height], records, actual
+
+
+def pack_depth(depth):
+    bits = np.ascontiguousarray(depth, dtype='<f4').view('<u4')
+    return np.concatenate([(bits & 65535).astype('<u2'), (bits >> 16).astype('<u2')], axis=-1)
+
+
+def unpack_depth(encoded):
+    low, high = np.split(np.asarray(encoded, dtype='<u2'), 2, axis=-1)
+    return (low.astype('<u4') | (high.astype('<u4') << 16)).view('<f4')
+
+
+def check_transform(values):
+    a = np.asarray(values)
+    if not np.isfinite(a).all() or a.shape[-2:] != (4, 4):
+        raise ValueError('invalid transform shape/values')
+    if not np.allclose(a[..., 3, :], [0, 0, 0, 1], atol=1e-5):
+        raise ValueError('invalid homogeneous transform row')
+    r = a[..., :3, :3]
+    if not np.allclose(np.swapaxes(r, -1, -2) @ r, np.eye(3), atol=2e-3) or not np.allclose(
+            np.linalg.det(r), 1, atol=2e-3):
+        raise ValueError('nonrigid rotation')
+
+
+class View:
+    def __init__(self, path, dataset, release, sequence, camera, frames, sampling='dense', split='unknown'):
+        self.path = Path(path)
+        self.path.mkdir(parents=True, exist_ok=True)
+        self.frames = frames
+        self.valid_rules = {}
+        self.full_jpeg = False
+        self.meta = dict(schema_version=SCHEMA['schema_version'], dataset_id=dataset,
+                         release_id=release, sequence_id=sequence, camera_id=camera,
+                         sample_type='video', num_frames=len(frames), hand_slots=['left', 'right'],
+                         sampling={'type': sampling, 'source_fps': None, 'frames_ref': 'camera/frames.jsonl'},
+                         camera={'model': 'unknown', 'schema_id': None, 'image_size': None},
+                         components={}, split=split, view_type='unknown')
+        if split == 'unknown':
+            self.meta['split_reason'] = 'No verified official split mapping available for this sequence'
+        self.build = {'validation': [], 'unresolved': [], 'validity_revision': SCHEMA['validity_revision']}
+
+    def absent(self, key, reason, status='source_missing'):
+        self.meta['components'][key] = {'available': False, 'reason': reason, 'status': status}
+        if status != 'source_missing':
+            self.build['unresolved'].append({'component': key, 'status': status, 'reason': reason})
+
+    def component(self, key, schema, ref, axes, loc, **extra):
+        if schema not in SCHEMA['components']:
+            raise ValueError(f'unregistered schema: {schema}')
+        if ref.startswith('annotation/') and extra.get('valid_ref'):
+            rule = self.valid_rules.get(key, self.valid_rules.get(key.split('_')[0]))
+            if not rule:
+                raise ValueError(f'{key}: adapter must declare annotation validity rule')
+            extra.setdefault('valid_policy', dict(
+                revision=SCHEMA['validity_revision'], meaning=SCHEMA['annotation_validity']['meaning'],
+                source_rule=rule, source_locator=loc, scope=extra.get('valid_axes', axes),
+                numerical_checks='Schema shape, finite valid floats, SE(3) where applicable; malformed input aborts',
+                official_qa={'status': 'not_provided', 'reason': 'No separate applicable official QA in selected source inputs'},
+                local_excluded_frame_indices=[], local_exclusion_reasons={}, visibility_independent=True))
+        self.meta['components'][key] = dict(available=True, schema_id=schema, data_ref=ref,
+                                          axes=axes, provenance=source(), source_locator=loc) | extra
+        return self.meta['components'][key]
+
+    def tensor(self, key, schema, ref, array, valid, axes, loc, **extra):
+        array = np.asarray(array, dtype=np.float32)
+        valid = np.asarray(valid, dtype=bool)
+        valid_shape = SCHEMA['components'][schema].get('valid_shape')
+        if valid_shape and (len(valid_shape) != valid.ndim or any(isinstance(s, int) and valid.shape[i] != s for i, s in enumerate(valid_shape))):
+            raise ValueError(f'{key}: schema validity shape mismatch')
+        if array.shape[:valid.ndim] != valid.shape:
+            raise ValueError(f'{key}: validity axes mismatch')
+        if not np.isfinite(array[valid]).all():
+            raise ValueError(f'{key}: source annotation exists but is nonfinite')
+        array = array.copy()
+        array[~valid] = np.nan
+        if schema in ('transform/se3/v1', 'object/rigid/v1'):
+            check_transform(array[valid])
+        expected = SCHEMA['components'][schema].get('shape')
+        if expected and (len(expected) != array.ndim or any(
+                isinstance(n, int) and array.shape[i] != n for i, n in enumerate(expected))):
+            raise ValueError(f'{key}: schema shape mismatch {array.shape}')
+        dest = self.path / ref
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        torch.save(torch.from_numpy(array), dest)
+        valid_ref = str(Path(ref).with_name(Path(ref).stem + '_valid.pt'))
+        torch.save(torch.from_numpy(valid.copy()), self.path / valid_ref)
+        return self.component(key, schema, ref, axes, loc, valid_ref=valid_ref,
+                              valid_axes=axes[:valid.ndim], **extra)
+
+    def rgb(self, paths, loc, video=None, count=None, ffv1_first=False, codec_threads=1):
+        with tempfile.TemporaryDirectory(prefix='rgb-', dir=self.path) as work:
+            cfg, size, records, n = rgb_video(paths, self.path / 'observation/rgb.mkv',
+                                             Path(work), video, count, self.meta['sequence_id'], self.meta['camera_id'],
+                                             self.full_jpeg, ffv1_first, codec_threads)
+        if n != len(self.frames):
+            raise ValueError('RGB differs from frames timeline')
+        torch.save(torch.ones(n, dtype=torch.bool, device='cpu') if video is not None else
+                   torch.tensor([p is not None for p in paths], dtype=torch.bool, device='cpu'),
+                   self.path / 'observation/rgb_valid.pt')
+        self.component('rgb', 'rgb/uint8/v1', 'observation/rgb.mkv', ['T', 'height', 'width', 'channel'],
+                       loc, storage=cfg, valid_ref='observation/rgb_valid.pt', valid_axes=['T'],
+                       provenance=source('Verified source packet copy or lossless fixed-decoder RGB encoding'))
+        self.meta['camera']['image_size'] = size
+        self.build['validation'].extend(records)
+
+    def raster(self, key, arrays, valid, loc, labels=None, codec_threads=1):
+        depth = key == 'depth'
+        ref = 'observation/depth.mkv' if depth else 'annotation/segment/mask.mkv'
+        dest = self.path / ref
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        width, height = self.meta['camera']['image_size']
+        count = 0
+        with tempfile.TemporaryDirectory(prefix='raster-', dir=self.path) as wd:
+            work = Path(wd)
+            with (work / 'data.raw').open('wb') as out, (work / 'valid.raw').open('wb') as vo:
+                for arr in arrays:
+                    arr = np.asarray(arr)
+                    if arr.shape != (height, width):
+                        raise ValueError(f'{key}: raster not on RGB grid')
+                    if depth:
+                        arr = arr.astype('<f4')
+                        good = np.isfinite(arr) & (arr > 0)
+                        arr[~good] = np.nan
+                        out.write(pack_depth(arr).tobytes())
+                        vo.write(good.astype(np.uint8).tobytes())
+                    else:
+                        if not np.issubdtype(arr.dtype, np.integer) or arr.min() < 0 or arr.max() > 65535:
+                            raise ValueError('invalid segmentation region codes')
+                        out.write(arr.astype('<u2').tobytes())
+                    count += 1
+            if count != len(self.frames):
+                raise ValueError(f'{key}: frame count mismatch')
+            cfg, record = encode_raw(work / 'data.raw', dest, width * (2 if depth else 1), height,
+                                    'gray16le', 'mkv/depth_float32_bits/v1' if depth else 'mkv/uint16_ffv1/v1',
+                                    threads=codec_threads)
+            self.build['validation'].append(record | {'component': key})
+            if depth:
+                vcfg, record = encode_raw(work / 'valid.raw', self.path / 'observation/depth_valid.mkv',
+                                         width, height, 'gray', 'mkv/bool_ffv1/v1', threads=codec_threads)
+                self.build['validation'].append(record | {'component': 'depth_valid'})
+                self.component(key, 'depth/z_float32/v1', ref, ['T', 'height', 'width'], loc,
+                    storage=cfg, valid_storage=vcfg, valid_ref='observation/depth_valid.mkv',
+                    valid_axes=['T', 'height', 'width'], unit='m', depth_type='z', depth_origin='measured', invalid_value='NaN')
+            else:
+                vref = 'annotation/segment/mask_valid.pt'
+                torch.save(torch.as_tensor(valid, dtype=torch.bool, device='cpu'), self.path / vref)
+                jsonl_write(self.path / 'annotation/segment/instances.jsonl', labels)
+                self.component(key, 'segment/uint16_labels/v1', ref, ['T', 'height', 'width'], loc,
+                    storage=cfg, valid_ref=vref, valid_axes=['T'], segmentation_type='instance',
+                    mapping_ref='annotation/segment/instances.jsonl', coverage={'kind': 'unknown'})
+
+    def camera(self, intrinsic, loc, extrinsic=None, extrinsic_loc=None):
+        n = len(self.frames)
+        if intrinsic is not None:
+            a = np.asarray(intrinsic)
+            a = np.broadcast_to(a, (n, 3, 3)) if a.shape == (3, 3) else a
+            if not np.allclose(a[..., 2, :], [0, 0, 1]) or np.any(a[..., 0, 0] <= 0) or np.any(a[..., 1, 1] <= 0):
+                raise ValueError('invalid pinhole intrinsic matrix')
+            self.tensor('intrinsic', 'camera/pinhole/v1', 'camera/intrinsic.pt', a,
+                        np.ones(n, bool), ['T', 'row', 'column'], loc)
+            self.meta['camera'].update(model='pinhole', schema_id='camera/pinhole/v1')
+        if extrinsic is not None:
+            a = np.asarray(extrinsic)
+            a = np.broadcast_to(a, (n, 4, 4)) if a.shape == (4, 4) else a
+            self.tensor('extrinsic', 'transform/se3/v1', 'camera/extrinsic.pt', a,
+                        np.ones(n, bool), ['T', 'row', 'column'], extrinsic_loc or loc,
+                        convention='T_camera_from_world')
+
+    def object(self, oid, loc, scope='sequence', scope_id=None, **extra):
+        info = dict(object_id=oid, identity_scope=scope, scope_id=scope_id or self.meta['sequence_id'],
+                    source_locator=loc, has_model=False) | extra
+        json_write(self.path / f'annotation/object/{oid}/metainfo.json', info)
+        return info
+
+    def relations(self, rows, valid, loc):
+        ref = 'annotation/contact/relations.jsonl'
+        jsonl_write(self.path / ref, rows)
+        vref = 'annotation/contact/relations_valid.pt'
+        torch.save(torch.as_tensor(valid, dtype=torch.bool, device='cpu'), self.path / vref)
+        self.component('relations', 'contact/relations/v1', ref, ['T'], loc, valid_ref=vref, valid_axes=['T'])
+
+    def finish(self):
+        check_view_type(self.meta)
+        for key, component in self.meta['components'].items():
+            if component.get('valid_policy'):
+                check_valid_policy(component, len(self.frames))
+                valid = torch.load(self.path / component['valid_ref'], weights_only=True)
+                self.build.setdefault('annotation_validity', {})[key] = {
+                    'valid_policy': component['valid_policy'], 'valid_count': int(valid.sum()),
+                    'invalid_count': valid.numel() - int(valid.sum())}
+        for i, frame in enumerate(self.frames):
+            frame.update(frame_index=i)
+            frame.setdefault('timestamp_ns', None)
+            frame.setdefault('clock_domain', None)
+            if 'source_locator' not in frame:
+                raise ValueError('frame source locator missing')
+        jsonl_write(self.path / 'camera/frames.jsonl', self.frames)
+        json_write(self.path / 'metainfo.json', self.meta)
+        return self.build
+
+
+def check_mesh(path, asset_root):
+    path, asset_root = Path(path), Path(asset_root).resolve()
+    vertices, faces, largest_index = 0, 0, 0
+    materials = []
+    with path.open() as inp:
+        for line in inp:
+            fields = line.split()
+            if not fields or fields[0].startswith('#'):
+                continue
+            if fields[0] == 'v':
+                if len(fields) < 4 or not all(math.isfinite(float(v)) for v in fields[1:4]):
+                    raise ValueError(f'invalid mesh vertex: {path}')
+                vertices += 1
+            elif fields[0] == 'f':
+                if len(fields) < 4:
+                    raise ValueError('degenerate OBJ face')
+                for field in fields[1:]:
+                    index = int(field.split('/')[0])
+                    if index == 0 or index < -vertices:
+                        raise ValueError('invalid OBJ vertex index')
+                    largest_index = max(largest_index, index)
+                faces += 1
+            elif fields[0] == 'mtllib':
+                materials.extend(shlex.split(line)[1:])
+    if not vertices or not faces or largest_index > vertices:
+        raise ValueError('empty or invalid mesh')
+    def dependency(parent, name):
+        dep = (parent / name).resolve()
+        if not dep.is_relative_to(asset_root) or not dep.is_file():
+            raise ValueError(f'missing or escaping asset dependency: {name}')
+        return dep
+    dependencies = []
+    for name in materials:
+        mtl = dependency(path.parent, name)
+        dependencies.append(mtl)
+        for line in mtl.read_text().splitlines():
+            fields = shlex.split(line, comments=True)
+            if fields and (fields[0].startswith('map_') or fields[0] in ('bump', 'norm', 'disp', 'decal')):
+                dependencies.append(dependency(mtl.parent, fields[-1]))
+    return {'vertices': vertices, 'faces': faces, 'sha256': sha256(path),
+            'dependencies': {p.relative_to(asset_root).as_posix(): sha256(p) for p in dependencies}}
+
+
+def mesh_asset(view, oid, directory, obj, loc):
+    dest = view.path / f'annotation/object/{oid}/assets'
+    shutil.copytree(directory, dest)
+    ref = (dest / Path(obj).relative_to(directory)).relative_to(view.path).as_posix()
+    mesh_check = check_mesh(dest / Path(obj).relative_to(directory), dest)
+    view.build['validation'].append({'component': f'mesh_{oid}', **mesh_check})
+    view.component(f'mesh_{oid}', 'mesh/obj/v1', ref, ['vertex'], loc, valid=True, unit='m')
+    p = view.path / f'annotation/object/{oid}/metainfo.json'
+    info = json.loads(p.read_text())
+    info.update(has_model=True, mesh_ref=ref)
+    json_write(p, info)
+
+
+def safe_member(root, name):
+    path = (Path(root) / name).resolve()
+    if not path.is_relative_to(Path(root).resolve()):
+        raise ValueError(f'unsafe archive path: {name}')
+    return path
+
+
+class ChumpyStub:
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+
+class ManoUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if module.startswith('chumpy'):
+            return ChumpyStub
+        return super().find_class(module, name)
+
+
+def mano_models(directory):
+    result = {}
+    if directory is None:
+        return result
+    for side in ('left', 'right'):
+        path = Path(directory).expanduser() / f'MANO_{side.upper()}.pkl'
+        if not path.exists():
+            continue
+        with path.open('rb') as f:
+            data = ManoUnpickler(f, encoding='latin1').load()
+        result[side] = {'components': np.asarray(data['hands_components']),
+                        'mean': np.asarray(data['hands_mean']), 'sha256': sha256(path),
+                        'file': path.name}
+    return result
+
+
+def model_profile(models):
+    identity = json.dumps({side: d['sha256'] for side, d in sorted(models.items())}).encode()
+    return {'version': 'sha256:' + hashlib.sha256(identity).hexdigest(), 'flat_hand_mean': True,
+            'left_shapedirs_correction': 'not_applied',
+            'models': {side: {'file': d['file'], 'sha256': d['sha256']} for side, d in models.items()}}
+
+
+def pca_to_axis_angle(coeffs, model):
+    coeffs = np.asarray(coeffs)
+    if coeffs.shape[-1:] != (45,) or not np.isfinite(coeffs).all():
+        raise ValueError('invalid MANO PCA coefficients')
+    return coeffs @ model['components'] + model['mean']
+
+
+def parser(dataset, description):
+    p = argparse.ArgumentParser(description=description)
+    p.add_argument('--root', f'--{dataset.lower()}-root', dest='root', type=Path, default=RAW_ROOT / dataset)
+    p.add_argument('--out', type=Path, default=Path('converted'))
+    p.add_argument('--release-id', default='v1.0')
+    p.add_argument('--limit', type=int, help='Maximum sequences to convert')
+    p.add_argument('--max-frames', type=int, help='First N source frame indices per view (recorded as sampling)')
+    p.add_argument('--mano-dir', type=Path)
+    p.add_argument('--views', help='Comma-separated source camera IDs')
+    p.add_argument('--jpeg-full-check', action='store_true', help='Full decoded RGB check for selected JPEG pilot/final views')
+    return p
+
+
+def roots(root):
+    root = Path(root).expanduser()
+    return [p for p in (root / 'raw/data', root / 'raw', root) if p.is_dir()]
+
+
+def find_file(root, name):
+    return next((p / name for p in roots(root) if (p / name).exists()), None)
+
+
+def release(args, dataset):
+    if not args.release_id or Path(args.release_id).name != args.release_id or args.release_id in ('.', '..'):
+        raise ValueError('release-id must be a single directory name')
+    if args.limit is not None and args.limit < 1 or args.max_frames is not None and args.max_frames < 1:
+        raise ValueError('limits must be positive')
+    out = args.out.expanduser().resolve() / dataset / args.release_id
+    raw = args.root.expanduser().resolve()
+    if out == raw or out.is_relative_to(raw):
+        raise ValueError('output must not modify the raw source tree')
+    (out / 'data').mkdir(parents=True, exist_ok=True)
+    (out / 'doc').mkdir(exist_ok=True)
+    (out / 'script').mkdir(exist_ok=True)
+    scripts = list(Path(__file__).resolve().parent.glob('*.py'))
+    existing = {p.name for p in (out / 'script').glob('*.py')}
+    if existing and existing != {p.name for p in scripts}:
+        raise ValueError('converter files changed; choose a new --release-id')
+    copies = [(SCHEMA_PATH.parent / name, out / 'doc' / name) for name in ('CONTRACT.md', 'schema.json')]
+    copies += [(path, out / 'script' / path.name) for path in scripts]
+    # Check every existing file before changing any published definition or script.
+    for src, dest in copies:
+        if dest.exists() and sha256(dest) != sha256(src):
+            raise ValueError('converter or contract changed within an existing release; choose a new --release-id')
+    for src, dest in copies:
+        if src.resolve() != dest.resolve():
+            shutil.copyfile(src, dest)
+    json_write(out / 'script/config.json', {k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()})
+    return out
+
+
+@contextmanager
+def sequence_dir(out, sequence):
+    if Path(sequence).name != sequence:
+        raise ValueError('sequence ID must be a single path component')
+    final = out / 'data' / sequence
+    with tempfile.TemporaryDirectory(prefix=sequence + '.tmp-', dir=out / 'data') as wd:
+        tmp = Path(wd)
+        yield tmp
+        if final.exists():
+            if any((final / child.name).exists() for child in tmp.iterdir()):
+                raise FileExistsError('view already published; use a new release-id to preserve it')
+            for child in list(tmp.iterdir()):
+                child.rename(final / child.name)
+        else:
+            tmp.rename(final)
+
+
+def build_record(out, sequence, reports):
+    path = out / 'doc' / (sequence + '.build.json')
+    previous = json.loads(path.read_text()) if path.exists() else {}
+    config = json.loads((out / 'script/config.json').read_text())
+    for report in reports.values():
+        report['configuration'] = config
+    json_write(path, {'sequence_id': sequence, 'storage_revision': SCHEMA['storage_revision'],
+        'scripts': {p.name: sha256(p) for p in (out / 'script').glob('*.py')},
+        'runtime': {'torch': torch.__version__, 'ffmpeg': ffversion()},
+        'views': previous.get('views', {}) | reports})
+
+
+def check_view_type(meta):
+    # The pinned ARCTIC contract makes view_type optional; adapters still supply known views.
+    if 'view_type' not in meta:
+        return
+    if meta['view_type'] not in ('ego', 'exo', 'unknown'):
+        raise ValueError('view_type must be ego/exo/unknown')
+    expected = {'dex-ycb': 'exo', 'EPIC-KITCHENS-VISOR': 'ego', 'HOI4D': 'ego'}.get(meta['dataset_id'])
+    if meta['dataset_id'] == 'H2O':
+        expected = 'ego' if meta['camera_id'] == 'cam4' else 'exo' if meta['camera_id'] in ('cam0', 'cam1', 'cam2', 'cam3') else 'unknown'
+    if expected and meta['view_type'] not in (expected, 'unknown'):
+        raise ValueError('view_type contradicts known source capture setup')
+
+
+def check_valid_policy(component, count):
+    policy = component.get('valid_policy', {})
+    for field in ('revision', 'meaning', 'source_rule', 'source_locator', 'scope', 'numerical_checks',
+                  'official_qa', 'local_excluded_frame_indices', 'local_exclusion_reasons', 'visibility_independent'):
+        if field not in policy:
+            raise ValueError(f'valid_policy missing {field}')
+    if policy['revision'] != SCHEMA['validity_revision'] or policy['meaning'] != SCHEMA['annotation_validity']['meaning']:
+        raise ValueError('outdated annotation validity semantics')
+    if not policy['source_rule'] or not policy['numerical_checks'] or policy['scope'] != component['valid_axes']:
+        raise ValueError('incomplete validity rule/scope')
+    if policy['official_qa'].get('status') != 'not_provided' or not policy['official_qa'].get('reason'):
+        raise ValueError('official QA requires a verified adapter; supervision acceptance paused')
+    excluded = policy['local_excluded_frame_indices']
+    if any(type(i) is not int or not 0 <= i < count for i in excluded):
+        raise ValueError('invalid local exclusion frame index')
+    if excluded:
+        raise ValueError('local exclusions require a reviewed rule/report; not supported by these adapters')
+    if policy['visibility_independent'] is not True:
+        raise ValueError('visibility must remain independent of validity')
+
+
+def validate_view(path):
+    """Validate the persisted contract, not a rendering of the source labels."""
+    path = Path(path)
+    meta = json.loads((path / 'metainfo.json').read_text())
+    n = meta['num_frames']
+    check_view_type(meta)
+    if meta['schema_version'] != SCHEMA['schema_version'] or meta['hand_slots'] != ['left', 'right'] or n < 1:
+        raise ValueError('invalid view header')
+    def resolve(ref):
+        if Path(ref).is_absolute() or '\\' in ref:
+            raise ValueError('component reference must be relative POSIX')
+        dest = safe_member(path, ref)
+        if not dest.is_file():
+            raise ValueError(f'referenced file missing: {ref}')
+        return dest
+    def tensor(ref):
+        def cpu_storage(storage, location):
+            if location != 'cpu':
+                raise ValueError('PT storage must be on CPU')
+            return storage
+        value = torch.load(resolve(ref), map_location=cpu_storage, weights_only=True)
+        if not isinstance(value, torch.Tensor) or value.device.type != 'cpu':
+            raise ValueError('PT must contain only a CPU Tensor')
+        return value.numpy()
+    frames = [json.loads(line) for line in resolve(meta['sampling']['frames_ref']).read_text().splitlines()]
+    if len(frames) != n or [f['frame_index'] for f in frames] != list(range(n)):
+        raise ValueError('frame index/count mismatch')
+    for f in frames:
+        if not all(k in f for k in ('source_frame_id', 'timestamp_ns', 'clock_domain', 'source_locator')):
+            raise ValueError('incomplete frame provenance')
+    entities = {'hand_left', 'hand_right'}
+    parts = {}
+    for p in (path / 'annotation/object').glob('*/metainfo.json'):
+        obj = json.loads(p.read_text())
+        if obj['object_id'] != p.parent.name or obj['identity_scope'] not in ('frame', 'subsequence', 'sequence'):
+            raise ValueError('invalid object identity')
+        entities.add(obj['object_id'])
+        if obj.get('mesh_ref'):
+            if not resolve(obj['mesh_ref']).is_relative_to(p.parent.resolve()):
+                raise ValueError('mesh must belong to its object')
+        if obj.get('articulation_ref'):
+            art = json.loads(resolve(obj['articulation_ref']).read_text())
+            part_ids = {part['part_id'] for part in art['parts']}
+            if len(part_ids) != len(art['parts']):
+                raise ValueError('duplicate part ID')
+            parents = {part['part_id']: part['parent_id'] for part in art['parts']}
+            for part_id in parents:
+                visited, cur = set(), part_id
+                while cur is not None:
+                    if cur in visited or cur not in parents:
+                        raise ValueError('invalid or cyclic part hierarchy')
+                    visited.add(cur)
+                    cur = parents[cur]
+            parts[obj['object_id']] = part_ids
+    video_stats = {}
+    for key, component in meta['components'].items():
+        if not component.get('available'):
+            if not component.get('reason'):
+                raise ValueError('unavailable component needs a reason')
+            continue
+        schema = SCHEMA['components'][component['schema_id']]
+        for required in ('axes', 'provenance', 'source_locator'):
+            if required not in component:
+                raise ValueError(f'{key}: {required} missing')
+        for required in schema.get('required_metadata', []):
+            if required not in component:
+                raise ValueError(f'{key}: {required} missing')
+        if component['provenance']['kind'] == 'derived':
+            raise ValueError('v1.0 must not synthesize annotations')
+        if component['data_ref'].startswith('annotation/') and schema.get('valid_shape'):
+            if not component.get('valid_ref') or not component.get('valid_axes'):
+                raise ValueError(f'{key}: annotation validity reference/axes missing')
+            check_valid_policy(component, n)
+        data_path = resolve(component['data_ref'])
+        valid = tensor(component['valid_ref']) if component.get('valid_ref', '').endswith('.pt') else None
+        valid_shape = schema.get('valid_shape')
+        if valid is not None and valid_shape and (len(valid_shape) != valid.ndim or any(
+                isinstance(s, int) and valid.shape[i] != s for i, s in enumerate(valid_shape))):
+            raise ValueError(f'{key}: validity schema shape mismatch')
+        if valid is not None and (valid.dtype != bool or valid.shape[0] != n):
+            raise ValueError(f'{key}: invalid validity tensor')
+        if component['schema_id'] == 'mesh/obj/v1':
+            objroot = next((parent for parent in data_path.parents if parent.parent.name == 'object'), None)
+            if objroot is None:
+                raise ValueError('mesh must be owned by an object')
+            check_mesh(data_path, objroot)
+        if data_path.suffix == '.pt':
+            arr = tensor(component['data_ref'])
+            if arr.dtype != np.float32 or arr.shape[0] != n:
+                raise ValueError(f'{key}: float dtype or timeline mismatch')
+            shape = schema.get('shape')
+            if shape and (len(shape) != arr.ndim or any(isinstance(s, int) and arr.shape[i] != s for i, s in enumerate(shape))):
+                raise ValueError(f'{key}: schema shape mismatch')
+            if valid is not None:
+                if arr.shape[:valid.ndim] != valid.shape or not np.isfinite(arr[valid]).all() or not np.isnan(arr[~valid]).all():
+                    raise ValueError(f'{key}: invalid finite/NaN/validity values')
+                if component['schema_id'] in ('object/rigid/v1', 'transform/se3/v1'):
+                    check_transform(arr[valid])
+        if data_path.suffix == '.mkv':
+            cfg = component['storage']
+            if cfg['profile'] not in SCHEMA['storage_profiles']:
+                raise ValueError('unregistered video profile')
+            for field in SCHEMA['video_metadata']['required']:
+                if field not in cfg:
+                    raise ValueError('video storage declaration incomplete')
+            w, h = meta['camera']['image_size']
+            if cfg['encoded_size'] != [w * (2 if key == 'depth' else 1), h]:
+                raise ValueError('encoded raster differs from logical RGB grid')
+            actual = probe(data_path)
+            if (actual['codec_name'] != cfg['codec'] or actual['pix_fmt'] != cfg['pixel_format'] or
+                    [actual['width'], actual['height']] != cfg['encoded_size']):
+                raise ValueError('video storage metadata differs from file')
+            if key == 'rgb':
+                fmt, bpp = 'rgb24', 3
+            else:
+                fmt, bpp = 'gray16le', 2
+            digest, size, _ = decoded_digest(data_path, fmt)
+            w, h = cfg['encoded_size']
+            if size != n * w * h * bpp:
+                raise ValueError('raster timeline mismatch')
+            video_stats[key] = {'decoded_sha256': digest, 'frames': n}
+            if key == 'depth':
+                validity = component['valid_storage']
+                vp = resolve(component['valid_ref'])
+                actual_valid = probe(vp)
+                if (validity['profile'] != 'mkv/bool_ffv1/v1' or actual_valid['codec_name'] != 'ffv1'
+                        or actual_valid['pix_fmt'] != 'gray' or [actual_valid['width'], actual_valid['height']] != [w // 2, h]):
+                    raise ValueError('invalid depth validity video')
+                count = 0
+                for encoded, mask in zip(video_frames(data_path, 'gray16le', (h, w), '<u2'),
+                        video_frames(vp, 'gray', (h, w // 2), np.uint8), strict=True):
+                    if not np.isin(mask, [0, 1]).all():
+                        raise ValueError('depth valid pixels must be 0 or 1')
+                    depth, good = unpack_depth(encoded), mask.astype(bool)
+                    if not (np.isfinite(depth[good]) & (depth[good] > 0)).all() or not np.isnan(depth[~good]).all():
+                        raise ValueError('invalid depth/validity semantics')
+                    count += 1
+                if count != n:
+                    raise ValueError('depth validity timeline mismatch')
+        if component['schema_id'].startswith('segment/') and component.get('mapping_ref'):
+            rows = [json.loads(line) for line in resolve(component['mapping_ref']).read_text().splitlines()]
+            if len(rows) != n or [row['frame_index'] for row in rows] != list(range(n)):
+                raise ValueError('segmentation mapping timeline mismatch')
+            for row in rows:
+                labels = row['labels']
+                if len({a['mask_value'] for a in labels}) != len(labels):
+                    raise ValueError('duplicate region mapping')
+                for label in labels:
+                    if label['entity_id'] is not None and label['entity_id'] not in entities:
+                        raise ValueError('unresolved segmentation entity')
+                    if label['part_id'] is not None and label['part_id'] not in parts.get(label['entity_id'], set()):
+                        raise ValueError('unresolved segmentation part')
+            if component['schema_id'] == 'segment/uint16_labels/v1':
+                width, height = meta['camera']['image_size']
+                for i, mask in enumerate(video_frames(data_path, 'gray16le', (height, width), '<u2')):
+                    codes = set(np.unique(mask).tolist()) - {0, 65535}
+                    mapped = {label['mask_value'] for label in rows[i]['labels']} - {0, 65535}
+                    if codes != mapped or not valid[i] and codes:
+                        raise ValueError('mask values differ from declared instances/validity')
+            if component['schema_id'] == 'segment/instance_polygons/v1':
+                polygons = [json.loads(line) for line in data_path.read_text().splitlines()]
+                if len(polygons) != n:
+                    raise ValueError('polygon timeline mismatch')
+                for i, row in enumerate(polygons):
+                    if row['frame_index'] != i or {x['mask_value'] for x in row['instances']} != {x['mask_value'] for x in rows[i]['labels']}:
+                        raise ValueError('polygon/mapping mismatch')
+        if component['schema_id'] == 'contact/relations/v1':
+            rows = [json.loads(line) for line in data_path.read_text().splitlines()]
+            if len(rows) != n:
+                raise ValueError('relation timeline mismatch')
+            for i, row in enumerate(rows):
+                if row['frame_index'] != i or not valid[i] and row['relations']:
+                    raise ValueError('relation validity mismatch')
+                for relation in row['relations']:
+                    if relation['subject_id'] not in entities or relation['status'] not in ('positive', 'negative', 'unknown', 'target_unannotated'):
+                        raise ValueError('invalid relation')
+                    if relation['status'] == 'positive' and relation['object_id'] not in entities:
+                        raise ValueError('unresolved positive contact')
+    return {'view': str(path), 'num_frames': n, 'videos': video_stats, 'validated': True}

H2O/shared-v1.1/script/v1_0_snapshot/script/render_dexycb_validation.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Audit a finished Dex-YCB release and render persisted modalities for manual review."""
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+import sys
+
+from render_hoi4d_validation import render
+
+
+def inspect(root):
+    data, doc, scripts = root / 'data', root / 'doc', root / 'script'
+    sequences = sorted(p for p in data.iterdir() if p.is_dir())
+    assert len(sequences) == 1000, f'expected 1000 sequences, got {len(sequences)}'
+    assert len(list(doc.glob('*.build.json'))) == 1000
+    assert not list(data.glob('*.tmp-*')), 'unfinished temporary sequences'
+    config = json.loads((scripts / 'config.json').read_text())
+    assert all(config.get(k) is None for k in ('limit', 'max_frames', 'subjects', 'views'))
+    hashes = {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in scripts.glob('*.py')}
+    subjects, splits, availability = Counter(), Counter(), Counter()
+    selected = []
+    for seq in sequences:
+        views = sorted(p for p in seq.iterdir() if p.is_dir())
+        assert len(views) == 8, (seq, len(views))
+        build = json.loads((doc / (seq.name + '.build.json')).read_text())
+        assert set(build['views']) == {p.name for p in views}, seq
+        assert all(hashes.get(k) == v for k, v in build['scripts'].items()), seq
+        subject = seq.name.split('_')[0]
+        subjects[subject] += 1
+        if subjects[subject] == 1:
+            selected.append(views[0])
+            if subject.endswith('subject-09'):
+                selected.append(views[-1])  # one more camera, different camera
+        if seq.name == '20201015-subject-09_20201015_150838':
+            selected.append(views[0])  # source-labelled left-hand sequence
+        for view in views:
+            meta = json.loads((view / 'metainfo.json').read_text())
+            assert meta['sequence_id'] == seq.name and meta['camera_id'] == view.name, view
+            assert meta['dataset_id'] == 'dex-ycb' and meta['release_id'] == 'shared-v1.0', view
+            assert meta['num_frames'] > 0 and meta.get('view_type') == 'exo', view
+            assert (view / 'camera/frames.jsonl').is_file(), view
+            assert meta['components']['rgb']['available'], view
+            splits[meta['split']] += 1
+            for key, part in meta['components'].items():
+                if part.get('available'):
+                    availability[key] += 1
+                    for ref in ('data_ref', 'valid_ref'):
+                        if part.get(ref):
+                            assert (view / part[ref]).is_file(), (view, key, ref)
+    assert len(subjects) == 10 and set(subjects.values()) == {100}, subjects
+    assert availability['depth'] == availability['rgb'] == 8000, availability
+    report = dict(sequences=len(sequences), views=sum(splits.values()), subjects=dict(subjects),
+                  splits=dict(splits), available_views=dict(availability), config=config,
+                  published_script_sha256=hashes, sampled_views=[str(v.relative_to(root)) for v in selected],
+                  scope='Structure and file refs checked for all views; persisted QC and HTML only for sampled views. No manual visual approval yet.')
+    destination = doc / 'validation'
+    destination.mkdir(exist_ok=True)
+    (destination / 'STRUCTURAL_AUDIT.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
+    for view in selected:
+        render(view, destination)
+    return report
+
+
+if __name__ == '__main__':
+    print(json.dumps(inspect(Path(sys.argv[1]).expanduser().resolve()), ensure_ascii=False), flush=True)

H2O/shared-v1.1/script/v1_0_snapshot/script/render_h2o_validation.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Render stored H2O RGB-D, native camera-space hands/objects, and OBJ assets for review."""
+import argparse
+import html
+import json
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw
+import torch
+
+from render_hoi4d_validation import mesh_preview, picture, snapshot
+from warehouse_v1_0 import unpack_depth, validate_view
+
+
+def load(view, item, n):
+    if not item.get('available') or not item.get('data_ref', '').endswith('.pt'):
+        return None, None
+    values = torch.load(view / item['data_ref'], map_location='cpu', weights_only=True).numpy()
+    valid = torch.load(view / item['valid_ref'], map_location='cpu', weights_only=True).numpy() if item.get('valid_ref') else None
+    return (values, valid) if values.ndim and values.shape[0] == n else (None, None)
+
+
+def render(view, destination):
+    meta = json.loads((view / 'metainfo.json').read_text())
+    if meta['dataset_id'] != 'H2O':
+        raise ValueError('H2O view required')
+    n = meta['num_frames']
+    height, width = reversed(meta['camera']['image_size'])
+    parts = meta['components']
+    frames = [json.loads(line) for line in (view / 'camera/frames.jsonl').read_text().splitlines()]
+    assert len(frames) == n
+    selected = {0, n // 4, n // 2, 3 * n // 4, n - 1}
+    numeric = {}
+    for name, item in parts.items():
+        if item.get('data_ref', '').endswith('.pt') and item.get('available'):
+            values, valid = load(view, item, n)
+            if values is not None:
+                numeric[name] = (values, valid)
+                if valid is not None:
+                    indices = np.flatnonzero(valid.reshape(n, -1).any(axis=1))
+                    if len(indices):
+                        selected.add(int(indices[0]))
+    selected = set(sorted(selected)[:12]) | {n - 1}
+    rgb = snapshot(view / parts['rgb']['data_ref'], 'rgb24', (height, width, 3), np.uint8, selected)
+    depth = snapshot(view / parts['depth']['data_ref'], 'gray16le', (height, 2 * width), '<u2', selected) if parts.get('depth', {}).get('available') else {}
+    intrinsic = numeric.get('intrinsic', (None, None))[0]
+    pages = []
+    for i in sorted(selected):
+        photo = Image.fromarray(rgb[i])
+        legend = []
+        if intrinsic is not None:
+            draw = ImageDraw.Draw(photo)
+            for name, (points, valid) in numeric.items():
+                if name != 'keypoints_xyz' and not name.startswith('points_'):
+                    continue
+                color = '#00e6ff' if name == 'keypoints_xyz' else '#ff48a4'
+                for slot, row in enumerate(points[i] if points.ndim == 4 else [points[i]]):
+                    mask = valid[i, slot] if points.ndim == 4 else valid[i]
+                    for xyz, good in zip(row, mask, strict=True):
+                        if good and np.isfinite(xyz).all() and xyz[2] > 0:
+                            u, v = intrinsic[i, 0, 0] * xyz[0] / xyz[2] + intrinsic[i, 0, 2], intrinsic[i, 1, 1] * xyz[1] / xyz[2] + intrinsic[i, 1, 2]
+                            if 0 <= u < width and 0 <= v < height:
+                                draw.ellipse((u-4, v-4, u+4, v+4), fill=color)
+                legend.append(name + ' ' + color)
+        panels = ['<figure>' + picture(photo) + '<figcaption>RGB + 原生 3D 关键点投影（仅预览：' + html.escape(', '.join(legend) or '当前帧无可投影点') + '）</figcaption></figure>']
+        if i in depth:
+            z = unpack_depth(depth[i])
+            luminance = (np.clip(np.nan_to_num(z, nan=0), 0, 3) * 85).astype(np.uint8)
+            panels.append('<figure>' + picture(Image.fromarray(luminance)) + '<figcaption>深度 Z，黑=无效，白≥3 m；不改源深度</figcaption></figure>')
+        details = {'frame': frames[i]}
+        for name, (values, valid) in numeric.items():
+            details[name] = {'value': values[i].tolist(), 'valid': None if valid is None else valid[i].tolist()}
+        pages.append('<section><h2>帧 ' + str(i) + ' / ' + str(n) + '</h2><div class="panels">' + ''.join(panels) + '</div><details><summary>原帧号、全部数值标注及有效性</summary><pre>' + html.escape(json.dumps(details, ensure_ascii=False, indent=2)) + '</pre></details></section>')
+    assets = []
+    for name, item in parts.items():
+        if item.get('available') and item.get('data_ref', '').lower().endswith('.obj'):
+            assets.append('<figure><h3>' + html.escape(name) + '</h3>' + mesh_preview(view / item['data_ref']) + '<figcaption>源 OBJ 静态预览，不代表物体姿态投影</figcaption></figure>')
+    report = validate_view(view)
+    destination.mkdir(parents=True, exist_ok=True)
+    title = view.parent.name + '_' + view.name
+    style = 'body{font:16px sans-serif;max-width:1500px;margin:auto;padding:1rem;background:#f5f7fa;color:#18232f}section,details{background:white;padding:1rem;margin:1rem 0;border-radius:8px}.panels{display:flex;flex-wrap:wrap}img{max-width:100%}pre{white-space:pre-wrap;overflow:auto;font-size:12px}'
+    page = '<!doctype html><html lang="zh"><meta charset="utf-8"><title>' + html.escape(title) + '</title><style>' + style + '</style><h1>' + html.escape(title) + '</h1><p>预览只作人工核查；仅显示真实存在的标注，不合成分割。</p>' + ''.join(pages) + '<h2>源网格</h2><div class="panels">' + ''.join(assets) + '</div><details><summary>全部组件元数据</summary><pre>' + html.escape(json.dumps(meta, ensure_ascii=False, indent=2)) + '</pre></details><details><summary>持久化 QC</summary><pre>' + html.escape(json.dumps(report, ensure_ascii=False, indent=2)) + '</pre></details></html>'
+    (destination / (title + '.html')).write_text(page)
+    (destination / (title + '.report.json')).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
+    links = sorted(p.name for p in destination.glob('*.html') if p.name != 'index.html')
+    (destination / 'index.html').write_text('<!doctype html><html lang="zh"><meta charset="utf-8"><h1>H2O 试点预览</h1><ul>' + ''.join('<li><a href="' + html.escape(x, quote=True) + '">' + html.escape(x) + '</a></li>' for x in links) + '</ul></html>')
+    return destination / (title + '.html')
+
+
+if __name__ == '__main__':
+    p = argparse.ArgumentParser()
+    p.add_argument('views', nargs='+', type=Path)
+    p.add_argument('--out', type=Path, required=True)
+    args = p.parse_args()
+    for view in args.views:
+        print(render(view, args.out), flush=True)

H2O/shared-v1.1/script/v1_0_snapshot/script/render_hoi4d_source_review.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Evidence-only HTML: native HOI4D pose boxes over persisted RGB and native masks."""
+import argparse
+import html
+import json
+from pathlib import Path
+import shutil
+import zipfile
+
+import numpy as np
+from PIL import Image, ImageDraw
+
+from render_hoi4d_validation import picture, snapshot
+
+
+def source_parts(view):
+    rows = []
+    for source in view.glob('annotation/object/*/assets/result.json'):
+        def visit(node):
+            if isinstance(node, list):
+                for child in node:
+                    visit(child)
+                return
+            if node.get('objs'):
+                rows.append({'source_part_id': node['id'], 'source_part_name': node['name'],
+                             'source_meshes': node['objs'], 'source_locator': str(source.relative_to(view))})
+            for child in node.get('children', []):
+                visit(child)
+        visit(json.loads(source.read_text()))
+    return rows
+
+
+def render(view, z, output):
+    output.mkdir(parents=True, exist_ok=True)
+    meta = json.loads((view / 'metainfo.json').read_text())
+    seq = meta['sampling']['selection']['source_sequence']
+    w, h = meta['camera']['image_size']
+    chosen = sorted({0, meta['num_frames'] // 2, meta['num_frames'] - 1})
+    frames = [json.loads(line) for line in (view / 'camera/frames.jsonl').read_text().splitlines()]
+    rgb = snapshot(view / meta['components']['rgb']['data_ref'], 'rgb24', (h, w, 3), np.uint8, chosen)
+    segment = meta['components'].get('segment', {})
+    masks = (snapshot(view / segment['data_ref'], 'gray16le', (h, w), '<u2', chosen)
+             if segment.get('available') else {})
+    rows = [json.loads(line) for line in (view / 'annotation/segment/instances.jsonl').read_text().splitlines()]
+    source = f'HOI4D_annotations/{seq}/objpose/'
+    pose_files = {int(Path(name).stem): name for name in z.namelist()
+                  if name.startswith(source) and name.endswith('.json')}
+    panels = []
+    for index in chosen:
+        native_id = frames[index]['source_frame_id']
+        arr = rgb[index].copy()
+        mask = masks.get(index)
+        if mask is not None:
+            tint = np.zeros_like(arr)
+            for code in np.unique(mask):
+                if code not in (0, 65535):
+                    tint[mask == code] = ((int(code) * 89) % 240 + 15,
+                                          (int(code) * 61) % 240 + 15, (int(code) * 131) % 240 + 15)
+            affected = (mask != 0) & (mask != 65535)
+            arr[affected] = ((arr[affected].astype(np.uint16) * 3 + tint[affected]) // 4).astype(np.uint8)
+        image = Image.fromarray(arr)
+        draw = ImageDraw.Draw(image)
+        native = json.loads(z.read(pose_files[native_id])) if native_id in pose_files else {}
+        for source_index, record in enumerate(native.get('dataList', native.get('objects', []))):
+            box = record.get('2dBox', {}).get('camera1') or []
+            if len(box) == 2 and all(len(point) == 2 for point in box):
+                x0, y0 = box[0]
+                x1, y1 = box[1]
+                draw.rectangle((x0, y0, x1, y1), outline='#ffff00', width=4)
+                draw.text((x0, max(0, y0 - 16)), f"source[{source_index}] id={record.get('id')} {record.get('label')}", fill='#ffff00', stroke_width=2, stroke_fill='#000000')
+        mask_row = rows[index]['labels'] if segment.get('available') else []
+        note = {'source_frame_id': native_id, 'native_pose_records': [
+            {k: r.get(k) for k in ('id', 'label', '2dBox')} for r in native.get('dataList', native.get('objects', []))],
+            'native_mask_codes': mask_row}
+        panels.append('<section><h2>' + html.escape(seq) + f' / frame {native_id}</h2>' + picture(image)
+                      + '<p>仅验收：伪彩=原生分割码，黄框=上游 2dBox；颜色和框不写回 shared，空间重叠不能代替身份依据。</p>'
+                      + '<details><summary>上游原记录与编码对照</summary><pre>'
+                      + html.escape(json.dumps(note, ensure_ascii=False, indent=2)) + '</pre></details></section>')
+    parts = source_parts(view)
+    name = view.parent.name + '_' + view.name + '.html'
+    page = '<!doctype html><html lang="zh"><meta charset="utf-8"><title>HOI4D source correspondence review</title><style>body{font:16px sans-serif;max-width:1100px;margin:auto;background:#f6f7fa}section{background:white;padding:1em;margin:1em}img{max-width:100%}pre{white-space:pre-wrap;overflow:auto}</style><h1>源姿态／原生分割／RGB 的证据图（非真值修改）</h1>'
+    page += ''.join(panels) + '<details><summary>CAD result.json 原生部件→OBJ；不等同逐帧姿态对应</summary><pre>'
+    page += html.escape(json.dumps(parts, ensure_ascii=False, indent=2)) + '</pre></details></html>'
+    (output / name).write_text(page)
+    print(name, 'native_part_links',len(parts),flush=True)
+    return name
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('--raw-root', type=Path, required=True)
+    p.add_argument('--release', type=Path, required=True)
+    p.add_argument('--out', type=Path, required=True)
+    args = p.parse_args(argv)
+    args.out.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(args.raw_root / 'HOI4D_annotations.zip') as z:
+        names = []
+        for view in sorted((args.release / 'data').glob('*/ego')):
+            if any('/C' + category + '/' in json.loads((view / 'metainfo.json').read_text())['sampling']['selection']['source_sequence']
+                   for category in ('2', '3', '14', '17')):
+                names.append(render(view, z, args.out))
+    links = ''.join(f'<li><a href="{html.escape(name, quote=True)}">{html.escape(name)}</a></li>' for name in names)
+    (args.out / 'index.html').write_text('<!doctype html><html lang="zh"><meta charset="utf-8"><h1>源依据对照（非物体几何验收通过）</h1><ul>' + links + '</ul></html>')
+    shutil.copyfile(Path(__file__), args.out / 'renderer.py')
+
+
+if __name__ == '__main__':
+    main()

H2O/shared-v1.1/script/v1_0_snapshot/script/render_hoi4d_validation.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Standalone, offline HTML review of every persisted component in selected views."""
+import argparse
+import base64
+import html
+import io
+import json
+import random
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw
+import torch
+
+from warehouse_v1_0 import video_frames, unpack_depth, validate_view
+
+
+def snapshot(video, fmt, shape, dtype, indices):
+    return {i: frame.copy() for i, frame in enumerate(video_frames(video, fmt, shape, dtype)) if i in indices}
+
+
+def picture(image):
+    image.thumbnail((800, 450))  # Previews only; released tensors and videos are not resized.
+    output = io.BytesIO()
+    image.save(output, format='PNG')
+    return '<img loading="lazy" src="data:image/png;base64,' + base64.b64encode(output.getvalue()).decode() + '">'
+
+
+def preview_color(value, dataset_id):
+    # Dex-YCB reserves 255 for the native hand mask. The old mod-240 palette
+    # gave it the same color as YCB object 15; keep data codes untouched.
+    if dataset_id == 'dex-ycb' and value == 255:
+        return (255, 32, 64)
+    return tuple((value * factor) % 240 + 15 for factor in (89, 61, 131))
+
+
+def mesh_preview(path):
+    """Project the whole source asset; bound drawing cost without favoring early faces."""
+    vertices, faces, referenced = [], [], set()
+    rng = random.Random(0)
+    face_count = 0
+    with path.open(errors='replace') as stream:
+        for line in stream:
+            if line.startswith('v '):
+                vertices.append([float(v) for v in line.split()[1:4]])
+            elif line.startswith('f '):
+                face = []
+                for token in line.split()[1:]:
+                    index = int(token.split('/')[0])
+                    face.append(index - 1 if index > 0 else len(vertices) + index)
+                if len(face) < 3:
+                    continue
+                referenced.update(face)
+                face_count += 1
+                # ponytail: bounded static preview; use a full OBJ viewer if 5000 faces miss fine detail.
+                if len(faces) < 5000:
+                    faces.append(face)
+                else:
+                    pick = rng.randrange(face_count)
+                    if pick < len(faces):
+                        faces[pick] = face
+    if not vertices or not faces:
+        return 'OBJ 未提供可绘制的顶点/面'
+    if min(referenced) < 0 or max(referenced) >= len(vertices):
+        raise ValueError(f'invalid OBJ face index: {path}')
+    xyz = np.asarray(vertices, dtype=np.float64)
+    if not np.isfinite(xyz).all():
+        raise ValueError(f'nonfinite OBJ vertex: {path}')
+    # Fixed orthonormal isometric basis: geometry only, not an inferred camera pose.
+    projected = np.column_stack(((xyz[:, 0] - xyz[:, 2]) / np.sqrt(2),
+        (xyz[:, 0] + xyz[:, 2] - 2 * xyz[:, 1]) / np.sqrt(6)))
+    used = projected[np.fromiter(referenced, dtype=np.int64)]
+    lo, hi = used.min(axis=0), used.max(axis=0)
+    extent = (hi - lo).max()
+    if extent <= 0:
+        return 'OBJ 所有面投影到同一点'
+    projected = (projected - (lo + hi) / 2) * (380 / extent) + 215
+    image = Image.new('RGB', (430, 430), 'white')
+    draw = ImageDraw.Draw(image)
+    for face in faces:
+        polygon = [tuple(projected[i]) for i in face]
+        draw.line(polygon + [polygon[0]], fill='#205caa', width=1)
+    return picture(image)
+
+
+def render(view, destination):
+    meta = json.loads((view / 'metainfo.json').read_text())
+    n = meta['num_frames']
+    width, height = meta['camera']['image_size']
+    components = meta['components']
+    frames = [json.loads(line) for line in (view / 'camera/frames.jsonl').read_text().splitlines()]
+    assert len(frames) == n
+    selected = {0, n // 4, n // 2, 3 * n // 4, n - 1}
+    for item in components.values():
+        ref = item.get('valid_ref', '')
+        if ref.endswith('.pt'):
+            valid = torch.load(view / ref, map_location='cpu', weights_only=True).numpy()
+            if valid.shape[0] == n:
+                matching = np.flatnonzero(valid.reshape(n, -1).any(axis=1))
+                if len(matching):
+                    selected.add(int(matching[0]))
+    selected = set(sorted(selected)[:12]) | {n - 1}
+    rgb = snapshot(view / components['rgb']['data_ref'], 'rgb24', (height, width, 3), np.uint8, selected)
+    depth = (snapshot(view / components['depth']['data_ref'], 'gray16le', (height, 2 * width), '<u2', selected)
+             if components.get('depth', {}).get('available') else {})
+    masks = (snapshot(view / components['segment']['data_ref'], 'gray16le', (height, width), '<u2', selected)
+             if components.get('segment', {}).get('available') else {})
+    labels = {}
+    mapping = view / 'annotation/segment/instances.jsonl'
+    if mapping.exists():
+        labels = {row['frame_index']: row['labels'] for row in map(json.loads, mapping.read_text().splitlines()) if row['frame_index'] in selected}
+    uv = components.get('keypoints_uv', {})
+    uv_points = torch.load(view / uv['data_ref'], map_location='cpu', weights_only=True).numpy() if uv.get('available') else None
+    uv_valid = torch.load(view / uv['valid_ref'], map_location='cpu', weights_only=True).numpy() if uv.get('available') else None
+    sections = []
+    for i in sorted(selected):
+        image = Image.fromarray(rgb[i])
+        if uv_points is not None:
+            draw = ImageDraw.Draw(image)
+            for slot, color in enumerate(('#00ffff', '#ff9922')):
+                for (x, y), valid in zip(uv_points[i, slot], uv_valid[i, slot], strict=True):
+                    if valid and np.isfinite([x, y]).all():
+                        draw.ellipse((x - 3, y - 3, x + 3, y + 3), fill=color)
+        panels = ['<figure>' + picture(image) + '<figcaption>RGB + 原生 2D 手关键点（若有）</figcaption></figure>']
+        if i in depth:
+            z = unpack_depth(depth[i])
+            luminance = (np.clip(np.nan_to_num(z, nan=0), 0, 3) * 85).astype(np.uint8)
+            panels.append('<figure>' + picture(Image.fromarray(luminance)) + '<figcaption>深度 Z（黑=无效，白≥3 m；仅预览）</figcaption></figure>')
+        if i in masks:
+            mask = masks[i]
+            colors = np.zeros((*mask.shape, 3), dtype=np.uint8)
+            for value in np.unique(mask):
+                if value not in (0, 65535):
+                    colors[mask == value] = preview_color(int(value), meta['dataset_id'])
+            legend = '；'.join(f'{int(value)}=' + ('手' if value == 255 and meta['dataset_id'] == 'dex-ycb' else '物体' if meta['dataset_id'] == 'dex-ycb' else '区域') + f' #{bytes(preview_color(int(value), meta["dataset_id"])).hex()}' for value in np.unique(mask) if value not in (0, 65535))
+            panels.append('<figure>' + picture(Image.fromarray(colors)) + '<figcaption>原生分割整数编码的伪彩色预览（' + html.escape(legend) + '）</figcaption></figure>')
+            active = (mask != 0) & (mask != 65535)
+            overlay = rgb[i].copy()
+            overlay[active] = ((overlay[active].astype(np.uint16) + colors[active]) // 2).astype(np.uint8)
+            panels.append('<figure>' + picture(Image.fromarray(overlay)) + '<figcaption>原生分割叠加 RGB（仅预览）</figcaption></figure>')
+        details = {'frame': frames[i], 'segment_labels': labels.get(i, [])}
+        for name, component in components.items():
+            ref = component.get('data_ref', '')
+            if component.get('available') and ref.endswith('.pt'):
+                values = torch.load(view / ref, map_location='cpu', weights_only=True)
+                if values.ndim and values.shape[0] == n:
+                    details[name] = {'value': values[i].tolist()}
+                    if component.get('valid_ref', '').endswith('.pt'):
+                        valid = torch.load(view / component['valid_ref'], map_location='cpu', weights_only=True)
+                        details[name]['valid'] = valid[i].tolist()
+        sections.append('<section><h2>帧 ' + str(i) + ' / ' + str(n) + '</h2><div class="panels">' + ''.join(panels)
+                        + '</div><details><summary>帧号、来源、全部数值组件与有效性</summary><pre>'
+                        + html.escape(json.dumps(details, ensure_ascii=False, indent=2)) + '</pre></details></section>')
+    assets = []
+    for name, component in components.items():
+        if component.get('available') and component['data_ref'].lower().endswith('.obj'):
+            ref = component['data_ref']
+            assets.append('<figure><h3>' + html.escape(name) + '</h3>' + mesh_preview(view / ref)
+                          + '<figcaption>仅展示网格原生形状；未验证尺度／位姿对应。</figcaption></figure>')
+    result = validate_view(view)
+    destination.mkdir(parents=True, exist_ok=True)
+    title = view.parent.name + '_' + view.name
+    css = 'body{font:16px sans-serif;max-width:1500px;margin:auto;padding:1rem;background:#f5f7fa;color:#18232f}section,details{background:#fff;padding:1rem;margin:1rem 0;border-radius:8px}figure{margin:.5rem}figcaption{font-size:.85rem}.panels{display:flex;flex-wrap:wrap}img{max-width:100%;border:1px solid #ddd}pre{white-space:pre-wrap;overflow:auto;font-size:12px}'
+    page = '<!doctype html><html lang="zh"><meta charset="utf-8"><title>' + html.escape(title) + '</title><style>' + css + '</style><h1>' + html.escape(title) + '</h1><p>预览图仅供人工审核，不是训练输入；未提供的模态在 metainfo 中保留原因。</p>' + ''.join(sections) + '<h2>原始物体模型（独立预览）</h2><div class="panels">' + ''.join(assets) + '</div><details><summary>全部组件元信息及原始来源</summary><pre>' + html.escape(json.dumps(meta, ensure_ascii=False, indent=2)) + '</pre></details><details><summary>持久化 QC 结果</summary><pre>' + html.escape(json.dumps(result, ensure_ascii=False, indent=2)) + '</pre></details></html>'
+    (destination / (title + '.html')).write_text(page)
+    (destination / (title + '.report.json')).write_text(json.dumps(result, ensure_ascii=False, indent=2))
+    links = sorted(p.name for p in destination.glob('*.html') if p.name != 'index.html')
+    (destination / 'index.html').write_text('<!doctype html><html lang="zh"><meta charset="utf-8"><title>' + html.escape(meta['dataset_id']) + ' review</title><h1>' + html.escape(meta['dataset_id']) + ' 抽样人工审核</h1><p>选择视图；所有预览均来自已保存的 shared 数据。</p><ul>' + ''.join('<li><a href="' + html.escape(x, quote=True) + '">' + html.escape(x) + '</a></li>' for x in links) + '</ul></html>')
+    print(destination / (title + '.html'), 'selected_frames', sorted(selected), flush=True)
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('views', nargs='+', type=Path)
+    p.add_argument('--out', type=Path)
+    args = p.parse_args()
+    for view in args.views:
+        render(view, args.out or view.parents[2] / 'doc/validation')
+
+
+if __name__ == '__main__':
+    main()

H2O/shared-v1.1/script/v1_0_snapshot/script/run-full.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -u
+base="$HOME/Datasets/uni-hoi-h2o-full-20260930-process16-pipe"
+raw="$HOME/Datasets/Hand-Datasets-Raw/H2O"
+ram=/dev/shm/xuzhefeng-h2o-full-process16-20260930
+cd "$HOME/Projects/uni-hoi-dataset" || exit 1
+mkdir -p "$base/scratch" "$ram"
+export TMPDIR="$base/scratch" PYTHONUNBUFFERED=1
+test ! -e "$base/full.status" || exit 2
+printf 'START=%s\nARCHIVE_WORKERS=4 VIEW_WORKERS=16 VIEW_BACKEND=processes\nCODEC_THREADS=10 DECODE_THREADS=10 DEPTH_THREADS=4 FFV1_SLICES=16\nCAMERA_PIPELINE=true STREAM_MEDIA=true PNG_RAM_GIB=32\nCPU_TARGET_PERCENT=80 CPU_LIMIT=none\n' "$(date -Is)" > "$base/full.status"
+/usr/bin/time -v .venv/bin/python "$base/frozen-code/scripts/convert_h2o_v1.0.py" --root "$raw" --out "$base" --release-id shared-v1.0 --workers 4 --view-workers 16 --view-backend processes --camera-pipeline --stream-media --codec-threads 10 --decode-threads 10 --depth-threads 4 --ffv1-slices 16 --ram-stage-dir "$ram" --ram-stage-gib 32 --mano-dir "$HOME/Projects/WiLoR/mano_data" > "$base/full.log" 2>&1
+code=$?
+printf 'EXIT=%s END=%s\n' "$code" "$(date -Is)" >> "$base/full.status"
+exit "$code"

H2O/shared-v1.1/script/v1_0_snapshot/script/warehouse_v1_0.py

@@ -0,0 +1,1032 @@
+"""Shared I/O for CONTRACT.md v1.0. No annotation synthesis."""
+import argparse
+from contextlib import contextmanager
+from functools import lru_cache
+import hashlib
+import json
+import math
+import os
+import shlex
+from pathlib import Path
+import pickle
+import random
+import shutil
+import subprocess
+import tempfile
+import time
+
+import numpy as np
+from PIL import Image
+import torch
+
+SCHEMA_PATH = next(p for p in (Path(__file__).resolve().parents[1] / 'docs/schema.json',
+                               Path(__file__).resolve().parents[1] / 'doc/schema.json') if p.is_file())
+SCHEMA = json.loads(SCHEMA_PATH.read_text())
+RAW_ROOT = Path.home() / 'Datasets/Hand-Datasets-Raw'
+
+
+def json_write(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + '\n')
+
+
+def jsonl_write(path, rows):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open('w') as out:
+        for row in rows:
+            out.write(json.dumps(row, ensure_ascii=False, allow_nan=False) + '\n')
+
+
+def sha256(path):
+    with Path(path).open('rb') as f:
+        return hashlib.file_digest(f, 'sha256').hexdigest()
+
+
+def locator(path, member=None, data=None, **extra):
+    result = {'file': str(Path(path).resolve())}
+    if member is not None:
+        result['member'] = member
+    if data is not None:
+        result['sha256'] = hashlib.sha256(data).hexdigest()
+    return result | extra
+
+
+def source(method='Copy source annotation; normalize storage only'):
+    return {'kind': 'format_conversion', 'method': method}
+
+
+def run(args, **kwargs):
+    return subprocess.run(args, check=True, stderr=subprocess.PIPE, **kwargs)
+
+
+@lru_cache(maxsize=1)
+def ffversion():
+    return run(['ffmpeg', '-version'], stdout=subprocess.PIPE).stdout.decode().splitlines()[0]
+
+
+def probe(path):
+    return json.loads(run(['ffprobe', '-v', 'error', '-select_streams', 'v:0',
+                           '-show_streams', '-of', 'json', str(path)],
+                          stdout=subprocess.PIPE).stdout)['streams'][0]
+
+
+def decode_args(path, pixel_format):
+    threads = os.environ.get('HAND_WAREHOUSE_FFMPEG_THREADS', '1')
+    return ['ffmpeg', '-v', 'error', '-nostdin', '-filter_threads', threads, '-threads', threads, '-noautorotate',
+            '-i', str(path), '-map', '0:v:0', '-vsync', '0', '-threads', threads,
+            '-f', 'rawvideo', '-pix_fmt', pixel_format]
+
+
+def decoded_digest(path, pixel_format):
+    start = time.monotonic()
+    with tempfile.TemporaryFile() as err:
+        proc = subprocess.Popen(decode_args(path, pixel_format) + ['pipe:1'],
+                                stdout=subprocess.PIPE, stderr=err)
+        digest, size = hashlib.sha256(), 0
+        with proc.stdout:
+            while chunk := proc.stdout.read(1024 * 1024):
+                digest.update(chunk)
+                size += len(chunk)
+        if proc.wait():
+            err.seek(0)
+            raise RuntimeError(err.read().decode(errors='replace'))
+    return digest.hexdigest(), size, time.monotonic() - start
+
+
+def video_frames(path, pixel_format, shape, dtype):
+    frame_bytes = int(np.prod(shape)) * np.dtype(dtype).itemsize
+    with tempfile.TemporaryFile() as err:
+        proc = subprocess.Popen(decode_args(path, pixel_format) + ['pipe:1'], stdout=subprocess.PIPE, stderr=err)
+        completed = False
+        try:
+            while True:
+                data = proc.stdout.read(frame_bytes)
+                if not data:
+                    break
+                if len(data) != frame_bytes:
+                    raise ValueError('truncated decoded video frame')
+                yield np.frombuffer(data, dtype=dtype).reshape(shape)
+            if proc.wait():
+                err.seek(0)
+                raise ValueError(err.read().decode(errors='replace'))
+            completed = True
+        finally:
+            proc.stdout.close()
+            if not completed and proc.poll() is None:
+                proc.terminate()
+            proc.wait()
+
+
+def storage(path, profile, parameters, source_lossy):
+    info = probe(path)
+    if info['codec_name'] == 'h264':
+        frames = json.loads(run(['ffprobe', '-v', 'error', '-threads', '1', '-select_streams', 'v:0',
+            '-show_entries', 'frame=key_frame', '-of', 'json', str(path)], stdout=subprocess.PIPE).stdout)['frames']
+        parameters = parameters | {'keyframe_indices': [i for i, f in enumerate(frames) if f['key_frame']]}
+    return {'profile': profile, 'codec': info['codec_name'],
+            'pixel_format': info['pix_fmt'], 'encoded_size': [info['width'], info['height']],
+            'decoder': {'name': 'ffmpeg', 'version': ffversion(), 'autorotate': False,
+                        'color_space': info.get('color_space', 'unknown'),
+                        'color_range': info.get('color_range', 'unknown'),
+                        'color_primaries': info.get('color_primaries', 'unknown'),
+                        'color_transfer': info.get('color_transfer', 'unknown')},
+            'encoder_parameters': {'version': ffversion()} | parameters,
+            'source_lossy': source_lossy, 'storage_fps': 30, 'timebase_role': 'index_only'}
+
+
+def encode_raw(raw, target, width, height, pixel_format, profile, codec='ffv1', extra=(), threads=1):
+    start = time.monotonic()
+    slices = os.environ.get('HAND_WAREHOUSE_FFV1_SLICES')
+    if codec == 'ffv1' and slices:
+        if slices != '16':
+            raise ValueError('only the verified FFV1 16-slice profile is enabled')
+        extra = (*extra, '-level', '3', '-slices', slices)
+    command = ['ffmpeg', '-v', 'error', '-nostdin', '-filter_threads',
+               os.environ.get('HAND_WAREHOUSE_FFMPEG_THREADS', '1'), '-y', '-f', 'rawvideo',
+               '-pixel_format', pixel_format, '-video_size', f'{width}x{height}', '-framerate', '30',
+               '-i', str(raw) if isinstance(raw, Path) else 'pipe:0', '-an', '-c:v', codec,
+               '-threads', str(threads), *extra, str(target)]
+    if isinstance(raw, Path):
+        run(command)
+        expected_size, expected_hash = raw.stat().st_size, sha256(raw)
+    else:
+        with tempfile.TemporaryFile() as err:
+            proc = subprocess.Popen(command, stdin=subprocess.PIPE, stderr=err)
+            expected_size, checksum = 0, hashlib.sha256()
+            try:
+                for frame in raw:
+                    proc.stdin.write(frame)
+                    checksum.update(frame)
+                    expected_size += len(frame)
+                proc.stdin.close()
+                if proc.wait():
+                    err.seek(0)
+                    raise RuntimeError(err.read().decode(errors='replace'))
+            except BaseException:
+                if proc.poll() is None:
+                    proc.kill()
+                proc.stdin.close()
+                proc.wait()
+                raise
+        expected_hash = checksum.hexdigest()
+    digest, size, decode_seconds = decoded_digest(target, pixel_format)
+    if size != expected_size or digest != expected_hash:
+        raise ValueError(f'lossless roundtrip failed: {target}')
+    parameters = {'name': codec, 'arguments': list(extra)}
+    if threads != 1:
+        parameters['threads'] = threads
+    config = storage(target, profile, parameters, False)
+    return config, {'bytes': target.stat().st_size, 'encode_seconds': time.monotonic() - start - decode_seconds,
+                    'decode_seconds': decode_seconds, 'decoded_sha256': digest, 'all_frames_exact': True}
+
+
+def measure_rgb_access(video, raw, width, height, count, source_video=None, source_image=None):
+    index = count // 2
+    start = time.monotonic()
+    data = run(decode_args(video, 'rgb24') +
+               ['-vf', f'select=eq(n\\,{index})', '-frames:v', '1', 'pipe:1'],
+               stdout=subprocess.PIPE).stdout
+    if raw is None:
+        if source_image is not None:
+            expected = run(decode_args(source_image, 'rgb24') + ['-frames:v', '1', 'pipe:1'],
+                           stdout=subprocess.PIPE).stdout
+        elif source_video is not None:
+            expected = run(decode_args(source_video, 'rgb24') +
+                           ['-vf', f'select=eq(n\\,{index})', '-frames:v', '1', 'pipe:1'],
+                           stdout=subprocess.PIPE).stdout
+        else:
+            raise ValueError('source video/image required for streaming RGB access check')
+    else:
+        with raw.open('rb') as inp:
+            inp.seek(index * width * height * 3)
+            expected = inp.read(width * height * 3)
+    if len(expected) != width * height * 3 or data != expected:
+        raise ValueError('exact indexed RGB read failed')
+    return {'random_access_strategy': 'decode from first keyframe; select exact presentation index',
+            'random_frame_index': index, 'random_frame_read_seconds': time.monotonic() - start}
+
+
+def jpeg_sample_indices(sequence, camera, count):
+    seed = int.from_bytes(hashlib.sha256(f'{sequence}/{camera}/20260920'.encode()).digest()[:8], 'big')
+    indices = {0, count - 1, count // 4, count // 2, 3 * count // 4}
+    indices.update(random.Random(seed).sample([i for i in range(count) if i not in indices],
+                                            min(count, 16) - len(indices)))
+    return sorted(indices), seed
+
+
+def check_jpeg_copy(target, paths, hashes, size, sequence, camera, full):
+    packets = json.loads(run(['ffprobe', '-v', 'error', '-select_streams', 'v:0',
+        '-show_packets', '-show_data_hash', 'sha256', '-of', 'json', str(target)],
+        stdout=subprocess.PIPE).stdout)['packets']
+    if [p['data_hash'].split(':', 1)[1].lower() for p in packets] != hashes:
+        raise ValueError('JPEG packet hashes/order/count differ')
+    info = probe(target)
+    if [info['width'], info['height']] != list(size):
+        raise ValueError('JPEG container dimensions differ')
+    indices, seed = jpeg_sample_indices(sequence, camera, len(paths))
+    if full:
+        indices = list(range(len(paths)))
+    select = '+'.join(f'eq(n\\,{i})' for i in indices)
+    frame_bytes = size[0] * size[1] * 3
+    # Spool selected frames to disk, keeping RAM bounded for full-view audits.
+    with tempfile.TemporaryFile() as decoded:
+        run(decode_args(target, 'rgb24') + ([] if full else ['-vf', 'select=' + select]) + ['pipe:1'], stdout=decoded)
+        decoded.seek(0)
+        for i in indices:
+            expected = run(decode_args(paths[i], 'rgb24') + ['pipe:1'], stdout=subprocess.PIPE).stdout
+            if len(expected) != frame_bytes or decoded.read(frame_bytes) != expected:
+                raise ValueError(f'JPEG decoded pixels differ at frame {i}')
+        if decoded.read(1):
+            raise ValueError('JPEG selected pixel count differs')
+    return {'policy': 'jpeg-packets-all-rgb-sample16/v1', 'seed': seed,
+            'selected_frame_indices': indices, 'pixel_frames_checked': len(indices),
+            'packet_frames_checked': len(paths), 'jpeg_packets_exact': True,
+            'packet_count_order_dimensions_exact': True, 'sampled_pixels_exact': True,
+            'all_frames_exact': len(indices) == len(paths), 'full_view_audit': full}
+
+
+def rgb_video(paths, target, work, video=None, count=None, sequence="", camera="", full_jpeg=False,
+              ffv1_first=False, codec_threads=1, stream_source=False):
+    """JPEG packet proof plus deterministic pixels; re-encodings compare all pixels."""
+    target.parent.mkdir(parents=True, exist_ok=True)
+    raw = work / 'rgb.raw'
+    packets = []
+    has_missing = video is None and any(p is None for p in paths)
+    if has_missing:
+        present = next((p for p in paths if p is not None), None)
+        if present is None:
+            raise ValueError('no source RGB image to establish the pixel format/grid')
+        original = probe(present)
+        width, height = original['width'], original['height']
+        with raw.open('wb') as dest:
+            for path in paths:
+                if path is None:
+                    dest.write(bytes(width * height * 3))
+                else:
+                    with Image.open(path) as im:
+                        if im.mode != 'RGB' or im.size != (width, height):
+                            raise ValueError('source RGB grid/type changes within view')
+                    run(decode_args(path, 'rgb24') + ['pipe:1'], stdout=dest)
+        lossy, count = 'unknown', len(paths)
+        input_args = None
+    elif video is None:
+        if not paths:
+            raise ValueError('RGB timeline must contain existing source images')
+        suffix = paths[0].suffix.lower()
+        if suffix not in ('.jpg', '.jpeg', '.png'):
+            raise ValueError('unsupported source RGB format')
+        images = work / 'rgb_source'
+        images.mkdir()
+        dimensions = None
+        for i, path in enumerate(paths):
+            with Image.open(path) as im:
+                if im.mode != 'RGB' or (dimensions is not None and dimensions != im.size):
+                    raise ValueError('RGB must be homogeneous 8-bit RGB, with no silent color/size conversion')
+                dimensions = im.size
+                if im.format == 'PNG':
+                    with path.open('rb') as header:
+                        if header.read(25)[24] != 8:
+                            raise ValueError('high bit depth RGB needs a registered schema')
+            dest = images / f'{i:08d}{suffix}'
+            if stream_source and suffix == '.png':
+                try:
+                    os.link(path, dest)  # Immutable staging input; avoid a second PNG copy.
+                except OSError:
+                    # Temporary alias only: RAM/disk staging may be on different filesystems.
+                    os.symlink(path.resolve(), dest)
+            else:
+                shutil.copyfile(path, dest)
+            if suffix in ('.jpg', '.jpeg'):
+                packets.append(sha256(path))
+        width, height = dimensions
+        input_args = ['-framerate', '30', '-i', str(images / ('%08d' + suffix))]
+        count = len(paths)
+        original = probe(paths[0])
+        lossy = suffix in ('.jpg', '.jpeg')
+    else:
+        original = probe(video)
+        if int(original.get('bits_per_raw_sample') or 8) > 8 or any(
+                x in original.get('pix_fmt', '') for x in ('10', '12', '16', 'f32')):
+            raise ValueError('high bit depth RGB needs a registered schema')
+        width, height = original['width'], original['height']
+        input_args = ['-i', str(video)]
+        lossy = 'unknown'
+    limits = ['-frames:v', str(count)] if count else []
+    records = []
+    if video is None and not has_missing and suffix in ('.jpg', '.jpeg'):
+        start = time.monotonic()
+        try:
+            run(['ffmpeg', '-v', 'error', '-nostdin', '-y', *input_args, '-map', '0:v:0',
+                 *limits, '-c:v', 'copy', '-an', str(target)])
+            encode_seconds = time.monotonic() - start
+            validation = check_jpeg_copy(target, paths, packets, (width, height), sequence, camera, full_jpeg)
+            cfg = storage(target, 'mkv/mjpeg_copy/v1', {'stream_copy': True}, lossy)
+            cfg['decoder']['source_color_metadata'] = {k: original.get(k, 'unknown') for k in
+                ('color_space', 'color_range', 'color_primaries', 'color_transfer')}
+            records.append(validation | {'profile': cfg['profile'], 'bytes': target.stat().st_size,
+                'encode_seconds': encode_seconds, 'validation_seconds': time.monotonic() - start - encode_seconds})
+            return cfg, [width, height], records, count
+        except (subprocess.CalledProcessError, ValueError) as exc:
+            records.append({'profile': 'mkv/mjpeg_copy/v1', 'rejected': str(exc)})
+            target.unlink(missing_ok=True)
+    stream_images = stream_source and video is None and not has_missing and suffix == '.png'
+    if stream_images:
+        source_size, expected_hash = count * width * height * 3, None
+    elif stream_source and video is not None:
+        expected_hash, source_size, source_seconds = decoded_digest(video, 'rgb24', count)
+    else:
+        if not has_missing:
+            threads = os.environ.get('HAND_WAREHOUSE_FFMPEG_THREADS', '1')
+            run(['ffmpeg', '-v', 'error', '-nostdin', '-y', '-threads', threads, '-noautorotate',
+                 *input_args, '-map', '0:v:0', *limits, '-vsync', '0', '-threads', threads,
+                 '-f', 'rawvideo', '-pix_fmt', 'rgb24', str(raw)])
+        source_size, expected_hash = raw.stat().st_size, sha256(raw)
+    frame_bytes = width * height * 3
+    actual, remainder = divmod(source_size, frame_bytes)
+    if remainder or not actual or (count is not None and actual != count):
+        raise ValueError('source RGB frame count mismatch')
+    can_copy = video is not None
+    if can_copy:
+        start = time.monotonic()
+        try:
+            run(['ffmpeg', '-v', 'error', '-nostdin', '-y', *input_args, '-map', '0:v:0',
+                 *limits, '-c:v', 'copy', '-an', str(target)])
+            digest, size, seconds = decoded_digest(target, 'rgb24')
+            if digest != expected_hash or size != source_size:
+                raise ValueError('stream-copy RGB bytes/order/count mismatch')
+            cfg = storage(target, 'mkv/source_copy/v1',
+                          {'stream_copy': True}, lossy)
+            if video:
+                cfg['storage_fps'] = original.get('avg_frame_rate')
+                cfg['preserve_source_pts'] = True
+            records.append({'profile': cfg['profile'], 'all_frames_exact': True,
+                            'decoded_sha256': digest,
+                            'bytes': target.stat().st_size, 'decode_seconds': seconds,
+                            'encode_seconds': time.monotonic() - start - seconds})
+            records[-1].update(measure_rgb_access(target, None if stream_source else raw, width, height, actual, video))
+            if stream_source:
+                records[-1]['source_decode_seconds'] = source_seconds
+            return cfg, [width, height], records, actual
+        except (subprocess.CalledProcessError, ValueError) as exc:
+            records.append({'profile': 'stream_copy', 'rejected': str(exc)})
+            target.unlink(missing_ok=True)
+    if stream_source and video is not None:
+        # Exact fallback only: stream-copy normally avoids creating the source RGB spool.
+        run(decode_args(video, 'rgb24') + limits + [str(raw)])
+        if raw.stat().st_size != source_size or sha256(raw) != expected_hash:
+            raise ValueError('streaming source RGB differs from fallback decode')
+    candidates = []
+    for profile, codec, params in [
+        ('mkv/ffv1_rgb/v1', 'ffv1', ['-level', '3', '-pix_fmt', 'bgr0']),
+        ('mkv/h264_rgb_lossless/v1', 'libx264rgb', ['-crf', '0', '-preset', 'medium', '-g', '30'])]:
+        path = work / (codec + '.mkv')
+        try:
+            streamed = stream_images
+            def source_frames():
+                source_path = video if video is not None else images / ('%08d' + suffix)
+                frames = video_frames(source_path, 'rgb24', (height, width, 3), np.uint8)
+                try:
+                    for _ in range(actual):
+                        try:
+                            frame = next(frames)
+                        except StopIteration:
+                            raise ValueError('source RGB frame count mismatch') from None
+                        yield frame.tobytes()
+                finally:
+                    frames.close()
+            cfg, record = encode_raw(source_frames() if streamed else raw, path, width, height,
+                                     'rgb24', profile, codec, params, codec_threads)
+            if expected_hash is not None and record['decoded_sha256'] != expected_hash:
+                raise ValueError('source RGB digest/order differs from encoded output')
+            cfg['source_lossy'] = lossy
+            cfg['decoder']['source_color_metadata'] = {k: original.get(k, 'unknown') for k in
+                ('color_space', 'color_range', 'color_primaries', 'color_transfer')}
+            record['profile'] = profile
+            record.update(measure_rgb_access(path, None if streamed else raw, width, height, actual,
+                source_video=video, source_image=paths[actual // 2] if stream_images else None))
+            records.append(record)
+            candidates.append((path.stat().st_size, path, cfg))
+            if ffv1_first and codec == 'ffv1':
+                break  # Keep the H.264 fallback only if the preferred exact encoder fails.
+        except subprocess.CalledProcessError as exc:
+            records.append({'profile': profile, 'rejected': exc.stderr.decode(errors='replace')})
+    if not candidates:
+        raise ValueError('no supported lossless RGB encoder')
+    _, chosen, cfg = min(candidates, key=lambda x: x[0])
+    shutil.move(chosen, target)
+    return cfg, [width, height], records, actual
+
+
+def pack_depth(depth):
+    bits = np.ascontiguousarray(depth, dtype='<f4').view('<u4')
+    return np.concatenate([(bits & 65535).astype('<u2'), (bits >> 16).astype('<u2')], axis=-1)
+
+
+def unpack_depth(encoded):
+    low, high = np.split(np.asarray(encoded, dtype='<u2'), 2, axis=-1)
+    return (low.astype('<u4') | (high.astype('<u4') << 16)).view('<f4')
+
+
+def check_transform(values):
+    a = np.asarray(values)
+    if not np.isfinite(a).all() or a.shape[-2:] != (4, 4):
+        raise ValueError('invalid transform shape/values')
+    if not np.allclose(a[..., 3, :], [0, 0, 0, 1], atol=1e-5):
+        raise ValueError('invalid homogeneous transform row')
+    r = a[..., :3, :3]
+    if not np.allclose(np.swapaxes(r, -1, -2) @ r, np.eye(3), atol=2e-3) or not np.allclose(
+            np.linalg.det(r), 1, atol=2e-3):
+        raise ValueError('nonrigid rotation')
+
+
+class View:
+    def __init__(self, path, dataset, release, sequence, camera, frames, sampling='dense', split='unknown'):
+        self.path = Path(path)
+        self.path.mkdir(parents=True, exist_ok=True)
+        self.frames = frames
+        self.valid_rules = {}
+        self.full_jpeg = False
+        self.meta = dict(schema_version=SCHEMA['schema_version'], dataset_id=dataset,
+                         release_id=release, sequence_id=sequence, camera_id=camera,
+                         sample_type='video', num_frames=len(frames), hand_slots=['left', 'right'],
+                         sampling={'type': sampling, 'source_fps': None, 'frames_ref': 'camera/frames.jsonl'},
+                         camera={'model': 'unknown', 'schema_id': None, 'image_size': None},
+                         components={}, split=split, view_type='unknown')
+        if split == 'unknown':
+            self.meta['split_reason'] = 'No verified official split mapping available for this sequence'
+        self.build = {'validation': [], 'unresolved': [], 'validity_revision': SCHEMA['validity_revision']}
+
+    def absent(self, key, reason, status='source_missing'):
+        self.meta['components'][key] = {'available': False, 'reason': reason, 'status': status}
+        if status != 'source_missing':
+            self.build['unresolved'].append({'component': key, 'status': status, 'reason': reason})
+
+    def component(self, key, schema, ref, axes, loc, **extra):
+        if schema not in SCHEMA['components']:
+            raise ValueError(f'unregistered schema: {schema}')
+        if ref.startswith('annotation/') and extra.get('valid_ref'):
+            rule = self.valid_rules.get(key, self.valid_rules.get(key.split('_')[0]))
+            if not rule:
+                raise ValueError(f'{key}: adapter must declare annotation validity rule')
+            extra.setdefault('valid_policy', dict(
+                revision=SCHEMA['validity_revision'], meaning=SCHEMA['annotation_validity']['meaning'],
+                source_rule=rule, source_locator=loc, scope=extra.get('valid_axes', axes),
+                numerical_checks='Schema shape, finite valid floats, SE(3) where applicable; malformed input aborts',
+                official_qa={'status': 'not_provided', 'reason': 'No separate applicable official QA in selected source inputs'},
+                local_excluded_frame_indices=[], local_exclusion_reasons={}, visibility_independent=True))
+        self.meta['components'][key] = dict(available=True, schema_id=schema, data_ref=ref,
+                                          axes=axes, provenance=source(), source_locator=loc) | extra
+        return self.meta['components'][key]
+
+    def tensor(self, key, schema, ref, array, valid, axes, loc, **extra):
+        array = np.asarray(array, dtype=np.float32)
+        valid = np.asarray(valid, dtype=bool)
+        valid_shape = SCHEMA['components'][schema].get('valid_shape')
+        if valid_shape and (len(valid_shape) != valid.ndim or any(isinstance(s, int) and valid.shape[i] != s for i, s in enumerate(valid_shape))):
+            raise ValueError(f'{key}: schema validity shape mismatch')
+        if array.shape[:valid.ndim] != valid.shape:
+            raise ValueError(f'{key}: validity axes mismatch')
+        if not np.isfinite(array[valid]).all():
+            raise ValueError(f'{key}: source annotation exists but is nonfinite')
+        array = array.copy()
+        array[~valid] = np.nan
+        if schema in ('transform/se3/v1', 'object/rigid/v1'):
+            check_transform(array[valid])
+        expected = SCHEMA['components'][schema].get('shape')
+        if expected and (len(expected) != array.ndim or any(
+                isinstance(n, int) and array.shape[i] != n for i, n in enumerate(expected))):
+            raise ValueError(f'{key}: schema shape mismatch {array.shape}')
+        dest = self.path / ref
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        torch.save(torch.from_numpy(array), dest)
+        valid_ref = str(Path(ref).with_name(Path(ref).stem + '_valid.pt'))
+        torch.save(torch.from_numpy(valid.copy()), self.path / valid_ref)
+        return self.component(key, schema, ref, axes, loc, valid_ref=valid_ref,
+                              valid_axes=axes[:valid.ndim], **extra)
+
+    def rgb(self, paths, loc, video=None, count=None, ffv1_first=False, codec_threads=1,
+            stream_source=False):
+        media_dir = os.environ.get('HAND_WAREHOUSE_MEDIA_TMPDIR') if stream_source and (video is not None or all(p is not None for p in paths)) else None
+        with tempfile.TemporaryDirectory(prefix='rgb-', dir=media_dir or self.path) as work:
+            cfg, size, records, n = rgb_video(paths, self.path / 'observation/rgb.mkv',
+                                             Path(work), video, count, self.meta['sequence_id'], self.meta['camera_id'],
+                                             self.full_jpeg, ffv1_first, codec_threads, stream_source)
+        if n != len(self.frames):
+            raise ValueError('RGB differs from frames timeline')
+        torch.save(torch.ones(n, dtype=torch.bool, device='cpu') if video is not None else
+                   torch.tensor([p is not None for p in paths], dtype=torch.bool, device='cpu'),
+                   self.path / 'observation/rgb_valid.pt')
+        self.component('rgb', 'rgb/uint8/v1', 'observation/rgb.mkv', ['T', 'height', 'width', 'channel'],
+                       loc, storage=cfg, valid_ref='observation/rgb_valid.pt', valid_axes=['T'],
+                       provenance=source('Verified source packet copy or lossless fixed-decoder RGB encoding'))
+        self.meta['camera']['image_size'] = size
+        self.build['validation'].extend(records)
+
+    def raster(self, key, arrays, valid, loc, labels=None, codec_threads=1, stream=False):
+        depth = key == 'depth'
+        ref = 'observation/depth.mkv' if depth else 'annotation/segment/mask.mkv'
+        dest = self.path / ref
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        width, height = self.meta['camera']['image_size']
+        count = 0
+        media_dir = os.environ.get('HAND_WAREHOUSE_MEDIA_TMPDIR') if stream and len(self.frames) * width * height <= 2 * 1024**3 else None
+        with tempfile.TemporaryDirectory(prefix='raster-', dir=media_dir or self.path) as wd:
+            work = Path(wd)
+            with (work / 'valid.raw').open('wb') as vo:
+                def frames():
+                    nonlocal count
+                    for arr in arrays:
+                        arr = np.asarray(arr)
+                        if arr.shape != (height, width):
+                            raise ValueError(f'{key}: raster not on RGB grid')
+                        if depth:
+                            arr = arr.astype('<f4')
+                            good = np.isfinite(arr) & (arr > 0)
+                            arr[~good] = np.nan
+                            vo.write(good.astype(np.uint8).tobytes())
+                            payload = pack_depth(arr).tobytes()
+                        else:
+                            if not np.issubdtype(arr.dtype, np.integer) or arr.min() < 0 or arr.max() > 65535:
+                                raise ValueError('invalid segmentation region codes')
+                            payload = arr.astype('<u2').tobytes()
+                        count += 1
+                        yield payload
+                    if count != len(self.frames):
+                        raise ValueError(f'{key}: frame count mismatch')
+
+                if stream:
+                    source = frames()
+                else:
+                    source = work / 'data.raw'
+                    with source.open('wb') as out:
+                        for payload in frames():
+                            out.write(payload)
+                cfg, record = encode_raw(source, dest, width * (2 if depth else 1), height,
+                                         'gray16le', 'mkv/depth_float32_bits/v1' if depth else 'mkv/uint16_ffv1/v1',
+                                         threads=codec_threads)
+            self.build['validation'].append(record | {'component': key})
+            if depth:
+                vcfg, record = encode_raw(work / 'valid.raw', self.path / 'observation/depth_valid.mkv',
+                                         width, height, 'gray', 'mkv/bool_ffv1/v1', threads=codec_threads)
+                self.build['validation'].append(record | {'component': 'depth_valid'})
+                self.component(key, 'depth/z_float32/v1', ref, ['T', 'height', 'width'], loc,
+                    storage=cfg, valid_storage=vcfg, valid_ref='observation/depth_valid.mkv',
+                    valid_axes=['T', 'height', 'width'], unit='m', depth_type='z', depth_origin='measured', invalid_value='NaN')
+            else:
+                vref = 'annotation/segment/mask_valid.pt'
+                torch.save(torch.as_tensor(valid, dtype=torch.bool, device='cpu'), self.path / vref)
+                jsonl_write(self.path / 'annotation/segment/instances.jsonl', labels)
+                self.component(key, 'segment/uint16_labels/v1', ref, ['T', 'height', 'width'], loc,
+                    storage=cfg, valid_ref=vref, valid_axes=['T'], segmentation_type='instance',
+                    mapping_ref='annotation/segment/instances.jsonl', coverage={'kind': 'unknown'})
+
+    def camera(self, intrinsic, loc, extrinsic=None, extrinsic_loc=None):
+        n = len(self.frames)
+        if intrinsic is not None:
+            a = np.asarray(intrinsic)
+            a = np.broadcast_to(a, (n, 3, 3)) if a.shape == (3, 3) else a
+            if not np.allclose(a[..., 2, :], [0, 0, 1]) or np.any(a[..., 0, 0] <= 0) or np.any(a[..., 1, 1] <= 0):
+                raise ValueError('invalid pinhole intrinsic matrix')
+            self.tensor('intrinsic', 'camera/pinhole/v1', 'camera/intrinsic.pt', a,
+                        np.ones(n, bool), ['T', 'row', 'column'], loc)
+            self.meta['camera'].update(model='pinhole', schema_id='camera/pinhole/v1')
+        if extrinsic is not None:
+            a = np.asarray(extrinsic)
+            a = np.broadcast_to(a, (n, 4, 4)) if a.shape == (4, 4) else a
+            self.tensor('extrinsic', 'transform/se3/v1', 'camera/extrinsic.pt', a,
+                        np.ones(n, bool), ['T', 'row', 'column'], extrinsic_loc or loc,
+                        convention='T_camera_from_world')
+
+    def object(self, oid, loc, scope='sequence', scope_id=None, **extra):
+        info = dict(object_id=oid, identity_scope=scope, scope_id=scope_id or self.meta['sequence_id'],
+                    source_locator=loc, has_model=False) | extra
+        json_write(self.path / f'annotation/object/{oid}/metainfo.json', info)
+        return info
+
+    def relations(self, rows, valid, loc):
+        ref = 'annotation/contact/relations.jsonl'
+        jsonl_write(self.path / ref, rows)
+        vref = 'annotation/contact/relations_valid.pt'
+        torch.save(torch.as_tensor(valid, dtype=torch.bool, device='cpu'), self.path / vref)
+        self.component('relations', 'contact/relations/v1', ref, ['T'], loc, valid_ref=vref, valid_axes=['T'])
+
+    def finish(self):
+        check_view_type(self.meta)
+        for key, component in self.meta['components'].items():
+            if component.get('valid_policy'):
+                check_valid_policy(component, len(self.frames))
+                valid = torch.load(self.path / component['valid_ref'], weights_only=True)
+                self.build.setdefault('annotation_validity', {})[key] = {
+                    'valid_policy': component['valid_policy'], 'valid_count': int(valid.sum()),
+                    'invalid_count': valid.numel() - int(valid.sum())}
+        for i, frame in enumerate(self.frames):
+            frame.update(frame_index=i)
+            frame.setdefault('timestamp_ns', None)
+            frame.setdefault('clock_domain', None)
+            if 'source_locator' not in frame:
+                raise ValueError('frame source locator missing')
+        jsonl_write(self.path / 'camera/frames.jsonl', self.frames)
+        json_write(self.path / 'metainfo.json', self.meta)
+        return self.build
+
+
+def check_mesh(path, asset_root):
+    path, asset_root = Path(path), Path(asset_root).resolve()
+    vertices, faces, largest_index = 0, 0, 0
+    materials = []
+    with path.open() as inp:
+        for line in inp:
+            fields = line.split()
+            if not fields or fields[0].startswith('#'):
+                continue
+            if fields[0] == 'v':
+                if len(fields) < 4 or not all(math.isfinite(float(v)) for v in fields[1:4]):
+                    raise ValueError(f'invalid mesh vertex: {path}')
+                vertices += 1
+            elif fields[0] == 'f':
+                if len(fields) < 4:
+                    raise ValueError('degenerate OBJ face')
+                for field in fields[1:]:
+                    index = int(field.split('/')[0])
+                    if index == 0 or index < -vertices:
+                        raise ValueError('invalid OBJ vertex index')
+                    largest_index = max(largest_index, index)
+                faces += 1
+            elif fields[0] == 'mtllib':
+                materials.extend(shlex.split(line)[1:])
+    if not vertices or not faces or largest_index > vertices:
+        raise ValueError('empty or invalid mesh')
+    def dependency(parent, name):
+        dep = (parent / name).resolve()
+        if not dep.is_relative_to(asset_root) or not dep.is_file():
+            raise ValueError(f'missing or escaping asset dependency: {name}')
+        return dep
+    dependencies = []
+    for name in materials:
+        mtl = dependency(path.parent, name)
+        dependencies.append(mtl)
+        for line in mtl.read_text().splitlines():
+            fields = shlex.split(line, comments=True)
+            if fields and (fields[0].startswith('map_') or fields[0] in ('bump', 'norm', 'disp', 'decal')):
+                dependencies.append(dependency(mtl.parent, fields[-1]))
+    return {'vertices': vertices, 'faces': faces, 'sha256': sha256(path),
+            'dependencies': {p.relative_to(asset_root).as_posix(): sha256(p) for p in dependencies}}
+
+
+def mesh_asset(view, oid, directory, obj, loc):
+    dest = view.path / f'annotation/object/{oid}/assets'
+    shutil.copytree(directory, dest)
+    ref = (dest / Path(obj).relative_to(directory)).relative_to(view.path).as_posix()
+    mesh_check = check_mesh(dest / Path(obj).relative_to(directory), dest)
+    view.build['validation'].append({'component': f'mesh_{oid}', **mesh_check})
+    view.component(f'mesh_{oid}', 'mesh/obj/v1', ref, ['vertex'], loc, valid=True, unit='m')
+    p = view.path / f'annotation/object/{oid}/metainfo.json'
+    info = json.loads(p.read_text())
+    info.update(has_model=True, mesh_ref=ref)
+    json_write(p, info)
+
+
+def safe_member(root, name):
+    path = (Path(root) / name).resolve()
+    if not path.is_relative_to(Path(root).resolve()):
+        raise ValueError(f'unsafe archive path: {name}')
+    return path
+
+
+class ChumpyStub:
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+
+class ManoUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if module.startswith('chumpy'):
+            return ChumpyStub
+        return super().find_class(module, name)
+
+
+def mano_models(directory):
+    result = {}
+    if directory is None:
+        return result
+    for side in ('left', 'right'):
+        path = Path(directory).expanduser() / f'MANO_{side.upper()}.pkl'
+        if not path.exists():
+            continue
+        with path.open('rb') as f:
+            data = ManoUnpickler(f, encoding='latin1').load()
+        result[side] = {'components': np.asarray(data['hands_components']),
+                        'mean': np.asarray(data['hands_mean']), 'sha256': sha256(path),
+                        'file': path.name}
+    return result
+
+
+def model_profile(models):
+    identity = json.dumps({side: d['sha256'] for side, d in sorted(models.items())}).encode()
+    return {'version': 'sha256:' + hashlib.sha256(identity).hexdigest(), 'flat_hand_mean': True,
+            'left_shapedirs_correction': 'not_applied',
+            'models': {side: {'file': d['file'], 'sha256': d['sha256']} for side, d in models.items()}}
+
+
+def pca_to_axis_angle(coeffs, model):
+    coeffs = np.asarray(coeffs)
+    if coeffs.shape[-1:] != (45,) or not np.isfinite(coeffs).all():
+        raise ValueError('invalid MANO PCA coefficients')
+    return coeffs @ model['components'] + model['mean']
+
+
+def parser(dataset, description):
+    p = argparse.ArgumentParser(description=description)
+    p.add_argument('--root', f'--{dataset.lower()}-root', dest='root', type=Path, default=RAW_ROOT / dataset)
+    p.add_argument('--out', type=Path, default=Path('converted'))
+    p.add_argument('--release-id', default='v1.0')
+    p.add_argument('--limit', type=int, help='Maximum sequences to convert')
+    p.add_argument('--max-frames', type=int, help='First N source frame indices per view (recorded as sampling)')
+    p.add_argument('--mano-dir', type=Path)
+    p.add_argument('--views', help='Comma-separated source camera IDs')
+    p.add_argument('--jpeg-full-check', action='store_true', help='Full decoded RGB check for selected JPEG pilot/final views')
+    return p
+
+
+def roots(root):
+    root = Path(root).expanduser()
+    return [p for p in (root / 'raw/data', root / 'raw', root) if p.is_dir()]
+
+
+def find_file(root, name):
+    return next((p / name for p in roots(root) if (p / name).exists()), None)
+
+
+def release(args, dataset):
+    if not args.release_id or Path(args.release_id).name != args.release_id or args.release_id in ('.', '..'):
+        raise ValueError('release-id must be a single directory name')
+    if args.limit is not None and args.limit < 1 or args.max_frames is not None and args.max_frames < 1:
+        raise ValueError('limits must be positive')
+    out = args.out.expanduser().resolve() / dataset / args.release_id
+    raw = args.root.expanduser().resolve()
+    if out == raw or out.is_relative_to(raw):
+        raise ValueError('output must not modify the raw source tree')
+    (out / 'data').mkdir(parents=True, exist_ok=True)
+    (out / 'doc').mkdir(exist_ok=True)
+    (out / 'script').mkdir(exist_ok=True)
+    scripts = list(Path(__file__).resolve().parent.glob('*.py'))
+    existing = {p.name for p in (out / 'script').glob('*.py')}
+    if existing and existing != {p.name for p in scripts}:
+        raise ValueError('converter files changed; choose a new --release-id')
+    copies = [(SCHEMA_PATH.parent / name, out / 'doc' / name) for name in ('CONTRACT.md', 'schema.json')]
+    copies += [(path, out / 'script' / path.name) for path in scripts]
+    # Check every existing file before changing any published definition or script.
+    for src, dest in copies:
+        if dest.exists() and sha256(dest) != sha256(src):
+            raise ValueError('converter or contract changed within an existing release; choose a new --release-id')
+    for src, dest in copies:
+        if src.resolve() != dest.resolve():
+            shutil.copyfile(src, dest)
+    json_write(out / 'script/config.json', {k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()})
+    return out
+
+
+@contextmanager
+def sequence_dir(out, sequence):
+    if Path(sequence).name != sequence:
+        raise ValueError('sequence ID must be a single path component')
+    final = out / 'data' / sequence
+    with tempfile.TemporaryDirectory(prefix=sequence + '.tmp-', dir=out / 'data') as wd:
+        tmp = Path(wd)
+        yield tmp
+        if final.exists():
+            if any((final / child.name).exists() for child in tmp.iterdir()):
+                raise FileExistsError('view already published; use a new release-id to preserve it')
+            for child in list(tmp.iterdir()):
+                child.rename(final / child.name)
+        else:
+            tmp.rename(final)
+
+
+def build_record(out, sequence, reports):
+    path = out / 'doc' / (sequence + '.build.json')
+    previous = json.loads(path.read_text()) if path.exists() else {}
+    config = json.loads((out / 'script/config.json').read_text())
+    for report in reports.values():
+        report['configuration'] = config
+    json_write(path, {'sequence_id': sequence, 'storage_revision': SCHEMA['storage_revision'],
+        'scripts': {p.name: sha256(p) for p in (out / 'script').glob('*.py')},
+        'runtime': {'torch': torch.__version__, 'ffmpeg': ffversion()},
+        'views': previous.get('views', {}) | reports})
+
+
+def check_view_type(meta):
+    # The pinned ARCTIC contract makes view_type optional; adapters still supply known views.
+    if 'view_type' not in meta:
+        return
+    if meta['view_type'] not in ('ego', 'exo', 'unknown'):
+        raise ValueError('view_type must be ego/exo/unknown')
+    expected = {'dex-ycb': 'exo', 'EPIC-KITCHENS-VISOR': 'ego', 'HOI4D': 'ego'}.get(meta['dataset_id'])
+    if meta['dataset_id'] == 'H2O':
+        expected = 'ego' if meta['camera_id'] == 'cam4' else 'exo' if meta['camera_id'] in ('cam0', 'cam1', 'cam2', 'cam3') else 'unknown'
+    if expected and meta['view_type'] not in (expected, 'unknown'):
+        raise ValueError('view_type contradicts known source capture setup')
+
+
+def check_valid_policy(component, count):
+    policy = component.get('valid_policy', {})
+    for field in ('revision', 'meaning', 'source_rule', 'source_locator', 'scope', 'numerical_checks',
+                  'official_qa', 'local_excluded_frame_indices', 'local_exclusion_reasons', 'visibility_independent'):
+        if field not in policy:
+            raise ValueError(f'valid_policy missing {field}')
+    if policy['revision'] != SCHEMA['validity_revision'] or policy['meaning'] != SCHEMA['annotation_validity']['meaning']:
+        raise ValueError('outdated annotation validity semantics')
+    if not policy['source_rule'] or not policy['numerical_checks'] or policy['scope'] != component['valid_axes']:
+        raise ValueError('incomplete validity rule/scope')
+    if policy['official_qa'].get('status') != 'not_provided' or not policy['official_qa'].get('reason'):
+        raise ValueError('official QA requires a verified adapter; supervision acceptance paused')
+    excluded = policy['local_excluded_frame_indices']
+    if any(type(i) is not int or not 0 <= i < count for i in excluded):
+        raise ValueError('invalid local exclusion frame index')
+    if excluded:
+        raise ValueError('local exclusions require a reviewed rule/report; not supported by these adapters')
+    if policy['visibility_independent'] is not True:
+        raise ValueError('visibility must remain independent of validity')
+
+
+def validate_view(path):
+    """Validate the persisted contract, not a rendering of the source labels."""
+    path = Path(path)
+    meta = json.loads((path / 'metainfo.json').read_text())
+    n = meta['num_frames']
+    check_view_type(meta)
+    if meta['schema_version'] != SCHEMA['schema_version'] or meta['hand_slots'] != ['left', 'right'] or n < 1:
+        raise ValueError('invalid view header')
+    def resolve(ref):
+        if Path(ref).is_absolute() or '\\' in ref:
+            raise ValueError('component reference must be relative POSIX')
+        dest = safe_member(path, ref)
+        if not dest.is_file():
+            raise ValueError(f'referenced file missing: {ref}')
+        return dest
+    def tensor(ref):
+        def cpu_storage(storage, location):
+            if location != 'cpu':
+                raise ValueError('PT storage must be on CPU')
+            return storage
+        value = torch.load(resolve(ref), map_location=cpu_storage, weights_only=True)
+        if not isinstance(value, torch.Tensor) or value.device.type != 'cpu':
+            raise ValueError('PT must contain only a CPU Tensor')
+        return value.numpy()
+    frames = [json.loads(line) for line in resolve(meta['sampling']['frames_ref']).read_text().splitlines()]
+    if len(frames) != n or [f['frame_index'] for f in frames] != list(range(n)):
+        raise ValueError('frame index/count mismatch')
+    for f in frames:
+        if not all(k in f for k in ('source_frame_id', 'timestamp_ns', 'clock_domain', 'source_locator')):
+            raise ValueError('incomplete frame provenance')
+    entities = {'hand_left', 'hand_right'}
+    parts = {}
+    for p in (path / 'annotation/object').glob('*/metainfo.json'):
+        obj = json.loads(p.read_text())
+        if obj['object_id'] != p.parent.name or obj['identity_scope'] not in ('frame', 'subsequence', 'sequence'):
+            raise ValueError('invalid object identity')
+        entities.add(obj['object_id'])
+        if obj.get('mesh_ref'):
+            if not resolve(obj['mesh_ref']).is_relative_to(p.parent.resolve()):
+                raise ValueError('mesh must belong to its object')
+        if obj.get('articulation_ref'):
+            art = json.loads(resolve(obj['articulation_ref']).read_text())
+            part_ids = {part['part_id'] for part in art['parts']}
+            if len(part_ids) != len(art['parts']):
+                raise ValueError('duplicate part ID')
+            parents = {part['part_id']: part['parent_id'] for part in art['parts']}
+            for part_id in parents:
+                visited, cur = set(), part_id
+                while cur is not None:
+                    if cur in visited or cur not in parents:
+                        raise ValueError('invalid or cyclic part hierarchy')
+                    visited.add(cur)
+                    cur = parents[cur]
+            parts[obj['object_id']] = part_ids
+    video_stats = {}
+    for key, component in meta['components'].items():
+        if not component.get('available'):
+            if not component.get('reason'):
+                raise ValueError('unavailable component needs a reason')
+            continue
+        schema = SCHEMA['components'][component['schema_id']]
+        for required in ('axes', 'provenance', 'source_locator'):
+            if required not in component:
+                raise ValueError(f'{key}: {required} missing')
+        for required in schema.get('required_metadata', []):
+            if required not in component:
+                raise ValueError(f'{key}: {required} missing')
+        if component['provenance']['kind'] == 'derived':
+            raise ValueError('v1.0 must not synthesize annotations')
+        if component['data_ref'].startswith('annotation/') and schema.get('valid_shape'):
+            if not component.get('valid_ref') or not component.get('valid_axes'):
+                raise ValueError(f'{key}: annotation validity reference/axes missing')
+            check_valid_policy(component, n)
+        data_path = resolve(component['data_ref'])
+        valid = tensor(component['valid_ref']) if component.get('valid_ref', '').endswith('.pt') else None
+        valid_shape = schema.get('valid_shape')
+        if valid is not None and valid_shape and (len(valid_shape) != valid.ndim or any(
+                isinstance(s, int) and valid.shape[i] != s for i, s in enumerate(valid_shape))):
+            raise ValueError(f'{key}: validity schema shape mismatch')
+        if valid is not None and (valid.dtype != bool or valid.shape[0] != n):
+            raise ValueError(f'{key}: invalid validity tensor')
+        if component['schema_id'] == 'mesh/obj/v1':
+            objroot = next((parent for parent in data_path.parents if parent.parent.name == 'object'), None)
+            if objroot is None:
+                raise ValueError('mesh must be owned by an object')
+            check_mesh(data_path, objroot)
+        if data_path.suffix == '.pt':
+            arr = tensor(component['data_ref'])
+            if arr.dtype != np.float32 or arr.shape[0] != n:
+                raise ValueError(f'{key}: float dtype or timeline mismatch')
+            shape = schema.get('shape')
+            if shape and (len(shape) != arr.ndim or any(isinstance(s, int) and arr.shape[i] != s for i, s in enumerate(shape))):
+                raise ValueError(f'{key}: schema shape mismatch')
+            if valid is not None:
+                if arr.shape[:valid.ndim] != valid.shape or not np.isfinite(arr[valid]).all() or not np.isnan(arr[~valid]).all():
+                    raise ValueError(f'{key}: invalid finite/NaN/validity values')
+                if component['schema_id'] in ('object/rigid/v1', 'transform/se3/v1'):
+                    check_transform(arr[valid])
+        if data_path.suffix == '.mkv':
+            cfg = component['storage']
+            if cfg['profile'] not in SCHEMA['storage_profiles']:
+                raise ValueError('unregistered video profile')
+            for field in SCHEMA['video_metadata']['required']:
+                if field not in cfg:
+                    raise ValueError('video storage declaration incomplete')
+            w, h = meta['camera']['image_size']
+            if cfg['encoded_size'] != [w * (2 if key == 'depth' else 1), h]:
+                raise ValueError('encoded raster differs from logical RGB grid')
+            actual = probe(data_path)
+            if (actual['codec_name'] != cfg['codec'] or actual['pix_fmt'] != cfg['pixel_format'] or
+                    [actual['width'], actual['height']] != cfg['encoded_size']):
+                raise ValueError('video storage metadata differs from file')
+            if key == 'rgb':
+                fmt, bpp = 'rgb24', 3
+            else:
+                fmt, bpp = 'gray16le', 2
+            digest, size, _ = decoded_digest(data_path, fmt)
+            w, h = cfg['encoded_size']
+            if size != n * w * h * bpp:
+                raise ValueError('raster timeline mismatch')
+            video_stats[key] = {'decoded_sha256': digest, 'frames': n}
+            if key == 'depth':
+                validity = component['valid_storage']
+                vp = resolve(component['valid_ref'])
+                actual_valid = probe(vp)
+                if (validity['profile'] != 'mkv/bool_ffv1/v1' or actual_valid['codec_name'] != 'ffv1'
+                        or actual_valid['pix_fmt'] != 'gray' or [actual_valid['width'], actual_valid['height']] != [w // 2, h]):
+                    raise ValueError('invalid depth validity video')
+                count = 0
+                for encoded, mask in zip(video_frames(data_path, 'gray16le', (h, w), '<u2'),
+                        video_frames(vp, 'gray', (h, w // 2), np.uint8), strict=True):
+                    if not np.isin(mask, [0, 1]).all():
+                        raise ValueError('depth valid pixels must be 0 or 1')
+                    depth, good = unpack_depth(encoded), mask.astype(bool)
+                    if not (np.isfinite(depth[good]) & (depth[good] > 0)).all() or not np.isnan(depth[~good]).all():
+                        raise ValueError('invalid depth/validity semantics')
+                    count += 1
+                if count != n:
+                    raise ValueError('depth validity timeline mismatch')
+        if component['schema_id'].startswith('segment/') and component.get('mapping_ref'):
+            rows = [json.loads(line) for line in resolve(component['mapping_ref']).read_text().splitlines()]
+            if len(rows) != n or [row['frame_index'] for row in rows] != list(range(n)):
+                raise ValueError('segmentation mapping timeline mismatch')
+            for row in rows:
+                labels = row['labels']
+                if len({a['mask_value'] for a in labels}) != len(labels):
+                    raise ValueError('duplicate region mapping')
+                for label in labels:
+                    if label['entity_id'] is not None and label['entity_id'] not in entities:
+                        raise ValueError('unresolved segmentation entity')
+                    if label['part_id'] is not None and label['part_id'] not in parts.get(label['entity_id'], set()):
+                        raise ValueError('unresolved segmentation part')
+            if component['schema_id'] == 'segment/uint16_labels/v1':
+                width, height = meta['camera']['image_size']
+                for i, mask in enumerate(video_frames(data_path, 'gray16le', (height, width), '<u2')):
+                    codes = set(np.unique(mask).tolist()) - {0, 65535}
+                    mapped = {label['mask_value'] for label in rows[i]['labels']} - {0, 65535}
+                    if codes != mapped or not valid[i] and codes:
+                        raise ValueError('mask values differ from declared instances/validity')
+            if component['schema_id'] == 'segment/instance_polygons/v1':
+                polygons = [json.loads(line) for line in data_path.read_text().splitlines()]
+                if len(polygons) != n:
+                    raise ValueError('polygon timeline mismatch')
+                for i, row in enumerate(polygons):
+                    if row['frame_index'] != i or {x['mask_value'] for x in row['instances']} != {x['mask_value'] for x in rows[i]['labels']}:
+                        raise ValueError('polygon/mapping mismatch')
+        if component['schema_id'] == 'contact/relations/v1':
+            rows = [json.loads(line) for line in data_path.read_text().splitlines()]
+            if len(rows) != n:
+                raise ValueError('relation timeline mismatch')
+            for i, row in enumerate(rows):
+                if row['frame_index'] != i or not valid[i] and row['relations']:
+                    raise ValueError('relation validity mismatch')
+                for relation in row['relations']:
+                    if relation['subject_id'] not in entities or relation['status'] not in ('positive', 'negative', 'unknown', 'target_unannotated'):
+                        raise ValueError('invalid relation')
+                    if relation['status'] == 'positive' and relation['object_id'] not in entities:
+                        raise ValueError('unresolved positive contact')
+    return {'view': str(path), 'num_frames': n, 'videos': video_stats, 'validated': True}