@holoscript/core 6.0.3 → 6.1.1

package/dist/chunk-IVY74O6C.js

@@ -0,0 +1,247 @@
+// src/traits/engines/motion-matching.ts
+var TRAJECTORY_HORIZON_FRAMES = 12;
+var TRAJECTORY_FRAME_DT = 1 / 30;
+function magnitude(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function classifyGait(speed, energyEfficiency) {
+  const efficiencyPenalty = energyEfficiency > 1 ? 0.85 : 1;
+  const adjusted = speed * efficiencyPenalty;
+  if (adjusted < 0.05) return "idle";
+  if (adjusted < 1.4) return "walk";
+  if (adjusted < 3) return "trot";
+  return "run";
+}
+function projectLinearTrajectory(velocity) {
+  const trajectory = [];
+  for (let i = 1; i <= TRAJECTORY_HORIZON_FRAMES; i++) {
+    const t = i * TRAJECTORY_FRAME_DT;
+    trajectory.push([velocity.x * t, velocity.y * t, velocity.z * t]);
+  }
+  return trajectory;
+}
+var NullMotionMatchingEngine = class {
+  constructor(modelId) {
+    this.loaded = false;
+    this.modelId = modelId;
+  }
+  async load() {
+    this.loaded = true;
+  }
+  infer(input) {
+    const speed = magnitude(input.targetVelocity);
+    const energyEfficiency = input.energyEfficiency ?? 1;
+    const phaseAdvance = (speed * 0.3 + 0.5) * input.delta;
+    const phase = (input.currentPhase + phaseAdvance) % 1;
+    const leftFootContact = phase < 0.5;
+    const rightFootContact = phase >= 0.5;
+    return {
+      pose: { joints: {}, timestamp: Date.now() },
+      phase,
+      trajectory: projectLinearTrajectory(input.targetVelocity),
+      stability: 1,
+      contactFeatures: { leftFoot: leftFootContact, rightFoot: rightFootContact },
+      gait: classifyGait(speed, energyEfficiency),
+      kineticEnergyProxy: speed * speed * energyEfficiency
+    };
+  }
+  dispose() {
+    this.loaded = false;
+  }
+};
+function createNullMotionMatchingEngine(modelId) {
+  return new NullMotionMatchingEngine(modelId);
+}
+
+// src/traits/engines/synthetic-walk-cycle.ts
+var STRIDE_AMPLITUDE_RAD = 0.6;
+var KNEE_FLEXION_AMPLITUDE_RAD = 0.5;
+var HIP_BOB_AMPLITUDE = 0.04;
+var SYNTHETIC_WALK_JOINTS = [
+  "hip",
+  "left_thigh",
+  "right_thigh",
+  "left_knee",
+  "right_knee",
+  "left_foot",
+  "right_foot"
+];
+function buildSyntheticBipedPose(phase, speed) {
+  const leftSwing = Math.sin(phase * 2 * Math.PI);
+  const rightSwing = Math.sin((phase + 0.5) * 2 * Math.PI);
+  const speedScale = Math.min(speed, 6) / 6;
+  const hipY = 1 + Math.cos(phase * 4 * Math.PI) * HIP_BOB_AMPLITUDE * speedScale;
+  const hipYawRad = leftSwing * 0.05 * speedScale;
+  const hipQuat = [0, Math.sin(hipYawRad / 2), 0, Math.cos(hipYawRad / 2)];
+  const leftThighPitchRad = leftSwing * STRIDE_AMPLITUDE_RAD * speedScale;
+  const rightThighPitchRad = rightSwing * STRIDE_AMPLITUDE_RAD * speedScale;
+  const leftThighQuat = [Math.sin(leftThighPitchRad / 2), 0, 0, Math.cos(leftThighPitchRad / 2)];
+  const rightThighQuat = [Math.sin(rightThighPitchRad / 2), 0, 0, Math.cos(rightThighPitchRad / 2)];
+  const leftKneeRad = Math.max(0, leftSwing) * KNEE_FLEXION_AMPLITUDE_RAD * speedScale;
+  const rightKneeRad = Math.max(0, rightSwing) * KNEE_FLEXION_AMPLITUDE_RAD * speedScale;
+  const leftKneeQuat = [Math.sin(leftKneeRad / 2), 0, 0, Math.cos(leftKneeRad / 2)];
+  const rightKneeQuat = [Math.sin(rightKneeRad / 2), 0, 0, Math.cos(rightKneeRad / 2)];
+  const leftFootRad = -leftThighPitchRad * 0.5;
+  const rightFootRad = -rightThighPitchRad * 0.5;
+  const leftFootQuat = [Math.sin(leftFootRad / 2), 0, 0, Math.cos(leftFootRad / 2)];
+  const rightFootQuat = [Math.sin(rightFootRad / 2), 0, 0, Math.cos(rightFootRad / 2)];
+  return {
+    hip: { position: [0, hipY, 0], rotation: hipQuat },
+    left_thigh: { position: [0.1, hipY - 0.4, 0], rotation: leftThighQuat },
+    right_thigh: { position: [-0.1, hipY - 0.4, 0], rotation: rightThighQuat },
+    left_knee: { position: [0.1, hipY - 0.8, 0], rotation: leftKneeQuat },
+    right_knee: { position: [-0.1, hipY - 0.8, 0], rotation: rightKneeQuat },
+    left_foot: { position: [0.1, hipY - 1, 0], rotation: leftFootQuat },
+    right_foot: { position: [-0.1, hipY - 1, 0], rotation: rightFootQuat }
+  };
+}
+var SyntheticWalkCycleEngine = class {
+  constructor(modelId = "synthetic_biped_walk") {
+    this.loaded = false;
+    this.modelId = modelId;
+  }
+  async load() {
+    this.loaded = true;
+  }
+  infer(input) {
+    const speed = magnitude(input.targetVelocity);
+    const energyEfficiency = input.energyEfficiency ?? 1;
+    const phaseAdvance = Math.max(speed, 0.1) * 0.5 * input.delta;
+    const phase = (input.currentPhase + phaseAdvance) % 1;
+    const joints = buildSyntheticBipedPose(phase, speed);
+    const pose = { joints, timestamp: Date.now() };
+    const leftFoot = speed < 0.05 || phase < 0.5;
+    const rightFoot = speed < 0.05 || phase >= 0.5;
+    const contactFeatures = { leftFoot, rightFoot };
+    return {
+      pose,
+      phase,
+      trajectory: projectLinearTrajectory(input.targetVelocity),
+      stability: speed > 5 ? Math.max(0.1, 1 - (speed - 5) * 0.2) : 1,
+      contactFeatures,
+      gait: classifyGait(speed, energyEfficiency),
+      kineticEnergyProxy: speed * speed * energyEfficiency
+    };
+  }
+  dispose() {
+    this.loaded = false;
+  }
+};
+function createSyntheticWalkCycleEngine(modelId) {
+  return new SyntheticWalkCycleEngine(modelId);
+}
+
+// src/traits/engines/motion-data-schema.ts
+var MOTION_DATA_SCHEMA_VERSION = 1;
+function validateTrainingFrame(frame) {
+  if (typeof frame.frameIndex !== "number" || frame.frameIndex < 0) {
+    throw new Error(`TrainingFrame: frameIndex must be a non-negative number, got ${frame.frameIndex}`);
+  }
+  if (typeof frame.phase !== "number" || frame.phase < 0 || frame.phase >= 1) {
+    throw new Error(`TrainingFrame: phase must be in [0, 1), got ${frame.phase}`);
+  }
+  if (!frame.pose || typeof frame.pose !== "object" || !frame.pose.joints) {
+    throw new Error("TrainingFrame: pose.joints required");
+  }
+  if (!frame.contactFeatures || typeof frame.contactFeatures !== "object") {
+    throw new Error("TrainingFrame: contactFeatures required");
+  }
+  const validGaits = ["idle", "walk", "trot", "run", "crouch"];
+  if (!validGaits.includes(frame.gait)) {
+    throw new Error(`TrainingFrame: gait must be one of ${validGaits.join(", ")}, got ${frame.gait}`);
+  }
+}
+function validateMotionCapture(capture) {
+  if (capture.schemaVersion !== MOTION_DATA_SCHEMA_VERSION) {
+    throw new Error(
+      `MotionCapture: schemaVersion ${capture.schemaVersion} unsupported (current=${MOTION_DATA_SCHEMA_VERSION})`
+    );
+  }
+  if (!capture.captureId || typeof capture.captureId !== "string") {
+    throw new Error("MotionCapture: captureId required");
+  }
+  if (!capture.skeletonId || typeof capture.skeletonId !== "string") {
+    throw new Error("MotionCapture: skeletonId required");
+  }
+  if (capture.fps <= 0 || capture.fps > 240) {
+    throw new Error(`MotionCapture: fps must be in (0, 240], got ${capture.fps}`);
+  }
+  if (!capture.license || !capture.license.spdx) {
+    throw new Error(
+      "MotionCapture: license.spdx required \u2014 every training capture must declare a commercial-use-compatible license (refuses CC BY-NC, GPL viral, proprietary without explicit grant)"
+    );
+  }
+  const blockedSpdx = ["CC-BY-NC-4.0", "CC-BY-NC-SA-4.0", "CC-BY-NC-ND-4.0", "GPL-3.0", "AGPL-3.0"];
+  if (blockedSpdx.includes(capture.license.spdx)) {
+    throw new Error(
+      `MotionCapture: license ${capture.license.spdx} is incompatible with @holoscript/core commercial distribution. Permitted: MIT, Apache-2.0, BSD-3-Clause, CC-BY-4.0 (with attribution), proprietary-with-grant.`
+    );
+  }
+  if (!Array.isArray(capture.frames) || capture.frames.length === 0) {
+    throw new Error("MotionCapture: frames must be a non-empty array");
+  }
+  for (const frame of capture.frames) validateTrainingFrame(frame);
+}
+function validateTrainingCorpus(corpus) {
+  if (corpus.schemaVersion !== MOTION_DATA_SCHEMA_VERSION) {
+    throw new Error(`TrainingCorpus: schemaVersion ${corpus.schemaVersion} unsupported`);
+  }
+  if (!corpus.corpusId) throw new Error("TrainingCorpus: corpusId required");
+  if (!corpus.skeletonId) throw new Error("TrainingCorpus: skeletonId required");
+  if (!corpus.splits) throw new Error("TrainingCorpus: splits required");
+  const captureIds = new Set(corpus.captures.map((c) => c.captureId));
+  const splitIds = [...corpus.splits.train, ...corpus.splits.val, ...corpus.splits.test];
+  for (const id of splitIds) {
+    if (!captureIds.has(id)) {
+      throw new Error(`TrainingCorpus: split references unknown captureId ${id}`);
+    }
+  }
+  const seenInSplit = /* @__PURE__ */ new Set();
+  for (const id of splitIds) {
+    if (seenInSplit.has(id)) {
+      throw new Error(`TrainingCorpus: captureId ${id} appears in multiple splits \u2014 data leakage`);
+    }
+    seenInSplit.add(id);
+  }
+  for (const cap of corpus.captures) {
+    if (cap.skeletonId !== corpus.skeletonId) {
+      throw new Error(
+        `TrainingCorpus: capture ${cap.captureId} skeleton ${cap.skeletonId} differs from corpus skeleton ${corpus.skeletonId}`
+      );
+    }
+    validateMotionCapture(cap);
+  }
+}
+function inferenceFrameToTensor(frame, sortedJointNames) {
+  const headerLen = 8;
+  const jointLen = sortedJointNames.length * 7;
+  const out = new Float32Array(headerLen + jointLen);
+  out[0] = frame.phase;
+  out[1] = frame.rootVelocity.x;
+  out[2] = frame.rootVelocity.y;
+  out[3] = frame.rootVelocity.z;
+  out[4] = frame.rootAngularVelocity;
+  const terrain = frame.terrainNormal ?? { x: 0, y: 1, z: 0 };
+  out[5] = terrain.x;
+  out[6] = terrain.y;
+  out[7] = terrain.z;
+  for (let i = 0; i < sortedJointNames.length; i++) {
+    const jointName = sortedJointNames[i];
+    const joint = frame.pose.joints[jointName];
+    const base = headerLen + i * 7;
+    if (joint) {
+      out[base + 0] = joint.position[0];
+      out[base + 1] = joint.position[1];
+      out[base + 2] = joint.position[2];
+      out[base + 3] = joint.rotation[0];
+      out[base + 4] = joint.rotation[1];
+      out[base + 5] = joint.rotation[2];
+      out[base + 6] = joint.rotation[3];
+    }
+  }
+  return out;
+}
+
+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 };
+//# sourceMappingURL=chunk-IVY74O6C.js.map
+//# sourceMappingURL=chunk-IVY74O6C.js.map