@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-EQV4R3EV.cjs

@@ -1,769 +0,0 @@
-'use strict';
-
-var chunkLXJ4667L_cjs = require('./chunk-LXJ4667L.cjs');
-var chunkBF2235SI_cjs = require('./chunk-BF2235SI.cjs');
-var platform = require('@holoscript/platform');
-
-// src/compiler/USDPhysicsCompiler.ts
-chunkBF2235SI_cjs.init_CompilerBase();
-chunkLXJ4667L_cjs.init_DomainBlockCompilerMixin();
-var USDPhysicsCompiler = class extends chunkBF2235SI_cjs.CompilerBase {
-  constructor(options = {}) {
-    super();
-    this.compilerName = "USDPhysicsCompiler";
-    this.lines = [];
-    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
-    };
-  }
-  getRequiredCapability() {
-    return platform.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.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.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 = chunkLXJ4667L_cjs.compileDomainBlocks(
-        domainBlocks,
-        {
-          material: (block) => {
-            const mat = chunkLXJ4667L_cjs.compileMaterialBlock(block);
-            return chunkLXJ4667L_cjs.materialToUSD(mat);
-          },
-          physics: (block) => {
-            const phys = chunkLXJ4667L_cjs.compilePhysicsBlock(block);
-            const urdf = chunkLXJ4667L_cjs.physicsToURDF(phys);
-            return `# Physics: ${phys.keyword} "${phys.name || ""}"
-` + urdf.split("\n").map((l) => `# URDF: ${l}`).join("\n");
-          },
-          vfx: (block) => {
-            const ps = chunkLXJ4667L_cjs.compileParticleBlock(block);
-            return chunkLXJ4667L_cjs.particlesToUSD(ps);
-          },
-          postfx: (block) => {
-            const pp = chunkLXJ4667L_cjs.compilePostProcessingBlock(block);
-            return chunkLXJ4667L_cjs.postProcessingToUSD(pp);
-          },
-          audio: (block) => {
-            const audio = chunkLXJ4667L_cjs.compileAudioSourceBlock(block);
-            return chunkLXJ4667L_cjs.audioSourceToUSD(audio);
-          },
-          weather: (block) => {
-            const weather = chunkLXJ4667L_cjs.compileWeatherBlock(block);
-            return chunkLXJ4667L_cjs.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) {
-    this.emit(`#usda 1.0`);
-    this.emit(`(`);
-    this.indentLevel++;
-    this.emit(`defaultPrim = "${this.sanitizeName(name)}"`);
-    this.emit(`doc = "Generated by HoloScript USDPhysicsCompiler for NVIDIA Isaac Sim"`);
-    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 v3.0"`);
-    this.emit(`string targetRuntime = "Isaac Sim / Omniverse"`);
-    this.indentLevel--;
-    this.emit(`}`);
-    this.indentLevel--;
-    this.emit(`)`);
-  }
-  // ===========================================================================
-  // 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]})`
-      );
-    }
-    if (prim.rotation && !this.isIdentityQuaternion(prim.rotation)) {
-      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('"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}`);
-        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) {
-      apis.push({
-        type: "PhysicsCollisionAPI",
-        collisionEnabled: true
-      });
-    }
-    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 parentBody = String(jointConfig.connectedBody || "base_link");
-      const axis = this.mapAxis(jointConfig.axis);
-      const joint = {
-        type: "PhysicsJoint",
-        jointType,
-        body0: parentBody,
-        body1: `RobotArticulation/${name}`,
-        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;
-  }
-};
-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");
-}
-
-exports.USDPhysicsCompiler = USDPhysicsCompiler;
-exports.compileForIsaacSim = compileForIsaacSim;
-exports.compileToUSDPhysics = compileToUSDPhysics;
-//# sourceMappingURL=chunk-EQV4R3EV.cjs.map
-//# sourceMappingURL=chunk-EQV4R3EV.cjs.map