@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-XJAN7CZG.cjs

@@ -0,0 +1,432 @@
+'use strict';
+
+// 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;
+}
+
+exports.BUNDLED_MODEL_SEED = BUNDLED_MODEL_SEED;
+exports.HIDDEN_DIM = HIDDEN_DIM;
+exports.NoOpInferenceAdapter = NoOpInferenceAdapter;
+exports.OnnxNodeInferenceAdapter = OnnxNodeInferenceAdapter;
+exports.PHASE_CONTROL_POINTS = PHASE_CONTROL_POINTS;
+exports.PfnnNetwork = PfnnNetwork;
+exports.PureJsInferenceAdapter = PureJsInferenceAdapter;
+exports.add = add;
+exports.createBundledPfnn = createBundledPfnn;
+exports.createNoOpInferenceAdapter = createNoOpInferenceAdapter;
+exports.createOnnxNodeInferenceAdapter = createOnnxNodeInferenceAdapter;
+exports.createPureJsInferenceAdapter = createPureJsInferenceAdapter;
+exports.createTensor = createTensor;
+exports.eluInPlace = eluInPlace;
+exports.matmul = matmul;
+exports.resolveOnnxModelPath = resolveOnnxModelPath;
+//# sourceMappingURL=chunk-XJAN7CZG.cjs.map
+//# sourceMappingURL=chunk-XJAN7CZG.cjs.map

package/dist/chunk-XKTPFXGA.js

