@holoscript/core 8.0.14 → 8.0.16

package/dist/chunk-VQOTDNFL.cjs

@@ -0,0 +1,3337 @@
+'use strict';
+
+var chunkLM2VU56C_cjs = require('./chunk-LM2VU56C.cjs');
+var chunkN2ILK7BF_cjs = require('./chunk-N2ILK7BF.cjs');
+
+// src/version.ts
+var HOLOSCRIPT_VERSION = "8.0.16" ;
+var GIT_COMMIT_SHA = "c55048b35" ;
+var BUILD_TIMESTAMP = "2026-07-17T05:25:25.840Z" ;
+function getVersionString() {
+  const sha = `+${GIT_COMMIT_SHA}` ;
+  return `${HOLOSCRIPT_VERSION}${sha}`;
+}
+function getVersionInfo() {
+  return {
+    version: HOLOSCRIPT_VERSION,
+    gitCommitSha: GIT_COMMIT_SHA,
+    buildTimestamp: BUILD_TIMESTAMP,
+    versionString: getVersionString()
+  };
+}
+
+// src/reconstruction/imagePatchEmbedKernel.ts
+var WGSL_IMAGE_PATCH_EMBED = `
+struct Params {
+  imgH:       u32,
+  imgW:       u32,
+  patchH:     u32,
+  patchW:     u32,
+  numChannels:u32,
+  embedDim:   u32,
+  patchLen:   u32,  // = patchH * patchW * numChannels
+  numPatchesX:u32,  // = imgW / patchW
+}
+
+@group(0) @binding(0) var<storage, read>       img:  array<f32>; // [imgH, imgW, numChannels]
+@group(0) @binding(1) var<storage, read>       proj: array<f32>; // [embedDim, patchLen]
+@group(0) @binding(2) var<storage, read_write> out:  array<f32>; // [numPatches, embedDim]
+@group(0) @binding(3) var<uniform>             p:    Params;
+
+@compute @workgroup_size(64, 1, 1)
+fn main(
+  @builtin(workgroup_id)        wg:  vec3<u32>,
+  @builtin(local_invocation_id) lid: vec3<u32>,
+) {
+  let patchIdx = wg.x;
+  let patchRow = patchIdx / p.numPatchesX;
+  let patchCol = patchIdx % p.numPatchesX;
+
+  // Top-left corner of patch in the image
+  let startRow = patchRow * p.patchH;
+  let startCol = patchCol * p.patchW;
+
+  // Fan out over embedDim
+  var d = lid.x;
+  while (d < p.embedDim) {
+    let projRow = d * p.patchLen;
+    var dot: f32 = 0.0;
+
+    for (var pr = 0u; pr < p.patchH; pr++) {
+      for (var pc2 = 0u; pc2 < p.patchW; pc2++) {
+        for (var ch = 0u; ch < p.numChannels; ch++) {
+          let imgRow = startRow + pr;
+          let imgCol = startCol + pc2;
+          let imgIdx = (imgRow * p.imgW + imgCol) * p.numChannels + ch;
+          let projIdx = projRow + (pr * p.patchW + pc2) * p.numChannels + ch;
+          dot = dot + img[imgIdx] * proj[projIdx];
+        }
+      }
+    }
+    out[patchIdx * p.embedDim + d] = dot;
+    d = d + 64u;
+  }
+}
+`;
+function storageBuffer(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 createImagePatchEmbedKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_IMAGE_PATCH_EMBED });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(image, proj, params) {
+      const { imgH, imgW, patchH, patchW, numChannels, embedDim } = params;
+      if (imgH % patchH !== 0)
+        throw new Error(`imagePatchEmbed: imgH=${imgH} not divisible by patchH=${patchH}`);
+      if (imgW % patchW !== 0)
+        throw new Error(`imagePatchEmbed: imgW=${imgW} not divisible by patchW=${patchW}`);
+      const patchLen = patchH * patchW * numChannels;
+      const numPatchesY = imgH / patchH;
+      const numPatchesX = imgW / patchW;
+      const numPatches = numPatchesY * numPatchesX;
+      if (image.length !== imgH * imgW * numChannels)
+        throw new Error(`imagePatchEmbed: image size mismatch`);
+      if (proj.length !== embedDim * patchLen)
+        throw new Error(`imagePatchEmbed: proj size mismatch`);
+      const outBytes = numPatches * embedDim * 4;
+      const imgBuf = storageBuffer(device, image);
+      const projBuf = storageBuffer(device, proj);
+      const outBuf = device.createBuffer({
+        size: outBytes,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+      const paramAB = new ArrayBuffer(32);
+      const pu = new Uint32Array(paramAB);
+      pu[0] = imgH;
+      pu[1] = imgW;
+      pu[2] = patchH;
+      pu[3] = patchW;
+      pu[4] = numChannels;
+      pu[5] = embedDim;
+      pu[6] = patchLen;
+      pu[7] = numPatchesX;
+      const paramsBuf = device.createBuffer({
+        size: paramAB.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(paramsBuf, 0, paramAB);
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: imgBuf } },
+          { binding: 1, resource: { buffer: projBuf } },
+          { binding: 2, resource: { buffer: outBuf } },
+          { binding: 3, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(numPatches);
+      pass.end();
+      const staging = device.createBuffer({
+        size: outBytes,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+      });
+      enc.copyBufferToBuffer(outBuf, 0, staging, 0, outBytes);
+      device.queue.submit([enc.finish()]);
+      await staging.mapAsync(GPUMapMode.READ);
+      const result = new Float32Array(staging.getMappedRange().slice(0));
+      staging.unmap();
+      imgBuf.destroy();
+      projBuf.destroy();
+      outBuf.destroy();
+      paramsBuf.destroy();
+      staging.destroy();
+      return result;
+    }
+  };
+}
+
+// src/reconstruction/layerNormKernel.ts
+var WGSL_LAYER_NORM_SOURCE = `
+struct Params {
+  rows: u32,
+  dModel: u32,
+  eps: f32,
+}
+@group(0) @binding(0) var<storage, read> input: array<f32>;
+@group(0) @binding(1) var<storage, read> gamma: array<f32>;
+@group(0) @binding(2) var<storage, read> beta: array<f32>;
+@group(0) @binding(3) var<storage, read_write> output: array<f32>;
+@group(0) @binding(4) var<uniform> params: Params;
+var<workgroup> reduceScratch: array<f32, 64>;
+fn inputIndex(row: u32, col: u32) -> u32 {
+  return row * params.dModel + col;
+}
+@compute @workgroup_size(64, 1, 1)
+fn main(
+  @builtin(workgroup_id) workgroupId: vec3<u32>,
+  @builtin(local_invocation_id) localId: vec3<u32>,
+) {
+  let row = workgroupId.x;
+  let lane = localId.x;
+  if (row >= params.rows || params.dModel == 0u) {
+    return;
+  }
+  var sum = 0.0;
+  for (var c: u32 = lane; c < params.dModel; c = c + 64u) {
+    sum = sum + input[inputIndex(row, c)];
+  }
+  reduceScratch[lane] = sum;
+  workgroupBarrier();
+  var stride: u32 = 32u;
+  loop {
+    if (lane < stride) {
+      reduceScratch[lane] = reduceScratch[lane] + reduceScratch[lane + stride];
+    }
+    workgroupBarrier();
+    if (stride == 1u) {
+      break;
+    }
+    stride = stride >> 1u;
+  }
+  let mean = reduceScratch[0] / f32(params.dModel);
+  var sq = 0.0;
+  for (var c: u32 = lane; c < params.dModel; c = c + 64u) {
+    let d = input[inputIndex(row, c)] - mean;
+    sq = sq + d * d;
+  }
+  reduceScratch[lane] = sq;
+  workgroupBarrier();
+  stride = 32u;
+  loop {
+    if (lane < stride) {
+      reduceScratch[lane] = reduceScratch[lane] + reduceScratch[lane + stride];
+    }
+    workgroupBarrier();
+    if (stride == 1u) {
+      break;
+    }
+    stride = stride >> 1u;
+  }
+  let variance = reduceScratch[0] / f32(params.dModel);
+  let invStd = inverseSqrt(variance + params.eps);
+  for (var c: u32 = lane; c < params.dModel; c = c + 64u) {
+    let idx = inputIndex(row, c);
+    let normalized = (input[idx] - mean) * invStd;
+    output[idx] = normalized * gamma[c] + beta[c];
+  }
+}
+`;
+function createStorageBuffer(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 createParamsBuffer(device, rows, dModel, eps) {
+  const paramsBytes = new ArrayBuffer(16);
+  const view = new DataView(paramsBytes);
+  view.setUint32(0, rows, true);
+  view.setUint32(4, dModel, true);
+  view.setFloat32(8, eps, true);
+  const params = device.createBuffer({
+    size: paramsBytes.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(params, 0, paramsBytes);
+  return params;
+}
+function createLayerNormKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_LAYER_NORM_SOURCE });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: {
+      module: shader,
+      entryPoint: "main"
+    }
+  });
+  return {
+    async run(input, gamma, beta) {
+      if (gamma.length === 0) {
+        throw new Error("LayerNorm: gamma must be non-empty");
+      }
+      if (beta.length !== gamma.length) {
+        throw new Error("LayerNorm: beta length must match gamma length");
+      }
+      if (input.length % gamma.length !== 0) {
+        throw new Error("LayerNorm: input length must be a multiple of gamma length (dModel)");
+      }
+      const dModel = gamma.length;
+      const rows = input.length / dModel;
+      const eps = 1e-5;
+      const inputBuf = createStorageBuffer(device, input);
+      const gammaBuf = createStorageBuffer(device, gamma);
+      const betaBuf = createStorageBuffer(device, beta);
+      const outputBuf = device.createBuffer({
+        size: input.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+      const paramsBuf = createParamsBuffer(device, rows, dModel, eps);
+      const readback2 = device.createBuffer({
+        size: input.byteLength,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+      const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: inputBuf } },
+          { binding: 1, resource: { buffer: gammaBuf } },
+          { binding: 2, resource: { buffer: betaBuf } },
+          { binding: 3, resource: { buffer: outputBuf } },
+          { binding: 4, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const encoder = device.createCommandEncoder();
+      {
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bindGroup);
+        pass.dispatchWorkgroups(rows, 1, 1);
+        pass.end();
+      }
+      encoder.copyBufferToBuffer(outputBuf, 0, readback2, 0, input.byteLength);
+      device.queue.submit([encoder.finish()]);
+      await readback2.mapAsync(GPUMapMode.READ);
+      const bytes = readback2.getMappedRange();
+      const out = new Float32Array(bytes.slice(0));
+      readback2.unmap();
+      inputBuf.destroy();
+      gammaBuf.destroy();
+      betaBuf.destroy();
+      outputBuf.destroy();
+      paramsBuf.destroy();
+      readback2.destroy();
+      return out;
+    }
+  };
+}
+
+// src/reconstruction/gemmKernel.ts
+var TILE = 8;
+var WGSL_GEMM_SOURCE = `
+const TILE: u32 = 8u;
+struct Params {
+  M: u32,
+  N: u32,
+  K: u32,
+}
+@group(0) @binding(0) var<storage, read>       A:  array<f32>;  // [M * K]
+@group(0) @binding(1) var<storage, read>       B:  array<f32>;  // [K * N]
+@group(0) @binding(2) var<storage, read_write> C:  array<f32>;  // [M * N]
+@group(0) @binding(3) var<uniform>             p:  Params;
+var<workgroup> tileA: array<f32, 64>; // TILE * TILE = 8*8
+var<workgroup> tileB: array<f32, 64>;
+@compute @workgroup_size(8, 8, 1)
+fn main(
+  @builtin(workgroup_id)        wg:  vec3<u32>,
+  @builtin(local_invocation_id) lid: vec3<u32>,
+) {
+  let row = wg.y * TILE + lid.y;
+  let col = wg.x * TILE + lid.x;
+  var acc: f32 = 0.0;
+  let numTiles = (p.K + TILE - 1u) / TILE;
+  for (var t = 0u; t < numTiles; t++) {
+    // Load tile of A (row of A) into shared
+    let aCol = t * TILE + lid.x;
+    if (row < p.M && aCol < p.K) {
+      tileA[lid.y * TILE + lid.x] = A[row * p.K + aCol];
+    } else {
+      tileA[lid.y * TILE + lid.x] = 0.0;
+    }
+    // Load tile of B (col of B) into shared
+    let bRow = t * TILE + lid.y;
+    if (bRow < p.K && col < p.N) {
+      tileB[lid.y * TILE + lid.x] = B[bRow * p.N + col];
+    } else {
+      tileB[lid.y * TILE + lid.x] = 0.0;
+    }
+    workgroupBarrier();
+    for (var k = 0u; k < TILE; k++) {
+      acc = acc + tileA[lid.y * TILE + k] * tileB[k * TILE + lid.x];
+    }
+    workgroupBarrier();
+  }
+  if (row < p.M && col < p.N) {
+    C[row * p.N + col] = acc;
+  }
+}
+`;
+function storageBuffer2(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 createGemmKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_GEMM_SOURCE });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(A, B, M, N, K) {
+      if (A.length !== M * K) throw new Error(`GEMM: A.length=${A.length} != M*K=${M * K}`);
+      if (B.length !== K * N) throw new Error(`GEMM: B.length=${B.length} != K*N=${K * N}`);
+      const aBuf = storageBuffer2(device, A);
+      const bBuf = storageBuffer2(device, B);
+      const cBuf = device.createBuffer({
+        size: M * N * 4,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+      const paramAB = new ArrayBuffer(16);
+      const pu = new Uint32Array(paramAB);
+      pu[0] = M;
+      pu[1] = N;
+      pu[2] = K;
+      const paramsBuf = device.createBuffer({
+        size: paramAB.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(paramsBuf, 0, paramAB);
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: aBuf } },
+          { binding: 1, resource: { buffer: bBuf } },
+          { binding: 2, resource: { buffer: cBuf } },
+          { binding: 3, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const wgX = Math.ceil(N / TILE);
+      const wgY = Math.ceil(M / TILE);
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(wgX, wgY, 1);
+      pass.end();
+      const staging = device.createBuffer({
+        size: M * N * 4,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+      });
+      enc.copyBufferToBuffer(cBuf, 0, staging, 0, M * N * 4);
+      device.queue.submit([enc.finish()]);
+      await staging.mapAsync(GPUMapMode.READ);
+      const result = new Float32Array(staging.getMappedRange().slice(0));
+      staging.unmap();
+      aBuf.destroy();
+      bBuf.destroy();
+      cBuf.destroy();
+      paramsBuf.destroy();
+      staging.destroy();
+      return result;
+    }
+  };
+}
+
+// src/reconstruction/ropeKernel.ts
+var WGSL_ROPE_SOURCE = `
+struct Params {
+  seqLen:    u32,
+  numHeads:  u32,
+  headDim:   u32,
+  base:      f32,
+  posOffset: u32,
+}
+@group(0) @binding(0) var<storage, read>       qIn:  array<f32>;
+@group(0) @binding(1) var<storage, read_write> qOut: array<f32>;
+@group(0) @binding(2) var<uniform>             p:    Params;
+fn flatIdx(token: u32, head: u32, dim: u32) -> u32 {
+  return token * p.numHeads * p.headDim + head * p.headDim + dim;
+}
+@compute @workgroup_size(32, 1, 1)
+fn main(
+  @builtin(workgroup_id)        wgid: vec3<u32>,
+  @builtin(local_invocation_id) lid:  vec3<u32>,
+) {
+  let wg    = wgid.x;
+  let token = wg / p.numHeads;
+  let head  = wg % p.numHeads;
+  if (token >= p.seqLen) { return; }
+  let pairs = p.headDim / 2u;
+  let pos   = token + p.posOffset;
+  var pairIdx = lid.x;
+  while (pairIdx < pairs) {
+    let d       = pairIdx;
+    let exponent = -2.0 * f32(d) / f32(p.headDim);
+    let theta    = f32(pos) * pow(p.base, exponent);
+    let c = cos(theta);
+    let s = sin(theta);
+    let i0 = flatIdx(token, head, 2u * d);
+    let i1 = flatIdx(token, head, 2u * d + 1u);
+    let x0 = qIn[i0];
+    let x1 = qIn[i1];
+    qOut[i0] = x0 * c - x1 * s;
+    qOut[i1] = x0 * s + x1 * c;
+    pairIdx = pairIdx + 32u;
+  }
+}
+`;
+function createStorageBuffer2(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 createOutputBuffer(device, byteLength) {
+  return device.createBuffer({
+    size: byteLength,
+    usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+  });
+}
+function createParamsBuffer2(device, rp) {
+  const buf = new ArrayBuffer(32);
+  const u = new Uint32Array(buf);
+  const f = new Float32Array(buf);
+  u[0] = rp.seqLen;
+  u[1] = rp.numHeads;
+  u[2] = rp.headDim;
+  f[3] = rp.base;
+  u[4] = rp.posOffset;
+  const gpuBuf = device.createBuffer({
+    size: buf.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(gpuBuf, 0, buf);
+  return gpuBuf;
+}
+function createRopeKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_ROPE_SOURCE });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(input, params) {
+      const { seqLen, numHeads, headDim } = params;
+      const base = params.base ?? 1e4;
+      const posOffset = params.posOffset ?? 0;
+      if (headDim % 2 !== 0) {
+        throw new Error("RoPE: headDim must be even");
+      }
+      const expected = seqLen * numHeads * headDim;
+      if (input.length !== expected) {
+        throw new Error(
+          `RoPE: input length ${input.length} does not match seqLen*numHeads*headDim=${expected}`
+        );
+      }
+      const rp = { seqLen, numHeads, headDim, base, posOffset };
+      const inBuf = createStorageBuffer2(device, input);
+      const outBuf = createOutputBuffer(device, input.byteLength);
+      const paramsBuf = createParamsBuffer2(device, rp);
+      const stagingBuf = device.createBuffer({
+        size: input.byteLength,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+      });
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: inBuf } },
+          { binding: 1, resource: { buffer: outBuf } },
+          { binding: 2, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(seqLen * numHeads);
+      pass.end();
+      enc.copyBufferToBuffer(outBuf, 0, stagingBuf, 0, input.byteLength);
+      device.queue.submit([enc.finish()]);
+      await stagingBuf.mapAsync(GPUMapMode.READ);
+      const result = new Float32Array(stagingBuf.getMappedRange().slice(0));
+      stagingBuf.unmap();
+      inBuf.destroy();
+      outBuf.destroy();
+      paramsBuf.destroy();
+      stagingBuf.destroy();
+      return result;
+    }
+  };
+}
+
+// src/reconstruction/fusedMHAKernel.ts
+var WGSL_FUSED_MHA = `
+struct Params {
+  numHeads: u32,
+  qLen:     u32,
+  kLen:     u32,
+  dHead:    u32,   // head dimension (= sqrt-scale base)
+  vHead:    u32,   // output feature dim per head (usually == dHead)
+}
+
+@group(0) @binding(0) var<storage, read>       Q:   array<f32>;  // [h, qLen, dHead]
+@group(0) @binding(1) var<storage, read>       K:   array<f32>;  // [h, kLen, dHead]
+@group(0) @binding(2) var<storage, read>       V:   array<f32>;  // [h, kLen, vHead]
+@group(0) @binding(3) var<storage, read_write> O:   array<f32>;  // [h, qLen, vHead]
+@group(0) @binding(4) var<uniform>             p:   Params;
+
+// Shared memory: reuse for scores then for v-accumulation
+var<workgroup> scores: array<f32, 1024>;  // max supported kLen per workgroup
+
+@compute @workgroup_size(64, 1, 1)
+fn main(
+  @builtin(workgroup_id)        wg:  vec3<u32>,
+  @builtin(local_invocation_id) lid: vec3<u32>,
+) {
+  // workgroup index encodes (head, qRow)
+  let head = wg.x / p.qLen;
+  let qRow = wg.x % p.qLen;
+
+  if (head >= p.numHeads || qRow >= p.qLen) { return; }
+
+  let scale: f32 = 1.0 / sqrt(f32(p.dHead));
+
+  // ---- Phase 1: compute dot products Q[qRow] \xB7 K[k] for all k ----
+  // Thread 0 does sequential dot products and stores in shared scores[]
+  // (for kLen \u2264 1024; if larger, falls back to partial accumulation)
+  if (lid.x == 0u) {
+    let qBase = (head * p.qLen + qRow) * p.dHead;
+    for (var ki = 0u; ki < p.kLen; ki++) {
+      let kBase = (head * p.kLen + ki) * p.dHead;
+      var dot: f32 = 0.0;
+      for (var d = 0u; d < p.dHead; d++) {
+        dot = dot + Q[qBase + d] * K[kBase + d];
+      }
+      scores[ki] = dot * scale;
+    }
+  }
+  workgroupBarrier();
+
+  // ---- Phase 2: stable softmax in-place ----
+  if (lid.x == 0u) {
+    var maxS: f32 = scores[0];
+    for (var ki = 1u; ki < p.kLen; ki++) {
+      maxS = max(maxS, scores[ki]);
+    }
+    var sumExp: f32 = 0.0;
+    for (var ki = 0u; ki < p.kLen; ki++) {
+      scores[ki] = exp(scores[ki] - maxS);
+      sumExp = sumExp + scores[ki];
+    }
+    for (var ki = 0u; ki < p.kLen; ki++) {
+      scores[ki] = scores[ki] / sumExp;
+    }
+  }
+  workgroupBarrier();
+
+  // ---- Phase 3: weighted sum over V ----
+  // Threads fan out over vHead dimension
+  let outBase = (head * p.qLen + qRow) * p.vHead;
+  var vi = lid.x;
+  while (vi < p.vHead) {
+    var acc: f32 = 0.0;
+    for (var ki = 0u; ki < p.kLen; ki++) {
+      acc = acc + scores[ki] * V[(head * p.kLen + ki) * p.vHead + vi];
+    }
+    O[outBase + vi] = acc;
+    vi = vi + 64u;
+  }
+}
+`;
+function storageBuffer3(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 createFusedMHAKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_FUSED_MHA });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: { module: shader, entryPoint: "main" }
+  });
+  return {
+    async run(Q, K, V, params) {
+      const { numHeads, qLen, kLen, dHead } = params;
+      const vHead = params.vHead ?? dHead;
+      if (kLen > 1024) throw new Error(`fusedMHA: kLen=${kLen} exceeds shared memory limit 1024`);
+      if (Q.length !== numHeads * qLen * dHead) throw new Error(`fusedMHA: Q size mismatch`);
+      if (K.length !== numHeads * kLen * dHead) throw new Error(`fusedMHA: K size mismatch`);
+      if (V.length !== numHeads * kLen * vHead) throw new Error(`fusedMHA: V size mismatch`);
+      const outBytes = numHeads * qLen * vHead * 4;
+      const qBuf = storageBuffer3(device, Q);
+      const kBuf = storageBuffer3(device, K);
+      const vBuf = storageBuffer3(device, V);
+      const oBuf = device.createBuffer({
+        size: outBytes,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+      const paramAB = new ArrayBuffer(24);
+      const pu = new Uint32Array(paramAB);
+      pu[0] = numHeads;
+      pu[1] = qLen;
+      pu[2] = kLen;
+      pu[3] = dHead;
+      pu[4] = vHead;
+      const paramsBuf = device.createBuffer({
+        size: paramAB.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      });
+      device.queue.writeBuffer(paramsBuf, 0, paramAB);
+      const bg = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: qBuf } },
+          { binding: 1, resource: { buffer: kBuf } },
+          { binding: 2, resource: { buffer: vBuf } },
+          { binding: 3, resource: { buffer: oBuf } },
+          { binding: 4, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const workgroups = numHeads * qLen;
+      const enc = device.createCommandEncoder();
+      const pass = enc.beginComputePass();
+      pass.setPipeline(pipeline);
+      pass.setBindGroup(0, bg);
+      pass.dispatchWorkgroups(workgroups);
+      pass.end();
+      const staging = device.createBuffer({
+        size: outBytes,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+      });
+      enc.copyBufferToBuffer(oBuf, 0, staging, 0, outBytes);
+      device.queue.submit([enc.finish()]);
+      await staging.mapAsync(GPUMapMode.READ);
+      const result = new Float32Array(staging.getMappedRange().slice(0));
+      staging.unmap();
+      qBuf.destroy();
+      kBuf.destroy();
+      vBuf.destroy();
+      oBuf.destroy();
+      paramsBuf.destroy();
+      staging.destroy();
+      return result;
+    }
+  };
+}
+
+// src/reconstruction/geluKernel.ts
+var WGSL_GELU_SOURCE = `
+struct Params {
+  elements: u32,
+}
+@group(0) @binding(0) var<storage, read> input: array<f32>;
+@group(0) @binding(1) var<storage, read_write> output: array<f32>;
+@group(0) @binding(2) var<uniform> params: Params;
+fn gelu(x: f32) -> f32 {
+  let k0 = 0.7978845608;
+  let k1 = 0.044715;
+  let x3 = x * x * x;
+  let inner = k0 * (x + k1 * x3);
+  return 0.5 * x * (1.0 + tanh(inner));
+}
+@compute @workgroup_size(64, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  var idx = gid.x;
+  let stride = 64u;
+  while (idx < params.elements) {
+    output[idx] = gelu(input[idx]);
+    idx = idx + stride;
+  }
+}
+`;
+function createInputBuffer(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 createParamsBuffer3(device, elements) {
+  const paramsBytes = new ArrayBuffer(16);
+  const view = new DataView(paramsBytes);
+  view.setUint32(0, elements, true);
+  const params = device.createBuffer({
+    size: paramsBytes.byteLength,
+    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+  });
+  device.queue.writeBuffer(params, 0, paramsBytes);
+  return params;
+}
+function createGeluKernel(device) {
+  const shader = device.createShaderModule({ code: WGSL_GELU_SOURCE });
+  const pipeline = device.createComputePipeline({
+    layout: "auto",
+    compute: {
+      module: shader,
+      entryPoint: "main"
+    }
+  });
+  return {
+    async run(input) {
+      if (input.length === 0) {
+        throw new Error("GELU: input must be non-empty");
+      }
+      const inputBuf = createInputBuffer(device, input);
+      const outputBuf = device.createBuffer({
+        size: input.byteLength,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+      });
+      const paramsBuf = createParamsBuffer3(device, input.length);
+      const readback2 = device.createBuffer({
+        size: input.byteLength,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+      const bindGroup = device.createBindGroup({
+        layout: pipeline.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: { buffer: inputBuf } },
+          { binding: 1, resource: { buffer: outputBuf } },
+          { binding: 2, resource: { buffer: paramsBuf } }
+        ]
+      });
+      const encoder = device.createCommandEncoder();
+      {
+        const pass = encoder.beginComputePass();
+        pass.setPipeline(pipeline);
+        pass.setBindGroup(0, bindGroup);
+        pass.dispatchWorkgroups(1, 1, 1);
+        pass.end();
+      }
+      encoder.copyBufferToBuffer(outputBuf, 0, readback2, 0, input.byteLength);
+      device.queue.submit([encoder.finish()]);
+      await readback2.mapAsync(GPUMapMode.READ);
+      const bytes = readback2.getMappedRange();
+      const out = new Float32Array(bytes.slice(0));
+      readback2.unmap();
+      inputBuf.destroy();
+      outputBuf.destroy();
+      paramsBuf.destroy();
+      readback2.destroy();
+      return out;
+    }
+  };
+}
+
+// src/reconstruction/holoMapMicroEncoder.ts
+var MICRO = 14;
+var EMBED_DIM = 32;
+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 || "";
+  for (let i = 0; i < s.length; i += 1) {
+    h = Math.imul(h ^ s.charCodeAt(i), 2654435769);
+  }
+  return h >>> 0;
+}
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return () => {
+    t += 1831565813;
+    let r = Math.imul(t ^ t >>> 15, t | 1);
+    r ^= r + Math.imul(r ^ r >>> 7, r | 61);
+    return ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}
+function fillGaussian2D(out, rng, scale) {
+  for (let i = 0; i < out.length; i += 1) out[i] = (rng() * 2 - 1) * 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;
+  const rng = mulberry32(hashConfigSeed(config));
+  const weights = {
+    proj: new Float32Array(EMBED_DIM * PATCH_LEN),
+    Wq: new Float32Array(EMBED_DIM * EMBED_DIM),
+    Wk: new Float32Array(EMBED_DIM * EMBED_DIM),
+    Wv: new Float32Array(EMBED_DIM * EMBED_DIM),
+    Wxyz: new Float32Array(EMBED_DIM * 3),
+    gamma1: new Float32Array(EMBED_DIM).fill(1),
+    beta1: new Float32Array(EMBED_DIM).fill(0),
+    gamma2: new Float32Array(EMBED_DIM).fill(1),
+    beta2: new Float32Array(EMBED_DIM).fill(0)
+  };
+  fillGaussian2D(weights.proj, rng, 0.02);
+  fillGaussian2D(weights.Wq, rng, 0.02);
+  fillGaussian2D(weights.Wk, rng, 0.02);
+  fillGaussian2D(weights.Wv, rng, 0.02);
+  fillGaussian2D(weights.Wxyz, rng, 0.05);
+  weightCache.set(key, weights);
+  return weights;
+}
+function frameToMicroImage(frame) {
+  const out = new Float32Array(MICRO * MICRO * 3);
+  for (let y = 0; y < MICRO; y += 1) {
+    const sy = Math.min(frame.height - 1, Math.floor(y * frame.height / MICRO));
+    for (let x = 0; x < MICRO; x += 1) {
+      const sx = Math.min(frame.width - 1, Math.floor(x * frame.width / MICRO));
+      const src = (sy * frame.width + sx) * frame.stride;
+      const dst = (y * MICRO + x) * 3;
+      out[dst] = frame.rgb[src] / 255;
+      out[dst + 1] = frame.rgb[src + 1] / 255;
+      out[dst + 2] = frame.rgb[src + 2] / 255;
+    }
+  }
+  return out;
+}
+function patchEmbedCpu(image, proj, embedDim) {
+  const out = new Float32Array(embedDim);
+  for (let d = 0; d < embedDim; d += 1) {
+    let dot = 0;
+    const row = d * PATCH_LEN;
+    for (let i = 0; i < PATCH_LEN; i += 1) dot += image[i] * proj[row + i];
+    out[d] = dot;
+  }
+  return out;
+}
+function gemmCpu(a, b, M, K, N) {
+  const c = new Float32Array(M * N);
+  for (let m = 0; m < M; m += 1) {
+    for (let n = 0; n < N; n += 1) {
+      let acc = 0;
+      for (let k = 0; k < K; k += 1) acc += a[m * K + k] * b[k * N + n];
+      c[m * N + n] = acc;
+    }
+  }
+  return c;
+}
+function layerNormCpu(x, gamma, beta, rows, d) {
+  const y = new Float32Array(x.length);
+  const eps = 1e-5;
+  for (let r = 0; r < rows; r += 1) {
+    let sum = 0;
+    for (let j = 0; j < d; j += 1) sum += x[r * d + j];
+    const mean = sum / d;
+    let sq = 0;
+    for (let j = 0; j < d; j += 1) {
+      const t = x[r * d + j] - mean;
+      sq += t * t;
+    }
+    const inv = 1 / Math.sqrt(sq / d + eps);
+    for (let j = 0; j < d; j += 1) {
+      const norm = (x[r * d + j] - mean) * inv;
+      y[r * d + j] = norm * gamma[j] + beta[j];
+    }
+  }
+  return y;
+}
+function geluCpu(x) {
+  const y = new Float32Array(x.length);
+  const k0 = 0.7978845608;
+  const k1 = 0.044715;
+  for (let i = 0; i < x.length; i += 1) {
+    const v = x[i];
+    const x3 = v * v * v;
+    const inner = k0 * (v + k1 * x3);
+    y[i] = 0.5 * v * (1 + Math.tanh(inner));
+  }
+  return y;
+}
+function mhaCpu(Q, K, V, numHeads, qLen, kLen, dHead, vHead) {
+  const out = new Float32Array(numHeads * qLen * vHead);
+  const scale = 1 / Math.sqrt(Math.max(dHead, 1));
+  for (let h = 0; h < numHeads; h += 1) {
+    for (let qi = 0; qi < qLen; qi += 1) {
+      const scores = new Float32Array(kLen);
+      let maxS = -Infinity;
+      const qBase = (h * qLen + qi) * dHead;
+      for (let ki = 0; ki < kLen; ki += 1) {
+        const kBase = (h * kLen + ki) * dHead;
+        let dot = 0;
+        for (let d = 0; d < dHead; d += 1) dot += Q[qBase + d] * K[kBase + d];
+        const s = dot * scale;
+        scores[ki] = s;
+        maxS = Math.max(maxS, s);
+      }
+      let denom = 0;
+      for (let ki = 0; ki < kLen; ki += 1) {
+        scores[ki] = Math.exp(scores[ki] - maxS);
+        denom += scores[ki];
+      }
+      const oBase = (h * qLen + qi) * vHead;
+      for (let vi = 0; vi < vHead; vi += 1) {
+        let acc = 0;
+        for (let ki = 0; ki < kLen; ki += 1) {
+          acc += scores[ki] / Math.max(denom, 1e-9) * V[(h * kLen + ki) * vHead + vi];
+        }
+        out[oBase + vi] = acc;
+      }
+    }
+  }
+  return out;
+}
+function ropeCpuSync(q, seqLen, numHeads, headDim, posOffset) {
+  const out = q.slice();
+  const base = 1e4;
+  for (let t = 0; t < seqLen; t += 1) {
+    const pos = t + posOffset;
+    for (let h = 0; h < numHeads; h += 1) {
+      for (let p = 0; p < headDim / 2; p += 1) {
+        const exp = -2 * (p / headDim);
+        const theta = pos * base ** exp;
+        const c = Math.cos(theta);
+        const s = Math.sin(theta);
+        const i0 = (t * numHeads + h) * headDim + 2 * p;
+        const i1 = i0 + 1;
+        const x0 = q[i0];
+        const x1 = q[i1];
+        out[i0] = x0 * c - x1 * s;
+        out[i1] = x0 * s + x1 * c;
+      }
+    }
+  }
+  return out;
+}
+async function tryCreateHoloMapEncoderDevice() {
+  try {
+    const nav = globalThis.navigator;
+    if (!nav?.gpu) return null;
+    const adapter = await nav.gpu.requestAdapter();
+    if (!adapter) return null;
+    return await adapter.requestDevice();
+  } catch {
+    return null;
+  }
+}
+function createHoloMapMicroEncoder(device) {
+  const patchEmbed = createImagePatchEmbedKernel(device);
+  const layerNorm = createLayerNormKernel(device);
+  const gemm = createGemmKernel(device);
+  const rope = createRopeKernel(device);
+  const fusedMha = createFusedMHAKernel(device);
+  const gelu = createGeluKernel(device);
+  return {
+    async run(frame, config) {
+      const weights = getMicroWeights(config);
+      const image = frameToMicroImage(frame);
+      let tokens = await patchEmbed.run(image, weights.proj, {
+        imgH: MICRO,
+        imgW: MICRO,
+        patchH: MICRO,
+        patchW: MICRO,
+        numChannels: 3,
+        embedDim: EMBED_DIM
+      });
+      tokens = await layerNorm.run(tokens, weights.gamma1, weights.beta1);
+      const qFlat = await gemm.run(tokens, weights.Wq, 1, EMBED_DIM, EMBED_DIM);
+      const kFlat = await gemm.run(tokens, weights.Wk, 1, EMBED_DIM, EMBED_DIM);
+      const vFlat = await gemm.run(tokens, weights.Wv, 1, EMBED_DIM, EMBED_DIM);
+      const q3 = await rope.run(qFlat, {
+        seqLen: 1,
+        numHeads: NUM_HEADS,
+        headDim: HEAD_DIM,
+        posOffset: frame.index
+      });
+      const k3 = await rope.run(kFlat, {
+        seqLen: 1,
+        numHeads: NUM_HEADS,
+        headDim: HEAD_DIM,
+        posOffset: frame.index
+      });
+      let attn = await fusedMha.run(q3, k3, vFlat, {
+        numHeads: NUM_HEADS,
+        qLen: 1,
+        kLen: 1,
+        dHead: HEAD_DIM,
+        vHead: HEAD_DIM
+      });
+      attn = await layerNorm.run(attn, weights.gamma2, weights.beta2);
+      attn = await gelu.run(attn);
+      return gemm.run(attn, weights.Wxyz, 1, EMBED_DIM, 3);
+    }
+  };
+}
+async function runHoloMapMicroEncoderCpu(frame, config) {
+  const weights = getMicroWeights(config);
+  const image = frameToMicroImage(frame);
+  let tokens = patchEmbedCpu(image, weights.proj, EMBED_DIM);
+  tokens = layerNormCpu(tokens, weights.gamma1, weights.beta1, 1, EMBED_DIM);
+  const qFlat = gemmCpu(tokens, weights.Wq, 1, EMBED_DIM, EMBED_DIM);
+  const kFlat = gemmCpu(tokens, weights.Wk, 1, EMBED_DIM, EMBED_DIM);
+  const vFlat = gemmCpu(tokens, weights.Wv, 1, EMBED_DIM, EMBED_DIM);
+  const qR = ropeCpuSync(qFlat, 1, NUM_HEADS, HEAD_DIM, frame.index);
+  const kR = ropeCpuSync(kFlat, 1, NUM_HEADS, HEAD_DIM, frame.index);
+  let attn = mhaCpu(qR, kR, vFlat, NUM_HEADS, 1, 1, HEAD_DIM, HEAD_DIM);
+  attn = layerNormCpu(attn, weights.gamma2, weights.beta2, 1, EMBED_DIM);
+  attn = geluCpu(attn);
+  return gemmCpu(attn, weights.Wxyz, 1, EMBED_DIM, 3);
+}
+
+// src/reconstruction/holoMapTelemetry.ts
+var highVolumeEvents = /* @__PURE__ */ new Set(["step", "step_throttled", "step_evict"]);
+var pendingStepSummaries = /* @__PURE__ */ new Map();
+function loggingDisabled() {
+  try {
+    return typeof process !== "undefined" && process.env?.HOLOMAP_LOG === "0";
+  } catch {
+    return false;
+  }
+}
+function verboseStepLoggingEnabled() {
+  try {
+    if (typeof process === "undefined") {
+      return false;
+    }
+    const value = process.env?.HOLOMAP_LOG?.toLowerCase();
+    return value === "verbose" || value === "debug" || process.env?.HOLOMAP_LOG_STEPS === "1";
+  } catch {
+    return false;
+  }
+}
+function numericDetail(detail, key) {
+  const value = detail?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function getOrCreateStepSummary(runId) {
+  const existing = pendingStepSummaries.get(runId);
+  if (existing) {
+    return existing;
+  }
+  const summary = {
+    stepCount: 0,
+    firstFrameIndex: null,
+    lastFrameIndex: null,
+    pointCountTotal: 0,
+    totalStepMs: 0,
+    maxStepMs: 0,
+    minStepMs: Infinity,
+    throttledCount: 0,
+    evictionCount: 0,
+    evictedPointTotal: 0,
+    lastThrottledFrameIndex: null,
+    lastEvictedFrameIndex: null,
+    lastRetainedSteps: null,
+    latestAvgStepMs: null,
+    latestThrottledSoFar: null
+  };
+  pendingStepSummaries.set(runId, summary);
+  return summary;
+}
+function accumulateStepSummary(runId, event, detail) {
+  const summary = getOrCreateStepSummary(runId);
+  const frameIndex = numericDetail(detail, "frameIndex");
+  if (event === "step") {
+    summary.stepCount += 1;
+    if (frameIndex !== null) {
+      summary.firstFrameIndex = summary.firstFrameIndex ?? frameIndex;
+      summary.lastFrameIndex = frameIndex;
+    }
+    summary.pointCountTotal += numericDetail(detail, "pointCount") ?? 0;
+    const stepMs = numericDetail(detail, "stepMs");
+    if (stepMs !== null) {
+      summary.totalStepMs += stepMs;
+      summary.maxStepMs = Math.max(summary.maxStepMs, stepMs);
+      summary.minStepMs = Math.min(summary.minStepMs, stepMs);
+    }
+    summary.latestAvgStepMs = numericDetail(detail, "avgStepMs") ?? summary.latestAvgStepMs;
+    summary.latestThrottledSoFar = numericDetail(detail, "throttledSoFar") ?? summary.latestThrottledSoFar;
+    return;
+  }
+  if (event === "step_throttled") {
+    summary.throttledCount += 1;
+    summary.lastThrottledFrameIndex = frameIndex ?? summary.lastThrottledFrameIndex;
+    return;
+  }
+  summary.evictionCount += 1;
+  summary.lastEvictedFrameIndex = frameIndex ?? summary.lastEvictedFrameIndex;
+  summary.evictedPointTotal += numericDetail(detail, "evictedPoints") ?? 0;
+  summary.lastRetainedSteps = numericDetail(detail, "retainedSteps") ?? summary.lastRetainedSteps;
+}
+function emitLogPayload(runId, event, detail) {
+  const payload = {
+    t: (/* @__PURE__ */ new Date()).toISOString(),
+    runId,
+    event,
+    ...detail
+  };
+  console.log(`[HoloMap] ${JSON.stringify(payload)}`);
+}
+function flushStepSummary(runId, reason) {
+  const summary = pendingStepSummaries.get(runId);
+  if (!summary) {
+    return;
+  }
+  pendingStepSummaries.delete(runId);
+  const throttledCount = Math.max(summary.throttledCount, summary.latestThrottledSoFar ?? 0);
+  emitLogPayload(runId, "step_summary", {
+    reason,
+    stepCount: summary.stepCount,
+    firstFrameIndex: summary.firstFrameIndex,
+    lastFrameIndex: summary.lastFrameIndex,
+    pointCountTotal: summary.pointCountTotal,
+    avgStepMs: summary.stepCount > 0 ? Math.round(summary.totalStepMs / summary.stepCount) : summary.latestAvgStepMs ?? 0,
+    maxStepMs: summary.stepCount > 0 ? Math.round(summary.maxStepMs) : 0,
+    minStepMs: summary.stepCount > 0 ? Math.round(summary.minStepMs) : 0,
+    throttledCount,
+    evictionCount: summary.evictionCount,
+    evictedPointTotal: summary.evictedPointTotal,
+    lastThrottledFrameIndex: summary.lastThrottledFrameIndex,
+    lastEvictedFrameIndex: summary.lastEvictedFrameIndex,
+    lastRetainedSteps: summary.lastRetainedSteps
+  });
+}
+function createHoloMapRunId() {
+  try {
+    const c = globalThis.crypto;
+    if (c && "randomUUID" in c) {
+      return `hm_${c.randomUUID().slice(0, 8)}`;
+    }
+  } catch {
+  }
+  return `hm_${Math.random().toString(36).slice(2, 10)}`;
+}
+function logHoloMapEvent(runId, event, detail) {
+  if (loggingDisabled()) {
+    return;
+  }
+  if (highVolumeEvents.has(event) && !verboseStepLoggingEnabled()) {
+    accumulateStepSummary(runId, event, detail);
+    return;
+  }
+  if (event === "finalize" || event === "dispose" || event === "error") {
+    flushStepSummary(runId, event);
+  }
+  emitLogPayload(runId, event, detail);
+}
+function resetHoloMapTelemetryForTests() {
+  pendingStepSummaries.clear();
+}
+
+// src/reconstruction/holoMapWeightLoader.ts
+async function sha256Digest(bytes) {
+  const c = globalThis.crypto;
+  if (c?.subtle) {
+    const buf = await c.subtle.digest(
+      "SHA-256",
+      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+    );
+    return bufferToHex(new Uint8Array(buf));
+  }
+  const { createHash } = await import('crypto');
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function bufferToHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i += 1) s += bytes[i].toString(16).padStart(2, "0");
+  return s;
+}
+function normalizeWeightCidDigest(cid) {
+  const t = cid.trim().toLowerCase();
+  if (t.startsWith("sha256:")) return t.slice("sha256:".length);
+  return t;
+}
+async function assertWeightCid(bytes, weightCid) {
+  const expect = normalizeWeightCidDigest(weightCid);
+  if (!/^[0-9a-f]{64}$/.test(expect)) {
+    throw new Error(
+      `HoloMap weights: weightCid must be sha256:hex64 or 64-char hex (got "${weightCid.slice(0, 24)}...")`
+    );
+  }
+  const actual = await sha256Digest(bytes);
+  if (actual !== expect) {
+    throw new Error(
+      `HoloMap weights: digest mismatch \u2014 expected ${expect.slice(0, 12)}\u2026 got ${actual.slice(0, 12)}\u2026`
+    );
+  }
+}
+function isFileUrl(url) {
+  return url.startsWith("file://");
+}
+async function readFileUrl(url) {
+  const { readFile } = await import('fs/promises');
+  const path = url.slice("file://".length);
+  const buf = await readFile(path);
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function loadHoloMapWeightBlob(options) {
+  const { weightUrl, weightUrls = [], weightCid, fetchImpl, skipCache, localResolver } = options;
+  const f = fetchImpl ?? globalThis.fetch;
+  if (localResolver && weightCid) {
+    try {
+      const local = await localResolver(weightCid);
+      if (local) {
+        await assertWeightCid(new Uint8Array(local), weightCid);
+        await putCachedWeightBlob(weightCid, local);
+        return { bytes: local, verified: true, source: "file" };
+      }
+    } catch {
+    }
+  }
+  if (weightCid && !skipCache) {
+    const cached = await getCachedWeightBlob(weightCid);
+    if (cached) {
+      return { bytes: cached, verified: true, source: "cache" };
+    }
+  }
+  const candidates = [weightUrl, ...weightUrls];
+  for (const url of candidates) {
+    if (isFileUrl(url)) {
+      try {
+        const buf = await readFileUrl(url);
+        if (weightCid) {
+          await assertWeightCid(new Uint8Array(buf), weightCid);
+        }
+        if (weightCid) {
+          await putCachedWeightBlob(weightCid, buf);
+        }
+        return { bytes: buf, verified: !!weightCid, source: "file" };
+      } catch {
+      }
+      continue;
+    }
+    if (typeof f !== "function") {
+      throw new Error("HoloMap weights: fetch is not available (provide fetchImpl)");
+    }
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        const res = await f(url);
+        if (!res.ok) {
+          throw new Error(`GET ${url} failed (${res.status} ${res.statusText})`);
+        }
+        const buf = await res.arrayBuffer();
+        if (weightCid) {
+          await assertWeightCid(new Uint8Array(buf), weightCid);
+        }
+        if (weightCid) {
+          await putCachedWeightBlob(weightCid, buf);
+        }
+        return { bytes: buf, verified: !!weightCid, source: "network" };
+      } catch (err) {
+        if (attempt < 2) {
+          await sleep(250 * (attempt + 1));
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  throw new Error(`HoloMap weights: all sources exhausted (tried ${candidates.length} URL(s))`);
+}
+
+// src/reconstruction/holoMapWeightCache.ts
+var DB_NAME = "HoloMapWeightCache";
+var STORE_NAME = "weights";
+var DB_VERSION = 1;
+async function openIndexedDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onerror = () => reject(req.error);
+    req.onsuccess = () => resolve(req.result);
+    req.onupgradeneeded = () => {
+      req.result.createObjectStore(STORE_NAME);
+    };
+  });
+}
+async function idbGet(db, key) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const req = store.get(key);
+    req.onsuccess = () => {
+      const result = req.result;
+      if (result instanceof ArrayBuffer) resolve(result);
+      else if (result && typeof result.byteLength === "number") resolve(result);
+      else resolve(void 0);
+    };
+    req.onerror = () => reject(req.error);
+  });
+}
+async function idbPut(db, key, value) {
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const req = store.put(value, key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+var nodeCacheDeps = null;
+async function getNodeCacheDeps() {
+  if (nodeCacheDeps) return nodeCacheDeps;
+  try {
+    const fs = await import('fs/promises');
+    const os = await import('os');
+    const path = await import('path');
+    nodeCacheDeps = {
+      readFile: (p) => fs.readFile(p),
+      writeFile: (p, d) => fs.writeFile(p, d),
+      mkdir: (p, o) => fs.mkdir(p, o),
+      stat: (p) => fs.stat(p),
+      tmpdir: () => os.tmpdir(),
+      homedir: () => os.homedir()
+    };
+    return nodeCacheDeps;
+  } catch {
+    return null;
+  }
+}
+async function nodeCachePath(deps, cid) {
+  const path = await import('path');
+  const base = process.env.HOLOMAP_WEIGHT_CACHE_DIR ?? path.join(deps.homedir(), ".cache", "holoscript", "holomap-weights");
+  return path.join(base, `${cid}.bin`);
+}
+async function nodeCacheGet(deps, cid) {
+  const p = await nodeCachePath(deps, cid);
+  try {
+    const buf = await deps.readFile(p);
+    const copy = new ArrayBuffer(buf.byteLength);
+    new Uint8Array(copy).set(buf);
+    return copy;
+  } catch {
+    return void 0;
+  }
+}
+async function nodeCachePut(deps, cid, value) {
+  const p = await nodeCachePath(deps, cid);
+  const path = await import('path');
+  const dir = path.dirname(p);
+  await deps.mkdir(dir, { recursive: true });
+  await deps.writeFile(p, new Uint8Array(value));
+}
+function isIndexedDBAvailable() {
+  return typeof indexedDB !== "undefined";
+}
+async function getCachedWeightBlob(weightCid) {
+  const cid = normalizeWeightCidDigest(weightCid);
+  if (isIndexedDBAvailable()) {
+    try {
+      const db = await openIndexedDB();
+      const cached = await idbGet(db, cid);
+      db.close();
+      return cached;
+    } catch {
+    }
+  }
+  const deps = await getNodeCacheDeps();
+  if (deps) {
+    return nodeCacheGet(deps, cid);
+  }
+  return void 0;
+}
+async function putCachedWeightBlob(weightCid, value) {
+  const cid = normalizeWeightCidDigest(weightCid);
+  if (isIndexedDBAvailable()) {
+    try {
+      const db = await openIndexedDB();
+      await idbPut(db, cid, value);
+      db.close();
+      return;
+    } catch {
+    }
+  }
+  const deps = await getNodeCacheDeps();
+  if (deps) {
+    await nodeCachePut(deps, cid, 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;
+  const residentPageStates = /* @__PURE__ */ new Set();
+  let disposed = false;
+  let nextPageId = 0;
+  let accessClock = 0;
+  let devicePageCount = 0;
+  let hostPageCount = 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 Array.from(residentPageStates);
+  }
+  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";
+    residentPageStates.delete(page);
+    devicePageCount -= 1;
+    hostPageCount += 1;
+    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;
+    if (page.residency === "host") hostPageCount -= 1;
+    page.residency = "device";
+    residentPageStates.add(page);
+    devicePageCount += 1;
+    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);
+    residentPageStates.add(page);
+    devicePageCount += 1;
+    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 appendCpuInPlace(pages, touchedPages, vectors, startToken) {
+    const numVecs = vectors.length / config.hiddenDim;
+    for (let v = 0; v < numVecs; v += 1) {
+      const token = startToken + v;
+      const logicalPage = Math.floor(token / config.pageSize);
+      const inPage = token % config.pageSize;
+      const physicalPage = touchedPages.get(logicalPage)?.physicalPage;
+      if (physicalPage === void 0 || physicalPage === null) {
+        throw new Error(`PagedKVCache append misses resident logical page ${logicalPage}.`);
+      }
+      const base = physicalPage * config.pageSize * config.hiddenDim;
+      for (let d = 0; d < config.hiddenDim; d += 1) {
+        pages[base + inPage * config.hiddenDim + d] = vectors[v * config.hiddenDim + d];
+      }
+    }
+  }
+  function lookupCpuDirect(pages, layerState, 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 = layerState.pages.get(logicalPage)?.physicalPage;
+      if (physicalPage === void 0 || physicalPage === null) {
+        throw new Error(`PagedKVCache lookup misses resident logical page ${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(residentPageStates).filter((page) => page.layer === layer).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();
+      return {
+        device: devicePageCount * pageBytes * 2,
+        host: hostPageCount * pageBytes * 2
+      };
+    },
+    async dispose() {
+      disposed = true;
+      for (const layer of layers) layer.pages.clear();
+      residentPageStates.clear();
+      freePhysicalPages.length = 0;
+      devicePageCount = 0;
+      hostPageCount = 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 requiredPages = /* @__PURE__ */ new Set();
+      for (let i = 0; i < tokenCount; i += 1) {
+        const token = startToken + i;
+        const logicalPage = Math.floor(token / config.pageSize);
+        requiredPages.add(logicalPage);
+      }
+      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);
+      }
+      if (appendKernel) {
+        const slotMap = new Uint32Array(tokenCount);
+        for (let i = 0; i < tokenCount; i += 1) {
+          const token = startToken + i;
+          const logicalPage = Math.floor(token / config.pageSize);
+          const slot = token % config.pageSize;
+          slotMap[i] = logicalPage << 16 | slot;
+        }
+        const pageTable = buildPageTable(layer, touchedPages.keys());
+        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 {
+        appendCpuInPlace(keyPages, touchedPages, keyVectors, startToken);
+        appendCpuInPlace(valuePages, touchedPages, valueVectors, startToken);
+      }
+      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));
+      }
+      if (lookupKernel) {
+        const pageTable = buildPageTable(layer, requiredPages);
+        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: lookupCpuDirect(keyPages, layers[layer], tokenCount, startToken),
+        values: lookupCpuDirect(valuePages, layers[layer], 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 },
+  targetFPS: 15,
+  maxSequenceLength: 1e4,
+  seed: 0,
+  modelHash: "unset",
+  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 };
+    this.initialized = false;
+    this.steps = [];
+    this.replayKey = "unset";
+    this.runId = createHoloMapRunId();
+    this.encoderDevice = null;
+    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];
+    this.boundsMax = [0, 0, 0];
+    this.boundsValid = false;
+    /** Running total point count (avoids O(n) re-scan in finalize). */
+    this.totalPointCount = 0;
+    // ── Scan-derived trajectory / drift state ──
+    // Anchor pose, trajectory keyframes, and drift are derived from the scan
+    // geometry rather than emitted as constants. Drift is an uncertainty-weighted
+    // inter-frame pose delta accumulated over the capture.
+    /** Accumulated drift estimate (meters) over the capture. */
+    this.cumulativeDriftMeters = 0;
+    /**
+     * Running sum of every observed point position + confidence (eviction-adjusted).
+     * The anchor pose is the centroid (sum/count) of all observed points and the
+     * descriptor carries the global mean confidence, so a single tampered point
+     * moves the anchor — bounds center/extent alone are insensitive to a one-point
+     * nudge that does not touch an extremum. (E4 acceptance bar.)
+     */
+    this.globalPosSum = [0, 0, 0];
+    this.globalConfSum = 0;
+    this.globalPrincipalMomentXX = 0;
+    this.globalPrincipalMomentZZ = 0;
+    this.globalPrincipalMomentXZ = 0;
+    /** Previous frame camera pose (centroid of that frame's points). */
+    this.prevPose = null;
+    /** Previous full camera pose, including scan-derived principal-axis rotation. */
+    this.prevCameraPose = null;
+    /** Previous inter-frame velocity, for constant-velocity drift prediction. */
+    this.prevVelocity = null;
+    /** Frame index of the last detected loop closure (−1 if none). */
+    this.lastLoopClosureFrameIdx = -1;
+    /** Compact camera-pose history for loop-closure (revisit) detection. */
+    this.poseHistory = [];
+    /** Compact trajectory snapshot emitted with every accepted step. */
+    this.trajectoryKeyframes = [];
+    /** Last accepted capture timestamp (ms) for deterministic FPS throttling. */
+    this.lastAcceptedFrameTimestampMs = null;
+    /** Deterministic session start timestamp. */
+    this.sessionStartMs = 0;
+    /** Performance metrics accumulated across steps. */
+    this.perfMetrics = { stepCount: 0, throttledCount: 0, totalStepMs: 0, maxStepMs: 0, minStepMs: Infinity };
+  }
+  /**
+   * Nearest-neighbour sample of a row-major depth map at a normalized UV.
+   * Used to read MEASURED sensor depth at a tile centre (frame.depth). Nearest
+   * (not bilinear) keeps it deterministic and cheap; tiles are small.
+   */
+  static sampleDepthNearestUv(depth, 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 = 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 {
+        min: [0, 0, 0],
+        max: [0, 0, 0]
+      };
+    }
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const step of steps) {
+      const { positions } = step.points;
+      for (let i = 0; i < positions.length; i += 3) {
+        const x = positions[i] ?? 0;
+        const y = positions[i + 1] ?? 0;
+        const z = positions[i + 2] ?? 0;
+        if (x < minX) minX = x;
+        if (y < minY) minY = y;
+        if (z < minZ) minZ = z;
+        if (x > maxX) maxX = x;
+        if (y > maxY) maxY = y;
+        if (z > maxZ) maxZ = z;
+      }
+    }
+    if (!Number.isFinite(minX)) {
+      return {
+        min: [0, 0, 0],
+        max: [0, 0, 0]
+      };
+    }
+    return {
+      min: [minX, minY, minZ],
+      max: [maxX, maxY, maxZ]
+    };
+  }
+  /** Update running bounds with new point positions. */
+  updateBounds(positions) {
+    if (positions.length === 0) return;
+    if (!this.boundsValid) {
+      this.boundsMin = [
+        Number.POSITIVE_INFINITY,
+        Number.POSITIVE_INFINITY,
+        Number.POSITIVE_INFINITY
+      ];
+      this.boundsMax = [
+        Number.NEGATIVE_INFINITY,
+        Number.NEGATIVE_INFINITY,
+        Number.NEGATIVE_INFINITY
+      ];
+    }
+    for (let i = 0; i < positions.length; i += 3) {
+      const x = positions[i] ?? 0;
+      const y = positions[i + 1] ?? 0;
+      const z = positions[i + 2] ?? 0;
+      if (x < this.boundsMin[0]) this.boundsMin[0] = x;
+      if (y < this.boundsMin[1]) this.boundsMin[1] = y;
+      if (z < this.boundsMin[2]) this.boundsMin[2] = z;
+      if (x > this.boundsMax[0]) this.boundsMax[0] = x;
+      if (y > this.boundsMax[1]) this.boundsMax[1] = y;
+      if (z > this.boundsMax[2]) this.boundsMax[2] = z;
+    }
+    this.boundsValid = true;
+  }
+  /** Get current bounds (running or computed). */
+  getBounds() {
+    if (this.boundsValid) {
+      return { min: [...this.boundsMin], max: [...this.boundsMax] };
+    }
+    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;
+    let xz = 0;
+    let n = 0;
+    for (const positions of chunks) {
+      for (let i = 0; i < positions.length; i += 3) {
+        const dx = (positions[i] ?? 0) - centroid[0];
+        const dz = (positions[i + 2] ?? 0) - centroid[2];
+        xx += dx * dx;
+        zz += dz * dz;
+        xz += dx * dz;
+        n += 1;
+      }
+    }
+    if (n < 2 || xx + zz < 1e-12) return [0, 0, 0, 1];
+    const yaw = 0.5 * Math.atan2(2 * xz, xx - zz);
+    return _HoloMapRuntimeImpl.yawToQuaternion(yaw);
+  }
+  static estimatePrincipalAxisRotationFromMoments(momentXX, momentZZ, momentXZ, pointCount, centroid) {
+    if (pointCount < 2) return [0, 0, 0, 1];
+    const xx = momentXX - pointCount * centroid[0] * centroid[0];
+    const zz = momentZZ - pointCount * centroid[2] * centroid[2];
+    const xz = momentXZ - pointCount * centroid[0] * centroid[2];
+    if (xx + zz < 1e-12) return [0, 0, 0, 1];
+    const yaw = 0.5 * Math.atan2(2 * xz, xx - zz);
+    return _HoloMapRuntimeImpl.yawToQuaternion(yaw);
+  }
+  static yawToQuaternion(yaw) {
+    const half = yaw / 2;
+    return [0, Math.sin(half), 0, Math.cos(half)];
+  }
+  static poseDistanceMeters(a, b) {
+    const dx = a.position[0] - b.position[0];
+    const dy = a.position[1] - b.position[1];
+    const dz = a.position[2] - b.position[2];
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+  static poseRotationDeltaRadians(a, b) {
+    const dot = Math.abs(
+      a.rotation[0] * b.rotation[0] + a.rotation[1] * b.rotation[1] + a.rotation[2] * b.rotation[2] + a.rotation[3] * b.rotation[3]
+    );
+    const clamped = Math.max(-1, Math.min(1, dot));
+    return 2 * Math.acos(clamped);
+  }
+  static buildTrajectoryEmbedding(pose, anchorDescriptor, interFrameDeltaMeters, interFrameRotationRadians) {
+    return new Float32Array([
+      pose.position[0],
+      pose.position[1],
+      pose.position[2],
+      pose.rotation[0],
+      pose.rotation[1],
+      pose.rotation[2],
+      pose.rotation[3],
+      pose.confidence,
+      interFrameDeltaMeters,
+      interFrameRotationRadians,
+      anchorDescriptor[0] ?? 0,
+      anchorDescriptor[1] ?? 0,
+      anchorDescriptor[2] ?? 0,
+      anchorDescriptor[3] ?? 0
+    ]);
+  }
+  static cloneTrajectoryKeyframes(keyframes, maxCount = keyframes.length) {
+    const start = Math.max(0, keyframes.length - Math.max(0, maxCount));
+    const out = [];
+    for (let i = start; i < keyframes.length; i += 1) {
+      const keyframe = keyframes[i];
+      out.push({
+        frameIndex: keyframe.frameIndex,
+        timestampMs: keyframe.timestampMs,
+        pose: {
+          position: [...keyframe.pose.position],
+          rotation: [...keyframe.pose.rotation],
+          confidence: keyframe.pose.confidence
+        },
+        embedding: new Float32Array(keyframe.embedding)
+      });
+    }
+    return out;
+  }
+  pushTrajectoryKeyframe(keyframe) {
+    this.trajectoryKeyframes.push(keyframe);
+    if (this.trajectoryKeyframes.length > _HoloMapRuntimeImpl.TRAJECTORY_KEYFRAME_CAP) {
+      this.trajectoryKeyframes.shift();
+    }
+  }
+  async init(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 && !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);
+    }
+    this.steps.length = 0;
+    this.totalPointCount = 0;
+    this.boundsValid = false;
+    this.boundsMin = [0, 0, 0];
+    this.boundsMax = [0, 0, 0];
+    this.cumulativeDriftMeters = 0;
+    this.prevPose = null;
+    this.prevCameraPose = null;
+    this.prevVelocity = null;
+    this.lastLoopClosureFrameIdx = -1;
+    this.poseHistory.length = 0;
+    this.trajectoryKeyframes.length = 0;
+    this.globalPosSum = [0, 0, 0];
+    this.globalConfSum = 0;
+    this.globalPrincipalMomentXX = 0;
+    this.globalPrincipalMomentZZ = 0;
+    this.globalPrincipalMomentXZ = 0;
+    this.lastAcceptedFrameTimestampMs = null;
+    this.sessionStartMs = performance.now();
+    this.perfMetrics = {
+      stepCount: 0,
+      throttledCount: 0,
+      totalStepMs: 0,
+      maxStepMs: 0,
+      minStepMs: Infinity
+    };
+    this.replayKey = chunkLM2VU56C_cjs.computeHoloMapReplayFingerprint({
+      modelHash: this.config.modelHash,
+      seed: this.config.seed,
+      weightStrategy: this.config.weightStrategy ?? "distill",
+      videoHash: this.config.videoHash,
+      tileGrid: this.config.tileGrid,
+      weightCid: this.config.weightCid,
+      verticalProfile: this.config.verticalProfile
+    });
+    this.weightBytes = null;
+    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,
+        weightUrls: this.config.weightUrls,
+        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: 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
+    });
+  }
+  static normalizeTileGrid(value) {
+    const raw = value ?? _HoloMapRuntimeImpl.GRID_N;
+    if (!Number.isFinite(raw)) {
+      throw new Error(`HoloMapRuntime.init invalid tileGrid: ${String(value)}`);
+    }
+    const tileGrid = Math.floor(raw);
+    if (tileGrid < 1 || tileGrid > _HoloMapRuntimeImpl.MAX_GRID_N) {
+      throw new Error(
+        `HoloMapRuntime.init tileGrid must be an integer from 1 to ${_HoloMapRuntimeImpl.MAX_GRID_N}`
+      );
+    }
+    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
+   * pixels (used to color the corresponding output point).
+   *
+   * Tiles inherit `frame.index` shifted by tile id so micro-encoder
+   * per-frame seeds remain deterministic and distinct across tiles.
+   */
+  static tileFrame(frame, gridN) {
+    const out = [];
+    const tileW = Math.max(1, Math.floor(frame.width / gridN));
+    const tileH = Math.max(1, Math.floor(frame.height / gridN));
+    const stride = frame.stride;
+    for (let ty = 0; ty < gridN; ty += 1) {
+      for (let tx = 0; tx < gridN; tx += 1) {
+        const x0 = tx * tileW;
+        const y0 = ty * tileH;
+        const x1 = tx === gridN - 1 ? frame.width : x0 + tileW;
+        const y1 = ty === gridN - 1 ? frame.height : y0 + tileH;
+        const w = x1 - x0;
+        const h = y1 - y0;
+        const tileBytes = new Uint8Array(w * h * stride);
+        let rSum = 0;
+        let gSum = 0;
+        let bSum = 0;
+        let lumaSum = 0;
+        let lumaSqSum = 0;
+        let count = 0;
+        for (let y = 0; y < h; y += 1) {
+          const srcRow = (y0 + y) * frame.width * stride;
+          const dstRow = y * w * stride;
+          for (let x = 0; x < w; x += 1) {
+            const sIdx = srcRow + (x0 + x) * stride;
+            const dIdx = dstRow + x * stride;
+            const r = frame.rgb[sIdx] ?? 0;
+            const g = frame.rgb[sIdx + 1] ?? 0;
+            const b = frame.rgb[sIdx + 2] ?? 0;
+            tileBytes[dIdx] = r;
+            tileBytes[dIdx + 1] = g;
+            tileBytes[dIdx + 2] = b;
+            if (stride === 4) tileBytes[dIdx + 3] = frame.rgb[sIdx + 3] ?? 255;
+            rSum += r;
+            gSum += g;
+            bSum += b;
+            const luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            lumaSum += luma;
+            lumaSqSum += luma * luma;
+            count += 1;
+          }
+        }
+        const denom = Math.max(1, count);
+        const meanLuma = lumaSum / denom;
+        const lumaVariance = Math.max(0, lumaSqSum / denom - meanLuma * meanLuma);
+        const tileId = ty * gridN + tx;
+        out.push({
+          tile: {
+            // Encode (frameIndex, tileId) into the per-tile micro index so
+            // each tile gets a distinct deterministic micro-encoder seed.
+            index: frame.index * gridN * gridN + tileId,
+            rgb: tileBytes,
+            width: w,
+            height: h,
+            stride
+          },
+          centerUv: [
+            (x0 + x1) * 0.5 / Math.max(1, frame.width),
+            (y0 + y1) * 0.5 / Math.max(1, frame.height)
+          ],
+          luminance: meanLuma / 255,
+          texture: Math.sqrt(lumaVariance) / 255,
+          meanColor: [Math.round(rSum / denom), Math.round(gSum / denom), Math.round(bSum / denom)]
+        });
+      }
+    }
+    return out;
+  }
+  async encodeTile(tile, microCfg) {
+    if (!this.microEncoder) {
+      return runHoloMapMicroEncoderCpu(tile, microCfg);
+    }
+    try {
+      return await this.microEncoder.run(tile, microCfg);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (this.config.allowCpuFallback === false) {
+        throw new Error(`HoloMap WebGPU micro-encoder failed: ${message}`);
+      }
+      logHoloMapEvent(this.runId, "micro_encoder_fallback", {
+        frameIndex: tile.index,
+        reason: message
+      });
+      this.microEncoder = null;
+      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).");
+    }
+    if (!Number.isFinite(frame.timestampMs)) {
+      throw new Error(`HoloMapRuntime.step invalid frame timestamp: ${frame.timestampMs}`);
+    }
+    const expectedBytes = frame.width * frame.height * frame.stride;
+    if (frame.rgb.byteLength !== expectedBytes) {
+      throw new Error(
+        `HoloMapRuntime.step invalid frame byte length: got ${frame.rgb.byteLength}, expected ${expectedBytes} (w=${frame.width}, h=${frame.height}, stride=${frame.stride})`
+      );
+    }
+    if (frame.depth && frame.depth.length !== frame.width * frame.height) {
+      throw new Error(
+        `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})`
+      );
+    }
+    const minIntervalMs = 1e3 / Math.max(1, this.config.targetFPS);
+    if (this.lastAcceptedFrameTimestampMs !== null && frame.timestampMs - this.lastAcceptedFrameTimestampMs < minIntervalMs) {
+      this.perfMetrics.throttledCount += 1;
+      logHoloMapEvent(this.runId, "step_throttled", {
+        frameIndex: frame.index,
+        elapsedFrameMs: Math.round(frame.timestampMs - this.lastAcceptedFrameTimestampMs),
+        targetIntervalMs: Math.round(minIntervalMs)
+      });
+      return null;
+    }
+    const stepStartMs = performance.now();
+    this.lastAcceptedFrameTimestampMs = frame.timestampMs;
+    if (this.steps.length >= this.config.maxSequenceLength) {
+      const evicted = this.steps.shift();
+      const evictedPoints = evicted.points.positions.length / 3;
+      this.totalPointCount -= evictedPoints;
+      const ep = evicted.points.positions;
+      for (let i = 0; i < ep.length; i += 3) {
+        const x = ep[i];
+        const y = ep[i + 1];
+        const z = ep[i + 2];
+        this.globalPosSum[0] -= x;
+        this.globalPosSum[1] -= y;
+        this.globalPosSum[2] -= z;
+        this.globalPrincipalMomentXX -= x * x;
+        this.globalPrincipalMomentZZ -= z * z;
+        this.globalPrincipalMomentXZ -= x * z;
+      }
+      const ec = evicted.points.confidence;
+      for (let i = 0; i < ec.length; i += 1) this.globalConfSum -= ec[i];
+      this.boundsValid = false;
+      for (const s of this.steps) {
+        this.updateBounds(s.points.positions);
+      }
+      logHoloMapEvent(this.runId, "step_evict", {
+        frameIndex: evicted.frameIndex,
+        evictedPoints,
+        retainedSteps: this.steps.length
+      });
+    }
+    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);
+    const numPoints = tiles.length;
+    const positions = new Float32Array(numPoints * 3);
+    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;
+    let framePrincipalMomentXX = 0;
+    let framePrincipalMomentZZ = 0;
+    let framePrincipalMomentXZ = 0;
+    for (let t = 0; t < numPoints; t += 1) {
+      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;
+      let px = planeX + latentX * 0.08;
+      let py = planeY + latentY * 0.08;
+      let pz;
+      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,
+          frame.height,
+          centerUv
+        );
+        pz = (0.5 - measured) * _HoloMapRuntimeImpl.DEPTH_Z_SCALE;
+      } else {
+        pz = rawDepthSignal;
+      }
+      positions[t * 3] = px;
+      positions[t * 3 + 1] = py;
+      positions[t * 3 + 2] = pz;
+      colors[t * 3] = meanColor[0];
+      colors[t * 3 + 1] = meanColor[1];
+      colors[t * 3 + 2] = meanColor[2];
+      const latentMag = Math.sqrt(latentX * latentX + latentY * latentY + latentZ * latentZ);
+      const baseConfidence = Math.min(
+        1,
+        0.45 + 0.35 / (1 + latentMag) + Math.min(0.2, texture * 1.5)
+      );
+      if (frame.depthConfidence) {
+        const sensorConfidence = _HoloMapRuntimeImpl.sampleDepthNearestUv(
+          frame.depthConfidence,
+          frame.width,
+          frame.height,
+          centerUv
+        );
+        confidence[t] = baseConfidence * sensorConfidence;
+      } else {
+        confidence[t] = baseConfidence;
+      }
+      confidenceSum += confidence[t];
+      centroidX += px;
+      centroidY += py;
+      centroidZ += pz;
+      framePrincipalMomentXX += px * px;
+      framePrincipalMomentZZ += pz * pz;
+      framePrincipalMomentXZ += px * pz;
+    }
+    const inv = 1 / Math.max(1, numPoints);
+    const poseX = centroidX * inv;
+    const poseY = centroidY * inv;
+    const poseZ = centroidZ * inv;
+    const meanConfidence = confidenceSum * inv;
+    const derivedPosition = [poseX, poseY, poseZ];
+    const poseConfidence = Math.max(0, Math.min(1, meanConfidence));
+    const cameraPose = metricProjectionPose ? {
+      position: [...metricProjectionPose.position],
+      rotation: [...metricProjectionPose.rotation],
+      confidence: metricProjectionPose.confidence
+    } : {
+      position: derivedPosition,
+      rotation: _HoloMapRuntimeImpl.estimatePrincipalAxisRotation([positions], derivedPosition),
+      confidence: poseConfidence
+    };
+    const curPose = [
+      cameraPose.position[0],
+      cameraPose.position[1],
+      cameraPose.position[2]
+    ];
+    let interFrameDeltaMeters = 0;
+    let interFrameRotationRadians = 0;
+    if (this.prevCameraPose) {
+      interFrameDeltaMeters = _HoloMapRuntimeImpl.poseDistanceMeters(
+        cameraPose,
+        this.prevCameraPose
+      );
+      interFrameRotationRadians = _HoloMapRuntimeImpl.poseRotationDeltaRadians(
+        cameraPose,
+        this.prevCameraPose
+      );
+      const uncertaintyWeight = Math.max(
+        0.05,
+        1 - Math.min(cameraPose.confidence, this.prevCameraPose.confidence)
+      );
+      this.cumulativeDriftMeters += interFrameDeltaMeters * uncertaintyWeight + interFrameRotationRadians * 0.05;
+    }
+    if (this.prevPose) {
+      const velocity = [
+        curPose[0] - this.prevPose[0],
+        curPose[1] - this.prevPose[1],
+        curPose[2] - this.prevPose[2]
+      ];
+      if (this.prevVelocity) {
+        const predX = this.prevPose[0] + this.prevVelocity[0];
+        const predY = this.prevPose[1] + this.prevVelocity[1];
+        const predZ = this.prevPose[2] + this.prevVelocity[2];
+        const rx = curPose[0] - predX;
+        const ry = curPose[1] - predY;
+        const rz = curPose[2] - predZ;
+        this.cumulativeDriftMeters += Math.sqrt(rx * rx + ry * ry + rz * rz);
+      }
+      this.prevVelocity = velocity;
+    }
+    this.prevPose = curPose;
+    this.prevCameraPose = cameraPose;
+    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,
+      descriptor: loopDescriptor
+    });
+    if (this.poseHistory.length > _HoloMapRuntimeImpl.POSE_HISTORY_CAP) this.poseHistory.shift();
+    this.updateBounds(positions);
+    this.globalPosSum[0] += centroidX;
+    this.globalPosSum[1] += centroidY;
+    this.globalPosSum[2] += centroidZ;
+    this.globalConfSum += confidenceSum;
+    this.globalPrincipalMomentXX += framePrincipalMomentXX;
+    this.globalPrincipalMomentZZ += framePrincipalMomentZZ;
+    this.globalPrincipalMomentXZ += framePrincipalMomentXZ;
+    const totalPoints = this.totalPointCount + numPoints;
+    const ginv = 1 / Math.max(1, totalPoints);
+    const anchorCenter = [
+      this.globalPosSum[0] * ginv,
+      this.globalPosSum[1] * ginv,
+      this.globalPosSum[2] * ginv
+    ];
+    const globalMeanConfidence = this.globalConfSum * ginv;
+    const b = this.getBounds();
+    const extentX = b.max[0] - b.min[0];
+    const extentY = b.max[1] - b.min[1];
+    const extentZ = b.max[2] - b.min[2];
+    const anchorRotation = _HoloMapRuntimeImpl.estimatePrincipalAxisRotationFromMoments(
+      this.globalPrincipalMomentXX,
+      this.globalPrincipalMomentZZ,
+      this.globalPrincipalMomentXZ,
+      totalPoints,
+      anchorCenter
+    );
+    const anchorDescriptor = new Float32Array([extentX, extentY, extentZ, globalMeanConfidence]);
+    this.pushTrajectoryKeyframe({
+      frameIndex: frame.index,
+      timestampMs: frame.timestampMs,
+      pose: cameraPose,
+      embedding: _HoloMapRuntimeImpl.buildTrajectoryEmbedding(
+        cameraPose,
+        anchorDescriptor,
+        interFrameDeltaMeters,
+        interFrameRotationRadians
+      )
+    });
+    const trajectoryKeyframes = _HoloMapRuntimeImpl.cloneTrajectoryKeyframes(
+      this.trajectoryKeyframes,
+      _HoloMapRuntimeImpl.TRAJECTORY_STEP_SNAPSHOT_CAP
+    );
+    const step = {
+      frame,
+      pose: cameraPose,
+      points: {
+        positions,
+        colors,
+        confidence
+      },
+      ...streamingKV ? { streamingKV } : {},
+      trajectory: {
+        keyframes: trajectoryKeyframes,
+        estimatedDriftMeters: this.cumulativeDriftMeters,
+        lastLoopClosureFrame: this.lastLoopClosureFrameIdx,
+        revision: frame.index + 1
+      },
+      anchor: {
+        anchorFrameIndex: this.trajectoryKeyframes[0]?.frameIndex ?? frame.index,
+        anchorPose: {
+          position: anchorCenter,
+          rotation: anchorRotation,
+          confidence: Math.max(0, Math.min(1, globalMeanConfidence))
+        },
+        anchorDescriptor,
+        revision: frame.index + 1
+      },
+      ...depthAlignment ? { depthAlignment } : {}
+    };
+    this.steps.push({
+      frameIndex: frame.index,
+      points: {
+        positions,
+        confidence
+      }
+    });
+    this.totalPointCount += numPoints;
+    const stepMs = performance.now() - stepStartMs;
+    this.perfMetrics.stepCount += 1;
+    this.perfMetrics.totalStepMs += stepMs;
+    if (stepMs > this.perfMetrics.maxStepMs) this.perfMetrics.maxStepMs = stepMs;
+    if (stepMs < this.perfMetrics.minStepMs) this.perfMetrics.minStepMs = stepMs;
+    logHoloMapEvent(this.runId, "step", {
+      frameIndex: frame.index,
+      pointCount: numPoints,
+      stepMs: Math.round(stepMs),
+      avgStepMs: Math.round(this.perfMetrics.totalStepMs / this.perfMetrics.stepCount),
+      throttledSoFar: this.perfMetrics.throttledCount
+    });
+    return step;
+  }
+  async finalize() {
+    if (!this.initialized) {
+      throw new Error("HoloMapRuntime not initialized. Call init(config) before finalize().");
+    }
+    const frameCount = this.steps.length;
+    const pointCount = this.totalPointCount;
+    const bounds = this.getBounds();
+    const avgStepMs = this.perfMetrics.stepCount > 0 ? this.perfMetrics.totalStepMs / this.perfMetrics.stepCount : 0;
+    logHoloMapEvent(this.runId, "finalize", {
+      frameCount,
+      pointCount,
+      avgStepMs: Math.round(avgStepMs),
+      maxStepMs: Math.round(this.perfMetrics.maxStepMs),
+      minStepMs: Math.round(this.perfMetrics.minStepMs),
+      throttledCount: this.perfMetrics.throttledCount,
+      sessionDurationMs: Math.round(performance.now() - this.sessionStartMs)
+    });
+    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",
+      pointCount,
+      frameCount,
+      bounds,
+      replayHash: this.replayKey,
+      simulationContract: {
+        kind: chunkN2ILK7BF_cjs.HOLOMAP_SIMULATION_CONTRACT_KIND,
+        replayFingerprint: this.replayKey,
+        holoScriptBuild: getVersionString()
+      },
+      provenance: {
+        anchorHash: `self-attested:${this.replayKey}`,
+        capturedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      assets: {
+        points: "reconstruction.points.bin",
+        trajectory: "reconstruction.trajectory.json",
+        anchors: "reconstruction.anchors.json"
+      },
+      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;
+  }
+  async dispose() {
+    logHoloMapEvent(this.runId, "dispose", {
+      stepsRetained: this.steps.length,
+      totalPointCount: this.totalPointCount,
+      throttledCount: this.perfMetrics.throttledCount
+    });
+    this.initialized = false;
+    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;
+    this.prevCameraPose = null;
+    this.prevVelocity = null;
+    this.lastLoopClosureFrameIdx = -1;
+    this.poseHistory.length = 0;
+    this.trajectoryKeyframes.length = 0;
+    this.globalPosSum = [0, 0, 0];
+    this.globalConfSum = 0;
+    this.globalPrincipalMomentXX = 0;
+    this.globalPrincipalMomentZZ = 0;
+    this.globalPrincipalMomentXZ = 0;
+    this.boundsValid = false;
+    this.lastAcceptedFrameTimestampMs = null;
+    this.perfMetrics = {
+      stepCount: 0,
+      throttledCount: 0,
+      totalStepMs: 0,
+      maxStepMs: 0,
+      minStepMs: Infinity
+    };
+  }
+};
+_HoloMapRuntimeImpl.LOOP_CLOSURE_MIN_GAP = 3;
+_HoloMapRuntimeImpl.LOOP_CLOSURE_RADIUS = 0.05;
+_HoloMapRuntimeImpl.POSE_HISTORY_CAP = 512;
+_HoloMapRuntimeImpl.TRAJECTORY_KEYFRAME_CAP = 512;
+_HoloMapRuntimeImpl.TRAJECTORY_STEP_SNAPSHOT_CAP = 64;
+/** Maps normalized measured depth [0=near,1=far] to a point Z range matching
+ *  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).
+ * Each tile runs the full 8-kernel transformer chain via the micro encoder
+ * (imagePatchEmbed → layerNorm → gemm Q/K/V → rope → fusedMHA →
+ * layerNorm → gelu → gemm xyz). pagedKV append/lookup remains available
+ * 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) {
+  const runtime = new HoloMapRuntimeImpl();
+  if (_config) {
+    void runtime.init({ ...HOLOMAP_DEFAULTS, ..._config });
+  }
+  return runtime;
+}
+
+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-VQOTDNFL.cjs.map
+//# sourceMappingURL=chunk-VQOTDNFL.cjs.map