@holoscript/core 7.0.0 → 8.0.0

package/dist/traits/engines/index.js

@@ -0,0 +1,380 @@
+import { TRAJECTORY_HORIZON_FRAMES, projectLinearTrajectory, magnitude } from '../../chunk-IVY74O6C.js';
+export { MOTION_DATA_SCHEMA_VERSION, NullMotionMatchingEngine, SYNTHETIC_WALK_JOINTS, SyntheticWalkCycleEngine, TRAJECTORY_FRAME_DT, TRAJECTORY_HORIZON_FRAMES, buildSyntheticBipedPose, classifyGait, createNullMotionMatchingEngine, createSyntheticWalkCycleEngine, inferenceFrameToTensor, magnitude, projectLinearTrajectory, validateMotionCapture, validateTrainingCorpus, validateTrainingFrame } from '../../chunk-IVY74O6C.js';
+import { createPureJsInferenceAdapter } from '../../chunk-FHP6LXJS.js';
+export { BUNDLED_MODEL_SEED, HIDDEN_DIM, NoOpInferenceAdapter, OnnxNodeInferenceAdapter, PHASE_CONTROL_POINTS, PfnnNetwork, PureJsInferenceAdapter, add, createBundledPfnn, createNoOpInferenceAdapter, createOnnxNodeInferenceAdapter, createPureJsInferenceAdapter, createTensor, eluInPlace, matmul, resolveOnnxModelPath } from '../../chunk-FHP6LXJS.js';
+import '../../chunk-OL46QLBJ.js';
+
+// src/traits/engines/onnx-motion-matching.ts
+var TRAJ_SAMPLES = 12;
+var TRAJ_FEATURES_PER_SAMPLE = 5;
+var PHASE_CHANNELS = 4;
+var CORE_INPUT_DIM = 7;
+var INPUT_DIM = CORE_INPUT_DIM + TRAJ_SAMPLES * TRAJ_FEATURES_PER_SAMPLE + PHASE_CHANNELS;
+var OUTPUT_DIM = TRAJECTORY_HORIZON_FRAMES * 3 + PHASE_CHANNELS + 4 + 1 + 5;
+var SHARED_OUTPUT_DIM = OUTPUT_DIM;
+var BUNDLED_MODELS = {
+  biped_humanoid_v2: {
+    id: "biped_humanoid_v2",
+    label: "Biped Humanoid v2 (PFNN, Holden 2017)",
+    skeletonType: "biped",
+    jointCount: 24,
+    inputDim: INPUT_DIM,
+    outputDim: SHARED_OUTPUT_DIM,
+    modelUrl: "bundled://biped_humanoid_v2.onnx"
+  },
+  quadruped_dog_v2: {
+    id: "quadruped_dog_v2",
+    label: "Quadruped Dog v2 (4-contact PFNN)",
+    skeletonType: "quadruped",
+    jointCount: 28,
+    inputDim: INPUT_DIM,
+    outputDim: SHARED_OUTPUT_DIM,
+    modelUrl: "bundled://quadruped_dog_v2.onnx"
+  }
+};
+var BIPED_JOINTS = [
+  "root",
+  "pelvis",
+  "spine_01",
+  "spine_02",
+  "spine_03",
+  "neck_01",
+  "head",
+  "clavicle_l",
+  "upper_arm_l",
+  "lower_arm_l",
+  "hand_l",
+  "clavicle_r",
+  "upper_arm_r",
+  "lower_arm_r",
+  "hand_r",
+  "thigh_l",
+  "calf_l",
+  "foot_l",
+  "ball_l",
+  "thigh_r",
+  "calf_r",
+  "foot_r",
+  "ball_r",
+  "center_of_mass"
+];
+var QUADRUPED_JOINTS = [
+  "root",
+  "spine_01",
+  "spine_02",
+  "spine_03",
+  "neck_01",
+  "head",
+  "front_upper_arm_l",
+  "front_lower_arm_l",
+  "front_foot_l",
+  "front_upper_arm_r",
+  "front_lower_arm_r",
+  "front_foot_r",
+  "rear_thigh_l",
+  "rear_calf_l",
+  "rear_foot_l",
+  "rear_thigh_r",
+  "rear_calf_r",
+  "rear_foot_r",
+  "tail_01",
+  "tail_02",
+  "tail_03",
+  "front_left_toe",
+  "front_right_toe",
+  "rear_left_toe",
+  "rear_right_toe",
+  "center_of_mass",
+  "jaw",
+  "left_ear"
+];
+function encodeInputTensor(input) {
+  const data = new Float32Array(INPUT_DIM);
+  let offset = 0;
+  data[offset++] = input.targetVelocity.x;
+  data[offset++] = input.targetVelocity.y;
+  data[offset++] = input.targetVelocity.z;
+  const tn = input.terrainNormal ?? { x: 0, y: 1, z: 0 };
+  data[offset++] = tn.x;
+  data[offset++] = tn.y;
+  data[offset++] = tn.z;
+  data[offset++] = input.energyEfficiency ?? 1;
+  const trajectory = projectLinearTrajectory(input.targetVelocity);
+  const speed = magnitude(input.targetVelocity);
+  const velDir = speed > 1e-6 ? { x: input.targetVelocity.x / speed, z: input.targetVelocity.z / speed } : { x: 0, z: 0 };
+  for (let i = 0; i < TRAJ_SAMPLES; i++) {
+    const pt = trajectory[i] ?? [0, 0, 0];
+    data[offset++] = pt[0];
+    data[offset++] = pt[2];
+    data[offset++] = velDir.x;
+    data[offset++] = velDir.z;
+    const phaseLinear = (input.currentPhase + (i + 1) * 0.04) % 1;
+    data[offset++] = phaseLinear;
+  }
+  const p = input.currentPhase * 2 * Math.PI;
+  data[offset++] = Math.sin(p);
+  data[offset++] = Math.cos(p);
+  data[offset++] = Math.sin(2 * p);
+  data[offset++] = Math.cos(2 * p);
+  return { data, shape: [1, INPUT_DIM] };
+}
+var GAIT_LABELS = [
+  "idle",
+  "walk",
+  "trot",
+  "run",
+  "crouch"
+];
+function decodeOutputTensor(output, skeletonType, prevPhase) {
+  const d = output.data;
+  const trajectory = [];
+  for (let i = 0; i < TRAJECTORY_HORIZON_FRAMES; i++) {
+    trajectory.push([d[i * 3] ?? 0, d[i * 3 + 1] ?? 0, d[i * 3 + 2] ?? 0]);
+  }
+  const phaseBase = 36;
+  const sinP = d[phaseBase] ?? 0;
+  const cosP = d[phaseBase + 1] ?? 1;
+  const rawPhase = (Math.atan2(sinP, cosP) / (2 * Math.PI) + 1) % 1;
+  const maxAdvance = 0.15;
+  const delta = (rawPhase - prevPhase + 1) % 1;
+  const phase = (prevPhase + Math.min(delta, maxAdvance)) % 1;
+  const contactBase = 40;
+  const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+  const lf = sigmoid(d[contactBase] ?? 0) > 0.5;
+  const rf = sigmoid(d[contactBase + 1] ?? 0) > 0.5;
+  const lh = sigmoid(d[contactBase + 2] ?? 0) > 0.5;
+  const rh = sigmoid(d[contactBase + 3] ?? 0) > 0.5;
+  const contactFeatures = { leftFoot: lf, rightFoot: rf };
+  if (skeletonType === "quadruped") {
+    contactFeatures["leftHand"] = lh;
+    contactFeatures["rightHand"] = rh;
+  }
+  const stability = Math.max(0, Math.min(1, sigmoid(d[44] ?? 2)));
+  let maxLogit = -Infinity;
+  let gaitIdx = 0;
+  for (let i = 0; i < 5; i++) {
+    const logit = d[45 + i] ?? 0;
+    if (logit > maxLogit) {
+      maxLogit = logit;
+      gaitIdx = i;
+    }
+  }
+  const gait = GAIT_LABELS[gaitIdx] ?? "idle";
+  const joints = {};
+  const names = skeletonType === "biped" ? BIPED_JOINTS : QUADRUPED_JOINTS;
+  for (const name of names) {
+    joints[name] = { position: [0, 0, 0], rotation: [0, 0, 0, 1] };
+  }
+  return {
+    pose: { joints, timestamp: Date.now() },
+    phase,
+    trajectory,
+    stability,
+    contactFeatures,
+    gait,
+    kineticEnergyProxy: 0
+  };
+}
+var OnnxMotionMatchingEngine = class {
+  constructor(modelId, options = {}) {
+    this.loaded = false;
+    this._phase = 0;
+    this.modelId = modelId;
+    const desc = BUNDLED_MODELS[modelId];
+    if (!desc) {
+      throw new Error(
+        `OnnxMotionMatchingEngine: unknown modelId "${modelId}". Available: ${Object.keys(BUNDLED_MODELS).join(", ")}`
+      );
+    }
+    this.descriptor = desc;
+    this.adapter = options.adapter ?? createPureJsInferenceAdapter(desc.inputDim, desc.outputDim);
+  }
+  async load() {
+    await this.adapter.load(this.descriptor.modelUrl);
+    this.loaded = true;
+    this._phase = 0;
+  }
+  infer(input) {
+    if (!this.loaded) {
+      throw new Error(`OnnxMotionMatchingEngine(${this.modelId}): call load() before infer()`);
+    }
+    const inputTensor = encodeInputTensor(input);
+    const outputTensor = this._runSync(inputTensor);
+    const result = decodeOutputTensor(outputTensor, this.descriptor.skeletonType, this._phase);
+    this._phase = result.phase;
+    return result;
+  }
+  /**
+   * Async inference path — use when the adapter is WebGPU/ONNX Runtime Web.
+   * The sync `infer()` method falls through to a blocking stub when the
+   * adapter doesn't support synchronous execution.
+   */
+  async inferAsync(input) {
+    if (!this.loaded) {
+      throw new Error(`OnnxMotionMatchingEngine(${this.modelId}): call load() before inferAsync()`);
+    }
+    const inputTensor = encodeInputTensor(input);
+    const response = await this.adapter.run({
+      inputs: { motion_input: inputTensor },
+      outputs: ["motion_output"]
+    });
+    const outputTensor = response.outputs["motion_output"] ?? {
+      data: new Float32Array(OUTPUT_DIM)};
+    const result = decodeOutputTensor(outputTensor, this.descriptor.skeletonType, this._phase);
+    this._phase = result.phase;
+    return result;
+  }
+  dispose() {
+    this.adapter.dispose();
+    this.loaded = false;
+    this._phase = 0;
+  }
+  // ── private helpers ─────────────────────────────────────────────────────
+  /**
+   * Synchronous forward pass.
+   *
+   * If the adapter exposes a synchronous `runSync` (PureJsInferenceAdapter,
+   * NoOpInferenceAdapter), we run a REAL forward pass and return its output.
+   * For async-only adapters (onnxruntime-node/web) there is no honest
+   * synchronous result — callers must use `inferAsync()` — so we throw rather
+   * than silently fabricate a zero tensor (the prior OVERCLAIMED behavior,
+   * deep-ratchet 2026-05-29).
+   */
+  _runSync(inputTensor) {
+    if (typeof this.adapter.runSync === "function") {
+      const response = this.adapter.runSync({
+        inputs: { motion_input: inputTensor },
+        outputs: ["motion_output"]
+      });
+      return response.outputs["motion_output"] ?? {
+        data: new Float32Array(OUTPUT_DIM),
+        shape: [1, OUTPUT_DIM]
+      };
+    }
+    throw new Error(
+      `OnnxMotionMatchingEngine(${this.modelId}): adapter "${this.adapter.name}" has no synchronous run path. Use inferAsync() with this adapter, or inject a synchronous adapter (PureJsInferenceAdapter) for infer().`
+    );
+  }
+};
+async function batchInferAsync(engine, batch) {
+  const start = performance.now();
+  const results = await Promise.all(batch.agents.map((a) => engine.inferAsync(a)));
+  const batchMs = performance.now() - start;
+  return { results, batchMs, agentCount: batch.agents.length };
+}
+async function createOnnxMotionMatchingEngine(modelId, options = {}) {
+  const engine = new OnnxMotionMatchingEngine(modelId, options);
+  await engine.load();
+  return engine;
+}
+function listBundledModels() {
+  return Object.values(BUNDLED_MODELS);
+}
+
+// src/traits/engines/noise.ts
+function noise(t, seed) {
+  const n = Math.sin(t * 12.9898 + seed * 78.233) * 43758.5453;
+  return (n - Math.floor(n)) * 2 - 1;
+}
+function smoothNoise(t, seed) {
+  const floor = Math.floor(t);
+  const frac = t - floor;
+  const smooth = frac * frac * (3 - 2 * frac);
+  return noise(floor, seed) + smooth * (noise(floor + 1, seed) - noise(floor, seed));
+}
+
+// src/traits/engines/cloth-verlet.ts
+function buildClothConstraints(resolution, positions) {
+  const constraints = [];
+  for (let i = 0; i < resolution; i++) {
+    for (let j = 0; j < resolution; j++) {
+      const idx = i * resolution + j;
+      if (j < resolution - 1) {
+        const right = idx + 1;
+        const dx = positions[idx * 3] - positions[right * 3];
+        const dy = positions[idx * 3 + 1] - positions[right * 3 + 1];
+        const dz = positions[idx * 3 + 2] - positions[right * 3 + 2];
+        constraints.push([idx, right, Math.sqrt(dx * dx + dy * dy + dz * dz)]);
+      }
+      if (i < resolution - 1) {
+        const below = idx + resolution;
+        const dx = positions[idx * 3] - positions[below * 3];
+        const dy = positions[idx * 3 + 1] - positions[below * 3 + 1];
+        const dz = positions[idx * 3 + 2] - positions[below * 3 + 2];
+        constraints.push([idx, below, Math.sqrt(dx * dx + dy * dy + dz * dz)]);
+      }
+    }
+  }
+  return constraints;
+}
+function stepClothVerlet(state, config, delta) {
+  const positions = state.positions;
+  const prev = state.prevPositions;
+  const pinned = state.pinned;
+  const constraints = state.constraints;
+  const dampingFactor = 1 - config.damping;
+  const count = positions.length / 3;
+  const gravity = -9.81 * config.gravityScale * delta * delta;
+  const windX = smoothNoise(state.time * 0.5, 0) * config.windResponse * delta;
+  const windZ = smoothNoise(state.time * 0.7, 1) * config.windResponse * delta;
+  for (let i = 0; i < count; i++) {
+    if (pinned.has(i)) continue;
+    const ix = i * 3;
+    const iy = ix + 1;
+    const iz = ix + 2;
+    const cx = positions[ix];
+    const cy = positions[iy];
+    const cz = positions[iz];
+    const vx = (cx - prev[ix]) * dampingFactor;
+    const vy = (cy - prev[iy]) * dampingFactor;
+    const vz = (cz - prev[iz]) * dampingFactor;
+    prev[ix] = cx;
+    prev[iy] = cy;
+    prev[iz] = cz;
+    positions[ix] = cx + vx + windX;
+    positions[iy] = cy + vy + gravity;
+    positions[iz] = cz + vz + windZ;
+  }
+  const iterations = Math.ceil(config.stiffness * 5);
+  for (let iter = 0; iter < iterations; iter++) {
+    for (const [a, b, restLen] of constraints) {
+      const ax = positions[a * 3];
+      const ay = positions[a * 3 + 1];
+      const az = positions[a * 3 + 2];
+      const bx = positions[b * 3];
+      const by = positions[b * 3 + 1];
+      const bz = positions[b * 3 + 2];
+      const dx = bx - ax;
+      const dy = by - ay;
+      const dz = bz - az;
+      const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      if (dist < 1e-4) continue;
+      const diff = (dist - restLen) / dist * 0.5;
+      const ox = dx * diff;
+      const oy = dy * diff;
+      const oz = dz * diff;
+      const aPin = pinned.has(a);
+      const bPin = pinned.has(b);
+      if (!aPin && !bPin) {
+        positions[a * 3] += ox;
+        positions[a * 3 + 1] += oy;
+        positions[a * 3 + 2] += oz;
+        positions[b * 3] -= ox;
+        positions[b * 3 + 1] -= oy;
+        positions[b * 3 + 2] -= oz;
+      } else if (!aPin) {
+        positions[a * 3] += ox * 2;
+        positions[a * 3 + 1] += oy * 2;
+        positions[a * 3 + 2] += oz * 2;
+      } else if (!bPin) {
+        positions[b * 3] -= ox * 2;
+        positions[b * 3 + 1] -= oy * 2;
+        positions[b * 3 + 2] -= oz * 2;
+      }
+    }
+  }
+}
+
+export { BUNDLED_MODELS, INPUT_DIM, OUTPUT_DIM, OnnxMotionMatchingEngine, batchInferAsync, buildClothConstraints, createOnnxMotionMatchingEngine, decodeOutputTensor, encodeInputTensor, listBundledModels, noise, smoothNoise, stepClothVerlet };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map