@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-HZTDET3N.js

@@ -0,0 +1,1399 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compilePhysicsBlock, physicsToURDF, compileMaterialBlock } from './chunk-JCLBKPMX.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/URDFCompiler.ts
+var URDFCompiler_exports = {};
+__export(URDFCompiler_exports, {
+  URDFCompiler: () => URDFCompiler,
+  compileForGazebo: () => compileForGazebo,
+  compileForIsaacSim: () => compileForIsaacSim,
+  compileForROS2: () => compileForROS2,
+  compileToURDF: () => compileToURDF,
+  createURDFCompiler: () => createURDFCompiler,
+  default: () => URDFCompiler_default,
+  generateControllersYaml: () => generateControllersYaml,
+  generateROS2LaunchFile: () => generateROS2LaunchFile
+});
+function createURDFCompiler(options) {
+  return new URDFCompiler(options);
+}
+function compileToURDF(composition, options) {
+  const compiler = new URDFCompiler(options);
+  return compiler.compile(composition);
+}
+function compileForROS2(composition, options) {
+  const ros2Options = {
+    includeGazeboPlugins: true,
+    includeROS2Control: true,
+    includeVisual: true,
+    includeCollision: true,
+    includeInertial: true,
+    ...options
+  };
+  const compiler = new URDFCompiler(ros2Options);
+  return compiler.compile(composition);
+}
+function compileForGazebo(composition, options) {
+  const gazeboOptions = {
+    includeGazeboPlugins: true,
+    gazeboVersion: "classic",
+    includeVisual: true,
+    includeCollision: true,
+    includeInertial: true,
+    ...options
+  };
+  const compiler = new URDFCompiler(gazeboOptions);
+  return compiler.compile(composition);
+}
+function compileForIsaacSim(composition, options) {
+  const isaacOptions = {
+    includeVisual: true,
+    includeCollision: true,
+    includeInertial: true,
+    includeGazeboPlugins: false,
+    // Isaac Sim uses PhysX, not Gazebo plugins
+    includeROS2Control: true,
+    includeIsaacSimExtensions: true,
+    isaacSimDriveType: "acceleration",
+    isaacSimTargetType: "position",
+    isaacSimSolverPositionIterations: 8,
+    isaacSimSolverVelocityIterations: 4,
+    ...options
+  };
+  const compiler = new URDFCompiler(isaacOptions);
+  return compiler.compile(composition);
+}
+function generateROS2LaunchFile(packageName, urdfFilename, options) {
+  const useSimTime = options?.useSimTime ?? true;
+  const rviz = options?.rviz ?? true;
+  const gazebo = options?.gazebo ?? true;
+  const controllers = options?.controllers ?? [
+    "joint_state_broadcaster",
+    "joint_trajectory_controller"
+  ];
+  const lines = [];
+  lines.push('"""');
+  lines.push(`ROS 2 Launch file for ${packageName}`);
+  lines.push("Auto-generated by HoloScript URDFCompiler");
+  lines.push('"""');
+  lines.push("");
+  lines.push("import os");
+  lines.push("from ament_index_python.packages import get_package_share_directory");
+  lines.push("from launch import LaunchDescription");
+  lines.push(
+    "from launch.actions import DeclareLaunchArgument, IncludeLaunchDescription, RegisterEventHandler"
+  );
+  lines.push("from launch.conditions import IfCondition");
+  lines.push("from launch.event_handlers import OnProcessExit");
+  lines.push("from launch.launch_description_sources import PythonLaunchDescriptionSource");
+  lines.push(
+    "from launch.substitutions import Command, FindExecutable, LaunchConfiguration, PathJoinSubstitution"
+  );
+  lines.push("from launch_ros.actions import Node");
+  lines.push("from launch_ros.substitutions import FindPackageShare");
+  lines.push("");
+  lines.push("");
+  lines.push("def generate_launch_description():");
+  lines.push(`    pkg_share = get_package_share_directory('${packageName}')`);
+  lines.push(`    urdf_file = os.path.join(pkg_share, 'urdf', '${urdfFilename}')`);
+  lines.push("");
+  lines.push('    with open(urdf_file, "r") as f:');
+  lines.push("        robot_description = f.read()");
+  lines.push("");
+  lines.push("    # Robot State Publisher");
+  lines.push("    robot_state_publisher = Node(");
+  lines.push("        package='robot_state_publisher',");
+  lines.push("        executable='robot_state_publisher',");
+  lines.push("        parameters=[{");
+  lines.push("            'robot_description': robot_description,");
+  lines.push(`            'use_sim_time': ${useSimTime ? "True" : "False"},`);
+  lines.push("        }],");
+  lines.push("        output='screen',");
+  lines.push("    )");
+  lines.push("");
+  if (rviz) {
+    lines.push("    # RViz2");
+    lines.push('    rviz_config = os.path.join(pkg_share, "config", "display.rviz")');
+    lines.push("    rviz = Node(");
+    lines.push("        package='rviz2',");
+    lines.push("        executable='rviz2',");
+    lines.push("        arguments=['-d', rviz_config],");
+    lines.push(`        parameters=[{'use_sim_time': ${useSimTime ? "True" : "False"}}],`);
+    lines.push("        output='screen',");
+    lines.push("    )");
+    lines.push("");
+  }
+  if (gazebo) {
+    lines.push("    # Gazebo");
+    lines.push("    gazebo = IncludeLaunchDescription(");
+    lines.push("        PythonLaunchDescriptionSource([");
+    lines.push("            FindPackageShare('ros_gz_sim'),");
+    lines.push("            '/launch/gz_sim.launch.py',");
+    lines.push("        ]),");
+    lines.push("        launch_arguments={'gz_args': '-r empty.sdf'}.items(),");
+    lines.push("    )");
+    lines.push("");
+    lines.push("    # Spawn robot");
+    lines.push("    spawn_entity = Node(");
+    lines.push("        package='ros_gz_sim',");
+    lines.push("        executable='create',");
+    lines.push(
+      "        arguments=['-topic', 'robot_description', '-name', '" + packageName + "'],"
+    );
+    lines.push("        output='screen',");
+    lines.push("    )");
+    lines.push("");
+  }
+  for (const controller of controllers) {
+    const varName = controller.replace(/-/g, "_");
+    lines.push(`    # ${controller}`);
+    lines.push(`    ${varName}_spawner = Node(`);
+    lines.push("        package='controller_manager',");
+    lines.push("        executable='spawner',");
+    lines.push(`        arguments=['${controller}'],`);
+    lines.push("        output='screen',");
+    lines.push("    )");
+    lines.push("");
+  }
+  lines.push("    return LaunchDescription([");
+  lines.push("        robot_state_publisher,");
+  if (rviz) lines.push("        rviz,");
+  if (gazebo) {
+    lines.push("        gazebo,");
+    lines.push("        spawn_entity,");
+  }
+  for (const controller of controllers) {
+    lines.push(`        ${controller.replace(/-/g, "_")}_spawner,`);
+  }
+  lines.push("    ])");
+  return lines.join("\n");
+}
+function generateControllersYaml(robotName, jointNames, options) {
+  const controllerType = options?.controllerType ?? "joint_trajectory_controller/JointTrajectoryController";
+  const publishRate = options?.publishRate ?? 50;
+  const lines = [];
+  lines.push("# Auto-generated by HoloScript URDFCompiler");
+  lines.push(`# Robot: ${robotName}`);
+  lines.push("");
+  lines.push("controller_manager:");
+  lines.push("  ros__parameters:");
+  lines.push(`    update_rate: ${publishRate}`);
+  lines.push("");
+  lines.push("    joint_state_broadcaster:");
+  lines.push("      type: joint_state_broadcaster/JointStateBroadcaster");
+  lines.push("");
+  lines.push("    joint_trajectory_controller:");
+  lines.push(`      type: ${controllerType}`);
+  lines.push("");
+  lines.push("joint_trajectory_controller:");
+  lines.push("  ros__parameters:");
+  lines.push("    joints:");
+  for (const joint of jointNames) {
+    lines.push(`      - ${joint}`);
+  }
+  lines.push("    command_interfaces:");
+  lines.push("      - position");
+  lines.push("    state_interfaces:");
+  lines.push("      - position");
+  lines.push("      - velocity");
+  return lines.join("\n");
+}
+var URDFCompiler, URDFCompiler_default;
+var init_URDFCompiler = __esm({
+  "src/compiler/URDFCompiler.ts"() {
+    init_CompilerBase();
+    init_DomainBlockCompilerMixin();
+    URDFCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "URDFCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.links = [];
+        this.joints = [];
+        this.materials = /* @__PURE__ */ new Map();
+        this.sensors = [];
+        this.transmissions = [];
+        this.ros2Controls = [];
+        this.isaacSimSensors = [];
+        this.loopJoints = [];
+        this.fixedFrames = [];
+        this.options = {
+          robotName: options.robotName || "HoloScriptRobot",
+          includeVisual: options.includeVisual ?? true,
+          includeCollision: options.includeCollision ?? true,
+          includeInertial: options.includeInertial ?? true,
+          defaultMass: options.defaultMass ?? 1,
+          meshPathPrefix: options.meshPathPrefix || "package://meshes/",
+          includeHoloExtensions: options.includeHoloExtensions ?? true,
+          includeGazeboPlugins: options.includeGazeboPlugins ?? false,
+          includeROS2Control: options.includeROS2Control ?? false,
+          gazeboVersion: options.gazeboVersion ?? "classic",
+          gazeboPhysicsEngine: options.gazeboPhysicsEngine ?? "ode",
+          defaultMu1: options.defaultMu1 ?? 0.5,
+          defaultMu2: options.defaultMu2 ?? 0.5,
+          defaultKp: options.defaultKp ?? 1e6,
+          defaultKd: options.defaultKd ?? 100,
+          enableSelfCollision: options.enableSelfCollision ?? false,
+          packageName: options.packageName ?? "holoscript_robot",
+          includeIsaacSimExtensions: options.includeIsaacSimExtensions ?? false,
+          isaacSimDriveType: options.isaacSimDriveType ?? "acceleration",
+          isaacSimTargetType: options.isaacSimTargetType ?? "position",
+          isaacSimSolverPositionIterations: options.isaacSimSolverPositionIterations ?? 8,
+          isaacSimSolverVelocityIterations: options.isaacSimSolverVelocityIterations ?? 4
+        };
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.URDF;
+      }
+      // ===========================================================================
+      // 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 { name: _name, ...config } = trait;
+        return config;
+      }
+      /** Map HoloScript joint types to URDF joint types */
+      mapJointType(holoType) {
+        switch (holoType) {
+          case "hinge":
+          case "revolute":
+            return "revolute";
+          case "slider":
+          case "prismatic":
+            return "prismatic";
+          case "ball":
+          case "floating":
+            return "floating";
+          case "fixed":
+            return "fixed";
+          case "continuous":
+            return "continuous";
+          case "planar":
+            return "planar";
+          default:
+            return "fixed";
+        }
+      }
+      /** Sanitize name for URDF element names (Isaac Sim compatible) */
+      sanitizeName(name) {
+        let sanitized = name.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+        if (sanitized.startsWith("_")) {
+          sanitized = "a" + sanitized;
+        }
+        return sanitized;
+      }
+      /** Escape special characters for XML attribute values */
+      escapeXml(str) {
+        return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      }
+      /** 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("");
+      }
+      /** Convert HoloValue to string */
+      getStringValue(value) {
+        if (typeof value === "string") return value;
+        if (typeof value === "number") return String(value);
+        if (typeof value === "boolean") return String(value);
+        return "";
+      }
+      /** Parse hex color string to RGBA components */
+      parseColor(color) {
+        if (color.startsWith("#")) {
+          const hex = color.slice(1);
+          return {
+            r: parseInt(hex.slice(0, 2), 16) / 255,
+            g: parseInt(hex.slice(2, 4), 16) / 255,
+            b: parseInt(hex.slice(4, 6), 16) / 255,
+            a: hex.length > 6 ? parseInt(hex.slice(6, 8), 16) / 255 : 1
+          };
+        }
+        const colors = {
+          red: { r: 1, g: 0, b: 0, a: 1 },
+          green: { r: 0, g: 0.8, b: 0, a: 1 },
+          blue: { r: 0, g: 0, b: 1, a: 1 },
+          white: { r: 1, g: 1, b: 1, a: 1 },
+          black: { r: 0, g: 0, b: 0, a: 1 },
+          yellow: { r: 1, g: 1, b: 0, a: 1 },
+          cyan: { r: 0, g: 1, b: 1, a: 1 },
+          magenta: { r: 1, g: 0, b: 1, a: 1 },
+          orange: { r: 1, g: 0.65, b: 0, a: 1 },
+          gray: { r: 0.5, g: 0.5, b: 0.5, a: 1 },
+          grey: { r: 0.5, g: 0.5, b: 0.5, a: 1 }
+        };
+        return colors[color.toLowerCase()] || { r: 0.8, g: 0.8, b: 0.8, a: 1 };
+      }
+      // ===========================================================================
+      // EXTRACTION METHODS
+      // ===========================================================================
+      /** Extract position from object properties */
+      extractPosition(obj) {
+        const posProp = obj.properties.find((p) => p.key === "position");
+        if (posProp && Array.isArray(posProp.value)) {
+          return [
+            Number(posProp.value[0]) || 0,
+            Number(posProp.value[1]) || 0,
+            Number(posProp.value[2]) || 0
+          ];
+        }
+        return [0, 0, 0];
+      }
+      /** Extract rotation from object properties (degrees -> radians) */
+      extractRotation(obj) {
+        const rotProp = obj.properties.find((p) => p.key === "rotation");
+        if (rotProp && Array.isArray(rotProp.value)) {
+          return [
+            (Number(rotProp.value[0]) || 0) * Math.PI / 180,
+            (Number(rotProp.value[1]) || 0) * Math.PI / 180,
+            (Number(rotProp.value[2]) || 0) * Math.PI / 180
+          ];
+        }
+        return [0, 0, 0];
+      }
+      /** Extract uniform scale value from object properties */
+      extractScale(obj) {
+        const scaleProp = obj.properties.find((p) => p.key === "scale");
+        if (scaleProp) {
+          if (typeof scaleProp.value === "number") {
+            return scaleProp.value;
+          }
+          if (Array.isArray(scaleProp.value)) {
+            return Number(scaleProp.value[0]) || 1;
+          }
+        }
+        return 1;
+      }
+      /** Extract 3D scale from object properties */
+      extractScale3D(obj) {
+        const scaleProp = obj.properties.find((p) => p.key === "scale");
+        if (scaleProp) {
+          if (typeof scaleProp.value === "number") {
+            return [scaleProp.value, scaleProp.value, scaleProp.value];
+          }
+          if (Array.isArray(scaleProp.value) && scaleProp.value.length >= 3) {
+            return [
+              Number(scaleProp.value[0]) || 1,
+              Number(scaleProp.value[1]) || 1,
+              Number(scaleProp.value[2]) || 1
+            ];
+          }
+        }
+        return [1, 1, 1];
+      }
+      /** Extract color from object properties */
+      extractColor(obj) {
+        const colorProp = obj.properties.find((p) => p.key === "color");
+        return colorProp ? this.getStringValue(colorProp.value) : void 0;
+      }
+      /** Extract mass from physics property or trait */
+      extractMass(obj) {
+        const physicsProp = obj.properties.find((p) => p.key === "physics");
+        if (physicsProp && typeof physicsProp.value === "object" && !Array.isArray(physicsProp.value)) {
+          const massEntry = physicsProp.value.mass;
+          if (typeof massEntry === "number") return massEntry;
+        }
+        const massProp = obj.properties.find((p) => p.key === "mass");
+        if (massProp && typeof massProp.value === "number") return massProp.value;
+        return void 0;
+      }
+      /** Extract geometry type and dimensions from object */
+      extractGeometry(obj) {
+        const geometryProp = obj.properties.find((p) => p.key === "geometry");
+        if (!geometryProp) return void 0;
+        const geometryValue = this.getStringValue(geometryProp.value);
+        const scale = this.extractScale(obj);
+        switch (geometryValue) {
+          case "cube":
+          case "box":
+            return { type: "box", size: [scale, scale, scale] };
+          case "sphere":
+            return { type: "sphere", radius: scale / 2 };
+          case "cylinder":
+            return { type: "cylinder", radius: scale / 2, length: scale };
+          case "cone":
+            return { type: "cylinder", radius: scale / 2, length: scale };
+          case "capsule":
+            return { type: "cylinder", radius: scale / 3, length: scale };
+          case "plane":
+            return { type: "box", size: [scale, 0.01, scale] };
+          default:
+            if (geometryValue.endsWith(".glb") || geometryValue.endsWith(".dae") || geometryValue.endsWith(".stl") || geometryValue.endsWith(".obj")) {
+              const filename = geometryValue.replace(".glb", ".stl").replace(".dae", ".stl").replace(".obj", ".stl");
+              return {
+                type: "mesh",
+                filename: `${this.options.meshPathPrefix}${filename}`,
+                scale: this.extractScale3D(obj)
+              };
+            }
+            return { type: "box", size: [scale, scale, scale] };
+        }
+      }
+      /** Calculate inertia tensor from geometry and mass */
+      calculateInertia(geometry, mass) {
+        let ixx = mass * (1 + 1) / 12;
+        let iyy = mass * (1 + 1) / 12;
+        let izz = mass * (1 + 1) / 12;
+        if (geometry) {
+          switch (geometry.type) {
+            case "box": {
+              const [w, h, d] = geometry.size || [1, 1, 1];
+              ixx = mass * (h * h + d * d) / 12;
+              iyy = mass * (w * w + d * d) / 12;
+              izz = mass * (w * w + h * h) / 12;
+              break;
+            }
+            case "sphere": {
+              const r = geometry.radius || 0.5;
+              ixx = iyy = izz = 2 / 5 * mass * r * r;
+              break;
+            }
+            case "cylinder": {
+              const r = geometry.radius || 0.5;
+              const l = geometry.length || 1;
+              ixx = iyy = mass * (3 * r * r + l * l) / 12;
+              izz = mass * r * r / 2;
+              break;
+            }
+          }
+        }
+        return {
+          mass,
+          inertia: { ixx, ixy: 0, ixz: 0, iyy, iyz: 0, izz }
+        };
+      }
+      // ===========================================================================
+      // COMPILATION
+      // ===========================================================================
+      /**
+       * Compile HoloScript composition to URDF XML
+       */
+      compile(composition, agentToken, outputPath) {
+        if (agentToken) {
+          this.validateCompilerAccess(agentToken, outputPath);
+        }
+        this.lines = [];
+        this.links = [];
+        this.joints = [];
+        this.materials.clear();
+        this.sensors = [];
+        this.transmissions = [];
+        this.ros2Controls = [];
+        this.isaacSimSensors = [];
+        this.loopJoints = [];
+        this.fixedFrames = [];
+        this.indentLevel = 0;
+        this.extractFromComposition(composition);
+        this.emit('<?xml version="1.0"?>');
+        this.emit(`<!-- Auto-generated by HoloScript URDFCompiler v2.0 -->`);
+        this.emit(
+          `<!-- Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}" -->`
+        );
+        this.emit(`<!-- Target: ROS 2 / Gazebo / MoveIt 2 / RViz2 -->`);
+        this.emitBlank();
+        this.emit(`<robot name="${this.escapeXml(this.options.robotName)}">`);
+        this.indentLevel++;
+        this.emitMaterials();
+        for (const link of this.links) {
+          this.emitLink(link);
+        }
+        for (const joint of this.joints) {
+          this.emitJoint(joint);
+        }
+        if (this.transmissions.length > 0) {
+          this.emitBlank();
+          this.emit("<!-- Transmissions -->");
+          for (const transmission of this.transmissions) {
+            this.emitTransmission(transmission);
+          }
+        }
+        if (this.options.includeROS2Control && this.ros2Controls.length > 0) {
+          this.emitBlank();
+          this.emit("<!-- ROS 2 Control Hardware Interface -->");
+          for (const control of this.ros2Controls) {
+            this.emitROS2Control(control);
+          }
+        }
+        if (this.options.includeGazeboPlugins) {
+          this.emitBlank();
+          this.emitGazeboPlugins(composition);
+        }
+        if (this.sensors.length > 0 && this.options.includeGazeboPlugins) {
+          for (const sensor of this.sensors) {
+            this.emitGazeboSensor(sensor);
+          }
+        }
+        if (this.options.includeIsaacSimExtensions) {
+          this.emitIsaacSimExtensions();
+        }
+        if (this.options.includeHoloExtensions) {
+          this.emitHoloExtensions(composition);
+        }
+        this.emitDomainBlocks(composition);
+        this.indentLevel--;
+        this.emit("</robot>");
+        return this.lines.join("\n");
+      }
+      emitDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emitBlank();
+        this.emit("<!-- v4.2 Domain Blocks -->");
+        const compiled = compileDomainBlocks(
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = compileMaterialBlock(block);
+              const lines = [];
+              lines.push(
+                `<material name="${this.escapeStringValue(mat.name, "TypeScript")}">`
+              );
+              if (mat.baseColor) {
+                const h = mat.baseColor.replace("#", "");
+                const r = (parseInt(h.substring(0, 2), 16) / 255).toFixed(3);
+                const g = (parseInt(h.substring(2, 4), 16) / 255).toFixed(3);
+                const b = (parseInt(h.substring(4, 6), 16) / 255).toFixed(3);
+                lines.push(`  <color rgba="${r} ${g} ${b} ${mat.opacity ?? 1}"/>`);
+              }
+              for (const [mapType, path] of Object.entries(mat.textureMaps)) {
+                if (mapType === "albedo_map") {
+                  lines.push(`  <texture filename="${path}"/>`);
+                }
+              }
+              lines.push("</material>");
+              return lines.join("\n");
+            },
+            physics: (block) => {
+              const phys = compilePhysicsBlock(block);
+              return physicsToURDF(phys);
+            },
+            audio: (block) => {
+              const audio = compileAudioSourceBlock(block);
+              return `<!-- Audio: ${this.escapeStringValue(audio.name, "TypeScript")} (${audio.keyword}) clip="${audio.properties.clip || ""}" volume="${audio.properties.volume ?? 1}" -->`;
+            },
+            weather: (block) => {
+              const weather = compileWeatherBlock(block);
+              return `<!-- Weather: ${weather.keyword} "${weather.name || ""}" layers: ${weather.layers.map((l) => l.type).join(", ")} -->`;
+            }
+          },
+          (block) => `<!-- Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}" -->`
+        );
+        for (const output of compiled) {
+          for (const line of output.split("\n")) {
+            this.emit(line);
+          }
+        }
+      }
+      // ===========================================================================
+      // EXTRACTION FROM COMPOSITION
+      // ===========================================================================
+      extractFromComposition(composition) {
+        this.materials.set("default", {
+          name: "default",
+          color: { r: 0.8, g: 0.8, b: 0.8, a: 1 }
+        });
+        this.links.push({
+          name: "base_link",
+          visual: void 0,
+          collision: void 0,
+          inertial: {
+            mass: 1e-3,
+            inertia: { ixx: 1e-3, ixy: 0, ixz: 0, iyy: 1e-3, iyz: 0, izz: 1e-3 }
+          }
+        });
+        const actuatedJoints = [];
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            this.processObject(obj, "base_link", actuatedJoints);
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            this.processSpatialGroup(group, "base_link", actuatedJoints);
+          }
+        }
+        if (this.options.includeROS2Control && actuatedJoints.length > 0) {
+          this.ros2Controls.push({
+            name: `${this.sanitizeName(this.options.robotName)}_ros2_control`,
+            type: "system",
+            hardwarePlugin: "gz_ros2_control/GazeboSimSystem",
+            joints: actuatedJoints
+          });
+        }
+      }
+      processObject(obj, parentLink, actuatedJoints) {
+        const linkName = this.sanitizeName(obj.name);
+        const hasPhysics = this.hasTrait(obj, "physics") || this.hasTrait(obj, "rigid");
+        const hasCollider = this.hasTrait(obj, "collidable") || this.hasTrait(obj, "trigger");
+        const jointConfig = this.getTraitConfig(obj, "joint");
+        const sensorConfig = this.getTraitConfig(obj, "sensor");
+        const actuatorConfig = this.getTraitConfig(obj, "actuator");
+        const geometry = this.extractGeometry(obj);
+        const position = this.extractPosition(obj);
+        const rotation = this.extractRotation(obj);
+        const color = this.extractColor(obj);
+        if (color) {
+          const colorHash = color.replace(/[^a-zA-Z0-9]/g, "");
+          const matName = `material_${linkName}_${colorHash}`;
+          const rgba = this.parseColor(color);
+          this.materials.set(matName, {
+            name: matName,
+            color: rgba
+          });
+        }
+        const link = {
+          name: linkName,
+          origin: {
+            xyz: position,
+            rpy: rotation
+          }
+        };
+        if (this.options.includeVisual && geometry) {
+          link.visual = { ...geometry, color };
+        }
+        if (this.options.includeCollision && (hasCollider || hasPhysics) && geometry) {
+          link.collision = geometry;
+        }
+        if (this.options.includeInertial) {
+          const mass = this.extractMass(obj) || this.options.defaultMass;
+          link.inertial = this.calculateInertia(geometry, mass);
+        }
+        this.links.push(link);
+        const joint = {
+          name: `${parentLink}_to_${linkName}_joint`,
+          type: "fixed",
+          parent: parentLink,
+          child: linkName,
+          origin: {
+            xyz: position,
+            rpy: rotation
+          }
+        };
+        if (jointConfig) {
+          if (jointConfig.jointType) {
+            joint.type = this.mapJointType(jointConfig.jointType);
+          }
+          if (jointConfig.axis) {
+            const axis = jointConfig.axis;
+            joint.axis = Array.isArray(axis) ? [axis[0] ?? 0, axis[1] ?? 0, axis[2] ?? 1] : [axis[0] ?? 0, axis[1] ?? 0, axis[2] ?? 1];
+          }
+          if (jointConfig.limits && (joint.type === "revolute" || joint.type === "prismatic")) {
+            const limitsConfig = jointConfig.limits;
+            joint.limits = {
+              lower: joint.type === "revolute" ? (limitsConfig.min ?? -180) * Math.PI / 180 : limitsConfig.min ?? -1,
+              upper: joint.type === "revolute" ? (limitsConfig.max ?? 180) * Math.PI / 180 : limitsConfig.max ?? 1,
+              effort: limitsConfig.effort ?? 100,
+              velocity: limitsConfig.velocity ?? 1
+            };
+          }
+          if (jointConfig.damping !== void 0) {
+            joint.dynamics = {
+              damping: jointConfig.damping,
+              friction: jointConfig.friction ?? 0
+            };
+          }
+          if (jointConfig.mimic) {
+            const mimicConfig = jointConfig.mimic;
+            joint.mimic = {
+              joint: mimicConfig.joint,
+              multiplier: mimicConfig.multiplier ?? 1,
+              offset: mimicConfig.offset ?? 0
+            };
+          }
+          if (jointConfig.safetyController) {
+            const safety = jointConfig.safetyController;
+            joint.safetyController = {
+              softLowerLimit: safety.softLowerLimit ?? 0,
+              softUpperLimit: safety.softUpperLimit ?? 0,
+              kPosition: safety.kPosition ?? 100,
+              kVelocity: safety.kVelocity ?? 10
+            };
+          }
+          if (jointConfig.connectedBody) {
+            const newParent = this.sanitizeName(jointConfig.connectedBody);
+            joint.parent = newParent;
+            joint.name = `${newParent}_to_${linkName}_joint`;
+          }
+          if (joint.type !== "fixed" && this.options.includeROS2Control) {
+            const interfaces = this.getJointInterfaces(joint.type);
+            const actuatedEntry = {
+              name: joint.name,
+              type: joint.type,
+              ...interfaces
+            };
+            if (joint.mimic) {
+              actuatedEntry.mimic = joint.mimic;
+            }
+            actuatedJoints.push(actuatedEntry);
+          }
+        }
+        this.joints.push(joint);
+        if (sensorConfig) {
+          this.processSensorTrait(sensorConfig, linkName);
+        }
+        if (actuatorConfig) {
+          this.processActuatorTrait(actuatorConfig, joint.name, linkName);
+        }
+      }
+      processSpatialGroup(group, parentLink, actuatedJoints) {
+        const groupLinkName = this.sanitizeName(group.name);
+        this.links.push({
+          name: groupLinkName,
+          inertial: {
+            mass: 1e-3,
+            inertia: { ixx: 1e-3, ixy: 0, ixz: 0, iyy: 1e-3, iyz: 0, izz: 1e-3 }
+          }
+        });
+        this.joints.push({
+          name: `${parentLink}_to_${groupLinkName}_joint`,
+          type: "fixed",
+          parent: parentLink,
+          child: groupLinkName
+        });
+        if (group.objects) {
+          for (const obj of group.objects) {
+            this.processObject(obj, groupLinkName, actuatedJoints);
+          }
+        }
+      }
+      /** Process @sensor trait into sensor definition */
+      processSensorTrait(config, parentLink) {
+        const sensorType = config.sensorType || config.type || "camera";
+        const name = config.name || `${parentLink}_${sensorType}_sensor`;
+        const sensor = {
+          name: this.sanitizeName(name),
+          type: this.mapSensorType(sensorType),
+          parentLink,
+          updateRate: config.updateRate ?? 30,
+          topicName: config.topic ?? `/${this.sanitizeName(name)}`,
+          frameName: config.frameName ?? `${parentLink}_${sensorType}_frame`
+        };
+        if (sensor.type === "camera" || sensor.type === "depth_camera") {
+          sensor.camera = {
+            horizontalFov: config.fov ?? 1.3962634,
+            imageWidth: config.width ?? 640,
+            imageHeight: config.height ?? 480,
+            clipNear: config.clipNear ?? 0.1,
+            clipFar: config.clipFar ?? 100,
+            format: config.format ?? "R8G8B8"
+          };
+        }
+        if (sensor.type === "lidar" || sensor.type === "ray") {
+          sensor.lidar = {
+            samples: config.samples ?? 360,
+            resolution: config.resolution ?? 1,
+            minAngle: config.minAngle ?? -Math.PI,
+            maxAngle: config.maxAngle ?? Math.PI,
+            minRange: config.minRange ?? 0.1,
+            maxRange: config.maxRange ?? 30
+          };
+        }
+        if (sensor.type === "imu") {
+          sensor.imu = {
+            gaussianNoise: config.noise ?? 0
+          };
+        }
+        this.sensors.push(sensor);
+      }
+      /** Map sensor type strings to URDF sensor types */
+      mapSensorType(type) {
+        switch (type.toLowerCase()) {
+          case "camera":
+          case "rgb_camera":
+            return "camera";
+          case "depth":
+          case "depth_camera":
+          case "rgbd":
+            return "depth_camera";
+          case "imu":
+            return "imu";
+          case "lidar":
+          case "laser":
+            return "lidar";
+          case "ray":
+            return "ray";
+          case "force_torque":
+          case "ft":
+            return "force_torque";
+          case "contact":
+          case "bumper":
+            return "contact";
+          case "gps":
+          case "navsat":
+            return "gps";
+          default:
+            return "camera";
+        }
+      }
+      /** Process @actuator trait into transmission definition */
+      processActuatorTrait(config, jointName, linkName) {
+        const transmission = {
+          name: `${linkName}_transmission`,
+          type: config.transmissionType ?? "transmission_interface/SimpleTransmission",
+          jointName,
+          actuatorName: config.actuatorName ?? `${linkName}_actuator`,
+          hardwareInterface: config.hardwareInterface ?? "hardware_interface/PositionJointInterface",
+          mechanicalReduction: config.mechanicalReduction
+        };
+        this.transmissions.push(transmission);
+      }
+      /** Get command and state interfaces for ros2_control based on joint type */
+      getJointInterfaces(jointType) {
+        switch (jointType) {
+          case "revolute":
+          case "continuous":
+            return {
+              commandInterfaces: ["position"],
+              stateInterfaces: ["position", "velocity"]
+            };
+          case "prismatic":
+            return {
+              commandInterfaces: ["position"],
+              stateInterfaces: ["position", "velocity"]
+            };
+          default:
+            return {
+              commandInterfaces: ["position"],
+              stateInterfaces: ["position"]
+            };
+        }
+      }
+      // ===========================================================================
+      // EMISSION METHODS
+      // ===========================================================================
+      /** Emit all materials */
+      emitMaterials() {
+        this.emit("<!-- Materials -->");
+        for (const [_key, mat] of this.materials) {
+          this.emit(`<material name="${this.escapeStringValue(mat.name, "TypeScript")}">`);
+          this.indentLevel++;
+          this.emit(`<color rgba="${mat.color.r} ${mat.color.g} ${mat.color.b} ${mat.color.a}"/>`);
+          if (mat.texture) {
+            this.emit(`<texture filename="${mat.texture}"/>`);
+          }
+          this.indentLevel--;
+          this.emit("</material>");
+        }
+        this.emitBlank();
+      }
+      /** Emit a single link element */
+      emitLink(link) {
+        this.emit(`<link name="${this.escapeStringValue(link.name, "TypeScript")}">`);
+        this.indentLevel++;
+        if (link.visual) {
+          this.emit("<visual>");
+          this.indentLevel++;
+          if (link.origin) {
+            this.emitOrigin(link.origin);
+          }
+          this.emitGeometry(link.visual);
+          if (link.visual.color) {
+            const colorHash = link.visual.color.replace(/[^a-zA-Z0-9]/g, "");
+            const matName = `material_${this.escapeStringValue(link.name, "TypeScript")}_${colorHash}`;
+            if (this.materials.has(matName)) {
+              this.emit(`<material name="${matName}"/>`);
+            } else {
+              this.emit('<material name="default"/>');
+            }
+          } else {
+            this.emit('<material name="default"/>');
+          }
+          this.indentLevel--;
+          this.emit("</visual>");
+        }
+        if (link.collision) {
+          this.emit("<collision>");
+          this.indentLevel++;
+          if (link.origin) {
+            this.emitOrigin(link.origin);
+          }
+          this.emitGeometry(link.collision);
+          this.indentLevel--;
+          this.emit("</collision>");
+        }
+        if (link.inertial) {
+          this.emit("<inertial>");
+          this.indentLevel++;
+          if (link.inertial.origin) {
+            this.emitOrigin(link.inertial.origin);
+          }
+          this.emit(`<mass value="${link.inertial.mass}"/>`);
+          const i = link.inertial.inertia;
+          this.emit(
+            `<inertia ixx="${i.ixx.toFixed(6)}" ixy="${i.ixy}" ixz="${i.ixz}" iyy="${i.iyy.toFixed(6)}" iyz="${i.iyz}" izz="${i.izz.toFixed(6)}"/>`
+          );
+          this.indentLevel--;
+          this.emit("</inertial>");
+        }
+        this.indentLevel--;
+        this.emit("</link>");
+        this.emitBlank();
+      }
+      /** Emit a single joint element */
+      emitJoint(joint) {
+        this.emit(
+          `<joint name="${this.escapeStringValue(joint.name, "TypeScript")}" type="${joint.type}">`
+        );
+        this.indentLevel++;
+        this.emit(`<parent link="${joint.parent}"/>`);
+        this.emit(`<child link="${joint.child}"/>`);
+        if (joint.origin) {
+          this.emitOrigin(joint.origin);
+        }
+        if (joint.axis) {
+          this.emit(`<axis xyz="${joint.axis.join(" ")}"/>`);
+        }
+        if (joint.limits) {
+          this.emit(
+            `<limit lower="${joint.limits.lower}" upper="${joint.limits.upper}" effort="${joint.limits.effort}" velocity="${joint.limits.velocity}"/>`
+          );
+        }
+        if (joint.dynamics) {
+          this.emit(
+            `<dynamics damping="${joint.dynamics.damping}" friction="${joint.dynamics.friction}"/>`
+          );
+        }
+        if (joint.mimic) {
+          this.emit(
+            `<mimic joint="${joint.mimic.joint}" multiplier="${joint.mimic.multiplier}" offset="${joint.mimic.offset}"/>`
+          );
+        }
+        if (joint.safetyController) {
+          this.emit(
+            `<safety_controller soft_lower_limit="${joint.safetyController.softLowerLimit}" soft_upper_limit="${joint.safetyController.softUpperLimit}" k_position="${joint.safetyController.kPosition}" k_velocity="${joint.safetyController.kVelocity}"/>`
+          );
+        }
+        this.indentLevel--;
+        this.emit("</joint>");
+        this.emitBlank();
+      }
+      /** Emit geometry element */
+      emitGeometry(geom) {
+        this.emit("<geometry>");
+        this.indentLevel++;
+        switch (geom.type) {
+          case "box":
+            this.emit(`<box size="${(geom.size || [1, 1, 1]).join(" ")}"/>`);
+            break;
+          case "sphere":
+            this.emit(`<sphere radius="${geom.radius || 0.5}"/>`);
+            break;
+          case "cylinder":
+            this.emit(`<cylinder radius="${geom.radius || 0.5}" length="${geom.length || 1}"/>`);
+            break;
+          case "mesh":
+            if (geom.scale && (geom.scale[0] !== 1 || geom.scale[1] !== 1 || geom.scale[2] !== 1)) {
+              this.emit(`<mesh filename="${geom.filename}" scale="${geom.scale.join(" ")}"/>`);
+            } else {
+              this.emit(`<mesh filename="${geom.filename}"/>`);
+            }
+            break;
+        }
+        this.indentLevel--;
+        this.emit("</geometry>");
+      }
+      /** Emit origin element */
+      emitOrigin(origin) {
+        this.emit(
+          `<origin xyz="${origin.xyz.join(" ")}" rpy="${origin.rpy.map((v) => v.toFixed(6)).join(" ")}"/>`
+        );
+      }
+      /** Emit transmission element (for ros_control) */
+      emitTransmission(trans) {
+        this.emit(
+          `<transmission name="${this.escapeStringValue(trans.name, "TypeScript")}">`
+        );
+        this.indentLevel++;
+        this.emit(`<type>${trans.type}</type>`);
+        this.emit(`<joint name="${trans.jointName}">`);
+        this.indentLevel++;
+        this.emit(`<hardwareInterface>${trans.hardwareInterface}</hardwareInterface>`);
+        this.indentLevel--;
+        this.emit("</joint>");
+        this.emit(`<actuator name="${trans.actuatorName}">`);
+        this.indentLevel++;
+        this.emit(`<hardwareInterface>${trans.hardwareInterface}</hardwareInterface>`);
+        if (trans.mechanicalReduction !== void 0) {
+          this.emit(`<mechanicalReduction>${trans.mechanicalReduction}</mechanicalReduction>`);
+        }
+        this.indentLevel--;
+        this.emit("</actuator>");
+        this.indentLevel--;
+        this.emit("</transmission>");
+        this.emitBlank();
+      }
+      /** Emit ros2_control hardware interface block */
+      emitROS2Control(control) {
+        this.emit(
+          `<ros2_control name="${this.escapeStringValue(control.name, "TypeScript")}" type="${control.type}">`
+        );
+        this.indentLevel++;
+        this.emit("<hardware>");
+        this.indentLevel++;
+        this.emit(`<plugin>${control.hardwarePlugin}</plugin>`);
+        if (control.parameters) {
+          for (const [key, value] of Object.entries(control.parameters)) {
+            this.emit(`<param name="${key}">${value}</param>`);
+          }
+        }
+        this.indentLevel--;
+        this.emit("</hardware>");
+        for (const joint of control.joints) {
+          this.emit(`<joint name="${this.escapeStringValue(joint.name, "TypeScript")}">`);
+          this.indentLevel++;
+          for (const iface of joint.commandInterfaces) {
+            this.emit(`<command_interface name="${iface}"/>`);
+          }
+          for (const iface of joint.stateInterfaces) {
+            this.emit(`<state_interface name="${iface}"/>`);
+          }
+          if (joint.mimic) {
+            this.emit(`<param name="mimic">${joint.mimic.joint}</param>`);
+            this.emit(`<param name="multiplier">${joint.mimic.multiplier}</param>`);
+          }
+          this.indentLevel--;
+          this.emit("</joint>");
+        }
+        if (control.sensors) {
+          for (const sensor of control.sensors) {
+            this.emit(`<sensor name="${this.escapeStringValue(sensor.name, "TypeScript")}">`);
+            this.indentLevel++;
+            for (const iface of sensor.stateInterfaces) {
+              this.emit(`<state_interface name="${iface}"/>`);
+            }
+            this.indentLevel--;
+            this.emit("</sensor>");
+          }
+        }
+        this.indentLevel--;
+        this.emit("</ros2_control>");
+        this.emitBlank();
+      }
+      /** Emit Gazebo plugin tags */
+      emitGazeboPlugins(composition) {
+        this.emit("<!-- Gazebo Plugins -->");
+        this.emit("<gazebo>");
+        this.indentLevel++;
+        if (this.options.enableSelfCollision) {
+          this.emit("<self_collide>true</self_collide>");
+        }
+        if (this.options.includeROS2Control && this.ros2Controls.length > 0) {
+          this.emit('<plugin filename="gz_ros2_control-system" name="gz_ros2_control">');
+          this.indentLevel++;
+          this.emit(
+            "<parameters>$(find " + this.options.packageName + ")/config/controllers.yaml</parameters>"
+          );
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        this.indentLevel--;
+        this.emit("</gazebo>");
+        this.emitBlank();
+        for (const link of this.links) {
+          if (link.name === "base_link" && !link.visual) continue;
+          const hasSpecialConfig = link.visual?.color || link.collision;
+          if (hasSpecialConfig) {
+            this.emit(
+              `<gazebo reference="${this.escapeStringValue(link.name, "TypeScript")}">`
+            );
+            this.indentLevel++;
+            if (link.visual?.color) {
+              const rgba = this.parseColor(link.visual.color);
+              this.emit(`<material>Gazebo/${this.getGazeboColorName(rgba)}</material>`);
+            }
+            if (link.collision) {
+              this.emit(`<mu1>${this.options.defaultMu1}</mu1>`);
+              this.emit(`<mu2>${this.options.defaultMu2}</mu2>`);
+              this.emit(`<kp>${this.options.defaultKp}</kp>`);
+              this.emit(`<kd>${this.options.defaultKd}</kd>`);
+            }
+            this.indentLevel--;
+            this.emit("</gazebo>");
+            this.emitBlank();
+          }
+        }
+      }
+      /** Map RGBA to closest Gazebo built-in color name */
+      getGazeboColorName(rgba) {
+        if (rgba.r > 0.8 && rgba.g < 0.3 && rgba.b < 0.3) return "Red";
+        if (rgba.r < 0.3 && rgba.g > 0.6 && rgba.b < 0.3) return "Green";
+        if (rgba.r < 0.3 && rgba.g < 0.3 && rgba.b > 0.8) return "Blue";
+        if (rgba.r > 0.8 && rgba.g > 0.8 && rgba.b < 0.3) return "Yellow";
+        if (rgba.r < 0.3 && rgba.g > 0.8 && rgba.b > 0.8) return "Turquoise";
+        if (rgba.r > 0.8 && rgba.g < 0.3 && rgba.b > 0.8) return "Purple";
+        if (rgba.r > 0.8 && rgba.g > 0.5 && rgba.b < 0.2) return "Orange";
+        if (rgba.r > 0.9 && rgba.g > 0.9 && rgba.b > 0.9) return "White";
+        if (rgba.r < 0.1 && rgba.g < 0.1 && rgba.b < 0.1) return "Black";
+        if (rgba.r > 0.4 && rgba.r < 0.6 && rgba.g > 0.4 && rgba.g < 0.6) return "Grey";
+        return "DarkGrey";
+      }
+      /** Emit Gazebo sensor tag for a specific sensor */
+      emitGazeboSensor(sensor) {
+        this.emit(`<gazebo reference="${sensor.parentLink}">`);
+        this.indentLevel++;
+        this.emit(
+          `<sensor name="${this.escapeStringValue(sensor.name, "TypeScript")}" type="${this.getGazeboSensorType(sensor.type)}">`
+        );
+        this.indentLevel++;
+        this.emit(`<always_on>true</always_on>`);
+        this.emit(`<update_rate>${sensor.updateRate ?? 30}</update_rate>`);
+        this.emit(`<visualize>true</visualize>`);
+        if ((sensor.type === "camera" || sensor.type === "depth_camera") && sensor.camera) {
+          this.emit("<camera>");
+          this.indentLevel++;
+          this.emit(`<horizontal_fov>${sensor.camera.horizontalFov}</horizontal_fov>`);
+          this.emit("<image>");
+          this.indentLevel++;
+          this.emit(`<width>${sensor.camera.imageWidth}</width>`);
+          this.emit(`<height>${sensor.camera.imageHeight}</height>`);
+          this.emit(`<format>${sensor.camera.format || "R8G8B8"}</format>`);
+          this.indentLevel--;
+          this.emit("</image>");
+          this.emit("<clip>");
+          this.indentLevel++;
+          this.emit(`<near>${sensor.camera.clipNear}</near>`);
+          this.emit(`<far>${sensor.camera.clipFar}</far>`);
+          this.indentLevel--;
+          this.emit("</clip>");
+          this.indentLevel--;
+          this.emit("</camera>");
+          this.emit('<plugin name="camera_controller" filename="libgazebo_ros_camera.so">');
+          this.indentLevel++;
+          this.emit(`<frame_name>${sensor.frameName}</frame_name>`);
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        if ((sensor.type === "lidar" || sensor.type === "ray") && sensor.lidar) {
+          this.emit("<ray>");
+          this.indentLevel++;
+          this.emit("<scan>");
+          this.indentLevel++;
+          this.emit("<horizontal>");
+          this.indentLevel++;
+          this.emit(`<samples>${sensor.lidar.samples}</samples>`);
+          this.emit(`<resolution>${sensor.lidar.resolution}</resolution>`);
+          this.emit(`<min_angle>${sensor.lidar.minAngle}</min_angle>`);
+          this.emit(`<max_angle>${sensor.lidar.maxAngle}</max_angle>`);
+          this.indentLevel--;
+          this.emit("</horizontal>");
+          this.indentLevel--;
+          this.emit("</scan>");
+          this.emit("<range>");
+          this.indentLevel++;
+          this.emit(`<min>${sensor.lidar.minRange}</min>`);
+          this.emit(`<max>${sensor.lidar.maxRange}</max>`);
+          this.emit("<resolution>0.01</resolution>");
+          this.indentLevel--;
+          this.emit("</range>");
+          this.indentLevel--;
+          this.emit("</ray>");
+          this.emit('<plugin name="laser_controller" filename="libgazebo_ros_ray_sensor.so">');
+          this.indentLevel++;
+          this.emit(`<ros><remapping>~/out:=${sensor.topicName || "/scan"}</remapping></ros>`);
+          this.emit("<output_type>sensor_msgs/LaserScan</output_type>");
+          this.emit(`<frame_name>${sensor.frameName}</frame_name>`);
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        if (sensor.type === "imu") {
+          this.emit("<imu>");
+          this.indentLevel++;
+          if (sensor.imu?.gaussianNoise) {
+            this.emit(
+              `<noise><type>gaussian</type><stddev>${sensor.imu.gaussianNoise}</stddev></noise>`
+            );
+          }
+          this.indentLevel--;
+          this.emit("</imu>");
+          this.emit('<plugin name="imu_controller" filename="libgazebo_ros_imu_sensor.so">');
+          this.indentLevel++;
+          this.emit(`<ros><remapping>~/out:=${sensor.topicName || "/imu/data"}</remapping></ros>`);
+          this.emit(`<frame_name>${sensor.frameName}</frame_name>`);
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        if (sensor.type === "force_torque") {
+          this.emit("<force_torque>");
+          this.indentLevel++;
+          this.emit("<measure_direction>child_to_parent</measure_direction>");
+          this.indentLevel--;
+          this.emit("</force_torque>");
+        }
+        if (sensor.type === "contact") {
+          this.emit("<contact>");
+          this.indentLevel++;
+          this.emit(`<collision>${sensor.parentLink}_collision</collision>`);
+          this.indentLevel--;
+          this.emit("</contact>");
+          this.emit('<plugin name="bumper_controller" filename="libgazebo_ros_bumper.so">');
+          this.indentLevel++;
+          this.emit(
+            `<ros><remapping>bumper_states:=${sensor.topicName || "/bumper"}</remapping></ros>`
+          );
+          this.emit(`<frame_name>${sensor.frameName}</frame_name>`);
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        if (sensor.type === "gps") {
+          this.emit('<plugin name="gps_controller" filename="libgazebo_ros_gps_sensor.so">');
+          this.indentLevel++;
+          this.emit(`<ros><remapping>~/out:=${sensor.topicName || "/gps/fix"}</remapping></ros>`);
+          this.emit(`<frame_name>${sensor.frameName}</frame_name>`);
+          this.indentLevel--;
+          this.emit("</plugin>");
+        }
+        this.indentLevel--;
+        this.emit("</sensor>");
+        this.indentLevel--;
+        this.emit("</gazebo>");
+        this.emitBlank();
+      }
+      /** Map sensor type to Gazebo sensor type string */
+      getGazeboSensorType(type) {
+        switch (type) {
+          case "camera":
+            return "camera";
+          case "depth_camera":
+            return "depth";
+          case "imu":
+            return "imu";
+          case "lidar":
+          case "ray":
+            return "ray";
+          case "force_torque":
+            return "force_torque";
+          case "contact":
+            return "contact";
+          case "gps":
+            return "gps";
+          default:
+            return "camera";
+        }
+      }
+      /** Emit HoloScript extension comments */
+      emitHoloExtensions(composition) {
+        this.emitBlank();
+        this.emit("<!-- HoloScript Extensions -->");
+        this.emit(
+          `<!-- Original composition: "${this.escapeStringValue(composition.name, "TypeScript")}" -->`
+        );
+        const skybox = this.getEnvProp(composition, "skybox");
+        if (skybox && typeof skybox === "string") {
+          this.emit(`<!-- Environment skybox: ${skybox} -->`);
+        }
+        if (composition.templates && composition.templates.length > 0) {
+          this.emit(`<!-- Templates: ${composition.templates.map((t) => t.name).join(", ")} -->`);
+        }
+        if (this.sensors.length > 0) {
+          this.emit(
+            `<!-- Sensors: ${this.sensors.map((s) => `${this.escapeStringValue(s.name, "TypeScript")} (${s.type})`).join(", ")} -->`
+          );
+        }
+      }
+      /** Helper to get environment property from either array or object format */
+      getEnvProp(composition, key) {
+        const env = composition.environment;
+        if (!env) return void 0;
+        if (Array.isArray(env.properties)) {
+          const prop = env.properties.find((p) => p.key === key);
+          if (prop) return prop.value;
+        }
+        if (key in env) {
+          return env[key];
+        }
+        if (env.properties && typeof env.properties === "object" && !Array.isArray(env.properties)) {
+          const props = env.properties;
+          if (key in props) {
+            return props[key];
+          }
+        }
+        return void 0;
+      }
+      // ===========================================================================
+      // ISAAC SIM EXTENSION EMISSION
+      // ===========================================================================
+      /** Emit Isaac Sim sensor extension tag */
+      emitIsaacSimSensor(sensor) {
+        this.emit(
+          `<sensor name="${this.escapeStringValue(sensor.name, "TypeScript")}" type="${sensor.type}" isaac_sim_config="${sensor.isaacSimConfig}">`
+        );
+        this.indentLevel++;
+        this.emit(`<parent link="${sensor.parentLink}"/>`);
+        if (sensor.origin) {
+          this.emitOrigin(sensor.origin);
+        }
+        this.indentLevel--;
+        this.emit("</sensor>");
+      }
+      /** Emit Isaac Sim loop joint extension tag */
+      emitLoopJoint(loopJoint) {
+        this.emit(
+          `<loop_joint name="${this.escapeStringValue(loopJoint.name, "TypeScript")}" type="${loopJoint.type}">`
+        );
+        this.indentLevel++;
+        this.emit(
+          `<link1 link="${loopJoint.link1.link}" rpy="${loopJoint.link1.rpy.join(" ")}" xyz="${loopJoint.link1.xyz.join(" ")}"/>`
+        );
+        this.emit(
+          `<link1 link="${loopJoint.link2.link}" rpy="${loopJoint.link2.rpy.join(" ")}" xyz="${loopJoint.link2.xyz.join(" ")}"/>`
+        );
+        this.indentLevel--;
+        this.emit("</loop_joint>");
+      }
+      /** Emit Isaac Sim fixed frame extension tag */
+      emitFixedFrame(frame) {
+        this.emit(`<fixed_frame name="${this.escapeStringValue(frame.name, "TypeScript")}">`);
+        this.indentLevel++;
+        this.emit(`<parent link="${frame.parentLink}"/>`);
+        this.emitOrigin(frame.origin);
+        this.indentLevel--;
+        this.emit("</fixed_frame>");
+      }
+      /** Emit Isaac Sim PhysX configuration comments */
+      emitIsaacSimExtensions() {
+        if (!this.options.includeIsaacSimExtensions) return;
+        this.emitBlank();
+        this.emit("<!-- Isaac Sim Extensions -->");
+        for (const sensor of this.isaacSimSensors) {
+          this.emitIsaacSimSensor(sensor);
+        }
+        for (const loopJoint of this.loopJoints) {
+          this.emitLoopJoint(loopJoint);
+        }
+        for (const fixedFrame of this.fixedFrames) {
+          this.emitFixedFrame(fixedFrame);
+        }
+        this.emit(
+          `<!-- isaac_sim_config: drive_type=${this.options.isaacSimDriveType} target_type=${this.options.isaacSimTargetType} -->`
+        );
+        this.emit(
+          `<!-- isaac_sim_config: solver_position_iterations=${this.options.isaacSimSolverPositionIterations} solver_velocity_iterations=${this.options.isaacSimSolverVelocityIterations} -->`
+        );
+      }
+    };
+    URDFCompiler_default = URDFCompiler;
+  }
+});
+
+export { URDFCompiler, URDFCompiler_default, URDFCompiler_exports, compileForGazebo, compileForIsaacSim, compileForROS2, compileToURDF, createURDFCompiler, generateControllersYaml, generateROS2LaunchFile, init_URDFCompiler };
+//# sourceMappingURL=chunk-HZTDET3N.js.map
+//# sourceMappingURL=chunk-HZTDET3N.js.map