@@ -0,0 +1,164 @@
+import { init_ProvenanceSemiring, authorityWeight, ProvenanceSemiring } from './chunk-TJHVSBP2.js';
+import { init_AgentRBAC, init_CompilerBase, getRBAC, UnauthorizedCompilerAccessError } from './chunk-QPSKHBJP.js';
+
+// src/compiler/TraitCompositionCompiler.ts
+init_AgentRBAC();
+init_CompilerBase();
+init_ProvenanceSemiring();
+var CompositionConflictError = class extends Error {
+  constructor(traitA, traitB, conflictKey) {
+    super(
+      `Trait composition conflict: "${traitA}" and "${traitB}" both declare conflicting key "${conflictKey}".`
+    );
+    this.traitA = traitA;
+    this.traitB = traitB;
+    this.conflictKey = conflictKey;
+    this.name = "CompositionConflictError";
+  }
+};
+var MissingComponentError = class extends Error {
+  constructor(composedName, missingComponent) {
+    super(
+      `Composition "${composedName}" references unknown component trait "${missingComponent}". Register it in TraitBinder before compiling.`
+    );
+    this.composedName = composedName;
+    this.missingComponent = missingComponent;
+    this.name = "MissingComponentError";
+  }
+};
+var TraitCompositionCompiler = class {
+  constructor(inheritanceResolver) {
+    this.inheritanceResolver = inheritanceResolver;
+  }
+  /**
+   * Set or replace the trait inheritance resolver.
+   * Call this after constructing if the resolver becomes available later.
+   */
+  setInheritanceResolver(resolver) {
+    this.inheritanceResolver = resolver;
+  }
+  /**
+   * Compile a set of composition declarations.
+   *
+   * @param decls         - Declarations to compile.
+   * @param getHandler    - Lookup a component handler by name.
+   * @param traitGraph    - Optional TraitDependencyGraph; if supplied, new
+   *                        composed traits are registered there.
+   * @param agentToken    - JWT token proving agent identity (optional for backwards compatibility).
+   * @returns Compiled ComposedTraitDef[], in declaration order.
+   * @throws UnauthorizedTraitCompositionAccessError if token is provided but invalid.
+   */
+  compile(decls, getHandler, traitGraph, agentToken) {
+    this.validateAccess(agentToken);
+    return decls.map((decl) => this.compileOne(decl, getHandler, traitGraph));
+  }
+  // ---------------------------------------------------------------------------
+  // RBAC enforcement
+  // ---------------------------------------------------------------------------
+  /**
+   * Validate agent has permission to compile trait compositions.
+   * Skips validation when no token is provided (backwards compatibility / testing).
+   */
+  validateAccess(agentToken) {
+    if (!agentToken) return;
+    const rbac = getRBAC();
+    const decision = rbac.checkAccess({
+      token: agentToken,
+      resourceType: "ast" /* AST */,
+      operation: "read",
+      expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
+    });
+    if (!decision.allowed) {
+      throw new UnauthorizedTraitCompositionAccessError(decision, "TraitCompositionCompiler");
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  compileOne(decl, getHandler, traitGraph) {
+    const handlers = decl.components.map((name) => {
+      const handler = getHandler(name);
+      if (!handler) throw new MissingComponentError(decl.name, name);
+      return { name, handler };
+    });
+    if (authorityWeight(
+      decl.provenance?.context?.authorityLevel ?? 0
+    ) < 100) {
+      this.detectConflicts(handlers);
+    }
+    const semiring = new ProvenanceSemiring();
+    const applications = [];
+    for (const { name, handler } of handlers) {
+      let configAccumulator = {};
+      if (this.inheritanceResolver && this.inheritanceResolver.hasTrait(name)) {
+        const resolvedProps = this.inheritanceResolver.getFlattenedProperties(name);
+        configAccumulator = { ...resolvedProps };
+      }
+      if (handler.defaultConfig) {
+        configAccumulator = { ...configAccumulator, ...handler.defaultConfig };
+      }
+      applications.push({ name, config: configAccumulator });
+    }
+    if (decl.overrides) {
+      applications.push({
+        name: `${decl.name}_overrides`,
+        config: decl.overrides,
+        context: { authorityLevel: Number.MAX_SAFE_INTEGER }
+        // Overrides always win!
+      });
+    }
+    const { config: merged, errors } = semiring.add(applications);
+    if (errors.length > 0) {
+      const match = errors[0].match(/Composition conflict: @(.+) and @(.+) both supply '(.+)'/);
+      if (match) {
+        throw new CompositionConflictError(match[1], match[2], match[3]);
+      } else {
+        throw new CompositionConflictError("Merge", "Failure", errors[0]);
+      }
+    }
+    if (this.inheritanceResolver && decl.components.length > 1) {
+      const diamonds = this.inheritanceResolver.detectDiamondInheritance(decl.components);
+      for (const diamond of diamonds) {
+      }
+    }
+    if (traitGraph) {
+      traitGraph.registerTrait({
+        name: decl.name,
+        requires: decl.components,
+        conflicts: []
+      });
+    }
+    return {
+      name: decl.name,
+      components: decl.components,
+      defaultConfig: merged
+    };
+  }
+  /**
+   * Naive conflict check: if handler A's `conflicts` array includes handler B's
+   * name (or vice-versa), throw.
+   */
+  detectConflicts(handlers) {
+    for (let i = 0; i < handlers.length; i++) {
+      const a = handlers[i];
+      const aConflicts = a.handler.conflicts ?? [];
+      for (let j = i + 1; j < handlers.length; j++) {
+        const b = handlers[j];
+        const bConflicts = b.handler.conflicts ?? [];
+        if (aConflicts.includes(b.name) || bConflicts.includes(a.name)) {
+          throw new CompositionConflictError(a.name, b.name, b.name);
+        }
+      }
+    }
+  }
+};
+var UnauthorizedTraitCompositionAccessError = class extends UnauthorizedCompilerAccessError {
+  constructor(decision, compilerName) {
+    super(decision, "trait composition", compilerName);
+    this.name = "UnauthorizedTraitCompositionAccessError";
+  }
+};
+
+export { CompositionConflictError, MissingComponentError, TraitCompositionCompiler, UnauthorizedTraitCompositionAccessError };
+//# sourceMappingURL=chunk-XKTPFXGA.js.map
+//# sourceMappingURL=chunk-XKTPFXGA.js.map