@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-LHAXPADA.js

@@ -0,0 +1,882 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, weatherToUSD, compileAudioSourceBlock, audioSourceToUSD, compilePostProcessingBlock, postProcessingToUSD, compileParticleBlock, particlesToUSD, compilePhysicsBlock, physicsToURDF, compileMaterialBlock, materialToUSD } from './chunk-BOVPWH4H.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/USDPhysicsCompiler.ts
+init_CompilerBase();
+init_DomainBlockCompilerMixin();
+var USDPhysicsCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "USDPhysicsCompiler";
+    this.lines = [];
+    /** Root composition name, set during compile() for USD path resolution. */
+    this.compositionName = "World";
+    this.indentLevel = 0;
+    this.prims = [];
+    this.joints = [];
+    this.materials = /* @__PURE__ */ new Map();
+    this.options = {
+      stageName: options.stageName ?? "HoloScriptPhysicsStage",
+      upAxis: options.upAxis ?? "Z",
+      // Isaac Sim default
+      metersPerUnit: options.metersPerUnit ?? 1,
+      timeCodesPerSecond: options.timeCodesPerSecond ?? 60,
+      includePhysicsScene: options.includePhysicsScene ?? true,
+      gravity: options.gravity ?? [0, 0, -9.81],
+      physicsTimestep: options.physicsTimestep ?? 1 / 60,
+      enableGPUDynamics: options.enableGPUDynamics ?? true,
+      includeCollision: options.includeCollision ?? true,
+      includeVisual: options.includeVisual ?? true,
+      defaultMass: options.defaultMass ?? 1,
+      defaultStaticFriction: options.defaultStaticFriction ?? 0.5,
+      defaultDynamicFriction: options.defaultDynamicFriction ?? 0.5,
+      defaultRestitution: options.defaultRestitution ?? 0.1,
+      enableArticulation: options.enableArticulation ?? true,
+      targetContext: options.targetContext ?? "isaac_sim",
+      embedSemanticAST: options.embedSemanticAST ?? true,
+      provenanceHash: options.provenanceHash ?? ""
+    };
+  }
+  getRequiredCapability() {
+    return ANSCapabilityPath.USD;
+  }
+  // ===========================================================================
+  // HELPER METHODS
+  // ===========================================================================
+  /** Get trait name from either string or object format */
+  getTraitName(trait) {
+    return typeof trait === "string" ? trait : trait.name;
+  }
+  /** Check if object has a specific trait */
+  hasTrait(obj, traitName) {
+    return obj.traits?.some((t) => this.getTraitName(t) === traitName) ?? false;
+  }
+  /** Get trait configuration object */
+  getTraitConfig(obj, traitName) {
+    const trait = obj.traits?.find((t) => this.getTraitName(t) === traitName);
+    if (!trait) return void 0;
+    if (typeof trait === "string") return {};
+    const traitObj = trait;
+    if ("config" in traitObj && typeof traitObj.config === "object") {
+      return traitObj.config;
+    }
+    const { name: _name, ...rest } = traitObj;
+    if (rest.type === "ObjectTrait") {
+      const { type: _type, ...config } = rest;
+      return config;
+    }
+    return rest;
+  }
+  /** Sanitize name for USD path */
+  sanitizeName(name) {
+    let sanitized = name.replace(/[^a-zA-Z0-9_]/g, "_");
+    if (/^[0-9]/.test(sanitized)) {
+      sanitized = "_" + sanitized;
+    }
+    return sanitized;
+  }
+  /** Emit a line with current indent */
+  emit(line) {
+    const indent = "    ".repeat(this.indentLevel);
+    this.lines.push(indent + line);
+  }
+  /** Emit empty line */
+  emitBlank() {
+    this.lines.push("");
+  }
+  /** Get property value from object properties array */
+  getPropertyValue(obj, key) {
+    const prop = obj.properties?.find((p) => p.key === key);
+    return prop?.value;
+  }
+  /** Extract position from object properties */
+  extractPosition(obj) {
+    const pos = this.getPropertyValue(obj, "position");
+    if (Array.isArray(pos) && pos.length >= 3) {
+      return [Number(pos[0]) || 0, Number(pos[1]) || 0, Number(pos[2]) || 0];
+    }
+    return [0, 0, 0];
+  }
+  /** Extract rotation as quaternion from object properties */
+  extractRotation(obj) {
+    const rot = this.getPropertyValue(obj, "rotation");
+    if (Array.isArray(rot) && rot.length >= 3) {
+      const euler = [
+        (Number(rot[0]) || 0) * (Math.PI / 180),
+        (Number(rot[1]) || 0) * (Math.PI / 180),
+        (Number(rot[2]) || 0) * (Math.PI / 180)
+      ];
+      return this.eulerToQuaternion(euler[0], euler[1], euler[2]);
+    }
+    return [0, 0, 0, 1];
+  }
+  /** Convert Euler angles (radians) to quaternion */
+  eulerToQuaternion(roll, pitch, yaw) {
+    const cy = Math.cos(yaw * 0.5);
+    const sy = Math.sin(yaw * 0.5);
+    const cp = Math.cos(pitch * 0.5);
+    const sp = Math.sin(pitch * 0.5);
+    const cr = Math.cos(roll * 0.5);
+    const sr = Math.sin(roll * 0.5);
+    return [
+      sr * cp * cy - cr * sp * sy,
+      // x
+      cr * sp * cy + sr * cp * sy,
+      // y
+      cr * cp * sy - sr * sp * cy,
+      // z
+      cr * cp * cy + sr * sp * sy
+      // w
+    ];
+  }
+  /** Extract scale from object properties */
+  extractScale(obj) {
+    const scale = this.getPropertyValue(obj, "scale");
+    if (Array.isArray(scale) && scale.length >= 3) {
+      return [Number(scale[0]) || 1, Number(scale[1]) || 1, Number(scale[2]) || 1];
+    }
+    if (typeof scale === "number") {
+      return [scale, scale, scale];
+    }
+    return [1, 1, 1];
+  }
+  /** Extract geometry type from object */
+  extractGeometry(obj) {
+    const geom = this.getPropertyValue(obj, "geometry");
+    if (!geom) return void 0;
+    const geomType = String(geom);
+    const scale = this.extractScale(obj);
+    switch (geomType) {
+      case "cube":
+      case "box":
+        return { type: "Cube", size: scale };
+      case "sphere":
+        return { type: "Sphere", radius: Math.max(...scale) / 2 };
+      case "cylinder":
+        return { type: "Cylinder", radius: Math.max(scale[0], scale[2]) / 2 };
+      case "capsule":
+        return { type: "Capsule", radius: Math.max(scale[0], scale[2]) / 2 };
+      case "cone":
+        return { type: "Cone", radius: Math.max(scale[0], scale[2]) / 2 };
+      default:
+        if (geomType.endsWith(".usd") || geomType.endsWith(".usda") || geomType.endsWith(".usdc")) {
+          return { type: "Reference", size: scale };
+        }
+        return { type: "Cube", size: scale };
+    }
+  }
+  /** Map HoloScript joint types to USD joint types */
+  mapJointType(holoType) {
+    switch (holoType) {
+      case "hinge":
+      case "revolute":
+        return "revolute";
+      case "slider":
+      case "prismatic":
+        return "prismatic";
+      case "ball":
+      case "spherical":
+        return "spherical";
+      case "fixed":
+        return "fixed";
+      case "6dof":
+      case "d6":
+        return "d6";
+      default:
+        return "fixed";
+    }
+  }
+  /** Map axis string to USD axis */
+  mapAxis(axis) {
+    if (Array.isArray(axis)) {
+      const absX = Math.abs(Number(axis[0]) || 0);
+      const absY = Math.abs(Number(axis[1]) || 0);
+      const absZ = Math.abs(Number(axis[2]) || 0);
+      if (absX >= absY && absX >= absZ) return "X";
+      if (absY >= absX && absY >= absZ) return "Y";
+      return "Z";
+    }
+    const axisStr = String(axis).toUpperCase();
+    if (axisStr === "X" || axisStr === "Y" || axisStr === "Z") {
+      return axisStr;
+    }
+    return "Z";
+  }
+  // ===========================================================================
+  // COMPILATION
+  // ===========================================================================
+  /**
+   * Compile HoloScript composition to USD ASCII with physics schemas
+   */
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    this.compositionName = this.sanitizeName(composition.name);
+    this.lines = [];
+    this.prims = [];
+    this.joints = [];
+    this.materials.clear();
+    this.indentLevel = 0;
+    this.extractFromComposition(composition);
+    this.emitHeader(composition.name);
+    this.emitBlank();
+    this.emit(`def Xform "${this.sanitizeName(composition.name)}" (`);
+    this.indentLevel++;
+    this.emit(`kind = "component"`);
+    this.indentLevel--;
+    this.emit(`)
+{`);
+    this.indentLevel++;
+    if (this.options.embedSemanticAST) {
+      this.emitSemanticCustomData(composition);
+      this.emitBlank();
+    }
+    if (this.options.includePhysicsScene) {
+      this.emitPhysicsScene();
+      this.emitBlank();
+    }
+    if (this.materials.size > 0) {
+      this.emitPhysicsMaterials();
+      this.emitBlank();
+    }
+    const isRobot = this.prims.some(
+      (p) => p.apis.some((a) => a.type === "PhysicsArticulationRootAPI")
+    );
+    if (isRobot && this.options.enableArticulation) {
+      this.emitArticulationRoot();
+    } else {
+      for (const prim of this.prims) {
+        this.emitPrim(prim);
+        this.emitBlank();
+      }
+    }
+    for (const joint of this.joints) {
+      this.emitJoint(joint);
+      this.emitBlank();
+    }
+    const domainBlocks = composition.domainBlocks ?? [];
+    if (domainBlocks.length > 0) {
+      this.emitBlank();
+      this.emit(`# === v4.2 Domain Blocks ===`);
+      const compiled = compileDomainBlocks(
+        domainBlocks,
+        {
+          material: (block) => {
+            const mat = compileMaterialBlock(block);
+            return materialToUSD(mat);
+          },
+          physics: (block) => {
+            const phys = compilePhysicsBlock(block);
+            const urdf = physicsToURDF(phys);
+            return `# Physics: ${phys.keyword} "${phys.name || ""}"
+` + urdf.split("\n").map((l) => `# URDF: ${l}`).join("\n");
+          },
+          vfx: (block) => {
+            const ps = compileParticleBlock(block);
+            return particlesToUSD(ps);
+          },
+          postfx: (block) => {
+            const pp = compilePostProcessingBlock(block);
+            return postProcessingToUSD(pp);
+          },
+          audio: (block) => {
+            const audio = compileAudioSourceBlock(block);
+            return audioSourceToUSD(audio);
+          },
+          weather: (block) => {
+            const weather = compileWeatherBlock(block);
+            return weatherToUSD(weather);
+          }
+        },
+        (block) => `# Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
+      );
+      for (const output of compiled) {
+        this.emitBlank();
+        for (const line of output.split("\n")) {
+          this.emit(line);
+        }
+      }
+    }
+    this.indentLevel--;
+    this.emit(`}`);
+    return this.lines.join("\n");
+  }
+  // ===========================================================================
+  // HEADER EMISSION
+  // ===========================================================================
+  emitHeader(name) {
+    const runtimeLabel = this.options.targetContext === "isaac_sim" ? "NVIDIA Isaac Sim / Isaac Lab" : this.options.targetContext === "omniverse" ? "NVIDIA Omniverse" : "Generic USD Runtime";
+    this.emit(`#usda 1.0`);
+    this.emit(`(`);
+    this.indentLevel++;
+    this.emit(`defaultPrim = "${this.sanitizeName(name)}"`);
+    this.emit(`doc = "Generated by HoloScript USDPhysicsCompiler for ${runtimeLabel}"`);
+    this.emit(`metersPerUnit = ${this.options.metersPerUnit}`);
+    this.emit(`upAxis = "${this.options.upAxis}"`);
+    this.emit(`timeCodesPerSecond = ${this.options.timeCodesPerSecond}`);
+    this.emit(`customLayerData = {`);
+    this.indentLevel++;
+    this.emit(`string generator = "HoloScript v6.0"`);
+    this.emit(`string targetRuntime = "${runtimeLabel}"`);
+    this.emit(`string holoscript:targetContext = "${this.options.targetContext}"`);
+    this.indentLevel--;
+    this.emit(`}`);
+    this.indentLevel--;
+    this.emit(`)`);
+    if (this.options.provenanceHash) {
+      this.emit(`# Provenance Hash: ${this.options.provenanceHash}`);
+    }
+  }
+  // ===========================================================================
+  // PHYSICS SCENE
+  // ===========================================================================
+  emitPhysicsScene() {
+    const gravityMag = Math.sqrt(
+      this.options.gravity[0] ** 2 + this.options.gravity[1] ** 2 + this.options.gravity[2] ** 2
+    );
+    const gravityDir = gravityMag > 0 ? [
+      this.options.gravity[0] / gravityMag,
+      this.options.gravity[1] / gravityMag,
+      this.options.gravity[2] / gravityMag
+    ] : [0, 0, -1];
+    this.emit(`def PhysicsScene "PhysicsScene"`);
+    this.emit(`{`);
+    this.indentLevel++;
+    this.emit(
+      `float3 physics:gravityDirection = (${gravityDir[0]}, ${gravityDir[1]}, ${gravityDir[2]})`
+    );
+    this.emit(`float physics:gravityMagnitude = ${gravityMag}`);
+    this.emit(`# Isaac Sim GPU dynamics`);
+    this.emit(`bool physxScene:enableGPUDynamics = ${this.options.enableGPUDynamics}`);
+    this.emit(`float physxScene:timestep = ${this.options.physicsTimestep}`);
+    this.emit(`uint physxScene:solverType = 1  # TGS solver`);
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  // ===========================================================================
+  // PHYSICS MATERIALS
+  // ===========================================================================
+  emitPhysicsMaterials() {
+    this.emit(`def Scope "PhysicsMaterials"`);
+    this.emit(`{`);
+    this.indentLevel++;
+    for (const [_key, mat] of this.materials) {
+      this.emit(`def Material "${this.escapeStringValue(mat.name, "TypeScript")}" (`);
+      this.indentLevel++;
+      this.emit(`prepend apiSchemas = ["PhysicsMaterialAPI"]`);
+      this.indentLevel--;
+      this.emit(`)`);
+      this.emit(`{`);
+      this.indentLevel++;
+      this.emit(`float physics:staticFriction = ${mat.staticFriction}`);
+      this.emit(`float physics:dynamicFriction = ${mat.dynamicFriction}`);
+      this.emit(`float physics:restitution = ${mat.restitution}`);
+      if (mat.density !== void 0) {
+        this.emit(`float physics:density = ${mat.density}`);
+      }
+      this.indentLevel--;
+      this.emit(`}`);
+    }
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  // ===========================================================================
+  // ARTICULATION ROOT
+  // ===========================================================================
+  emitArticulationRoot() {
+    this.emit(`def Xform "RobotArticulation" (`);
+    this.indentLevel++;
+    this.emit(`prepend apiSchemas = ["PhysicsArticulationRootAPI"]`);
+    this.indentLevel--;
+    this.emit(`)`);
+    this.emit(`{`);
+    this.indentLevel++;
+    this.emit(`bool physics:articulationEnabled = true`);
+    this.emit(`# Isaac Sim articulation settings`);
+    this.emit(`bool physxArticulation:enabledSelfCollisions = false`);
+    this.emit(`uint physxArticulation:solverPositionIterationCount = 32`);
+    this.emit(`uint physxArticulation:solverVelocityIterationCount = 1`);
+    this.emitBlank();
+    for (const prim of this.prims) {
+      this.emitPrim(prim);
+      this.emitBlank();
+    }
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  // ===========================================================================
+  // PRIM EMISSION
+  // ===========================================================================
+  emitPrim(prim) {
+    const apiSchemas = prim.apis.map((api) => {
+      switch (api.type) {
+        case "PhysicsRigidBodyAPI":
+          return "PhysicsRigidBodyAPI";
+        case "PhysicsCollisionAPI":
+          return "PhysicsCollisionAPI";
+        case "PhysicsMassAPI":
+          return "PhysicsMassAPI";
+        case "PhysicsArticulationRootAPI":
+          return "PhysicsArticulationRootAPI";
+        default:
+          return null;
+      }
+    }).filter(Boolean);
+    if (apiSchemas.length > 0) {
+      const schemasStr = apiSchemas.map((s) => `"${s}"`).join(", ");
+      this.emit(
+        `def ${prim.typeName} "${this.escapeStringValue(prim.name, "TypeScript")}" (`
+      );
+      this.indentLevel++;
+      this.emit(`prepend apiSchemas = [${schemasStr}]`);
+      this.indentLevel--;
+      this.emit(`)`);
+    } else {
+      this.emit(
+        `def ${prim.typeName} "${this.escapeStringValue(prim.name, "TypeScript")}"`
+      );
+    }
+    this.emit(`{`);
+    this.indentLevel++;
+    if (prim.translation) {
+      this.emit(
+        `double3 xformOp:translate = (${prim.translation[0]}, ${prim.translation[1]}, ${prim.translation[2]})`
+      );
+    }
+    const useEulerRotation = this.options.targetContext === "isaac_sim";
+    if (prim.rotation && !this.isIdentityQuaternion(prim.rotation)) {
+      if (useEulerRotation) {
+        const euler = this.quaternionToEulerDegrees(prim.rotation);
+        this.emit(
+          `float3 xformOp:rotateXYZ = (${euler[0].toFixed(4)}, ${euler[1].toFixed(4)}, ${euler[2].toFixed(4)})`
+        );
+      } else {
+        this.emit(
+          `quatd xformOp:orient = (${prim.rotation[3]}, ${prim.rotation[0]}, ${prim.rotation[1]}, ${prim.rotation[2]})`
+        );
+      }
+    }
+    if (prim.scale && !this.isUniformScale(prim.scale)) {
+      this.emit(`double3 xformOp:scale = (${prim.scale[0]}, ${prim.scale[1]}, ${prim.scale[2]})`);
+    }
+    const hasTransform = prim.translation || prim.rotation || prim.scale;
+    if (hasTransform) {
+      const ops = [];
+      if (prim.translation) ops.push('"xformOp:translate"');
+      if (prim.rotation && !this.isIdentityQuaternion(prim.rotation)) {
+        ops.push(useEulerRotation ? '"xformOp:rotateXYZ"' : '"xformOp:orient"');
+      }
+      if (prim.scale && !this.isUniformScale(prim.scale)) ops.push('"xformOp:scale"');
+      this.emit(`uniform token[] xformOpOrder = [${ops.join(", ")}]`);
+    }
+    for (const api of prim.apis) {
+      this.emitAPIAttributes(api);
+    }
+    for (const child of prim.children) {
+      this.emitBlank();
+      this.emitPrim(child);
+    }
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  isIdentityQuaternion(q) {
+    return Math.abs(q[0]) < 1e-4 && Math.abs(q[1]) < 1e-4 && Math.abs(q[2]) < 1e-4 && Math.abs(q[3] - 1) < 1e-4;
+  }
+  isUniformScale(s) {
+    return Math.abs(s[0] - 1) < 1e-4 && Math.abs(s[1] - 1) < 1e-4 && Math.abs(s[2] - 1) < 1e-4;
+  }
+  emitAPIAttributes(api) {
+    switch (api.type) {
+      case "PhysicsRigidBodyAPI":
+        this.emitBlank();
+        this.emit(`# PhysicsRigidBodyAPI`);
+        this.emit(`bool physics:rigidBodyEnabled = ${api.rigidBodyEnabled}`);
+        if (api.kinematicEnabled !== void 0) {
+          this.emit(`bool physics:kinematicEnabled = ${api.kinematicEnabled}`);
+        }
+        if (api.startsAsleep !== void 0) {
+          this.emit(`bool physics:startsAsleep = ${api.startsAsleep}`);
+        }
+        if (api.linearVelocity) {
+          this.emit(
+            `float3 physics:velocity = (${api.linearVelocity[0]}, ${api.linearVelocity[1]}, ${api.linearVelocity[2]})`
+          );
+        }
+        if (api.angularVelocity) {
+          this.emit(
+            `float3 physics:angularVelocity = (${api.angularVelocity[0]}, ${api.angularVelocity[1]}, ${api.angularVelocity[2]})`
+          );
+        }
+        break;
+      case "PhysicsCollisionAPI":
+        this.emitBlank();
+        this.emit(`# PhysicsCollisionAPI`);
+        this.emit(`bool physics:collisionEnabled = ${api.collisionEnabled}`);
+        if (api.collisionShape) {
+          this.emit(`token physics:collisionShape = "${api.collisionShape}"`);
+        }
+        if (api.collisionSize) {
+          this.emit(
+            `float3 physics:collisionSize = (${api.collisionSize[0]}, ${api.collisionSize[1]}, ${api.collisionSize[2]})`
+          );
+        }
+        if (api.collisionRadius !== void 0) {
+          this.emit(`float physics:collisionRadius = ${api.collisionRadius}`);
+        }
+        if (api.collisionHeight !== void 0) {
+          this.emit(`float physics:collisionHeight = ${api.collisionHeight}`);
+        }
+        break;
+      case "PhysicsMassAPI":
+        this.emitBlank();
+        this.emit(`# PhysicsMassAPI`);
+        this.emit(`float physics:mass = ${api.mass}`);
+        if (api.density !== void 0) {
+          this.emit(`float physics:density = ${api.density}`);
+        }
+        if (api.centerOfMass) {
+          this.emit(
+            `point3f physics:centerOfMass = (${api.centerOfMass[0]}, ${api.centerOfMass[1]}, ${api.centerOfMass[2]})`
+          );
+        }
+        if (api.diagonalInertia) {
+          this.emit(
+            `float3 physics:diagonalInertia = (${api.diagonalInertia[0]}, ${api.diagonalInertia[1]}, ${api.diagonalInertia[2]})`
+          );
+        }
+        break;
+      case "PhysicsArticulationRootAPI":
+        this.emitBlank();
+        this.emit(`# PhysicsArticulationRootAPI`);
+        this.emit(`bool physics:articulationEnabled = ${api.articulationEnabled}`);
+        break;
+    }
+  }
+  // ===========================================================================
+  // JOINT EMISSION
+  // ===========================================================================
+  emitJoint(joint) {
+    const jointClass = this.getUSDJointClass(joint.jointType);
+    const hasLimits = joint.lowerLimit !== void 0 || joint.upperLimit !== void 0;
+    const hasDrives = joint.drives && joint.drives.length > 0;
+    this.emit(`def ${jointClass} "${joint.body0}_to_${joint.body1}_joint"`);
+    this.emit(`{`);
+    this.indentLevel++;
+    this.emit(`rel physics:body0 = <${joint.body0}>`);
+    this.emit(`rel physics:body1 = <${joint.body1}>`);
+    if (joint.localPos0) {
+      this.emit(
+        `point3f physics:localPos0 = (${joint.localPos0[0]}, ${joint.localPos0[1]}, ${joint.localPos0[2]})`
+      );
+    }
+    if (joint.localPos1) {
+      this.emit(
+        `point3f physics:localPos1 = (${joint.localPos1[0]}, ${joint.localPos1[1]}, ${joint.localPos1[2]})`
+      );
+    }
+    if (joint.localRot0) {
+      this.emit(
+        `quatf physics:localRot0 = (${joint.localRot0[3]}, ${joint.localRot0[0]}, ${joint.localRot0[1]}, ${joint.localRot0[2]})`
+      );
+    }
+    if (joint.localRot1) {
+      this.emit(
+        `quatf physics:localRot1 = (${joint.localRot1[3]}, ${joint.localRot1[0]}, ${joint.localRot1[1]}, ${joint.localRot1[2]})`
+      );
+    }
+    if (joint.jointType === "revolute" || joint.jointType === "prismatic") {
+      this.emit(`token physics:axis = "${joint.axis || "Z"}"`);
+    }
+    if (hasLimits) {
+      this.emitBlank();
+      this.emit(`# Joint limits`);
+      if (joint.lowerLimit !== void 0) {
+        this.emit(`float physics:lowerLimit = ${joint.lowerLimit}`);
+      }
+      if (joint.upperLimit !== void 0) {
+        this.emit(`float physics:upperLimit = ${joint.upperLimit}`);
+      }
+    }
+    if (hasDrives) {
+      for (const drive of joint.drives) {
+        this.emitDrive(drive, joint.axis || "Z");
+      }
+    }
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  getUSDJointClass(jointType) {
+    switch (jointType) {
+      case "revolute":
+        return "PhysicsRevoluteJoint";
+      case "prismatic":
+        return "PhysicsPrismaticJoint";
+      case "spherical":
+        return "PhysicsSphericalJoint";
+      case "fixed":
+        return "PhysicsFixedJoint";
+      case "d6":
+        return "PhysicsD6Joint";
+      default:
+        return "PhysicsFixedJoint";
+    }
+  }
+  emitDrive(drive, axis) {
+    const driveAttr = `physics:${axis.toLowerCase()}Drive`;
+    this.emitBlank();
+    this.emit(`# PhysicsDriveAPI`);
+    this.emit(`token ${driveAttr}:type = "${drive.driveType}"`);
+    if (drive.maxForce !== void 0) {
+      this.emit(`float ${driveAttr}:maxForce = ${drive.maxForce}`);
+    }
+    if (drive.targetPosition !== void 0) {
+      this.emit(`float ${driveAttr}:targetPosition = ${drive.targetPosition}`);
+    }
+    if (drive.targetVelocity !== void 0) {
+      this.emit(`float ${driveAttr}:targetVelocity = ${drive.targetVelocity}`);
+    }
+    if (drive.stiffness !== void 0) {
+      this.emit(`float ${driveAttr}:stiffness = ${drive.stiffness}`);
+    }
+    if (drive.damping !== void 0) {
+      this.emit(`float ${driveAttr}:damping = ${drive.damping}`);
+    }
+  }
+  // ===========================================================================
+  // EXTRACTION FROM COMPOSITION
+  // ===========================================================================
+  extractFromComposition(composition) {
+    this.materials.set("default", {
+      path: "/PhysicsMaterials/DefaultMaterial",
+      name: "DefaultMaterial",
+      staticFriction: this.options.defaultStaticFriction,
+      dynamicFriction: this.options.defaultDynamicFriction,
+      restitution: this.options.defaultRestitution
+    });
+    if (composition.objects) {
+      for (const obj of composition.objects) {
+        const prim = this.processObject(obj);
+        if (prim) {
+          this.prims.push(prim);
+        }
+      }
+    }
+    if (composition.spatialGroups) {
+      for (const group of composition.spatialGroups) {
+        const groupPrims = this.processSpatialGroup(group);
+        this.prims.push(...groupPrims);
+      }
+    }
+  }
+  processObject(obj, parentPath) {
+    const name = this.sanitizeName(obj.name);
+    const path = parentPath ? `${parentPath}/${name}` : name;
+    const hasPhysics = this.hasTrait(obj, "physics") || this.hasTrait(obj, "rigid");
+    const hasCollider = this.hasTrait(obj, "collidable") || this.hasTrait(obj, "trigger");
+    const isKinematic = this.hasTrait(obj, "kinematic");
+    const isArticulationRoot = this.hasTrait(obj, "articulation_root");
+    const physicsConfig = this.getTraitConfig(obj, "physics") || {};
+    const jointConfig = this.getTraitConfig(obj, "joint");
+    const geometry = this.extractGeometry(obj);
+    const position = this.extractPosition(obj);
+    const rotation = this.extractRotation(obj);
+    const scale = this.extractScale(obj);
+    let typeName = "Xform";
+    if (geometry) {
+      typeName = geometry.type === "Reference" ? "Xform" : geometry.type;
+    }
+    const apis = [];
+    if (hasPhysics) {
+      apis.push({
+        type: "PhysicsRigidBodyAPI",
+        rigidBodyEnabled: true,
+        kinematicEnabled: isKinematic
+      });
+    }
+    if (hasCollider || hasPhysics) {
+      const collisionApi = {
+        type: "PhysicsCollisionAPI",
+        collisionEnabled: true
+      };
+      if (geometry && geometry.type !== "Reference") {
+        collisionApi.collisionShape = geometry.type;
+        if (geometry.size) {
+          collisionApi.collisionSize = geometry.size;
+        }
+        if (geometry.radius !== void 0) {
+          collisionApi.collisionRadius = geometry.radius;
+        }
+        if (geometry.type === "Cylinder" || geometry.type === "Capsule" || geometry.type === "Cone") {
+          collisionApi.collisionHeight = scale[1];
+        }
+      }
+      apis.push(collisionApi);
+    }
+    if (hasPhysics) {
+      const mass = physicsConfig.mass ?? this.options.defaultMass;
+      apis.push({
+        type: "PhysicsMassAPI",
+        mass
+      });
+    }
+    if (isArticulationRoot) {
+      apis.push({
+        type: "PhysicsArticulationRootAPI",
+        articulationEnabled: true
+      });
+    }
+    if (jointConfig) {
+      const jointType = this.mapJointType(String(jointConfig.type || "fixed"));
+      const rawParentBody = String(jointConfig.connectedBody || "");
+      const articulationRoot = `/${this.compositionName}`;
+      const body0Path = rawParentBody ? rawParentBody.startsWith("/") ? rawParentBody : `${articulationRoot}/${this.sanitizeName(rawParentBody)}` : articulationRoot;
+      const body1Path = `/${this.compositionName}/${this.sanitizeName(name)}`;
+      const axis = this.mapAxis(jointConfig.axis);
+      const joint = {
+        type: "PhysicsJoint",
+        jointType,
+        body0: body0Path,
+        body1: body1Path,
+        axis
+      };
+      if (jointConfig.lowerLimit !== void 0 || jointConfig.upperLimit !== void 0) {
+        const isRevolute = jointType === "revolute";
+        joint.lowerLimit = jointConfig.lowerLimit !== void 0 ? isRevolute ? Number(jointConfig.lowerLimit) * (Math.PI / 180) : Number(jointConfig.lowerLimit) : void 0;
+        joint.upperLimit = jointConfig.upperLimit !== void 0 ? isRevolute ? Number(jointConfig.upperLimit) * (Math.PI / 180) : Number(jointConfig.upperLimit) : void 0;
+      }
+      if (jointConfig.motor) {
+        const motorConfig = jointConfig.motor;
+        joint.drives = [
+          {
+            type: "PhysicsDriveAPI",
+            driveType: motorConfig.type || "position",
+            maxForce: motorConfig.maxForce,
+            stiffness: motorConfig.stiffness,
+            damping: motorConfig.damping
+          }
+        ];
+      }
+      this.joints.push(joint);
+    }
+    return {
+      path,
+      name,
+      typeName,
+      translation: position,
+      rotation,
+      scale,
+      children: [],
+      apis
+    };
+  }
+  processSpatialGroup(group) {
+    const prims = [];
+    const groupName = this.sanitizeName(group.name);
+    const groupPrim = {
+      path: groupName,
+      name: groupName,
+      typeName: "Xform",
+      children: [],
+      apis: []
+    };
+    const hasRobotObjects = group.objects?.some((obj) => this.hasTrait(obj, "joint"));
+    if (hasRobotObjects) {
+      groupPrim.apis.push({
+        type: "PhysicsArticulationRootAPI",
+        articulationEnabled: true
+      });
+    }
+    if (group.objects) {
+      for (const obj of group.objects) {
+        const childPrim = this.processObject(obj, groupName);
+        if (childPrim) {
+          groupPrim.children.push(childPrim);
+        }
+      }
+    }
+    prims.push(groupPrim);
+    return prims;
+  }
+  // ===========================================================================
+  // SEMANTIC AST EMBEDDING (Metaverse Standards Forum interoperability)
+  // ===========================================================================
+  /**
+   * Emit a `customData` block on the root Xform carrying a compact
+   * representation of the HoloScript semantic AST.
+   *
+   * This enables downstream consumers (Omniverse extensions, Isaac Lab
+   * pipelines, or any USD-aware tool) to read the original behavioral
+   * intent without needing a HoloScript parser.
+   *
+   * The payload follows the MSF 3D Asset Interoperability WG recommendation
+   * of placing behavioral metadata in `customData` (USD) or `extras` (glTF).
+   */
+  emitSemanticCustomData(composition) {
+    this.emit(`# HoloScript Semantic AST (MSF Interoperability)`);
+    this.emit(`customData = {`);
+    this.indentLevel++;
+    this.emit(`string holoscript:version = "6.0"`);
+    this.emit(`string holoscript:compositionName = "${this.escapeStringValue(composition.name, "USD")}"`);
+    const objectNames = (composition.objects || []).map((o) => o.name);
+    if (objectNames.length > 0) {
+      const namesStr = objectNames.map((n) => `"${this.escapeStringValue(n, "USD")}"`).join(", ");
+      this.emit(`string[] holoscript:objects = [${namesStr}]`);
+    }
+    const allTraits = /* @__PURE__ */ new Set();
+    for (const obj of composition.objects || []) {
+      for (const trait of obj.traits || []) {
+        const tName = typeof trait === "string" ? trait : trait.name;
+        allTraits.add(tName);
+      }
+    }
+    if (allTraits.size > 0) {
+      const traitsStr = [...allTraits].map((t) => `"${this.escapeStringValue(t, "USD")}"`).join(", ");
+      this.emit(`string[] holoscript:traits = [${traitsStr}]`);
+    }
+    const groupNames = (composition.spatialGroups || []).map((g) => g.name);
+    if (groupNames.length > 0) {
+      const groupsStr = groupNames.map((n) => `"${this.escapeStringValue(n, "USD")}"`).join(", ");
+      this.emit(`string[] holoscript:spatialGroups = [${groupsStr}]`);
+    }
+    this.emit(`string holoscript:targetContext = "${this.options.targetContext}"`);
+    this.indentLevel--;
+    this.emit(`}`);
+  }
+  /**
+   * Convert a quaternion (x, y, z, w) back to Euler angles in degrees.
+   * Used when targetContext === 'isaac_sim' requires rotateXYZ ops.
+   */
+  quaternionToEulerDegrees(q) {
+    const [x, y, z, w] = q;
+    const RAD2DEG = 180 / Math.PI;
+    const sinr_cosp = 2 * (w * x + y * z);
+    const cosr_cosp = 1 - 2 * (x * x + y * y);
+    const roll = Math.atan2(sinr_cosp, cosr_cosp) * RAD2DEG;
+    const sinp = 2 * (w * y - z * x);
+    const pitch = Math.abs(sinp) >= 1 ? Math.sign(sinp) * 90 : Math.asin(sinp) * RAD2DEG;
+    const siny_cosp = 2 * (w * z + x * y);
+    const cosy_cosp = 1 - 2 * (y * y + z * z);
+    const yaw = Math.atan2(siny_cosp, cosy_cosp) * RAD2DEG;
+    return [roll, pitch, yaw];
+  }
+};
+function compileToUSDPhysics(composition, options) {
+  const compiler = new USDPhysicsCompiler(options);
+  return compiler.compile(composition, "system");
+}
+function compileForIsaacSim(composition, options) {
+  const isaacOptions = {
+    upAxis: "Z",
+    metersPerUnit: 1,
+    enableGPUDynamics: true,
+    enableArticulation: true,
+    timeCodesPerSecond: 60,
+    ...options
+  };
+  const compiler = new USDPhysicsCompiler(isaacOptions);
+  return compiler.compile(composition, "system");
+}
+
+export { USDPhysicsCompiler, compileForIsaacSim, compileToUSDPhysics };
+//# sourceMappingURL=chunk-LHAXPADA.js.map
+//# sourceMappingURL=chunk-LHAXPADA.js.map