@holoscript/core 8.0.7 → 8.0.9

package/dist/{chunk-WFKVS2K4.cjs → chunk-AUZRKIHQ.cjs}

@@ -1,12 +1,12 @@
 'use strict';
 
 var chunkLM2VU56C_cjs = require('./chunk-LM2VU56C.cjs');
-var chunkT6W3Z3SH_cjs = require('./chunk-T6W3Z3SH.cjs');
+var chunkN2ILK7BF_cjs = require('./chunk-N2ILK7BF.cjs');
 
 // src/version.ts
-var HOLOSCRIPT_VERSION = "8.0.6" ;
-var GIT_COMMIT_SHA = "33f2b3e49" ;
-var BUILD_TIMESTAMP = "2026-06-08T22:53:19.715Z" ;
+var HOLOSCRIPT_VERSION = "8.0.9" ;
+var GIT_COMMIT_SHA = "67dd1e5dd" ;
+var BUILD_TIMESTAMP = "2026-07-05T21:49:25.063Z" ;
 function getVersionString() {
   const sha = `+${GIT_COMMIT_SHA}` ;
   return `${HOLOSCRIPT_VERSION}${sha}`;
@@ -281,7 +281,7 @@ function createLayerNormKernel(device) {
         usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
       });
       const paramsBuf = createParamsBuffer(device, rows, dModel, eps);
-      const readback = device.createBuffer({
+      const readback2 = device.createBuffer({
         size: input.byteLength,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
       });
@@ -303,18 +303,18 @@ function createLayerNormKernel(device) {
         pass.dispatchWorkgroups(rows, 1, 1);
         pass.end();
       }
-      encoder.copyBufferToBuffer(outputBuf, 0, readback, 0, input.byteLength);
+      encoder.copyBufferToBuffer(outputBuf, 0, readback2, 0, input.byteLength);
       device.queue.submit([encoder.finish()]);
-      await readback.mapAsync(GPUMapMode.READ);
-      const bytes = readback.getMappedRange();
+      await readback2.mapAsync(GPUMapMode.READ);
+      const bytes = readback2.getMappedRange();
       const out = new Float32Array(bytes.slice(0));
-      readback.unmap();
+      readback2.unmap();
       inputBuf.destroy();
       gammaBuf.destroy();
       betaBuf.destroy();
       outputBuf.destroy();
       paramsBuf.destroy();
-      readback.destroy();
+      readback2.destroy();
       return out;
     }
   };
@@ -791,7 +791,7 @@ function createGeluKernel(device) {
         usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
       });
       const paramsBuf = createParamsBuffer3(device, input.length);
-      const readback = device.createBuffer({
+      const readback2 = device.createBuffer({
         size: input.byteLength,
         usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
       });
@@ -811,16 +811,16 @@ function createGeluKernel(device) {
         pass.dispatchWorkgroups(1, 1, 1);
         pass.end();
       }
-      encoder.copyBufferToBuffer(outputBuf, 0, readback, 0, input.byteLength);
+      encoder.copyBufferToBuffer(outputBuf, 0, readback2, 0, input.byteLength);
       device.queue.submit([encoder.finish()]);
-      await readback.mapAsync(GPUMapMode.READ);
-      const bytes = readback.getMappedRange();
+      await readback2.mapAsync(GPUMapMode.READ);
+      const bytes = readback2.getMappedRange();
       const out = new Float32Array(bytes.slice(0));
-      readback.unmap();
+      readback2.unmap();
       inputBuf.destroy();
       outputBuf.destroy();
       paramsBuf.destroy();
-      readback.destroy();
+      readback2.destroy();
       return out;
     }
   };
@@ -833,6 +833,7 @@ var NUM_HEADS = 4;
 var HEAD_DIM = 8;
 var PATCH_LEN = MICRO * MICRO * 3;
 var weightCache = /* @__PURE__ */ new Map();
