@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-KPGC7SK2.js

@@ -0,0 +1,192 @@
+// src/traits/ControlLoopTrait.ts
+function identityN(n) {
+  const I = new Array(n * n).fill(0);
+  for (let i = 0; i < n; i++) I[i * n + i] = 1;
+  return I;
+}
+function matMul(A, r, k, B, c) {
+  const C = new Array(r * c).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      for (let l = 0; l < k; l++) {
+        C[i * c + j] += A[i * k + l] * B[l * c + j];
+      }
+    }
+  }
+  return C;
+}
+function matT(A, r, c) {
+  const T = new Array(r * c).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      T[j * r + i] = A[i * c + j];
+    }
+  }
+  return T;
+}
+function matAdd(A, B) {
+  return A.map((v, i) => v + B[i]);
+}
+function solveLinear(A, n, b) {
+  const a = Array.from({ length: n }, (_, i) => A.slice(i * n, i * n + n));
+  const x = [...b];
+  for (let k = 0; k < n; k++) {
+    let maxVal = Math.abs(a[k][k]);
+    let maxRow = k;
+    for (let i = k + 1; i < n; i++) {
+      if (Math.abs(a[i][k]) > maxVal) {
+        maxVal = Math.abs(a[i][k]);
+        maxRow = i;
+      }
+    }
+    [a[k], a[maxRow]] = [a[maxRow], a[k]];
+    [x[k], x[maxRow]] = [x[maxRow], x[k]];
+    for (let i = k + 1; i < n; i++) {
+      if (Math.abs(a[k][k]) < 1e-14) continue;
+      const f = a[i][k] / a[k][k];
+      for (let j = k; j < n; j++) a[i][j] -= f * a[k][j];
+      x[i] -= f * x[k];
+    }
+  }
+  const result = new Array(n).fill(0);
+  for (let i = n - 1; i >= 0; i--) {
+    if (Math.abs(a[i][i]) < 1e-14) {
+      result[i] = 0;
+      continue;
+    }
+    result[i] = x[i];
+    for (let j = i + 1; j < n; j++) result[i] -= a[i][j] * result[j];
+    result[i] /= a[i][i];
+  }
+  return result;
+}
+function matVec(A, r, c, x) {
+  const y = new Array(r).fill(0);
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) y[i] += A[i * c + j] * x[j];
+  }
+  return y;
+}
+function matScale(A, s) {
+  return A.map((v) => v * s);
+}
+function stepPid(params, setpoint, measurement, dt, state) {
+  const { Kp, Ki, Kd } = params;
+  const iMax = params.iMax ?? Infinity;
+  const alpha = params.filterCoeff ?? 1;
+  const outMin = params.outputMin ?? -Infinity;
+  const outMax = params.outputMax ?? Infinity;
+  const error = setpoint - measurement;
+  state.integralAccum += error * dt;
+  state.integralAccum = Math.max(-iMax, Math.min(iMax, state.integralAccum));
+  const rawDeriv = dt > 0 ? (error - state.prevError) / dt : 0;
+  const filtDeriv = alpha * rawDeriv + (1 - alpha) * state.prevDerivative;
+  state.prevError = error;
+  state.prevDerivative = filtDeriv;
+  const proportional = Kp * error;
+  const integral = Ki * state.integralAccum;
+  const derivative = Kd * filtDeriv;
+  const u = Math.max(outMin, Math.min(outMax, proportional + integral + derivative));
+  return { u, type: "pid", proportional, integral, derivative };
+}
+function stepMpc(params, state) {
+  const { model } = params;
+  const { A, B, n, m } = model;
+  const H = params.horizon ?? 10;
+  const Q = params.Q ?? identityN(n);
+  const Qf = params.Qf ?? Q;
+  const R = params.R ?? identityN(m);
+  const uMin = params.uMin ?? new Array(m).fill(-Infinity);
+  const uMax = params.uMax ?? new Array(m).fill(Infinity);
+  const BT = matT(B, n, m);
+  const AT = matT(A, n, n);
+  let P = [...Qf];
+  const gains = [];
+  for (let t = H - 1; t >= 0; t--) {
+    const BTP = matMul(BT, m, n, P, n);
+    const S = matMul(BTP, m, n, B, m);
+    const SpR = matAdd(S, R);
+    const BTPA = matMul(BTP, m, n, A, n);
+    const K = new Array(m * n).fill(0);
+    for (let col = 0; col < n; col++) {
+      const rhs = new Array(m).fill(0);
+      for (let row = 0; row < m; row++) rhs[row] = BTPA[row * n + col];
+      const kcol = solveLinear(SpR, m, rhs);
+      for (let row = 0; row < m; row++) K[row * n + col] = kcol[row];
+    }
+    gains[t] = K;
+    const BK = matMul(B, n, m, K, n);
+    const AmBK = A.map((v, i) => v - BK[i]);
+    const PAmBK = matMul(P, n, n, AmBK, n);
+    const ATPAmBK = matMul(AT, n, n, PAmBK, n);
+    P = matAdd(Q, ATPAmBK);
+  }
+  const horizon = [];
+  let x = [...state];
+  for (let t = 0; t < H; t++) {
+    const K = gains[t];
+    const u_raw = matVec(matScale(K, -1), m, n, x);
+    const u_t = u_raw.map((v, i) => Math.max(uMin[i], Math.min(uMax[i], v)));
+    horizon.push(...u_t);
+    const Ax = matVec(A, n, n, x);
+    const Bu = matVec(B, n, m, u_t);
+    x = Ax.map((v, i) => v + Bu[i]);
+  }
+  const firstU = horizon.slice(0, m);
+  const u = m === 1 ? firstU[0] : firstU[0];
+  return { u, type: "mpc", horizon };
+}
+function getPidState(node) {
+  let ns = node.__control_state;
+  if (!ns) {
+    ns = {};
+    node.__control_state = ns;
+  }
+  if (!ns.pid) ns.pid = { integralAccum: 0, prevError: 0, prevDerivative: 0 };
+  return ns.pid;
+}
+function resetPidState(node) {
+  const ns = node.__control_state;
+  if (ns?.pid) ns.pid = { integralAccum: 0, prevError: 0, prevDerivative: 0 };
+}
+var controlLoopHandler = {
+  name: "control_loop",
+  defaultConfig: {},
+  onAttach(node) {
+    node.__control_state = {};
+    node.__control_output = null;
+  },
+  onEvent(node, config, _ctx, event) {
+    const n = node;
+    if (event.type === "control_loop.reset") {
+      resetPidState(n);
+      n.__control_output = null;
+      return;
+    }
+    if (event.type === "control_loop.pid_step") {
+      const req = event;
+      const params = req.params ?? config.pid;
+      if (!params) return;
+      const state = getPidState(n);
+      n.__control_output = stepPid(
+        params,
+        req.setpoint,
+        req.measurement,
+        req.dt ?? 1,
+        state
+      );
+      return;
+    }
+    if (event.type === "control_loop.mpc_step") {
+      const req = event;
+      const params = req.params ?? config.mpc;
+      if (!params) return;
+      n.__control_output = stepMpc(params, req.state);
+      return;
+    }
+  }
+};
+
+export { controlLoopHandler, stepMpc, stepPid };
+//# sourceMappingURL=chunk-KPGC7SK2.js.map
+//# sourceMappingURL=chunk-KPGC7SK2.js.map

