@holoscript/core 6.0.4 → 6.1.1

package/dist/traits/engines/index.cjs

@@ -0,0 +1,520 @@
+'use strict';
+
+var chunkMYY4PMWX_cjs = require('../../chunk-MYY4PMWX.cjs');
+var chunkXJAN7CZG_cjs = require('../../chunk-XJAN7CZG.cjs');
+require('../../chunk-HCCQLAA4.cjs');
+
+// 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 = chunkMYY4PMWX_cjs.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 = chunkMYY4PMWX_cjs.projectLinearTrajectory(input.targetVelocity);
+  const speed = chunkMYY4PMWX_cjs.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 < chunkMYY4PMWX_cjs.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 ?? chunkXJAN7CZG_cjs.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;
+      }
+    }
+  }
+}
+
+Object.defineProperty(exports, "MOTION_DATA_SCHEMA_VERSION", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.MOTION_DATA_SCHEMA_VERSION; }
+});
+Object.defineProperty(exports, "NullMotionMatchingEngine", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.NullMotionMatchingEngine; }
+});
+Object.defineProperty(exports, "SYNTHETIC_WALK_JOINTS", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.SYNTHETIC_WALK_JOINTS; }
+});
+Object.defineProperty(exports, "SyntheticWalkCycleEngine", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.SyntheticWalkCycleEngine; }
+});
+Object.defineProperty(exports, "TRAJECTORY_FRAME_DT", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.TRAJECTORY_FRAME_DT; }
+});
+Object.defineProperty(exports, "TRAJECTORY_HORIZON_FRAMES", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.TRAJECTORY_HORIZON_FRAMES; }
+});
+Object.defineProperty(exports, "buildSyntheticBipedPose", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.buildSyntheticBipedPose; }
+});
+Object.defineProperty(exports, "classifyGait", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.classifyGait; }
+});
+Object.defineProperty(exports, "createNullMotionMatchingEngine", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.createNullMotionMatchingEngine; }
+});
+Object.defineProperty(exports, "createSyntheticWalkCycleEngine", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.createSyntheticWalkCycleEngine; }
+});
+Object.defineProperty(exports, "inferenceFrameToTensor", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.inferenceFrameToTensor; }
+});
+Object.defineProperty(exports, "magnitude", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.magnitude; }
+});
+Object.defineProperty(exports, "projectLinearTrajectory", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.projectLinearTrajectory; }
+});
+Object.defineProperty(exports, "validateMotionCapture", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.validateMotionCapture; }
+});
+Object.defineProperty(exports, "validateTrainingCorpus", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.validateTrainingCorpus; }
+});
+Object.defineProperty(exports, "validateTrainingFrame", {
+  enumerable: true,
+  get: function () { return chunkMYY4PMWX_cjs.validateTrainingFrame; }
+});
+Object.defineProperty(exports, "BUNDLED_MODEL_SEED", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.BUNDLED_MODEL_SEED; }
+});
+Object.defineProperty(exports, "HIDDEN_DIM", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.HIDDEN_DIM; }
+});
+Object.defineProperty(exports, "NoOpInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.NoOpInferenceAdapter; }
+});
+Object.defineProperty(exports, "OnnxNodeInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.OnnxNodeInferenceAdapter; }
+});
+Object.defineProperty(exports, "PHASE_CONTROL_POINTS", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.PHASE_CONTROL_POINTS; }
+});
+Object.defineProperty(exports, "PfnnNetwork", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.PfnnNetwork; }
+});
+Object.defineProperty(exports, "PureJsInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.PureJsInferenceAdapter; }
+});
+Object.defineProperty(exports, "add", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.add; }
+});
+Object.defineProperty(exports, "createBundledPfnn", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.createBundledPfnn; }
+});
+Object.defineProperty(exports, "createNoOpInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.createNoOpInferenceAdapter; }
+});
+Object.defineProperty(exports, "createOnnxNodeInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.createOnnxNodeInferenceAdapter; }
+});
+Object.defineProperty(exports, "createPureJsInferenceAdapter", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.createPureJsInferenceAdapter; }
+});
+Object.defineProperty(exports, "createTensor", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.createTensor; }
+});
+Object.defineProperty(exports, "eluInPlace", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.eluInPlace; }
+});
+Object.defineProperty(exports, "matmul", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.matmul; }
+});
+Object.defineProperty(exports, "resolveOnnxModelPath", {
+  enumerable: true,
+  get: function () { return chunkXJAN7CZG_cjs.resolveOnnxModelPath; }
+});
+exports.BUNDLED_MODELS = BUNDLED_MODELS;
+exports.INPUT_DIM = INPUT_DIM;
+exports.OUTPUT_DIM = OUTPUT_DIM;
+exports.OnnxMotionMatchingEngine = OnnxMotionMatchingEngine;
+exports.batchInferAsync = batchInferAsync;
+exports.buildClothConstraints = buildClothConstraints;
+exports.createOnnxMotionMatchingEngine = createOnnxMotionMatchingEngine;
+exports.decodeOutputTensor = decodeOutputTensor;
+exports.encodeInputTensor = encodeInputTensor;
+exports.listBundledModels = listBundledModels;
+exports.noise = noise;
+exports.smoothNoise = smoothNoise;
+exports.stepClothVerlet = stepClothVerlet;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/traits/engines/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @holoscript/core/traits/engines — motion-matching engine surface type declarations
+ * Auto-generated stub — sources in packages/core/src/traits/engines/
+ */
+
+// motion-matching
+export interface Vec3 { x: number; y: number; z: number; }
+
+export interface SkeletonPose {
+  joints: Record<string, { position: [number, number, number]; rotation: [number, number, number, number]; }>;
+  timestamp: number;
+}
+
+export interface ContactFeatures {
+  leftFoot: boolean;
+  rightFoot: boolean;
+  [extra: string]: boolean;
+}
+
+export type Gait = 'idle' | 'walk' | 'trot' | 'run' | 'crouch';
+
+export interface MotionInferenceInput {
+  targetVelocity: Vec3;
+  currentPhase: number;
+  delta: number;
+  terrainNormal?: Vec3;
+  energyEfficiency?: number;
+}
+
+export interface MotionInferenceResult {
+  pose: SkeletonPose;
+  phase: number;
+  trajectory: Array<[number, number, number]>;
+  stability: number;
+  contactFeatures: ContactFeatures;
+  gait: Gait;
+  kineticEnergyProxy: number;
+}
+
+export interface MotionMatchingEngine {
+  readonly modelId: string;
+  readonly loaded: boolean;
+  load(): Promise<void>;
+  infer(input: MotionInferenceInput): MotionInferenceResult;
+  dispose(): void;
+}
+
+export type MotionMatchingEngineFactory = (modelId: string) => MotionMatchingEngine;
+export declare const TRAJECTORY_HORIZON_FRAMES: number;
+export declare const TRAJECTORY_FRAME_DT: number;
+export declare function magnitude(v: Vec3): number;
+export declare function classifyGait(speed: number, energyEfficiency: number): Gait;
+export declare function projectLinearTrajectory(velocity: Vec3): Array<[number, number, number]>;
+export declare class NullMotionMatchingEngine implements MotionMatchingEngine {
+  readonly modelId: string;
+  readonly loaded: boolean;
+  load(): Promise<void>;
+  infer(input: MotionInferenceInput): MotionInferenceResult;
+  dispose(): void;
+}
+export declare function createNullMotionMatchingEngine(modelId: string): MotionMatchingEngine;
+
+// onnx-adapter
+export type ExecutionProvider = 'webgpu' | 'wasm' | 'cpu' | 'cuda';
+export type TensorShape = readonly number[];
+export interface Float32Tensor { data: Float32Array; shape: TensorShape; }
+export interface InferenceRequest { inputs: Record<string, Float32Tensor>; [key: string]: any; }
+export interface InferenceResponse { outputs: Record<string, Float32Tensor>; [key: string]: any; }
+export interface InferenceAdapter {
+  run(req: InferenceRequest): Promise<InferenceResponse>;
+  dispose?(): void;
+  [key: string]: any;
+}
+export declare class NoOpInferenceAdapter implements InferenceAdapter {
+  run(req: InferenceRequest): Promise<InferenceResponse>;
+  [key: string]: any;
+}
+export declare function createNoOpInferenceAdapter(): InferenceAdapter;
+
+// synthetic-walk-cycle
+export declare const SYNTHETIC_WALK_JOINTS: string[];
+export declare function buildSyntheticBipedPose(phase: number, speed: number): Record<string, { position: [number, number, number]; rotation: [number, number, number, number]; }>;
+export declare class SyntheticWalkCycleEngine implements MotionMatchingEngine {
+  readonly modelId: string;
+  readonly loaded: boolean;
+  load(): Promise<void>;
+  infer(input: MotionInferenceInput): MotionInferenceResult;
+  dispose(): void;
+}
+export declare function createSyntheticWalkCycleEngine(modelId?: string): MotionMatchingEngine;
+
+// motion-data-schema
+export declare const MOTION_DATA_SCHEMA_VERSION: 1;
+export interface TrainingFrame { joints: SkeletonPose['joints']; contacts?: ContactFeatures; timestamp?: number; [key: string]: any; }
+export interface InferenceFrame { targetVelocity: Vec3; currentPhase: number; delta: number; timestamp?: number; [key: string]: any; }
+export interface MotionCapture { frames: TrainingFrame[]; fps: number; [key: string]: any; }
+export interface TrainingCorpus { captures: MotionCapture[]; [key: string]: any; }
+export declare function validateTrainingFrame(frame: TrainingFrame): void;
+export declare function validateMotionCapture(capture: MotionCapture): void;
+export declare function validateTrainingCorpus(corpus: TrainingCorpus): void;
+export declare function inferenceFrameToTensor(frame: InferenceFrame, ...args: any[]): Float32Array;
+
+// cloth-verlet
+export interface ClothVerletState { positions: Float32Array; prevPositions: Float32Array; velocities?: Float32Array; [key: string]: any; }
+export interface ClothVerletConfig { gravity?: Vec3; damping?: number; iterations?: number; stiffness?: number; [key: string]: any; }
+export declare function buildClothConstraints(...args: any[]): any;
+export declare function stepClothVerlet(state: ClothVerletState, config?: ClothVerletConfig, ...args: any[]): ClothVerletState;
+
+// noise
+export declare function noise(t: number, seed: number): number;
+export declare function smoothNoise(t: number, seed: number): number;