#!/usr/bin/env python3 """Validate the two explicitly registered sequence insertion supplements. Strict validation binds media and metadata to a captured immutable Hub inventory. Prepublication validation is explicitly unbound and cannot authorize publication. The ordinary dated fragment validator and its RecNN contract remain unchanged. """ from __future__ import annotations import argparse import csv import hashlib import json import re from pathlib import Path, PurePosixPath REGISTRY_PATH = 'Standard_Time_Lapses/Provenance/Sequence_Insertions/registry.json' MANIFEST_PATH = 'Standard_Time_Lapses/Provenance/Sequence_Insertions/2026-10-29-F/sequence.json' F_LABEL = '2026-10-25.0938.BallpointPen.Ink.Paper.9x12' NINE_BY_TWELVE_MANIFEST_PATH = 'Standard_Time_Lapses/Provenance/Sequence_Insertions/2026-10-30-9x12/sequence.json' NINE_BY_TWELVE_LABEL = '2026-10-27.0100.Pencil.Graphite.FountainPen.Ink.Paper.9x12' # Exact path/label pairs only: this is not a generic insertion mechanism. SEQUENCE_CONTRACTS = { (MANIFEST_PATH, F_LABEL): (('03a', '03b'), '2026-10-25', '09:38'), (NINE_BY_TWELVE_MANIFEST_PATH, NINE_BY_TWELVE_LABEL): (('03a',), '2026-10-27', '01:00'), } PREDECESSOR_PATH = 'Standard_Time_Lapses/Provenance/2026-10-29/fragment_sequence_relationships.csv' PREDECESSOR_SHA256 = 'd930bd171220403df10247cb3c05cb7ad431689c7bfcd0e4ec7e3c11ec9f232d' PREDECESSOR_REVISION = '4f563085afacfc454496ac2d61606614268b2cb8' EVIDENCE = {'membership': 'owner-confirmed', 'order': 'visual-inference-with-device-metadata-corroboration', 'gapless_capture': 'not-established'} HASH_RE = re.compile(r'^[0-9a-f]{64}$') REVISION_RE = re.compile(r'^[0-9a-f]{40}$') RECORD_RE = re.compile(r'^tla-[0-9a-f]{16}$') LETTERED_RE = re.compile(r'\.Rec\d+[a-zA-Z]+\.mp4$') MEMBER_KEYS = {'record_id', 'file_path', 'sha256', 'hub_xet_hash', 'size_bytes', 'sequence_position'} MANIFEST_KEYS = {'schema_version', 'fragment_set_label', 'source_hub_revision', 'predecessor', 'additions', 'members', 'sequence_completeness', 'evidence', 'notes'} def matches(pattern, value): return isinstance(value, str) and pattern.fullmatch(value) is not None def positive_int(value): return type(value) is int and value > 0 def read_json(path): return json.loads(path.read_text(encoding='utf-8-sig')) def read_csv(path): with path.open(encoding='utf-8-sig', newline='') as handle: reader = csv.DictReader(handle) if not reader.fieldnames: raise ValueError('CSV header is missing') return list(reader) def safe_path(root, value): if not isinstance(value, str) or not value or '\\' in value: raise ValueError('invalid repository path') relative = PurePosixPath(value) if relative.is_absolute() or any(p in ('..', '.') for p in relative.parts) or ':' in value: raise ValueError('unsafe repository path') path = root.joinpath(*relative.parts).resolve() if not path.is_relative_to(root.resolve()): raise ValueError('repository path escapes root') return path def unique_index(rows, field, errors, label): result = {} if not isinstance(rows, list): errors.append(f'{label}: expected a list') return result for row in rows: if not isinstance(row, dict) or not isinstance(row.get(field), str) or not row[field]: errors.append(f'{label}: invalid {field}') continue value = row[field] if value in result: errors.append(f'{label}: duplicate {field}: {value}') result[value] = row return result def validate_insertions(root: Path, metadata: Path, *, inventory=None, prepublication=False, bind_inventory=True): """Return errors and validated sequences; never return partial membership. bind_inventory=False is for the metadata loader's local structural check. It still requires real remote identities; only prepublication=True permits a null source revision and null Xet identities for the declared additions. """ errors = [] sequences = [] level = ('prepublication_unbound' if prepublication else 'pinned_repository_inventory' if bind_inventory else 'structural_and_metadata_only') result = {'verification_level': level, 'inventory_binding_checked': False, 'sequences': sequences, 'errors': errors} try: registry = read_json(root / REGISTRY_PATH) metadata_rows = read_csv(metadata) by_id = unique_index(metadata_rows, 'record_id', errors, 'metadata') unique_index(metadata_rows, 'file_name', errors, 'metadata') if (not isinstance(registry, dict) or set(registry) != {'schema_version', 'sequences'} or type(registry.get('schema_version')) is not int or registry['schema_version'] != 1 or not isinstance(registry.get('sequences'), list) or not registry['sequences']): raise ValueError('registry must contain schema_version 1 and a nonempty sequences list') if bind_inventory and not prepublication and not isinstance(inventory, dict): errors.append('strict validation requires an actual pinned repository inventory') inventory_bundle = None current_inventory = None if (bind_inventory and not prepublication and isinstance(inventory, dict) and ('inventories' in inventory or 'current_inventory' in inventory)): inventory_bundle = {} entries = inventory.get('inventories') current_inventory = inventory.get('current_inventory') if (set(inventory) != {'current_inventory', 'inventories'} or not isinstance(entries, list) or not entries): errors.append('inventory bundle requires current_inventory and a nonempty inventories list') if (not isinstance(current_inventory, dict) or not matches(REVISION_RE, current_inventory.get('sha'))): errors.append('current_inventory requires an immutable revision') current_inventory = None if isinstance(entries, list): for source in entries: if not isinstance(source, dict) or set(source) != {'inventory', 'metadata_path'}: errors.append('source entry requires inventory and metadata_path'); continue receipt, snapshot = source['inventory'], source['metadata_path'] if not isinstance(receipt, dict) or not matches(REVISION_RE, receipt.get('sha')): errors.append('source inventory requires an immutable revision'); continue if not isinstance(snapshot, str) or not Path(snapshot).is_absolute(): errors.append('source metadata_path must be an explicit absolute local path'); continue pin = receipt['sha'] if pin in inventory_bundle: errors.append('inventory bundle contains duplicate revisions'); continue inventory_bundle[pin] = (receipt, Path(snapshot)) seen_labels, seen_paths, registered_ids = set(), set(), set() for entry in registry['sequences']: if not isinstance(entry, dict) or set(entry) != {'manifest_path', 'sha256'}: errors.append('invalid registry entry'); continue path = safe_path(root, entry['manifest_path']) if entry['manifest_path'] not in {path for path, _ in SEQUENCE_CONTRACTS}: errors.append('unregistered insertion manifest path'); continue if entry['manifest_path'] in seen_paths: errors.append('duplicate active insertion version'); continue seen_paths.add(entry['manifest_path']) raw = path.read_bytes() if not matches(HASH_RE, entry['sha256']) or hashlib.sha256(raw).hexdigest() != entry['sha256']: errors.append('registry manifest SHA-256 mismatch'); continue manifest = json.loads(raw) if not isinstance(manifest, dict) or set(manifest) != MANIFEST_KEYS: errors.append('invalid sequence manifest fields'); continue if type(manifest['schema_version']) is not int or manifest['schema_version'] != 1: errors.append('invalid sequence schema_version') label = manifest['fragment_set_label'] if (entry['manifest_path'], label) not in SEQUENCE_CONTRACTS: errors.append('unregistered fragment_set_label'); continue suffixes, finish_date, finish_time = SEQUENCE_CONTRACTS[(entry['manifest_path'], label)] addition_count = len(suffixes) if label in seen_labels: errors.append('duplicate active sequence for fragment_set_label'); continue seen_labels.add(label) if manifest['sequence_completeness'] != 'unknown' or manifest['evidence'] != EVIDENCE: errors.append('insertion evidence/completeness contract differs') if not isinstance(manifest['notes'], str) or not manifest['notes'].strip(): errors.append('sequence notes must be nonblank') revision = manifest['source_hub_revision'] if not matches(REVISION_RE, revision) and not (prepublication and revision is None): errors.append('source_hub_revision must be an immutable commit') expected_predecessor = {'path': PREDECESSOR_PATH, 'sha256': PREDECESSOR_SHA256, 'source_hub_revision': PREDECESSOR_REVISION} if manifest['predecessor'] != expected_predecessor: errors.append('predecessor differs from the immutable registered F receipt' if label == F_LABEL else 'predecessor differs from the immutable registered 9x12 receipt') predecessor = root / PREDECESSOR_PATH if hashlib.sha256(predecessor.read_bytes()).hexdigest() != PREDECESSOR_SHA256: errors.append('historical predecessor bytes changed'); continue old = [row for row in read_csv(predecessor) if row['object_role'] == 'canonical_fragment' and row['fragment_set_label'] == label] old.sort(key=lambda row: int(row['sequence_position'])) old_ids = [row['record_id'] for row in old] additions = manifest['additions'] if (not isinstance(additions, list) or len(additions) != addition_count or not all(matches(RECORD_RE, item) for item in additions) or len(set(additions)) != addition_count or any(item in old_ids for item in additions)): errors.append('additions must declare exactly two new unique record IDs' if label == F_LABEL else 'additions must declare exactly one new unique record ID'); continue members = manifest['members'] members_by_id = unique_index(members, 'record_id', errors, 'members') if not isinstance(members, list) or any(not isinstance(m, dict) for m in members): errors.append('members must be objects'); continue for field in ('file_path', 'sha256'): unique_index(members, field, errors, 'members') bound_xet = [m.get('hub_xet_hash') for m in members if isinstance(m.get('hub_xet_hash'), str)] if len(bound_xet) != len(set(bound_xet)): errors.append('members contain duplicate Xet identities') expected_ids = old_ids[:3] + additions + old_ids[3:] if [m.get('record_id') for m in members] != expected_ids: errors.append('members must preserve all nine predecessor objects in order and insert only Rec03a/Rec03b after Rec03' if label == F_LABEL else 'members must preserve all seven predecessor objects in order and insert only Rec03a after Rec03') for old_member in old: member = members_by_id.get(old_member['record_id'], {}) for field in MEMBER_KEYS - {'sequence_position'}: expected = int(old_member[field]) if field == 'size_bytes' else old_member[field] if member.get(field) != expected: errors.append(f"{old_member['record_id']}: predecessor {field} changed or missing") for record_id, suffix in zip(additions, suffixes): if members_by_id.get(record_id, {}).get('file_path') != f'Standard_Time_Lapses/{label}.Rec{suffix}.mp4': errors.append('unregistered insertion suffix or path') for position, member in enumerate(members, 1): record_id = member.get('record_id') if set(member) != MEMBER_KEYS: errors.append('invalid member field contract') if not matches(RECORD_RE, record_id): errors.append('invalid member record_id'); continue if type(member.get('sequence_position')) is not int or member['sequence_position'] != position: errors.append(f'{record_id}: sequence_position differs from explicit order') if not positive_int(member.get('size_bytes')) or not matches(HASH_RE, member.get('sha256')): errors.append(f'{record_id}: invalid size or SHA-256') pending = prepublication and record_id in additions and member.get('hub_xet_hash') is None if not pending and not matches(HASH_RE, member.get('hub_xet_hash')): errors.append(f'{record_id}: invalid or unbound Xet identity') row = by_id.get(record_id, {}) expected_metadata = {'file_name': member.get('file_path'), 'hub_xet_hash': '' if pending else member.get('hub_xet_hash'), 'size_bytes': str(member.get('size_bytes')), 'date': finish_date, 'time': finish_time, 'work_id': '', 'acquisition_protocol_version': 'standard-2026-08-27'} for field, expected in expected_metadata.items(): if field not in row or row[field] != expected: errors.append(f'{record_id}: metadata {field} differs from registered sequence') registered_ids.update(additions) if bind_inventory and not prepublication and isinstance(inventory, dict): if inventory_bundle is None: validate_inventory(inventory, revision, metadata, members, errors) result['inventory_binding_checked'] = True else: source = inventory_bundle.get(revision) if source is None: errors.append('inventory bundle missing declared source_hub_revision') else: receipt, snapshot = source validate_inventory(receipt, revision, snapshot, members, errors) if current_inventory is not None: validate_inventory(current_inventory, current_inventory['sha'], metadata, members, errors) if source is not None and current_inventory is not None: result['inventory_binding_checked'] = True sequences.append(manifest) for row in metadata_rows: if LETTERED_RE.search(row.get('file_name', '')) and row.get('record_id') not in registered_ids: errors.append(f"{row.get('record_id')}: unregistered lettered Rec suffix") except (OSError, ValueError, TypeError, KeyError, UnicodeError) as exc: errors.append(f'unable to validate sequence insertions: {exc}') if errors: result['sequences'] = [] return result def validate_inventory(inventory, revision, metadata, members, errors): if inventory.get('sha') != revision: errors.append('inventory commit differs from source_hub_revision') files = inventory.get('validationFiles') receipt = files.get('metadata.csv') if isinstance(files, dict) else None data = metadata.read_bytes() if (not isinstance(receipt, dict) or receipt.get('repoCommit') != revision or receipt.get('sha256') != hashlib.sha256(data).hexdigest() or type(receipt.get('size')) is not int or receipt['size'] != len(data)): errors.append('metadata.csv is not bound to exact pinned repository bytes') siblings = unique_index(inventory.get('siblings'), 'rfilename', errors, 'inventory') for member in members: remote = siblings.get(member.get('file_path'), {}) lfs = remote.get('lfs') if not isinstance(lfs, dict): lfs = {} if (type(remote.get('size')) is not int or remote['size'] != member.get('size_bytes') or lfs.get('sha256') != member.get('sha256') or remote.get('xetHash') != member.get('hub_xet_hash') or remote.get('repoCommit') != revision): errors.append(f"{member.get('record_id')}: pinned repository media identity differs or is absent") def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--root', type=Path, default=Path('.')) parser.add_argument('--metadata', type=Path, required=True) parser.add_argument('--repo-inventory-json', type=Path) parser.add_argument('--prepublication', action='store_true', help='local-only preparation; never publishable validation') args = parser.parse_args() try: inventory = read_json(args.repo_inventory_json) if args.repo_inventory_json else None result = validate_insertions(args.root, args.metadata, inventory=inventory, prepublication=args.prepublication) except (OSError, ValueError, UnicodeError) as exc: result = {'errors': [f'unable to read inventory: {exc}'], 'sequences': []} print(json.dumps(result, indent=2)) raise SystemExit(bool(result['errors'])) if __name__ == '__main__': main()