@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-IUTY5WQ2.cjs

@@ -0,0 +1,424 @@
+'use strict';
+
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/DTDLCompiler.ts
+var DTDLCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(DTDLCompiler_exports, {
+  DTDLCompiler: () => exports.DTDLCompiler,
+  DTDL_TRAIT_COMPONENTS: () => exports.DTDL_TRAIT_COMPONENTS,
+  default: () => exports.DTDLCompiler_default
+});
+exports.DTDLCompiler = void 0; exports.DTDL_TRAIT_COMPONENTS = void 0; exports.DTDLCompiler_default = void 0;
+var init_DTDLCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/DTDLCompiler.ts"() {
+    chunkKKP7JKN4_cjs.init_CompilerBase();
+    exports.DTDLCompiler = class extends chunkKKP7JKN4_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "DTDLCompiler";
+        this.generatedInterfaces = [];
+        this.options = {
+          dtdlVersion: options.dtdlVersion ?? 3,
+          namespace: options.namespace || "dtmi:holoscript",
+          modelVersion: options.modelVersion ?? 1,
+          includeDescriptions: options.includeDescriptions ?? true,
+          includeTraitComponents: options.includeTraitComponents ?? true
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.DTDL;
+      }
+      /**
+       * Get trait name from either string or { name: string } format
+       */
+      getTraitName(trait) {
+        return typeof trait === "string" ? trait : trait.name;
+      }
+      /**
+       * Check if traits include a specific trait name
+       */
+      hasTrait(traits, targetTrait) {
+        return traits?.some((t) => this.getTraitName(t) === targetTrait) ?? false;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.generatedInterfaces = [];
+        if (composition.templates) {
+          for (const template of composition.templates) {
+            this.generatedInterfaces.push(this.compileTemplate(template));
+          }
+        }
+        const mainInterface = this.compileComposition(composition);
+        this.generatedInterfaces.push(mainInterface);
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            if (this.objectNeedsInterface(obj)) {
+              this.generatedInterfaces.push(this.compileObject(obj));
+            }
+          }
+        }
+        return JSON.stringify(this.generatedInterfaces, null, 2);
+      }
+      compileComposition(composition) {
+        const modelId = this.generateModelId(composition.name);
+        const contents = [];
+        if (composition.environment) {
+          contents.push(...this.compileEnvironmentProperties(composition.environment));
+        }
+        if (composition.state) {
+          contents.push(...this.compileStateProperties(composition.state));
+        }
+        if (composition.logic) {
+          contents.push(...this.compileLogicCommands(composition.logic));
+        }
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            contents.push(this.createObjectRelationship(obj));
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            contents.push({
+              "@type": "Relationship",
+              name: this.sanitizeName(group.name),
+              displayName: group.name,
+              description: `Spatial group containing ${group.objects?.length || 0} objects`
+            });
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: composition.name,
+          contents
+        };
+        if (this.options.includeDescriptions) {
+          iface.description = `Generated from HoloScript composition "${this.escapeStringValue(composition.name, "TypeScript")}"`;
+        }
+        return iface;
+      }
+      compileTemplate(template) {
+        const modelId = this.generateModelId(template.name);
+        const contents = [];
+        if (template.state) {
+          contents.push(...this.compileStateProperties(template.state));
+        }
+        if (template.actions) {
+          for (const action of template.actions) {
+            contents.push({
+              "@type": "Command",
+              name: action.name,
+              displayName: action.name,
+              description: `Action defined in template ${this.escapeStringValue(template.name, "TypeScript")}`
+            });
+          }
+        }
+        if (template.traits && this.options.includeTraitComponents) {
+          for (const trait of template.traits) {
+            const traitName = typeof trait === "string" ? trait : trait.name;
+            const component = this.traitToComponent(traitName);
+            if (component) {
+              contents.push(component);
+            }
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: template.name,
+          contents
+        };
+        const templateExt = template;
+        if (templateExt.extends) {
+          iface.extends = [this.generateModelId(templateExt.extends)];
+        }
+        return iface;
+      }
+      compileObject(obj) {
+        const modelId = this.generateModelId(obj.name);
+        const contents = [];
+        const posProp = obj.properties.find((p) => p.key === "position");
+        if (posProp) {
+          contents.push({
+            "@type": ["Property", "Location"],
+            name: "position",
+            schema: {
+              "@type": "Object",
+              fields: [
+                { name: "x", schema: "double" },
+                { name: "y", schema: "double" },
+                { name: "z", schema: "double" }
+              ]
+            },
+            writable: true
+          });
+        }
+        for (const prop of obj.properties) {
+          if (prop.key !== "position" && prop.key !== "geometry") {
+            contents.push(this.propertyToContent(prop.key, prop.value));
+          }
+        }
+        if (this.hasTrait(obj.traits, "sensor") || this.hasTrait(obj.traits, "observable")) {
+          contents.push({
+            "@type": "Telemetry",
+            name: "sensorReading",
+            schema: "double",
+            description: "Sensor telemetry data"
+          });
+        }
+        if (obj.traits && this.options.includeTraitComponents) {
+          for (const trait of obj.traits) {
+            const traitName = this.getTraitName(trait);
+            const component = this.traitToComponent(traitName);
+            if (component) {
+              contents.push(component);
+            }
+          }
+        }
+        const iface = {
+          "@context": this.getDtdlContext(),
+          "@type": "Interface",
+          "@id": modelId,
+          displayName: obj.name,
+          contents
+        };
+        if (obj.template) {
+          iface.extends = this.generateModelId(obj.template);
+        }
+        return iface;
+      }
+      compileEnvironmentProperties(env) {
+        const props = [];
+        const envExt = env;
+        if (Array.isArray(envExt.properties)) {
+          for (const prop of envExt.properties) {
+            this.addEnvironmentProperty(props, prop.key, prop.value);
+          }
+        } else {
+          for (const key of Object.keys(envExt)) {
+            if (key !== "type") {
+              this.addEnvironmentProperty(props, key, envExt[key]);
+            }
+          }
+        }
+        return props;
+      }
+      addEnvironmentProperty(props, key, _value) {
+        if (key === "skybox") {
+          props.push({
+            "@type": "Property",
+            name: "skybox",
+            schema: "string",
+            displayName: "Skybox",
+            description: "Environment skybox setting"
+          });
+        } else if (key === "ambient_light") {
+          props.push({
+            "@type": "Property",
+            name: "ambientLight",
+            schema: "double",
+            displayName: "Ambient Light",
+            description: "Ambient light level"
+          });
+        } else if (key === "fog") {
+          props.push({
+            "@type": "Property",
+            name: "fogEnabled",
+            schema: "boolean",
+            displayName: "Fog Enabled"
+          });
+        }
+      }
+      compileStateProperties(state) {
+        const props = [];
+        for (const prop of state.properties) {
+          props.push(this.propertyToContent(prop.key, prop.value));
+        }
+        return props;
+      }
+      compileLogicCommands(logic) {
+        const commands = [];
+        const logicExt = logic;
+        const items = logicExt.handlers || logicExt.rules || [];
+        for (const item of items) {
+          const event = item.event;
+          if (event?.startsWith("on_")) {
+            commands.push({
+              "@type": "Command",
+              name: event.replace("on_", ""),
+              displayName: this.formatEventName(event),
+              description: `Event handler for ${event}`
+            });
+          }
+        }
+        return commands;
+      }
+      propertyToContent(key, value) {
+        return {
+          "@type": "Property",
+          name: this.sanitizeName(key),
+          schema: this.inferSchema(value),
+          displayName: this.formatDisplayName(key),
+          writable: true
+        };
+      }
+      createObjectRelationship(obj) {
+        return {
+          "@type": "Relationship",
+          name: `has${this.pascalCase(obj.name)}`,
+          displayName: obj.name,
+          target: this.objectNeedsInterface(obj) ? this.generateModelId(obj.name) : void 0,
+          maxMultiplicity: 1
+        };
+      }
+      traitToComponent(trait) {
+        const traitComponents = {
+          grabbable: {
+            schema: `${this.options.namespace}:component:Grabbable;${this.options.modelVersion}`,
+            description: "Allows object to be grabbed/manipulated"
+          },
+          networked: {
+            schema: `${this.options.namespace}:component:Networked;${this.options.modelVersion}`,
+            description: "Enables network synchronization"
+          },
+          physics: {
+            schema: `${this.options.namespace}:component:Physics;${this.options.modelVersion}`,
+            description: "Enables physics simulation"
+          },
+          collidable: {
+            schema: `${this.options.namespace}:component:Collidable;${this.options.modelVersion}`,
+            description: "Enables collision detection"
+          },
+          sensor: {
+            schema: `${this.options.namespace}:component:Sensor;${this.options.modelVersion}`,
+            description: "IoT sensor capabilities"
+          },
+          observable: {
+            schema: `${this.options.namespace}:component:Observable;${this.options.modelVersion}`,
+            description: "State observation capabilities"
+          }
+        };
+        const config = traitComponents[trait];
+        if (!config) return null;
+        return {
+          "@type": "Component",
+          name: trait,
+          schema: config.schema,
+          description: config.description
+        };
+      }
+      inferSchema(value) {
+        if (typeof value === "boolean") return "boolean";
+        if (typeof value === "number") {
+          return Number.isInteger(value) ? "integer" : "double";
+        }
+        if (typeof value === "string") return "string";
+        if (Array.isArray(value)) {
+          if (value.length > 0) {
+            return {
+              "@type": "Array",
+              elementSchema: this.inferSchema(value[0])
+            };
+          }
+          return { "@type": "Array", elementSchema: "double" };
+        }
+        if (typeof value === "object" && value !== null) {
+          const fields = Object.entries(value).map(([k, v]) => ({
+            name: k,
+            schema: this.inferSchema(v)
+          }));
+          return { "@type": "Object", fields };
+        }
+        return "string";
+      }
+      getDtdlContext() {
+        return this.options.dtdlVersion === 3 ? "dtmi:dtdl:context;3" : "dtmi:dtdl:context;2";
+      }
+      generateModelId(name) {
+        const sanitized = this.sanitizeName(name);
+        return `${this.options.namespace}:${sanitized};${this.options.modelVersion}`;
+      }
+      objectNeedsInterface(obj) {
+        const hasState = obj.properties.some((p) => p.key === "state" || typeof p.value === "object");
+        const complexTraitList = ["networked", "sensor", "observable", "state"];
+        const hasComplexTraits = obj.traits?.some(
+          (t) => complexTraitList.includes(this.getTraitName(t))
+        );
+        return hasState || hasComplexTraits || false;
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+      }
+      formatDisplayName(name) {
+        return name.replace(/_/g, " ").replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+      }
+      formatEventName(event) {
+        return event.replace(/^on_/, "").replace(/_/g, " ").replace(/^./, (s) => s.toUpperCase());
+      }
+      pascalCase(name) {
+        return name.replace(/[^a-zA-Z0-9]/g, " ").split(" ").map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+      }
+    };
+    exports.DTDL_TRAIT_COMPONENTS = [
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Grabbable;1",
+        displayName: "Grabbable",
+        description: "Component for objects that can be grabbed in VR/AR",
+        contents: [
+          { "@type": "Property", name: "isGrabbed", schema: "boolean", writable: false },
+          { "@type": "Property", name: "grabDistance", schema: "double", writable: true }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Networked;1",
+        displayName: "Networked",
+        description: "Component for network-synchronized objects",
+        contents: [
+          { "@type": "Property", name: "networkId", schema: "string", writable: false },
+          { "@type": "Property", name: "syncRate", schema: "integer", writable: true },
+          { "@type": "Property", name: "ownerId", schema: "string", writable: false }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Physics;1",
+        displayName: "Physics",
+        description: "Component for physics-enabled objects",
+        contents: [
+          { "@type": "Property", name: "mass", schema: "double", writable: true },
+          { "@type": "Property", name: "friction", schema: "double", writable: true },
+          { "@type": "Property", name: "restitution", schema: "double", writable: true },
+          { "@type": "Property", name: "isKinematic", schema: "boolean", writable: true }
+        ]
+      },
+      {
+        "@context": "dtmi:dtdl:context;3",
+        "@type": "Interface",
+        "@id": "dtmi:holoscript:component:Sensor;1",
+        displayName: "Sensor",
+        description: "Component for IoT sensor capabilities",
+        contents: [
+          { "@type": "Property", name: "sensorType", schema: "string", writable: false },
+          { "@type": "Telemetry", name: "value", schema: "double" },
+          { "@type": "Telemetry", name: "timestamp", schema: "dateTime" }
+        ]
+      }
+    ];
+    exports.DTDLCompiler_default = exports.DTDLCompiler;
+  }
+});
+
+exports.DTDLCompiler_exports = DTDLCompiler_exports;
+exports.init_DTDLCompiler = init_DTDLCompiler;
+//# sourceMappingURL=chunk-IUTY5WQ2.cjs.map
+//# sourceMappingURL=chunk-IUTY5WQ2.cjs.map

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