@holoscript/core 6.0.4 → 6.1.2

package/dist/chunk-FHP6LXJS.js

@@ -0,0 +1,415 @@
+// src/traits/engines/tensor-ops.ts
+function sizeOf(shape) {
+  return shape.reduce((a, b) => a * b, 1);
+}
+function createTensor(shape, data) {
+  if (!Array.isArray(shape) || shape.length === 0 || shape.some((d) => !Number.isInteger(d) || d <= 0)) {
+    throw new Error(`tensor-ops: invalid shape ${JSON.stringify(shape)}`);
+  }
+  const size = sizeOf(shape);
+  const buf = new Float32Array(size);
+  if (data) {
+    const n = Math.min(size, data.length);
+    for (let i = 0; i < n; i++) buf[i] = data[i];
+  }
+  return { shape: shape.slice(), data: buf };
+}
+function add(a, b) {
+  if (a.data.length !== b.data.length) {
+    throw new Error(
+      `tensor-ops: add shape mismatch ${JSON.stringify(a.shape)} vs ${JSON.stringify(b.shape)}`
+    );
+  }
+  const out = new Float32Array(a.data.length);
+  for (let i = 0; i < out.length; i++) out[i] = a.data[i] + b.data[i];
+  return { shape: a.shape.slice(), data: out };
+}
+function matmul(a, b) {
+  if (a.shape.length !== 2 || b.shape.length !== 2) {
+    throw new Error("tensor-ops: matmul requires 2D tensors");
+  }
+  const [m, k] = a.shape;
+  const [k2, n] = b.shape;
+  if (k !== k2) {
+    throw new Error(`tensor-ops: matmul inner dim mismatch ${k} vs ${k2}`);
+  }
+  const out = new Float32Array(m * n);
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      let acc = 0;
+      for (let p = 0; p < k; p++) acc += a.data[i * k + p] * b.data[p * n + j];
+      out[i * n + j] = acc;
+    }
+  }
+  return { shape: [m, n], data: out };
+}
+
+// src/traits/engines/pfnn-network.ts
+var PHASE_CONTROL_POINTS = 4;
+var HIDDEN_DIM = 64;
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function eluInPlace(data) {
+  for (let i = 0; i < data.length; i++) {
+    const x = data[i];
+    data[i] = x >= 0 ? x : Math.exp(x) - 1;
+  }
+}
+function initWeight(rng, inDim, outDim) {
+  const limit = Math.sqrt(6 / (inDim + outDim));
+  const data = new Float32Array(inDim * outDim);
+  for (let i = 0; i < data.length; i++) data[i] = (rng() * 2 - 1) * limit;
+  return { shape: [inDim, outDim], data };
+}
+function initBias(rng, outDim) {
+  const data = new Float32Array(outDim);
+  for (let i = 0; i < data.length; i++) data[i] = (rng() * 2 - 1) * 0.01;
+  return { shape: [1, outDim], data };
+}
+var PfnnNetwork = class {
+  constructor(inputDim, outputDim, seed = 2654435769, hiddenDim = HIDDEN_DIM) {
+    this.inputDim = inputDim;
+    this.outputDim = outputDim;
+    this.hiddenDim = hiddenDim;
+    const rng = mulberry32(seed);
+    this.controlPoints = [];
+    for (let c = 0; c < PHASE_CONTROL_POINTS; c++) {
+      const layers = [
+        { weight: initWeight(rng, inputDim, hiddenDim), bias: initBias(rng, hiddenDim) },
+        { weight: initWeight(rng, hiddenDim, hiddenDim), bias: initBias(rng, hiddenDim) },
+        { weight: initWeight(rng, hiddenDim, outputDim), bias: initBias(rng, outputDim) }
+      ];
+      this.controlPoints.push({ layers });
+    }
+  }
+  /**
+   * Export the raw weights — used by the .onnx provisioning script so the
+   * ONNX graph carries the identical numbers. Returned arrays are copies.
+   */
+  exportWeights() {
+    return {
+      controlPoints: this.controlPoints.map((cp) => ({
+        layers: cp.layers.map((l) => ({
+          weight: Array.from(l.weight.data),
+          bias: Array.from(l.bias.data),
+          shape: [l.weight.shape[0], l.weight.shape[1]]
+        }))
+      }))
+    };
+  }
+  /**
+   * Cyclic cubic Catmull-Rom blend of the four control points at phase φ.
+   * Holden 2017 eq. 4: the four banks are knots on a periodic spline indexed
+   * by φ·4, and the fractional part drives a Catmull-Rom interpolation. We
+   * blend per-layer weight and bias buffers.
+   */
+  blendLayer(layerIdx, phase) {
+    const t = (phase % 1 + 1) % 1;
+    const scaled = t * PHASE_CONTROL_POINTS;
+    const k = Math.floor(scaled);
+    const f = scaled - k;
+    const mod = (n) => (n % PHASE_CONTROL_POINTS + PHASE_CONTROL_POINTS) % PHASE_CONTROL_POINTS;
+    const p0 = this.controlPoints[mod(k - 1)].layers[layerIdx];
+    const p1 = this.controlPoints[mod(k)].layers[layerIdx];
+    const p2 = this.controlPoints[mod(k + 1)].layers[layerIdx];
+    const p3 = this.controlPoints[mod(k + 2)].layers[layerIdx];
+    const f2 = f * f;
+    const f3 = f2 * f;
+    const w0 = -0.5 * f3 + f2 - 0.5 * f;
+    const w1 = 1.5 * f3 - 2.5 * f2 + 1;
+    const w2 = -1.5 * f3 + 2 * f2 + 0.5 * f;
+    const w3 = 0.5 * f3 - 0.5 * f2;
+    const blend = (a, b, c, d) => {
+      const out = new Float32Array(a.data.length);
+      for (let i = 0; i < out.length; i++) {
+        out[i] = w0 * a.data[i] + w1 * b.data[i] + w2 * c.data[i] + w3 * d.data[i];
+      }
+      return { shape: a.shape.slice(), data: out };
+    };
+    return {
+      weight: blend(p0.weight, p1.weight, p2.weight, p3.weight),
+      bias: blend(p0.bias, p1.bias, p2.bias, p3.bias)
+    };
+  }
+  /**
+   * Run a real forward pass. `input` is a Float32Array of length inputDim.
+   * `phase` ∈ [0,1) selects the blended weights. Returns a Float32Array of
+   * length outputDim. Pure, deterministic, no native deps.
+   */
+  forward(input, phase) {
+    if (input.length !== this.inputDim) {
+      throw new Error(
+        `PfnnNetwork.forward: input length ${input.length} != inputDim ${this.inputDim}`
+      );
+    }
+    let x = createTensor([1, this.inputDim], input);
+    const layer0 = this.blendLayer(0, phase);
+    const layer1 = this.blendLayer(1, phase);
+    const layer2 = this.blendLayer(2, phase);
+    x = add(matmul(x, layer0.weight), layer0.bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layer1.weight), layer1.bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layer2.weight), layer2.bias);
+    return x.data;
+  }
+  /**
+   * Forward pass using ONLY control point `cp` (no phase blending). This is the
+   * exact computation the provisioned .onnx graph encodes (it bakes a single
+   * control point). Used by the pure-JS ↔ ONNX numerical-parity test to prove
+   * both paths run the identical genuine forward pass.
+   */
+  forwardControlPoint(input, cp = 0) {
+    if (input.length !== this.inputDim) {
+      throw new Error(
+        `PfnnNetwork.forwardControlPoint: input length ${input.length} != inputDim ${this.inputDim}`
+      );
+    }
+    const layers = this.controlPoints[(cp % PHASE_CONTROL_POINTS + PHASE_CONTROL_POINTS) % PHASE_CONTROL_POINTS].layers;
+    let x = createTensor([1, this.inputDim], input);
+    x = add(matmul(x, layers[0].weight), layers[0].bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layers[1].weight), layers[1].bias);
+    eluInPlace(x.data);
+    x = add(matmul(x, layers[2].weight), layers[2].bias);
+    return x.data;
+  }
+};
+var BUNDLED_MODEL_SEED = 2654435769;
+function createBundledPfnn(inputDim, outputDim) {
+  return new PfnnNetwork(inputDim, outputDim, BUNDLED_MODEL_SEED);
+}
+
+// src/traits/engines/onnx-adapter.ts
+var NoOpInferenceAdapter = class {
+  constructor() {
+    this.name = "NoOpInferenceAdapter";
+    this.preferredProvider = "cpu";
+    this.loaded = false;
+    this.modelUrl = null;
+  }
+  async load(modelUrl) {
+    this.modelUrl = modelUrl;
+    this.loaded = true;
+  }
+  runSync(request) {
+    if (!this.loaded) {
+      throw new Error("NoOpInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("NoOpInferenceAdapter: at least one input required");
+    }
+    const firstInput = request.inputs[inputNames[0]];
+    const outputNames = request.outputs && request.outputs.length > 0 ? request.outputs : ["output"];
+    const outputs = {};
+    for (const name of outputNames) {
+      outputs[name] = {
+        data: new Float32Array(firstInput.data.length),
+        shape: firstInput.shape
+      };
+    }
+    return {
+      outputs,
+      durationMs: 0,
+      providerUsed: this.preferredProvider
+    };
+  }
+  async run(request) {
+    return this.runSync(request);
+  }
+  dispose() {
+    this.loaded = false;
+    this.modelUrl = null;
+  }
+  /** Returns the URL the adapter was loaded with — diagnostic only. */
+  get loadedModelUrl() {
+    return this.modelUrl;
+  }
+};
+function createNoOpInferenceAdapter() {
+  return new NoOpInferenceAdapter();
+}
+var PureJsInferenceAdapter = class {
+  constructor(inputDim, outputDim) {
+    this.inputDim = inputDim;
+    this.outputDim = outputDim;
+    this.name = "PureJsInferenceAdapter";
+    this.preferredProvider = "cpu";
+    this.loaded = false;
+    this.net = null;
+    this.modelUrl = null;
+  }
+  async load(modelUrl) {
+    this.modelUrl = modelUrl;
+    if (this.inputDim != null && this.outputDim != null) {
+      this.net = createBundledPfnn(this.inputDim, this.outputDim);
+    }
+    this.loaded = true;
+  }
+  ensureNet(inputDim) {
+    if (this.net && this.net.inputDim === inputDim) return this.net;
+    const outDim = this.outputDim ?? MOTION_OUTPUT_DIM_DEFAULT;
+    this.net = createBundledPfnn(inputDim, outDim);
+    return this.net;
+  }
+  /** Recover the locomotion phase from the engine's phase channels. */
+  phaseFromInput(data) {
+    const n = data.length;
+    const sinP = data[n - 4] ?? 0;
+    const cosP = data[n - 3] ?? 1;
+    return (Math.atan2(sinP, cosP) / (2 * Math.PI) + 1) % 1;
+  }
+  runSync(request) {
+    if (!this.loaded) {
+      throw new Error("PureJsInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("PureJsInferenceAdapter: at least one input required");
+    }
+    const input = request.inputs[inputNames[0]];
+    const net = this.ensureNet(input.data.length);
+    const phase = this.phaseFromInput(input.data);
+    const start = nowMs();
+    const out = net.forward(input.data, phase);
+    const durationMs = nowMs() - start;
+    const outName = request.outputs && request.outputs.length > 0 ? request.outputs[0] : "motion_output";
+    return {
+      outputs: { [outName]: { data: out, shape: [1, out.length] } },
+      durationMs,
+      providerUsed: this.preferredProvider
+    };
+  }
+  async run(request) {
+    return this.runSync(request);
+  }
+  dispose() {
+    this.loaded = false;
+    this.net = null;
+    this.modelUrl = null;
+  }
+};
+var MOTION_OUTPUT_DIM_DEFAULT = 50;
+function nowMs() {
+  return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+}
+function createPureJsInferenceAdapter(inputDim, outputDim) {
+  return new PureJsInferenceAdapter(inputDim, outputDim);
+}
+var OnnxNodeInferenceAdapter = class {
+  constructor(preferredProvider = "cpu") {
+    this.name = "OnnxNodeInferenceAdapter";
+    this.loaded = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.session = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.ort = null;
+    this.resolvedPath = null;
+    this.preferredProvider = preferredProvider;
+  }
+  async load(modelUrl) {
+    const path = await resolveOnnxModelPath(modelUrl);
+    if (!path) {
+      throw new Error(
+        `OnnxNodeInferenceAdapter: no .onnx model file resolved for "${modelUrl}". Provision it with scripts/provision-motion-model.mjs or set HOLOSCRIPT_MOTION_MODELS_DIR.`
+      );
+    }
+    this.ort = await import('onnxruntime-node');
+    this.session = await this.ort.InferenceSession.create(path);
+    this.resolvedPath = path;
+    this.loaded = true;
+  }
+  async run(request) {
+    if (!this.loaded || !this.session || !this.ort) {
+      throw new Error("OnnxNodeInferenceAdapter: load() must be called before run()");
+    }
+    const inputNames = Object.keys(request.inputs);
+    if (inputNames.length === 0) {
+      throw new Error("OnnxNodeInferenceAdapter: at least one input required");
+    }
+    const feeds = {};
+    const sessionInputs = this.session.inputNames ?? [];
+    const requestEntries = Object.entries(request.inputs);
+    requestEntries.forEach(([name, tensor], i) => {
+      const target = sessionInputs[i] ?? name;
+      feeds[target] = new this.ort.Tensor("float32", tensor.data, Array.from(tensor.shape));
+    });
+    const start = nowMs();
+    const results = await this.session.run(feeds);
+    const durationMs = nowMs() - start;
+    const sessionOutputs = this.session.outputNames ?? Object.keys(results);
+    const wanted = request.outputs && request.outputs.length > 0 ? request.outputs : sessionOutputs;
+    const outputs = {};
+    wanted.forEach((name, i) => {
+      const srcName = sessionOutputs[i] ?? name;
+      const t = results[srcName] ?? results[name];
+      if (t) {
+        outputs[name] = { data: t.data, shape: t.dims.slice() };
+      }
+    });
+    return { outputs, durationMs, providerUsed: this.preferredProvider };
+  }
+  dispose() {
+    if (this.session && typeof this.session.release === "function") {
+      try {
+        void this.session.release();
+      } catch {
+      }
+    }
+    this.session = null;
+    this.ort = null;
+    this.resolvedPath = null;
+    this.loaded = false;
+  }
+  /** The on-disk path the session was created from — diagnostic only. */
+  get loadedModelPath() {
+    return this.resolvedPath;
+  }
+};
+function createOnnxNodeInferenceAdapter(preferredProvider = "cpu") {
+  return new OnnxNodeInferenceAdapter(preferredProvider);
+}
+async function resolveOnnxModelPath(modelUrl) {
+  let fs;
+  let path;
+  try {
+    fs = await import('fs');
+    path = await import('path');
+  } catch {
+    return null;
+  }
+  const exists = (p) => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  };
+  if (!modelUrl.startsWith("bundled://") && exists(modelUrl)) return modelUrl;
+  const id = modelUrl.startsWith("bundled://") ? modelUrl.slice("bundled://".length) : path.basename(modelUrl);
+  const fileName = id.endsWith(".onnx") ? id : `${id}.onnx`;
+  const candidates = [];
+  const envDir = process?.env?.HOLOSCRIPT_MOTION_MODELS_DIR?.trim();
+  if (envDir) candidates.push(path.join(path.resolve(envDir), fileName));
+  let dir = process?.cwd?.() ?? ".";
+  for (let i = 0; i < 8; i++) {
+    candidates.push(path.join(dir, ".models", "motion", fileName));
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return candidates.find(exists) ?? null;
+}
+
+export { BUNDLED_MODEL_SEED, HIDDEN_DIM, NoOpInferenceAdapter, OnnxNodeInferenceAdapter, PHASE_CONTROL_POINTS, PfnnNetwork, PureJsInferenceAdapter, add, createBundledPfnn, createNoOpInferenceAdapter, createOnnxNodeInferenceAdapter, createPureJsInferenceAdapter, createTensor, eluInPlace, matmul, resolveOnnxModelPath };
+//# sourceMappingURL=chunk-FHP6LXJS.js.map
+//# sourceMappingURL=chunk-FHP6LXJS.js.map

package/dist/{chunk-7LCYLPW2.cjs → chunk-FJPADH77.cjs}

@@ -1,5 +1,7 @@
 'use strict';
 
+var chunkE7JP3BS3_cjs = require('./chunk-E7JP3BS3.cjs');
+
 // src/storage/IPFSTypes.ts
 var IPFSUploadError = class extends Error {
   constructor(message, provider, originalError) {
@@ -27,6 +29,7 @@ var FileSizeExceededError = class extends Error {
 };
 
 // src/storage/IPFSProviders.ts
+chunkE7JP3BS3_cjs.init_safeJsonParse();
 var PinataProvider = class {
   constructor(apiKey, apiSecret) {
     this.baseUrl = "https://api.pinata.cloud";
@@ -267,10 +270,10 @@ var InfuraProvider = class {
     }
     const text = await response.text();
     const lines = text.trim().split("\n");
-    const lastLine = JSON.parse(lines[lines.length - 1]);
+    const lastLine = chunkE7JP3BS3_cjs.readJson(lines[lines.length - 1]);
     let totalSize = 0;
     for (const line of lines) {
-      const data = JSON.parse(line);
+      const data = chunkE7JP3BS3_cjs.readJson(line);
       totalSize += data.Size || 0;
     }
     return {
@@ -659,5 +662,5 @@ exports.IPFSUploadError = IPFSUploadError;
 exports.InfuraProvider = InfuraProvider;
 exports.NFTStorageProvider = NFTStorageProvider;
 exports.PinataProvider = PinataProvider;
-//# sourceMappingURL=chunk-7LCYLPW2.cjs.map
-//# sourceMappingURL=chunk-7LCYLPW2.cjs.map
+//# sourceMappingURL=chunk-FJPADH77.cjs.map
+//# sourceMappingURL=chunk-FJPADH77.cjs.map