+var weightBlobKeyCache = /* @__PURE__ */ new WeakMap();
 function hashConfigSeed(config) {
   let h = config.seed >>> 0;
   const s = config.modelHash || "";
@@ -856,7 +857,99 @@ function fillGaussian2D(out, rng, scale) {
 function microWeightKey(config) {
   return `${config.seed}\0${config.modelHash || ""}`;
 }
+var MICRO_WEIGHT_MAGIC = [72, 77, 87, 49];
+var MICRO_WEIGHT_VERSION = 1;
+var MICRO_WEIGHT_FLOATS = EMBED_DIM * PATCH_LEN + // proj
+3 * EMBED_DIM * EMBED_DIM + // Wq, Wk, Wv
+EMBED_DIM * 3 + // Wxyz
+4 * EMBED_DIM;
+var MICRO_WEIGHT_BYTES = 8 + MICRO_WEIGHT_FLOATS * 4;
+function toUint8(bytes) {
+  return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+}
+function fnv1a(bytes) {
+  let h = 2166136261;
+  for (let i = 0; i < bytes.length; i += 1) {
+    h ^= bytes[i];
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function cachedWeightBlobKey(input) {
+  const bytes = toUint8(input);
+  const cached = weightBlobKeyCache.get(input);
+  if (cached) return { bytes, key: cached };
+  const key = `${bytes.byteLength}:${fnv1a(bytes)}`;
+  weightBlobKeyCache.set(input, key);
+  return { bytes, key };
+}
+function serializeMicroWeights(w) {
+  const bytes = new Uint8Array(MICRO_WEIGHT_BYTES);
+  bytes.set(MICRO_WEIGHT_MAGIC, 0);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(4, MICRO_WEIGHT_VERSION, true);
+  let off = 8;
+  const put = (arr) => {
+    for (let i = 0; i < arr.length; i += 1) {
+      view.setFloat32(off, arr[i], true);
+      off += 4;
+    }
+  };
+  put(w.proj);
+  put(w.Wq);
+  put(w.Wk);
+  put(w.Wv);
+  put(w.Wxyz);
+  put(w.gamma1);
+  put(w.beta1);
+  put(w.gamma2);
+  put(w.beta2);
+  return bytes;
+}
+function deserializeMicroWeights(input) {
+  const bytes = toUint8(input);
+  if (bytes.byteLength !== MICRO_WEIGHT_BYTES) return null;
+  for (let i = 0; i < 4; i += 1) {
+    if (bytes[i] !== MICRO_WEIGHT_MAGIC[i]) return null;
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint32(4, true) !== MICRO_WEIGHT_VERSION) return null;
+  let off = 8;
+  const take = (count) => {
+    const out = new Float32Array(count);
+    for (let i = 0; i < count; i += 1) {
+      out[i] = view.getFloat32(off, true);
+      off += 4;
+    }
+    return out;
+  };
+  return {
+    proj: take(EMBED_DIM * PATCH_LEN),
+    Wq: take(EMBED_DIM * EMBED_DIM),
+    Wk: take(EMBED_DIM * EMBED_DIM),
+    Wv: take(EMBED_DIM * EMBED_DIM),
+    Wxyz: take(EMBED_DIM * 3),
+    gamma1: take(EMBED_DIM),
+    beta1: take(EMBED_DIM),
+    gamma2: take(EMBED_DIM),
+    beta2: take(EMBED_DIM)
+  };
+}
 function getMicroWeights(config) {
+  if (config.weightBytes) {
+    const { bytes: wb, key: blobKey } = cachedWeightBlobKey(config.weightBytes);
+    const ckptKey = `${microWeightKey(config)}\0ckpt:${blobKey}`;
+    const cachedReal = weightCache.get(ckptKey);
+    if (cachedReal) return cachedReal;
+    const real = deserializeMicroWeights(wb);
+    if (real) {
+      weightCache.set(ckptKey, real);
+      return real;
+    }
+    console.warn(
+      `[holoMapMicroEncoder] weightBytes present (${wb.byteLength} B) but not a valid HMW1 checkpoint (expected ${MICRO_WEIGHT_BYTES} B + magic) \u2014 falling back to PRNG-synthesized weights.`
+    );
+  }
   const key = microWeightKey(config);
   const cached = weightCache.get(key);
   if (cached) return cached;
@@ -1449,6 +1542,615 @@ async function putCachedWeightBlob(weightCid, value) {
   }
 }
 
+// src/reconstruction/holoMapAnchoredManifest.ts
+function mergeAnchoredProvenance(manifest, urls) {
+  return {
+    ...manifest,
+    provenance: {
+      ...manifest.provenance,
+      anchorHash: urls.anchorHash,
+      opentimestampsProof: urls.opentimestampsProof,
+      baseCalldataTx: urls.baseCalldataTx,
+      capturedAtIso: manifest.provenance.capturedAtIso
+    }
+  };
+}
+function stripAnchoredProvenance(manifest) {
+  return {
+    ...manifest,
+    provenance: {
+      capturedAtIso: manifest.provenance.capturedAtIso
+    }
+  };
+}
+function selfAttestReconstructionManifest(manifest) {
+  const stripped = stripAnchoredProvenance(manifest);
+  return {
+    ...stripped,
+    provenance: {
+      ...stripped.provenance,
+      anchorHash: `self-attested:${stripped.replayHash}`
+    }
+  };
+}
+async function computeReconstructionManifestDigest(manifest) {
+  const canonical = stableStringify(stripAnchoredProvenance(manifest));
+  return `sha256:${await sha256Hex(canonical)}`;
+}
+async function anchorReconstructionManifest(manifest, provider) {
+  const stripped = stripAnchoredProvenance(manifest);
+  if (!provider) return selfAttestReconstructionManifest(stripped);
+  const manifestDigest = await computeReconstructionManifestDigest(stripped);
+  const urls = await provider.anchorManifest({
+    manifestDigest,
+    replayHash: stripped.replayHash,
+    replayFingerprint: stripped.simulationContract.replayFingerprint,
+    capturedAtIso: stripped.provenance.capturedAtIso,
+    manifest: stripped
+  });
+  if (!urls) return selfAttestReconstructionManifest(stripped);
+  return mergeAnchoredProvenance(stripped, urls);
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).sort(([a], [b]) => a.localeCompare(b));
+  return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+}
+async function sha256Hex(input) {
+  const bytes = new TextEncoder().encode(input);
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle) {
+    const digest = await subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  const { createHash } = await import('crypto');
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+// src/reconstruction/pagedKVKernels.ts
+var WGSL_PAGED_KV_APPEND = `
+struct AppendParams {
+  numVecs:  u32,   // number of NEW vectors to append
+  headDim:  u32,   // dimension of each vector
+  pageSize: u32,   // vectors per page
+}
+// kv_pages: flat storage for all pages. page p, slot s, dim d:
+//   index = pageTable[p] * pageSize * headDim + s * headDim + d
+@group(0) @binding(0) var<storage, read>       newVecs:   array<f32>;   // [numVecs * headDim]
+@group(0) @binding(1) var<storage, read>       pageTable: array<u32>;   // logical page \u2192 base offset in kv_pages (in elements)
+@group(0) @binding(2) var<storage, read>       slotMap:   array<u32>;   // per-vector: (logicalPage << 16 | slotInPage)
+@group(0) @binding(3) var<storage, read_write> kvPages:   array<f32>;   // output KV store
+@group(0) @binding(4) var<uniform>             p:         AppendParams;
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  // gid.x spans numVecs * headDim
+  let total = p.numVecs * p.headDim;
+  if (gid.x >= total) { return; }
+  let vecIdx  = gid.x / p.headDim;
+  let dimIdx  = gid.x % p.headDim;
+  let slot    = slotMap[vecIdx];
+  let logPage = slot >> 16u;
+  let inPage  = slot & 0xFFFFu;
+  let base    = pageTable[logPage] * p.pageSize * p.headDim;
+  kvPages[base + inPage * p.headDim + dimIdx] = newVecs[vecIdx * p.headDim + dimIdx];
+}
+`;
+var WGSL_PAGED_KV_LOOKUP = `
+struct LookupParams {
+  numVecs:    u32,   // number of vectors to read
+  headDim:    u32,
+  pageSize:   u32,
+  startSlot:  u32,   // logical first slot (token offset)
+}
+@group(0) @binding(0) var<storage, read>       kvPages:   array<f32>;
+@group(0) @binding(1) var<storage, read>       pageTable: array<u32>;  // logical page \u2192 base offset (in elements)
+@group(0) @binding(2) var<storage, read_write> out:       array<f32>;  // [numVecs * headDim]
+@group(0) @binding(3) var<uniform>             p:         LookupParams;
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let total = p.numVecs * p.headDim;
+  if (gid.x >= total) { return; }
+  let vecIdx   = gid.x / p.headDim;
+  let dimIdx   = gid.x % p.headDim;
+  let logSlot  = (vecIdx + p.startSlot);
+  let logPage  = logSlot / p.pageSize;
+  let inPage   = logSlot % p.pageSize;
+  let base     = pageTable[logPage] * p.pageSize * p.headDim;
+  out[gid.x]   = kvPages[base + inPage * p.headDim + dimIdx];
+}
+`;
+function storageBuffer4(device, data) {
+  const buf = device.createBuffer({
+    size: data.byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(buf, 0, data.buffer, data.byteOffset, data.byteLength);
+  return buf;
+}
+function outputBuffer(device, bytes) {
+  return device.createBuffer({
+    size: bytes,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+}
+function uniformBuffer(device, data) {
+  const buf = device.createBuffer({
+    size: data.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(buf, 0, data);
+  return buf;
+}
+async function readback(device, src, bytes) {
+  const staging = device.createBuffer({
+    size: bytes,
+    usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+  });
+  const enc = device.createCommandEncoder();
+  enc.copyBufferToBuffer(src, 0, staging, 0, bytes);
+  device.queue.submit([enc.finish()]);
+  await staging.mapAsync(GPUMapMode.READ);
+  const result = new Float32Array(staging.getMappedRange().slice(0));
+  staging.unmap();
+  staging.destroy();
+  return result;
+}
+function createPagedKVAppendKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_PAGED_KV_APPEND });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(kvPagesData, pageTableData, slotMapData, newVectors, pageSize, headDim) {
+      const numVecs = newVectors.length / headDim;
+      const kvBuf = device.createBuffer({
+        size: kvPagesData.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
+      });
+      device.queue.writeBuffer(
+        kvBuf,
+        0,
+        kvPagesData.buffer,
+        kvPagesData.byteOffset,
+        kvPagesData.byteLength
+      );
+      const newVecsBuf = storageBuffer4(device, newVectors);
+      const pageTableBuf = storageBuffer4(device, pageTableData);
+      const slotMapBuf = storageBuffer4(device, slotMapData);
+      const paramAB = new ArrayBuffer(16);
+      new Uint32Array(paramAB)[0] = numVecs;
+      new Uint32Array(paramAB)[1] = headDim;
+      new Uint32Array(paramAB)[2] = pageSize;
+      const paramsBuf = uniformBuffer(device, paramAB);
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: newVecsBuf } },
+          { binding: 1, resource: { buffer: pageTableBuf } },
+          { binding: 2, resource: { buffer: slotMapBuf } },
+          { binding: 3, resource: { buffer: kvBuf } },
+          { binding: 4, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const total = numVecs * headDim;
+      const workgroups = Math.ceil(total / 64);
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(workgroups);
+      pass.end();
+      device.queue.submit([enc.finish()]);
+      const result = await readback(device, kvBuf, kvPagesData.byteLength);
+      newVecsBuf.destroy();
+      pageTableBuf.destroy();
+      slotMapBuf.destroy();
+      kvBuf.destroy();
+      paramsBuf.destroy();
+      return result;
+    }
+  };
+}
+function createPagedKVLookupKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_PAGED_KV_LOOKUP });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(kvPagesData, pageTableData, numVecs, startSlot, pageSize, headDim) {
+      const outBytes = numVecs * headDim * 4;
+      const kvBuf = storageBuffer4(device, kvPagesData);
+      const pageTableBuf = storageBuffer4(device, pageTableData);
+      const outBuf = outputBuffer(device, outBytes);
+      const paramAB = new ArrayBuffer(16);
+      const pu = new Uint32Array(paramAB);
+      pu[0] = numVecs;
+      pu[1] = headDim;
+      pu[2] = pageSize;
+      pu[3] = startSlot;
+      const paramsBuf = uniformBuffer(device, paramAB);
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: kvBuf } },
+          { binding: 1, resource: { buffer: pageTableBuf } },
+          { binding: 2, resource: { buffer: outBuf } },
+          { binding: 3, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const total = numVecs * headDim;
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(Math.ceil(total / 64));
+      pass.end();
+      device.queue.submit([enc.finish()]);
+      const result = await readback(device, outBuf, outBytes);
+      kvBuf.destroy();
+      pageTableBuf.destroy();
+      outBuf.destroy();
+      paramsBuf.destroy();
+      return result;
+    }
+  };
+}
+
+// src/reconstruction/PagedKVCache.ts
+var PAGE_TABLE_EMPTY = 4294967295;
+function createPagedKVCache(config) {
+  validateConfig(config);
+  const layers = Array.from({ length: config.numLayers }, () => ({
+    pages: /* @__PURE__ */ new Map(),
+    nextToken: 0
+  }));
+  const pageBytes = config.pageSize * config.hiddenDim * Float32Array.BYTES_PER_ELEMENT;
+  const keyPages = new Float32Array(config.maxResidentPages * config.pageSize * config.hiddenDim);
+  const valuePages = new Float32Array(config.maxResidentPages * config.pageSize * config.hiddenDim);
+  const freePhysicalPages = Array.from({ length: config.maxResidentPages }, (_, i) => i).reverse();
+  const appendKernel = config.device ? createPagedKVAppendKernel(config.device) : null;
+  const lookupKernel = config.device ? createPagedKVLookupKernel(config.device) : null;
+  let disposed = false;
+  let nextPageId = 0;
+  let accessClock = 0;
+  function assertLive() {
+    if (disposed) throw new Error("PagedKVCache has been disposed.");
+  }
+  function validateLayer(layer) {
+    if (!Number.isInteger(layer) || layer < 0 || layer >= config.numLayers) {
+      throw new Error(`PagedKVCache layer ${layer} out of range 0..${config.numLayers - 1}`);
+    }
+  }
+  function pageSnapshot(page) {
+    return {
+      pageId: page.pageId,
+      layer: page.layer,
+      residency: page.residency,
+      firstToken: page.firstToken,
+      lastToken: page.lastToken
+    };
+  }
+  function pageOffset(physicalPage) {
+    return physicalPage * config.pageSize * config.hiddenDim;
+  }
+  function copyResidentPage(page, keys, values) {
+    if (page.physicalPage === null) return;
+    const offset = pageOffset(page.physicalPage);
+    const end = offset + config.pageSize * config.hiddenDim;
+    keys.set(keyPages.subarray(offset, end));
+    values.set(valuePages.subarray(offset, end));
+  }
+  function zeroPhysicalPage(physicalPage) {
+    const offset = pageOffset(physicalPage);
+    const end = offset + config.pageSize * config.hiddenDim;
+    keyPages.fill(0, offset, end);
+    valuePages.fill(0, offset, end);
+  }
+  function residentPages() {
+    return layers.flatMap(
+      (layer) => Array.from(layer.pages.values()).filter((page) => page.residency === "device")
+    );
+  }
+  function evictPage(page) {
+    if (page.physicalPage === null) return pageSnapshot(page);
+    const hostKeys = new Float32Array(config.pageSize * config.hiddenDim);
+    const hostValues = new Float32Array(config.pageSize * config.hiddenDim);
+    copyResidentPage(page, hostKeys, hostValues);
+    zeroPhysicalPage(page.physicalPage);
+    freePhysicalPages.push(page.physicalPage);
+    page.physicalPage = null;
+    page.hostKeys = hostKeys;
+    page.hostValues = hostValues;
+    page.residency = "host";
+    return pageSnapshot(page);
+  }
+  function evictOldestInternal(count, protectedPage) {
+    if (count <= 0) return [];
+    const victims = residentPages().filter((page) => page !== protectedPage).sort((a, b) => a.lastAccess - b.lastAccess).slice(0, count);
+    return victims.map((page) => evictPage(page));
+  }
+  function allocatePhysicalPage(protectedPage) {
+    if (freePhysicalPages.length === 0) {
+      evictOldestInternal(1, protectedPage);
+    }
+    const physicalPage = freePhysicalPages.pop();
+    if (physicalPage === void 0) {
+      throw new Error("PagedKVCache could not allocate a resident page.");
+    }
+    zeroPhysicalPage(physicalPage);
+    return physicalPage;
+  }
+  function ensurePageResident(page) {
+    if (page.residency === "device" && page.physicalPage !== null) {
+      page.lastAccess = ++accessClock;
+      return;
+    }
+    const physicalPage = allocatePhysicalPage(page);
+    page.physicalPage = physicalPage;
+    page.residency = "device";
+    page.lastAccess = ++accessClock;
+    if (page.hostKeys) {
+      keyPages.set(page.hostKeys, pageOffset(physicalPage));
+      page.hostKeys = void 0;
+    }
+    if (page.hostValues) {
+      valuePages.set(page.hostValues, pageOffset(physicalPage));
+      page.hostValues = void 0;
+    }
+  }
+  function allocatePageInternal(layer, logicalPage) {
+    const layerState = layers[layer];
+    const existing = layerState.pages.get(logicalPage);
+    if (existing) {
+      ensurePageResident(existing);
+      return existing;
+    }
+    const physicalPage = allocatePhysicalPage();
+    const page = {
+      pageId: nextPageId++,
+      logicalPage,
+      layer,
+      residency: "device",
+      firstToken: logicalPage * config.pageSize,
+      lastToken: logicalPage * config.pageSize + config.pageSize - 1,
+      physicalPage,
+      lastAccess: ++accessClock
+    };
+    layerState.pages.set(logicalPage, page);
+    return page;
+  }
+  function buildPageTable(layer, logicalPages) {
+    const requiredPages = Array.from(new Set(logicalPages)).sort((a, b) => a - b);
+    const maxLogicalPage = requiredPages[requiredPages.length - 1] ?? 0;
+    const pageTable = new Uint32Array(maxLogicalPage + 1);
+    pageTable.fill(PAGE_TABLE_EMPTY);
+    const layerState = layers[layer];
+    for (const logicalPage of requiredPages) {
+      const page = layerState.pages.get(logicalPage);
+      if (page) {
+        ensurePageResident(page);
+        pageTable[logicalPage] = page.physicalPage ?? PAGE_TABLE_EMPTY;
+      }
+    }
+    return pageTable;
+  }
+  function appendCpu(pages, pageTable, slotMap, vectors) {
+    const out = new Float32Array(pages);
+    const numVecs = vectors.length / config.hiddenDim;
+    for (let v = 0; v < numVecs; v += 1) {
+      const logicalPage = slotMap[v] >>> 16;
+      const inPage = slotMap[v] & 65535;
+      const physicalPage = pageTable[logicalPage];
+      const base = physicalPage * config.pageSize * config.hiddenDim;
+      for (let d = 0; d < config.hiddenDim; d += 1) {
+        out[base + inPage * config.hiddenDim + d] = vectors[v * config.hiddenDim + d];
+      }
+    }
+    return out;
+  }
+  function lookupCpu(pages, pageTable, tokenCount, startToken) {
+    const out = new Float32Array(tokenCount * config.hiddenDim);
+    for (let v = 0; v < tokenCount; v += 1) {
+      const logicalSlot = startToken + v;
+      const logicalPage = Math.floor(logicalSlot / config.pageSize);
+      const inPage = logicalSlot % config.pageSize;
+      const physicalPage = pageTable[logicalPage];
+      const base = physicalPage * config.pageSize * config.hiddenDim;
+      for (let d = 0; d < config.hiddenDim; d += 1) {
+        out[v * config.hiddenDim + d] = pages[base + inPage * config.hiddenDim + d];
+      }
+    }
+    return out;
+  }
+  return {
+    config,
+    allocatePage(layer, firstToken) {
+      assertLive();
+      validateLayer(layer);
+      if (!Number.isInteger(firstToken) || firstToken < 0) {
+        throw new Error(`PagedKVCache firstToken must be a non-negative integer, got ${firstToken}`);
+      }
+      const logicalPage = Math.floor(firstToken / config.pageSize);
+      return pageSnapshot(allocatePageInternal(layer, logicalPage));
+    },
+    residentPagesForLayer(layer) {
+      assertLive();
+      validateLayer(layer);
+      return Array.from(layers[layer].pages.values()).filter((page) => page.residency === "device").sort((a, b) => a.firstToken - b.firstToken).map((page) => pageSnapshot(page));
+    },
+    evictOldest(count) {
+      assertLive();
+      if (!Number.isInteger(count) || count < 0) {
+        throw new Error(`PagedKVCache evict count must be a non-negative integer, got ${count}`);
+      }
+      return evictOldestInternal(count);
+    },
+    memoryUsage() {
+      assertLive();
+      let devicePages = 0;
+      let hostPages = 0;
+      for (const layer of layers) {
+        for (const page of layer.pages.values()) {
+          if (page.residency === "device") devicePages += 1;
+          if (page.residency === "host") hostPages += 1;
+        }
+      }
+      return {
+        device: devicePages * pageBytes * 2,
+        host: hostPages * pageBytes * 2
+      };
+    },
+    async dispose() {
+      disposed = true;
+      for (const layer of layers) layer.pages.clear();
+      freePhysicalPages.length = 0;
+    },
+    async append(layer, keyVectors, valueVectors = keyVectors, firstToken) {
+      assertLive();
+      validateLayer(layer);
+      if (keyVectors.length !== valueVectors.length) {
+        throw new Error("PagedKVCache append requires key/value vectors with equal length.");
+      }
+      if (keyVectors.length % config.hiddenDim !== 0) {
+        throw new Error(
+          `PagedKVCache append vector length ${keyVectors.length} is not divisible by hiddenDim=${config.hiddenDim}`
+        );
+      }
+      const tokenCount = keyVectors.length / config.hiddenDim;
+      if (tokenCount === 0) return [];
+      const startToken = firstToken ?? layers[layer].nextToken;
+      if (!Number.isInteger(startToken) || startToken < 0) {
+        throw new Error(`PagedKVCache append firstToken must be non-negative, got ${startToken}`);
+      }
+      const touchedPages = /* @__PURE__ */ new Map();
+      const slotMap = new Uint32Array(tokenCount);
+      const requiredPages = /* @__PURE__ */ new Set();
+      for (let i = 0; i < tokenCount; i += 1) {
+        const token = startToken + i;
+        const logicalPage = Math.floor(token / config.pageSize);
+        const slot = token % config.pageSize;
+        requiredPages.add(logicalPage);
+        slotMap[i] = logicalPage << 16 | slot;
+      }
+      if (requiredPages.size > config.maxResidentPages) {
+        throw new Error(
+          `PagedKVCache append touches ${requiredPages.size} pages but only ${config.maxResidentPages} can be resident.`
+        );
+      }
+      for (const logicalPage of requiredPages) {
+        const page = allocatePageInternal(layer, logicalPage);
+        touchedPages.set(logicalPage, page);
+      }
+      const pageTable = buildPageTable(layer, touchedPages.keys());
+      if (appendKernel) {
+        keyPages.set(
+          await appendKernel.run(
+            keyPages,
+            pageTable,
+            slotMap,
+            keyVectors,
+            config.pageSize,
+            config.hiddenDim
+          )
+        );
+        valuePages.set(
+          await appendKernel.run(
+            valuePages,
+            pageTable,
+            slotMap,
+            valueVectors,
+            config.pageSize,
+            config.hiddenDim
+          )
+        );
+      } else {
+        keyPages.set(appendCpu(keyPages, pageTable, slotMap, keyVectors));
+        valuePages.set(appendCpu(valuePages, pageTable, slotMap, valueVectors));
+      }
+      for (const page of touchedPages.values()) page.lastAccess = ++accessClock;
+      layers[layer].nextToken = Math.max(layers[layer].nextToken, startToken + tokenCount);
+      return Array.from(touchedPages.values()).sort((a, b) => a.firstToken - b.firstToken).map((page) => pageSnapshot(page));
+    },
+    async lookup(layer, startToken, tokenCount) {
+      assertLive();
+      validateLayer(layer);
+      if (!Number.isInteger(startToken) || startToken < 0) {
+        throw new Error(`PagedKVCache lookup startToken must be non-negative, got ${startToken}`);
+      }
+      if (!Number.isInteger(tokenCount) || tokenCount < 0) {
+        throw new Error(`PagedKVCache lookup tokenCount must be non-negative, got ${tokenCount}`);
+      }
+      if (tokenCount === 0) {
+        return { keys: new Float32Array(), values: new Float32Array() };
+      }
+      const endToken = startToken + tokenCount - 1;
+      const firstLogicalPage = Math.floor(startToken / config.pageSize);
+      const maxLogicalPage = Math.floor(endToken / config.pageSize);
+      const requiredPages = [];
+      for (let logicalPage = firstLogicalPage; logicalPage <= maxLogicalPage; logicalPage += 1) {
+        const page = layers[layer].pages.get(logicalPage);
+        if (!page) {
+          throw new Error(`PagedKVCache lookup misses layer ${layer} logical page ${logicalPage}.`);
+        }
+        requiredPages.push(logicalPage);
+      }
+      if (requiredPages.length > config.maxResidentPages) {
+        throw new Error(
+          `PagedKVCache lookup needs ${requiredPages.length} pages but only ${config.maxResidentPages} can be resident.`
+        );
+      }
+      for (const logicalPage of requiredPages) {
+        ensurePageResident(layers[layer].pages.get(logicalPage));
+      }
+      const pageTable = buildPageTable(layer, requiredPages);
+      if (lookupKernel) {
+        return {
+          keys: await lookupKernel.run(
+            keyPages,
+            pageTable,
+            tokenCount,
+            startToken,
+            config.pageSize,
+            config.hiddenDim
+          ),
+          values: await lookupKernel.run(
+            valuePages,
+            pageTable,
+            tokenCount,
+            startToken,
+            config.pageSize,
+            config.hiddenDim
+          )
+        };
+      }
+      return {
+        keys: lookupCpu(keyPages, pageTable, tokenCount, startToken),
+        values: lookupCpu(valuePages, pageTable, tokenCount, startToken)
+      };
+    }
+  };
+}
+function validateConfig(config) {
+  const fields = [
+    ["pageSize", config.pageSize],
+    ["maxResidentPages", config.maxResidentPages],
+    ["hiddenDim", config.hiddenDim],
+    ["numHeads", config.numHeads],
+    ["numLayers", config.numLayers]
+  ];
+  for (const [field, value] of fields) {
+    if (!Number.isInteger(value) || value <= 0) {
+      throw new Error(`PagedKVCache config ${String(field)} must be a positive integer.`);
+    }
+  }
+  if (config.pageSize > 65535) {
+    throw new Error("PagedKVCache pageSize must fit the 16-bit slot packing used by WGSL kernels.");
+  }
+}
+
 // src/reconstruction/HoloMapRuntime.ts
 var HOLOMAP_DEFAULTS = {
   inputResolution: { width: 518, height: 378 },
@@ -1459,8 +2161,14 @@ var HOLOMAP_DEFAULTS = {
   tileGrid: 4,
   cpuOffload: false,
   weightStrategy: "distill",
+  reconstructionMode: "preview",
   allowCpuFallback: true
 };
+var HOLOMAP_DENSE_PROOF_DEFAULTS = {
+  ...HOLOMAP_DEFAULTS,
+  tileGrid: 16,
+  reconstructionMode: "dense-proof"
+};
 var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
   constructor() {
     this.config = { ...HOLOMAP_DEFAULTS };
@@ -1472,6 +2180,10 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     this.microEncoder = null;
     /** Loaded weight blob (optional; GPU upload wiring follows R3+). */
     this.weightBytes = null;
+    this.weightVerified = false;
+    this.weightSource = null;
+    this.streamingKVCache = null;
+    this.streamingKVNextToken = 0;
     // ── Sprint-3 performance / determinism state ──
     /** Running bounding box (updated incrementally per step). */
     this.boundsMin = [0, 0, 0];
@@ -1524,6 +2236,131 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     const v = depth[py * width + px];
     return Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 0.5;
   }
+  static sampleMetricDepthNearestUv(depthMeters, width, height, uv) {
+    const px = Math.min(width - 1, Math.max(0, Math.round(uv[0] * (width - 1))));
+    const py = Math.min(height - 1, Math.max(0, Math.round(uv[1] * (height - 1))));
+    const v = depthMeters[py * width + px];
+    return Number.isFinite(v) && v > 0 ? v : void 0;
+  }
+  static hasUsableIntrinsics(intrinsics) {
+    return !!intrinsics && Number.isFinite(intrinsics.width) && Number.isFinite(intrinsics.height) && Number.isFinite(intrinsics.fx) && Number.isFinite(intrinsics.fy) && Number.isFinite(intrinsics.cx) && Number.isFinite(intrinsics.cy) && intrinsics.width > 0 && intrinsics.height > 0 && intrinsics.fx > 0 && intrinsics.fy > 0;
+  }
+  static 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];
+  }
+  static rotateByQuaternion(v, q) {
+    const [x, y, z, w] = _HoloMapRuntimeImpl.normalizeQuaternion(q);
+    const [vx, vy, vz] = v;
+    const tx = 2 * (y * vz - z * vy);
+    const ty = 2 * (z * vx - x * vz);
+    const tz = 2 * (x * vy - y * vx);
+    return [
+      vx + w * tx + (y * tz - z * ty),
+      vy + w * ty + (z * tx - x * tz),
+      vz + w * tz + (x * ty - y * tx)
+    ];
+  }
+  static projectMetricDepthToWorld(uv, depthMeters, intrinsics, pose) {
+    const pixelX = uv[0] * intrinsics.width;
+    const pixelY = uv[1] * intrinsics.height;
+    const local = [
+      (pixelX - intrinsics.cx) * depthMeters / intrinsics.fx,
+      (intrinsics.cy - pixelY) * depthMeters / intrinsics.fy,
+      -depthMeters
+    ];
+    if (!pose) return local;
+    const rotated = _HoloMapRuntimeImpl.rotateByQuaternion(local, pose.rotation);
+    return [
+      pose.position[0] + rotated[0],
+      pose.position[1] + rotated[1],
+      pose.position[2] + rotated[2]
+    ];
+  }
+  static fitShiftScaleDepth(samples) {
+    const paired = samples.filter((sample) => sample.metricDepthMeters !== void 0).map((sample) => ({
+      x: sample.rawDepthSignal,
+      y: sample.metricDepthMeters
+    }));
+    if (paired.length === 0) return void 0;
+    let meanX = 0;
+    let meanY = 0;
+    for (const sample of paired) {
+      meanX += sample.x;
+      meanY += sample.y;
+    }
+    meanX /= paired.length;
+    meanY /= paired.length;
+    let varianceX = 0;
+    let covariance = 0;
+    for (const sample of paired) {
+      const dx = sample.x - meanX;
+      varianceX += dx * dx;
+      covariance += dx * (sample.y - meanY);
+    }
+    const scale = varianceX > 1e-12 ? covariance / varianceX : 0;
+    const shift = meanY - scale * meanX;
+    let squared = 0;
+    for (const sample of paired) {
+      const err = scale * sample.x + shift - sample.y;
+      squared += err * err;
+    }
+    return {
+      kind: "shift-scale",
+      sampleCount: paired.length,
+      scale,
+      shift,
+      rmseMeters: Math.sqrt(squared / paired.length)
+    };
+  }
+  static alignedDepthMeters(sample, fit) {
+    if (fit) {
+      const aligned = fit.scale * sample.rawDepthSignal + fit.shift;
+      if (Number.isFinite(aligned) && aligned > 0) return aligned;
+    }
+    return sample.metricDepthMeters;
+  }
+  static buildLoopClosureDescriptor(samples) {
+    if (samples.length === 0) return new Float32Array([0, 0, 0, 0, 0, 0]);
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let luma = 0;
+    let texture = 0;
+    let depth = 0;
+    let depthCount = 0;
+    for (const sample of samples) {
+      r += sample.meanColor[0] / 255;
+      g += sample.meanColor[1] / 255;
+      b += sample.meanColor[2] / 255;
+      luma += sample.luminance;
+      texture += sample.texture;
+      if (sample.metricDepthMeters !== void 0) {
+        depth += Math.min(1, sample.metricDepthMeters / 10);
+        depthCount += 1;
+      }
+    }
+    const inv = 1 / samples.length;
+    return new Float32Array([
+      r * inv,
+      g * inv,
+      b * inv,
+      luma * inv,
+      texture * inv,
+      depthCount > 0 ? depth / depthCount : 0
+    ]);
+  }
+  static descriptorDistance(a, b) {
+    const n = Math.min(a.length, b.length);
+    if (n === 0) return Number.POSITIVE_INFINITY;
+    let squared = 0;
+    for (let i = 0; i < n; i += 1) {
+      const d = (a[i] ?? 0) - (b[i] ?? 0);
+      squared += d * d;
+    }
+    return Math.sqrt(squared / n);
+  }
   static computeBounds(steps) {
     if (steps.length === 0) {
       return {
@@ -1597,6 +2434,10 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     }
     return _HoloMapRuntimeImpl.computeBounds(this.steps);
   }
+  static *retainedPositionChunks(steps, current) {
+    for (const step of steps) yield step.points.positions;
+    yield current;
+  }
   static estimatePrincipalAxisRotation(chunks, centroid) {
     let xx = 0;
     let zz = 0;
@@ -1670,10 +2511,22 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     }
   }
   async init(config) {
-    this.config = { ...config };
+    this.config = {
+      ...config,
+      reconstructionMode: config.reconstructionMode ?? "preview"
+    };
+    if (this.config.reconstructionMode === "dense-proof") {
+      this.config.tileGrid = Math.max(
+        this.config.tileGrid ?? _HoloMapRuntimeImpl.GRID_N,
+        _HoloMapRuntimeImpl.DENSE_PROOF_GRID_N
+      );
+    }
     this.config.tileGrid = _HoloMapRuntimeImpl.normalizeTileGrid(this.config.tileGrid);
+    if (this.config.reconstructionMode === "dense-proof") {
+      _HoloMapRuntimeImpl.assertDenseProofConfig(this.config);
+    }
     const allowCpu = this.config.allowCpuFallback !== false;
-    if (!allowCpu && !chunkT6W3Z3SH_cjs.isWebGpuEnvironmentPresent()) {
+    if (!allowCpu && !chunkN2ILK7BF_cjs.isWebGpuEnvironmentPresent()) {
       const err = "HoloMap: native reconstruction requires WebGPU (allowCpuFallback=false). Run in a WebGPU-capable browser, or set allowCpuFallback=true for CPU fallback, or use compatibility scene ingest (Marble) for headless benchmarks.";
       logHoloMapEvent(this.runId, "error", { message: err });
       throw new Error(err);
@@ -1711,25 +2564,56 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       verticalProfile: this.config.verticalProfile
     });
     this.weightBytes = null;
-    if (this.config.weightUrl) {
+    this.weightVerified = false;
+    this.weightSource = null;
+    const weightUrl = this.config.weightUrl ?? (this.config.weightCid && this.config.localResolver ? `holomap-local://${this.config.weightCid}` : void 0);
+    if (weightUrl) {
       const result = await loadHoloMapWeightBlob({
-        weightUrl: this.config.weightUrl,
+        weightUrl,
         weightUrls: this.config.weightUrls,
-        weightCid: this.config.weightCid
+        weightCid: this.config.weightCid,
+        localResolver: this.config.localResolver
       });
       this.weightBytes = result.bytes;
+      this.weightVerified = result.verified;
+      this.weightSource = result.source;
+    }
+    if (this.config.reconstructionMode === "dense-proof" && (!this.weightBytes || !this.weightVerified)) {
+      throw new Error(
+        "HoloMap dense-proof mode requires verified checkpoint bytes; preview mode is the only mode allowed to fall back to PRNG weights."
+      );
     }
     this.encoderDevice = await tryCreateHoloMapEncoderDevice();
     this.microEncoder = this.encoderDevice ? createHoloMapMicroEncoder(this.encoderDevice) : null;
+    const streamingTokens = Math.max(
+      1,
+      this.config.maxSequenceLength * (this.config.tileGrid ?? _HoloMapRuntimeImpl.GRID_N) ** 2
+    );
+    const streamingPageSize = Math.max(
+      1,
+      Math.min(64, this.config.tileGrid ?? _HoloMapRuntimeImpl.GRID_N)
+    );
+    this.streamingKVCache = createPagedKVCache({
+      pageSize: streamingPageSize,
+      maxResidentPages: Math.max(1, Math.min(256, Math.ceil(streamingTokens / streamingPageSize))),
+      hiddenDim: 3,
+      numHeads: 1,
+      numLayers: 1,
+      device: this.encoderDevice
+    });
+    this.streamingKVNextToken = 0;
     this.initialized = true;
     logHoloMapEvent(this.runId, "init", {
       modelHash: this.config.modelHash,
       seed: this.config.seed,
       allowCpuFallback: allowCpu,
-      webgpu: chunkT6W3Z3SH_cjs.isWebGpuEnvironmentPresent(),
+      webgpu: chunkN2ILK7BF_cjs.isWebGpuEnvironmentPresent(),
       microEncoder: this.microEncoder ? "webgpu" : "cpu",
+      reconstructionMode: this.config.reconstructionMode,
       tileGrid: this.config.tileGrid,
       weightLoadedBytes: this.weightBytes?.byteLength ?? 0,
+      weightVerified: this.weightVerified,
+      weightSource: this.weightSource,
       replayFingerprint: this.replayKey
     });
   }
@@ -1746,6 +2630,19 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     }
     return tileGrid;
   }
