@holoscript/core 8.0.12 → 8.0.13

package/dist/{chunk-VO52AJD5.js → chunk-RVNXBF2M.js}

@@ -725,7 +725,7 @@ var ImportResolver = class {
           throw new Error(`File not found: '${canonicalPath}' (imported from '${importedBy}')`);
         }
       }
-      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-55AY4MUF.js');
+      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-HQV6IJAH.js');
       const parser = new HoloScriptPlusParser({ enableTypeScriptImports: true });
       const result = parser.parse(source);
       if (!result.success && result.errors.length > 0) {
@@ -2003,5 +2003,5 @@ var UnauthorizedIncrementalCompilerAccessError = class extends UnauthorizedCompi
 };
 
 export { IncrementalCompiler, TraitDependencyGraph, UnauthorizedIncrementalCompilerAccessError, createIncrementalCompiler, deserializeCache, globalTraitGraph, serializeCache };
-//# sourceMappingURL=chunk-VO52AJD5.js.map
-//# sourceMappingURL=chunk-VO52AJD5.js.map
+//# sourceMappingURL=chunk-RVNXBF2M.js.map
+//# sourceMappingURL=chunk-RVNXBF2M.js.map

package/dist/{chunk-7N63JHUN.cjs → chunk-RZ2EPXO3.cjs}

@@ -727,7 +727,7 @@ var ImportResolver = class {
           throw new Error(`File not found: '${canonicalPath}' (imported from '${importedBy}')`);
         }
       }
