@holoscript/robotics-plugin 1.0.0 → 2.0.1

package/dist/usd-codegen.js

@@ -1,49 +1,23 @@
-"use strict";
 /**
  * HoloScript → USD Code Generator
  *
  * Generates Universal Scene Description (USD) files from HoloScript AST.
- * Targets NVIDIA Isaac Sim with UsdPhysics schema.
+ * Targets NVIDIA Isaac Sim with UsdPhysics and PhysX schemas.
+ *
+ * Isaac Lab Interop (Path A):
+ * - Emits PhysicsDriveAPI for PD actuator control
+ * - Emits PhysxJointAxisAPI for per-axis joint friction assumptions
+ * - Supports domain randomization metadata for sim-to-real transfer
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.USDCodeGen = void 0;
-class USDCodeGen {
-    constructor() {
+export class USDCodeGen {
+    constructor(config) {
         this.output = [];
         this.indentLevel = 0;
+        this.config = {
+            isaacLabVersion: config?.isaacLabVersion || '2.3',
+            enableJointFriction: config?.enableJointFriction ?? true,
+            enableDriveAttributes: config?.enableDriveAttributes ?? true,
+        };
     }
     generate(ast) {
         this.output = [];
@@ -59,21 +33,44 @@ class USDCodeGen {
         this.indentLevel--;
         this.emit(')');
         this.emit('');
-        // Root articulation
+        // Isaac Lab header comment
+        this.emit(`# Generated for Isaac Lab ${this.config.isaacLabVersion}`);
+        this.emit('# Units: meters, kilograms, seconds; HoloScript angular inputs are radians.');
+        this.emit('# USD angular joint limits and velocities are exported in degrees per OpenUSD/PhysX.');
+        // Emit domain randomization config as USD comments (for Isaac Lab Python codegen)
+        if (ast.domainRandomization) {
+            this.emit('');
+            this.emit('# Domain Randomization Configuration');
+            this.emitDomainRandomizationAsComment(ast.domainRandomization);
+            this.emit('');
+        }
+        // Root articulation.
+        const rootSchemas = ['PhysicsArticulationRootAPI'];
+        if (this.config.enableJointFriction) {
+            rootSchemas.push('PhysxArticulationAPI');
+        }
         this.emit(`def Xform "${ast.name}" (`);
         this.indentLevel++;
-        this.emit('prepend apiSchemas = ["PhysicsArticulationRootAPI"]');
+        this.emit(`prepend apiSchemas = ${this.formatTokenArray(rootSchemas)}`);
         this.indentLevel--;
         this.emit(')');
         this.emit('{');
         this.indentLevel++;
+        if (this.config.enableJointFriction) {
+            this.emit('');
+            this.emit('# PhysxArticulationAPI root settings');
+            this.emit('bool physxArticulation:articulationEnabled = true');
+            this.emit('bool physxArticulation:enabledSelfCollisions = false');
+            this.emit('int physxArticulation:solverPositionIterationCount = 32');
+            this.emit('int physxArticulation:solverVelocityIterationCount = 1');
+        }
         // Collect joints for later generation
         const joints = [];
         // Separate joint and link objects
         const jointObjects = [];
         const linkObjects = [];
         for (const obj of ast.objects) {
-            if (obj.traits.includes('joint_revolute') || obj.traits.includes('joint_prismatic')) {
+            if (this.isJointObject(obj)) {
                 jointObjects.push(obj);
             }
             else {
@@ -82,10 +79,11 @@ class USDCodeGen {
         }
         // Generate links
         for (const obj of ast.objects) {
-            if (obj.traits.includes('joint_revolute') || obj.traits.includes('joint_prismatic')) {
+            if (this.isJointObject(obj)) {
                 // New template format: Joint is separate object
                 // Check if there's a corresponding link (child of this joint)
-                const childLink = linkObjects.find(link => link.properties.parent === obj.name);
+                const childLink = linkObjects.find((link) => link.properties.parent === obj.name);
+                const kind = this.getJointKind(obj);
                 if (childLink) {
                     // Generate the child link
                     this.generateLink(childLink);
@@ -93,9 +91,11 @@ class USDCodeGen {
                     const parent = obj.properties.parent || 'World';
                     joints.push({
                         name: obj.name,
+                        kind,
                         parent,
                         child: childLink.name,
                         props: obj.properties,
+                        actuatorGroups: obj.actuatorGroups,
                     });
                 }
                 else {
@@ -104,16 +104,18 @@ class USDCodeGen {
                     const parent = obj.properties.joint_parent || 'World';
                     joints.push({
                         name: `${obj.name}Joint`,
+                        kind,
                         parent,
                         child: obj.name,
                         props: obj.properties,
+                        actuatorGroups: obj.actuatorGroups,
                     });
                 }
             }
             else {
                 // Link object without joint (base, end effector, etc.)
                 // Only generate if not already generated as child of a joint
-                const isChildOfJoint = jointObjects.some(j => linkObjects.find(l => l.properties.parent === j.name && l.name === obj.name));
+                const isChildOfJoint = jointObjects.some((j) => linkObjects.find((l) => l.properties.parent === j.name && l.name === obj.name));
                 if (!isChildOfJoint) {
                     this.generateLink(obj);
                 }
@@ -135,6 +137,10 @@ class USDCodeGen {
         const isStatic = obj.traits.includes('static');
         this.emit('');
         this.emit(`# ${obj.name}`);
+        if (obj.domainRandomization) {
+            this.emit('# Object Domain Randomization Configuration');
+            this.emitDomainRandomizationAsComment(obj.domainRandomization);
+        }
         this.emit(`def ${usdType} "${obj.name}" (`);
         this.indentLevel++;
         // Add physics APIs (unless static)
@@ -200,10 +206,10 @@ class USDCodeGen {
         else if (obj.properties.material) {
             // Default colors based on material
             const materialColors = {
-                'metal': '0.6, 0.6, 0.65',
-                'plastic': '0.8, 0.8, 0.8',
-                'wood': '0.6, 0.4, 0.2',
-                'glass': '0.9, 0.9, 1.0',
+                metal: '0.6, 0.6, 0.65',
+                plastic: '0.8, 0.8, 0.8',
+                wood: '0.6, 0.4, 0.2',
+                glass: '0.9, 0.9, 1.0',
             };
             const material = obj.properties.material;
             const color = materialColors[material] || '0.8, 0.8, 0.8';
@@ -239,8 +245,17 @@ class USDCodeGen {
         this.emit('}');
     }
     generateJoint(joint) {
+        const axisToken = joint.kind === 'prismatic' ? 'linear' : 'angular';
+        const schemas = this.getJointApiSchemas(joint, axisToken);
         this.emit('');
-        this.emit(`def PhysicsRevoluteJoint "${joint.name}"`);
+        this.emit(`def ${joint.kind === 'prismatic' ? 'PhysicsPrismaticJoint' : 'PhysicsRevoluteJoint'} "${joint.name}"`);
+        if (schemas.length > 0) {
+            this.emit('(');
+            this.indentLevel++;
+            this.emit(`prepend apiSchemas = ${this.formatTokenArray(schemas)}`);
+            this.indentLevel--;
+            this.emit(')');
+        }
         this.emit('{');
         this.indentLevel++;
         // Body references
@@ -276,18 +291,53 @@ class USDCodeGen {
         const limits = joint.props.joint_limits || joint.props.limits;
         if (limits) {
             const limitsVec = limits;
-            this.emit(`float physics:lowerLimit = ${limitsVec[0]}`);
-            this.emit(`float physics:upperLimit = ${limitsVec[1]}`);
+            this.emit(`float physics:lowerLimit = ${this.formatNumber(this.convertJointScalar(limitsVec[0], joint.kind))}`);
+            this.emit(`float physics:upperLimit = ${this.formatNumber(this.convertJointScalar(limitsVec[1], joint.kind))}`);
         }
         this.emit('');
         // Joint dynamics (support both old and new property names)
-        const effort = joint.props.joint_effort || joint.props.max_effort;
-        if (effort) {
+        const effort = this.numberProp(joint.props, 'joint_effort', 'max_effort');
+        if (effort !== undefined) {
             this.emit(`float physics:maxForce = ${effort}`);
         }
-        const velocity = joint.props.max_velocity;
-        if (velocity) {
-            this.emit(`float physics:maxVelocity = ${velocity}`);
+        const velocity = this.numberProp(joint.props, 'max_velocity');
+        if (velocity !== undefined) {
+            this.emit(`float physics:maxVelocity = ${this.formatNumber(this.convertJointScalar(velocity, joint.kind))}`);
+        }
+        // OpenUSD PhysicsDriveAPI attributes for PD actuator control.
+        if (this.config.enableDriveAttributes && this.hasDriveProperties(joint.props)) {
+            this.emit('');
+            this.emit('# PhysicsDriveAPI attributes for PD control');
+            const kp = this.numberProp(joint.props, 'kp', 'stiffness');
+            const kd = this.numberProp(joint.props, 'kd', 'damping');
+            if (kp !== undefined) {
+                this.emit(`float drive:${axisToken}:physics:stiffness = ${kp}`);
+            }
+            if (kd !== undefined) {
+                this.emit(`float drive:${axisToken}:physics:damping = ${kd}`);
+            }
+            if (effort !== undefined) {
+                this.emit(`float drive:${axisToken}:physics:maxForce = ${effort}`);
+            }
+            this.emit(`uniform token drive:${axisToken}:physics:type = "force"`);
+        }
+        if (this.config.enableJointFriction && this.hasPhysxJointAxisProperties(joint.props)) {
+            this.emit('');
+            this.emit('# PhysxJointAxisAPI per-axis friction and velocity assumptions');
+            this.emitPhysxJointAxisProperties(joint.props, joint.kind, axisToken);
+        }
+        const latency = this.numberProp(joint.props, 'actuator_latency', 'latency');
+        if (latency !== undefined) {
+            this.emit('');
+            this.emit('# Isaac Lab delayed actuator hint; convert seconds to delay steps in task config.');
+            this.emit(`custom float holoscript:isaacLab:actuatorLatencySeconds = ${latency}`);
+        }
+        if (joint.actuatorGroups?.length) {
+            this.emit('');
+            this.emit('# Isaac Lab actuator group hints');
+            for (const group of joint.actuatorGroups) {
+                this.emitActuatorGroupComment(group);
+            }
         }
         this.indentLevel--;
         this.emit('}');
@@ -300,15 +350,89 @@ class USDCodeGen {
     }
     geometryToUSD(geometry) {
         const mapping = {
-            'cylinder': 'Cylinder',
-            'box': 'Cube',
-            'sphere': 'Sphere',
-            'cone': 'Cone',
-            'plane': 'Plane',
-            'torus': 'Torus',
+            cylinder: 'Cylinder',
+            box: 'Cube',
+            sphere: 'Sphere',
+            cone: 'Cone',
+            plane: 'Plane',
+            torus: 'Torus',
         };
         return mapping[geometry] || 'Cube';
     }
+    isJointObject(obj) {
+        return obj.traits.includes('joint_revolute') || obj.traits.includes('joint_prismatic');
+    }
+    getJointKind(obj) {
+        return obj.traits.includes('joint_prismatic') ? 'prismatic' : 'revolute';
+    }
+    getJointApiSchemas(joint, axisToken) {
+        const schemas = [];
+        if (this.config.enableDriveAttributes && this.hasDriveProperties(joint.props)) {
+            schemas.push(`PhysicsDriveAPI:${axisToken}`);
+        }
+        if (this.config.enableJointFriction && this.hasPhysxJointAxisProperties(joint.props)) {
+            schemas.push(`PhysxJointAxisAPI:${axisToken}`);
+        }
+        return schemas;
+    }
+    hasDriveProperties(props) {
+        return this.numberProp(props, 'kp', 'stiffness', 'kd', 'damping', 'joint_effort', 'max_effort') !== undefined;
+    }
+    hasPhysxJointAxisProperties(props) {
+        return (this.numberProp(props, 'joint_friction', 'friction', 'joint_static_friction', 'joint_dynamic_friction', 'joint_viscous_friction', 'armature', 'max_velocity') !== undefined);
+    }
+    emitPhysxJointAxisProperties(props, kind, axisToken) {
+        const friction = this.numberProp(props, 'joint_friction', 'friction');
+        const staticFriction = this.numberProp(props, 'joint_static_friction') ?? friction;
+        const dynamicFriction = this.numberProp(props, 'joint_dynamic_friction') ?? friction;
+        const viscousFriction = this.numberProp(props, 'joint_viscous_friction');
+        const armature = this.numberProp(props, 'armature');
+        const velocity = this.numberProp(props, 'max_velocity');
+        if (staticFriction !== undefined) {
+            this.emit(`float physxJointAxis:${axisToken}:staticFrictionEffort = ${staticFriction}`);
+        }
+        if (dynamicFriction !== undefined) {
+            this.emit(`float physxJointAxis:${axisToken}:dynamicFrictionEffort = ${dynamicFriction}`);
+        }
+        if (viscousFriction !== undefined) {
+            this.emit(`float physxJointAxis:${axisToken}:viscousFrictionCoefficient = ${viscousFriction}`);
+        }
+        if (armature !== undefined) {
+            this.emit(`float physxJointAxis:${axisToken}:armature = ${armature}`);
+        }
+        if (velocity !== undefined) {
+            this.emit(`float physxJointAxis:${axisToken}:maxJointVelocity = ${this.formatNumber(this.convertJointScalar(velocity, kind))}`);
+        }
+    }
+    emitActuatorGroupComment(group) {
+        const details = [
+            `type=${group.type}`,
+            `joints=[${group.jointNames.join(', ')}]`,
+            group.stiffness !== undefined ? `stiffness=${group.stiffness}` : undefined,
+            group.damping !== undefined ? `damping=${group.damping}` : undefined,
+            group.friction !== undefined ? `friction=${group.friction}` : undefined,
+            group.latency !== undefined ? `latencySeconds=${group.latency}` : undefined,
+        ].filter(Boolean);
+        this.emit(`#   ${group.name}: ${details.join(' ')}`);
+    }
+    numberProp(props, ...keys) {
+        for (const key of keys) {
+            const value = props[key];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    convertJointScalar(value, kind) {
+        return kind === 'revolute' ? (value * 180) / Math.PI : value;
+    }
+    formatNumber(value) {
+        return Number(value.toFixed(6)).toString();
+    }
+    formatTokenArray(values) {
+        return `[${values.map((value) => `"${value}"`).join(', ')}]`;
+    }
     vectorToAxisName(axis) {
         const [x = 0, y = 0, z = 1] = axis;
         if (Math.abs(x) > Math.abs(y) && Math.abs(x) > Math.abs(z)) {
@@ -321,41 +445,60 @@ class USDCodeGen {
             return 'Z';
         }
     }
-}
-exports.USDCodeGen = USDCodeGen;
-// Example usage
-if (require.main === module) {
-    Promise.resolve().then(() => __importStar(require('./lexer'))).then(({ Lexer }) => {
-        Promise.resolve().then(() => __importStar(require('./parser'))).then(({ Parser }) => {
-            const source = `
-composition "TwoLinkArm" {
-  object "Base" @static {
-    geometry: "cylinder"
-    dimensions: [0.1, 0.05]
-    material: "metal"
-    position: [0, 0, 0]
-  }
-
-  object "Link1" @joint_revolute {
-    geometry: "box"
-    dimensions: [0.5, 0.1, 0.1]
-    material: "metal"
-    joint_parent: "Base"
-    joint_axis: [0, 0, 1]
-    joint_limits: [-3.14, 3.14]
-    joint_effort: 100
-    mass: 1.0
-  }
-}
-`;
-            const lexer = new Lexer(source);
-            const tokens = lexer.tokenize();
-            const parser = new Parser(tokens);
-            const ast = parser.parse();
-            const codegen = new USDCodeGen();
-            const usd = codegen.generate(ast);
-            console.log('USD Output:');
-            console.log(usd);
-        });
-    });
+    emitDomainRandomizationAsComment(dr) {
+        if (dr.physics) {
+            this.emit('# physics:');
+            if (dr.physics.massScale) {
+                this.emit(`#   massScale: [${dr.physics.massScale[0]}, ${dr.physics.massScale[1]}]`);
+            }
+            if (dr.physics.frictionRange) {
+                this.emit(`#   frictionRange: [${dr.physics.frictionRange[0]}, ${dr.physics.frictionRange[1]}]`);
+            }
+            if (dr.physics.dampingRange) {
+                this.emit(`#   dampingRange: [${dr.physics.dampingRange[0]}, ${dr.physics.dampingRange[1]}]`);
+            }
+            if (dr.physics.armatureRange) {
+                this.emit(`#   armatureRange: [${dr.physics.armatureRange[0]}, ${dr.physics.armatureRange[1]}]`);
+            }
+        }
+        if (dr.actuator) {
+            this.emit('# actuator:');
+            if (dr.actuator.kpNoise !== undefined) {
+                this.emit(`#   kpNoise: ${dr.actuator.kpNoise}`);
+            }
+            if (dr.actuator.kdNoise !== undefined) {
+                this.emit(`#   kdNoise: ${dr.actuator.kdNoise}`);
+            }
+            if (dr.actuator.latencyNoise !== undefined) {
+                this.emit(`#   latencyNoise: ${dr.actuator.latencyNoise}`);
+            }
+        }
+        if (dr.observation) {
+            this.emit('# observation:');
+            if (dr.observation.jointPosNoise !== undefined) {
+                this.emit(`#   jointPosNoise: ${dr.observation.jointPosNoise}`);
+            }
+            if (dr.observation.jointVelNoise !== undefined) {
+                this.emit(`#   jointVelNoise: ${dr.observation.jointVelNoise}`);
+            }
+            if (dr.observation.imuNoise !== undefined) {
+                this.emit(`#   imuNoise: ${dr.observation.imuNoise}`);
+            }
+        }
+        if (dr.initialState) {
+            this.emit('# initialState:');
+            if (dr.initialState.rootPoseRange) {
+                this.emit(`#   rootPoseRange: [${dr.initialState.rootPoseRange.join(', ')}]`);
+            }
+        }
+        if (dr.disturbance) {
+            this.emit('# disturbance:');
+            if (dr.disturbance.forceRange) {
+                this.emit(`#   forceRange: [${dr.disturbance.forceRange[0]}, ${dr.disturbance.forceRange[1]}]`);
+            }
+            if (dr.disturbance.intervalRange) {
+                this.emit(`#   intervalRange: [${dr.disturbance.intervalRange[0]}, ${dr.disturbance.intervalRange[1]}]`);
+            }
+        }
+    }
 }

package/examples/isaac-lab-sim-to-real-bridge.holo

@@ -0,0 +1,63 @@
+# Isaac Lab Sim-to-Real Bridge Prototype v0.1
+# Task: task_1779183224900_643n [p3][build] — minimal bridge (idea-seed 51)
+# Source memo: research/2026-04-19_isaac-lab-sim-to-real.md (Claude 2026-04-19)
+#
+# Demonstrates the *declarative authoring surface* for Path A (HoloScript → Isaac Lab feed).
+# This composition is the thinnest runnable example that encodes the sim-to-real
+# parameters identified in the memo (§1.1–1.3): domain randomization, non-ideal actuators,
+# and future USD friction schema.
+#
+# Current state (2026-05-19): parser ignores the @isaac_lab block (no IsaacLabCompiler yet).
+# Future: usd-codegen.ts emits PhysxArticulationAPI + drive:* + joint-friction schema;
+#        IsaacLabCompiler.ts emits ManagerBasedRLEnvCfg + EventTermCfg references.
+#
+# See packages/plugins/robotics-plugin/python/isaac_lab_bridge.py for the matching
+# thin shim that "executes" the bridge concept without requiring an Isaac Sim license.
+
+robot spot {
+  # Base from existing robotics examples (robot-arm-complete.holo)
+  @urdf_export "spot.urdf"
+  @usd_export   "spot.usd"
+  @ros_node     { topic: "/joint_states", rate_hz: 30 }
+
+  @isaac_lab {
+    # Memo Path A, step 3 (DR vocabulary) + step 4 (actuator groups)
+    actuator_model: "DelayedPDActuator",   # maps to isaaclab.actuators.DelayedPDActuator
+    actuator_groups: {
+      legs: { kp: 120.0, kd: 8.0, latency_ms: 4 }   # explicit comms delay (sim-to-real)
+    }
+
+    domain_randomization: {
+      # EventTermCfg targets (isaaclab.envs.mdp.*)
+      rigid_body_mass:     { range: [0.95, 1.05], mode: "reset" }
+      rigid_body_friction: { range: [0.7, 1.3],   mode: "reset" }
+      joint_damping:       { range: [0.8, 1.2],   mode: "interval", interval_s: 2.0 }
+      push_force:          { magnitude: 120,      interval_s: [3, 12] }
+    }
+
+    observation_noise: {
+      joint_pos: 0.012,
+      joint_vel: 0.025,
+      imu:       0.018
+    }
+
+    # Future: emit PhysxJointFrictionAPI / PhysxArticulation:friction:* (memo §1.4)
+    joint_friction_schema: "physx"
+  }
+
+  # Minimal kinematic skeleton (enough for USD/Isaac import)
+  base_link { mass: 12.0 }
+  joints {
+    FL_hip  { type: revolute, axis: "y", limits: [-1.57, 1.57] }
+    FL_knee { type: revolute, axis: "x", limits: [-2.5,  2.5 ] }
+    # ... (truncated for prototype; full 12-DOF in real Spot asset)
+  }
+}
+
+# Done criteria for this task satisfied by:
+# - 1 runnable demo: python .../isaac_lab_bridge.py  (emits Isaac Lab stub config)
+# - Docs: this file header + memo cross-ref + py docstring
+# - Thin interop shim: maps HoloScript declarative → Isaac Lab EventTermCfg/ActuatorCfg
+#
+# Next (out of scope for p3): full IsaacLabCompiler.ts + usd-codegen patches (memo steps 1-5).
+# Verification: see commit that landed these two files + `python` execution output.

package/examples/isaac-lab-sim-to-real.holo

@@ -0,0 +1,127 @@
+// Isaac Lab Sim-to-Real Example
+// Demonstrates Path A: HoloScript -> Isaac Lab asset/export
+// Features:
+// - PhysicsDriveAPI for PD actuator control
+// - PhysxJointAxisAPI for per-axis joint friction assumptions
+// - Domain randomization configuration
+// - Delayed actuator metadata for communication latency
+
+composition "TwoLinkArm_IsaacLab" {
+  // Domain randomization at composition level
+  // These values are emitted as comments for Isaac Lab Python codegen
+  domain_randomization: {
+    physics: {
+      massScale: [0.8, 1.2]
+      frictionRange: [0.3, 0.7]
+      dampingRange: [0.0, 0.1]
+      armatureRange: [0.0001, 0.002]
+    }
+    actuator: {
+      kpNoise: 0.1
+      kdNoise: 0.05
+      latencyNoise: 0.002
+    }
+    observation: {
+      jointPosNoise: 0.001
+      jointVelNoise: 0.01
+      imuNoise: 0.005
+    }
+    initialState: {
+      rootPoseRange: [-0.5, 0.5, -0.5, 0.5, 0.0, 1.0]
+    }
+    disturbance: {
+      forceRange: [0.0, 5.0]
+      intervalRange: [1.0, 3.0]
+    }
+  }
+
+  object "base_link" {
+    @static
+    geometry: "cylinder"
+    radius: 0.1
+    height: 0.05
+    mass: 2.0
+    position: [0, 0, 0]
+    material: "metal"
+  }
+
+  object "joint1" {
+    @joint_revolute
+    joint_parent: "base_link"
+    joint_origin: [0, 0, 0.05]
+    joint_axis: [0, 0, 1]
+    joint_limits: [-3.14, 3.14]
+    joint_effort: 50
+    max_velocity: 3.14
+    // PD gains for Isaac Lab drive control
+    kp: 100.0
+    kd: 10.0
+    // Joint friction (sim-to-real)
+    joint_friction: 0.05
+    joint_viscous_friction: 0.01
+    armature: 0.001
+    // Actuator latency for DelayedPDActuator
+    actuator_latency: 0.005
+    actuator_group: {
+      name: "arm_group"
+      type: "DelayedPDActuator"
+      joints: ["joint1", "joint2"]
+      stiffness: 100
+      damping: 10
+      friction: 0.05
+      latency: 0.005
+    }
+  }
+
+  object "link1" {
+    @joint_revolute
+    joint_parent: "joint1"
+    geometry: "cylinder"
+    radius: 0.05
+    length: 0.3
+    mass: 1.0
+    position: [0, 0, 0.15]
+    material: "metal"
+    // Inertia tensor
+    inertia: [0.01, 0.01, 0.001, 0, 0, 0]
+    // PD gains
+    kp: 80.0
+    kd: 8.0
+    joint_friction: 0.03
+  }
+
+  object "joint2" {
+    @joint_revolute
+    joint_parent: "link1"
+    joint_origin: [0, 0, 0.3]
+    joint_axis: [0, 1, 0]
+    joint_limits: [-1.57, 1.57]
+    joint_effort: 30
+    max_velocity: 3.14
+    kp: 80.0
+    kd: 8.0
+    joint_friction: 0.03
+    actuator_latency: 0.005
+  }
+
+  object "link2" {
+    geometry: "cylinder"
+    radius: 0.04
+    length: 0.25
+    mass: 0.8
+    position: [0, 0, 0.125]
+    material: "metal"
+    inertia: [0.005, 0.005, 0.0008, 0, 0, 0]
+    kp: 60.0
+    kd: 6.0
+    joint_friction: 0.02
+  }
+
+  object "end_effector" {
+    geometry: "sphere"
+    radius: 0.03
+    mass: 0.2
+    position: [0, 0, 0.25]
+    material: "plastic"
+  }
+}