package/dist/chunk-KROXXBK5.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/compiler/ObjectPool.ts
+var ASTNodePool = class {
+  /**
+   * @param factory Creates a fresh instance of the node.
+   * @param resetter Resets the node state before it is handed out again.
+   * @param initialCapacity How many nodes to pre-allocate.
+   */
+  constructor(factory, resetter, initialCapacity = 1e4) {
+    this.pool = [];
+    this.factory = factory;
+    this.resetter = resetter;
+    for (let i = 0; i < initialCapacity; i++) {
+      this.pool.push(this.factory());
+    }
+  }
+  /**
+   * Acquire a node from the pool, or create a new one if the pool is empty.
+   */
+  acquire() {
+    if (this.pool.length > 0) {
+      const node = this.pool.pop();
+      this.resetter(node);
+      return node;
+    }
+    return this.factory();
+  }
+  /**
+   * Release a node back to the pool to be reused.
+   */
+  release(node) {
+    this.pool.push(node);
+  }
+  /**
+   * Release an array of nodes back to the pool.
+   */
+  releaseAll(nodes) {
+    for (const node of nodes) {
+      this.pool.push(node);
+    }
+  }
+  /**
+   * Clear the pool, allowing garbage collection.
+   */
+  clear() {
+    this.pool.length = 0;
+  }
+};
+
+exports.ASTNodePool = ASTNodePool;
+//# sourceMappingURL=chunk-KROXXBK5.cjs.map
+//# sourceMappingURL=chunk-KROXXBK5.cjs.map

