@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-CSD27UNQ.js

@@ -0,0 +1,2176 @@
+import { computeHoloMapReplayFingerprint } from './chunk-WNNE3PO3.js';
+import { isWebGpuEnvironmentPresent, HOLOMAP_SIMULATION_CONTRACT_KIND } from './chunk-YF2I3MV3.js';
+
+// src/version.ts
+var HOLOSCRIPT_VERSION = "8.0.1" ;
+var GIT_COMMIT_SHA = "efb467dce" ;
+var BUILD_TIMESTAMP = "2026-06-04T22:03:08.151Z" ;
+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 readback = 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, readback, 0, input.byteLength);
+      device.queue.submit([encoder.finish()]);
+      await readback.mapAsync(GPUMapMode.READ);
+      const bytes = readback.getMappedRange();
+      const out = new Float32Array(bytes.slice(0));
+      readback.unmap();
+      inputBuf.destroy();
+      gammaBuf.destroy();
+      betaBuf.destroy();
+      outputBuf.destroy();
+      paramsBuf.destroy();
+      readback.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 readback = 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, readback, 0, input.byteLength);
+      device.queue.submit([encoder.finish()]);
+      await readback.mapAsync(GPUMapMode.READ);
+      const bytes = readback.getMappedRange();
+      const out = new Float32Array(bytes.slice(0));
+      readback.unmap();
+      inputBuf.destroy();
+      outputBuf.destroy();
+      paramsBuf.destroy();
+      readback.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();
+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 || ""}`;
+}
+function getMicroWeights(config) {
+  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/HoloMapRuntime.ts
+var HOLOMAP_DEFAULTS = {
+  inputResolution: { width: 518, height: 378 },
+  targetFPS: 15,
+  maxSequenceLength: 1e4,
+  seed: 0,
+  modelHash: "unset",
+  tileGrid: 4,
+  cpuOffload: false,
+  weightStrategy: "distill",
+  allowCpuFallback: true
+};
+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;
+    // ── 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;
+    /** 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 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 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 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) {
+    return keyframes.map((keyframe) => ({
+      frameIndex: keyframe.frameIndex,
+      timestampMs: keyframe.timestampMs,
+      pose: {
+        position: [...keyframe.pose.position],
+        rotation: [...keyframe.pose.rotation],
+        confidence: keyframe.pose.confidence
+      },
+      embedding: new Float32Array(keyframe.embedding)
+    }));
+  }
+  pushTrajectoryKeyframe(keyframe) {
+    this.trajectoryKeyframes.push(keyframe);
+    if (this.trajectoryKeyframes.length > _HoloMapRuntimeImpl.TRAJECTORY_KEYFRAME_CAP) {
+      this.trajectoryKeyframes.shift();
+    }
+  }
+  async init(config) {
+    this.config = { ...config };
+    this.config.tileGrid = _HoloMapRuntimeImpl.normalizeTileGrid(this.config.tileGrid);
+    const allowCpu = this.config.allowCpuFallback !== false;
+    if (!allowCpu && !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.lastAcceptedFrameTimestampMs = null;
+    this.sessionStartMs = performance.now();
+    this.perfMetrics = { stepCount: 0, throttledCount: 0, totalStepMs: 0, maxStepMs: 0, minStepMs: Infinity };
+    this.replayKey = 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;
+    if (this.config.weightUrl) {
+      const result = await loadHoloMapWeightBlob({
+        weightUrl: this.config.weightUrl,
+        weightUrls: this.config.weightUrls,
+        weightCid: this.config.weightCid
+      });
+      this.weightBytes = result.bytes;
+    }
+    this.encoderDevice = await tryCreateHoloMapEncoderDevice();
+    this.microEncoder = this.encoderDevice ? createHoloMapMicroEncoder(this.encoderDevice) : null;
+    this.initialized = true;
+    logHoloMapEvent(this.runId, "init", {
+      modelHash: this.config.modelHash,
+      seed: this.config.seed,
+      allowCpuFallback: allowCpu,
+      webgpu: isWebGpuEnvironmentPresent(),
+      microEncoder: this.microEncoder ? "webgpu" : "cpu",
+      tileGrid: this.config.tileGrid,
+      weightLoadedBytes: this.weightBytes?.byteLength ?? 0,
+      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;
+  }
+  /**
+   * 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 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.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) {
+        this.globalPosSum[0] -= ep[i];
+        this.globalPosSum[1] -= ep[i + 1];
+        this.globalPosSum[2] -= ep[i + 2];
+      }
+      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.frame.index,
+        evictedPoints,
+        retainedSteps: this.steps.length
+      });
+    }
+    const microCfg = { seed: this.config.seed, modelHash: this.config.modelHash };
+    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);
+    let centroidX = 0;
+    let centroidY = 0;
+    let centroidZ = 0;
+    let confidenceSum = 0;
+    for (let t = 0; t < numPoints; t += 1) {
+      const { tile, meanColor, centerUv, luminance, texture } = tiles[t];
+      const xyz = await this.encodeTile(tile, microCfg);
+      const latentX = xyz[0] ?? 0;
+      const latentY = xyz[1] ?? 0;
+      const latentZ = xyz[2] ?? 0;
+      const planeX = (centerUv[0] - 0.5) * 2 * aspect;
+      const planeY = (0.5 - centerUv[1]) * 2;
+      const px = planeX + latentX * 0.08;
+      const py = planeY + latentY * 0.08;
+      let pz;
+      if (frame.depth) {
+        const measured = _HoloMapRuntimeImpl.sampleDepthNearestUv(
+          frame.depth,
+          frame.width,
+          frame.height,
+          centerUv
+        );
+        pz = (0.5 - measured) * _HoloMapRuntimeImpl.DEPTH_Z_SCALE;
+      } else {
+        const depthHint = (luminance - 0.5) * 0.34 + texture * 0.24;
+        pz = depthHint + latentZ * 0.12;
+      }
+      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;
+    }
+    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 = frame.devicePose ? {
+      position: [...frame.devicePose.position],
+      rotation: [...frame.devicePose.rotation],
+      confidence: frame.devicePose.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;
+    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 });
+    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;
+    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.estimatePrincipalAxisRotation(
+      [...this.steps.map((s) => s.points.positions), positions],
+      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);
+    const step = {
+      frame,
+      pose: cameraPose,
+      points: {
+        positions,
+        colors,
+        confidence
+      },
+      trajectory: {
+        keyframes: trajectoryKeyframes,
+        estimatedDriftMeters: this.cumulativeDriftMeters,
+        lastLoopClosureFrame: this.lastLoopClosureFrameIdx,
+        revision: frame.index + 1
+      },
+      anchor: {
+        anchorFrameIndex: trajectoryKeyframes[0]?.frameIndex ?? frame.index,
+        anchorPose: {
+          position: anchorCenter,
+          rotation: anchorRotation,
+          confidence: Math.max(0, Math.min(1, globalMeanConfidence))
+        },
+        anchorDescriptor,
+        revision: frame.index + 1
+      }
+    };
+    this.steps.push(step);
+    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)
+    });
+    return {
+      version: "1.0.0",
+      worldId: `holomap-${this.replayKey}`,
+      displayName: "HoloMap Reconstruction",
+      pointCount,
+      frameCount,
+      bounds,
+      replayHash: this.replayKey,
+      simulationContract: {
+        kind: 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"
+    };
+  }
+  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;
+    this.weightBytes = 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.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;
+/** 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;
+/**
+ * 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.MAX_GRID_N = 32;
+var HoloMapRuntimeImpl = _HoloMapRuntimeImpl;
+function createHoloMapRuntime(_config) {
+  const runtime = new HoloMapRuntimeImpl();
+  if (_config) {
+    void runtime.init({ ...HOLOMAP_DEFAULTS, ..._config });
+  }
+  return runtime;
+}
+
+export { BUILD_TIMESTAMP, GIT_COMMIT_SHA, HOLOMAP_DEFAULTS, HOLOSCRIPT_VERSION, assertWeightCid, createHoloMapMicroEncoder, createHoloMapRunId, createHoloMapRuntime, frameToMicroImage, getCachedWeightBlob, getVersionInfo, getVersionString, loadHoloMapWeightBlob, logHoloMapEvent, normalizeWeightCidDigest, putCachedWeightBlob, resetHoloMapTelemetryForTests, runHoloMapMicroEncoderCpu, tryCreateHoloMapEncoderDevice };
+//# sourceMappingURL=chunk-CSD27UNQ.js.map
+//# sourceMappingURL=chunk-CSD27UNQ.js.map