@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-7VPUC62U.js

@@ -0,0 +1,1106 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/hologram/index.ts
+var hologram_exports = {};
+__export(hologram_exports, {
+  DepthEstimationService: () => DepthEstimationService,
+  GIFDecomposer: () => GIFDecomposer,
+  GIFDisposalMethod: () => GIFDisposalMethod,
+  MVHEVCCompiler: () => MVHEVCCompiler,
+  ModelCache: () => ModelCache,
+  QuiltCompiler: () => QuiltCompiler,
+  TemporalSmoother: () => TemporalSmoother,
+  WebCodecsDepthPipeline: () => WebCodecsDepthPipeline,
+  depthToNormalMap: () => depthToNormalMap,
+  detectBestBackend: () => detectBestBackend
+});
+
+// src/hologram/DepthEstimationService.ts
+var DEFAULT_MODEL_ID = "depth-anything/Depth-Anything-V2-Small-hf";
+var DEFAULT_MAX_RESOLUTION = 512;
+var DEFAULT_TEMPORAL_ALPHA = 0.8;
+var CACHE_DB_NAME = "holoscript-ml-models";
+var CACHE_STORE_NAME = "depth-models";
+async function detectBestBackend() {
+  if (typeof navigator !== "undefined" && "gpu" in navigator) {
+    try {
+      const adapter = await navigator.gpu.requestAdapter();
+      if (adapter) return "webgpu";
+    } catch {
+    }
+  }
+  if (typeof WebAssembly !== "undefined") {
+    return "wasm";
+  }
+  return "cpu";
+}
+function depthToNormalMap(depthMap, width, height) {
+  const normalMap = new Float32Array(width * height * 3);
+  for (let y = 1; y < height - 1; y++) {
+    for (let x = 1; x < width - 1; x++) {
+      const tl = depthMap[(y - 1) * width + (x - 1)];
+      const t = depthMap[(y - 1) * width + x];
+      const tr = depthMap[(y - 1) * width + (x + 1)];
+      const l = depthMap[y * width + (x - 1)];
+      const r = depthMap[y * width + (x + 1)];
+      const bl = depthMap[(y + 1) * width + (x - 1)];
+      const b = depthMap[(y + 1) * width + x];
+      const br = depthMap[(y + 1) * width + (x + 1)];
+      const dx = tr + 2 * r + br - (tl + 2 * l + bl);
+      const dy = bl + 2 * b + br - (tl + 2 * t + tr);
+      const dz = 1;
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      const idx = (y * width + x) * 3;
+      normalMap[idx] = dx / len * 0.5 + 0.5;
+      normalMap[idx + 1] = dy / len * 0.5 + 0.5;
+      normalMap[idx + 2] = dz / len * 0.5 + 0.5;
+    }
+  }
+  for (let x = 0; x < width; x++) {
+    const topIdx = x * 3;
+    const botIdx = ((height - 1) * width + x) * 3;
+    normalMap[topIdx] = 0.5;
+    normalMap[topIdx + 1] = 0.5;
+    normalMap[topIdx + 2] = 1;
+    normalMap[botIdx] = 0.5;
+    normalMap[botIdx + 1] = 0.5;
+    normalMap[botIdx + 2] = 1;
+  }
+  for (let y = 0; y < height; y++) {
+    const leftIdx = y * width * 3;
+    const rightIdx = (y * width + width - 1) * 3;
+    normalMap[leftIdx] = 0.5;
+    normalMap[leftIdx + 1] = 0.5;
+    normalMap[leftIdx + 2] = 1;
+    normalMap[rightIdx] = 0.5;
+    normalMap[rightIdx + 1] = 0.5;
+    normalMap[rightIdx + 2] = 1;
+  }
+  return normalMap;
+}
+var ModelCache = class {
+  db = null;
+  async open() {
+    if (this.db) return;
+    if (typeof indexedDB === "undefined") return;
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(CACHE_DB_NAME, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(CACHE_STORE_NAME)) {
+          db.createObjectStore(CACHE_STORE_NAME);
+        }
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve();
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async get(key) {
+    if (!this.db) return null;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(CACHE_STORE_NAME, "readonly");
+      const store = tx.objectStore(CACHE_STORE_NAME);
+      const request = store.get(key);
+      request.onsuccess = () => resolve(request.result ?? null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async set(key, value) {
+    if (!this.db) return;
+    return new Promise((resolve, reject) => {
+      const tx = this.db.transaction(CACHE_STORE_NAME, "readwrite");
+      const store = tx.objectStore(CACHE_STORE_NAME);
+      const request = store.put(value, key);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async has(key) {
+    const value = await this.get(key);
+    return value !== null;
+  }
+  close() {
+    this.db?.close();
+    this.db = null;
+  }
+};
+var TemporalSmoother = class {
+  previousDepth = null;
+  alpha;
+  constructor(alpha = DEFAULT_TEMPORAL_ALPHA) {
+    this.alpha = Math.max(0, Math.min(1, alpha));
+  }
+  /**
+   * Smooth the current depth map against the previous frame.
+   * Returns a new smoothed array (does not mutate input).
+   */
+  smooth(currentDepth) {
+    if (!this.previousDepth || this.previousDepth.length !== currentDepth.length) {
+      this.previousDepth = new Float32Array(currentDepth);
+      return new Float32Array(currentDepth);
+    }
+    const smoothed = new Float32Array(currentDepth.length);
+    for (let i = 0; i < currentDepth.length; i++) {
+      smoothed[i] = this.alpha * currentDepth[i] + (1 - this.alpha) * this.previousDepth[i];
+    }
+    this.previousDepth = new Float32Array(smoothed);
+    return smoothed;
+  }
+  reset() {
+    this.previousDepth = null;
+  }
+};
+var GIFDisposalMethod = /* @__PURE__ */ ((GIFDisposalMethod2) => {
+  GIFDisposalMethod2[GIFDisposalMethod2["Unspecified"] = 0] = "Unspecified";
+  GIFDisposalMethod2[GIFDisposalMethod2["DoNotDispose"] = 1] = "DoNotDispose";
+  GIFDisposalMethod2[GIFDisposalMethod2["RestoreBackground"] = 2] = "RestoreBackground";
+  GIFDisposalMethod2[GIFDisposalMethod2["RestorePrevious"] = 3] = "RestorePrevious";
+  return GIFDisposalMethod2;
+})(GIFDisposalMethod || {});
+var GIFDecomposer = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      maxFrames: config.maxFrames ?? 500,
+      targetWidth: config.targetWidth ?? 0
+    };
+  }
+  /**
+   * Decompose raw GIF frame data into full composited RGBA frames.
+   * Each frame in the input array should have: data (Uint8ClampedArray),
+   * width, height, left, top, disposalMethod, delayMs.
+   */
+  decompose(rawFrames, gifWidth, gifHeight) {
+    const maxFrames = Math.min(rawFrames.length, this.config.maxFrames);
+    const frames = [];
+    let canvas = new Uint8ClampedArray(gifWidth * gifHeight * 4);
+    let previousCanvas = new Uint8ClampedArray(gifWidth * gifHeight * 4);
+    for (let i = 0; i < maxFrames; i++) {
+      const raw = rawFrames[i];
+      const savedCanvas = new Uint8ClampedArray(canvas);
+      for (let y = 0; y < raw.height; y++) {
+        for (let x = 0; x < raw.width; x++) {
+          const srcIdx = (y * raw.width + x) * 4;
+          const dstX = raw.left + x;
+          const dstY = raw.top + y;
+          if (dstX >= gifWidth || dstY >= gifHeight) continue;
+          const dstIdx = (dstY * gifWidth + dstX) * 4;
+          const alpha = raw.data[srcIdx + 3];
+          if (alpha > 0) {
+            canvas[dstIdx] = raw.data[srcIdx];
+            canvas[dstIdx + 1] = raw.data[srcIdx + 1];
+            canvas[dstIdx + 2] = raw.data[srcIdx + 2];
+            canvas[dstIdx + 3] = alpha;
+          }
+        }
+      }
+      frames.push({
+        data: new Uint8ClampedArray(canvas),
+        width: gifWidth,
+        height: gifHeight,
+        delayMs: raw.delayMs || 100,
+        index: i
+      });
+      switch (raw.disposalMethod) {
+        case 2 /* RestoreBackground */:
+          for (let y = 0; y < raw.height; y++) {
+            for (let x = 0; x < raw.width; x++) {
+              const dstX = raw.left + x;
+              const dstY = raw.top + y;
+              if (dstX >= gifWidth || dstY >= gifHeight) continue;
+              const dstIdx = (dstY * gifWidth + dstX) * 4;
+              canvas[dstIdx] = 0;
+              canvas[dstIdx + 1] = 0;
+              canvas[dstIdx + 2] = 0;
+              canvas[dstIdx + 3] = 0;
+            }
+          }
+          break;
+        case 3 /* RestorePrevious */:
+          canvas = new Uint8ClampedArray(previousCanvas);
+          break;
+        case 1 /* DoNotDispose */:
+        case 0 /* Unspecified */:
+        default:
+          break;
+      }
+      previousCanvas = savedCanvas;
+    }
+    return frames;
+  }
+};
+var DepthEstimationService = class _DepthEstimationService {
+  static instance = null;
+  pipeline = null;
+  config;
+  modelCache = new ModelCache();
+  _initialized = false;
+  _initializing = null;
+  _backend = "cpu";
+  constructor(config = {}) {
+    this.config = {
+      modelId: config.modelId ?? DEFAULT_MODEL_ID,
+      backend: config.backend ?? "webgpu",
+      maxResolution: config.maxResolution ?? DEFAULT_MAX_RESOLUTION,
+      enableCache: config.enableCache ?? true,
+      onProgress: config.onProgress ?? (() => {
+      })
+    };
+  }
+  static getInstance(config) {
+    if (!_DepthEstimationService.instance) {
+      _DepthEstimationService.instance = new _DepthEstimationService(config);
+    }
+    return _DepthEstimationService.instance;
+  }
+  static resetInstance() {
+    if (_DepthEstimationService.instance) {
+      _DepthEstimationService.instance.dispose();
+      _DepthEstimationService.instance = null;
+    }
+  }
+  get initialized() {
+    return this._initialized;
+  }
+  get backend() {
+    return this._backend;
+  }
+  /**
+   * Initialize the depth estimation pipeline.
+   * Downloads model on first call, loads from IndexedDB cache on subsequent calls.
+   * Safe to call multiple times — returns cached promise if already initializing.
+   */
+  async initialize(config) {
+    if (this._initialized) return;
+    if (this._initializing) return this._initializing;
+    if (config) {
+      Object.assign(this.config, config);
+    }
+    this._initializing = this._doInitialize();
+    await this._initializing;
+    this._initializing = null;
+  }
+  async _doInitialize() {
+    this._backend = this.config.backend ?? await detectBestBackend();
+    if (this.config.enableCache) {
+      try {
+        await this.modelCache.open();
+      } catch {
+      }
+    }
+    try {
+      let transformers;
+      try {
+        transformers = await import("./transformers.node-4NKAPD5U.js");
+      } catch {
+        this._initialized = true;
+        return;
+      }
+      const { pipeline: createPipeline } = transformers;
+      this.pipeline = await createPipeline("depth-estimation", this.config.modelId, {
+        device: this._backend === "cpu" ? void 0 : this._backend,
+        progress_callback: (progress) => {
+          if (progress?.progress !== void 0) {
+            this.config.onProgress(progress.progress / 100);
+          }
+        }
+      });
+    } catch {
+    }
+    this._initialized = true;
+  }
+  /**
+   * Estimate depth from a single image.
+   * Returns both depth map and derived normal map.
+   *
+   * @param imageData - ImageData, HTMLImageElement, HTMLCanvasElement, or image URL
+   */
+  async estimateDepth(imageData) {
+    if (!this._initialized) {
+      throw new Error("DepthEstimationService not initialized. Call initialize() first.");
+    }
+    const startTime = performance.now();
+    const { width, height, data } = imageData;
+    const scale = Math.min(1, this.config.maxResolution / Math.max(width, height));
+    const outW = Math.round(width * scale);
+    const outH = Math.round(height * scale);
+    let depthMap;
+    if (this.pipeline) {
+      depthMap = await this._runPipelineInference(data, width, height, outW, outH);
+    } else {
+      depthMap = this._generatePlaceholderDepth(data, width, height, outW, outH);
+    }
+    const normalMap = depthToNormalMap(depthMap, outW, outH);
+    const inferenceMs = performance.now() - startTime;
+    return {
+      depthMap,
+      normalMap,
+      width: outW,
+      height: outH,
+      backend: this._backend,
+      inferenceMs
+    };
+  }
+  /**
+   * Estimate depth for a sequence of frames with temporal smoothing.
+   * Maintains coherence across frames via EMA filter.
+   *
+   * @see P.150.01: Temporal Depth Smoothing pattern
+   */
+  async estimateDepthSequence(frames, config) {
+    const alpha = config?.temporalAlpha ?? DEFAULT_TEMPORAL_ALPHA;
+    const smoother = new TemporalSmoother(alpha);
+    const results = [];
+    for (const frame of frames) {
+      const raw = await this.estimateDepth(frame);
+      const smoothedDepth = smoother.smooth(raw.depthMap);
+      const smoothedNormals = depthToNormalMap(smoothedDepth, raw.width, raw.height);
+      results.push({
+        ...raw,
+        depthMap: smoothedDepth,
+        normalMap: smoothedNormals
+      });
+    }
+    return results;
+  }
+  /**
+   * Run real Depth Anything V2 inference via Transformers.js pipeline.
+   * Converts RGBA pixel data to a RawImage, runs the pipeline, and
+   * extracts the depth tensor as a normalized Float32Array.
+   */
+  async _runPipelineInference(data, srcW, srcH, outW, outH) {
+    const input = { data, width: srcW, height: srcH };
+    const output = await this.pipeline(input);
+    const rawDepth = output.predicted_depth?.data ?? output.depth?.data ?? new Float32Array(0);
+    if (rawDepth.length === 0) {
+      return this._generatePlaceholderDepth(data, srcW, srcH, outW, outH);
+    }
+    let minVal = Infinity, maxVal = -Infinity;
+    for (let i = 0; i < rawDepth.length; i++) {
+      if (rawDepth[i] < minVal) minVal = rawDepth[i];
+      if (rawDepth[i] > maxVal) maxVal = rawDepth[i];
+    }
+    const range = maxVal - minVal || 1;
+    const pipelineW = output.predicted_depth?.dims?.[1] ?? output.depth?.width ?? srcW;
+    const pipelineH = output.predicted_depth?.dims?.[0] ?? output.depth?.height ?? srcH;
+    const depthMap = new Float32Array(outW * outH);
+    const scaleX = pipelineW / outW;
+    const scaleY = pipelineH / outH;
+    for (let y = 0; y < outH; y++) {
+      for (let x = 0; x < outW; x++) {
+        const pX = Math.min(Math.floor(x * scaleX), pipelineW - 1);
+        const pY = Math.min(Math.floor(y * scaleY), pipelineH - 1);
+        const val = rawDepth[pY * pipelineW + pX];
+        depthMap[y * outW + x] = (val - minVal) / range;
+      }
+    }
+    return depthMap;
+  }
+  /**
+   * Fallback depth generation using luminance as a proxy.
+   * Used when Transformers.js is not installed or pipeline fails.
+   */
+  _generatePlaceholderDepth(data, srcW, srcH, outW, outH) {
+    const depthMap = new Float32Array(outW * outH);
+    const scaleX = srcW / outW;
+    const scaleY = srcH / outH;
+    for (let y = 0; y < outH; y++) {
+      for (let x = 0; x < outW; x++) {
+        const srcX = Math.floor(x * scaleX);
+        const srcY = Math.floor(y * scaleY);
+        const srcIdx = (srcY * srcW + srcX) * 4;
+        const r = data[srcIdx] / 255;
+        const g = data[srcIdx + 1] / 255;
+        const b = data[srcIdx + 2] / 255;
+        const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+        depthMap[y * outW + x] = 1 - luminance;
+      }
+    }
+    return depthMap;
+  }
+  dispose() {
+    this.pipeline = null;
+    this._initialized = false;
+    this._initializing = null;
+    this.modelCache.close();
+  }
+};
+
+// src/hologram/QuiltCompiler.ts
+var DEVICE_PRESETS = {
+  go: {
+    views: 48,
+    columns: 8,
+    rows: 6,
+    resolution: [3360, 3360],
+    baseline: 0.04
+  },
+  "16inch": {
+    views: 48,
+    columns: 8,
+    rows: 6,
+    resolution: [3360, 3360],
+    baseline: 0.06
+  },
+  "27inch": {
+    views: 48,
+    columns: 8,
+    rows: 6,
+    resolution: [4096, 4096],
+    baseline: 0.08
+  },
+  "65inch": {
+    views: 100,
+    columns: 10,
+    rows: 10,
+    resolution: [8192, 8192],
+    baseline: 0.1
+  }
+};
+var DEFAULT_CONFIG = {
+  views: 48,
+  columns: 8,
+  rows: 6,
+  resolution: [3360, 3360],
+  baseline: 0.06,
+  device: "16inch",
+  focusDistance: 2
+};
+var QuiltCompiler = class {
+  compile(composition, agentToken, outputPath) {
+    void agentToken;
+    void outputPath;
+    const quiltResult = this.compileQuilt(composition);
+    return quiltResult.rendererCode;
+  }
+  /**
+   * Compile a HoloComposition to full quilt output with tile parameters.
+   */
+  compileQuilt(composition, overrides) {
+    const config = this.resolveConfig(composition, overrides);
+    const tiles = this.generateTiles(config);
+    const rendererCode = this.generateRendererCode(composition, config, tiles);
+    const tileWidth = Math.floor(config.resolution[0] / config.columns);
+    const tileHeight = Math.floor(config.resolution[1] / config.rows);
+    return {
+      config,
+      tiles,
+      rendererCode,
+      metadata: {
+        quiltAspect: config.resolution[0] / config.resolution[1],
+        tileWidth,
+        tileHeight,
+        numViews: config.views
+      }
+    };
+  }
+  /**
+   * Resolve quilt configuration from composition @quilt trait and device presets.
+   */
+  resolveConfig(composition, overrides) {
+    let config = { ...DEFAULT_CONFIG };
+    for (const obj of composition.objects) {
+      const quiltTrait = obj.traits?.find((t) => t.name === "quilt");
+      if (quiltTrait?.config) {
+        const p = quiltTrait.config;
+        if (typeof p["views"] === "number") config.views = p["views"];
+        if (typeof p["columns"] === "number") config.columns = p["columns"];
+        if (typeof p["rows"] === "number") config.rows = p["rows"];
+        if (Array.isArray(p["resolution"])) config.resolution = p["resolution"];
+        if (typeof p["baseline"] === "number") config.baseline = p["baseline"];
+        if (typeof p["device"] === "string" && p["device"] in DEVICE_PRESETS) {
+          config = {
+            ...config,
+            ...DEVICE_PRESETS[p["device"]],
+            device: p["device"]
+          };
+        }
+      }
+      const lgTrait = obj.traits?.find((t) => t.name === "looking_glass");
+      if (lgTrait?.config) {
+        const device = lgTrait.config["device"];
+        if (device && device in DEVICE_PRESETS) {
+          config = {
+            ...config,
+            ...DEVICE_PRESETS[device],
+            device
+          };
+        }
+      }
+    }
+    if (overrides) {
+      Object.assign(config, overrides);
+    }
+    return config;
+  }
+  /**
+   * Generate tile parameters for the camera rig.
+   * Uses view shearing (asymmetric frustum) instead of camera rotation
+   * to prevent toe-in artifacts.
+   *
+   * @see P.151.01: Multi-View Camera Rig pattern
+   */
+  generateTiles(config) {
+    const tiles = [];
+    const halfBaseline = config.baseline / 2;
+    for (let i = 0; i < config.views; i++) {
+      const t = config.views > 1 ? i / (config.views - 1) : 0.5;
+      const cameraOffset = -halfBaseline + t * config.baseline;
+      const viewShear = -cameraOffset / config.focusDistance;
+      tiles.push({
+        index: i,
+        column: i % config.columns,
+        row: Math.floor(i / config.columns),
+        cameraOffset,
+        viewShear
+      });
+    }
+    return tiles;
+  }
+  /**
+   * Generate R3F/Three.js renderer code for the quilt camera rig.
+   */
+  generateRendererCode(composition, config, tiles) {
+    const tileW = Math.floor(config.resolution[0] / config.columns);
+    const tileH = Math.floor(config.resolution[1] / config.rows);
+    const sceneObjects = composition.objects.map((obj) => this.objectToJSX(obj)).join("\n      ");
+    return `// QuiltCompiler output \u2014 ${config.views} views for ${config.device} Looking Glass
+// Tile grid: ${config.columns}x${config.rows} @ ${tileW}x${tileH}px each
+// Total resolution: ${config.resolution[0]}x${config.resolution[1]}
+
+import { useRef, useMemo } from 'react';
+import { Canvas, useThree, useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+
+const QUILT_CONFIG = ${JSON.stringify(config, null, 2)};
+
+const TILES = ${JSON.stringify(
+      tiles.map((t) => ({
+        index: t.index,
+        col: t.column,
+        row: t.row,
+        offset: Math.round(t.cameraOffset * 1e4) / 1e4,
+        shear: Math.round(t.viewShear * 1e4) / 1e4
+      })),
+      null,
+      2
+    )};
+
+function QuiltCamera({ tileIndex, children }) {
+  const { gl, size } = useThree();
+  const cameraRef = useRef();
+  const tile = TILES[tileIndex];
+
+  useFrame(() => {
+    if (!cameraRef.current) return;
+    const cam = cameraRef.current;
+    cam.position.x = tile.offset;
+    cam.projectionMatrix.elements[8] = tile.shear;
+    cam.updateProjectionMatrix();
+  });
+
+  return (
+    <perspectiveCamera ref={cameraRef} fov={14} near={0.1} far={100}>
+      {children}
+    </perspectiveCamera>
+  );
+}
+
+function QuiltScene() {
+  return (
+    <group>
+      ${sceneObjects}
+    </group>
+  );
+}
+
+export function QuiltRenderer() {
+  const tileW = ${tileW};
+  const tileH = ${tileH};
+  const renderTarget = useMemo(() =>
+    new THREE.WebGLRenderTarget(${config.resolution[0]}, ${config.resolution[1]}),
+    []
+  );
+
+  return (
+    <Canvas gl={{ preserveDrawingBuffer: true }}>
+      <QuiltScene />
+    </Canvas>
+  );
+}
+`;
+  }
+  /**
+   * Convert a HoloScript object to JSX for the quilt scene.
+   */
+  objectToJSX(obj) {
+    const getProp = (key) => obj.properties.find((p) => p.key === key)?.value;
+    const pos = getProp("position");
+    const rot = getProp("rotation");
+    const scale = getProp("scale");
+    const color = getProp("color") ?? "#888888";
+    const geo = getProp("geometry") ?? "box";
+    const posStr = Array.isArray(pos) ? `[${pos.join(", ")}]` : "[0, 0, 0]";
+    const rotStr = Array.isArray(rot) ? `[${rot.map((r) => Number(r) * Math.PI / 180).join(", ")}]` : void 0;
+    const scaleStr = Array.isArray(scale) ? `[${scale.join(", ")}]` : void 0;
+    const geoMap = {
+      box: "boxGeometry",
+      sphere: "sphereGeometry",
+      cylinder: "cylinderGeometry",
+      torus: "torusGeometry",
+      plane: "planeGeometry"
+    };
+    const geoTag = geoMap[geo] ?? "boxGeometry";
+    return `<mesh position={${posStr}}${rotStr ? ` rotation={${rotStr}}` : ""}${scaleStr ? ` scale={${scaleStr}}` : ""}>
+        <${geoTag} />
+        <meshStandardMaterial color="${color}" />
+      </mesh>`;
+  }
+};
+
+// src/hologram/MVHEVCCompiler.ts
+var DEFAULT_CONFIG2 = {
+  ipd: 0.065,
+  resolution: [1920, 1080],
+  fps: 30,
+  convergenceDistance: 2,
+  fovDegrees: 90,
+  quality: "high",
+  container: "mov",
+  disparityScale: 1
+};
+var QUALITY_BITRATE = {
+  low: 1e7,
+  // 10 Mbps per eye
+  medium: 25e6,
+  // 25 Mbps per eye
+  high: 5e7
+  // 50 Mbps per eye
+};
+var MVHEVCCompiler = class {
+  compile(composition, agentToken, outputPath) {
+    void agentToken;
+    void outputPath;
+    const result = this.compileMVHEVC(composition);
+    return result.swiftCode;
+  }
+  /**
+   * Full MV-HEVC compilation with stereo rig, Swift code, and mux command.
+   */
+  compileMVHEVC(composition, overrides) {
+    const config = this.resolveConfig(composition, overrides);
+    const views = this.generateStereoViews(config);
+    const swiftCode = this.generateSwiftCode(composition, config);
+    const muxCommand = this.generateMuxCommand(config);
+    return {
+      config,
+      views,
+      swiftCode,
+      muxCommand,
+      metadata: {
+        stereoMode: "multiview-hevc",
+        baseline: config.ipd,
+        convergence: config.convergenceDistance,
+        horizontalFOV: config.fovDegrees
+      }
+    };
+  }
+  /**
+   * Generate left/right stereo view parameters.
+   * Uses half-IPD offset with view shearing for convergence.
+   */
+  generateStereoViews(config) {
+    const halfIPD = config.ipd * config.disparityScale / 2;
+    const shearFactor = 1 / config.convergenceDistance;
+    return [
+      {
+        eye: "left",
+        cameraOffset: -halfIPD,
+        viewShear: halfIPD * shearFactor,
+        layerIndex: 0
+        // Base layer
+      },
+      {
+        eye: "right",
+        cameraOffset: halfIPD,
+        viewShear: -halfIPD * shearFactor,
+        layerIndex: 1
+        // Enhancement layer
+      }
+    ];
+  }
+  /**
+   * Extract MV-HEVC config from composition @spatial_video traits.
+   */
+  resolveConfig(composition, overrides) {
+    const config = { ...DEFAULT_CONFIG2 };
+    for (const obj of composition.objects) {
+      const svTrait = obj.traits?.find((t) => t.name === "spatial_video");
+      if (svTrait?.config) {
+        const p = svTrait.config;
+        if (typeof p["ipd"] === "number") config.ipd = p["ipd"];
+        if (Array.isArray(p["resolution"])) config.resolution = p["resolution"];
+        if (typeof p["fps"] === "number") config.fps = p["fps"];
+        if (typeof p["convergence"] === "number") config.convergenceDistance = p["convergence"];
+        if (typeof p["fov"] === "number") config.fovDegrees = p["fov"];
+        if (typeof p["quality"] === "string")
+          config.quality = p["quality"];
+      }
+    }
+    if (overrides) Object.assign(config, overrides);
+    return config;
+  }
+  /**
+   * Generate Swift code for spatial video playback on Apple Vision Pro.
+   */
+  generateSwiftCode(composition, config) {
+    const sceneName = composition.name || "SpatialVideoScene";
+    const bitrate = QUALITY_BITRATE[config.quality] ?? QUALITY_BITRATE.high;
+    return `// MVHEVCCompiler output \u2014 Spatial Video for Apple Vision Pro
+// Stereo baseline: ${config.ipd * 1e3}mm IPD, ${config.resolution[0]}x${config.resolution[1]} per eye
+// Convergence: ${config.convergenceDistance}m, FOV: ${config.fovDegrees}\xB0, ${config.fps}fps
+
+import SwiftUI
+import RealityKit
+import AVFoundation
+import AVKit
+
+// MARK: - Stereo Camera Rig
+
+struct StereoCameraConfig {
+    let ipd: Float = ${config.ipd}
+    let convergenceDistance: Float = ${config.convergenceDistance}
+    let fovDegrees: Float = ${config.fovDegrees}
+    let resolution: SIMD2<Int> = [${config.resolution[0]}, ${config.resolution[1]}]
+    let fps: Int = ${config.fps}
+    let bitrate: Int = ${bitrate}
+}
+
+// MARK: - Spatial Video Player
+
+struct ${sceneName}: View {
+    @State private var player: AVPlayer?
+
+    var body: some View {
+        RealityView { content in
+            // Spatial video entity with VideoPlayerComponent
+            let entity = Entity()
+
+            if let url = Bundle.main.url(forResource: "${sceneName.toLowerCase()}", withExtension: "${config.container}") {
+                let player = AVPlayer(url: url)
+
+                // Configure for MV-HEVC spatial video playback
+                var videoComponent = VideoPlayerComponent(avPlayer: player)
+                entity.components.set(videoComponent)
+
+                // Position the video surface
+                entity.position = [0, 1.5, -2]
+                entity.scale = [${(config.resolution[0] / config.resolution[1]).toFixed(2)}, 1.0, 1.0]
+
+                content.add(entity)
+                self.player = player
+            }
+        }
+        .onAppear {
+            player?.play()
+        }
+    }
+}
+
+// MARK: - Stereo Rendering Pipeline
+
+struct StereoRenderPipeline {
+    let config = StereoCameraConfig()
+
+    /// Render left and right eye views for MV-HEVC encoding
+    func renderStereoFrame(scene: Entity, timestamp: TimeInterval) -> (left: CGImage, right: CGImage)? {
+        let halfIPD = config.ipd / 2
+
+        // Left eye: offset camera by -halfIPD
+        let leftView = renderEyeView(
+            scene: scene,
+            cameraOffset: SIMD3<Float>(-halfIPD, 0, 0),
+            viewShear: halfIPD / config.convergenceDistance,
+            timestamp: timestamp
+        )
+
+        // Right eye: offset camera by +halfIPD
+        let rightView = renderEyeView(
+            scene: scene,
+            cameraOffset: SIMD3<Float>(halfIPD, 0, 0),
+            viewShear: -halfIPD / config.convergenceDistance,
+            timestamp: timestamp
+        )
+
+        guard let left = leftView, let right = rightView else { return nil }
+        return (left, right)
+    }
+
+    private func renderEyeView(
+        scene: Entity,
+        cameraOffset: SIMD3<Float>,
+        viewShear: Float,
+        timestamp: TimeInterval
+    ) -> CGImage? {
+        // Configure asymmetric frustum (view shearing, not toe-in)
+        // Prevents vertical parallax artifacts
+        // Implementation: offset camera position, shear projection matrix column 2
+        return nil // Platform-specific Metal rendering
+    }
+}
+
+// MARK: - AVAssetWriter MV-HEVC Muxer
+
+extension StereoRenderPipeline {
+    /// Create AVAssetWriter configured for MV-HEVC output
+    func createMVHEVCWriter(outputURL: URL) throws -> AVAssetWriter {
+        let writer = try AVAssetWriter(outputURL: outputURL, fileType: .mov)
+
+        // Base layer (left eye) \u2014 HEVC Main Profile
+        let baseSettings: [String: Any] = [
+            AVVideoCodecKey: AVVideoCodecType.hevc,
+            AVVideoWidthKey: config.resolution.x,
+            AVVideoHeightKey: config.resolution.y,
+            AVVideoCompressionPropertiesKey: [
+                AVVideoAverageBitRateKey: config.bitrate,
+                AVVideoProfileLevelKey: "HEVC_Main_AutoLevel",
+            ] as [String: Any],
+        ]
+        let baseInput = AVAssetWriterInput(mediaType: .video, outputSettings: baseSettings)
+        baseInput.expectsMediaDataInRealTime = false
+        writer.add(baseInput)
+
+        // Enhancement layer (right eye) \u2014 MV-HEVC Stereo Profile
+        // Tagged with kCMTagStereoInterpretation for spatial video
+        let enhancementSettings: [String: Any] = [
+            AVVideoCodecKey: AVVideoCodecType.hevc,
+            AVVideoWidthKey: config.resolution.x,
+            AVVideoHeightKey: config.resolution.y,
+            AVVideoCompressionPropertiesKey: [
+                AVVideoAverageBitRateKey: config.bitrate,
+                AVVideoProfileLevelKey: "HEVC_Main_AutoLevel",
+            ] as [String: Any],
+        ]
+        let enhancementInput = AVAssetWriterInput(mediaType: .video, outputSettings: enhancementSettings)
+        enhancementInput.expectsMediaDataInRealTime = false
+        writer.add(enhancementInput)
+
+        return writer
+    }
+}
+`;
+  }
+  /**
+   * Generate FFmpeg command for muxing separate L/R HEVC streams into MV-HEVC.
+   */
+  generateMuxCommand(config) {
+    const bitrate = Math.round(
+      (QUALITY_BITRATE[config.quality] ?? QUALITY_BITRATE.high) / 1e6
+    );
+    return [
+      "ffmpeg",
+      "-i left_eye.hevc -i right_eye.hevc",
+      `-c:v hevc -b:v ${bitrate}M`,
+      "-tag:v hvc1",
+      `-r ${config.fps}`,
+      `-s ${config.resolution[0]}x${config.resolution[1]}`,
+      "-movflags +faststart",
+      "-brand mp42",
+      // MV-HEVC signaling via SEI messages
+      "-metadata:s:v:0 stereo_mode=multiview_hevc",
+      '-metadata:s:v:0 "handler_name=Left Eye"',
+      '-metadata:s:v:1 "handler_name=Right Eye"',
+      `-f ${config.container}`,
+      `output_spatial.${config.container}`
+    ].join(" \\\n  ");
+  }
+};
+
+// src/hologram/WebCodecsDepthPipeline.ts
+var DEFAULT_CONFIG3 = {
+  maxFps: 30,
+  maxDepthResolution: 512,
+  temporalAlpha: 0.8,
+  codec: "vp9",
+  onFrame: void 0,
+  onError: void 0
+};
+var CODEC_STRINGS = {
+  h264: "avc1.42E01E",
+  vp9: "vp09.00.10.08",
+  av1: "av01.0.04M.08"
+};
+var WebCodecsDepthPipeline = class _WebCodecsDepthPipeline {
+  decoder = null;
+  // VideoDecoder
+  config;
+  depthService;
+  canvas = null;
+  ctx = null;
+  _running = false;
+  _disposed = false;
+  lastProcessTime = 0;
+  minFrameInterval;
+  // Stats
+  _framesDecoded = 0;
+  _framesProcessed = 0;
+  _framesSkipped = 0;
+  _totalDecodeMs = 0;
+  _totalInferenceMs = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+    this.minFrameInterval = 1e3 / this.config.maxFps;
+    this.depthService = DepthEstimationService.getInstance({
+      maxResolution: this.config.maxDepthResolution
+    });
+  }
+  /**
+   * Check if WebCodecs API is available in the current environment.
+   */
+  static isSupported() {
+    return typeof globalThis !== "undefined" && "VideoDecoder" in globalThis && "VideoFrame" in globalThis;
+  }
+  /**
+   * Initialize the pipeline: set up VideoDecoder and DepthEstimationService.
+   */
+  async initialize(config) {
+    if (config) Object.assign(this.config, config);
+    if (!_WebCodecsDepthPipeline.isSupported()) {
+      throw new Error("WebCodecs API not supported in this browser");
+    }
+    await this.depthService.initialize({
+      maxResolution: this.config.maxDepthResolution
+    });
+    this.canvas = new OffscreenCanvas(
+      this.config.maxDepthResolution,
+      this.config.maxDepthResolution
+    );
+    this.ctx = this.canvas.getContext("2d");
+    const VideoDecoderClass = globalThis.VideoDecoder;
+    this.decoder = new VideoDecoderClass({
+      output: (frame) => this._handleDecodedFrame(frame),
+      error: (err) => {
+        this.config.onError?.(err);
+      }
+    });
+    const codecString = CODEC_STRINGS[this.config.codec] ?? CODEC_STRINGS.vp9;
+    this.decoder.configure({
+      codec: codecString,
+      hardwareAcceleration: "prefer-hardware"
+    });
+    this._running = true;
+  }
+  /**
+   * Feed an encoded video chunk to the decoder.
+   * The chunk will be decoded and processed for depth asynchronously.
+   */
+  feedChunk(chunk) {
+    if (!this._running || this._disposed || !this.decoder) return;
+    if (this.decoder.state !== "configured") return;
+    this.decoder.decode(chunk);
+  }
+  /**
+   * Process a raw VideoFrame directly (for cases where decoding is handled externally).
+   */
+  async processFrame(frame) {
+    return this._handleDecodedFrame(frame);
+  }
+  /**
+   * Get pipeline statistics.
+   */
+  get stats() {
+    return {
+      framesDecoded: this._framesDecoded,
+      framesProcessed: this._framesProcessed,
+      framesSkipped: this._framesSkipped,
+      avgDecodeMs: this._framesDecoded > 0 ? this._totalDecodeMs / this._framesDecoded : 0,
+      avgInferenceMs: this._framesProcessed > 0 ? this._totalInferenceMs / this._framesProcessed : 0,
+      running: this._running
+    };
+  }
+  /**
+   * Handle a decoded VideoFrame: rate-limit, extract pixels, run depth inference.
+   */
+  async _handleDecodedFrame(frame) {
+    const decodeStart = performance.now();
+    this._framesDecoded++;
+    const now = performance.now();
+    if (now - this.lastProcessTime < this.minFrameInterval) {
+      this._framesSkipped++;
+      frame.close();
+      return null;
+    }
+    this.lastProcessTime = now;
+    this._totalDecodeMs += performance.now() - decodeStart;
+    try {
+      const bitmap = await createImageBitmap(frame);
+      const w = Math.min(bitmap.width, this.config.maxDepthResolution);
+      const h = Math.min(bitmap.height, this.config.maxDepthResolution);
+      if (this.canvas && (this.canvas.width !== w || this.canvas.height !== h)) {
+        this.canvas.width = w;
+        this.canvas.height = h;
+      }
+      this.ctx?.drawImage(bitmap, 0, 0, w, h);
+      bitmap.close();
+      const imageData = this.ctx?.getImageData(0, 0, w, h);
+      if (!imageData) {
+        frame.close();
+        return null;
+      }
+      const inferenceStart = performance.now();
+      const result = await this.depthService.estimateDepth(imageData);
+      this._totalInferenceMs += performance.now() - inferenceStart;
+      this._framesProcessed++;
+      this.config.onFrame?.(result, this._framesProcessed, frame.timestamp ?? 0);
+      frame.close();
+      return result;
+    } catch (err) {
+      frame.close();
+      this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    }
+  }
+  /**
+   * Flush any remaining frames in the decoder.
+   */
+  async flush() {
+    if (this.decoder?.state === "configured") {
+      await this.decoder.flush();
+    }
+  }
+  /**
+   * Stop the pipeline and release all resources.
+   */
+  dispose() {
+    this._disposed = true;
+    this._running = false;
+    if (this.decoder?.state !== "closed") {
+      try {
+        this.decoder?.close();
+      } catch {
+      }
+    }
+    this.decoder = null;
+    this.canvas = null;
+    this.ctx = null;
+  }
+};
+
+export {
+  detectBestBackend,
+  depthToNormalMap,
+  ModelCache,
+  TemporalSmoother,
+  GIFDisposalMethod,
+  GIFDecomposer,
+  DepthEstimationService,
+  QuiltCompiler,
+  MVHEVCCompiler,
+  WebCodecsDepthPipeline,
+  hologram_exports
+};