@holoscript/core 6.0.4 → 6.1.1

package/dist/chunk-KPJL34Y7.cjs

@@ -0,0 +1,186 @@
+'use strict';
+
+// src/math/tropicalSpmv.ts
+var TROPICAL_INF = 1e30;
+function mulberry32(seed) {
+  let t = seed >>> 0;
+  return () => {
+    t += 1831565813;
+    let r = Math.imul(t ^ t >>> 15, 1 | t);
+    r ^= r + Math.imul(r ^ r >>> 7, 61 | r);
+    return ((r ^ r >>> 14) >>> 0) / 4294967296;
+  };
+}
+function tropicalMinPlusSpmv(csr, x, y) {
+  const { n, rowPtr, colIdx, values } = csr;
+  if (x.length < n || y.length < n) {
+    throw new Error(`tropicalMinPlusSpmv: x and y must have length >= n (${n})`);
+  }
+  for (let i = 0; i < n; i++) {
+    let best = TROPICAL_INF;
+    const end = rowPtr[i + 1];
+    for (let k = rowPtr[i]; k < end; k++) {
+      const j = colIdx[k];
+      const aij = values[k];
+      const xj = x[j];
+      if (aij >= TROPICAL_INF || xj >= TROPICAL_INF) continue;
+      const s = aij + xj;
+      if (s < best) best = s;
+    }
+    y[i] = best;
+  }
+}
+function tropicalMinPlusSpmvDense(n, aRowMajor, x, y) {
+  if (aRowMajor.length !== n * n) throw new Error("tropicalMinPlusSpmvDense: expected n*n matrix");
+  for (let i = 0; i < n; i++) {
+    let best = TROPICAL_INF;
+    const row = i * n;
+    for (let j = 0; j < n; j++) {
+      const aij = aRowMajor[row + j];
+      if (aij >= TROPICAL_INF) continue;
+      const xj = x[j];
+      if (xj >= TROPICAL_INF) continue;
+      const s = aij + xj;
+      if (s < best) best = s;
+    }
+    y[i] = best;
+  }
+}
+function csrFromDense(n, dense) {
+  if (dense.length !== n * n) throw new Error("csrFromDense: dense must be n*n");
+  const rowCounts = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    let c = 0;
+    for (let j = 0; j < n; j++) {
+      const v = dense[i * n + j];
+      if (v < TROPICAL_INF && v === v) c++;
+    }
+    rowCounts[i] = c;
+  }
+  const rowPtr = new Uint32Array(n + 1);
+  for (let i = 0; i < n; i++) rowPtr[i + 1] = rowPtr[i] + rowCounts[i];
+  const nnz = rowPtr[n];
+  const colIdx = new Uint32Array(nnz);
+  const values = new Float32Array(nnz);
+  const write = new Uint32Array(rowPtr);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      const v = dense[i * n + j];
+      if (v < TROPICAL_INF && v === v) {
+        const p = write[i];
+        colIdx[p] = j;
+        values[p] = v;
+        write[i] = p + 1;
+      }
+    }
+  }
+  return { n, rowPtr, colIdx, values };
+}
+function erdosRenyiCsr(n, p, rng) {
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      if (rng() < p) {
+        rows[i].push(j);
+        vals[i].push(1e-6 + rng() * (1 - 1e-6));
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function barabasiAlbertCsr(n, m, rng) {
+  if (n < 2 || m < 1) throw new Error("barabasiAlbertCsr: need n>=2, m>=1");
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  const indeg = new Uint32Array(n);
+  const addEdge = (from, to, w) => {
+    rows[from].push(to);
+    vals[from].push(w);
+    indeg[to]++;
+  };
+  const m0 = Math.min(m + 1, n);
+  for (let i = 1; i < m0; i++) {
+    addEdge(i, 0, 1e-6 + rng());
+  }
+  for (let v = m0; v < n; v++) {
+    const chosen = /* @__PURE__ */ new Set();
+    let guard = 0;
+    while (chosen.size < Math.min(m, v) && guard < m * v * 5) {
+      guard++;
+      let tot = 0;
+      for (let u = 0; u < v; u++) tot += indeg[u] + 1;
+      let r = rng() * tot;
+      let acc = 0;
+      let pick = 0;
+      for (let u = 0; u < v; u++) {
+        acc += indeg[u] + 1;
+        if (r <= acc) {
+          pick = u;
+          break;
+        }
+      }
+      if (!chosen.has(pick)) {
+        chosen.add(pick);
+        addEdge(v, pick, 1e-6 + rng());
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function layeredNeuralCsr(n, layers, skipProbability, rng) {
+  if (layers < 2) throw new Error("layeredNeuralCsr: layers >= 2");
+  const rows = Array.from({ length: n }, () => []);
+  const vals = Array.from({ length: n }, () => []);
+  const layerOf = (i) => Math.floor(i * layers / n);
+  for (let i = 0; i < n; i++) {
+    const li = layerOf(i);
+    for (let j = 0; j < n; j++) {
+      const lj = layerOf(j);
+      if (lj === li + 1 || lj > li && rng() < skipProbability) {
+        rows[i].push(j);
+        vals[i].push(1e-6 + rng());
+      }
+    }
+  }
+  return packCsr(n, rows, vals);
+}
+function packCsr(n, rows, vals) {
+  const rowPtr = new Uint32Array(n + 1);
+  let nnz = 0;
+  for (let i = 0; i < n; i++) nnz += rows[i].length;
+  for (let i = 0; i < n; i++) rowPtr[i + 1] = rowPtr[i] + rows[i].length;
+  const colIdx = new Uint32Array(nnz);
+  const values = new Float32Array(nnz);
+  let w = 0;
+  for (let i = 0; i < n; i++) {
+    const rc = rows[i].length;
+    for (let k = 0; k < rc; k++) {
+      colIdx[w] = rows[i][k];
+      values[w] = vals[i][k];
+      w++;
+    }
+  }
+  return { n, rowPtr, colIdx, values };
+}
+function maxAbsDiff(a, b) {
+  let m = 0;
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const d = Math.abs(a[i] - b[i]);
+    if (d > m) m = d;
+  }
+  return m;
+}
+
+exports.TROPICAL_INF = TROPICAL_INF;
+exports.barabasiAlbertCsr = barabasiAlbertCsr;
+exports.csrFromDense = csrFromDense;
+exports.erdosRenyiCsr = erdosRenyiCsr;
+exports.layeredNeuralCsr = layeredNeuralCsr;
+exports.maxAbsDiff = maxAbsDiff;
+exports.mulberry32 = mulberry32;
+exports.tropicalMinPlusSpmv = tropicalMinPlusSpmv;
+exports.tropicalMinPlusSpmvDense = tropicalMinPlusSpmvDense;
+//# sourceMappingURL=chunk-KPJL34Y7.cjs.map
+//# sourceMappingURL=chunk-KPJL34Y7.cjs.map

package/dist/{chunk-HE7ULERA.cjs → chunk-KQTPCYTG.cjs}

@@ -1,21 +1,23 @@
 'use strict';
 
-var chunkLXJ4667L_cjs = require('./chunk-LXJ4667L.cjs');
-var chunkBF2235SI_cjs = require('./chunk-BF2235SI.cjs');
-var chunk3SAK5KFL_cjs = require('./chunk-3SAK5KFL.cjs');
-var platform = require('@holoscript/platform');
+var chunkAIA52I7T_cjs = require('./chunk-AIA52I7T.cjs');
+var chunkHGVXZDSK_cjs = require('./chunk-HGVXZDSK.cjs');
+var chunkRMHC2VG7_cjs = require('./chunk-RMHC2VG7.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/UnityCompiler.ts
 var UnityCompiler_exports = {};
-chunk3SAK5KFL_cjs.__export(UnityCompiler_exports, {
+chunkHCCQLAA4_cjs.__export(UnityCompiler_exports, {
   UnityCompiler: () => exports.UnityCompiler
 });
 exports.UnityCompiler = void 0;
-var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
+var init_UnityCompiler = chunkHCCQLAA4_cjs.__esm({
   "src/compiler/UnityCompiler.ts"() {
-    chunkBF2235SI_cjs.init_CompilerBase();
-    chunkLXJ4667L_cjs.init_DomainBlockCompilerMixin();
-    exports.UnityCompiler = class extends chunkBF2235SI_cjs.CompilerBase {
+    chunkRMHC2VG7_cjs.init_CompilerBase();
+    chunkHGVXZDSK_cjs.init_DomainBlockCompilerMixin();
+    chunkAIA52I7T_cjs.init_PlatformConditionalCompilerMixin();
+    exports.UnityCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "UnityCompiler";
@@ -25,14 +27,23 @@ var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
           namespace: options.namespace || "HoloScene",
           className: options.className || "GeneratedScene",
           useURP: options.useURP ?? true,
-          indent: options.indent || "    "
+          indent: options.indent || "    ",
+          provenanceHash: options.provenanceHash ?? "",
+          holomapPointCloud: options.holomapPointCloud
         };
+        if (options.platformTarget) {
+          this._platformTarget = typeof options.platformTarget === "string" ? chunkAIA52I7T_cjs.createPlatformTarget(options.platformTarget) : options.platformTarget;
+        }
       }
       getRequiredCapability() {
-        return platform.ANSCapabilityPath.UNITY;
+        return ans.ANSCapabilityPath.UNITY;
       }
       compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
+        if (this._platformTarget) {
+          const platformMixin = new chunkAIA52I7T_cjs.PlatformConditionalCompilerMixin();
+          composition = platformMixin.filterForPlatform(composition, this._platformTarget);
+        }
         this.lines = [];
         this.indentLevel = 0;
         this.emit("// Auto-generated by HoloScript UnityCompiler");
@@ -40,6 +51,9 @@ var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
           `// Source: composition "${this.escapeStringValue(composition.name, "CSharp")}"`
         );
         this.emit("// Do not edit manually \u2014 regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
         this.emit("");
         this.emit("using UnityEngine;");
         this.emit("using UnityEngine.UI;");
@@ -103,6 +117,7 @@ var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
             }
           }
         }
+        this.emitHolomapPointCloudLoader();
         this.indentLevel--;
         this.emit("}");
         this.emit("");
@@ -129,69 +144,138 @@ var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
         this.emit("}");
         return this.lines.join("\n");
       }
+      emitHolomapPointCloudLoader() {
+        const h = this.options.holomapPointCloud;
+        if (!h || h.pointCount < 1) return;
+        this.emit("    // --- HoloMap point cloud (base64 \u2192 Mesh topology Points) ---");
+        this.emit("    {");
+        const posLit = this.chunkBase64CSharpLiteral(h.positionsB64);
+        const colLit = this.chunkBase64CSharpLiteral(h.colorsB64);
+        this.emit(`      string holomapPosB64 = ${posLit};`);
+        this.emit(`      string holomapColB64 = ${colLit};`);
+        this.emit(`      int holomapN = ${h.pointCount};`);
+        this.emit(
+          "      byte[] holomapPos = System.Convert.FromBase64String(holomapPosB64);"
+        );
+        this.emit(
+          "      byte[] holomapCol = System.Convert.FromBase64String(holomapColB64);"
+        );
+        this.emit("      if (holomapPos.Length >= holomapN * 12 && holomapCol.Length >= holomapN * 3)");
+        this.emit("      {");
+        this.emit(
+          '        var holomapGo = new GameObject("HoloMapReconstructionPoints");'
+        );
+        this.emit("        holomapGo.transform.SetParent(transform, false);");
+        this.emit("        var mesh = new Mesh();");
+        this.emit(
+          "        mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;"
+        );
+        this.emit("        var verts = new Vector3[holomapN];");
+        this.emit("        var cols = new Color32[holomapN];");
+        this.emit("        var idx = new int[holomapN];");
+        this.emit("        for (int i = 0; i < holomapN; i++)");
+        this.emit("        {");
+        this.emit(
+          "          int p = i * 12; int c = i * 3;"
+        );
+        this.emit(
+          "          verts[i] = new Vector3(System.BitConverter.ToSingle(holomapPos, p), System.BitConverter.ToSingle(holomapPos, p + 4), System.BitConverter.ToSingle(holomapPos, p + 8));"
+        );
+        this.emit(
+          "          cols[i] = new Color32(holomapCol[c], holomapCol[c + 1], holomapCol[c + 2], 255);"
+        );
+        this.emit("          idx[i] = i;");
+        this.emit("        }");
+        this.emit("        mesh.vertices = verts;");
+        this.emit("        mesh.colors32 = cols;");
+        this.emit("        mesh.SetIndices(idx, MeshTopology.Points, 0, true);");
+        this.emit("        mesh.RecalculateBounds();");
+        this.emit("        var mf = holomapGo.AddComponent<MeshFilter>();");
+        this.emit("        mf.sharedMesh = mesh;");
+        this.emit("        var mr = holomapGo.AddComponent<MeshRenderer>();");
+        this.emit(
+          '        var sh = Shader.Find("Universal Render Pipeline/Unlit");'
+        );
+        this.emit(
+          '        if (sh == null) sh = Shader.Find("Unlit/Color");'
+        );
+        this.emit('        mr.sharedMaterial = sh != null ? new Material(sh) : new Material(Shader.Find("Hidden/InternalErrorShader"));');
+        this.emit("      }");
+        this.emit("    }");
+      }
+      /** Concatenated string literals so very large MCP payloads stay valid C#. */
+      chunkBase64CSharpLiteral(b64) {
+        const chunk = 4096;
+        if (b64.length <= chunk) return `"${b64}"`;
+        const parts = [];
+        for (let i = 0; i < b64.length; i += chunk) {
+          parts.push(`"${b64.slice(i, i + chunk)}"`);
+        }
+        return parts.join(" + ");
+      }
       compileDomainBlocks(composition) {
         const domainBlocks = composition.domainBlocks ?? [];
         if (domainBlocks.length === 0) return;
         this.emit("");
         this.emit("// === v4.2 Domain Blocks ===");
         let blockIdx = 0;
-        const compiled = chunkLXJ4667L_cjs.compileDomainBlocks(
+        const compiled = chunkHGVXZDSK_cjs.compileDomainBlocks(
           domainBlocks,
           {
             material: (block) => {
-              const mat = chunkLXJ4667L_cjs.compileMaterialBlock(block);
+              const mat = chunkHGVXZDSK_cjs.compileMaterialBlock(block);
               const prefix = `db${blockIdx++}`;
-              return chunkLXJ4667L_cjs.materialToUnity(mat, prefix);
+              return chunkHGVXZDSK_cjs.materialToUnity(mat, prefix);
             },
             physics: (block) => {
-              const phys = chunkLXJ4667L_cjs.compilePhysicsBlock(block);
+              const phys = chunkHGVXZDSK_cjs.compilePhysicsBlock(block);
               const prefix = `db${blockIdx++}`;
-              return chunkLXJ4667L_cjs.physicsToUnity(phys, prefix);
+              return chunkHGVXZDSK_cjs.physicsToUnity(phys, prefix);
             },
             vfx: (block) => {
-              const ps = chunkLXJ4667L_cjs.compileParticleBlock(block);
+              const ps = chunkHGVXZDSK_cjs.compileParticleBlock(block);
               const prefix = `db${blockIdx++}`;
-              return chunkLXJ4667L_cjs.particlesToUnity(ps, prefix);
+              return chunkHGVXZDSK_cjs.particlesToUnity(ps, prefix);
             },
             postfx: (block) => {
-              const pp = chunkLXJ4667L_cjs.compilePostProcessingBlock(block);
-              return chunkLXJ4667L_cjs.postProcessingToUnity(pp);
+              const pp = chunkHGVXZDSK_cjs.compilePostProcessingBlock(block);
+              return chunkHGVXZDSK_cjs.postProcessingToUnity(pp);
             },
             audio: (block) => {
-              const audio = chunkLXJ4667L_cjs.compileAudioSourceBlock(block);
+              const audio = chunkHGVXZDSK_cjs.compileAudioSourceBlock(block);
               const prefix = `db${blockIdx++}`;
-              return chunkLXJ4667L_cjs.audioSourceToUnity(audio, prefix);
+              return chunkHGVXZDSK_cjs.audioSourceToUnity(audio, prefix);
             },
             weather: (block) => {
-              const weather = chunkLXJ4667L_cjs.compileWeatherBlock(block);
-              return chunkLXJ4667L_cjs.weatherToUnity(weather);
+              const weather = chunkHGVXZDSK_cjs.compileWeatherBlock(block);
+              return chunkHGVXZDSK_cjs.weatherToUnity(weather);
             },
             narrative: (block) => {
-              const narr = chunkLXJ4667L_cjs.compileNarrativeBlock(block);
-              return chunkLXJ4667L_cjs.narrativeToUnity(narr);
+              const narr = chunkHGVXZDSK_cjs.compileNarrativeBlock(block);
+              return chunkHGVXZDSK_cjs.narrativeToUnity(narr);
             },
             payment: (block) => {
-              const pay = chunkLXJ4667L_cjs.compilePaymentBlock(block);
-              return chunkLXJ4667L_cjs.paymentToUnity(pay);
+              const pay = chunkHGVXZDSK_cjs.compilePaymentBlock(block);
+              return chunkHGVXZDSK_cjs.paymentToUnity(pay);
             },
             healthcare: (block) => {
-              const h = chunkLXJ4667L_cjs.compileHealthcareBlock(block);
-              return chunkLXJ4667L_cjs.healthcareToUnity(h);
+              const h = chunkHGVXZDSK_cjs.compileHealthcareBlock(block);
+              return chunkHGVXZDSK_cjs.healthcareToUnity(h);
             },
             robotics: (block) => {
-              const r = chunkLXJ4667L_cjs.compileRoboticsBlock(block);
-              return chunkLXJ4667L_cjs.roboticsToUnity(r);
+              const r = chunkHGVXZDSK_cjs.compileRoboticsBlock(block);
+              return chunkHGVXZDSK_cjs.roboticsToUnity(r);
             },
-            iot: (block) => chunkLXJ4667L_cjs.iotToUnity(chunkLXJ4667L_cjs.compileIoTBlock(block)),
-            dataviz: (block) => chunkLXJ4667L_cjs.datavizToUnity(chunkLXJ4667L_cjs.compileDataVizBlock(block)),
-            education: (block) => chunkLXJ4667L_cjs.educationToUnity(chunkLXJ4667L_cjs.compileEducationBlock(block)),
-            music: (block) => chunkLXJ4667L_cjs.musicToUnity(chunkLXJ4667L_cjs.compileMusicBlock(block)),
-            architecture: (block) => chunkLXJ4667L_cjs.architectureToUnity(chunkLXJ4667L_cjs.compileArchitectureBlock(block)),
-            web3: (block) => chunkLXJ4667L_cjs.web3ToUnity(chunkLXJ4667L_cjs.compileWeb3Block(block)),
-            procedural: (block) => chunkLXJ4667L_cjs.proceduralToUnity(chunkLXJ4667L_cjs.compileProceduralBlock(block)),
-            rendering: (block) => chunkLXJ4667L_cjs.renderingToUnity(chunkLXJ4667L_cjs.compileRenderingBlock(block)),
-            navigation: (block) => chunkLXJ4667L_cjs.navigationToUnity(chunkLXJ4667L_cjs.compileNavigationBlock(block)),
-            input: (block) => chunkLXJ4667L_cjs.inputToUnity(chunkLXJ4667L_cjs.compileInputBlock(block))
+            iot: (block) => chunkHGVXZDSK_cjs.iotToUnity(chunkHGVXZDSK_cjs.compileIoTBlock(block)),
+            dataviz: (block) => chunkHGVXZDSK_cjs.datavizToUnity(chunkHGVXZDSK_cjs.compileDataVizBlock(block)),
+            education: (block) => chunkHGVXZDSK_cjs.educationToUnity(chunkHGVXZDSK_cjs.compileEducationBlock(block)),
+            music: (block) => chunkHGVXZDSK_cjs.musicToUnity(chunkHGVXZDSK_cjs.compileMusicBlock(block)),
+            architecture: (block) => chunkHGVXZDSK_cjs.architectureToUnity(chunkHGVXZDSK_cjs.compileArchitectureBlock(block)),
+            web3: (block) => chunkHGVXZDSK_cjs.web3ToUnity(chunkHGVXZDSK_cjs.compileWeb3Block(block)),
+            procedural: (block) => chunkHGVXZDSK_cjs.proceduralToUnity(chunkHGVXZDSK_cjs.compileProceduralBlock(block)),
+            rendering: (block) => chunkHGVXZDSK_cjs.renderingToUnity(chunkHGVXZDSK_cjs.compileRenderingBlock(block)),
+            navigation: (block) => chunkHGVXZDSK_cjs.navigationToUnity(chunkHGVXZDSK_cjs.compileNavigationBlock(block)),
+            input: (block) => chunkHGVXZDSK_cjs.inputToUnity(chunkHGVXZDSK_cjs.compileInputBlock(block))
           },
           (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "CSharp")}"`
         );
@@ -693,5 +777,5 @@ var init_UnityCompiler = chunk3SAK5KFL_cjs.__esm({
 
 exports.UnityCompiler_exports = UnityCompiler_exports;
 exports.init_UnityCompiler = init_UnityCompiler;
-//# sourceMappingURL=chunk-HE7ULERA.cjs.map
-//# sourceMappingURL=chunk-HE7ULERA.cjs.map
+//# sourceMappingURL=chunk-KQTPCYTG.cjs.map
+//# sourceMappingURL=chunk-KQTPCYTG.cjs.map

package/dist/{chunk-OFKWH2IP.js → chunk-KX76JUQY.js}

@@ -435,7 +435,7 @@ function uint8ArrayToBase64(data) {
   return btoa(binary);
 }
 async function importGLTFPipeline() {
-  return import('./GLTFPipeline-DEN36VNK.js');
+  return import('./GLTFPipeline-SFIORFJU.js');
 }
 function registerGLTFTools(server) {
   for (const tool of GLTF_PIPELINE_TOOLS) {
@@ -445,5 +445,5 @@ function registerGLTFTools(server) {
 var GLTFPipelineMCPTool_default = handleGLTFToolCall;
 
 export { GLTFPipelineMCPTool_default, GLTF_PIPELINE_TOOLS, analyzeOptimizations, handleGLTFToolCall, inspectComposition, registerGLTFTools, validateForGLTF };
-//# sourceMappingURL=chunk-OFKWH2IP.js.map
-//# sourceMappingURL=chunk-OFKWH2IP.js.map
+//# sourceMappingURL=chunk-KX76JUQY.js.map
+//# sourceMappingURL=chunk-KX76JUQY.js.map