@holoscript/robotics-plugin 1.0.0 → 2.0.1

package/dist/parser.js

@@ -1,47 +1,11 @@
-"use strict";
 /**
  * HoloScript Parser
  *
  * Converts token stream into Abstract Syntax Tree (AST).
  * Uses recursive descent parsing.
  */
-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.Parser = void 0;
-const lexer_1 = require("./lexer");
-class Parser {
+import { TokenType } from './lexer';
+export class Parser {
     constructor(tokens) {
         this.position = 0;
         this.tokens = tokens;
@@ -80,45 +44,89 @@ class Parser {
         return this.advance();
     }
     parseComposition() {
-        const startToken = this.expect(lexer_1.TokenType.KEYWORD, 'composition');
-        const name = this.expect(lexer_1.TokenType.STRING).value;
-        this.expect(lexer_1.TokenType.LBRACE);
+        const startToken = this.expect(TokenType.KEYWORD, 'composition');
+        const name = this.expect(TokenType.STRING).value;
+        this.expect(TokenType.LBRACE);
         const objects = [];
-        while (this.currentToken().type !== lexer_1.TokenType.RBRACE && this.currentToken().type !== lexer_1.TokenType.EOF) {
-            objects.push(this.parseObject());
+        let domainRandomization;
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            // Check for domain_randomization block at composition level
+            if (this.currentToken().type === TokenType.IDENTIFIER &&
+                this.currentToken().value === 'domain_randomization') {
+                this.advance();
+                this.expect(TokenType.COLON);
+                domainRandomization = this.parseDomainRandomizationBlock();
+            }
+            else {
+                objects.push(this.parseObject());
+            }
         }
-        this.expect(lexer_1.TokenType.RBRACE);
+        this.expect(TokenType.RBRACE);
         return {
             type: 'composition',
             name,
             objects,
+            domainRandomization,
             line: startToken.line,
             column: startToken.column,
         };
     }
     parseObject() {
-        const startToken = this.expect(lexer_1.TokenType.KEYWORD, 'object');
-        const name = this.expect(lexer_1.TokenType.STRING).value;
+        const startToken = this.expect(TokenType.KEYWORD, 'object');
+        const name = this.expect(TokenType.STRING).value;
         // Parse traits (@trait1 @trait2 ...)
         const traits = [];
-        while (this.currentToken().type === lexer_1.TokenType.TRAIT) {
+        while (this.currentToken().type === TokenType.TRAIT) {
             traits.push(this.advance().value);
         }
-        this.expect(lexer_1.TokenType.LBRACE);
+        this.expect(TokenType.LBRACE);
         // Parse properties (key: value)
         const properties = {};
-        while (this.currentToken().type !== lexer_1.TokenType.RBRACE && this.currentToken().type !== lexer_1.TokenType.EOF) {
-            const key = this.expect(lexer_1.TokenType.IDENTIFIER).value;
-            this.expect(lexer_1.TokenType.COLON);
-            const value = this.parseValue();
-            properties[key] = value;
+        let domainRandomization;
+        let actuatorGroups;
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            // Support both object "link" @trait { ... } and object "link" { @trait ... }.
+            if (this.currentToken().type === TokenType.TRAIT) {
+                const trait = this.advance().value;
+                if (!traits.includes(trait)) {
+                    traits.push(trait);
+                }
+            }
+            // Check for domain_randomization block
+            else if (this.currentToken().type === TokenType.IDENTIFIER &&
+                this.currentToken().value === 'domain_randomization') {
+                this.advance();
+                this.expect(TokenType.COLON);
+                domainRandomization = this.parseDomainRandomizationBlock();
+            }
+            // Check for actuator_group block
+            else if (this.currentToken().type === TokenType.IDENTIFIER &&
+                this.currentToken().value === 'actuator_group') {
+                this.advance();
+                this.expect(TokenType.COLON);
+                const group = this.parseActuatorGroupBlock();
+                if (!actuatorGroups)
+                    actuatorGroups = [];
+                actuatorGroups.push(group);
+            }
+            // Regular property
+            else {
+                const keyName = this.expect(TokenType.IDENTIFIER).value;
+                this.expect(TokenType.COLON);
+                const value = this.parseValue();
+                properties[keyName] = value;
+            }
         }
-        this.expect(lexer_1.TokenType.RBRACE);
+        this.expect(TokenType.RBRACE);
         return {
             type: 'object',
             name,
             traits,
             properties,
+            domainRandomization,
+            actuatorGroups,
             line: startToken.line,
             column: startToken.column,
         };
@@ -126,19 +134,19 @@ class Parser {
     parseValue() {
         const token = this.currentToken();
         // String value
-        if (token.type === lexer_1.TokenType.STRING) {
+        if (token.type === TokenType.STRING) {
             return this.advance().value;
         }
         // Number value
-        if (token.type === lexer_1.TokenType.NUMBER) {
+        if (token.type === TokenType.NUMBER) {
             return parseFloat(this.advance().value);
         }
         // Array value [1, 2, 3]
-        if (token.type === lexer_1.TokenType.LBRACKET) {
+        if (token.type === TokenType.LBRACKET) {
             return this.parseArray();
         }
         // Function call (for future: diagonal([1, 2, 3]))
-        if (token.type === lexer_1.TokenType.IDENTIFIER && this.peek().type === lexer_1.TokenType.LBRACKET) {
+        if (token.type === TokenType.IDENTIFIER && this.peek().type === TokenType.LBRACKET) {
             this.advance(); // Skip function name for now
             const args = this.parseArray();
             // For now, treat function calls as arrays (e.g., diagonal([1,2,3]) -> [1,2,3])
@@ -148,16 +156,17 @@ class Parser {
         throw new Error(`Unexpected value type ${token.type} "${token.value}" at line ${token.line}, column ${token.column}`);
     }
     parseArray() {
-        this.expect(lexer_1.TokenType.LBRACKET);
+        this.expect(TokenType.LBRACKET);
         const values = [];
-        while (this.currentToken().type !== lexer_1.TokenType.RBRACKET && this.currentToken().type !== lexer_1.TokenType.EOF) {
-            if (this.currentToken().type === lexer_1.TokenType.NUMBER) {
+        while (this.currentToken().type !== TokenType.RBRACKET &&
+            this.currentToken().type !== TokenType.EOF) {
+            if (this.currentToken().type === TokenType.NUMBER) {
                 values.push(parseFloat(this.advance().value));
             }
-            else if (this.currentToken().type === lexer_1.TokenType.STRING) {
+            else if (this.currentToken().type === TokenType.STRING) {
                 values.push(this.advance().value);
             }
-            else if (this.currentToken().type === lexer_1.TokenType.LBRACKET) {
+            else if (this.currentToken().type === TokenType.LBRACKET) {
                 // Nested array
                 values.push(this.parseArray());
             }
@@ -165,38 +174,203 @@ class Parser {
                 throw new Error(`Unexpected token in array: ${this.currentToken().type} at line ${this.currentToken().line}`);
             }
             // Optional comma
-            if (this.currentToken().type === lexer_1.TokenType.COMMA) {
+            if (this.currentToken().type === TokenType.COMMA) {
                 this.advance();
             }
         }
-        this.expect(lexer_1.TokenType.RBRACKET);
+        this.expect(TokenType.RBRACKET);
         return values;
     }
-}
-exports.Parser = Parser;
-// Example usage
-if (require.main === module) {
-    Promise.resolve().then(() => __importStar(require('./lexer'))).then(({ Lexer }) => {
-        const source = `
-composition "TwoLinkArm" {
-  object "Base" @static {
-    geometry: "cylinder"
-    dimensions: [0.1, 0.05]
-    material: "metal"
-  }
-
-  object "Link1" @joint_revolute {
-    joint_axis: [0, 0, 1]
-    joint_limits: [-3.14, 3.14]
-    joint_effort: 100
-  }
-}
-`;
-        const lexer = new Lexer(source);
-        const tokens = lexer.tokenize();
-        const parser = new Parser(tokens);
-        const ast = parser.parse();
-        console.log('AST:');
-        console.log(JSON.stringify(ast, null, 2));
-    });
+    parseDomainRandomizationBlock() {
+        this.expect(TokenType.LBRACE);
+        const config = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            switch (key) {
+                case 'physics':
+                    config.physics = this.parsePhysicsRandomization();
+                    break;
+                case 'actuator':
+                    config.actuator = this.parseActuatorRandomization();
+                    break;
+                case 'observation':
+                    config.observation = this.parseObservationRandomization();
+                    break;
+                case 'initialState':
+                    config.initialState = this.parseInitialStateRandomization();
+                    break;
+                case 'disturbance':
+                    config.disturbance = this.parseDisturbanceRandomization();
+                    break;
+                default:
+                    // Skip unknown keys
+                    this.parseValue();
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return config;
+    }
+    parsePhysicsRandomization() {
+        this.expect(TokenType.LBRACE);
+        const physics = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            if (key === 'massScale' && Array.isArray(value)) {
+                physics.massScale = [value[0], value[1]];
+            }
+            else if (key === 'frictionRange' && Array.isArray(value)) {
+                physics.frictionRange = [value[0], value[1]];
+            }
+            else if (key === 'dampingRange' && Array.isArray(value)) {
+                physics.dampingRange = [value[0], value[1]];
+            }
+            else if (key === 'armatureRange' && Array.isArray(value)) {
+                physics.armatureRange = [value[0], value[1]];
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return physics;
+    }
+    parseActuatorRandomization() {
+        this.expect(TokenType.LBRACE);
+        const actuator = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            if (key === 'kpNoise' && typeof value === 'number') {
+                actuator.kpNoise = value;
+            }
+            else if (key === 'kdNoise' && typeof value === 'number') {
+                actuator.kdNoise = value;
+            }
+            else if (key === 'latencyNoise' && typeof value === 'number') {
+                actuator.latencyNoise = value;
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return actuator;
+    }
+    parseObservationRandomization() {
+        this.expect(TokenType.LBRACE);
+        const observation = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            if (key === 'jointPosNoise' && typeof value === 'number') {
+                observation.jointPosNoise = value;
+            }
+            else if (key === 'jointVelNoise' && typeof value === 'number') {
+                observation.jointVelNoise = value;
+            }
+            else if (key === 'imuNoise' && typeof value === 'number') {
+                observation.imuNoise = value;
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return observation;
+    }
+    parseInitialStateRandomization() {
+        this.expect(TokenType.LBRACE);
+        const initialState = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            if (key === 'jointPosRange') {
+                initialState.jointPosRange = this.parseNumberRangeMap();
+            }
+            else {
+                const value = this.parseValue();
+                if (key === 'rootPoseRange' && Array.isArray(value)) {
+                    initialState.rootPoseRange = value;
+                }
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return initialState;
+    }
+    parseNumberRangeMap() {
+        this.expect(TokenType.LBRACE);
+        const ranges = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            if (Array.isArray(value)) {
+                ranges[key] = [value[0], value[1]];
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return ranges;
+    }
+    parseDisturbanceRandomization() {
+        this.expect(TokenType.LBRACE);
+        const disturbance = {};
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            if (key === 'forceRange' && Array.isArray(value)) {
+                disturbance.forceRange = [value[0], value[1]];
+            }
+            else if (key === 'intervalRange' && Array.isArray(value)) {
+                disturbance.intervalRange = [value[0], value[1]];
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return disturbance;
+    }
+    parseActuatorGroupBlock() {
+        // Parse actuator_group { name: "foo" type: "DelayedPDActuator" joints: ["joint1", "joint2"] ... }
+        this.expect(TokenType.LBRACE);
+        const group = {
+            name: '',
+            type: 'IdealPDActuator',
+            jointNames: [],
+        };
+        while (this.currentToken().type !== TokenType.RBRACE &&
+            this.currentToken().type !== TokenType.EOF) {
+            const key = this.expect(TokenType.IDENTIFIER).value;
+            this.expect(TokenType.COLON);
+            const value = this.parseValue();
+            switch (key) {
+                case 'name':
+                    group.name = value;
+                    break;
+                case 'type':
+                    group.type = value;
+                    break;
+                case 'joints':
+                    if (Array.isArray(value)) {
+                        group.jointNames = value;
+                    }
+                    break;
+                case 'stiffness':
+                    group.stiffness = value;
+                    break;
+                case 'damping':
+                    group.damping = value;
+                    break;
+                case 'friction':
+                    group.friction = value;
+                    break;
+                case 'latency':
+                    group.latency = value;
+                    break;
+            }
+        }
+        this.expect(TokenType.RBRACE);
+        return group;
+    }
 }

package/dist/traits/ROS2HardwareLoopTrait.d.ts

@@ -0,0 +1,15 @@
+/** @ros2_hardware_loop Trait — Bidirectional hardware-in-the-loop bridge for physical robotics. @trait ros2_hardware_loop */
+export interface ROS2Config {
+    nodeName: string;
+    topicPrefix: string;
+    updateFrequencyHz: number;
+    bidirectional: boolean;
+}
+export interface ROS2State {
+    connected: boolean;
+    lastPingMs: number;
+    activeTopics: string[];
+    hardwareSyncDriftMs: number;
+}
+import type { TraitHandler } from './types';
+export declare function createROS2HardwareLoopHandler(): TraitHandler<ROS2Config>;

package/dist/traits/ROS2HardwareLoopTrait.js

@@ -0,0 +1,49 @@
+export function createROS2HardwareLoopHandler() {
+    return {
+        name: 'ros2_hardware_loop',
+        defaultConfig: { nodeName: 'holo_rig_01', topicPrefix: '/holo', updateFrequencyHz: 60, bidirectional: true },
+        onAttach(n, c, ctx) {
+            n.__ros2State = { connected: false, lastPingMs: 0, activeTopics: [], hardwareSyncDriftMs: 0 };
+            ctx.emit?.('ros2:init', { node: c.nodeName });
+        },
+        onDetach(n, _c, ctx) {
+            delete n.__ros2State;
+            ctx.emit?.('ros2:disconnect');
+        },
+        onUpdate() { },
+        onEvent(n, c, ctx, e) {
+            const s = n.__ros2State;
+            if (!s)
+                return;
+            const evt = e;
+            switch (evt.type) {
+                case 'ros2:connect':
+                    s.connected = true;
+                    // In real usage, initializes rclnodejs bridge for pub/sub physics
+                    ctx.emit?.('ros2:connected', { latencyMs: 12 });
+                    break;
+                case 'scene:transform_change':
+                    if (c.bidirectional && s.connected) {
+                        // Push virtual set transform to physical robot joint
+                        ctx.emit?.('ros2:publish', { topic: `${c.topicPrefix}/joint_cmd`, payload: evt.payload });
+                    }
+                    break;
+                case 'ros2:telemetry':
+                    // Receive physical robot telemetry to drive virtual set
+                    s.hardwareSyncDriftMs = Math.abs(Date.now() - (evt.payload.timestamp || Date.now()));
+                    n.transform = evt.payload.transform;
+                    break;
+                case 'ttu:manifested':
+                    // Dynamically bind to Text-To-Universe AST streams
+                    const crdtRoot = evt.payload?.crdtRoot;
+                    if (crdtRoot && s.connected) {
+                        const dynamicTopic = `${c.topicPrefix}/ttu_sync/${crdtRoot}`;
+                        s.activeTopics.push(dynamicTopic);
+                        ctx.emit?.('ros2:subscribe', { topic: dynamicTopic });
+                        ctx.emit?.('ros2:log', { message: `Bridged digital twin for TTU root: ${crdtRoot}` });
+                    }
+                    break;
+            }
+        }
+    };
+}

package/dist/traits/types.d.ts

@@ -0,0 +1,4 @@
+export type TraitContext = unknown;
+export type TraitEvent = unknown;
+export type HSPlusNode = unknown;
+export type TraitHandler<_T> = unknown;

package/dist/traits/types.js

@@ -0,0 +1 @@
+export {};

package/dist/usd-codegen.d.ts

@@ -2,17 +2,44 @@
  * 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
  */
 import { CompositionNode } from './ast';
+export interface IsaacLabConfig {
+    /** Isaac Lab version target for generated code */
+    isaacLabVersion?: string;
+    /** Enable PhysX articulation and per-axis joint friction schemas (default: true) */
+    enableJointFriction?: boolean;
+    /** Enable drive attributes for PD control (default: true) */
+    enableDriveAttributes?: boolean;
+}
 export declare class USDCodeGen {
     private output;
     private indentLevel;
+    private config;
+    constructor(config?: IsaacLabConfig);
     generate(ast: CompositionNode): string;
     private generateLink;
     private generateJoint;
     private indent;
     private emit;
     private geometryToUSD;
+    private isJointObject;
+    private getJointKind;
+    private getJointApiSchemas;
+    private hasDriveProperties;
+    private hasPhysxJointAxisProperties;
+    private emitPhysxJointAxisProperties;
+    private emitActuatorGroupComment;
+    private numberProp;
+    private convertJointScalar;
+    private formatNumber;
+    private formatTokenArray;
     private vectorToAxisName;
+    private emitDomainRandomizationAsComment;
 }