Upload 7 files

Upload a short video and run a source-bound atomization route.

This Space demonstrates Video Atomization, Trace-Stack Rehydration, and Data Hologram formation as a Substrate Mesh runtime surface. The uploaded video is not treated as a monolithic compressed payload. Instead, the runtime hashes the source, samples frame atoms, detects scene intervals, records motion deltas, applies trace capsules, stacks the traces, and returns a rehydrated review surface with an HIR × OAM receipt.

The demo shows how video can become a pressure-readable temporal mesh:

source video
→ source capsule
→ frame atoms
→ scene atoms
→ trace capsules
→ stacked trace field
→ data hologram manifest
→ rehydrated review surface
→ human validation capsule

Boundary: this is not video compression, not a replacement for codecs, and not a physical hologram generator. This v0.1 Space demonstrates the source-bound data-hologram layer. Physical hologram translation would require a later optical modulation layer.

Core claim: video does not have to be handled only as a compressed monolithic file. It can be atomized into source-bound trace units, stacked into a data hologram, pressure-read, and rehydrated into a reviewable route surface while preserving source authority and human validation.

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.DS_Store
+.env
+runs/
+tmp/

HF_Substrate_Video_Atomization_Runtime_v0_1.zip.sha256

@@ -0,0 +1 @@
+333da88eb4746d62725df837aef44bd47154a193bcc2005d8e7b498290263094  HF_Substrate_Video_Atomization_Runtime_v0_1.zip

README.md

@@ -1,15 +1,49 @@
 ---
-title: Video Atomization Trace Stack Runtime
-emoji: 📊
-colorFrom: yellow
-colorTo: green
+title: Substrate Video Atomization Runtime
+emoji: 🎞️
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
 license: cc-by-nc-sa-4.0
 short_description: Video atomization and trace-stack rehydration
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Substrate Video Atomization Runtime v0.1
+
+Upload a short video and run a source-bound atomization route.
+
+This Space demonstrates Video Atomization, Trace-Stack Rehydration, and Data Hologram formation as a Substrate Mesh runtime surface. The uploaded video is not treated as a monolithic compressed payload. Instead, the runtime hashes the source, samples frame atoms, detects scene intervals, records motion deltas, applies trace capsules, stacks the traces, and returns a rehydrated review surface with an HIR × OAM receipt.
+
+The demo shows how video can become a pressure-readable temporal mesh:
+
+```text
+source video
+→ source capsule
+→ frame atoms
+→ scene atoms
+→ trace capsules
+→ stacked trace field
+→ data hologram manifest
+→ rehydrated review surface
+→ human validation capsule
+```
+
+## Boundary
+
+This is not video compression, not a replacement for codecs, and not a physical hologram generator. This v0.1 Space demonstrates the source-bound data-hologram layer. Physical hologram translation would require a later optical modulation layer.
+
+## What the demo proves
+
+- The source video is hashed and held as the canonical anchor.
+- The video is atomized into source-bound frame and scene atoms.
+- Each sampled atom receives a trace capsule.
+- Trace capsules are stacked into a data-hologram manifest.
+- The rehydrated output remains a review surface, not a source replacement.
+- Human validation remains required before settlement.
+
+## Core claim
+
+Video does not have to be handled only as a compressed monolithic file. It can be atomized into source-bound trace units, stacked into a data hologram, pressure-read, and rehydrated into a reviewable route surface.

app.py

