@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-TVHSPJ4N.cjs

@@ -0,0 +1,606 @@
+'use strict';
+
+var chunkILRBGFVD_cjs = require('./chunk-ILRBGFVD.cjs');
+
+// src/traits/MitosisTrait.ts
+var mitosisHandler = {
+  name: "mitosis",
+  defaultConfig: {
+    strategy: "collaborative",
+    max_children: 5,
+    auto_cleanup: true
+  },
+  onAttach(node, config, context) {
+    const state = {
+      parent_id: ("parent_id" in config ? config.parent_id : null) || null,
+      active_children: [],
+      tasks_delegated: 0,
+      completed_tasks: 0,
+      last_sync_time: Date.now()
+    };
+    node.__mitosisState = state;
+    context.emit?.("mitosis_init", {
+      nodeId: node.id,
+      strategy: config.strategy,
+      parent_id: state.parent_id
+    });
+  },
+  onDetach(node, config, context) {
+    const state = node.__mitosisState;
+    if (state && config.auto_cleanup) {
+      for (const childId of state.active_children) {
+        context.emit?.("mitosis_despawn_child", { childId });
+      }
+    }
+    delete node.__mitosisState;
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__mitosisState;
+    if (!state) return;
+    if (event.type === "mitosis_spawned") {
+      const childId = event.childId;
+      const parentId = event.parentId;
+      if (node.id === parentId) {
+        state.active_children.push(childId);
+        state.tasks_delegated++;
+        context.emit?.("on_mitosis_spawned", { childId, parentId: node.id });
+      }
+    } else if (event.type === "mitosis_child_complete") {
+      const childId = "childId" in event ? event.childId : "";
+      const parentId = "parentId" in event ? event.parentId : "";
+      const result = "result" in event ? event.result : void 0;
+      if (node.id === parentId) {
+        state.completed_tasks++;
+        state.last_sync_time = Date.now();
+        context.emit?.("mitosis_synced", {
+          parentId: node.id,
+          childId,
+          result
+        });
+        if (config.strategy === "collaborative") {
+          if (result && typeof result === "object") {
+            Object.assign(node.properties || {}, result);
+          }
+        }
+      }
+    } else if (event.type === "mitosis_child_failed") {
+      context.emit?.("on_mitosis_error", {
+        parentId: node.id,
+        childId: event.childId,
+        error: event.error
+      });
+    }
+  }
+};
+
+// src/traits/JEPAPredictor.ts
+var JEPAPredictor = class {
+  constructor(config, weights) {
+    if (!Number.isInteger(config.latentDim) || config.latentDim < 1) {
+      throw new RangeError(`JEPAPredictor: latentDim must be a positive integer, got ${config.latentDim}`);
+    }
+    if (!Number.isInteger(config.condDim) || config.condDim < 0) {
+      throw new RangeError(`JEPAPredictor: condDim must be a non-negative integer, got ${config.condDim}`);
+    }
+    this.latentDim = config.latentDim;
+    this.condDim = config.condDim;
+    this.weights = weights ?? initDeterministicWeights(config.latentDim, config.condDim);
+  }
+  /**
+   * Forward pass: predict next-state embedding.
+   *
+   * @param contextEmb  Float32Array of length latentDim (context encoder output)
+   * @param conditioning Float32Array of length condDim, or null/undefined for
+   *                      unconditional prediction
+   */
+  forward(contextEmb, conditioning) {
+    const { latentDim, condDim } = this;
+    const inputDim = latentDim + condDim;
+    if (contextEmb.length !== latentDim) {
+      throw new RangeError(
+        `JEPAPredictor.forward: contextEmb.length=${contextEmb.length} \u2260 latentDim=${latentDim}`
+      );
+    }
+    const input = new Float32Array(inputDim);
+    input.set(contextEmb, 0);
+    if (condDim > 0) {
+      const cond = conditioning ?? new Float32Array(condDim);
+      if (cond.length !== condDim) {
+        throw new RangeError(
+          `JEPAPredictor.forward: conditioning.length=${cond.length} \u2260 condDim=${condDim}`
+        );
+      }
+      input.set(cond, latentDim);
+    }
+    const hidden = matMulVec(this.weights.W1, input, inputDim, latentDim);
+    addInPlace(hidden, this.weights.b1);
+    reluInPlace(hidden);
+    const predicted = matMulVec(this.weights.W2, hidden, latentDim, latentDim);
+    addInPlace(predicted, this.weights.b2);
+    return { predicted, hidden };
+  }
+  /**
+   * Replace weights (e.g. after an external training step or gradient update).
+   * Does NOT implement EMA — callers manage weight schedule externally.
+   */
+  setWeights(weights) {
+    validateWeights(weights, this.latentDim, this.condDim);
+    this.weights = weights;
+  }
+  /** Read-only access to current weights for serialisation. */
+  getWeights() {
+    return this.weights;
+  }
+  /**
+   * Plan: given a context state string and a list of candidate action names,
+   * return the action predicted to yield the highest-confidence next-state
+   * embedding (lowest L2 norm from the current state embedding — a proxy for
+   * "least surprising / most on-manifold" outcome).
+   *
+   * Encoding strategy: deterministic text→float32 hash (same technique used
+   * in JEPAObjective.encodeContext — no async/LLM dependency at plan time).
+   *
+   * @param currentState  Snapshot string of the agent's current state.
+   * @param candidateActions  Non-empty list of action name strings to score.
+   * @returns The action name with the highest predicted confidence, plus its
+   *          predicted embedding for downstream SimulationContract verification.
+   */
+  plan(currentState, candidateActions) {
+    if (candidateActions.length === 0) {
+      throw new RangeError("JEPAPredictor.plan: candidateActions must be non-empty");
+    }
+    const contextEmb = textToEmbedding(currentState, this.latentDim);
+    let bestAction = candidateActions[0];
+    let bestPredicted = new Float32Array(this.latentDim);
+    let bestConfidence = -Infinity;
+    for (const action of candidateActions) {
+      const conditioning = this.condDim > 0 ? textToEmbedding(action, this.condDim) : null;
+      const { predicted } = this.forward(contextEmb, conditioning);
+      const confidence = -l2Norm(predicted);
+      if (confidence > bestConfidence) {
+        bestConfidence = confidence;
+        bestAction = action;
+        bestPredicted = predicted;
+      }
+    }
+    return { action: bestAction, predicted: bestPredicted, confidence: bestConfidence };
+  }
+};
+function matMulVec(matrix, vec, inputDim, outputDim) {
+  const out = new Float32Array(outputDim);
+  for (let i = 0; i < outputDim; i++) {
+    let acc = 0;
+    const base = i * inputDim;
+    for (let j = 0; j < inputDim; j++) {
+      acc += matrix[base + j] * vec[j];
+    }
+    out[i] = acc;
+  }
+  return out;
+}
+function addInPlace(a, b) {
+  for (let i = 0; i < a.length; i++) {
+    a[i] += b[i];
+  }
+}
+function reluInPlace(a) {
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] < 0) a[i] = 0;
+  }
+}
+function initDeterministicWeights(latentDim, condDim) {
+  const inputDim = latentDim + condDim;
+  const scale1 = Math.sqrt(2 / inputDim);
+  const scale2 = Math.sqrt(2 / latentDim);
+  const W1 = new Float32Array(inputDim * latentDim);
+  const b1 = new Float32Array(latentDim);
+  const W2 = new Float32Array(latentDim * latentDim);
+  const b2 = new Float32Array(latentDim);
+  let seed = 3735928559;
+  const lcg = () => {
+    seed = Math.imul(seed, 1664525) + 1013904223;
+    return (seed >>> 0) / 4294967296 * 2 - 1;
+  };
+  for (let i = 0; i < W1.length; i++) W1[i] = lcg() * scale1;
+  for (let i = 0; i < W2.length; i++) W2[i] = lcg() * scale2;
+  return { W1, b1, W2, b2 };
+}
+function textToEmbedding(text, dim) {
+  const out = new Float32Array(dim);
+  let h = 5381;
+  for (let i = 0; i < text.length; i++) {
+    h = Math.imul(h, 33) ^ text.charCodeAt(i);
+    h = h >>> 0;
+  }
+  for (let d = 0; d < dim; d++) {
+    h = Math.imul(h, 1664525) + 1013904223;
+    h = h >>> 0;
+    out[d] = h / 4294967296 * 2 - 1;
+  }
+  return out;
+}
+function l2Norm(v) {
+  let sum = 0;
+  for (let i = 0; i < v.length; i++) sum += v[i] * v[i];
+  return Math.sqrt(sum);
+}
+function validateWeights(w, latentDim, condDim) {
+  const inputDim = latentDim + condDim;
+  const expected = {
+    W1: inputDim * latentDim,
+    b1: latentDim,
+    W2: latentDim * latentDim,
+    b2: latentDim
+  };
+  for (const key of ["W1", "b1", "W2", "b2"]) {
+    if (w[key].length !== expected[key]) {
+      throw new RangeError(
+        `JEPAPredictor: weights.${key}.length=${w[key].length} \u2260 expected ${expected[key]}`
+      );
+    }
+  }
+}
+
+// src/traits/EmbeddingTrait.ts
+var embeddingHandler = {
+  name: "embedding",
+  defaultConfig: { default_model: "text-embedding-3-small", default_dimensions: 1536 },
+  onAttach(node) {
+    node.__embeddingState = { generated: 0 };
+  },
+  onDetach(node) {
+    delete node.__embeddingState;
+  },
+  onUpdate() {
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__embeddingState;
+    if (!state) return;
+    if ((typeof event === "string" ? event : event.type) === "embedding:generate") {
+      state.generated++;
+      const dims = resolveEmbeddingDimensions(event, config);
+      const model = event.model ?? config.default_model;
+      const input = event.input ?? event.payload?.input ?? "";
+      context.emit?.("embedding:result", {
+        vector: createDeterministicEmbedding(input, dims, model),
+        dimensions: dims,
+        model,
+        source: "local-deterministic-fallback",
+        index: state.generated
+      });
+    }
+  }
+};
+function resolveEmbeddingDimensions(event, config) {
+  const rawDimensions = event.dimensions ?? event.payload?.dimensions;
+  const dimensions = typeof rawDimensions === "number" ? rawDimensions : config.default_dimensions;
+  if (!Number.isFinite(dimensions) || dimensions <= 0) {
+    return Math.max(1, Math.floor(config.default_dimensions));
+  }
+  return Math.floor(dimensions);
+}
+function createDeterministicEmbedding(input, dimensions, model) {
+  const vector = new Float32Array(dimensions);
+  const text = stringifyEmbeddingInput(input);
+  const features = extractEmbeddingFeatures(text);
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i];
+    const hash = fnv1a(`${model}\0${feature}\0${i}`);
+    const index = hash % dimensions;
+    const sign = hash & 1 ? 1 : -1;
+    const weight = 1 + Math.log1p(feature.length);
+    vector[index] += sign * weight;
+  }
+  normalizeVector(vector);
+  return vector;
+}
+function stringifyEmbeddingInput(input) {
+  if (typeof input === "string") return input;
+  if (input === null || input === void 0) return "";
+  try {
+    return JSON.stringify(input);
+  } catch {
+    return String(input);
+  }
+}
+function extractEmbeddingFeatures(text) {
+  const normalized = text.trim().toLowerCase();
+  if (!normalized) return ["<empty>"];
+  const tokens = normalized.match(/[a-z0-9_:-]+/g) ?? [normalized];
+  const features = [...tokens, `len:${normalized.length}`];
+  for (const token of tokens) {
+    if (token.length <= 3) {
+      features.push(`tok:${token}`);
+      continue;
+    }
+    for (let i = 0; i <= token.length - 3; i++) {
+      features.push(`tri:${token.slice(i, i + 3)}`);
+    }
+  }
+  return features;
+}
+function normalizeVector(vector) {
+  let normSquared = 0;
+  for (const value of vector) {
+    normSquared += value * value;
+  }
+  if (normSquared === 0) {
+    vector[0] = 1;
+    return;
+  }
+  const norm = Math.sqrt(normSquared);
+  for (let i = 0; i < vector.length; i++) {
+    vector[i] = vector[i] / norm;
+  }
+}
+function fnv1a(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+// src/traits/JEPAObjective.ts
+var jepObjectiveHandler = {
+  name: "jepa_objective",
+  defaultConfig: {
+    latentDim: 128,
+    condDim: 0,
+    sigregWeight: 0.05,
+    sigregProjections: 64,
+    sigregSigma: 1,
+    embeddingModel: "jepa-context-encoder"
+  },
+  onAttach(node, config) {
+    const predictorConfig = {
+      latentDim: config.latentDim,
+      condDim: config.condDim
+    };
+    node.__jepaState = {
+      step: 0,
+      predictor: new JEPAPredictor(predictorConfig),
+      embeddingConfig: {
+        default_model: config.embeddingModel,
+        default_dimensions: config.latentDim
+      },
+      pendingContextEmb: null
+    };
+  },
+  onDetach(node) {
+    delete node.__jepaState;
+  },
+  onUpdate() {
+  },
+  onEvent(node, config, context, event) {
+    const state = node.__jepaState;
+    if (!state) return;
+    const eventType = typeof event === "string" ? event : event.type;
+    if (eventType === "jepa:update_weights") {
+      handleWeightUpdate(state, context, event);
+      return;
+    }
+    if (eventType !== "jepa:encode_pair") return;
+    state.step++;
+    const step = state.step;
+    const contextStr = readString(event.context);
+    if (!contextStr) {
+      emitError(context, { code: "JEPA_CONTEXT_REQUIRED", message: "jepa:encode_pair requires a non-empty context string", step });
+      return;
+    }
+    const targetVec = toFloat32Array(event.targetVec);
+    if (!targetVec) {
+      emitError(context, { code: "JEPA_TARGET_VEC_REQUIRED", message: "jepa:encode_pair requires targetVec (Float32Array or number[])", step });
+      return;
+    }
+    if (targetVec.length !== config.latentDim) {
+      emitError(context, {
+        code: "JEPA_TARGET_DIM_MISMATCH",
+        message: `targetVec.length=${targetVec.length} \u2260 latentDim=${config.latentDim}`,
+        step
+      });
+      return;
+    }
+    const contextEmb = encodeContext(state, config, contextStr);
+    if (!contextEmb) {
+      emitError(context, { code: "JEPA_ENCODE_FAILED", message: "Context encoding returned null vector", step });
+      return;
+    }
+    const conditioning = toFloat32ArrayOrNull(event.conditioning);
+    const { predicted } = state.predictor.forward(contextEmb, conditioning);
+    const predictionLoss = mseLoss(predicted, targetVec);
+    const sigregLoss = computeSIGReg(
+      predicted,
+      config.sigregProjections,
+      config.sigregSigma
+    );
+    const totalLoss = predictionLoss + config.sigregWeight * sigregLoss;
+    context.emit?.("jepa:loss", {
+      predictionLoss,
+      sigregLoss,
+      totalLoss,
+      step,
+      predicted
+    });
+  }
+};
+function encodeContext(state, config, contextStr) {
+  let result = null;
+  const captureContext = {
+    vr: null,
+    physics: null,
+    audio: null,
+    haptics: null,
+    emit(eventName, payload) {
+      if (eventName === "embedding:result") {
+        const p = payload;
+        const v = p.vector;
+        if (v instanceof Float32Array) result = v;
+      }
+    },
+    getState: () => ({}),
+    setState: () => {
+    },
+    getScaleMultiplier: () => 1,
+    setScaleContext: () => {
+    }
+  };
+  const mockNode = {};
+  embeddingHandler.onAttach?.(mockNode, state.embeddingConfig, captureContext);
+  embeddingHandler.onEvent?.(
+    mockNode,
+    state.embeddingConfig,
+    captureContext,
+    {
+      type: "embedding:generate",
+      input: contextStr,
+      model: config.embeddingModel,
+      dimensions: config.latentDim
+    }
+  );
+  embeddingHandler.onDetach?.(mockNode, state.embeddingConfig, captureContext);
+  return result;
+}
+function computeSIGReg(z, numProjections, sigma) {
+  const dim = z.length;
+  const sigmaSquared = sigma * sigma;
+  let total = 0;
+  let seed = 3405648436;
+  const lcg = () => {
+    seed = Math.imul(seed, 1664525) + 1013904223;
+    return (seed >>> 0) / 4294967296 * 2 - 1;
+  };
+  const gaussianPair = () => {
+    const u1 = Math.max(1e-12, (lcg() + 1) / 2);
+    const u2 = (lcg() + 1) / 2;
+    const r = Math.sqrt(-2 * Math.log(u1));
+    const theta = 2 * Math.PI * u2;
+    return [r * Math.cos(theta), r * Math.sin(theta)];
+  };
+  for (let p = 0; p < numProjections; p++) {
+    let dot = 0;
+    for (let i = 0; i < dim; i += 2) {
+      const [g1, g2] = gaussianPair();
+      const scale = 1 / Math.sqrt(dim);
+      dot += z[i] * (g1 * scale);
+      if (i + 1 < dim) dot += z[i + 1] * (g2 * scale);
+    }
+    const proj2 = dot * dot;
+    const ratio = proj2 / sigmaSquared;
+    if (ratio > 0) {
+      total += ratio - 1 - Math.log(ratio);
+    } else {
+      total += 1;
+    }
+  }
+  return total / numProjections;
+}
+function handleWeightUpdate(state, context, event) {
+  try {
+    state.predictor.setWeights({
+      W1: requireFloat32(event.W1, "W1"),
+      b1: requireFloat32(event.b1, "b1"),
+      W2: requireFloat32(event.W2, "W2"),
+      b2: requireFloat32(event.b2, "b2")
+    });
+  } catch (err) {
+    emitError(context, {
+      code: "JEPA_WEIGHTS_INVALID",
+      message: err instanceof Error ? err.message : String(err),
+      step: state.step
+    });
+  }
+}
+function mseLoss(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const diff = a[i] - b[i];
+    sum += diff * diff;
+  }
+  return sum / a.length;
+}
+function emitError(context, payload) {
+  context.emit?.("jepa:error", payload);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function toFloat32Array(value) {
+  if (value instanceof Float32Array) return value;
+  if (Array.isArray(value) && value.every((v) => typeof v === "number")) {
+    return new Float32Array(value);
+  }
+  return null;
+}
+function toFloat32ArrayOrNull(value) {
+  if (value == null) return null;
+  return toFloat32Array(value);
+}
+function requireFloat32(value, name) {
+  if (value instanceof Float32Array) return value;
+  throw new TypeError(`jepa:update_weights: ${name} must be a Float32Array`);
+}
+
+// src/traits/OrbitalTrait.ts
+var _orbital = null;
+var orbitalHandler = {
+  name: "orbital",
+  defaultConfig: {},
+  /**
+   * Called when trait is attached to a node
+   */
+  onAttach(node, _config, _context) {
+    chunkILRBGFVD_cjs.logger.info(`[OrbitalTrait] Attached to ${node.name}`);
+  },
+  /**
+   * Called every frame to update orbital position
+   */
+  async onUpdate(node, config, context, _delta) {
+    const properties = node.properties || {};
+    const mergedConfig = { ...properties, ...config };
+    if (!mergedConfig || !mergedConfig.semiMajorAxis) {
+      return;
+    }
+    _orbital ?? (_orbital = await import('@holoscript/engine/orbital'));
+    const { calculatePosition } = _orbital;
+    const julianDate = context.julianDate || 0;
+    const visualScale = context.getScaleMultiplier() * 50;
+    const satelliteScale = 5;
+    const rawPosition = calculatePosition(mergedConfig, julianDate);
+    const currentScale = mergedConfig.parent ? visualScale * satelliteScale : visualScale;
+    let finalPosition = [
+      rawPosition[0] * currentScale,
+      rawPosition[2] * currentScale,
+      rawPosition[1] * currentScale
+    ];
+    if (mergedConfig.parent) {
+      let parentNode = context.getNode?.(mergedConfig.parent);
+      if (!parentNode && typeof mergedConfig.parent === "object" && mergedConfig.parent && mergedConfig.parent.position) {
+        parentNode = mergedConfig.parent;
+      }
+      if (parentNode && parentNode.position) {
+        finalPosition = [
+          finalPosition[0] + (parentNode.position[0] || 0),
+          finalPosition[1] + (parentNode.position[1] || 0),
+          finalPosition[2] + (parentNode.position[2] || 0)
+        ];
+      } else {
+        if (typeof mergedConfig.parent === "string") {
+          chunkILRBGFVD_cjs.logger.warn(`[OrbitalTrait] Parent "${mergedConfig.parent}" not found for ${node.name}`);
+        }
+      }
+    }
+    const posArray = [finalPosition[0], finalPosition[1], finalPosition[2]];
+    node.position = posArray;
+    context.emit("position_update", { position: posArray });
+  }
+};
+
+exports.JEPAPredictor = JEPAPredictor;
+exports.embeddingHandler = embeddingHandler;
+exports.jepObjectiveHandler = jepObjectiveHandler;
+exports.mitosisHandler = mitosisHandler;
+exports.orbitalHandler = orbitalHandler;
+//# sourceMappingURL=chunk-TVHSPJ4N.cjs.map
+//# sourceMappingURL=chunk-TVHSPJ4N.cjs.map