-      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-RNUCHOAJ.cjs');
+      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-RFNHRMPE.cjs');
       const parser = new HoloScriptPlusParser({ enableTypeScriptImports: true });
       const result = parser.parse(source);
       if (!result.success && result.errors.length > 0) {
@@ -2011,5 +2011,5 @@ exports.createIncrementalCompiler = createIncrementalCompiler;
 exports.deserializeCache = deserializeCache;
 exports.globalTraitGraph = globalTraitGraph;
 exports.serializeCache = serializeCache;
-//# sourceMappingURL=chunk-7N63JHUN.cjs.map
-//# sourceMappingURL=chunk-7N63JHUN.cjs.map
+//# sourceMappingURL=chunk-RZ2EPXO3.cjs.map
+//# sourceMappingURL=chunk-RZ2EPXO3.cjs.map

package/dist/{chunk-5H5GFBMG.cjs → chunk-SQAAWO4V.cjs}

@@ -5,8 +5,8 @@ var chunkN2ILK7BF_cjs = require('./chunk-N2ILK7BF.cjs');
 
 // src/version.ts
 var HOLOSCRIPT_VERSION = "8.0.12" ;
-var GIT_COMMIT_SHA = "530989456" ;
-var BUILD_TIMESTAMP = "2026-07-05T23:05:02.393Z" ;
+var GIT_COMMIT_SHA = "65d9a9d46" ;
+var BUILD_TIMESTAMP = "2026-07-07T08:36:54.702Z" ;
 function getVersionString() {
   const sha = `+${GIT_COMMIT_SHA}` ;
   return `${HOLOSCRIPT_VERSION}${sha}`;
@@ -1813,9 +1813,12 @@ function createPagedKVCache(config) {
   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.");
   }
@@ -1850,9 +1853,7 @@ function createPagedKVCache(config) {
     valuePages.fill(0, offset, end);
   }
   function residentPages() {
-    return layers.flatMap(
-      (layer) => Array.from(layer.pages.values()).filter((page) => page.residency === "device")
-    );
+    return Array.from(residentPageStates);
   }
   function evictPage(page) {
     if (page.physicalPage === null) return pageSnapshot(page);
@@ -1865,6 +1866,9 @@ function createPagedKVCache(config) {
     page.hostKeys = hostKeys;
     page.hostValues = hostValues;
     page.residency = "host";
+    residentPageStates.delete(page);
+    devicePageCount -= 1;
+    hostPageCount += 1;
     return pageSnapshot(page);
   }
   function evictOldestInternal(count, protectedPage) {
@@ -1890,7 +1894,10 @@ function createPagedKVCache(config) {
     }
     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));
@@ -1920,6 +1927,8 @@ function createPagedKVCache(config) {
       lastAccess: ++accessClock
     };
     layerState.pages.set(logicalPage, page);
+    residentPageStates.add(page);
+    devicePageCount += 1;
     return page;
   }
   function buildPageTable(layer, logicalPages) {
@@ -1937,27 +1946,32 @@ function createPagedKVCache(config) {
     }
     return pageTable;
   }
-  function appendCpu(pages, pageTable, slotMap, vectors) {
-    const out = new Float32Array(pages);
+  function appendCpuInPlace(pages, touchedPages, vectors, startToken) {
     const numVecs = vectors.length / config.hiddenDim;
     for (let v = 0; v < numVecs; v += 1) {
-      const logicalPage = slotMap[v] >>> 16;
-      const inPage = slotMap[v] & 65535;
-      const physicalPage = pageTable[logicalPage];
+      const 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) {
-        out[base + inPage * config.hiddenDim + d] = vectors[v * config.hiddenDim + d];
+        pages[base + inPage * config.hiddenDim + d] = vectors[v * config.hiddenDim + d];
       }
     }
-    return out;
   }
-  function lookupCpu(pages, pageTable, tokenCount, startToken) {
+  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 = pageTable[logicalPage];
+      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];
@@ -1979,7 +1993,7 @@ function createPagedKVCache(config) {
     residentPagesForLayer(layer) {
       assertLive();
       validateLayer(layer);
-      return Array.from(layers[layer].pages.values()).filter((page) => page.residency === "device").sort((a, b) => a.firstToken - b.firstToken).map((page) => pageSnapshot(page));
+      return Array.from(residentPageStates).filter((page) => page.layer === layer).sort((a, b) => a.firstToken - b.firstToken).map((page) => pageSnapshot(page));
     },
     evictOldest(count) {
       assertLive();
@@ -1990,23 +2004,18 @@ function createPagedKVCache(config) {
     },
     memoryUsage() {
       assertLive();
-      let devicePages = 0;
-      let hostPages = 0;
-      for (const layer of layers) {
-        for (const page of layer.pages.values()) {
-          if (page.residency === "device") devicePages += 1;
-          if (page.residency === "host") hostPages += 1;
-        }
-      }
       return {
-        device: devicePages * pageBytes * 2,
-        host: hostPages * pageBytes * 2
+        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();
@@ -2026,14 +2035,11 @@ function createPagedKVCache(config) {
         throw new Error(`PagedKVCache append firstToken must be non-negative, got ${startToken}`);
       }
       const touchedPages = /* @__PURE__ */ new Map();
-      const slotMap = new Uint32Array(tokenCount);
       const requiredPages = /* @__PURE__ */ new Set();
       for (let i = 0; i < tokenCount; i += 1) {
         const token = startToken + i;
         const logicalPage = Math.floor(token / config.pageSize);
-        const slot = token % config.pageSize;
         requiredPages.add(logicalPage);
-        slotMap[i] = logicalPage << 16 | slot;
       }
       if (requiredPages.size > config.maxResidentPages) {
         throw new Error(
@@ -2044,8 +2050,15 @@ function createPagedKVCache(config) {
         const page = allocatePageInternal(layer, logicalPage);
         touchedPages.set(logicalPage, page);
       }
-      const pageTable = buildPageTable(layer, touchedPages.keys());
       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,
@@ -2067,8 +2080,8 @@ function createPagedKVCache(config) {
           )
         );
       } else {
-        keyPages.set(appendCpu(keyPages, pageTable, slotMap, keyVectors));
-        valuePages.set(appendCpu(valuePages, pageTable, slotMap, valueVectors));
+        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);
@@ -2105,8 +2118,8 @@ function createPagedKVCache(config) {
       for (const logicalPage of requiredPages) {
         ensurePageResident(layers[layer].pages.get(logicalPage));
       }
-      const pageTable = buildPageTable(layer, requiredPages);
       if (lookupKernel) {
+        const pageTable = buildPageTable(layer, requiredPages);
         return {
           keys: await lookupKernel.run(
             keyPages,
@@ -2127,8 +2140,8 @@ function createPagedKVCache(config) {
         };
       }
       return {
-        keys: lookupCpu(keyPages, pageTable, tokenCount, startToken),
-        values: lookupCpu(valuePages, pageTable, tokenCount, startToken)
+        keys: lookupCpuDirect(keyPages, layers[layer], tokenCount, startToken),
+        values: lookupCpuDirect(valuePages, layers[layer], tokenCount, startToken)
       };
     }
   };
@@ -2206,6 +2219,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
      */
     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. */
@@ -2457,6 +2473,15 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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)];
@@ -2492,17 +2517,23 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       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)
-    }));
+  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);
@@ -2545,6 +2576,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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 = {
@@ -2813,9 +2847,15 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       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 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];
@@ -2900,6 +2940,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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;
@@ -2958,6 +3001,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       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;
@@ -3039,6 +3085,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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 = [
@@ -3051,8 +3100,11 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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(
-      _HoloMapRuntimeImpl.retainedPositionChunks(this.steps, positions),
+    const anchorRotation = _HoloMapRuntimeImpl.estimatePrincipalAxisRotationFromMoments(
+      this.globalPrincipalMomentXX,
+      this.globalPrincipalMomentZZ,
+      this.globalPrincipalMomentXZ,
+      totalPoints,
       anchorCenter
     );
     const anchorDescriptor = new Float32Array([extentX, extentY, extentZ, globalMeanConfidence]);
@@ -3068,7 +3120,8 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
       )
     });
     const trajectoryKeyframes = _HoloMapRuntimeImpl.cloneTrajectoryKeyframes(
-      this.trajectoryKeyframes
+      this.trajectoryKeyframes,
+      _HoloMapRuntimeImpl.TRAJECTORY_STEP_SNAPSHOT_CAP
     );
     const step = {
       frame,
@@ -3086,7 +3139,7 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
         revision: frame.index + 1
       },
       anchor: {
-        anchorFrameIndex: trajectoryKeyframes[0]?.frameIndex ?? frame.index,
+        anchorFrameIndex: this.trajectoryKeyframes[0]?.frameIndex ?? frame.index,
         anchorPose: {
           position: anchorCenter,
           rotation: anchorRotation,
@@ -3208,6 +3261,9 @@ var _HoloMapRuntimeImpl = class _HoloMapRuntimeImpl {
     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 = {
@@ -3223,6 +3279,7 @@ _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. */
@@ -3276,5 +3333,5 @@ exports.selfAttestReconstructionManifest = selfAttestReconstructionManifest;
 exports.serializeMicroWeights = serializeMicroWeights;
 exports.stripAnchoredProvenance = stripAnchoredProvenance;
 exports.tryCreateHoloMapEncoderDevice = tryCreateHoloMapEncoderDevice;
-//# sourceMappingURL=chunk-5H5GFBMG.cjs.map
-//# sourceMappingURL=chunk-5H5GFBMG.cjs.map
+//# sourceMappingURL=chunk-SQAAWO4V.cjs.map
+//# sourceMappingURL=chunk-SQAAWO4V.cjs.map

package/dist/{chunk-W2GA3EQB.cjs → chunk-TC7JEO6R.cjs}

@@ -56,8 +56,10 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
         this.emitDeviceInit();
         this.emitGeometryHelpers();
         this.emitShaderSources();
-        if (composition.environment) this.emitEnvironment(composition.environment);
+        this.emitEnvironment(composition.environment ?? { type: "Environment", properties: [] });
         this.emitCamera(composition.camera);
+        this.emit("const holoGraphObjects = [];");
+        this.emit("");
         if (composition.objects) {
           for (const obj of composition.objects) this.emitObject(obj);
         }
@@ -69,6 +71,7 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
         }
         if (this.options.enableCompute) this.emitComputeShaders(composition);
         this.emitWebGPUDomainBlocks(composition);
+        this.emitViewportRuntime();
         this.emitRenderLoop(composition);
         return this.lines.join("\n");
       }
@@ -497,6 +500,9 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
         this.emit(
           `const ${v}Mat = createBuffer(device, new Float32Array([${cr},${cg},${cb},1.0, ${rough},${metal},${emissiveStrength},0, ${er},${eg},${eb},0]), GPUBufferUsage.UNIFORM);`
         );
+        this.emit(
+          `holoGraphObjects.push({ id: "${this.escapeStringValue(obj.name, "TypeScript")}", name: "${this.escapeStringValue(obj.name, "TypeScript")}", geometry: "${this.escapeStringValue(meshType, "TypeScript")}", traits: ${this.json((obj.traits || []).map((t) => t.name))}, properties: ${this.json(this.extractObjectProperties(obj))}, basePosition: [${px},${py},${pz}], position: [${px},${py},${pz}], baseScale: [${sx},${sy},${sz}], scale: [${sx},${sy},${sz}], baseColor: [${cr},${cg},${cb}], color: [${cr},${cg},${cb}], material: { roughness: ${rough}, metalness: ${metal}, emissiveStrength: ${emissiveStrength}, emissive: [${er},${eg},${eb}] }, modelBuffer: ${v}Model, matBuffer: ${v}Mat, visible: true });`
+        );
         this.emit(`const ${v}Pipeline = device.createRenderPipeline({`);
         this.indent();
         this.emit('layout: "auto",');
@@ -857,6 +863,145 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
         this.emit("");
       }
       // ─── Render Loop ──────────────────────────────────────────────────────────
+      emitViewportRuntime() {
+        this.emit("// === HoloGraph Viewport Runtime ===");
+        this.emit("const holoGraphInitialCameraPos = new Float32Array(cameraPos);");
+        this.emit("const holoGraphInitialCameraTarget = new Float32Array(cameraTarget);");
+        this.emit(
+          'const holoGraphViewportState = { actionCount: 0, lastAction: null, filter: "all", colorMode: "semantic", structureStyle: "flow", labelPolicy: "none", focusId: null };'
+        );
+        this.emit('document.body.style.position = document.body.style.position || "relative";');
+        this.emit('const holoGraphLabelLayer = document.createElement("div");');
+        this.emit('holoGraphLabelLayer.setAttribute("data-holograph-label-layer", "true");');
+        this.emit('Object.assign(holoGraphLabelLayer.style, { position: "absolute", inset: "0", pointerEvents: "none", overflow: "hidden", fontFamily: "ui-monospace, SFMono-Regular, Consolas, monospace", zIndex: "5" });');
+        this.emit('canvas.insertAdjacentElement("afterend", holoGraphLabelLayer);');
+        this.emit("function hsVec3(v) { return [Number(v[0] || 0), Number(v[1] || 0), Number(v[2] || 0)]; }");
+        this.emit("function hsSub(a, b) { return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; }");
+        this.emit("function hsAdd(a, b) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }");
+        this.emit("function hsMul(v, s) { return [v[0] * s, v[1] * s, v[2] * s]; }");
+        this.emit("function hsLen(v) { return Math.hypot(v[0], v[1], v[2]) || 1; }");
+        this.emit("function hsNorm(v) { const l = hsLen(v); return [v[0] / l, v[1] / l, v[2] / l]; }");
+        this.emit(
+          "function hsCross(a, b) { return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; }"
+        );
+        this.emit(
+          'function hsHash(text) { let h = 2166136261; const s = String(text || ""); for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return h >>> 0; }'
+        );
+        this.emit(
+          "function hsHueRgb(h) { const x = (n) => { const k = (n + h * 6) % 6; return Math.max(0, Math.min(1, Math.min(k, 4 - k, 1))); }; return [x(5), x(3), x(1)]; }"
+        );
+        this.emit(
+          "function hsGraphCenter() { if (!holoGraphObjects.length) return [0, 0, 0]; const sum = holoGraphObjects.reduce((acc, o) => [acc[0] + o.basePosition[0], acc[1] + o.basePosition[1], acc[2] + o.basePosition[2]], [0, 0, 0]); return hsMul(sum, 1 / holoGraphObjects.length); }"
+        );
+        this.emit(
+          "function hsWriteModel(o) { const s = o.visible ? o.scale : [0, 0, 0]; device.queue.writeBuffer(o.modelBuffer, 0, new Float32Array([s[0],0,0,0, 0,s[1],0,0, 0,0,s[2],0, o.position[0],o.position[1],o.position[2],1])); }"
+        );
+        this.emit(
+          "function hsWriteMaterial(o, color) { o.color = [color[0], color[1], color[2]]; const m = o.material; device.queue.writeBuffer(o.matBuffer, 0, new Float32Array([color[0],color[1],color[2],1.0, m.roughness,m.metalness,m.emissiveStrength,0, m.emissive[0],m.emissive[1],m.emissive[2],0])); }"
+        );
+        this.emit("function hsCameraDistance() { return hsLen(hsSub(hsVec3(cameraTarget), hsVec3(cameraPos))); }");
+        this.emit(
+          "function hsSetCamera(pos, target) { cameraPos.set(pos); cameraTarget.set(target); device.queue.writeBuffer(vpUniform, 0, buildViewProjection()); document.body.dataset.holoscriptWebgpuCamera = JSON.stringify({ position: Array.from(cameraPos), target: Array.from(cameraTarget) }); }"
+        );
+        this.emit(
+          "function hsCameraBasis() { const forward = hsNorm(hsSub(hsVec3(cameraTarget), hsVec3(cameraPos))); const worldUp = [0, 1, 0]; const right = hsNorm(hsCross(forward, worldUp)); const up = hsNorm(hsCross(right, forward)); return { forward, right, up }; }"
+        );
+        this.emit(
+          'function hsMatchesFilter(o, filter) { const rawKind = o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || o.properties.type || ""; const symbolType = String(rawKind).toLowerCase(); const traits = (o.traits || []).map((t) => String(t).toLowerCase()); if (filter === "all") return true; if (filter === "call") return symbolType === "function" || symbolType === "method" || symbolType === "call" || traits.includes("function") || traits.includes("method") || traits.includes("call"); if (filter === "import") return symbolType === "module" || symbolType === "namespace" || symbolType === "package" || symbolType === "import" || traits.includes("module") || traits.includes("namespace") || traits.includes("package") || traits.includes("import"); return true; }'
+        );
+        this.emit(
+          'function hsColorForMode(o, mode) { if (mode === "identity_hue") return hsHueRgb((hsHash(o.id) % 10000) / 10000); if (mode === "file_hue") return hsHueRgb((hsHash(o.properties.file || o.properties.path || o.id) % 10000) / 10000); if (mode === "relation_hue") return hsHueRgb((hsHash(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || (o.traits || []).join(",")) % 10000) / 10000); return o.baseColor; }'
+        );
+        this.emit("function hsRound(n) { return Math.round(Number(n || 0) * 1000) / 1000; }");
+        this.emit("function hsRoundVec(v) { return [hsRound(v?.[0]), hsRound(v?.[1]), hsRound(v?.[2])]; }");
+        this.emit(
+          'function hsHueBucket(o, mode = holoGraphViewportState.colorMode) { if (mode === "identity_hue") return hsHash(o.id) % 10000; if (mode === "file_hue") return hsHash(o.properties.file || o.properties.path || o.id) % 10000; if (mode === "relation_hue") return hsHash(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || (o.traits || []).join(",")) % 10000; return hsHash(JSON.stringify(o.color || o.baseColor || [])) % 10000; }'
+        );
+        this.emit(
+          'function hsObjectRole(o) { return String(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || o.properties.type || (o.traits || [])[0] || "object"); }'
+        );
+        this.emit(
+          'function hsCounts(items, keyFn, limit = 12) { const m = new Map(); for (const item of items) { const key = String(keyFn(item) || "unknown"); m.set(key, (m.get(key) || 0) + 1); } return Array.from(m.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([key, count]) => ({ key, count })); }'
+        );
+        this.emit(
+          'function hsCompactObject(o, index) { return { index, id: o.id, name: o.name, geometry: o.geometry || "mesh", shape: o.geometry || "mesh", role: hsObjectRole(o), traits: o.traits || [], file: o.properties.file || null, path: o.properties.path || null, signature: o.properties.signature || null, language: o.properties.language || null, position: hsRoundVec(o.position), scale: hsRoundVec(o.scale), color: hsRoundVec(o.color || o.baseColor), hueBucket: hsHueBucket(o), visible: o.visible, projection: hsProjectPoint(o.position) }; }'
+        );
+        this.emit(
+          'function hsResolveObject(payload = {}) { const key = payload && (payload.nodeId ?? payload.id ?? payload.target ?? payload.anchorId ?? payload.name); let obj = null; if (typeof payload?.anchorIndex === "number") obj = holoGraphObjects[payload.anchorIndex] || null; if (!obj && typeof key === "number") obj = holoGraphObjects[key] || null; if (!obj && key !== undefined && key !== null) obj = holoGraphObjects.find((o) => o.id === String(key) || o.name === String(key)); if (!obj) obj = holoGraphObjects.find((o) => o.visible) || holoGraphObjects[0] || null; return obj; }'
+        );
+        this.emit(
+          "function hsNearestObjects(obj, limit = 8) { if (!obj) return []; return holoGraphObjects.filter((o) => o.visible && o !== obj).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, obj.position)) })).sort((a, b) => a.distance - b.distance).slice(0, Math.max(0, Math.min(32, Number(limit) || 8))).map((entry) => ({ ...hsCompactObject(entry.object, holoGraphObjects.indexOf(entry.object)), distance: hsRound(entry.distance) })); }"
+        );
+        this.emit(
+          'function hsDescribeScene(payload = {}) { const limit = Math.max(1, Math.min(128, Number(payload.limit || 24))); const visible = holoGraphObjects.filter((o) => o.visible); return { canonicalNames: { graphSurface: "HoloGraph", embeddingTower: "HoloEmbed", visionNavigator: "HoloLlama" }, actionContract: ["pan_left","pan_right","pan_up","pan_down","zoom_in","zoom_out","zoom_to_fit","focus_anchor","focus_node","filter_call","filter_import","filter_all","set_color_mode","set_structure_style","set_label_policy","reset_view"], projectionBridge: "renderer-native", canvas: { width: canvas.width, height: canvas.height, clientWidth: canvas.clientWidth, clientHeight: canvas.clientHeight }, camera: { position: hsRoundVec(cameraPos), target: hsRoundVec(cameraTarget), distance: hsRound(hsCameraDistance()) }, actionCount: holoGraphViewportState.actionCount, lastAction: holoGraphViewportState.lastAction, filter: holoGraphViewportState.filter, colorMode: holoGraphViewportState.colorMode, structureStyle: holoGraphViewportState.structureStyle, labelPolicy: holoGraphViewportState.labelPolicy, objectCount: holoGraphObjects.length, visibleObjects: visible.length, shapes: hsCounts(visible, (o) => o.geometry || "mesh"), roles: hsCounts(visible, hsObjectRole), hueBuckets: hsCounts(visible, (o) => `hue_${hsHueBucket(o)}`, 16), files: hsCounts(visible, (o) => o.properties.file || o.properties.path || "unknown", 16), objects: visible.slice(0, limit).map((o) => hsCompactObject(o, holoGraphObjects.indexOf(o))) }; }'
+        );
+        this.emit(
+          "function hsProjectObject(payload = {}) { const obj = hsResolveObject(payload); if (!obj) return null; return { ...hsCompactObject(obj, holoGraphObjects.indexOf(obj)), cameraDistance: hsRound(hsLen(hsSub(hsVec3(cameraPos), obj.position))) }; }"
+        );
+        this.emit(
+          "function hsInspectObject(payload = {}) { const obj = hsResolveObject(payload); if (!obj) return null; return { ...hsProjectObject(payload), properties: obj.properties, neighbors: hsNearestObjects(obj, payload.limit || 8) }; }"
+        );
+        this.emit('function hsNormalizeLabelPolicy(value) { const policy = String(value || "none").toLowerCase(); return ["none","ids","signatures","details"].includes(policy) ? policy : "none"; }');
+        this.emit(
+          'function hsLabelText(o) { const policy = holoGraphViewportState.labelPolicy; if (policy === "none") return ""; if (policy === "ids") return o.id; if (policy === "signatures") return o.properties.signature || o.id; return `${hsObjectRole(o)}:${o.properties.signature || o.id}`; }'
+        );
+        this.emit(
+          'function hsProjectPoint(p) { const m = buildViewProjection(); const x = Number(p?.[0] || 0), y = Number(p?.[1] || 0), z = Number(p?.[2] || 0); const cx = m[0]*x + m[4]*y + m[8]*z + m[12]; const cy = m[1]*x + m[5]*y + m[9]*z + m[13]; const cz = m[2]*x + m[6]*y + m[10]*z + m[14]; const cw = m[3]*x + m[7]*y + m[11]*z + m[15]; const clip = { x: hsRound(cx), y: hsRound(cy), z: hsRound(cz), w: hsRound(cw) }; if (!Number.isFinite(cw) || Math.abs(cw) < 0.00001) return { source: "renderer-native", valid: false, reason: "invalid-w", inFrame: false, clip }; const ndcX = cx / cw, ndcY = cy / cw, ndcZ = cz / cw; const normalizedX = ndcX * 0.5 + 0.5; const normalizedY = 0.5 - ndcY * 0.5; const width = canvas.clientWidth || canvas.width || 1; const height = canvas.clientHeight || canvas.height || 1; const screenX = normalizedX * width; const screenY = normalizedY * height; const centerDistance = Math.hypot(normalizedX - 0.5, normalizedY - 0.5); return { source: "renderer-native", valid: Number.isFinite(normalizedX) && Number.isFinite(normalizedY), inFrame: ndcX >= -1 && ndcX <= 1 && ndcY >= -1 && ndcY <= 1, ndc: { x: hsRound(ndcX), y: hsRound(ndcY), z: hsRound(ndcZ) }, normalizedX: hsRound(normalizedX), normalizedY: hsRound(normalizedY), screenX: hsRound(screenX), screenY: hsRound(screenY), centerDistance: hsRound(centerDistance), clip }; }'
+        );
+        this.emit(
+          'function hsRenderLabels() { const policy = holoGraphViewportState.labelPolicy; document.body.dataset.holoscriptWebgpuLabels = policy; if (policy === "none") { holoGraphLabelLayer.replaceChildren(); return; } const ranked = holoGraphObjects.filter((o) => o.visible).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, hsVec3(cameraTarget))) })).sort((a, b) => a.distance - b.distance).slice(0, 18); const nodes = []; for (const entry of ranked) { const o = entry.object; const text = hsLabelText(o); const point = hsProjectPoint(o.position); if (!text || !point?.valid || !point.inFrame) continue; const focus = entry.distance <= 0.001 || o.id === holoGraphViewportState.focusId; const el = document.createElement("div"); el.textContent = text.length > 72 ? `${text.slice(0, 69)}...` : text; Object.assign(el.style, { position: "absolute", left: `${point.screenX}px`, top: `${point.screenY}px`, transform: "translate(-50%, -120%)", maxWidth: "280px", padding: focus ? "4px 7px" : "3px 6px", border: focus ? "2px solid rgba(250,204,21,0.98)" : "1px solid rgba(255,255,255,0.68)", borderRadius: "3px", background: focus ? "rgba(15,23,42,0.94)" : "rgba(2,6,23,0.86)", color: focus ? "#fef9c3" : "#f8fafc", fontSize: focus ? "13px" : "12px", fontWeight: focus ? "700" : "600", lineHeight: "1.2", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", textShadow: "0 1px 2px #000" }); nodes.push(el); } const focusObj = holoGraphViewportState.focusId ? holoGraphObjects.find((o) => o.id === holoGraphViewportState.focusId && o.visible) : null; if (focusObj) { const panel = document.createElement("div"); Object.assign(panel.style, { position: "absolute", left: "12px", top: "12px", maxWidth: "560px", padding: "8px 10px", border: "2px solid rgba(250,204,21,0.98)", borderRadius: "4px", background: "rgba(15,23,42,0.96)", color: "#fef9c3", fontSize: "13px", fontWeight: "700", lineHeight: "1.35", textShadow: "0 1px 2px #000", boxShadow: "0 10px 30px rgba(0,0,0,0.34)" }); const near = holoGraphObjects.filter((o) => o.visible && o !== focusObj).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, focusObj.position)) })).sort((a, b) => a.distance - b.distance).slice(0, 5); const rows = [{ kind: "target", object: focusObj }, ...near.map((entry) => ({ kind: "near", object: entry.object }))]; for (const row of rows) { const line = document.createElement("div"); const text = `${row.kind} ${hsLabelText(row.object)}`; line.textContent = text.length > 96 ? `${text.slice(0, 93)}...` : text; panel.appendChild(line); } nodes.push(panel); } holoGraphLabelLayer.replaceChildren(...nodes); }'
+        );
+        this.emit("function hsApplyLabelPolicy(policy) { holoGraphViewportState.labelPolicy = hsNormalizeLabelPolicy(policy); hsRenderLabels(); }");
+        this.emit("function hsApplyFilter(filter) { holoGraphViewportState.filter = filter; for (const o of holoGraphObjects) { o.visible = hsMatchesFilter(o, filter); hsWriteModel(o); } }");
+        this.emit("function hsApplyColorMode(mode) { holoGraphViewportState.colorMode = mode; for (const o of holoGraphObjects) hsWriteMaterial(o, hsColorForMode(o, mode)); }");
+        this.emit(
+          'function hsApplyStructureStyle(style) { const center = hsGraphCenter(); const n = Math.max(1, holoGraphObjects.length); const radius = Math.max(20, Math.sqrt(n) * 18); holoGraphViewportState.structureStyle = style; holoGraphObjects.forEach((o, i) => { if (style === "compact") { o.position = hsAdd(center, hsMul(hsSub(o.basePosition, center), 0.45)); } else if (style === "radial") { const a = (i / n) * Math.PI * 2; o.position = [center[0] + Math.cos(a) * radius, center[1] + (o.basePosition[1] - center[1]) * 0.18, center[2] + Math.sin(a) * radius]; } else { o.position = [...o.basePosition]; } hsWriteModel(o); }); }'
+        );
+        this.emit(
+          "function hsFocusObject(payload) { const obj = hsResolveObject(payload); if (!obj) return false; holoGraphViewportState.focusId = obj.id; const target = [...obj.position]; const away = hsNorm(hsSub(hsVec3(cameraPos), hsVec3(cameraTarget))); const distance = Math.max(8, hsCameraDistance() * 0.45); hsSetCamera(hsAdd(target, hsMul(away, distance)), target); return true; }"
+        );
+        this.emit(
+          'function hsViewportSnapshot() { const scene = hsDescribeScene({ limit: 8 }); return { camera: { position: Array.from(cameraPos), target: Array.from(cameraTarget), distance: hsCameraDistance() }, projectionBridge: "renderer-native", canvas: scene.canvas, actionCount: holoGraphViewportState.actionCount, lastAction: holoGraphViewportState.lastAction, filter: holoGraphViewportState.filter, colorMode: holoGraphViewportState.colorMode, structureStyle: holoGraphViewportState.structureStyle, labelPolicy: holoGraphViewportState.labelPolicy, focusId: holoGraphViewportState.focusId, objectCount: scene.objectCount, visibleObjects: scene.visibleObjects, sceneSummary: { shapes: scene.shapes, roles: scene.roles, hueBuckets: scene.hueBuckets, files: scene.files }, sampleObjects: scene.objects }; }'
+        );
+        this.emit("function hsApplyViewportAction(action, payload = {}) {");
+        this.indent();
+        this.emit('const type = typeof action === "string" ? action : String(action?.type || action?.action || "");');
+        this.emit('const data = typeof action === "object" && action !== null ? { ...action, ...payload } : payload || {};');
+        this.emit("const before = hsViewportSnapshot();");
+        this.emit("const basis = hsCameraBasis();");
+        this.emit("const distance = hsCameraDistance();");
+        this.emit("const pan = Math.max(1, distance * 0.08);");
+        this.emit("let ok = true;");
+        this.emit('if (type === "pan_left") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.right, -pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.right, -pan)));');
+        this.emit('else if (type === "pan_right") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.right, pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.right, pan)));');
+        this.emit('else if (type === "pan_up") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.up, pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.up, pan)));');
+        this.emit('else if (type === "pan_down") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.up, -pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.up, -pan)));');
+        this.emit('else if (type === "zoom_in") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.forward, distance * 0.22)), hsVec3(cameraTarget));');
+        this.emit('else if (type === "zoom_out") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.forward, -distance * 0.25)), hsVec3(cameraTarget));');
+        this.emit('else if (type === "zoom_to_fit" || type === "reset_view") { holoGraphViewportState.focusId = null; hsSetCamera(Array.from(holoGraphInitialCameraPos), Array.from(holoGraphInitialCameraTarget)); }');
+        this.emit('else if (type === "focus_anchor" || type === "focus_node") ok = hsFocusObject(data);');
+        this.emit('else if (type === "filter_call") hsApplyFilter("call");');
+        this.emit('else if (type === "filter_import") hsApplyFilter("import");');
+        this.emit('else if (type === "filter_all") hsApplyFilter("all");');
+        this.emit('else if (type === "set_color_mode") hsApplyColorMode(String(data.mode || data.colorMode || "semantic"));');
+        this.emit('else if (type === "set_structure_style") hsApplyStructureStyle(String(data.style || data.structureStyle || "flow"));');
+        this.emit('else if (type === "set_label_policy") hsApplyLabelPolicy(data.policy || data.labelPolicy || "none");');
+        this.emit("else ok = false;");
+        this.emit("if (!ok) return { ok: false, action: type, before, after: hsViewportSnapshot() };");
+        this.emit("holoGraphViewportState.actionCount++;");
+        this.emit("holoGraphViewportState.lastAction = type;");
+        this.emit("document.body.dataset.holoscriptWebgpuLastAction = type;");
+        this.emit("return { ok: true, action: type, before, after: hsViewportSnapshot() };");
+        this.dedent();
+        this.emit("}");
+        this.emit("globalThis.holoscriptWebgpuViewport = { applyAction: hsApplyViewportAction, getState: hsViewportSnapshot, describeScene: hsDescribeScene, inspectObject: hsInspectObject, projectObject: hsProjectObject, projectPoint: hsProjectPoint };");
+        this.emit("globalThis.HoloGraphViewport = globalThis.holoscriptWebgpuViewport;");
+        this.emit('document.body.dataset.holoscriptWebgpuViewport = "ready";');
+        this.emit('document.body.dataset.holoscriptWebgpuInspector = "ready";');
+        this.emit('document.body.dataset.holoscriptWebgpuLabels = "none";');
+        this.emit("hsSetCamera(Array.from(cameraPos), Array.from(cameraTarget));");
+        this.emit("");
+      }
       emitRenderLoop(composition) {
         this.emit("// === Render Loop ===");
         this.emit("let frameCount = 0;");
@@ -865,6 +1010,8 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
         this.indent();
         this.emit("frameCount++;");
         this.emit("const time = (performance.now() - t0) / 1000.0;");
+        this.emit("device.queue.writeBuffer(vpUniform, 0, buildViewProjection());");
+        this.emit("hsRenderLabels();");
         this.emit("const enc = device.createCommandEncoder();");
         const gpuObjs = (composition.objects || []).filter(
           (o) => o.traits?.some(
@@ -1007,6 +1154,19 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
       findObjProp(obj, key) {
         return obj.properties?.find((p) => p.key === key)?.value;
       }
+      extractObjectProperties(obj) {
+        const properties = {};
+        for (const prop of obj.properties ?? []) {
+          if (!prop.key) continue;
+          const value = prop.value;
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every(
+            (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean"
+          )) {
+            properties[prop.key] = value;
+          }
+        }
+        return properties;
+      }
       parseColor(value) {
         if (typeof value === "string" && value.startsWith("#")) {
           const h = value.slice(1);
@@ -1061,5 +1221,5 @@ var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
 
 exports.WebGPUCompiler_exports = WebGPUCompiler_exports;
 exports.init_WebGPUCompiler = init_WebGPUCompiler;
-//# sourceMappingURL=chunk-W2GA3EQB.cjs.map
-//# sourceMappingURL=chunk-W2GA3EQB.cjs.map
+//# sourceMappingURL=chunk-TC7JEO6R.cjs.map
+//# sourceMappingURL=chunk-TC7JEO6R.cjs.map