@@ -0,0 +1,521 @@
+import os
+import cv2
+import json
+import hashlib
+import tempfile
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+from PIL import Image
+
+
+APP_TITLE = "Substrate Video Atomization Runtime v0.1"
+BOUNDARY_NOTE = (
+    "This demo performs source-bound video atomization and trace-stack rehydration. "
+    "It is not video compression, not a codec replacement, and not a physical hologram generator. "
+    "The output is a data-hologram review surface with receipts."
+)
+
+
+def sha256_file(path: str) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1024 * 1024), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def sha256_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def format_time(seconds: float) -> str:
+    if seconds is None:
+        seconds = 0.0
+    seconds = max(float(seconds), 0.0)
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = seconds % 60
+    return f"{h:02d}:{m:02d}:{s:06.3f}"
+
+
+def safe_float(value, default=0.0):
+    try:
+        if value is None:
+            return default
+        return float(value)
+    except Exception:
+        return default
+
+
+def safe_int(value, default=0):
+    try:
+        if value is None:
+            return default
+        return int(value)
+    except Exception:
+        return default
+
+
+def write_json(path: Path, obj) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(obj, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def make_run_dir() -> Path:
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    return Path(tempfile.mkdtemp(prefix=f"video_atomization_{stamp}_"))
+
+
+def classify_pressure(motion_delta: float, scene_threshold: float) -> str:
+    if motion_delta >= scene_threshold * 1.6:
+        return "STRAINED_SCENE_BREAK_PRESSURE"
+    if motion_delta >= scene_threshold:
+        return "HELD_WITH_SCENE_BOUNDARY"
+    return "HELD"
+
+
+def build_markdown_receipt(receipt: dict, source_capsule: dict, trace_stack: dict) -> str:
+    lines = [
+        "# HIR × OAM Video Atomization Receipt",
+        "",
+        f"- Receipt type: `{receipt['receipt_type']}`",
+        f"- Route state: `{receipt['pressure_state']}`",
+        f"- Source mutation: `{receipt['source_mutation']}`",
+        f"- Canonical anchor: `{receipt['canonical_anchor']}`",
+        f"- Atomization state: `{receipt['atomization_state']}`",
+        f"- Trace-stack state: `{receipt['trace_stack_state']}`",
+        f"- Data-hologram state: `{receipt['data_hologram_state']}`",
+        f"- Human review: `{receipt['human_review']}`",
+        "",
+        "## Source",
+        "",
+        f"- Filename: `{source_capsule.get('filename')}`",
+        f"- SHA-256: `{source_capsule.get('sha256')}`",
+        f"- Duration: `{source_capsule.get('duration_seconds')}` seconds",
+        f"- FPS: `{source_capsule.get('fps')}`",
+        f"- Frame count: `{source_capsule.get('frame_count')}`",
+        "",
+        "## Boundary",
+        "",
+        BOUNDARY_NOTE,
+        "",
+        "## Trace stack layers",
+        "",
+    ]
+    for layer in trace_stack.get("stack_layers", []):
+        lines.append(f"- `{layer}`")
+    lines.extend([
+        "",
+        "## Settlement",
+        "",
+        "Machine route surface only. Human retains settlement authority.",
+    ])
+    return "\n".join(lines)
+
+
+def create_run_packet(run_dir: Path, packet_name: str = "video_atomization_run_packet.zip") -> str:
+    packet_path = run_dir / packet_name
+    with zipfile.ZipFile(packet_path, "w", compression=zipfile.ZIP_DEFLATED) as z:
+        for path in run_dir.rglob("*"):
+            if path == packet_path or path.is_dir():
+                continue
+            z.write(path, path.relative_to(run_dir))
+    return str(packet_path)
+
+
+def atomize_video(video_path, sample_every_seconds=1.0, scene_threshold=32.0, max_frame_atoms=72):
+    if not video_path:
+        empty = pd.DataFrame()
+        return (
+            None,
+            {"error": "No video uploaded."},
+            empty,
+            empty,
+            {"error": "No trace stack generated."},
+            {"error": "No receipt generated."},
+            {"human_validation_state": "NOT_AVAILABLE"},
+            [],
+            None,
+            "Upload a video and run the route."
+        )
+
+    run_dir = make_run_dir()
+    frames_dir = run_dir / "frame_atoms"
+    manifests_dir = run_dir / "manifests"
+    receipts_dir = run_dir / "receipts"
+    frames_dir.mkdir(parents=True, exist_ok=True)
+    manifests_dir.mkdir(parents=True, exist_ok=True)
+    receipts_dir.mkdir(parents=True, exist_ok=True)
+
+    sample_every_seconds = max(safe_float(sample_every_seconds, 1.0), 0.1)
+    scene_threshold = max(safe_float(scene_threshold, 32.0), 1.0)
+    max_frame_atoms = max(safe_int(max_frame_atoms, 72), 1)
+
+    source_hash = sha256_file(video_path)
+    file_size = os.path.getsize(video_path)
+    filename = os.path.basename(video_path)
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        empty = pd.DataFrame()
+        return (
+            video_path,
+            {"error": "OpenCV could not read this video. Try MP4/H.264, WebM, or MOV."},
+            empty,
+            empty,
+            {"error": "No trace stack generated."},
+            {"error": "No receipt generated."},
+            {"human_validation_state": "NOT_AVAILABLE"},
+            [],
+            None,
+            "Could not read the video file."
+        )
+
+    fps = safe_float(cap.get(cv2.CAP_PROP_FPS), 0.0)
+    frame_count = safe_int(cap.get(cv2.CAP_PROP_FRAME_COUNT), 0)
+    width = safe_int(cap.get(cv2.CAP_PROP_FRAME_WIDTH), 0)
+    height = safe_int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT), 0)
+    duration = frame_count / fps if fps else 0.0
+
+    source_capsule = {
+        "capsule_type": "SOURCE_VIDEO_CAPSULE",
+        "source_id": "video_source_001",
+        "filename": filename,
+        "sha256": source_hash,
+        "size_bytes": file_size,
+        "width": width,
+        "height": height,
+        "fps": round(fps, 6),
+        "frame_count": frame_count,
+        "duration_seconds": round(duration, 6),
+        "route_state": "SOURCE_HASHED",
+        "source_mutation": "BLOCKED",
+        "canonical_anchor": "SOURCE_VIDEO_REMAINS_AUTHORITY",
+        "boundary": BOUNDARY_NOTE,
+    }
+
+    frame_atoms = []
+    scene_atoms = []
+    motion_atoms = []
+    gallery_items = []
+
+    sample_interval = max(int(round(fps * sample_every_seconds)), 1) if fps else 30
+    previous_gray = None
+    current_scene_start = 0.0
+    scene_index = 0
+    atom_index = 0
+    frame_idx = 0
+
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+
+        timestamp = frame_idx / fps if fps else 0.0
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+        motion_delta = 0.0
+        pressure_state = "HELD"
+        if previous_gray is not None:
+            diff = cv2.absdiff(gray, previous_gray)
+            motion_delta = float(diff.mean())
+            pressure_state = classify_pressure(motion_delta, scene_threshold)
+
+            motion_atoms.append({
+                "motion_atom_id": f"motion_atom_{frame_idx:06d}",
+                "frame_index": frame_idx,
+                "time": format_time(timestamp),
+                "source_video_sha256": source_hash,
+                "motion_delta": round(motion_delta, 6),
+                "pressure_state": pressure_state
+            })
+
+            if motion_delta >= scene_threshold:
+                scene_atoms.append({
+                    "scene_id": f"scene_atom_{scene_index:06d}",
+                    "time_start": format_time(current_scene_start),
+                    "time_end": format_time(timestamp),
+                    "source_video_sha256": source_hash,
+                    "scene_boundary_reason": f"motion_delta {motion_delta:.3f} >= threshold {scene_threshold:.3f}",
+                    "pressure_state": "HELD_WITH_BOUNDARY",
+                    "claim_boundary": "scene interval only; does not support identity, intent, or external-context claim",
+                    "rehydration_state": "ELIGIBLE_SOURCE_BOUND",
+                    "human_review": "REQUIRED_BEFORE_PUBLIC_CLAIM"
+                })
+                scene_index += 1
+                current_scene_start = timestamp
+
+        should_sample = frame_idx % sample_interval == 0 and atom_index < max_frame_atoms
+        if should_sample:
+            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            img = Image.fromarray(rgb)
+
+            frame_name = f"frame_atom_{atom_index:06d}.jpg"
+            img_path = frames_dir / frame_name
+            img.save(img_path, quality=90)
+
+            local_hash = sha256_file(str(img_path))
+            atom = {
+                "atom_id": f"frame_atom_{atom_index:06d}",
+                "atom_type": "frame",
+                "frame_index": frame_idx,
+                "time_start": format_time(timestamp),
+                "time_end": format_time(timestamp + (1.0 / fps if fps else 0.0)),
+                "source_video_sha256": source_hash,
+                "local_hash": local_hash,
+                "sample_path": f"frame_atoms/{frame_name}",
+                "motion_delta": round(motion_delta, 6),
+                "claim_boundary": "sampled frame only; does not support full-scene, identity, intent, or external-context claim",
+                "pressure_state": pressure_state,
+                "trace_capsule_state": "CAPSULED_SOURCE_BOUND",
+                "rehydration_state": "ELIGIBLE_SOURCE_BOUND",
+                "human_review": "REQUIRED_BEFORE_PUBLIC_CLAIM"
+            }
+            frame_atoms.append(atom)
+            gallery_items.append((str(img_path), atom["atom_id"]))
+            atom_index += 1
+
+        previous_gray = gray
+        frame_idx += 1
+
+    cap.release()
+
+    if duration > current_scene_start or not scene_atoms:
+        scene_atoms.append({
+            "scene_id": f"scene_atom_{scene_index:06d}",
+            "time_start": format_time(current_scene_start),
+            "time_end": format_time(duration),
+            "source_video_sha256": source_hash,
+            "scene_boundary_reason": "final interval closure",
+            "pressure_state": "HELD",
+            "claim_boundary": "scene interval only; does not support identity, intent, or external-context claim",
+            "rehydration_state": "ELIGIBLE_SOURCE_BOUND",
+            "human_review": "REQUIRED_BEFORE_PUBLIC_CLAIM"
+        })
+
+    atom_manifest = {
+        "manifest_type": "VIDEO_ATOM_MANIFEST",
+        "source_video_sha256": source_hash,
+        "atom_counts": {
+            "frame_atoms": len(frame_atoms),
+            "scene_atoms": len(scene_atoms),
+            "motion_atoms": len(motion_atoms),
+        },
+        "sampling": {
+            "sample_every_seconds": sample_every_seconds,
+            "sample_interval_frames": sample_interval,
+            "max_frame_atoms": max_frame_atoms,
+            "scene_threshold": scene_threshold,
+        },
+        "frame_atoms": frame_atoms,
+        "scene_atoms": scene_atoms,
+        "motion_atoms_summary": {
+            "count": len(motion_atoms),
+            "note": "Full motion atom list is included as motion_atoms.json in the run packet."
+        }
+    }
+
+    trace_stack = {
+        "manifest_type": "TRACE_STACK_DATA_HOLOGRAM_MANIFEST",
+        "trace_stack_id": "trace_stack_001",
+        "source_video_sha256": source_hash,
+        "stack_layers": [
+            "source_capsule",
+            "frame_trace_capsules",
+            "scene_trace_capsules",
+            "motion_delta_atoms",
+            "claim_boundaries",
+            "pressure_states",
+            "rehydration_states",
+            "human_validation_state"
+        ],
+        "data_hologram_state": "FORMED",
+        "rehydration_state": "REHYDRATED_SOURCE_BOUND_REVIEW_SURFACE",
+        "optical_hologram_state": "NOT_GENERATED_IN_THIS_DEMO",
+        "source_mutation": "BLOCKED",
+        "canonical_anchor": "SOURCE_VIDEO_REMAINS_AUTHORITY",
+        "boundary": "Data hologram only. Physical hologram translation requires a later optical modulation layer."
+    }
+
+    receipt = {
+        "receipt_type": "HIR_OAM_VIDEO_ATOMIZATION_RECEIPT",
+        "generated_utc": datetime.now(timezone.utc).isoformat(),
+        "source_held": True,
+        "source_mutation": "BLOCKED",
+        "atomization_state": "ATOMIZED_SOURCE_BOUND",
+        "trace_capsule_state": "CAPSULED_PER_ATOM",
+        "trace_stack_state": "STACKED",
+        "data_hologram_state": "FORMED",
+        "rehydration_state": "REHYDRATED_REVIEW_SURFACE",
+        "pressure_state": "HELD_WITH_BOUNDARY",
+        "human_review": "REQUIRED",
+        "canonical_anchor": "SOURCE_VIDEO_REMAINS_AUTHORITY",
+        "claims_blocked": [
+            "not a codec",
+            "not monolithic compression",
+            "not a physical hologram generator",
+            "not source replacement",
+            "not automatic settlement"
+        ]
+    }
+
+    human_validation = {
+        "capsule_type": "HUMAN_VALIDATION_CAPSULE",
+        "human_validation_state": "REQUIRED",
+        "machine_route_surface": "GENERATED",
+        "settlement_authority": "HUMAN",
+        "available_actions": [
+            "APPROVE",
+            "REJECT",
+            "DEFER",
+            "REPAIR",
+            "FORK",
+            "QUARANTINE",
+            "REQUEST_MORE_ATOMS"
+        ],
+        "settlement_note": "Machine generated route surface only. Human retains settlement authority."
+    }
+
+    write_json(manifests_dir / "source_video_capsule.json", source_capsule)
+    write_json(manifests_dir / "atom_manifest.json", atom_manifest)
+    write_json(manifests_dir / "trace_stack_data_hologram_manifest.json", trace_stack)
+    write_json(manifests_dir / "motion_atoms.json", motion_atoms)
+    write_json(receipts_dir / "hir_oam_video_atomization_receipt.json", receipt)
+    write_json(receipts_dir / "human_validation_capsule.json", human_validation)
+    (receipts_dir / "HIR_OAM_VIDEO_RECEIPT.md").write_text(
+        build_markdown_receipt(receipt, source_capsule, trace_stack),
+        encoding="utf-8"
+    )
+
+    frame_df = pd.DataFrame(frame_atoms)
+    scene_df = pd.DataFrame(scene_atoms)
+
+    packet_path = create_run_packet(run_dir)
+
+    summary = (
+        f"Route complete. Source held. {len(frame_atoms)} frame atoms, "
+        f"{len(scene_atoms)} scene atoms, {len(motion_atoms)} motion atoms. "
+        "Trace stack formed. Data hologram review surface generated. Human validation required."
+    )
+
+    return (
+        video_path,
+        source_capsule,
+        frame_df,
+        scene_df,
+        trace_stack,
+        receipt,
+        human_validation,
+        gallery_items,
+        packet_path,
+        summary
+    )
+
+
+custom_css = """
+.gradio-container { max-width: 1280px !important; }
+#receipt_summary textarea { font-size: 1.05rem; }
+"""
+
+with gr.Blocks(title=APP_TITLE, css=custom_css) as demo:
+    gr.Markdown(
+        """
+# Substrate Video Atomization Runtime v0.1
+
+Upload a short video and run a source-bound atomization route.
+
+This Space hashes the source video, samples frame atoms, detects scene intervals, records motion-delta pressure,
+applies trace capsules, stacks the traces into a data-hologram manifest, and returns an HIR × OAM receipt.
+
+**Boundary:** this is not video compression, not a codec replacement, and not a physical hologram generator.
+This v0.1 Space demonstrates the source-bound data-hologram layer.
+        """
+    )
+
+    with gr.Row():
+        video_input = gr.Video(
+            label="Upload source video",
+            sources=["upload"],
+            type="filepath"
+        )
+        video_output = gr.Video(label="Source video preview")
+
+    with gr.Row():
+        sample_every_seconds = gr.Slider(
+            minimum=0.25,
+            maximum=5.0,
+            value=1.0,
+            step=0.25,
+            label="Sample every N seconds"
+        )
+        scene_threshold = gr.Slider(
+            minimum=5.0,
+            maximum=90.0,
+            value=32.0,
+            step=1.0,
+            label="Scene boundary motion threshold"
+        )
+        max_frame_atoms = gr.Slider(
+            minimum=4,
+            maximum=160,
+            value=72,
+            step=4,
+            label="Maximum frame atoms"
+        )
+
+    run_btn = gr.Button("Run Video Atomization Route", variant="primary")
+
+    route_summary = gr.Textbox(
+        label="Route Summary",
+        elem_id="receipt_summary",
+        interactive=False
+    )
+
+    with gr.Tabs():
+        with gr.Tab("Source Capsule"):
+            source_json = gr.JSON(label="Source Video Capsule")
+
+        with gr.Tab("Frame Atoms"):
+            frame_table = gr.Dataframe(label="Frame Trace Capsules", wrap=True)
+
+        with gr.Tab("Scene Atoms"):
+            scene_table = gr.Dataframe(label="Scene Trace Capsules", wrap=True)
+
+        with gr.Tab("Trace Stack / Data Hologram"):
+            trace_json = gr.JSON(label="Stacked Trace Field")
+
+        with gr.Tab("HIR × OAM Receipt"):
+            receipt_json = gr.JSON(label="Route Receipt")
+
+        with gr.Tab("Human Validation"):
+            validation_json = gr.JSON(label="Human Validation Capsule")
+
+        with gr.Tab("Frame Atom Strip"):
+            gallery = gr.Gallery(label="Sampled Frame Atoms", columns=4, height=520)
+
+        with gr.Tab("Download Run Packet"):
+            run_packet = gr.File(label="Download JSON receipts and sampled frame atoms")
+
+    run_btn.click(
+        atomize_video,
+        inputs=[video_input, sample_every_seconds, scene_threshold, max_frame_atoms],
+        outputs=[
+            video_output,
+            source_json,
+            frame_table,
+            scene_table,
+            trace_json,
+            receipt_json,
+            validation_json,
+            gallery,
+            run_packet,
+            route_summary
+        ]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

demo_contract.json

@@ -0,0 +1,27 @@
+{
+  "contract_type": "SUBSTRATE_VIDEO_ATOMIZATION_RUNTIME_CONTRACT",
+  "version": "0.1",
+  "route": [
+    "source_video_upload",
+    "source_hash",
+    "frame_atom_sampling",
+    "scene_interval_detection",
+    "motion_delta_pressure_read",
+    "trace_capsule_assignment",
+    "trace_stack_manifest",
+    "data_hologram_manifest",
+    "rehydrated_review_surface",
+    "hir_oam_receipt",
+    "human_validation_capsule"
+  ],
+  "not_claims": [
+    "not video compression",
+    "not a codec replacement",
+    "not an optical hologram generator",
+    "not source replacement",
+    "not automatic settlement"
+  ],
+  "canonical_anchor_rule": "SOURCE_VIDEO_REMAINS_AUTHORITY",
+  "source_mutation": "BLOCKED",
+  "human_validation": "REQUIRED"
+}

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.44.0
+opencv-python-headless
+numpy
+pandas
+pillow