+  static assertDenseProofConfig(config) {
+    const missing = [];
+    if (!config.modelHash || config.modelHash === "unset") missing.push("modelHash");
+    if (!config.weightCid) missing.push("weightCid");
+    if (!config.weightUrl && !config.localResolver) missing.push("weightUrl or localResolver");
+    if (missing.length > 0) {
+      throw new Error(
+        `HoloMap dense-proof mode requires ${missing.join(
+          ", "
+        )}; preview mode is the only mode allowed to use PRNG/default weights.`
+      );
+    }
+  }
   /**
    * Carve `frame` into gridN×gridN tiles. Each tile carries its own
    * (rgb, width, height, stride, index) and the mean RGB color over its
@@ -1841,6 +2738,35 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       return runHoloMapMicroEncoderCpu(tile, microCfg);
     }
   }
+  async updateStreamingKVCache(encodedTiles) {
+    if (!this.streamingKVCache || encodedTiles.length === 0) return void 0;
+    const keys = new Float32Array(encodedTiles.length * 3);
+    const values = new Float32Array(encodedTiles.length * 3);
+    for (let i = 0; i < encodedTiles.length; i += 1) {
+      const sample = encodedTiles[i];
+      keys.set(sample.latent, i * 3);
+      values[i * 3] = sample.rawDepthSignal;
+      values[i * 3 + 1] = sample.texture;
+      values[i * 3 + 2] = sample.luminance;
+    }
+    const firstToken = this.streamingKVNextToken;
+    await this.streamingKVCache.append(0, keys, values, firstToken);
+    this.streamingKVNextToken += encodedTiles.length;
+    const retainedTokenCapacity = this.streamingKVCache.config.pageSize * this.streamingKVCache.config.maxResidentPages;
+    const kLen = Math.min(this.streamingKVNextToken, 128, retainedTokenCapacity);
+    const lookupStart = this.streamingKVNextToken - kLen;
+    const lookup = await this.streamingKVCache.lookup(0, lookupStart, kLen);
+    let checksum = 0;
+    for (let i = 0; i < lookup.keys.length; i += 1) checksum += lookup.keys[i] ?? 0;
+    for (let i = 0; i < lookup.values.length; i += 1) checksum += lookup.values[i] ?? 0;
+    return {
+      layer: 0,
+      kLen,
+      cachedPages: this.streamingKVCache.residentPagesForLayer(0).length,
+      lookupChecksum: checksum,
+      memory: this.streamingKVCache.memoryUsage()
+    };
+  }
   async step(frame) {
     if (!this.initialized) {
       throw new Error("HoloMapRuntime not initialized. Call init(config) before step(frame).");
@@ -1859,6 +2785,11 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         `HoloMapRuntime.step invalid measured depth length: got ${frame.depth.length}, expected ${frame.width * frame.height} (w=${frame.width}, h=${frame.height})`
       );
     }
+    if (frame.depthMeters && frame.depthMeters.length !== frame.width * frame.height) {
+      throw new Error(
+        `HoloMapRuntime.step invalid metric depth length: got ${frame.depthMeters.length}, expected ${frame.width * frame.height} (w=${frame.width}, h=${frame.height})`
+      );
+    }
     if (frame.depthConfidence && frame.depthConfidence.length !== frame.width * frame.height) {
       throw new Error(
         `HoloMapRuntime.step invalid measured depth confidence length: got ${frame.depthConfidence.length}, expected ${frame.width * frame.height} (w=${frame.width}, h=${frame.height})`
@@ -1893,12 +2824,19 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         this.updateBounds(s.points.positions);
       }
       logHoloMapEvent(this.runId, "step_evict", {
-        frameIndex: evicted.frame.index,
+        frameIndex: evicted.frameIndex,
         evictedPoints,
         retainedSteps: this.steps.length
       });
     }
-    const microCfg = { seed: this.config.seed, modelHash: this.config.modelHash };
+    const microCfg = {
+      seed: this.config.seed,
+      modelHash: this.config.modelHash,
+      // Wire the loaded checkpoint through to the encoder. Previously weightBytes
+      // was fetched + verified in init() then never passed here, so the encoder
+      // always ran on PRNG weights even when a real checkpoint was provided.
+      weightBytes: this.weightBytes
+    };
     const configuredGrid = this.config.tileGrid ?? _HoloMapRuntimeImpl.GRID_N;
     const gridN = Math.max(1, Math.min(configuredGrid, frame.width, frame.height));
     const tiles = _HoloMapRuntimeImpl.tileFrame(frame, gridN);
@@ -1907,22 +2845,83 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     const colors = new Uint8Array(numPoints * 3);
     const confidence = new Float32Array(numPoints);
     const aspect = frame.width / Math.max(1, frame.height);
+    const metricIntrinsics = _HoloMapRuntimeImpl.hasUsableIntrinsics(frame.cameraIntrinsics) ? frame.cameraIntrinsics : void 0;
+    const encodedTiles = [];
+    for (let t = 0; t < numPoints; t += 1) {
+      const sample = tiles[t];
+      const xyz = await this.encodeTile(sample.tile, microCfg);
+      const latentX = xyz[0] ?? 0;
+      const latentY = xyz[1] ?? 0;
+      const latentZ = xyz[2] ?? 0;
+      const depthHint = (sample.luminance - 0.5) * 0.34 + sample.texture * 0.24;
+      encodedTiles.push({
+        ...sample,
+        latent: [latentX, latentY, latentZ],
+        rawDepthSignal: depthHint + latentZ * 0.12,
+        metricDepthMeters: frame.depthMeters ? _HoloMapRuntimeImpl.sampleMetricDepthNearestUv(
+          frame.depthMeters,
+          frame.width,
+          frame.height,
+          sample.centerUv
+        ) : void 0
+      });
+    }
+    const streamingKV = await this.updateStreamingKVCache(encodedTiles);
+    const depthAlignment = _HoloMapRuntimeImpl.fitShiftScaleDepth(encodedTiles);
+    const loopDescriptor = _HoloMapRuntimeImpl.buildLoopClosureDescriptor(encodedTiles);
+    const rawDevicePose = frame.devicePose ? {
+      position: [...frame.devicePose.position],
+      rotation: [...frame.devicePose.rotation],
+      confidence: frame.devicePose.confidence
+    } : void 0;
+    let loopCorrectedPose;
+    if (frame.depthMeters && metricIntrinsics) {
+      for (const kf of this.poseHistory) {
+        if (frame.index - kf.frameIndex < _HoloMapRuntimeImpl.LOOP_CLOSURE_MIN_GAP) continue;
+        const descriptorDistance = _HoloMapRuntimeImpl.descriptorDistance(
+          loopDescriptor,
+          kf.descriptor
+        );
+        if (descriptorDistance <= _HoloMapRuntimeImpl.LOOP_CLOSURE_DESCRIPTOR_DISTANCE) {
+          this.lastLoopClosureFrameIdx = frame.index;
+          if (rawDevicePose) {
+            loopCorrectedPose = {
+              ...rawDevicePose,
+              position: [...kf.position],
+              confidence: Math.min(1, Math.max(rawDevicePose.confidence, 0.9))
+            };
+          }
+          break;
+        }
+      }
+    }
+    const metricProjectionPose = loopCorrectedPose ?? rawDevicePose;
     let centroidX = 0;
     let centroidY = 0;
     let centroidZ = 0;
     let confidenceSum = 0;
     for (let t = 0; t < numPoints; t += 1) {
-      const { tile, meanColor, centerUv, luminance, texture } = tiles[t];
-      const xyz = await this.encodeTile(tile, microCfg);
-      const latentX = xyz[0] ?? 0;
-      const latentY = xyz[1] ?? 0;
-      const latentZ = xyz[2] ?? 0;
+      const { meanColor, centerUv, texture, latent, rawDepthSignal } = encodedTiles[t];
+      const [latentX, latentY, latentZ] = latent;
       const planeX = (centerUv[0] - 0.5) * 2 * aspect;
       const planeY = (0.5 - centerUv[1]) * 2;
-      const px = planeX + latentX * 0.08;
-      const py = planeY + latentY * 0.08;
+      let px = planeX + latentX * 0.08;
+      let py = planeY + latentY * 0.08;
       let pz;
-      if (frame.depth) {
+      const metricDepth = _HoloMapRuntimeImpl.alignedDepthMeters(encodedTiles[t], depthAlignment);
+      if (metricDepth !== void 0 && metricIntrinsics) {
+        const worldPoint = _HoloMapRuntimeImpl.projectMetricDepthToWorld(
+          centerUv,
+          metricDepth,
+          metricIntrinsics,
+          metricProjectionPose
+        );
+        px = worldPoint[0];
+        py = worldPoint[1];
+        pz = worldPoint[2];
+      } else if (metricDepth !== void 0) {
+        pz = -metricDepth;
+      } else if (frame.depth) {
         const measured = _HoloMapRuntimeImpl.sampleDepthNearestUv(
           frame.depth,
           frame.width,
@@ -1931,8 +2930,7 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         );
         pz = (0.5 - measured) * _HoloMapRuntimeImpl.DEPTH_Z_SCALE;
       } else {
-        const depthHint = (luminance - 0.5) * 0.34 + texture * 0.24;
-        pz = depthHint + latentZ * 0.12;
+        pz = rawDepthSignal;
       }
       positions[t * 3] = px;
       positions[t * 3 + 1] = py;
@@ -1968,10 +2966,10 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     const meanConfidence = confidenceSum * inv;
     const derivedPosition = [poseX, poseY, poseZ];
     const poseConfidence = Math.max(0, Math.min(1, meanConfidence));
-    const cameraPose = frame.devicePose ? {
-      position: [...frame.devicePose.position],
-      rotation: [...frame.devicePose.rotation],
-      confidence: frame.devicePose.confidence
+    const cameraPose = metricProjectionPose ? {
+      position: [...metricProjectionPose.position],
+      rotation: [...metricProjectionPose.rotation],
+      confidence: metricProjectionPose.confidence
     } : {
       position: derivedPosition,
       rotation: _HoloMapRuntimeImpl.estimatePrincipalAxisRotation([positions], derivedPosition),
@@ -2018,17 +3016,23 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     }
     this.prevPose = curPose;
     this.prevCameraPose = cameraPose;
-    for (const kf of this.poseHistory) {
-      if (frame.index - kf.frameIndex < _HoloMapRuntimeImpl.LOOP_CLOSURE_MIN_GAP) continue;
-      const dx = curPose[0] - kf.position[0];
-      const dy = curPose[1] - kf.position[1];
-      const dz = curPose[2] - kf.position[2];
-      if (Math.sqrt(dx * dx + dy * dy + dz * dz) < _HoloMapRuntimeImpl.LOOP_CLOSURE_RADIUS) {
-        this.lastLoopClosureFrameIdx = frame.index;
-        break;
+    if (this.lastLoopClosureFrameIdx !== frame.index) {
+      for (const kf of this.poseHistory) {
+        if (frame.index - kf.frameIndex < _HoloMapRuntimeImpl.LOOP_CLOSURE_MIN_GAP) continue;
+        const dx = curPose[0] - kf.position[0];
+        const dy = curPose[1] - kf.position[1];
+        const dz = curPose[2] - kf.position[2];
+        if (Math.sqrt(dx * dx + dy * dy + dz * dz) < _HoloMapRuntimeImpl.LOOP_CLOSURE_RADIUS) {
+          this.lastLoopClosureFrameIdx = frame.index;
+          break;
+        }
       }
     }
-    this.poseHistory.push({ frameIndex: frame.index, position: curPose });
+    this.poseHistory.push({
+      frameIndex: frame.index,
+      position: curPose,
+      descriptor: loopDescriptor
+    });
     if (this.poseHistory.length > _HoloMapRuntimeImpl.POSE_HISTORY_CAP) this.poseHistory.shift();
     this.updateBounds(positions);
     this.globalPosSum[0] += centroidX;
@@ -2048,7 +3052,7 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     const extentY = b.max[1] - b.min[1];
     const extentZ = b.max[2] - b.min[2];
     const anchorRotation = _HoloMapRuntimeImpl.estimatePrincipalAxisRotation(
-      [...this.steps.map((s) => s.points.positions), positions],
+      _HoloMapRuntimeImpl.retainedPositionChunks(this.steps, positions),
       anchorCenter
     );
     const anchorDescriptor = new Float32Array([extentX, extentY, extentZ, globalMeanConfidence]);
@@ -2074,6 +3078,7 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         colors,
         confidence
       },
+      ...streamingKV ? { streamingKV } : {},
       trajectory: {
         keyframes: trajectoryKeyframes,
         estimatedDriftMeters: this.cumulativeDriftMeters,
@@ -2089,9 +3094,16 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         },
         anchorDescriptor,
         revision: frame.index + 1
-      }
+      },
+      ...depthAlignment ? { depthAlignment } : {}
     };
-    this.steps.push(step);
+    this.steps.push({
+      frameIndex: frame.index,
+      points: {
+        positions,
+        confidence
+      }
+    });
     this.totalPointCount += numPoints;
     const stepMs = performance.now() - stepStartMs;
     this.perfMetrics.stepCount += 1;
@@ -2124,7 +3136,16 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       throttledCount: this.perfMetrics.throttledCount,
       sessionDurationMs: Math.round(performance.now() - this.sessionStartMs)
     });
-    return {
+    const reconstruction = {
+      mode: this.config.reconstructionMode ?? "preview",
+      modelHash: this.config.modelHash,
+      tileGrid: this.config.tileGrid ?? _HoloMapRuntimeImpl.GRID_N,
+      weightLoadedBytes: this.weightBytes?.byteLength ?? 0,
+      weightVerified: this.weightVerified,
+      ...this.config.weightCid ? { weightCid: this.config.weightCid } : {},
+      ...this.weightSource ? { weightSource: this.weightSource } : {}
+    };
+    const manifest = {
       version: "1.0.0",
       worldId: `holomap-${this.replayKey}`,
       displayName: "HoloMap Reconstruction",
@@ -2133,7 +3154,7 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       bounds,
       replayHash: this.replayKey,
       simulationContract: {
-        kind: chunkT6W3Z3SH_cjs.HOLOMAP_SIMULATION_CONTRACT_KIND,
+        kind: chunkN2ILK7BF_cjs.HOLOMAP_SIMULATION_CONTRACT_KIND,
         replayFingerprint: this.replayKey,
         holoScriptBuild: getVersionString()
       },
@@ -2146,8 +3167,17 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         trajectory: "reconstruction.trajectory.json",
         anchors: "reconstruction.anchors.json"
       },
-      weightStrategy: this.config.weightStrategy ?? "distill"
+      weightStrategy: this.config.weightStrategy ?? "distill",
+      reconstruction
     };
+    try {
+      return await anchorReconstructionManifest(manifest, this.config.provenanceAnchorProvider);
+    } catch (error) {
+      logHoloMapEvent(this.runId, "anchor_failed", {
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return selfAttestReconstructionManifest(manifest);
+    }
   }
   replayHash() {
     return this.replayKey;
@@ -2162,7 +3192,12 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     this.steps.length = 0;
     this.microEncoder = null;
     this.encoderDevice = null;
+    await this.streamingKVCache?.dispose();
+    this.streamingKVCache = null;
+    this.streamingKVNextToken = 0;
     this.weightBytes = null;
+    this.weightVerified = false;
+    this.weightSource = null;
     this.totalPointCount = 0;
     this.cumulativeDriftMeters = 0;
     this.prevPose = null;
@@ -2192,6 +3227,7 @@ _HoloMapRuntimeImpl.TRAJECTORY_KEYFRAME_CAP = 512;
  *  the monocular estimate's spread (±~0.17), so sensor and estimate paths
  *  produce geometry in the same coordinate scale. */
 _HoloMapRuntimeImpl.DEPTH_Z_SCALE = 0.34;