package/dist/{chunk-ZPZAVHXL.cjs → chunk-LB3ZZMKT.cjs}

@@ -1,17 +1,16 @@
 'use strict';
 
 var chunkFT6TDR2O_cjs = require('./chunk-FT6TDR2O.cjs');
-var chunkKAIVDEIG_cjs = require('./chunk-KAIVDEIG.cjs');
-var chunkOIQYIIO3_cjs = require('./chunk-OIQYIIO3.cjs');
-var chunkGH6C2QGW_cjs = require('./chunk-GH6C2QGW.cjs');
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
+var chunkLDYZWNJW_cjs = require('./chunk-LDYZWNJW.cjs');
+var chunkKROXXBK5_cjs = require('./chunk-KROXXBK5.cjs');
+var chunkQQFB4RT2_cjs = require('./chunk-QQFB4RT2.cjs');
+var chunkQEDMOGF3_cjs = require('./chunk-QEDMOGF3.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
 var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/GLTFPipeline.ts
-chunkOIQYIIO3_cjs.init_TraitCompositor();
-chunkKAIVDEIG_cjs.init_R3FCompiler();
-chunkLODTHGST_cjs.init_CompilerBase();
-chunkGH6C2QGW_cjs.init_DomainBlockCompilerMixin();
+chunkZK7KX5CD_cjs.init_CompilerBase();
+chunkQEDMOGF3_cjs.init_DomainBlockCompilerMixin();
 
 // src/compiler/gltf/extensions.ts
 function createEmissiveStrengthExtension(strength) {
@@ -120,8 +119,7 @@ function declareExtensions(gltf) {
 }
 
 // src/compiler/GLTFPipeline.ts
-chunkKAIVDEIG_cjs.init_ObjectPool();
-var gltfNodePool = new chunkKAIVDEIG_cjs.ASTNodePool(
+var gltfNodePool = new chunkKROXXBK5_cjs.ASTNodePool(
   () => ({ name: "" }),
   (node) => {
     node.name = "";
@@ -840,7 +838,7 @@ function generatePlaneGeometry(scale) {
 var INITIAL_COMPILE_BUFFER_SIZE = 1024 * 1024;
 var MAX_RETAINED_BUFFER_SIZE = 1024 * 1024 * 20;
 var SHARED_COMPILE_BUFFER = new Uint8Array(INITIAL_COMPILE_BUFFER_SIZE);
-var GLTFPipeline = class extends chunkLODTHGST_cjs.CompilerBase {
+var GLTFPipeline = class _GLTFPipeline extends chunkZK7KX5CD_cjs.CompilerBase {
   constructor(options = {}) {
     super();
     this.compilerName = "GLTFPipeline";
@@ -884,7 +882,7 @@ var GLTFPipeline = class extends chunkLODTHGST_cjs.CompilerBase {
       generator: options.generator ?? "HoloScript GLTFPipeline v1.0.0",
       copyright: options.copyright ?? ""
     };
-    this.compositor = new chunkOIQYIIO3_cjs.TraitCompositor();
+    this.compositor = new chunkQQFB4RT2_cjs.TraitCompositor();
   }
   getRequiredCapability() {
     return ans.ANSCapabilityPath.GLTF;
@@ -1282,12 +1280,12 @@ var GLTFPipeline = class extends chunkLODTHGST_cjs.CompilerBase {
     }
     const domainBlocks = composition.domainBlocks ?? [];
     if (domainBlocks.length > 0) {
-      chunkGH6C2QGW_cjs.compileDomainBlocks(
+      chunkQEDMOGF3_cjs.compileDomainBlocks(
         domainBlocks,
         {
           material: (block) => {
-            const mat = chunkGH6C2QGW_cjs.compileMaterialBlock(block);
-            const gltfMat = chunkGH6C2QGW_cjs.materialToGLTF(mat);
+            const mat = chunkQEDMOGF3_cjs.compileMaterialBlock(block);
+            const gltfMat = chunkQEDMOGF3_cjs.materialToGLTF(mat);
             this.materials.push(gltfMat);
             this.stats.materialCount++;
             return "";
@@ -1601,8 +1599,8 @@ var GLTFPipeline = class extends chunkLODTHGST_cjs.CompilerBase {
     let attenuationColor;
     let attenuationDistance;
     const namedMat = this.findProp(object, "material");
-    if (typeof namedMat === "string" && chunkKAIVDEIG_cjs.MATERIAL_PRESETS[namedMat]) {
-      const preset = chunkKAIVDEIG_cjs.MATERIAL_PRESETS[namedMat];
+    if (typeof namedMat === "string" && chunkLDYZWNJW_cjs.MATERIAL_PRESETS[namedMat]) {
+      const preset = chunkLDYZWNJW_cjs.MATERIAL_PRESETS[namedMat];
       if (preset.color) color = this.parseColorString(preset.color);
       if (preset.metalness !== void 0) metallic = preset.metalness;
       if (preset.roughness !== void 0) roughness = preset.roughness;
@@ -2031,6 +2029,126 @@ var GLTFPipeline = class extends chunkLODTHGST_cjs.CompilerBase {
     this.accessors.push(accessor);
     return accessorIndex;
   }
+  /**
+   * Build a GLB binary directly from a raw triangle mesh (e.g. a marching-cubes SurfaceMesh from
+   * `Simulation.marchingCubes`). This is the bridge that makes sovereign SDF/CSG geometry loadable
+   * by the Meta Spatial SDK (which loads only glb/gltf — STL is not loadable). Reuses the pipeline's
+   * real accessor + GLB-container machinery; normals are computed if not supplied.
+   *
+   * @param positions flat xyz vertex array
+   * @param indices   flat triangle index array
+   */
+  addSurfaceMesh(positions, indices, opts = {}) {
+    this.bufferByteLength = 0;
+    this.accessors = [];
+    this.bufferViews = [];
+    this.meshes = [];
+    this.materials = [];
+    this.nodes = [];
+    this.scenes = [];
+    const name = opts.name ?? "surface";
+    const normals = opts.normals ?? _GLTFPipeline.computeVertexNormals(positions, indices);
+    const posAcc = this.createAccessor(positions, "VEC3", true);
+    const normAcc = this.createAccessor(normals, "VEC3");
+    let colorAcc = -1;
+    if (opts.vertexColor) {
+      const vertCount = positions.length / 3;
+      const posAccessor = this.accessors[posAcc];
+      const bMin = posAccessor.min ?? [0, 0, 0];
+      const bMax = posAccessor.max ?? [0, 0, 0];
+      const bounds = { min: bMin, max: bMax };
+      const colors = new Uint8Array(vertCount * 4);
+      const toByte = (x) => Math.round(Math.max(0, Math.min(1, x)) * 255);
+      for (let v = 0; v < vertCount; v++) {
+        const px = positions[v * 3];
+        const py = positions[v * 3 + 1];
+        const pz = positions[v * 3 + 2];
+        const c = opts.vertexColor([px, py, pz], v, bounds);
+        colors[v * 4] = toByte(c[0]);
+        colors[v * 4 + 1] = toByte(c[1]);
+        colors[v * 4 + 2] = toByte(c[2]);
+        colors[v * 4 + 3] = c.length > 3 ? toByte(c[3]) : 255;
+      }
+      colorAcc = this.emitColorAccessor(colors, vertCount);
+    }
+    const idxAcc = this.createAccessor(indices, "SCALAR");
+    this.materials.push({
+      name: `${name}_mat`,
+      pbrMetallicRoughness: {
+        baseColorFactor: opts.baseColor ?? [0.8, 0.8, 0.82, 1],
+        metallicFactor: opts.metallic ?? 0,
+        roughnessFactor: opts.roughness ?? 0.85
+      }
+    });
+    const attributes = { POSITION: posAcc, NORMAL: normAcc };
+    if (colorAcc >= 0) attributes.COLOR_0 = colorAcc;
+    this.meshes.push({
+      name,
+      primitives: [{ attributes, indices: idxAcc, material: 0 }]
+    });
+    this.nodes.push({ name, mesh: 0 });
+    this.scenes.push({ name, nodes: [0] });
+    const gltf = this.buildDocument(
+      { name, objects: [], spatialGroups: [] },
+      this.bufferByteLength
+    );
+    const buffer = this.bufferData.subarray(0, this.bufferByteLength);
+    return this.createGLB(gltf, buffer);
+  }
+  /**
+   * Emit a COLOR_0 accessor as a normalized UNSIGNED_BYTE VEC4 (4 bytes/vertex). Sets the
+   * ARRAY_BUFFER target + `normalized: true` so loaders (incl. Meta Spatial SDK / glTF runtimes)
+   * read the bytes back as 0..1 colors. Returns the accessor index.
+   */
+  emitColorAccessor(colors, vertCount) {
+    const byteOffset = this.bufferByteLength;
+    this.appendToBuffer(colors);
+    this.padBuffer(4);
+    const bufferViewIndex = this.bufferViews.length;
+    this.bufferViews.push({
+      buffer: 0,
+      byteOffset,
+      byteLength: colors.byteLength,
+      target: 34962
+      // ARRAY_BUFFER
+    });
+    const accessorIndex = this.accessors.length;
+    this.accessors.push({
+      bufferView: bufferViewIndex,
+      componentType: 5121,
+      // UNSIGNED_BYTE
+      count: vertCount,
+      type: "VEC4",
+      normalized: true
+    });
+    return accessorIndex;
+  }
+  /** Per-vertex normals (averaged face normals) for an indexed triangle mesh. */
+  static computeVertexNormals(positions, indices) {
+    const n = new Float32Array(positions.length);
+    for (let i = 0; i < indices.length; i += 3) {
+      const a = indices[i] * 3, b = indices[i + 1] * 3, c = indices[i + 2] * 3;
+      const e1x = positions[b] - positions[a], e1y = positions[b + 1] - positions[a + 1], e1z = positions[b + 2] - positions[a + 2];
+      const e2x = positions[c] - positions[a], e2y = positions[c + 1] - positions[a + 1], e2z = positions[c + 2] - positions[a + 2];
+      const nx = e1y * e2z - e1z * e2y, ny = e1z * e2x - e1x * e2z, nz = e1x * e2y - e1y * e2x;
+      n[a] += nx;
+      n[a + 1] += ny;
+      n[a + 2] += nz;
+      n[b] += nx;
+      n[b + 1] += ny;
+      n[b + 2] += nz;
+      n[c] += nx;
+      n[c + 1] += ny;
+      n[c + 2] += nz;
+    }
+    for (let i = 0; i < n.length; i += 3) {
+      const len = Math.hypot(n[i], n[i + 1], n[i + 2]) || 1;
+      n[i] /= len;
+      n[i + 1] /= len;
+      n[i + 2] /= len;
+    }
+    return n;
+  }
   /**
    * Build the glTF JSON document
    */
@@ -2253,5 +2371,5 @@ exports.GLTFPipeline = GLTFPipeline;
 exports.createGLTFPipeline = createGLTFPipeline;
 exports.generateScaleNormalMap = generateScaleNormalMap;
 exports.generateScaleTexture = generateScaleTexture;
-//# sourceMappingURL=chunk-ZPZAVHXL.cjs.map
-//# sourceMappingURL=chunk-ZPZAVHXL.cjs.map
+//# sourceMappingURL=chunk-LB3ZZMKT.cjs.map
+//# sourceMappingURL=chunk-LB3ZZMKT.cjs.map