@holoscript/core 8.0.13 → 8.0.14

package/dist/chunk-7ZKQ32XK.js

@@ -0,0 +1,1571 @@
+import { createHoloMapRuntime, HOLOMAP_DEFAULTS } from './chunk-47XZ62KM.js';
+import { parseHolo } from './chunk-JQCXLKAU.js';
+import { createHash } from 'crypto';
+
+// src/reconstruction/FusedAttentionKernel.ts
+var FUSED_ATTENTION_WGSL = `
+struct Params {
+  qRows: u32,
+  kRows: u32,
+  dModel: u32,
+  vCols: u32,
+  scale: f32,
+}
+
+@group(0) @binding(0) var<storage, read> q: array<f32>;
+@group(0) @binding(1) var<storage, read> k: array<f32>;
+@group(0) @binding(2) var<storage, read> v: array<f32>;
+@group(0) @binding(3) var<storage, read_write> out: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+fn qIndex(row: u32, col: u32) -> u32 {
+  return row * params.dModel + col;
+}
+
+fn kIndex(row: u32, col: u32) -> u32 {
+  return row * params.dModel + col;
+}
+
+fn vIndex(row: u32, col: u32) -> u32 {
+  return row * params.vCols + col;
+}
+
+fn oIndex(row: u32, col: u32) -> u32 {
+  return row * params.vCols + col;
+}
+
+@compute @workgroup_size(1, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let qRow = gid.x;
+  if (qRow >= params.qRows) {
+    return;
+  }
+
+  var maxScore = -1e30;
+  for (var kRow: u32 = 0u; kRow < params.kRows; kRow = kRow + 1u) {
+    var dot = 0.0;
+    for (var d: u32 = 0u; d < params.dModel; d = d + 1u) {
+      dot = dot + q[qIndex(qRow, d)] * k[kIndex(kRow, d)];
+    }
+    let score = dot * params.scale;
+    if (score > maxScore) {
+      maxScore = score;
+    }
+  }
+
+  var denom = 0.0;
+  for (var kRow: u32 = 0u; kRow < params.kRows; kRow = kRow + 1u) {
+    var dot = 0.0;
+    for (var d: u32 = 0u; d < params.dModel; d = d + 1u) {
+      dot = dot + q[qIndex(qRow, d)] * k[kIndex(kRow, d)];
+    }
+    denom = denom + exp(dot * params.scale - maxScore);
+  }
+
+  for (var c: u32 = 0u; c < params.vCols; c = c + 1u) {
+    var acc = 0.0;
+    for (var kRow: u32 = 0u; kRow < params.kRows; kRow = kRow + 1u) {
+      var dot = 0.0;
+      for (var d: u32 = 0u; d < params.dModel; d = d + 1u) {
+        dot = dot + q[qIndex(qRow, d)] * k[kIndex(kRow, d)];
+      }
+      let w = exp(dot * params.scale - maxScore) / max(denom, 1e-9);
+      acc = acc + w * v[vIndex(kRow, c)];
+    }
+    out[oIndex(qRow, c)] = acc;
+  }
+}
+`;
+function cpuFusedAttention(input) {
+  const { q, k, v, qRows, kRows, dModel, vCols } = input;
+  const out = new Float32Array(qRows * vCols);
+  const scale = 1 / Math.sqrt(Math.max(dModel, 1));
+  for (let qr = 0; qr < qRows; qr += 1) {
+    let maxScore = -Number.MAX_VALUE;
+    const scores = new Float32Array(kRows);
+    for (let kr = 0; kr < kRows; kr += 1) {
+      let dot = 0;
+      for (let d = 0; d < dModel; d += 1) {
+        dot += q[qr * dModel + d] * k[kr * dModel + d];
+      }
+      const s = dot * scale;
+      scores[kr] = s;
+      if (s > maxScore) maxScore = s;
+    }
+    let denom = 0;
+    for (let kr = 0; kr < kRows; kr += 1) {
+      const ex = Math.exp(scores[kr] - maxScore);
+      scores[kr] = ex;
+      denom += ex;
+    }
+    for (let c = 0; c < vCols; c += 1) {
+      let acc = 0;
+      for (let kr = 0; kr < kRows; kr += 1) {
+        const w = scores[kr] / Math.max(denom, 1e-9);
+        acc += w * v[kr * vCols + c];
+      }
+      out[qr * vCols + c] = acc;
+    }
+  }
+  return out;
+}
+async function webGpuFusedAttention(input) {
+  const nav = globalThis.navigator;
+  const gpu = nav.gpu;
+  if (!gpu) {
+    throw new Error("WebGPU not available");
+  }
+  const adapter = await gpu.requestAdapter();
+  if (!adapter) {
+    throw new Error("No WebGPU adapter");
+  }
+  const device = await adapter.requestDevice();
+  const { q, k, v, qRows, kRows, dModel, vCols } = input;
+  const qBytes = q.byteLength;
+  const kBytes = k.byteLength;
+  const vBytes = v.byteLength;
+  const outElems = qRows * vCols;
+  const outBytes = outElems * 4;
+  const qBuf = device.createBuffer({
+    size: Math.max(4, qBytes),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  const kBuf = device.createBuffer({
+    size: Math.max(4, kBytes),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  const vBuf = device.createBuffer({
+    size: Math.max(4, vBytes),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  const outBuf = device.createBuffer({
+    size: Math.max(4, outBytes),
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+  });
+  const uniBuf = device.createBuffer({
+    size: 256,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  const uniformData = new ArrayBuffer(256);
+  const u32 = new Uint32Array(uniformData, 0, 4);
+  const f32 = new Float32Array(uniformData, 16, 1);
+  u32[0] = qRows;
+  u32[1] = kRows;
+  u32[2] = dModel;
+  u32[3] = vCols;
+  f32[0] = 1 / Math.sqrt(Math.max(dModel, 1));
+  device.queue.writeBuffer(qBuf, 0, q.buffer, q.byteOffset, q.byteLength);
+  device.queue.writeBuffer(kBuf, 0, k.buffer, k.byteOffset, k.byteLength);
+  device.queue.writeBuffer(vBuf, 0, v.buffer, v.byteOffset, v.byteLength);
+  device.queue.writeBuffer(uniBuf, 0, uniformData);
+  const module = device.createShaderModule({ code: FUSED_ATTENTION_WGSL });
+  const bindLayout = device.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "read-only-storage" }
+      },
+      {
+        binding: 1,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "read-only-storage" }
+      },
+      {
+        binding: 2,
+        visibility: GPUShaderStage.COMPUTE,
+        buffer: { type: "read-only-storage" }
+      },
+      { binding: 3, visibility: GPUShaderStage.COMPUTE, buffer: { type: "storage" } },
+      { binding: 4, visibility: GPUShaderStage.COMPUTE, buffer: { type: "uniform" } }
+    ]
+  });
+  const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: [bindLayout] });
+  const pipeline = await device.createComputePipelineAsync({
+    layout: pipelineLayout,
+    compute: { module, entryPoint: "main" }
+  });
+  const bindGroup = device.createBindGroup({
+    layout: bindLayout,
+    entries: [
+      { binding: 0, resource: { buffer: qBuf } },
+      { binding: 1, resource: { buffer: kBuf } },
+      { binding: 2, resource: { buffer: vBuf } },
+      { binding: 3, resource: { buffer: outBuf } },
+      { binding: 4, resource: { buffer: uniBuf } }
+    ]
+  });
+  const encoder = device.createCommandEncoder();
+  const pass = encoder.beginComputePass();
+  pass.setPipeline(pipeline);
+  pass.setBindGroup(0, bindGroup);
+  pass.dispatchWorkgroups(qRows, 1, 1);
+  pass.end();
+  const readBuf = device.createBuffer({
+    size: Math.max(4, outBytes),
+    usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+  });
+  encoder.copyBufferToBuffer(outBuf, 0, readBuf, 0, outBytes);
+  device.queue.submit([encoder.finish()]);
+  await readBuf.mapAsync(GPUMapMode.READ);
+  const mapped = new Float32Array(readBuf.getMappedRange());
+  const copy = new Float32Array(outElems);
+  copy.set(mapped);
+  readBuf.unmap();
+  qBuf.destroy();
+  kBuf.destroy();
+  vBuf.destroy();
+  outBuf.destroy();
+  uniBuf.destroy();
+  readBuf.destroy();
+  return copy;
+}
+var CpuFusedAttentionBackend = class {
+  constructor() {
+    this.name = "cpu";
+  }
+  async compute(input) {
+    return cpuFusedAttention(input);
+  }
+};
+var WebGpuFusedAttentionBackend = class {
+  constructor() {
+    this.name = "webgpu";
+  }
+  async compute(input) {
+    try {
+      return await webGpuFusedAttention(input);
+    } catch {
+      return cpuFusedAttention(input);
+    }
+  }
+};
+async function createFusedAttentionBackend() {
+  if (typeof navigator !== "undefined" && "gpu" in navigator) {
+    return new WebGpuFusedAttentionBackend();
+  }
+  return new CpuFusedAttentionBackend();
+}
+
+// src/reconstruction/TrajectoryMemory.ts
+var TRAJECTORY_DEFAULTS = {
+  maxKeyframes: 512,
+  keyframeStrideMeters: 0.25,
+  loopClosureThreshold: 0.92
+};
+function createTrajectoryMemory(_config) {
+  throw new Error(
+    "TrajectoryMemory is scaffolded in Sprint 1; implementation lands in Sprint 2. See reconstruction/RFC-HoloMap.md \xA7Trajectory"
+  );
+}
+
+// src/reconstruction/AnchorContext.ts
+var ANCHOR_DEFAULTS = {
+  warmupFrames: 30,
+  minConfidence: 0.75,
+  maxDriftBeforeReanchor: 2
+};
+function createAnchorContext(_config) {
+  throw new Error(
+    "AnchorContext is scaffolded in Sprint 1; implementation lands in Sprint 2. See reconstruction/RFC-HoloMap.md \xA7Anchor"
+  );
+}
+
+// src/reconstruction/mobileSensorBundle.ts
+var HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION = "holomap-mobile-sensor-bundle/v1";
+var ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS = {
+  near: 500,
+  far: 5e3
+};
+function finiteNumber(value) {
+  return Number.isFinite(value);
+}
+function finiteArray(values, expectedLength) {
+  if (values.length !== expectedLength) return false;
+  for (let i = 0; i < values.length; i += 1) {
+    if (!finiteNumber(Number(values[i]))) return false;
+  }
+  return true;
+}
+function clampUnit(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function requirePositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+function normalizeArCoreDepthRange(range) {
+  const near = range?.near ?? ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS.near;
+  const far = range?.far ?? ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS.far;
+  if (!finiteNumber(near) || near <= 0)
+    throw new Error("arCoreDepthRange.near must be positive finite");
+  if (!finiteNumber(far) || far <= near)
+    throw new Error("arCoreDepthRange.far must be finite and greater than near");
+  return { near, far };
+}
+function requirePlane(width, height, values, name, maxValue) {
+  requirePositiveInteger(width, `${name}.width`);
+  requirePositiveInteger(height, `${name}.height`);
+  const expected = width * height;
+  if (values.length !== expected) {
+    throw new Error(`${name}.values length must be ${expected}`);
+  }
+  for (let i = 0; i < values.length; i += 1) {
+    const value = Number(values[i]);
+    if (!Number.isFinite(value) || value < 0 || value > maxValue) {
+      throw new Error(`${name}.values[${i}] must be a finite value from 0 to ${maxValue}`);
+    }
+  }
+}
+function nearestPlaneIndex(x, y, srcWidth, srcHeight, dstWidth, dstHeight) {
+  const sx = Math.min(srcWidth - 1, Math.max(0, Math.floor((x + 0.5) * srcWidth / dstWidth)));
+  const sy = Math.min(srcHeight - 1, Math.max(0, Math.floor((y + 0.5) * srcHeight / dstHeight)));
+  return sy * srcWidth + sx;
+}
+function arCoreDepthMillimetersToUnit(depthMillimeters, range) {
+  if (!Number.isFinite(depthMillimeters) || depthMillimeters <= 0) return 1;
+  return clampUnit((depthMillimeters - range.near) / (range.far - range.near));
+}
+function arCoreDepthCellIsTrusted(depthMillimeters, range) {
+  return Number.isFinite(depthMillimeters) && depthMillimeters > 0 && depthMillimeters <= range.far;
+}
+function toUint8Array(values, name) {
+  const out = new Uint8Array(values.length);
+  for (let i = 0; i < values.length; i += 1) {
+    const value = Number(values[i]);
+    if (!Number.isFinite(value) || value < 0 || value > 255) {
+      throw new Error(`${name}[${i}] must be a finite byte`);
+    }
+    out[i] = Math.round(value);
+  }
+  return out;
+}
+function toFloat32UnitArray(values, name) {
+  const out = new Float32Array(values.length);
+  for (let i = 0; i < values.length; i += 1) {
+    const value = Number(values[i]);
+    if (!Number.isFinite(value)) throw new Error(`${name}[${i}] must be finite`);
+    out[i] = clampUnit(value);
+  }
+  return out;
+}
+function confidenceToUnitArray(plane) {
+  const out = new Float32Array(plane.values.length);
+  for (let i = 0; i < plane.values.length; i += 1) {
+    const value = Number(plane.values[i]);
+    if (!Number.isFinite(value)) throw new Error(`sceneDepthConfidence[${i}] must be finite`);
+    if (plane.encoding === "unit") out[i] = clampUnit(value);
+    else if (plane.encoding === "arkit-0-2") out[i] = clampUnit(value / 2);
+    else out[i] = clampUnit(value / 255);
+  }
+  return out;
+}
+function arCoreDepthFrameToMobileSensorFrame(frame, depthRangeMillimeters) {
+  requirePositiveInteger(frame.width, "arCoreFrame.width");
+  requirePositiveInteger(frame.height, "arCoreFrame.height");
+  if (frame.stride !== 3 && frame.stride !== 4) {
+    throw new Error("arCoreFrame.stride must be 3 or 4");
+  }
+  if (!finiteNumber(frame.timestampMs)) throw new Error("arCoreFrame.timestampMs must be finite");
+  if (!Number.isInteger(frame.index) || frame.index < 0) {
+    throw new Error("arCoreFrame.index must be a non-negative integer");
+  }
+  if (!finiteArray(frame.rgb, frame.width * frame.height * frame.stride)) {
+    throw new Error("arCoreFrame.rgb length/content invalid");
+  }
+  const depth = frame.depthImage16Bits;
+  const range = normalizeArCoreDepthRange(depthRangeMillimeters);
+  requirePlane(depth.width, depth.height, depth.millimeters, "arCoreFrame.depthImage16Bits", 65535);
+  if (frame.rawDepthConfidenceImage) {
+    const confidence = frame.rawDepthConfidenceImage;
+    requirePlane(
+      confidence.width,
+      confidence.height,
+      confidence.values,
+      "arCoreFrame.rawDepthConfidenceImage",
+      255
+    );
+    if (confidence.width !== depth.width || confidence.height !== depth.height) {
+      throw new Error("arCoreFrame.rawDepthConfidenceImage dimensions must match depthImage16Bits");
+    }
+  }
+  const pixelCount = frame.width * frame.height;
+  const normalizedDepth = new Float32Array(pixelCount);
+  const metricDepthMeters = new Float32Array(pixelCount);
+  const normalizedConfidence = new Float32Array(pixelCount);
+  for (let y = 0; y < frame.height; y += 1) {
+    for (let x = 0; x < frame.width; x += 1) {
+      const dstIndex = y * frame.width + x;
+      const srcIndex = nearestPlaneIndex(
+        x,
+        y,
+        depth.width,
+        depth.height,
+        frame.width,
+        frame.height
+      );
+      const depthMillimeters = Number(depth.millimeters[srcIndex]);
+      normalizedDepth[dstIndex] = arCoreDepthMillimetersToUnit(depthMillimeters, range);
+      metricDepthMeters[dstIndex] = arCoreDepthCellIsTrusted(depthMillimeters, range) ? depthMillimeters / 1e3 : 0;
+      const sensorConfidence = frame.rawDepthConfidenceImage ? clampUnit(Number(frame.rawDepthConfidenceImage.values[srcIndex]) / 255) : 1;
+      normalizedConfidence[dstIndex] = arCoreDepthCellIsTrusted(depthMillimeters, range) ? sensorConfidence : 0;
+    }
+  }
+  return {
+    index: frame.index,
+    timestampMs: frame.timestampMs,
+    width: frame.width,
+    height: frame.height,
+    stride: frame.stride,
+    rgb: frame.rgb,
+    sceneDepth: {
+      width: frame.width,
+      height: frame.height,
+      values: normalizedDepth
+    },
+    sceneDepthMeters: {
+      width: frame.width,
+      height: frame.height,
+      values: metricDepthMeters
+    },
+    sceneDepthConfidence: {
+      width: frame.width,
+      height: frame.height,
+      encoding: "unit",
+      values: normalizedConfidence
+    },
+    cameraTransformColumnMajor4x4: frame.cameraTransformColumnMajor4x4,
+    devicePose: frame.devicePose
+  };
+}
+function createArCoreDepthMobileSensorBundle(input) {
+  if (!input.bundleId) throw new Error("arCoreBundle.bundleId missing");
+  if (!Array.isArray(input.frames) || input.frames.length === 0) {
+    throw new Error("arCoreBundle.frames missing");
+  }
+  return {
+    schemaVersion: HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION,
+    bundleId: input.bundleId,
+    capture: {
+      platform: "android-arcore-depth",
+      deviceModel: input.deviceModel,
+      coordinateSystem: "arcore-right-handed-y-up",
+      intrinsics: input.intrinsics
+    },
+    frames: input.frames.map(
+      (frame) => arCoreDepthFrameToMobileSensorFrame(frame, input.depthRangeMillimeters)
+    )
+  };
+}
+function normalizeQuaternion(q) {
+  const len = Math.hypot(q[0], q[1], q[2], q[3]);
+  if (len <= 1e-12) return [0, 0, 0, 1];
+  return [q[0] / len, q[1] / len, q[2] / len, q[3] / len];
+}
+function cameraPoseFromColumnMajorTransform(transform, confidence = 1) {
+  if (transform.length !== 16 || !finiteArray(transform, 16)) {
+    throw new Error("cameraTransformColumnMajor4x4 must contain 16 finite numbers");
+  }
+  const m00 = Number(transform[0]);
+  const m01 = Number(transform[4]);
+  const m02 = Number(transform[8]);
+  const m10 = Number(transform[1]);
+  const m11 = Number(transform[5]);
+  const m12 = Number(transform[9]);
+  const m20 = Number(transform[2]);
+  const m21 = Number(transform[6]);
+  const m22 = Number(transform[10]);
+  const trace = m00 + m11 + m22;
+  let rotation;
+  if (trace > 0) {
+    const s = Math.sqrt(trace + 1) * 2;
+    rotation = [(m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s, 0.25 * s];
+  } else if (m00 > m11 && m00 > m22) {
+    const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
+    rotation = [0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s];
+  } else if (m11 > m22) {
+    const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
+    rotation = [(m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s];
+  } else {
+    const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
+    rotation = [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
+  }
+  return {
+    position: [Number(transform[12]), Number(transform[13]), Number(transform[14])],
+    rotation: normalizeQuaternion(rotation),
+    confidence: clampUnit(confidence)
+  };
+}
+function validateMobileSensorBundle(bundle) {
+  const errors = [];
+  if (bundle.schemaVersion !== HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION)
+    errors.push("schemaVersion mismatch");
+  if (!bundle.bundleId) errors.push("bundleId missing");
+  if (!bundle.capture?.platform) errors.push("capture.platform missing");
+  const intrinsics = bundle.capture?.intrinsics;
+  if (!intrinsics) {
+    errors.push("capture.intrinsics missing");
+  } else {
+    for (const key of ["width", "height", "fx", "fy", "cx", "cy"]) {
+      if (!finiteNumber(intrinsics[key]) || intrinsics[key] <= 0) {
+        errors.push(`capture.intrinsics.${key} must be positive finite`);
+      }
+    }
+    if (!intrinsics.source) errors.push("capture.intrinsics.source missing");
+  }
+  if (!Array.isArray(bundle.frames) || bundle.frames.length === 0) errors.push("frames missing");
+  for (const frame of bundle.frames ?? []) {
+    const prefix = `frame[${frame?.index ?? "?"}]`;
+    if (!Number.isInteger(frame.index) || frame.index < 0)
+      errors.push(`${prefix}.index must be a non-negative integer`);
+    if (!finiteNumber(frame.timestampMs)) errors.push(`${prefix}.timestampMs must be finite`);
+    if (!Number.isInteger(frame.width) || frame.width <= 0)
+      errors.push(`${prefix}.width must be positive integer`);
+    if (!Number.isInteger(frame.height) || frame.height <= 0)
+      errors.push(`${prefix}.height must be positive integer`);
+    if (frame.stride !== 3 && frame.stride !== 4) errors.push(`${prefix}.stride must be 3 or 4`);
+    const pixelCount = frame.width * frame.height;
+    if (!finiteArray(frame.rgb, pixelCount * frame.stride))
+      errors.push(`${prefix}.rgb length/content invalid`);
+    if (frame.sceneDepth) {
+      if (frame.sceneDepth.width !== frame.width || frame.sceneDepth.height !== frame.height) {
+        errors.push(`${prefix}.sceneDepth dimensions must match frame`);
+      }
+      if (!finiteArray(frame.sceneDepth.values, pixelCount))
+        errors.push(`${prefix}.sceneDepth values invalid`);
+    }
+    if (frame.sceneDepthMeters) {
+      if (frame.sceneDepthMeters.width !== frame.width || frame.sceneDepthMeters.height !== frame.height) {
+        errors.push(`${prefix}.sceneDepthMeters dimensions must match frame`);
+      }
+      if (!finiteArray(frame.sceneDepthMeters.values, pixelCount))
+        errors.push(`${prefix}.sceneDepthMeters values invalid`);
+    }
+    if (frame.sceneDepthConfidence) {
+      if (frame.sceneDepthConfidence.width !== frame.width || frame.sceneDepthConfidence.height !== frame.height) {
+        errors.push(`${prefix}.sceneDepthConfidence dimensions must match frame`);
+      }
+      if (!finiteArray(frame.sceneDepthConfidence.values, pixelCount)) {
+        errors.push(`${prefix}.sceneDepthConfidence values invalid`);
+      }
+    }
+    if (frame.cameraTransformColumnMajor4x4 && !finiteArray(frame.cameraTransformColumnMajor4x4, 16)) {
+      errors.push(`${prefix}.cameraTransformColumnMajor4x4 invalid`);
+    }
+  }
+  return errors;
+}
+function mobileSensorBundleToFrames(bundle) {
+  const errors = validateMobileSensorBundle(bundle);
+  if (errors.length > 0)
+    throw new Error(`Invalid HoloMap mobile sensor bundle: ${errors.join("; ")}`);
+  return bundle.frames.map((frame) => ({
+    index: frame.index,
+    timestampMs: frame.timestampMs,
+    width: frame.width,
+    height: frame.height,
+    stride: frame.stride,
+    rgb: toUint8Array(frame.rgb, `frame[${frame.index}].rgb`),
+    depth: frame.sceneDepth ? toFloat32UnitArray(frame.sceneDepth.values, `frame[${frame.index}].sceneDepth`) : void 0,
+    depthMeters: frame.sceneDepthMeters ? new Float32Array(Array.from(frame.sceneDepthMeters.values, Number)) : void 0,
+    depthConfidence: frame.sceneDepthConfidence ? confidenceToUnitArray(frame.sceneDepthConfidence) : void 0,
+    cameraIntrinsics: {
+      width: bundle.capture.intrinsics.width,
+      height: bundle.capture.intrinsics.height,
+      fx: bundle.capture.intrinsics.fx,
+      fy: bundle.capture.intrinsics.fy,
+      cx: bundle.capture.intrinsics.cx,
+      cy: bundle.capture.intrinsics.cy
+    },
+    devicePose: frame.cameraTransformColumnMajor4x4 ? cameraPoseFromColumnMajorTransform(
+      frame.cameraTransformColumnMajor4x4,
+      frame.devicePose?.confidence ?? 1
+    ) : frame.devicePose
+  }));
+}
+async function replayMobileSensorBundle(bundle, config = {}) {
+  const frames = mobileSensorBundleToFrames(bundle);
+  const runtime = createHoloMapRuntime();
+  await runtime.init({
+    ...HOLOMAP_DEFAULTS,
+    seed: 0,
+    modelHash: bundle.bundleId,
+    videoHash: bundle.bundleId,
+    targetFPS: 1e5,
+    ...config
+  });
+  const steps = [];
+  try {
+    for (const frame of frames) {
+      const step = await runtime.step(frame);
+      if (step) steps.push(step);
+    }
+    const manifest = await runtime.finalize();
+    const meshAnchorCount = bundle.frames.reduce(
+      (sum, frame) => sum + (frame.meshAnchors?.length ?? 0),
+      0
+    );
+    return {
+      source: {
+        bundleId: bundle.bundleId,
+        platform: bundle.capture.platform,
+        frameCount: bundle.frames.length,
+        meshAnchorCount
+      },
+      steps,
+      manifest
+    };
+  } finally {
+    await runtime.dispose();
+  }
+}
+var PERCEIVER_CONSENSUS_VERSION = "perceiver-consensus-v3";
+var POSITION_EPSILON = 1e-6;
+var PERCEIVER_FACT_CLASSES = [
+  "source-name",
+  "agent-entities",
+  "affordance-count",
+  "affordance-names",
+  "physical-entities",
+  "geometry",
+  "position"
+];
+function canonicalPhysicalId(name) {
+  let folded = name.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  if (folded.startsWith("_")) folded = "a" + folded;
+  return folded;
+}
+function sha256Hex(s) {
+  return createHash("sha256").update(s).digest("hex");
+}
+function positionsEqual(a, b) {
+  return a.length === b.length && a.every((v, i) => Math.abs(v - b[i]) <= POSITION_EPSILON);
+}
+function derivePerceiverConsensus(derivations) {
+  if (derivations.length < 2) {
+    throw new Error(
+      "PerceiverConsensusReceipt: consensus requires >= 2 independent perceivers \u2014 a single-perceiver receipt is circular"
+    );
+  }
+  const ids = derivations.map((d) => d.perceiver);
+  if (new Set(ids).size !== ids.length) {
+    throw new Error(
+      `PerceiverConsensusReceipt: duplicate perceiver ids ${JSON.stringify(ids)} \u2014 self-agreement is not consensus`
+    );
+  }
+  const disagreements = [];
+  let comparedFacts = 0;
+  const expressers = (cls) => derivations.filter((d) => d.expresses.includes(cls));
+  const named = expressers("source-name").filter((d) => d.sourceName != null);
+  let sourceName = named[0]?.sourceName ?? null;
+  if (named.length >= 2) {
+    comparedFacts++;
+    const names = new Set(named.map((d) => d.sourceName));
+    if (names.size > 1) {
+      sourceName = null;
+      disagreements.push({
+        fact: "sourceName",
+        claims: Object.fromEntries(named.map((d) => [d.perceiver, d.sourceName])),
+        detail: `perceivers claim different source compositions: ${[...names].join(" vs ")}`
+      });
+    }
+  }
+  const agentVoters = expressers("agent-entities");
+  if (agentVoters.length >= 2) {
+    const byPerceiver = new Map(
+      agentVoters.map((d) => [d.perceiver, new Map(d.entities.map((e) => [e.id, e]))])
+    );
+    const idUnion = [...new Set(agentVoters.flatMap((d) => d.entities.map((e) => e.id)))].sort();
+    const sharedIds = [];
+    for (const id of idUnion) {
+      comparedFacts++;
+      if (agentVoters.every((d) => byPerceiver.get(d.perceiver).has(id))) {
+        sharedIds.push(id);
+      } else {
+        const dissent = agentVoters.filter((d) => !byPerceiver.get(d.perceiver).has(id));
+        disagreements.push({
+          fact: `entity:${id}`,
+          claims: Object.fromEntries(
+            agentVoters.map((d) => [
+              d.perceiver,
+              byPerceiver.get(d.perceiver).has(id) ? "present" : "absent"
+            ])
+          ),
+          detail: `agent entity "${id}" is invisible to ${dissent.map((d) => d.perceiver).join(", ")} \u2014 the surface is lying to someone`
+        });
+      }
+    }
+    for (const id of sharedIds) {
+      const countVoters = agentVoters.filter((d) => d.expresses.includes("affordance-count"));
+      if (countVoters.length >= 2) {
+        comparedFacts++;
+        const perEntity = countVoters.map((d) => ({
+          perceiver: d.perceiver,
+          entity: byPerceiver.get(d.perceiver).get(id)
+        }));
+        const counts = new Set(perEntity.map((p) => p.entity.offerCount));
+        if (counts.size > 1) {
+          disagreements.push({
+            fact: `entity:${id}:offerCount`,
+            claims: Object.fromEntries(perEntity.map((p) => [p.perceiver, p.entity.offerCount])),
+            detail: `affordance count on "${id}" diverges: ${perEntity.map((p) => `${p.perceiver} derives ${p.entity.offerCount}`).join("; ")}`
+          });
+          continue;
+        }
+      }
+      const nameVoters = agentVoters.filter(
+        (d) => d.expresses.includes("affordance-names") && Array.isArray(byPerceiver.get(d.perceiver).get(id).offers)
+      );
+      if (nameVoters.length >= 2) {
+        comparedFacts++;
+        const actionSets = nameVoters.map(
+          (d) => [...new Set(byPerceiver.get(d.perceiver).get(id).offers.map((o) => o.action))].sort().join(",")
+        );
+        if (new Set(actionSets).size > 1) {
+          disagreements.push({
+            fact: `entity:${id}:offerActions`,
+            claims: Object.fromEntries(nameVoters.map((d, i) => [d.perceiver, actionSets[i]])),
+            detail: `named affordances on "${id}" diverge: ${nameVoters.map((d, i) => `${d.perceiver} derives [${actionSets[i]}]`).join("; ")}`
+          });
+        }
+      }
+    }
+  }
+  const physVoters = expressers("physical-entities");
+  if (physVoters.length >= 2) {
+    const byPerceiver = new Map(
+      physVoters.map((d) => [
+        d.perceiver,
+        new Map((d.physicalEntities ?? []).map((e) => [e.id, e]))
+      ])
+    );
+    const idUnion = [
+      ...new Set(physVoters.flatMap((d) => (d.physicalEntities ?? []).map((e) => e.id)))
+    ].sort();
+    const sharedIds = [];
+    for (const id of idUnion) {
+      comparedFacts++;
+      if (physVoters.every((d) => byPerceiver.get(d.perceiver).has(id))) {
+        sharedIds.push(id);
+      } else {
+        const dissent = physVoters.filter((d) => !byPerceiver.get(d.perceiver).has(id));
+        disagreements.push({
+          fact: `physical:${id}`,
+          claims: Object.fromEntries(
+            physVoters.map((d) => [
+              d.perceiver,
+              byPerceiver.get(d.perceiver).has(id) ? "present" : "absent"
+            ])
+          ),
+          detail: `physical entity "${id}" is invisible to ${dissent.map((d) => d.perceiver).join(", ")} \u2014 the surface is lying to someone`
+        });
+      }
+    }
+    for (const id of sharedIds) {
+      const geomVoters = physVoters.filter(
+        (d) => d.expresses.includes("geometry") && typeof byPerceiver.get(d.perceiver).get(id).geometry === "string"
+      );
+      if (geomVoters.length >= 2) {
+        comparedFacts++;
+        const geoms = geomVoters.map((d) => byPerceiver.get(d.perceiver).get(id).geometry);
+        if (new Set(geoms).size > 1) {
+          disagreements.push({
+            fact: `physical:${id}:geometry`,
+            claims: Object.fromEntries(geomVoters.map((d, i) => [d.perceiver, geoms[i]])),
+            detail: `geometry of "${id}" diverges: ${geomVoters.map((d, i) => `${d.perceiver} derives ${geoms[i]}`).join("; ")}`
+          });
+        }
+      }
+      const posVoters = physVoters.filter(
+        (d) => d.expresses.includes("position") && Array.isArray(byPerceiver.get(d.perceiver).get(id).position)
+      );
+      if (posVoters.length >= 2) {
+        comparedFacts++;
+        const positions = posVoters.map((d) => byPerceiver.get(d.perceiver).get(id).position);
+        const agrees = positions.every((p) => positionsEqual(p, positions[0]));
+        if (!agrees) {
+          disagreements.push({
+            fact: `physical:${id}:position`,
+            claims: Object.fromEntries(
+              posVoters.map((d, i) => [d.perceiver, JSON.stringify(positions[i])])
+            ),
+            detail: `position of "${id}" diverges beyond \u03B5=${POSITION_EPSILON}: ${posVoters.map((d, i) => `${d.perceiver} derives ${JSON.stringify(positions[i])}`).join("; ")}`
+          });
+        }
+      }
+    }
+  }
+  for (const src of expressers("affordance-names")) {
+    for (const entity of src.entities) {
+      for (const offer of entity.offers ?? []) {
+        if (!offer.target) continue;
+        const actorKey = canonicalPhysicalId(entity.id);
+        const targetKey = canonicalPhysicalId(offer.target);
+        for (const p of expressers("physical-entities")) {
+          const map = new Map((p.physicalEntities ?? []).map((e) => [e.id, e]));
+          const actor = map.get(actorKey);
+          const target = map.get(targetKey);
+          const fact = `grounding:${entity.id}:${offer.action}`;
+          const claim = `${offer.action}@${offer.target}`;
+          if (!actor || !target) {
+            comparedFacts++;
+            disagreements.push({
+              fact,
+              claims: {
+                [src.perceiver]: claim,
+                [p.perceiver]: !actor ? `no physical actor "${actorKey}"` : `no physical target "${targetKey}"`
+              },
+              detail: `${src.perceiver} offers "${offer.action}" on "${offer.target}" but ${p.perceiver} derives no physical ${!actor ? "actor" : "target"} \u2014 the affordance is ungrounded`
+            });
+            continue;
+          }
+          const center = actor.reachCenter ?? actor.position;
+          const radius = actor.reachRadius ?? (actor.mobility !== "actuated" && actor.extent != null ? actor.extent : void 0);
+          if (!center || radius == null || !target.position || target.extent == null) {
+            continue;
+          }
+          comparedFacts++;
+          const dist = Math.hypot(
+            ...center.map((v, i) => v - target.position[i])
+          );
+          const reach = radius + target.extent + POSITION_EPSILON;
+          if (dist > reach) {
+            disagreements.push({
+              fact,
+              claims: {
+                [src.perceiver]: claim,
+                [p.perceiver]: `unreachable (dist ${dist.toFixed(3)} > reach ${reach.toFixed(3)})`
+              },
+              detail: `${src.perceiver} offers "${offer.action}" on "${offer.target}" but ${p.perceiver} derives no reachable affordance (distance ${dist.toFixed(3)} exceeds the ${actor.mobility ?? "fixed"}-mobility outer reach envelope ${reach.toFixed(3)}) \u2014 the surface is lying to someone`
+            });
+          }
+        }
+      }
+    }
+  }
+  const verdict = disagreements.length > 0 ? "FALSIFIED" : "CONSENSUS";
+  const perceivers = derivations.map((d) => ({
+    perceiver: d.perceiver,
+    artifactHash: d.artifactHash,
+    expresses: [...d.expresses].sort(),
+    entityCount: d.entities.length,
+    physicalEntityCount: d.physicalEntities?.length ?? 0,
+    // DERIVED coverage (whu2): the complement of declared voting rights,
+    // unioned with the extractor's free-text gap notes — a hardcoded list
+    // can go stale the day an artifact learns a fact class; the complement
+    // cannot.
+    coverageGaps: [
+      .../* @__PURE__ */ new Set([
+        ...PERCEIVER_FACT_CLASSES.filter((c) => !d.expresses.includes(c)),
+        ...d.coverageGaps
+      ])
+    ].sort()
+  })).sort((a, b) => a.perceiver.localeCompare(b.perceiver));
+  const receiptHash = sha256Hex(
+    [
+      PERCEIVER_CONSENSUS_VERSION,
+      verdict,
+      sourceName ?? "",
+      ...perceivers.map(
+        (p) => `${p.perceiver}:${p.artifactHash}:${p.entityCount}:${p.physicalEntityCount}`
+      ),
+      ...disagreements.map((d) => `${d.fact}=${JSON.stringify(Object.entries(d.claims).sort())}`).sort()
+    ].join("|")
+  );
+  return {
+    version: PERCEIVER_CONSENSUS_VERSION,
+    verdict,
+    sourceName,
+    perceivers,
+    comparedFacts,
+    disagreements,
+    receiptHash
+  };
+}
+var WEBGPU_PERCEIVER = "webgpu";
+function deriveWebGPUPerception(artifact) {
+  if (typeof artifact !== "string" || !artifact.includes("holoGraphObjects")) {
+    throw new Error(
+      "deriveWebGPUPerception: input is not a WebGPU compile artifact (missing holoGraphObjects scene registry)"
+    );
+  }
+  const sourceName = /^\/\/ Source: composition "([^"]+)"/m.exec(artifact)?.[1] ?? null;
+  const manifestRaw = /const holoSceneManifest = (\{[\s\S]*?\});/.exec(artifact)?.[1];
+  if (manifestRaw) {
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestRaw);
+    } catch (e) {
+      throw new Error(
+        `deriveWebGPUPerception: holoSceneManifest is not valid JSON \u2014 refusing a malformed manifest (${e.message})`
+      );
+    }
+    const objects = manifest.objects;
+    if (!Array.isArray(objects)) {
+      throw new Error("deriveWebGPUPerception: holoSceneManifest has no objects[] \u2014 malformed manifest");
+    }
+    const entities2 = [];
+    const physicalEntities2 = [];
+    for (const o of objects) {
+      const id = typeof o.id === "string" ? o.id : "";
+      const traits = Array.isArray(o.traits) ? o.traits : [];
+      if (!id) continue;
+      const affordances = Array.isArray(o.affordances) ? o.affordances.filter((a) => typeof a === "string") : [];
+      const position = Array.isArray(o.position) && o.position.every((n) => Number.isFinite(n)) ? o.position : void 0;
+      const geometry = typeof o.geometry === "string" ? o.geometry : void 0;
+      if (traits.includes("agent")) {
+        const entity = {
+          id,
+          kind: "agent",
+          offerCount: affordances.length,
+          offers: affordances.map((action) => ({ action }))
+        };
+        if (geometry) entity.geometry = geometry;
+        if (position) entity.position = position;
+        entities2.push(entity);
+      }
+      if (o.visible === true) {
+        const physical = { id: canonicalPhysicalId(id), label: id };
+        if (geometry) physical.geometry = geometry;
+        if (position) physical.position = position;
+        if (physicalEntities2.some((e) => e.id === physical.id)) {
+          throw new Error(
+            `deriveWebGPUPerception: two scene objects fold to canonical id "${physical.id}" \u2014 refusing an ambiguous world`
+          );
+        }
+        physicalEntities2.push(physical);
+      }
+    }
+    return {
+      perceiver: WEBGPU_PERCEIVER,
+      artifactHash: createHash("sha256").update(artifact).digest("hex"),
+      expresses: [
+        "source-name",
+        "agent-entities",
+        "affordance-count",
+        "affordance-names",
+        // the manifest names actions — full parity (rycr)
+        "physical-entities",
+        "geometry",
+        "position"
+      ],
+      sourceName,
+      entities: entities2,
+      physicalEntities: physicalEntities2,
+      coverageGaps: []
+    };
+  }
+  const entities = [];
+  const physicalEntities = [];
+  const pushes = artifact.match(/holoGraphObjects\.push\(\{[\s\S]*?\}\);/g) ?? [];
+  for (const push of pushes) {
+    const id = /\bid: "([^"]+)"/.exec(push)?.[1];
+    const traitsRaw = /\btraits: (\[[^\]]*\])/.exec(push)?.[1];
+    if (!id || !traitsRaw) continue;
+    let traits;
+    try {
+      traits = JSON.parse(traitsRaw);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(traits)) continue;
+    const geometry = /\bgeometry: "([^"]+)"/.exec(push)?.[1];
+    const positionRaw = /\bposition: (\[[^\]]*\])/.exec(push)?.[1];
+    let position;
+    if (positionRaw) {
+      try {
+        const parsed = JSON.parse(positionRaw);
+        if (Array.isArray(parsed) && parsed.every((n) => Number.isFinite(n))) position = parsed;
+      } catch {
+      }
+    }
+    if (traits.includes("agent")) {
+      const entity = {
+        id,
+        kind: "agent",
+        offerCount: traits.filter((t) => t === "tool").length
+      };
+      if (geometry) entity.geometry = geometry;
+      if (position) entity.position = position;
+      entities.push(entity);
+    }
+    if (/\bvisible: true\b/.test(push)) {
+      const physical = { id: canonicalPhysicalId(id), label: id };
+      if (geometry) physical.geometry = geometry;
+      if (position) physical.position = position;
+      if (physicalEntities.some((e) => e.id === physical.id)) {
+        throw new Error(
+          `deriveWebGPUPerception: two scene objects fold to canonical id "${physical.id}" \u2014 refusing an ambiguous world`
+        );
+      }
+      physicalEntities.push(physical);
+    }
+  }
+  return {
+    perceiver: WEBGPU_PERCEIVER,
+    artifactHash: createHash("sha256").update(artifact).digest("hex"),
+    expresses: [
+      "source-name",
+      "agent-entities",
+      "affordance-count",
+      "physical-entities",
+      "geometry",
+      "position"
+    ],
+    sourceName,
+    entities,
+    physicalEntities,
+    coverageGaps: ["affordance-action-names"]
+  };
+}
+var AGENT_INFERENCE_PERCEIVER = "agent-inference";
+function deriveAgentInferencePerception(files) {
+  if (files == null || typeof files !== "object" || typeof files["config.json"] !== "string") {
+    throw new Error(
+      "deriveAgentInferencePerception: input is not an agent-inference artifact map (missing config.json)"
+    );
+  }
+  let config;
+  try {
+    config = JSON.parse(files["config.json"]);
+  } catch (e) {
+    throw new Error(
+      `deriveAgentInferencePerception: config.json is not valid JSON \u2014 refusing to derive from a malformed artifact (${e.message})`
+    );
+  }
+  const agents = config.agents;
+  if (!Array.isArray(agents)) {
+    throw new Error(
+      "deriveAgentInferencePerception: config.json has no agents[] \u2014 malformed artifact"
+    );
+  }
+  const banner = files["agent.ts"] ?? files["agent.py"] ?? "";
+  const structuredSource = config.source;
+  const sourceName = typeof structuredSource === "string" && structuredSource.length > 0 ? structuredSource : /^\s*\*\s*(.+?) — Agent Inference Script$/m.exec(banner)?.[1] ?? null;
+  const entities = agents.map((a) => {
+    const agent = a;
+    if (typeof agent.name !== "string" || agent.name.length === 0) {
+      throw new Error(
+        "deriveAgentInferencePerception: agent without a name in config.json \u2014 malformed artifact"
+      );
+    }
+    const details = Array.isArray(agent.tool_details) ? agent.tool_details.filter(
+      (t) => typeof t?.name === "string"
+    ) : null;
+    const offers = details ? details.map((t) => ({
+      action: t.name,
+      ...typeof t.target === "string" && t.target.length > 0 ? { target: t.target } : {}
+    })) : (Array.isArray(agent.tools) ? agent.tools.filter((t) => typeof t === "string") : []).map(
+      (action) => ({ action })
+    );
+    return {
+      id: agent.name,
+      kind: "agent",
+      offerCount: offers.length,
+      offers
+    };
+  });
+  const hash = createHash("sha256");
+  for (const name of Object.keys(files).sort()) {
+    hash.update(name).update("\0").update(files[name]).update("\0");
+  }
+  return {
+    perceiver: AGENT_INFERENCE_PERCEIVER,
+    artifactHash: hash.digest("hex"),
+    expresses: ["source-name", "agent-entities", "affordance-count", "affordance-names"],
+    sourceName,
+    entities,
+    coverageGaps: ["spatial-position", "geometry", "non-agent-entities"]
+  };
+}
+var URDF_PERCEIVER = "urdf";
+function deriveUrdfPerception(artifact) {
+  if (typeof artifact !== "string" || !/<robot[\s>]/.test(artifact)) {
+    throw new Error(
+      "deriveUrdfPerception: input is not a URDF robot description (missing <robot> element)"
+    );
+  }
+  const sourceName = /<!-- Source: composition "([^"]+)" -->/.exec(artifact)?.[1] ?? null;
+  const jointByChild = /* @__PURE__ */ new Map();
+  for (const joint of artifact.match(/<joint\s+[^>]*>[\s\S]*?<\/joint>/g) ?? []) {
+    const type = /<joint\s+[^>]*type="([^"]+)"/.exec(joint)?.[1];
+    const child = /<child\s+link="([^"]+)"/.exec(joint)?.[1];
+    if (!type || !child) continue;
+    const parsed = { type };
+    parsed.parent = /<parent\s+link="([^"]+)"/.exec(joint)?.[1];
+    const xyz = /<origin\s+xyz="([^"]+)"/.exec(joint)?.[1];
+    if (xyz) {
+      const parts = xyz.trim().split(/\s+/).map(Number);
+      if (parts.length === 3 && parts.every(Number.isFinite)) parsed.origin = parts;
+    }
+    const rpy = /<origin\s+[^>]*rpy="([^"]+)"/.exec(joint)?.[1];
+    if (rpy) {
+      const parts = rpy.trim().split(/\s+/).map(Number);
+      parsed.rotated = parts.some((v) => Number.isFinite(v) && Math.abs(v) > 1e-9);
+    }
+    const lower = /<limit\s+[^>]*lower="([\d.eE+-]+)"/.exec(joint)?.[1];
+    const upper = /<limit\s+[^>]*upper="([\d.eE+-]+)"/.exec(joint)?.[1];
+    if (lower != null && Number.isFinite(Number(lower))) parsed.lower = Number(lower);
+    if (upper != null && Number.isFinite(Number(upper))) parsed.upper = Number(upper);
+    jointByChild.set(child, parsed);
+  }
+  function worldChainOrigin(link) {
+    const sum = [0, 0, 0];
+    let cur = link;
+    for (let hops = 0; cur && hops < 64; hops++) {
+      const j = jointByChild.get(cur);
+      if (!j) return sum;
+      if (j.rotated) return null;
+      if (j.origin) {
+        sum[0] += j.origin[0];
+        sum[1] += j.origin[1];
+        sum[2] += j.origin[2];
+      }
+      cur = j.parent;
+    }
+    return cur ? null : sum;
+  }
+  const physicalEntities = [];
+  const links = artifact.match(/<link\s+name="[^"]+">[\s\S]*?<\/link>/g) ?? [];
+  for (const link of links) {
+    const label = /<link\s+name="([^"]+)">/.exec(link)?.[1];
+    if (!label) continue;
+    const visual = /<visual>([\s\S]*?)<\/visual>/.exec(link)?.[1];
+    if (!visual) continue;
+    const entity = { id: canonicalPhysicalId(label), label };
+    const geom = /<geometry>\s*<(\w+)[\s/>]/.exec(visual)?.[1];
+    if (geom) entity.geometry = geom;
+    const sphereR = /<sphere\s+radius="([\d.eE+-]+)"/.exec(visual)?.[1];
+    const boxSize = /<box\s+size="([^"]+)"/.exec(visual)?.[1];
+    const cyl = /<cylinder\s+radius="([\d.eE+-]+)"\s+length="([\d.eE+-]+)"/.exec(visual);
+    if (sphereR != null && Number.isFinite(Number(sphereR))) {
+      entity.extent = Number(sphereR);
+    } else if (boxSize) {
+      const dims = boxSize.trim().split(/\s+/).map(Number);
+      if (dims.length === 3 && dims.every(Number.isFinite)) {
+        entity.extent = Math.hypot(...dims) / 2;
+      }
+    } else if (cyl && Number.isFinite(Number(cyl[1])) && Number.isFinite(Number(cyl[2]))) {
+      entity.extent = Math.hypot(Number(cyl[1]), Number(cyl[2]) / 2);
+    }
+    const world = worldChainOrigin(label);
+    if (world) entity.position = world;
+    const joint = jointByChild.get(label);
+    const jointType = joint?.type ?? "fixed";
+    entity.mobility = jointType === "fixed" ? "fixed" : "actuated";
+    if (world && entity.extent != null) {
+      entity.reachCenter = world;
+      if (jointType === "fixed") {
+        entity.reachRadius = entity.extent;
+      } else if (jointType === "revolute" || jointType === "continuous") {
+        entity.reachRadius = entity.extent;
+      } else if (jointType === "prismatic" && joint?.lower != null && joint?.upper != null) {
+        entity.reachRadius = entity.extent + Math.max(Math.abs(joint.lower), Math.abs(joint.upper));
+      }
+    }
+    if (physicalEntities.some((e) => e.id === entity.id)) {
+      throw new Error(
+        `deriveUrdfPerception: two links fold to canonical id "${entity.id}" \u2014 refusing an ambiguous world`
+      );
+    }
+    physicalEntities.push(entity);
+  }
+  return {
+    perceiver: URDF_PERCEIVER,
+    artifactHash: createHash("sha256").update(artifact).digest("hex"),
+    expresses: ["source-name", "physical-entities", "geometry", "position"],
+    sourceName,
+    entities: [],
+    // URDF has no agent vocabulary — abstains from agent facts
+    physicalEntities,
+    coverageGaps: ["agent-entities", "affordance-count", "affordance-action-names"]
+  };
+}
+
+// src/reconstruction/enforceVerifiedViewReceipts.ts
+var BINDING_TRAITS = ["bind", "chart", "sparkline", "model", "each"];
+function isDegenerateParse(comp) {
+  const noRealName = !comp.name || comp.name === "implicit";
+  const noObjects = (comp.objects?.length ?? 0) === 0;
+  const noState = (comp.state?.properties?.length ?? 0) === 0;
+  return noRealName && noObjects && noState;
+}
+function derivedProjectionNode(config) {
+  const state = config?.state;
+  if (typeof state !== "string" || !state) return null;
+  const path = config?.path;
+  return typeof path === "string" && path ? `${state}.${path}` : state;
+}
+function firstBindingTrait(traits) {
+  return traits.find((t) => typeof t.name === "string" && BINDING_TRAITS.includes(t.name));
+}
+function collectTargets(objects, out, flags) {
+  for (const o of objects ?? []) {
+    const traits = o.traits ?? [];
+    const bindTrait = firstBindingTrait(traits);
+    if (bindTrait) {
+      const node = derivedProjectionNode(bindTrait.config);
+      if (node) {
+        flags.anyBinding = true;
+        const hasProjects = traits.some((t) => t.name === "projects");
+        if (!hasProjects && typeof o.name === "string" && o.name) {
+          out.push({ object: o.name, node });
+        }
+      }
+    }
+    collectTargets(o.children, out, flags);
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchBrace(source, bodyStart) {
+  let depth = 1;
+  let inString = false;
+  for (let i = bodyStart; i < source.length; i++) {
+    const ch = source[i];
+    if (inString) {
+      if (ch === "\\") {
+        i++;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function injectProjectsIntoObject(source, objectName, node) {
+  const re = new RegExp(`object\\s+"${escapeRegExp(objectName)}"\\s*\\{`, "g");
+  let m;
+  while ((m = re.exec(source)) !== null) {
+    const bodyStart = m.index + m[0].length;
+    const close = matchBrace(source, bodyStart);
+    if (close < 0) return source;
+    const body = source.slice(bodyStart, close);
+    if (body.includes("@projects")) {
+      re.lastIndex = close;
+      continue;
+    }
+    const lineStart = source.lastIndexOf("\n", close - 1) + 1;
+    const braceIndent = source.slice(lineStart, close).match(/^[ \t]*/)?.[0] ?? "";
+    const innerIndent = braceIndent + "  ";
+    const injection = `${innerIndent}@projects { node: "${node}" }
+`;
+    return source.slice(0, lineStart) + injection + source.slice(lineStart);
+  }
+  return source;
+}
+function injectVerifiedView(source) {
+  const m = /composition(?:\s+"[^"]*")?\s*\{/.exec(source);
+  if (!m) return source;
+  const insertAt = m.index + m[0].length;
+  return `${source.slice(0, insertAt)}
+  @verified_view${source.slice(insertAt)}`;
+}
+function enforceVerifiedViewReceipts(source) {
+  let parsed;
+  try {
+    parsed = parseHolo(source);
+  } catch {
+    return source;
+  }
+  if (!parsed || !parsed.success || !parsed.ast) return source;
+  const comp = parsed.ast;
+  const targets = [];
+  const flags = { anyBinding: false };
+  collectTargets(comp.objects, targets, flags);
+  const hasVerifiedView = (comp.traits ?? []).some((t) => t?.name === "verified_view");
+  const needVerifiedView = flags.anyBinding && !hasVerifiedView;
+  if (targets.length === 0 && !needVerifiedView) return source;
+  let out = source;
+  for (const t of targets) out = injectProjectsIntoObject(out, t.object, t.node);
+  if (needVerifiedView) out = injectVerifiedView(out);
+  return out;
+}
+var UNPARSEABLE = {
+  parsed: false,
+  hasBindings: false,
+  verifiedViewOn: false,
+  complete: false,
+  violations: []
+};
+function diagnoseVerifiedView(source) {
+  let parsed;
+  try {
+    parsed = parseHolo(source);
+  } catch {
+    return UNPARSEABLE;
+  }
+  if (!parsed || !parsed.success || !parsed.ast) return UNPARSEABLE;
+  const comp = parsed.ast;
+  if (isDegenerateParse(comp)) return UNPARSEABLE;
+  const roots = new Set((comp.state?.properties ?? []).map((p) => p.key));
+  const scanRoots = (objs) => {
+    for (const o of objs ?? []) {
+      for (const t of o.traits ?? []) {
+        if (t.name === "fetch") {
+          const into = t.config?.into;
+          roots.add(typeof into === "string" && into ? into : "data");
+        }
+        if (t.name === "each") {
+          const as = t.config?.as;
+          roots.add(typeof as === "string" && as ? as : "item");
+        }
+        if (t.name === "computed") {
+          const nm = t.config?.name;
+          if (typeof nm === "string" && nm) roots.add(nm);
+        }
+        if (t.name === "hook") {
+          const returns = t.config?.returns;
+          if (typeof returns === "string") {
+            for (const r of returns.split(",").map((s) => s.trim())) {
+              if (r) roots.add(r);
+            }
+          }
+        }
+      }
+      scanRoots(o.children);
+    }
+  };
+  scanRoots(comp.objects);
+  const verifiedViewOn = (comp.traits ?? []).some((t) => t?.name === "verified_view");
+  const violations = [];
+  let hasBindings = false;
+  const walk = (objs) => {
+    for (const o of objs ?? []) {
+      const traits = o.traits ?? [];
+      const el = typeof o.name === "string" && o.name ? o.name : "element";
+      const bindTrait = firstBindingTrait(traits);
+      const node = bindTrait ? derivedProjectionNode(bindTrait.config) : null;
+      const projectsTrait = traits.find((t) => t.name === "projects");
+      const claimedRaw = projectsTrait?.config?.node;
+      const claimed = typeof claimedRaw === "string" ? claimedRaw : null;
+      if (node) {
+        hasBindings = true;
+        if (!projectsTrait) {
+          violations.push({
+            element: el,
+            node,
+            reason: "missing-projects",
+            detail: `renders "${node}" but declares no @projects receipt`
+          });
+        } else if (claimed !== node) {
+          violations.push({
+            element: el,
+            node: claimed,
+            reason: "mismatched-node",
+            detail: `claims to project "${claimed ?? ""}" but is bound to "${node}"`
+          });
+        } else if (!roots.has(node.split(".")[0])) {
+          violations.push({
+            element: el,
+            node,
+            reason: "hallucinated-root",
+            detail: `projects "${node}" but no state node "${node.split(".")[0]}" exists`
+          });
+        }
+      } else if (projectsTrait) {
+        violations.push({
+          element: el,
+          node: claimed,
+          reason: "projects-without-binding",
+          detail: `claims to project "${claimed ?? ""}" but has no data binding`
+        });
+      }
+      walk(o.children);
+    }
+  };
+  walk(comp.objects);
+  if (hasBindings && !verifiedViewOn) {
+    violations.push({
+      element: "(composition)",
+      node: null,
+      reason: "no-verified-view",
+      detail: "surface binds data but does not declare composition-level @verified_view"
+    });
+  }
+  return { parsed: true, hasBindings, verifiedViewOn, complete: violations.length === 0, violations };
+}
+function isProvenanceComplete(source) {
+  return diagnoseVerifiedView(source).complete;
+}
+var SURFACE_TWIN_VERSION = "surface-twin-v1";
+function resolveAuthoritative(entityState, node) {
+  if (entityState === void 0) return { found: false, value: null };
+  if (entityState === null || typeof entityState !== "object") {
+    return { found: true, value: entityState };
+  }
+  const dot = node.indexOf(".");
+  const field = dot >= 0 ? node.slice(dot + 1) : node;
+  let cur = entityState;
+  for (const seg of field.split(".")) {
+    if (cur !== null && typeof cur === "object" && seg in cur) {
+      cur = cur[seg];
+    } else {
+      return { found: false, value: null };
+    }
+  }
+  return { found: true, value: cur };
+}
+function displayEquals(a, b) {
+  return String(a) === String(b);
+}
+function applyProjectionTransform(raw, transform) {
+  const base = raw ?? 0;
+  const value = transform.precision !== void 0 ? Number(base).toFixed(transform.precision) : String(base);
+  return `${transform.prefix ?? ""}${value}${transform.suffix ?? ""}`;
+}
+function checkSurfaceTwinCorrespondence(input) {
+  const { contract, displayedValues, authoritativeState } = input;
+  const unavailable = new Set(input.unavailableEntities ?? []);
+  const divergences = [];
+  const abstentions = [];
+  let checked = 0;
+  for (const p of contract.projections ?? []) {
+    if (!p.entity) {
+      abstentions.push({ node: p.node, reason: "no-entity-binding" });
+      continue;
+    }
+    const transform = p.transform;
+    if (!p.identity && !transform) {
+      abstentions.push({ node: p.node, entity: p.entity, reason: "non-identity-transform" });
+      continue;
+    }
+    if (unavailable.has(p.entity)) {
+      abstentions.push({ node: p.node, entity: p.entity, reason: "authority-unavailable" });
+      continue;
+    }
+    if (!(p.node in displayedValues)) {
+      abstentions.push({ node: p.node, entity: p.entity, reason: "display-missing" });
+      continue;
+    }
+    const auth = resolveAuthoritative(authoritativeState[p.entity], p.node);
+    if (!auth.found) {
+      abstentions.push({ node: p.node, entity: p.entity, reason: "authority-missing" });
+      continue;
+    }
+    checked++;
+    const displayed = displayedValues[p.node];
+    const expected = transform ? applyProjectionTransform(auth.value, transform) : auth.value;
+    if (!displayEquals(displayed, expected)) {
+      divergences.push({
+        node: p.node,
+        entity: p.entity,
+        displayed,
+        authoritative: auth.value,
+        ...transform ? { expected } : {},
+        detail: transform ? `surface shows ${JSON.stringify(displayed)} but twin "${p.entity}" holds ${JSON.stringify(auth.value)} which formats to ${JSON.stringify(expected)}` : `surface shows ${JSON.stringify(displayed)} but twin "${p.entity}" holds ${JSON.stringify(auth.value)}`
+      });
+    }
+  }
+  const verdict = divergences.length > 0 ? "FALSIFIED" : "CONSENSUS";
+  const canonical = JSON.stringify({
+    version: SURFACE_TWIN_VERSION,
+    verdict,
+    checked,
+    divergences: [...divergences].sort((a, b) => a.node.localeCompare(b.node)),
+    abstentions: [...abstentions].sort(
+      (a, b) => (a.node + a.reason).localeCompare(b.node + b.reason)
+    )
+  });
+  const receiptHash = createHash("sha256").update(canonical).digest("hex");
+  return { version: SURFACE_TWIN_VERSION, verdict, checked, divergences, abstentions, receiptHash };
+}
+async function verifySurfaceTwinLive(input) {
+  const { contract, displayedValues, fetchAuthoritativeState } = input;
+  const entities = [
+    ...new Set(
+      (contract.projections ?? []).map((p) => p.entity).filter((e) => typeof e === "string" && e.length > 0)
+    )
+  ];
+  const authoritativeState = {};
+  const unavailableEntities = [];
+  const results = await Promise.allSettled(entities.map((e) => fetchAuthoritativeState(e)));
+  results.forEach((r, i) => {
+    const entity = entities[i];
+    if (r.status === "fulfilled" && r.value !== null && r.value !== void 0) {
+      authoritativeState[entity] = r.value;
+    } else {
+      unavailableEntities.push(entity);
+    }
+  });
+  return checkSurfaceTwinCorrespondence({
+    contract,
+    displayedValues,
+    authoritativeState,
+    unavailableEntities
+  });
+}
+
+// src/reconstruction/extractDisplayedProjections.ts
+var HTML_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&#x27;": "'"
+};
+function decodeEntities(s) {
+  return s.replace(/&(?:amp|lt|gt|quot|#39|#x27);/g, (m) => HTML_ENTITIES[m] ?? m);
+}
+function textContent(inner) {
+  return decodeEntities(inner.replace(/<[^>]*>/g, "")).replace(/\s+/g, " ").trim();
+}
+function extractDisplayedProjections(html) {
+  const out = {};
+  const attrRe = /data-holo-projects="([^"]+)"/g;
+  let m;
+  while ((m = attrRe.exec(html)) !== null) {
+    const node = m[1];
+    if (node in out) continue;
+    const lt = html.lastIndexOf("<", m.index);
+    if (lt < 0) continue;
+    const tagMatch = /^<([a-zA-Z][a-zA-Z0-9-]*)/.exec(html.slice(lt, m.index + 1));
+    if (!tagMatch) continue;
+    const tag = tagMatch[1];
+    const openEnd = html.indexOf(">", m.index);
+    if (openEnd < 0) continue;
+    if (html[openEnd - 1] === "/") {
+      out[node] = "";
+      continue;
+    }
+    const contentStart = openEnd + 1;
+    const openRe = new RegExp(`<${tag}(?=[\\s/>])`, "g");
+    const close = `</${tag}>`;
+    let depth = 1;
+    let i = contentStart;
+    while (i < html.length && depth > 0) {
+      const nextClose = html.indexOf(close, i);
+      if (nextClose < 0) break;
+      openRe.lastIndex = i;
+      const openM = openRe.exec(html);
+      if (openM && openM.index < nextClose) {
+        depth++;
+        i = openM.index + tag.length + 1;
+      } else {
+        depth--;
+        if (depth === 0) {
+          out[node] = textContent(html.slice(contentStart, nextClose));
+        }
+        i = nextClose + close.length;
+      }
+    }
+  }
+  return out;
+}
+
+export { AGENT_INFERENCE_PERCEIVER, ANCHOR_DEFAULTS, ARCORE_DEPTH_RECOMMENDED_RANGE_MILLIMETERS, HOLOMAP_MOBILE_SENSOR_BUNDLE_VERSION, PERCEIVER_CONSENSUS_VERSION, PERCEIVER_FACT_CLASSES, POSITION_EPSILON, SURFACE_TWIN_VERSION, TRAJECTORY_DEFAULTS, URDF_PERCEIVER, WEBGPU_PERCEIVER, applyProjectionTransform, arCoreDepthFrameToMobileSensorFrame, cameraPoseFromColumnMajorTransform, canonicalPhysicalId, checkSurfaceTwinCorrespondence, createAnchorContext, createArCoreDepthMobileSensorBundle, createFusedAttentionBackend, createTrajectoryMemory, deriveAgentInferencePerception, derivePerceiverConsensus, deriveUrdfPerception, deriveWebGPUPerception, derivedProjectionNode, diagnoseVerifiedView, enforceVerifiedViewReceipts, extractDisplayedProjections, isProvenanceComplete, mobileSensorBundleToFrames, replayMobileSensorBundle, validateMobileSensorBundle, verifySurfaceTwinLive };
+//# sourceMappingURL=chunk-7ZKQ32XK.js.map
+//# sourceMappingURL=chunk-7ZKQ32XK.js.map