+_HoloMapRuntimeImpl.LOOP_CLOSURE_DESCRIPTOR_DISTANCE = 0.015;
 /**
  * Default number of tiles per axis used to fan the encoder across the frame.
  * Total points emitted = tileGrid * tileGrid (one per tile).
@@ -2201,6 +3237,7 @@ _HoloMapRuntimeImpl.DEPTH_Z_SCALE = 0.34;
  * for future streaming kLen>1 paths.
  */
 _HoloMapRuntimeImpl.GRID_N = 4;
+_HoloMapRuntimeImpl.DENSE_PROOF_GRID_N = 16;
 _HoloMapRuntimeImpl.MAX_GRID_N = 32;
 var HoloMapRuntimeImpl = _HoloMapRuntimeImpl;
 function createHoloMapRuntime(_config) {
@@ -2214,21 +3251,30 @@ function createHoloMapRuntime(_config) {
 exports.BUILD_TIMESTAMP = BUILD_TIMESTAMP;
 exports.GIT_COMMIT_SHA = GIT_COMMIT_SHA;
 exports.HOLOMAP_DEFAULTS = HOLOMAP_DEFAULTS;
+exports.HOLOMAP_DENSE_PROOF_DEFAULTS = HOLOMAP_DENSE_PROOF_DEFAULTS;
 exports.HOLOSCRIPT_VERSION = HOLOSCRIPT_VERSION;
+exports.anchorReconstructionManifest = anchorReconstructionManifest;
 exports.assertWeightCid = assertWeightCid;
+exports.computeReconstructionManifestDigest = computeReconstructionManifestDigest;
 exports.createHoloMapMicroEncoder = createHoloMapMicroEncoder;
 exports.createHoloMapRunId = createHoloMapRunId;
 exports.createHoloMapRuntime = createHoloMapRuntime;
+exports.createPagedKVCache = createPagedKVCache;
+exports.deserializeMicroWeights = deserializeMicroWeights;
 exports.frameToMicroImage = frameToMicroImage;
 exports.getCachedWeightBlob = getCachedWeightBlob;
 exports.getVersionInfo = getVersionInfo;
 exports.getVersionString = getVersionString;
 exports.loadHoloMapWeightBlob = loadHoloMapWeightBlob;
 exports.logHoloMapEvent = logHoloMapEvent;
+exports.mergeAnchoredProvenance = mergeAnchoredProvenance;
 exports.normalizeWeightCidDigest = normalizeWeightCidDigest;
 exports.putCachedWeightBlob = putCachedWeightBlob;
 exports.resetHoloMapTelemetryForTests = resetHoloMapTelemetryForTests;
 exports.runHoloMapMicroEncoderCpu = runHoloMapMicroEncoderCpu;
+exports.selfAttestReconstructionManifest = selfAttestReconstructionManifest;
+exports.serializeMicroWeights = serializeMicroWeights;
+exports.stripAnchoredProvenance = stripAnchoredProvenance;
 exports.tryCreateHoloMapEncoderDevice = tryCreateHoloMapEncoderDevice;
-//# sourceMappingURL=chunk-WFKVS2K4.cjs.map
-//# sourceMappingURL=chunk-WFKVS2K4.cjs.map
+//# sourceMappingURL=chunk-AUZRKIHQ.cjs.map
+//# sourceMappingURL=chunk-AUZRKIHQ.cjs.map