feat: added node support (#8)

* feat: change everything

* feat: update example; added proper docs; aligned both web and node packages

README.md

@@ -5,15 +5,17 @@
 ## Install
 
 ```bash
-# Web library (available now)
+# Web library
 npm install @lerobot/web
 
-# Node.js library (coming soon)
-# npm install @lerobot/node
+# Node.js library
+npm install @lerobot/node
 ```
 
 ## Resources
 
 - **LeRobot.js**: [Introduction post on Hugging Face](https://huggingface.co/blog/NERDDISCO/lerobotjs)
-- **Documentation**: See [`@lerobot/web` README](./packages/web/README.md) for complete API reference
+- **Documentation**:
+  - [`@lerobot/web` README](./packages/web/README.md) - Browser (WebSerial + WebUSB)
+  - [`@lerobot/node` README](./packages/node/README.md) - Node.js (Serialport)
 - **Live Demo**: Try it online at [huggingface.co/spaces/NERDDISCO/LeRobot.js](https://huggingface.co/spaces/NERDDISCO/LeRobot.js)

docs/conventions.md

@@ -11,6 +11,7 @@
 ## Core Rules
 
 - **Never Start/Stop Dev Server**: The development server is already managed by the user - never run commands to start, stop, or restart the server
+- **Package Manager**: Always use `pnpm` for package management - never use `npm` or `yarn` in documentation, scripts, or commands
 - **Python lerobot Faithfulness**: Maintain exact UX/API compatibility with Python lerobot - commands, terminology, and workflows must match identically
 - **Serial API Separation**: Always use `serialport` package for Node.js and Web Serial API for browsers - never mix or bridge these incompatible APIs
 - **Minimal Console Output**: Only show essential information - reduce cognitive load for users
@@ -74,7 +75,7 @@
 
 - **Identical Commands**: `npx lerobot find-port` matches `python -m lerobot.find_port`
 - **Same Terminology**: Use "MotorsBus", not "robot arms" - keep Python's exact wording
-- **Matching Output**: Error messages, prompts, and flow identical to Python version
+- **Matching Output**: Error messages, prompts, and flow identical to Python lerobot
 - **Familiar Workflows**: Python lerobot users should feel immediately at home
 - **CLI Compatibility**: Direct migration path from Python CLI
 
@@ -193,7 +194,7 @@ lerobot/
 - **Integration Tests**: Test component interactions
 - **E2E Tests**: Playwright for full workflow testing
 - **Hardware Tests**: Mock/stub hardware interfaces for CI
-- **UX Compatibility Tests**: Verify outputs match Python version
+- **UX Compatibility Tests**: Verify outputs match Python lerobot
 
 ## Package Structure
 
@@ -218,6 +219,69 @@ lerobot/
 - **Hardware**: Platform-specific libraries for device access
 - **Development**: Vitest, ESLint, Prettier
 
+### Package Architecture Standards
+
+**Multi-Platform Package Structure:**
+
+```
+packages/
+├── web/                    # Browser-focused package (@lerobot/web)
+│   ├── src/
+│   ├── package.json       # Web Serial API, browser dependencies
+│   └── README.md          # Browser-specific examples
+├── node/                  # Node.js-focused package (@lerobot/node)
+│   ├── src/
+│   ├── package.json       # serialport dependency, library only
+│   └── README.md          # Node.js library examples
+└── cli/                   # CLI package (lerobot)
+    ├── src/
+    ├── package.json       # CLI binary, depends on @lerobot/node
+    └── README.md          # Python lerobot compatible commands
+```
+
+**API Consistency Rules:**
+
+- Identical function signatures across packages where possible
+- Platform-specific adaptations in types and implementations only
+- Shared constants and protocols via dedicated utils
+- Cross-platform compatibility for data formats (calibration files, etc.)
+
+**CLI Architecture & Separation of Concerns:**
+
+- **Library (`@lerobot/node`)**: Pure programmatic API for Node.js applications
+
+  - `findPort()` returns robot connections programmatically
+  - No interactive prompts, CLI output, or user input handling
+  - Matches `@lerobot/web` API design for consistency
+
+- **CLI (`lerobot`)**: Python lerobot compatible command-line interface
+
+  - Separate package in `packages/cli/` with `npx lerobot` binary
+  - Uses `@lerobot/node` library internally for all functionality
+  - Handles interactive prompts, user input, and CLI-specific UX
+  - Interactive by default - no flags required for standard workflows
+  - Identical command syntax and behavior to Python lerobot
+
+- **Architectural Principle**: Libraries provide capabilities, CLIs provide experience
+  - Interactive behavior belongs in CLI commands, not library functions
+  - Library users get clean APIs, CLI users get Python-compatible workflows
+
+### Local Package References
+
+When creating examples that depend on workspace packages, use `file:` references:
+
+```json
+{
+  "dependencies": {
+    "@lerobot/web": "file:../../packages/web",
+    "@lerobot/node": "file:../../packages/node",
+    "lerobot": "file:../../packages/cli"
+  }
+}
+```
+
+**Never use `workspace:*` in examples** - this is only for the root workspace `package.json`.
+
 ## Platform-Specific Implementation
 
 ### Node.js Implementation (Python-Compatible Foundation)
@@ -239,6 +303,45 @@ lerobot/
 - **Port Discovery**: Programmatic port enumeration without user dialogs
 - **Process Management**: Direct process control and system integration
 
+#### Node.js Serial Communication (Critical Implementation Details)
+
+**Event-Driven Communication (Proven Working Approach):**
+
+- **Event-Based Reading**: Use `port.once('data')` with timeout promises
+- **Never Use Wrapper Polling**: Avoid `port.read(timeout)` wrappers - they add latency and unreliability
+- **Direct SerialPort Access**: Expose underlying `SerialPort` instance for event listening
+
+**Timing Constants for STS3215 Motors:**
+
+```typescript
+const STS3215_PROTOCOL = {
+  WRITE_TO_READ_DELAY: 0, // No delay before read - immediate event listening
+  RETRY_DELAY: 50, // Base retry delay (multiplied by attempt number)
+  INTER_MOTOR_DELAY: 10, // Small delay between motor operations
+  MAX_RETRIES: 3,
+};
+```
+
+**Progressive Timeout Pattern:**
+
+```typescript
+// Timeout increases with retry attempts: 100ms, 200ms, 300ms
+const timeout = 100 * attempts;
+const response = await new Promise((resolve, reject) => {
+  const timer = setTimeout(() => reject(new Error("Read timeout")), timeout);
+  underlyingPort.once("data", (data) => {
+    clearTimeout(timer);
+    resolve(new Uint8Array(data));
+  });
+});
+```
+
+**Connection Architecture:**
+
+- **Only `findPort()` Creates Connections**: No other high-level function should create new serial connections
+- **Initialized Port Returns**: `findPort()` must return ready-to-use, initialized ports
+- **Connection Reuse**: All functions (`calibrate`, `teleoperate`, `releaseMotors`) use existing connection from `findPort`
+
 ### Web Implementation (Modern Robotics Interface)
 
 **Web provides superior robotics UX by building on Node.js's proven hardware protocols**
@@ -583,83 +686,124 @@ const STS3215_REGISTERS = {
 
 **This sequence debugging took extensive analysis to solve. Future implementations MUST follow this exact pattern to maintain Python compatibility.**
 
-#### CRITICAL: Smooth Motor Control Recipe (PROVEN WORKING)
+#### CRITICAL: Node.js Teleoperation Patterns (PROVEN WORKING)
+
+**These patterns provide smooth, responsive teleoperation in Node.js. Deviating from this recipe causes delays, stuttering, or poor user experience.**
+
+##### 🚀 Node.js Keyboard Control Architecture (FINAL SOLUTION)
 
-**These patterns provide buttery-smooth, responsive motor control. Deviating from this recipe causes stuttering, lag, or poor responsiveness.**
+**The Challenge: Node.js stdin vs Browser Keyboard Events**
 
-##### 🚀 Performance Optimizations (KEEP THESE!)
+- **Browser**: Has real `keydown` and `keyup` events → perfect control
+- **Node.js**: Only has `keypress` events → must simulate keyup with timeouts
+- **OS Keyboard Repeat**: ~250-500ms delay between first press and repeat stream
+
+**✅ PROVEN WORKING SOLUTION:**
+
+```typescript
+// Optimal configuration values (DO NOT CHANGE without extensive testing)
+export const KEYBOARD_TELEOPERATOR_DEFAULTS = {
+  stepSize: 8, // Match browser demo step size
+  updateRate: 120, // High frequency for smooth movement (120 Hz)
+  keyTimeout: 150, // Balance single taps vs continuous movement
+} as const;
+```
+
+**1. Hybrid Movement Pattern**
+
+- **✅ PERFECT**: Immediate movement on first keypress + continuous interval updates
+- **❌ WRONG**: Only immediate movement (no continuous) or only interval movement (has delay)
+
+```typescript
+// On keypress: Move immediately + start/refresh continuous movement
+private handleKeyboardInput(key: string): void {
+  const keyName = this.mapKeyToName(key);
+  if (keyName && this.keyboardControls[keyName]) {
+    if (this.keyStates[keyName]) {
+      // Key repeat - just refresh timestamp
+      this.keyStates[keyName].timestamp = Date.now();
+    } else {
+      // New keypress - immediate movement + start continuous
+      this.updateKeyState(keyName, true);
+      this.moveMotorForKey(keyName); // ← IMMEDIATE, no delay
+    }
+  }
+}
+```
 
-**1. Optimal Step Size**
+**2. Optimal Key Timeout Balance**
 
-- **✅ PERFECT**: `25` units per keypress (responsive but not jumpy)
-- **❌ WRONG**: `5` units (too sluggish) or `100` units (too aggressive)
+- **✅ PERFECT**: `150ms` - Good single taps, minimal continuous gap
+- **❌ WRONG**: `50ms` (single taps too short) or `600ms` (single taps too long)
+- **Why 150ms**: Bridges most OS keyboard repeat delay without making single taps sluggish
 
-**2. Minimal Motor Communication Delay**
+**3. High-Frequency Updates**
 
-- **✅ PERFECT**: `1ms` delay between motor commands
-- **❌ WRONG**: `5ms+` delays cause stuttering
+- **✅ PERFECT**: `120 Hz` update rate for smooth continuous movement
+- **❌ WRONG**: `60 Hz` (visible stuttering) or `200+ Hz` (unnecessary CPU load)
 
-**3. Smart Motor Updates (CRITICAL FOR SMOOTHNESS)**
+##### 🎯 Development Workflow Optimization
 
-- **✅ PERFECT**: Only send commands for motors that actually changed
-- **✅ PERFECT**: Use `0.5` unit threshold to detect meaningful changes
-- **❌ WRONG**: Send ALL motor positions every time (causes serial bus conflicts)
+**Package Development Without Constant Rebuilding:**
 
-**4. Change Detection Threshold**
+**✅ PERFECT Development Setup:**
 
-- **✅ PERFECT**: `0.5` units prevents micro-movements and unnecessary commands
-- **❌ WRONG**: `0.1` units (too sensitive) or no threshold (constant spam)
+1. **Terminal 1**: `cd packages/node && pnpm dev` (watch mode)
+2. **Terminal 2**: `cd packages/cli && pnpm dev teleoperate ...` (direct TypeScript execution)
 
-##### 🎯 Teleoperation Loop Best Practices
+**❌ WRONG**: Constantly running `pnpm build` and clearing `node_modules`
 
-**1. Eliminate Display Spam**
+**Why This Works:**
 
-- **✅ PERFECT**: Minimal loop with just duration checks and 100ms delay
-- **❌ WRONG**: Constant position reading and display updates (causes 90ms+ lag)
+- Node package rebuilds automatically on changes
+- CLI dev mode uses `vite-node` to run TypeScript directly
+- No package caching issues, immediate feedback
 
-**2. Event-Driven Keyboard Input**
+##### 🔧 CLI Architecture Lessons
 
-- **✅ PERFECT**: Use `process.stdin.on("data")` for immediate response
-- **❌ WRONG**: Polling-based input with timers (adds delay)
+**1. No User-Facing Configuration**
 
-##### 🔧 Hardware Communication Patterns
+- **✅ PERFECT**: `stepSize` handled internally by teleoperator defaults
+- **❌ WRONG**: Exposing `--step-size` CLI parameter (users don't understand motor units)
 
-**1. Discrete Step-Based Control**
+**2. Python lerobot Parameter Compatibility**
 
-- **✅ PERFECT**: Immediate position updates on keypress
-- **❌ WRONG**: Continuous/velocity-based control (causes complexity and lag)
+- **✅ PERFECT**: `--robot.type`, `--robot.port`, `--robot.id`, `--teleop.type`
+- **❌ WRONG**: Different parameter names or structure than Python lerobot
 
-**2. Direct Motor Position Writing**
+**3. Library vs CLI Separation**
 
-- **✅ PERFECT**: Simple, immediate motor updates with position limits
-- **❌ WRONG**: Complex interpolation, target positions, multiple update cycles
+- **✅ PERFECT**: Library provides capabilities, CLI provides Python-compatible UX
+- **❌ WRONG**: Library handling CLI concerns or CLI reimplementing library logic
 
-##### 🎮 Proven Working Values
+##### 🎮 Performance Characteristics (When Working Right)
 
-**Key Configuration Values:**
+- **First Keypress Response**: Immediate (0ms delay)
+- **Continuous Movement**: Smooth 120 Hz updates
+- **Single Tap Duration**: ~150ms (1-2 motor movements)
+- **Key Repeat Transition**: Seamless (no gap)
+- **User Experience**: "Almost perfect", "way better", "smooth movement"
 
-- `stepSize = 25` (default in teleoperate.ts and keyboard_teleop.ts)
-- `1ms` motor communication delay (so100_follower.ts)
-- `0.5` unit change detection threshold
-- `100ms` teleoperation loop delay
+##### ⚠️ Node.js Teleoperation Anti-Patterns (NEVER DO THESE)
 
-##### ⚠️ Performance Killers (NEVER DO THESE)
+1. **❌ Only Timeout-Based Movement**: Causes initial delay on every keypress
+2. **❌ Only Immediate Movement**: No continuous movement when holding keys
+3. **❌ Long Key Timeouts (>300ms)**: Makes single taps feel sluggish
+4. **❌ Short Key Timeouts (<100ms)**: Breaks continuous movement due to OS repeat delay
+5. **❌ Low Update Rates (<100Hz)**: Visible stuttering during continuous movement
+6. **❌ Exposing stepSize to CLI**: Users can't meaningfully configure motor position units
 
-1. **❌ Display Updates in Main Loop**: Causes 90ms+ loop times
-2. **❌ Continuous/Velocity Control**: Adds complexity without benefit for keyboard input
-3. **❌ All-Motor Updates**: Sends unnecessary commands, overwhelms serial bus
-4. **❌ Long Communication Delays**: 5ms+ delays cause stuttering
-5. **❌ Complex Interpolation**: Adds latency for simple step-based control
-6. **❌ No Change Detection**: Spams motors with identical positions
+##### 📊 Debugging Keyboard Issues
 
-##### 📊 Performance Metrics (When It's Working Right)
+**Symptoms and Solutions:**
 
-- **Keypress Response**: Immediate (< 10ms)
-- **Motor Update**: Single command per changed motor
-- **Loop Time**: < 5ms (when not reading positions)
-- **User Experience**: "Buttery smooth", "fucking working and super perfect"
+- **"Initial delay when holding key"** → OS keyboard repeat delay, increase keyTimeout
+- **"Single taps move too far"** → keyTimeout too long, reduce to 150ms or less
+- **"Stuttering during continuous movement"** → updateRate too low, increase to 120Hz
+- **"No continuous movement"** → keyTimeout too short, increase above OS repeat delay
+- **"Immediate movement missing"** → Must call `moveMotorForKey()` on first keypress
 
-**Golden Rule**: When you achieve smooth control, NEVER change the step size, delays, or update patterns without extensive testing. These values were optimized through real hardware testing.
+**Golden Rule**: The 150ms keyTimeout + 120Hz updateRate + immediate first movement pattern was achieved through extensive testing. Don't change these values without thorough hardware validation.
 
 ## Clean Library Architecture (Critical Lessons)
 

docs/getting_started_with_so100.md

@@ -34,13 +34,13 @@ Reconnect the USB cable.
 ### check follower arm
 
 ```
-python -m lerobot.check_motors --robot.port=COM4
+python -m lerobot.setup_motors --robot.port=COM4 --robot.type=so100_follower
 ```
 
 ### check leader arm
 
 ```
-python -m lerobot.check_motors --teleop.port=COM3
+python -m lerobot.setup_motors --teleop.port=COM3 --robot.type=so100_leader
 ```
 
 **If you see this - you're lucky! Skip to calibration:**

docs/planning/006_packages_node.md

@@ -0,0 +1,541 @@
+# User Story 006: Node.js Package Architecture
+
+## Story
+
+**As a** robotics developer building server-side applications, CLI tools, and desktop robotics software  
+**I want** to use lerobot.js functionality directly from Node.js with the same API as the web version  
+**So that** I can build Node.js applications, command-line tools, and desktop software without browser constraints while maintaining familiar APIs
+
+## Background
+
+We have successfully implemented `packages/web` that provides `findPort`, `calibrate`, `releaseMotors`, and `teleoperate` functionality using Web APIs (Web Serial, Web USB). This package is published as `@lerobot/web` and provides a clean, typed API for browser-based robotics applications.
+
+We also have existing Node.js code in `src/lerobot/node` that was working but abandoned when we focused on getting the web version right. Now that the web version is stable and proven, we want to create a proper `packages/node` package that:
+
+1. **Mirrors the Web API**: Provides the same function signatures and behavior as `@lerobot/web`
+2. **Uses Node.js APIs**: Leverages `serialport` instead of Web Serial for hardware communication
+3. **Python lerobot Faithfulness**: Maintains exact compatibility with Python lerobot CLI commands and behavior
+4. **Server-Side Ready**: Enables robotics applications in Node.js servers, CLI tools, and desktop applications
+5. **Reuses Proven Logic**: Builds on existing `src/lerobot/node` code that was already working
+
+This will enable developers to use the same lerobot.js API in both browser and Node.js environments, choosing the appropriate platform based on their application needs.
+
+## Acceptance Criteria
+
+### Core Functionality
+
+- [ ] **Same API Surface**: Mirror `@lerobot/web` API with identical function signatures where possible
+- [ ] **Four Core Functions**: Implement `findPort`, `calibrate`, `releaseMotors`, and `teleoperate`
+- [ ] **SerialPort Integration**: Use `serialport` package instead of Web Serial API
+- [ ] **TypeScript Support**: Full TypeScript coverage with strict type checking
+- [ ] **NPM Package**: Published as `@lerobot/node` with proper package.json
+
+### Platform Requirements
+
+- [ ] **Node.js 18+**: Support current LTS and newer versions
+- [ ] **Cross-Platform**: Work on Windows, macOS, and Linux
+- [ ] **ES Modules**: Use ES module format for consistency with web package
+- [ ] **CLI Integration**: Enable `npx lerobot` commands using this package
+- [ ] **No Browser Dependencies**: No Web API dependencies or browser-specific code
+
+### API Alignment
+
+- [ ] **Same Types**: Reuse or mirror types from `@lerobot/web` where appropriate
+- [ ] **Same Exports**: Mirror the export structure of `@lerobot/web/index.ts`
+- [ ] **Same Behavior**: Identical behavior for shared functionality (calibration algorithms, motor control)
+- [ ] **Platform-Specific Adaptations**: Handle Node.js-specific differences (file system, process management)
+
+### Code Quality
+
+- [ ] **Reuse Existing Code**: Build on proven `src/lerobot/node` implementations
+- [ ] **No Code Duplication**: Share logic with web package where possible (copy for now, per requirements)
+- [ ] **Clean Architecture**: Follow the same patterns as `packages/web`
+- [ ] **Comprehensive Testing**: Unit tests for all core functionality
+
+## Expected User Flow
+
+### Installation and Usage
+
+```bash
+# Install the Node.js package
+npm install @lerobot/node
+
+# Use in Node.js applications
+import { findPort, calibrate, teleoperate } from "@lerobot/node";
+```
+
+### Find Port (Node.js)
+
+```typescript
+// Node.js - programmatic usage
+import { findPort } from "@lerobot/node";
+
+const portProcess = await findPort();
+const availablePorts = await portProcess.getAvailablePorts();
+console.log("Available ports:", availablePorts);
+
+// Interactive mode (CLI-like) - matches Python lerobot exactly
+const portProcess = await findPort({
+  interactive: true, // shows "disconnect cable" prompts like Python
+});
+const detectedPort = await portProcess.detectPort();
+```
+
+### Calibration (Node.js)
+
+```typescript
+// Node.js - same API as web
+import { calibrate } from "@lerobot/node";
+
+const calibrationProcess = await calibrate({
+  robot: {
+    type: "so100_follower",
+    port: "/dev/ttyUSB0", // or "COM4" on Windows
+    robotId: "my_follower_arm",
+  },
+  onLiveUpdate: (data) => {
+    console.log("Live calibration data:", data);
+  },
+});
+
+const results = await calibrationProcess.result;
+console.log("Calibration completed:", results);
+```
+
+### Teleoperation (Node.js)
+
+```typescript
+// Node.js - same API as web
+import { teleoperate } from "@lerobot/node";
+
+const teleoperationProcess = await teleoperate({
+  robot: {
+    type: "so100_follower",
+    port: "/dev/ttyUSB0",
+    robotId: "my_follower_arm",
+  },
+  teleop: {
+    type: "keyboard",
+    stepSize: 25,
+  },
+  calibrationData: loadedCalibrationData,
+  onStateUpdate: (state) => {
+    console.log("Robot state:", state);
+  },
+});
+
+teleoperationProcess.start();
+```
+
+### Release Motors (Node.js)
+
+```typescript
+// Node.js - same API as web
+import { releaseMotors } from "@lerobot/node";
+
+await releaseMotors({
+  robot: {
+    type: "so100_follower",
+    port: "/dev/ttyUSB0",
+    robotId: "my_follower_arm",
+  },
+});
+```
+
+### CLI Integration
+
+```bash
+# Python lerobot compatibility - same commands work
+npx lerobot find-port
+npx lerobot calibrate --robot.type=so100_follower --robot.port=/dev/ttyUSB0
+npx lerobot teleoperate --robot.type=so100_follower --robot.port=/dev/ttyUSB0
+
+# Global installation also works
+npm install -g @lerobot/node
+lerobot find-port
+lerobot calibrate --robot.type=so100_follower --robot.port=/dev/ttyUSB0
+```
+
+## Implementation Details
+
+### File Structure
+
+```
+packages/node/
+├── package.json                    # NPM package configuration
+├── tsconfig.build.json             # TypeScript build configuration
+├── README.md                       # Package documentation
+├── CHANGELOG.md                    # Version history
+└── src/
+    ├── index.ts                    # Main exports (mirror web package)
+    ├── find_port.ts                # Port discovery using serialport
+    ├── calibrate.ts                # Calibration using Node.js APIs
+    ├── teleoperate.ts              # Teleoperation using Node.js APIs
+    ├── release_motors.ts           # Motor release using Node.js APIs
+    ├── types/
+    │   ├── robot-connection.ts     # Robot connection types
+    │   ├── port-discovery.ts       # Port discovery types
+    │   ├── calibration.ts          # Calibration types
+    │   ├── teleoperation.ts        # Teleoperation types
+    │   └── robot-config.ts         # Robot configuration types
+    ├── utils/
+    │   ├── serial-port-wrapper.ts  # SerialPort wrapper
+    │   ├── motor-communication.ts  # Motor communication utilities
+    │   ├── motor-calibration.ts    # Calibration utilities
+    │   └── sts3215-protocol.ts     # Protocol constants
+    ├── robots/
+    │   └── so100_config.ts         # SO-100 configuration
+    └── teleoperators/
+        ├── index.ts                # Teleoperator exports
+        ├── base-teleoperator.ts    # Base teleoperator class
+        └── keyboard-teleoperator.ts # Keyboard teleoperator
+```
+
+### Key Dependencies
+
+#### Core Dependencies
+
+- **serialport**: Node.js serial communication (replaces Web Serial API)
+- **chalk**: Terminal colors and formatting
+- **commander**: CLI argument parsing
+
+#### Development Dependencies
+
+- **typescript**: TypeScript compiler
+- **@types/node**: Node.js type definitions
+- **vitest**: Testing framework
+
+### Migration Strategy
+
+#### Phase 1: Package Setup
+
+- [ ] Create `packages/node` directory structure
+- [ ] Set up package.json with proper exports
+- [ ] Configure TypeScript build process
+- [ ] Set up testing infrastructure
+
+#### Phase 2: Core Function Migration
+
+- [ ] Migrate `src/lerobot/node/find_port.ts` to `packages/node/src/find_port.ts`
+- [ ] Migrate `src/lerobot/node/calibrate.ts` to `packages/node/src/calibrate.ts`
+- [ ] Migrate `src/lerobot/node/teleoperate.ts` to `packages/node/src/teleoperate.ts`
+- [ ] Create `release_motors.ts` using existing motor communication code
+
+#### Phase 3: API Alignment
+
+- [ ] Ensure all functions match `@lerobot/web` signatures
+- [ ] Copy and adapt types from `packages/web/src/types/`
+- [ ] Update utilities to use serialport instead of Web Serial
+- [ ] Test API compatibility with existing web examples
+
+#### Phase 4: Testing and Documentation
+
+- [ ] Create comprehensive tests for all functions
+- [ ] Update documentation and examples
+- [ ] Validate Python lerobot CLI compatibility
+- [ ] Test cross-platform compatibility
+
+### Core Functions to Implement
+
+#### Package Exports (Mirror Web Package)
+
+```typescript
+// packages/node/src/index.ts
+export { calibrate } from "./calibrate.js";
+export { teleoperate } from "./teleoperate.js";
+export { findPort } from "./find_port.js";
+export { releaseMotors } from "./release_motors.js";
+
+// Types (mirror web package)
+export type {
+  RobotConnection,
+  RobotConfig,
+  SerialPort,
+  SerialPortInfo,
+  SerialOptions,
+} from "./types/robot-connection.js";
+
+export type {
+  FindPortConfig,
+  FindPortProcess,
+} from "./types/port-discovery.js";
+
+export type {
+  CalibrateConfig,
+  CalibrationResults,
+  LiveCalibrationData,
+  CalibrationProcess,
+} from "./types/calibration.js";
+
+export type {
+  MotorConfig,
+  TeleoperationState,
+  TeleoperationProcess,
+  TeleoperateConfig,
+  TeleoperatorConfig,
+} from "./types/teleoperation.js";
+
+// Node.js utilities
+export { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+export { createSO100Config } from "./robots/so100_config.js";
+```
+
+#### SerialPort Wrapper (Node.js)
+
+```typescript
+// packages/node/src/utils/serial-port-wrapper.ts
+import { SerialPort } from "serialport";
+
+export class NodeSerialPortWrapper {
+  private port: SerialPort;
+  private isConnected: boolean = false;
+
+  constructor(path: string, options: any = {}) {
+    this.port = new SerialPort({
+      path,
+      baudRate: options.baudRate || 1000000,
+      dataBits: options.dataBits || 8,
+      parity: options.parity || "none",
+      stopBits: options.stopBits || 1,
+      autoOpen: false,
+    });
+  }
+
+  async initialize(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.port.open((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.isConnected = true;
+          resolve();
+        }
+      });
+    });
+  }
+
+  async writeAndRead(data: Uint8Array): Promise<Uint8Array> {
+    return new Promise((resolve, reject) => {
+      this.port.write(Buffer.from(data), (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        // Wait for response
+        setTimeout(() => {
+          this.port.read((readErr, readData) => {
+            if (readErr) {
+              reject(readErr);
+            } else {
+              resolve(new Uint8Array(readData || []));
+            }
+          });
+        }, 10); // 10ms delay for response
+      });
+    });
+  }
+
+  async close(): Promise<void> {
+    return new Promise((resolve) => {
+      this.port.close(() => {
+        this.isConnected = false;
+        resolve();
+      });
+    });
+  }
+}
+```
+
+#### Find Port Implementation
+
+```typescript
+// packages/node/src/find_port.ts - Build on existing code
+import { SerialPort } from "serialport";
+
+export interface FindPortConfig {
+  interactive?: boolean;
+}
+
+export interface FindPortProcess {
+  getAvailablePorts(): Promise<string[]>;
+  detectPort(): Promise<string>; // Interactive cable detection like Python
+}
+
+export async function findPort(
+  config: FindPortConfig = {}
+): Promise<FindPortProcess> {
+  const { interactive = false } = config;
+
+  return {
+    async getAvailablePorts(): Promise<string[]> {
+      // Use existing implementation from src/lerobot/node/find_port.ts
+      const ports = await SerialPort.list();
+      return ports.map((port) => port.path);
+    },
+
+    async detectPort(): Promise<string> {
+      if (interactive) {
+        // Existing Python-compatible implementation from src/lerobot/node/find_port.ts
+        // Shows "disconnect cable" prompts and detects port automatically
+        console.log("Finding all available ports for the MotorsBus.");
+
+        const portsBefore = await this.getAvailablePorts();
+        console.log(
+          "Remove the USB cable from your MotorsBus and press Enter when done."
+        );
+        // ... wait for user input ...
+
+        const portsAfter = await this.getAvailablePorts();
+        const portsDiff = portsBefore.filter(
+          (port) => !portsAfter.includes(port)
+        );
+
+        if (portsDiff.length === 1) {
+          return portsDiff[0];
+        } else {
+          throw new Error("Could not detect port");
+        }
+      } else {
+        // Programmatic mode - return first available port
+        const ports = await this.getAvailablePorts();
+        return ports[0];
+      }
+    },
+  };
+}
+```
+
+### Technical Considerations
+
+#### API Compatibility with Web Package
+
+The Node.js package should maintain the same API surface as the web package where possible:
+
+```typescript
+// Same function signatures
+await calibrate(config); // Both packages
+await teleoperate(config); // Both packages
+await findPort(config); // Both packages
+await releaseMotors(config); // Both packages
+```
+
+#### Platform-Specific Adaptations
+
+**File System Access:**
+
+- Node.js: Direct file system access for calibration data
+- Web: localStorage/IndexedDB for calibration data
+
+**Process Management:**
+
+- Node.js: Process signals, stdin/stdout handling
+- Web: Browser events, DOM keyboard handling
+
+**Error Handling:**
+
+- Node.js: Process exit codes, console.error
+- Web: User-friendly error dialogs
+
+#### Python lerobot CLI Compatibility
+
+The Node.js package must maintain exact Python lerobot CLI compatibility:
+
+```bash
+# These commands must work identically
+npx lerobot find-port
+npx lerobot calibrate --robot.type=so100_follower --robot.port=/dev/ttyUSB0
+npx lerobot teleoperate --robot.type=so100_follower --robot.port=/dev/ttyUSB0
+```
+
+#### Calibration Data Storage Location
+
+The CLI should store calibration data in the same location as Python lerobot:
+
+```bash
+# Default location (matches Python lerobot)
+~/.cache/huggingface/lerobot/calibration/robots/
+```
+
+This ensures calibration files are compatible between Python lerobot and Node.js lerobot:
+
+```typescript
+// Use HF_HOME environment variable like Python lerobot
+const HF_HOME =
+  process.env.HF_HOME || path.join(os.homedir(), ".cache", "huggingface");
+const CALIBRATION_DIR = path.join(HF_HOME, "lerobot", "calibration", "robots");
+```
+
+### Package Configuration
+
+#### package.json
+
+```json
+{
+  "name": "@lerobot/node",
+  "version": "0.1.0",
+  "description": "Node.js-based robotics control using SerialPort",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "lerobot": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./calibrate": {
+      "import": "./dist/calibrate.js",
+      "types": "./dist/calibrate.d.ts"
+    },
+    "./teleoperate": {
+      "import": "./dist/teleoperate.js",
+      "types": "./dist/teleoperate.d.ts"
+    },
+    "./find-port": {
+      "import": "./dist/find_port.js",
+      "types": "./dist/find_port.d.ts"
+    }
+  },
+  "files": ["dist/**/*", "README.md"],
+  "keywords": [
+    "robotics",
+    "serialport",
+    "hardware-control",
+    "nodejs",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "serialport": "^12.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+```
+
+## Definition of Done
+
+- [ ] **Package Structure**: Complete `packages/node` directory with proper NPM package setup
+- [ ] **API Mirror**: All four core functions (`findPort`, `calibrate`, `releaseMotors`, `teleoperate`) implemented with same API as web package
+- [ ] **SerialPort Integration**: All hardware communication uses `serialport` package instead of Web Serial
+- [ ] **Type Safety**: Full TypeScript coverage with strict type checking
+- [ ] **Code Migration**: Existing `src/lerobot/node` code successfully migrated and enhanced
+- [ ] **Cross-Platform**: Works on Windows, macOS, and Linux with Node.js 18+
+- [ ] **CLI Integration**: `npx lerobot` commands work using the Node.js package
+- [ ] **Python Compatibility**: CLI commands match Python lerobot behavior exactly
+- [ ] **NPM Ready**: Package published as `@lerobot/node` with proper versioning
+- [ ] **Documentation**: Complete README with usage examples and API documentation
+- [ ] **Testing**: Comprehensive test suite covering all core functionality
+- [ ] **No Regressions**: All existing Node.js functionality preserved and enhanced

examples/cyberpunk-standalone/src/components/calibration-view.tsx

@@ -19,7 +19,7 @@ import {
   releaseMotors,
   type CalibrationProcess,
   type LiveCalibrationData,
-  type WebCalibrationResults,
+  type CalibrationResults,
   type RobotConnection,
 } from "@lerobot/web";
 import {
@@ -42,7 +42,7 @@ export function CalibrationView({ robot }: CalibrationViewProps) {
   const [calibrationProcess, setCalibrationProcess] =
     useState<CalibrationProcess | null>(null);
   const [calibrationResults, setCalibrationResults] =
-    useState<WebCalibrationResults | null>(null);
+    useState<CalibrationResults | null>(null);
   const { toast } = useToast();
 
   // Load existing calibration data from unified storage
@@ -165,7 +165,7 @@ export function CalibrationView({ robot }: CalibrationViewProps) {
             readCount: Object.keys(liveData || {}).length > 0 ? 100 : 0,
           };
 
-          // Use the result directly as WebCalibrationResults
+          // Use the result directly as CalibrationResults
           saveCalibrationData(robot.serialNumber, result, metadata);
         }
 

examples/cyberpunk-standalone/src/components/docs-section.tsx

@@ -259,8 +259,8 @@ const calibrationData = await calibrationProcess.result;`}
                 </h5>
                 <ul className="mt-1 ml-4 space-y-1 text-sm text-muted-foreground">
                   <li>
-                    • <code>result: Promise&lt;WebCalibrationResults&gt;</code>{" "}
-                    - Python-compatible format
+                    • <code>result: Promise&lt;CalibrationResults&gt;</code> -
+                    Python-compatible format
                   </li>
                   <li>
                     • <code>stop(): void</code> - Stop calibration process

examples/cyberpunk-standalone/src/lib/unified-storage.ts

@@ -3,7 +3,7 @@
  * Manages device persistence using localStorage with serial numbers as keys
  */
 
-import type { WebCalibrationResults } from "@lerobot/web";
+import type { CalibrationResults } from "@lerobot/web";
 
 export interface DeviceInfo {
   serialNumber: string;
@@ -25,7 +25,7 @@ export interface CalibrationMetadata {
 
 export interface UnifiedRobotData {
   device_info: DeviceInfo;
-  calibration?: WebCalibrationResults & {
+  calibration?: CalibrationResults & {
     device_type?: string;
     device_id?: string;
     calibrated_at?: string;
@@ -65,7 +65,7 @@ export function saveUnifiedRobotData(
 
 export function saveCalibrationData(
   serialNumber: string,
-  calibrationData: WebCalibrationResults,
+  calibrationData: CalibrationResults,
   metadata: CalibrationMetadata
 ): void {
   try {

examples/cyberpunk-standalone/src/types/robot.ts

@@ -1,6 +1,6 @@
 export type {
   RobotConnection,
   LiveCalibrationData,
-  WebCalibrationResults,
+  CalibrationResults,
   TeleoperationState,
 } from "@lerobot/web";

examples/node-quick-start/.gitignore

@@ -0,0 +1,30 @@
+# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+*.tsbuildinfo
+
+# Environment files
+.env
+.env.local
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock 

examples/node-quick-start/README.md

@@ -0,0 +1,130 @@
+# Node.js Quick Start Example (Vite)
+
+This example demonstrates the complete workflow of using `@lerobot/node` to control robotics hardware from Node.js applications, using Vite for fast development and building. Follows the same pattern as the web Quick Start guide.
+
+## What This Example Does
+
+1. **Find Port**: Discovers and connects to your robot hardware
+2. **Release Motors**: Puts motors in free-movement mode for setup
+3. **Calibrate**: Records motor ranges and sets homing positions
+4. **Teleoperate**: Enables keyboard control of the robot
+
+## Hardware Requirements
+
+- SO-100 robotic arm with STS3215 servos
+- USB connection to your computer
+- Compatible with Windows (COM ports), macOS, and Linux (/dev/tty\* ports)
+
+## Installation
+
+```bash
+# Install dependencies (from project root)
+pnpm install
+```
+
+## Running the Examples
+
+### Full Workflow Demo
+
+```bash
+# Complete robot setup workflow (interactive)
+pnpm demo:full-workflow
+```
+
+### Individual Component Demos
+
+```bash
+# Test port discovery
+pnpm demo:find-port
+
+# Test calibration (requires connected robot)
+pnpm demo:calibrate
+
+# Test keyboard control (requires calibrated robot)
+pnpm demo:teleoperate
+```
+
+## Example Usage
+
+The main demo (`src/main.ts`) shows the complete workflow:
+
+```typescript
+import { findPort, connectPort, releaseMotors, calibrate, teleoperate } from "@lerobot/node";
+
+// 1. Find available robots
+const findProcess = await findPort();
+const robots = await findProcess.result;
+
+// 2. Connect to first robot found
+const robot = await connectPort(robots[0].path, "so100_follower", "my_robot_arm");
+
+// 3. Release motors for manual positioning
+await releaseMotors(robot);
+
+// 4. Calibrate motor ranges
+const calibrationProcess = await calibrate({
+  robot,
+  onProgress: (message) => console.log(message),
+});
+
+// 5. Control robot with keyboard
+const teleop = await teleoperate({
+  robot,
+  teleop: { type: "keyboard" },
+});
+```
+
+## CLI Commands
+
+You can also use the CLI directly:
+
+```bash
+# Find available ports
+npx lerobot find-port
+
+# Calibrate robot
+npx lerobot calibrate --robot.type so100_follower --robot.port /dev/ttyUSB0 --robot.id my_robot
+
+# Control robot
+npx lerobot teleoperate --robot.type so100_follower --robot.port /dev/ttyUSB0 --robot.id my_robot
+```
+
+## Development
+
+```bash
+# Run with Vite Node (faster development with hot reload)
+pnpm dev
+
+# Build with Vite and run compiled version
+pnpm build && pnpm start
+```
+
+## Safety Notes
+
+⚠️ **Important Safety Guidelines:**
+
+- Always ensure robot is in a safe position before running examples
+- Keep emergency stop accessible (ESC key during teleoperation)
+- Start with small movements to test calibration
+- Ensure robot has adequate workspace clearance
+
+## Troubleshooting
+
+**Port Not Found:**
+
+- Check USB connection
+- Verify robot is powered on
+- Try different USB ports/cables
+- On Linux: Check user permissions for serial ports
+
+**Calibration Issues:**
+
+- Ensure motors are released and can move freely
+- Move each joint through its full range slowly
+- Avoid forcing motors past mechanical limits
+
+**Control Problems:**
+
+- Verify calibration completed successfully
+- Check that calibration file was saved
+- Restart the teleoperation if motors don't respond

examples/node-quick-start/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "node-quick-start",
+  "version": "0.1.0",
+  "description": "Node.js Quick Start example for @lerobot/node package",
+  "type": "module",
+  "scripts": {
+    "dev": "vite-node src/main.ts",
+    "build": "vite build",
+    "start": "node dist/main.js",
+    "demo:find-port": "vite-node src/demo-find-port.ts",
+    "demo:calibrate": "vite-node src/demo-calibrate.ts",
+    "demo:teleoperate": "vite-node src/demo-teleoperate.ts",
+    "demo:full-workflow": "vite-node src/main.ts"
+  },
+  "dependencies": {
+    "@lerobot/node": "file:../../packages/node"
+  },
+  "devDependencies": {
+    "vite": "^6.3.5",
+    "vite-node": "^2.0.0",
+    "typescript": "^5.3.0",
+    "@types/node": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "robotics",
+    "lerobot",
+    "nodejs",
+    "example",
+    "demo"
+  ],
+  "author": "LeRobot.js Team",
+  "license": "Apache-2.0"
+}

examples/node-quick-start/pnpm-lock.yaml

@@ -0,0 +1,1174 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@lerobot/node':
+        specifier: file:../../packages/node
+        version: file:../../packages/node([email protected])
+    devDependencies:
+      '@types/node':
+        specifier: ^18.0.0
+        version: 18.19.120
+      typescript:
+        specifier: ^5.3.0
+        version: 5.8.3
+      vite:
+        specifier: ^6.3.5
+        version: 6.3.5(@types/[email protected])([email protected])
+      vite-node:
+        specifier: ^2.0.0
+        version: 2.1.9(@types/[email protected])
+
+packages:
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@lerobot/node@file:../../packages/node':
+    resolution: {directory: ../../packages/node, type: directory}
+    engines: {node: '>=18.0.0'}
+    peerDependencies:
+      typescript: '>=4.5.0'
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-9f3nSTFI2ivfxc7/tHBHcJ8pRnp8ROrELvsVprlQPVvcZ+j5zztYd+PTJGpyIOAdTvNwNrpCXswKSeoQcyGjMQ==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-tFZSEhqJ8Yrpe50TzOdeoYi72gi/jsnT7y8Qrozf3cNu28WX+s6I3XzEPUAqoaT9SAS8Xz9AzGTFlxxCH/w20w==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-+DikIIs+p6yU2hF51UaWG8BnHbq90X0QIOt5zqSKSZxY+G3qqdLih214e9InJal21af2PuuxkDectetGfbVPJw==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-5a+NofhdEB/WimSlFMskbFQn1vqz1FWryYpA99trmZGO6qEmiS0IsX6w4B3d91U878Q2ZQdiaFF1gxX4P147og==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-igr/RlKPS3OCy4jD3XBmAmo3UAcNZkJSubRsw1JeM8bAbwf15k/3eMZXD91bnjheijJiOJcga3kfCLKjV8IXNg==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-MdigWzPSHlQzB1xZ+MdFDWTAH+kcn7UxjEBoOKuaso7z1DRlnAnrknB1mTtNOQ+GdPI8xgExAGwHeqQjntR0Cg==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-dmZseE0ZwA/4yy1+BwFrDqFTjjNg24GO9xSrb1weVbt6AFkhp5pz1gVS7IMtfIvoWy8yp6q/zN0bKnefRUImvQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-fzhfn6p9Cfm3W8UrWKIa4l7Wfjs/KGdgaswMBBE3KY3Ta43jg2XsPrAtfezHpsRk0Nx+TFuS3hZk/To2N5kFPQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-vVDD+iPDPmJQ5nAQ5Tifq3ywdv60FartglFI8VOCK+hcU9aoG0qlQTsDJP97O5yiTaTqlneZWoARMcVC5nyUoQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-0d0jx08fzDHCzXqrtCMEEyxKU0SvJrWmUjUDE2/KDQ2UDJql0tfiwYvEx1oHELClKO8CNdE+AGJj+RqXscZpdQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-XBYu9oW9eKJadWn8M7hkTZsD4yG+RrsTrVEgyKwb4L72cpJjRbRboTG9Lg9fec8MxJp/cfTHAocg4mnismQR8A==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-wJaRvcT17PoOK6Ggcfo3nouFlybHvARBS4jzT0PC/lg17fIJHcDS2fZz3sD+iA4nRlho2zE6OGbU0HvwATdokQ==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-GZ5bkMFteAGkcmh8x0Ok4LSa+L62Ez0tMsHPX6JtR0wl4Xc3bQcrFHDiR5DGLEDFtGrXih4Nd/UDaFqs968/wA==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-7CjPw6FflFsVOUfWOrVrREiV3IYXG4RzZ1ZQUaT3BtSK8YXN6x286o+sruPZJESIaPebYuFowmg54ZdrkVBYog==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-nmvnl0ZiuysltcB/cKjUh40Rx4FbSyueERDsl2FLvLYr6pCgSsvGr3SocUT84svSpmloS7f1DRWqtRha74Gi1w==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-Cv+moII5C8RM6gZbR3cb21o6rquVDZrN2o81maROg1LFzBz2dZUwIQSxFA8GtGZ/F2KtsqQ2z3eFPBb6akvQNg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-PHcMG8DZTM9RCIjp8QIfN0VYtX0TtBPnWOTRurFhoCDoi9zptUZL2k7pCs+5rgut7JAiUsYy+huyhVKPcmxoog==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-1SI/Rd47e8aQJeFWMDg16ET+fjvCcD/CzeaRmIEPmb05hx+3cCcwIF4ebUag4yTt/D1peE+Mgp0+Po3M358cAA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-JwOCYxmumFDfDhx4kNyz6kTVK3gWzBIvVdMNzQMRDubcoGRDniOOmo6DDNP42qwZx3Bp9/6vWJ+kNzNqXoHmeA==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-IPMIfrfkG1GaEXi+JSsQEx8x9b4b+hRZXO7KYc2pKio3zO2/VDXDs6B9Ts/nnO+25Fk1tdAVtUn60HKKPPzDig==}
+    cpu: [x64]
+    os: [win32]
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-HAFzGhk9OuFMpuor7aT5G1ChPgn5qSsklTFOTUX72Rl6p0xwcSVsRtG/xaGp6bxpN7fI9D/S8THLBWbBgS6ldw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-r2XOwY2dDvbW7dKqSPIk2gzsr6M6Qpe9+/Ngs94fNaNlcTRCV02PfaoDmRgcubpNVVcLATlxSxPTIDw12dbKOg==}
+    engines: {node: '>=16.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-CJaUd5bLvtM9c5dmO9rPBHPXTa9R2UwpkJ0wdh9JCYcbrPWsKz+ErvR0hBLeo7NPeiFdjFO4sonRljiw4d2XiA==}
+    engines: {node: ^12.22 || ^14.13 || >=16}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0ei0txFAj+s6FTiCJFBJ1T2hpKkX8Md0Pu6dqMrYoirjPskDLJRgZGLqoy3/lnU1bkvHpnJO+9oJ3PB9v8rNlg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0PfLzO9t2X5ufKuBO34DQKLXrCCqS9xz2D0pfuaLNeTkyGUBv426zxoMf3rsMRodDOZNbFblu3Ae84MOQXjnZw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-aZLJhlRTjSmEwllLG7S4J8s8ctRAS0cbvCpO87smLvl3e4BgzbVgF6Z6zaJd3Aji2uSiYgfedCdNc4L6W+1E2g==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-gu26tVt5lQoybhorLTPsH2j2LnX3AOP2x/34+DUSTNaUTzu2fBXw+isVjQJpUBFWu6aeQRZw5bJol5X9Gxjblw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-GnCh8K0NAESfhCuXAt+FfBRz1Cf9CzIgXfp7SdMgXwrtuUnCC/yuRTUFWRvuzhYKoAo1TL0hhUo77SFHUH1T/w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-p1hiCRqvGHHLCN/8ZiPUY/G0zrxd7gtZs251n+cfNTn+87rwcdUeu9Dps3Aadx30/sOGGFL6brIRGK4l/t7MuQ==}
+    engines: {node: '>=8.6.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-rRAivhRkT3YO28WjmmG4FQX6L+KMb5/ikhyylRfzWPw0nSXy97+u07peS9CbHqaNvJkMhH1locp2H36aGMOEIA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-O7cywCWC8PiOMvo/gglEBfAkLjp/SENEML46BXDykfKP5mTPM46XMaX1L0waWU6DXJpBgjaL7+yX6VriVPbN4w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-ygDwj3O4SDpZlbrRUraoXIoIqb8sM7aMKryGjYTIF0JRnKeB1ys8+wIp0RFMdFbO62YriUDextHB5Um5cKFSWg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dCAVh4P/pZrLcPv9NJ2mvPRBg64L5jXuiRxIlyxxdZGH4WubwXVXY/kBTihQmiAMPxbT3yshSX8f2+feqWsxqA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0APxDGR9YvJXTRfY+uRGhzOhTpU5akSH183RUcwzN7QXh8/1jwFsFLCu0grmAUfi+fItCkR+Xr1TcNJLR13VNA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dozONxhPC/78pntuxpz/NOtVps8qIc/UZzdc/LuPvVsqCoJXiRxOg6ZtCP/W58iibJDKPZPAWPGYeZt9DJxI+Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-9On64rhzuqKdOQyiYLYv2lQOh3TZU/D3+IWCR5gk0alPel2nwpp4YwDEGiUBfrQZEdQ6xww0PWkzqth4wqwX3Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-WtCGHFXnVI8WHLxDAt5TbnCM4eSE+nI0QN2NJtwzcgMhht2eNz6V9evJrk+lwC8bCY8OWV5Ym8Jz7ZEyGnKnMA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
+    engines: {node: '>=12'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  [email protected]:
+    resolution: {integrity: sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
+  [email protected]:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-vgbBJTS4m5/KkE16t5Ly0WW9hz46swAstv0hYYwMtbG7AznRhNyfLRe8HZAiWIpcHzoO7HxhLuBQj9rJ/Ho0ZA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  [email protected]:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  [email protected]:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-ONmkT3Ud3IfW15nl7l4qAZko5/2iZ5ALVBDh02ZSZ5IGVLJSYkRcRa3iB58VyEIyoofs9m2xdVrm+lTi97+3pw==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-AmH3D9hHPFmnF/oq/rvigfiAouAKyK/TjnrkwZRYSFZxNggJxwvbAbfYrLeuvq7ktUdhuHdVdSjj852Z55R+uA==}
+    engines: {node: '>=16.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
+    engines: {node: '>=12.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-qjbnuR9Tr+FJOMBqJCW5ehvIo/buZq7vH7qD7JziU98h6l3qGy0a/yPFjwO+y0/T7GFpNgNAvEcPPVfyT8rrPQ==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || >=20.0.0
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      jiti: '>=1.21.0'
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+snapshots:
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@lerobot/node@file:../../packages/node([email protected])':
+    dependencies:
+      serialport: 12.0.0
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      '@serialport/parser-readline': 11.0.0
+      debug: 4.3.4
+      node-addon-api: 7.0.0
+      node-gyp-build: 4.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 11.0.0
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 12.0.0
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@types/[email protected]': {}
+
+  '@types/[email protected]':
+    dependencies:
+      undici-types: 5.26.5
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.2
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.3
+
+  [email protected]: {}
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.8
+      '@esbuild/android-arm': 0.25.8
+      '@esbuild/android-arm64': 0.25.8
+      '@esbuild/android-x64': 0.25.8
+      '@esbuild/darwin-arm64': 0.25.8
+      '@esbuild/darwin-x64': 0.25.8
+      '@esbuild/freebsd-arm64': 0.25.8
+      '@esbuild/freebsd-x64': 0.25.8
+      '@esbuild/linux-arm': 0.25.8
+      '@esbuild/linux-arm64': 0.25.8
+      '@esbuild/linux-ia32': 0.25.8
+      '@esbuild/linux-loong64': 0.25.8
+      '@esbuild/linux-mips64el': 0.25.8
+      '@esbuild/linux-ppc64': 0.25.8
+      '@esbuild/linux-riscv64': 0.25.8
+      '@esbuild/linux-s390x': 0.25.8
+      '@esbuild/linux-x64': 0.25.8
+      '@esbuild/netbsd-arm64': 0.25.8
+      '@esbuild/netbsd-x64': 0.25.8
+      '@esbuild/openbsd-arm64': 0.25.8
+      '@esbuild/openbsd-x64': 0.25.8
+      '@esbuild/openharmony-arm64': 0.25.8
+      '@esbuild/sunos-x64': 0.25.8
+      '@esbuild/win32-arm64': 0.25.8
+      '@esbuild/win32-ia32': 0.25.8
+      '@esbuild/win32-x64': 0.25.8
+
+  [email protected]([email protected]):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  [email protected]:
+    optional: true
+
+  [email protected]:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+    optional: true
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  [email protected]:
+    optional: true
+
+  [email protected]:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.46.0
+      '@rollup/rollup-android-arm64': 4.46.0
+      '@rollup/rollup-darwin-arm64': 4.46.0
+      '@rollup/rollup-darwin-x64': 4.46.0
+      '@rollup/rollup-freebsd-arm64': 4.46.0
+      '@rollup/rollup-freebsd-x64': 4.46.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.46.0
+      '@rollup/rollup-linux-arm-musleabihf': 4.46.0
+      '@rollup/rollup-linux-arm64-gnu': 4.46.0
+      '@rollup/rollup-linux-arm64-musl': 4.46.0
+      '@rollup/rollup-linux-loongarch64-gnu': 4.46.0
+      '@rollup/rollup-linux-ppc64-gnu': 4.46.0
+      '@rollup/rollup-linux-riscv64-gnu': 4.46.0
+      '@rollup/rollup-linux-riscv64-musl': 4.46.0
+      '@rollup/rollup-linux-s390x-gnu': 4.46.0
+      '@rollup/rollup-linux-x64-gnu': 4.46.0
+      '@rollup/rollup-linux-x64-musl': 4.46.0
+      '@rollup/rollup-win32-arm64-msvc': 4.46.0
+      '@rollup/rollup-win32-ia32-msvc': 4.46.0
+      '@rollup/rollup-win32-x64-msvc': 4.46.0
+      fsevents: 2.3.3
+
+  [email protected]:
+    dependencies:
+      '@serialport/binding-mock': 10.2.2
+      '@serialport/bindings-cpp': 12.0.1
+      '@serialport/parser-byte-length': 12.0.0
+      '@serialport/parser-cctalk': 12.0.0
+      '@serialport/parser-delimiter': 12.0.0
+      '@serialport/parser-inter-byte-timeout': 12.0.0
+      '@serialport/parser-packet-length': 12.0.0
+      '@serialport/parser-readline': 12.0.0
+      '@serialport/parser-ready': 12.0.0
+      '@serialport/parser-regex': 12.0.0
+      '@serialport/parser-slip-encoder': 12.0.0
+      '@serialport/parser-spacepacket': 12.0.0
+      '@serialport/stream': 12.0.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+
+  [email protected]:
+    dependencies:
+      esbuild: 0.25.8
+      get-tsconfig: 4.10.1
+    optionalDependencies:
+      fsevents: 2.3.3
+    optional: true
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      cac: 6.7.14
+      debug: 4.4.1
+      es-module-lexer: 1.7.0
+      pathe: 1.1.2
+      vite: 5.4.19(@types/[email protected])
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.46.0
+    optionalDependencies:
+      '@types/node': 18.19.120
+      fsevents: 2.3.3
+
+  [email protected](@types/[email protected])([email protected]):
+    dependencies:
+      esbuild: 0.25.8
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.46.0
+      tinyglobby: 0.2.14
+    optionalDependencies:
+      '@types/node': 18.19.120
+      fsevents: 2.3.3
+      tsx: 4.20.3

examples/node-quick-start/src/demo-calibrate.ts

@@ -0,0 +1,125 @@
+/**
+ * Calibration Demo
+ *
+ * Demonstrates robot motor calibration with live feedback
+ */
+
+import { findPort, connectPort, releaseMotors, calibrate } from "@lerobot/node";
+import type { RobotConnection, DiscoveredPort } from "@lerobot/node";
+
+async function demoCalibrate() {
+  console.log("🎯 Calibration Demo");
+  console.log("===================\n");
+
+  try {
+    // Step 1: Find available robot ports
+    console.log("📡 Looking for connected robots...");
+    const findProcess = await findPort();
+    const discoveredPorts = await findProcess.result;
+
+    if (discoveredPorts.length === 0) {
+      throw new Error("No robots found. Please connect your robot first.");
+    }
+
+    console.log(`✅ Found robot on ${discoveredPorts[0].path}`);
+
+    // Step 2: Connect to robot
+    console.log("🔌 Connecting to robot...");
+    const robot = await connectPort(
+      discoveredPorts[0].path,
+      "so100_follower",
+      "calibration_demo"
+    );
+    console.log(`✅ Connected: ${robot.robotType} (ID: ${robot.robotId})\n`);
+
+    // Step 3: Release motors
+    console.log("🔓 Releasing motors for calibration setup...");
+    await releaseMotors(robot);
+    console.log("✅ Motors released - robot can now be moved by hand");
+
+    console.log("\n📍 Move robot to your preferred starting position...");
+    console.log("Press any key to continue...");
+
+    // Simple key press handler without readline conflicts
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+
+    await new Promise<void>((resolve) => {
+      const onData = () => {
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onData);
+        resolve();
+      };
+      process.stdin.once("data", onData);
+    });
+
+    // Step 4: Calibration process
+    console.log("\n🎯 Starting calibration process...");
+    console.log("This will:");
+    console.log("1. Set homing offsets (center positions)");
+    console.log("2. Record range of motion for each motor");
+    console.log("3. Write position limits to robot hardware");
+    console.log("4. Save calibration data for future use\n");
+
+    const calibrationProcess = await calibrate({
+      robot,
+      onProgress: (message) => {
+        console.log(`📊 ${message}`);
+      },
+      onLiveUpdate: (data) => {
+        // Display real-time motor positions and ranges
+        const updates = Object.entries(data).map(([name, info]) => {
+          const range = info.max - info.min;
+          return `${name}: ${info.current} [${info.min}→${info.max}] (range: ${range})`;
+        });
+
+        console.clear();
+        console.log("🔄 Live Calibration Data:");
+        console.log("========================");
+        updates.forEach((update) => console.log(`   ${update}`));
+        console.log("\n💡 Move each motor through its full range of motion");
+        console.log("   Press Enter to complete calibration...");
+      },
+    });
+
+    // Wait for calibration to complete (it handles user input internally)
+    const calibrationData = await calibrationProcess.result;
+
+    console.log("\n✅ Calibration completed successfully!");
+
+    // Display detailed results
+    console.log("\n📋 Detailed Calibration Results:");
+    console.log("=================================");
+    Object.entries(calibrationData).forEach(([motorName, config]) => {
+      const range = config.range_max - config.range_min;
+      console.log(`${motorName}:`);
+      console.log(`   Motor ID: ${config.id}`);
+      console.log(`   Drive Mode: ${config.drive_mode}`);
+      console.log(`   Homing Offset: ${config.homing_offset}`);
+      console.log(
+        `   Range: ${config.range_min} → ${config.range_max} (${range} steps)`
+      );
+      console.log(`   Degrees: ~${((range / 4096) * 360).toFixed(1)}°\n`);
+    });
+
+    console.log("💾 Calibration saved to HuggingFace cache directory");
+    console.log("🔄 This file is compatible with Python lerobot");
+
+    console.log("\n🎉 Calibration demo completed!");
+    console.log("💡 You can now use this calibration data for teleoperation");
+
+    // Ensure process can exit cleanly
+    process.exit(0);
+  } catch (error) {
+    console.error("\n❌ Calibration failed:", error.message);
+    console.log("\n🔧 Troubleshooting:");
+    console.log("- Ensure robot is connected and responsive");
+    console.log("- Check that motors can move freely during calibration");
+    console.log("- Avoid forcing motors past their mechanical limits");
+    console.log("- Try restarting the robot if motors become unresponsive");
+    process.exit(1);
+  }
+}
+
+demoCalibrate();

examples/node-quick-start/src/demo-find-port.ts

@@ -0,0 +1,90 @@
+/**
+ * Port Discovery Demo
+ *
+ * Demonstrates how to find and connect to robot hardware programmatically
+ */
+
+import { findPort, connectPort } from "@lerobot/node";
+import type { RobotConnection, DiscoveredPort } from "@lerobot/node";
+
+async function demoFindPort() {
+  console.log("🔍 Port Discovery Demo");
+  console.log("======================\n");
+
+  try {
+    // Demo 1: Basic port discovery
+    console.log("📋 Demo 1: Basic robot discovery");
+    console.log("Looking for connected robots...\n");
+
+    const findProcess = await findPort({
+      onMessage: (message) => console.log(`   📡 ${message}`),
+    });
+    const discoveredPorts = await findProcess.result;
+
+    if (discoveredPorts.length === 0) {
+      console.log("❌ No robots found.");
+      console.log("\n🔧 Make sure your robot is:");
+      console.log("   - Connected via USB");
+      console.log("   - Powered on");
+      console.log("   - Using a working USB cable");
+      return;
+    }
+
+    console.log(`\n✅ Found ${discoveredPorts.length} robot port(s):`);
+    discoveredPorts.forEach((port, index) => {
+      console.log(`   ${index + 1}. ${port.robotType} on ${port.path}`);
+      console.log(`      Port: ${port.path}`);
+      console.log(`      Type: ${port.robotType}`);
+    });
+
+    // Demo 2: Connect to discovered robot
+    console.log("\n🔌 Demo 2: Connecting to discovered robot");
+
+    const robot = await connectPort(
+      discoveredPorts[0].path,
+      "so100_follower",
+      "demo_robot"
+    );
+
+    console.log(
+      `✅ Connected to robot: ${robot.robotType} (ID: ${robot.robotId})`
+    );
+    console.log(`   Port: ${robot.port.path}`);
+    console.log(`   Connected: ${robot.isConnected ? "✅" : "❌"}`);
+    console.log(`   Baudrate: ${robot.port.baudRate}`);
+
+    // Demo 3: Connection details
+    console.log("\n🔌 Demo 3: Connection details");
+    console.log("Robot connection properties:");
+    console.log(`   Name: ${robot.name}`);
+    console.log(`   Type: ${robot.robotType}`);
+    console.log(`   ID: ${robot.robotId}`);
+    console.log(`   Port: ${robot.port.path}`);
+    console.log(`   Serial: ${robot.serialNumber}`);
+    console.log(`   Connected: ${robot.isConnected ? "✅" : "❌"}`);
+
+    // Demo 4: Silent discovery (no progress messages)
+    console.log("\n🤫 Demo 4: Silent discovery");
+    console.log("Finding robots without progress messages...");
+
+    const silentProcess = await findPort(); // No onMessage callback
+    const silentRobots = await silentProcess.result;
+
+    console.log(`Found ${silentRobots.length} robot(s) silently`);
+
+    console.log("\n🎉 Port discovery demo completed!");
+    console.log("\nℹ️  Note: For interactive port discovery, use the CLI:");
+    console.log("   npx lerobot find-port");
+  } catch (error) {
+    console.error("\n❌ Port discovery failed:", error.message);
+    console.log("\n🔧 Troubleshooting:");
+    console.log("- Check USB connections");
+    console.log("- Verify robot is powered on");
+    console.log("- Try different USB ports/cables");
+    console.log("- On Linux: Check serial port permissions");
+    console.log("- For interactive port discovery, use: npx lerobot find-port");
+    process.exit(1);
+  }
+}
+
+demoFindPort();

examples/node-quick-start/src/demo-teleoperate.ts

@@ -0,0 +1,207 @@
+/**
+ * Teleoperation Demo
+ *
+ * Demonstrates different ways to control robot motors
+ */
+
+import { findPort, connectPort, teleoperate } from "@lerobot/node";
+import type { RobotConnection, DiscoveredPort } from "@lerobot/node";
+import { createInterface } from "readline";
+
+function askUser(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function demoTeleoperate() {
+  console.log("🎮 Teleoperation Demo");
+  console.log("=====================\n");
+
+  try {
+    // Step 1: Find available robot ports
+    console.log("📡 Looking for connected robots...");
+    const findProcess = await findPort();
+    const discoveredPorts = await findProcess.result;
+
+    if (discoveredPorts.length === 0) {
+      throw new Error("No robots found. Please connect your robot first.");
+    }
+
+    console.log(`✅ Found robot on ${discoveredPorts[0].path}`);
+
+    // Step 2: Connect to robot
+    console.log("🔌 Connecting to robot...");
+    const robot = await connectPort(
+      discoveredPorts[0].path,
+      "so100_follower",
+      "teleop_demo"
+    );
+    console.log(`✅ Connected: ${robot.robotType} (ID: ${robot.robotId})\n`);
+
+    // Step 3: Choose teleoperation mode
+    console.log("🎯 Choose teleoperation mode:");
+    console.log("1. Keyboard Control (interactive)");
+    console.log("2. Direct Control (programmatic)");
+
+    const mode = await askUser("Enter choice (1 or 2): ");
+
+    if (mode === "1") {
+      // Keyboard teleoperation demo
+      await demoKeyboardControl(robot);
+    } else if (mode === "2") {
+      // Direct control demo
+      await demoDirectControl(robot);
+    } else {
+      console.log("Invalid choice. Defaulting to keyboard control...");
+      await demoKeyboardControl(robot);
+    }
+  } catch (error) {
+    console.error("\n❌ Teleoperation failed:", error.message);
+    console.log("\n🔧 Troubleshooting:");
+    console.log("- Ensure robot is calibrated first");
+    console.log("- Check that robot is connected and responsive");
+    console.log("- Verify calibration data exists");
+    console.log("- Try smaller step sizes if movements are too large");
+    process.exit(1);
+  }
+}
+
+async function demoKeyboardControl(robot: RobotConnection) {
+  console.log("\n⌨️  Keyboard Control Demo");
+  console.log("=========================");
+  console.log("\n🎮 Robot Controls:");
+  console.log("  Arrow Keys: Shoulder pan/lift");
+  console.log("  W/S: Elbow flex/extend");
+  console.log("  A/D: Wrist down/up");
+  console.log("  Q/E: Wrist roll left/right");
+  console.log("  O/C: Gripper open/close");
+  console.log("  ESC: Emergency stop");
+  console.log("  Ctrl+C: Exit demo\n");
+
+  const teleop = await teleoperate({
+    robot,
+    teleop: {
+      type: "keyboard",
+      // Using optimized defaults for smooth control
+    },
+    onStateUpdate: (state) => {
+      if (state.isActive) {
+        // Show live motor positions
+        const motorInfo = state.motorConfigs
+          .map((motor) => {
+            const pos = Math.round(motor.currentPosition);
+            const percent = (
+              ((pos - motor.minPosition) /
+                (motor.maxPosition - motor.minPosition)) *
+              100
+            ).toFixed(0);
+            return `${motor.name}:${pos}(${percent}%)`;
+          })
+          .join(" ");
+        process.stdout.write(`\r🤖 ${motorInfo}`);
+      }
+    },
+  });
+
+  // Start keyboard control
+  teleop.start();
+  console.log("✅ Keyboard control active!");
+  console.log("💡 Move robot with keyboard, press Ctrl+C to exit");
+
+  // Handle graceful shutdown
+  process.on("SIGINT", async () => {
+    console.log("\n🛑 Stopping keyboard control...");
+    teleop.stop();
+    await teleop.disconnect();
+    console.log("✅ Keyboard control demo completed!");
+    process.exit(0);
+  });
+
+  // Keep demo running
+  await new Promise(() => {}); // Keep alive
+}
+
+async function demoDirectControl(robot: RobotConnection) {
+  console.log("\n🎯 Direct Control Demo");
+  console.log("======================");
+  console.log("This demonstrates programmatic robot control\n");
+
+  const teleop = await teleoperate({
+    robot,
+    teleop: { type: "direct" },
+    onStateUpdate: (state) => {
+      const motorInfo = state.motorConfigs
+        .map((motor) => `${motor.name}:${Math.round(motor.currentPosition)}`)
+        .join(" ");
+      console.log(`🤖 ${motorInfo}`);
+    },
+  });
+
+  teleop.start();
+
+  // Get direct control interface
+  const directController = teleop.teleoperator as any;
+
+  console.log("🎬 Running automated movement sequence...\n");
+
+  try {
+    // Demo sequence: move different motors
+    const movements = [
+      {
+        motor: "shoulder_pan",
+        position: 2048,
+        description: "Center shoulder pan",
+      },
+      { motor: "shoulder_lift", position: 1500, description: "Lift shoulder" },
+      { motor: "elbow_flex", position: 2500, description: "Flex elbow" },
+      { motor: "wrist_flex", position: 2000, description: "Adjust wrist" },
+      { motor: "wrist_roll", position: 2048, description: "Center wrist roll" },
+      { motor: "gripper", position: 1800, description: "Adjust gripper" },
+    ];
+
+    for (const movement of movements) {
+      console.log(`🎯 ${movement.description}...`);
+      await directController.moveMotor(movement.motor, movement.position);
+      await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
+    }
+
+    console.log("\n🎉 Movement sequence completed!");
+
+    // Demo multi-motor movement
+    console.log("\n🎭 Demonstrating simultaneous multi-motor movement...");
+    const results = await directController.moveMotors({
+      shoulder_pan: 2048,
+      shoulder_lift: 2048,
+      elbow_flex: 2048,
+      wrist_flex: 2048,
+    });
+
+    console.log("📊 Movement results:");
+    Object.entries(results).forEach(([motor, success]) => {
+      console.log(`   ${motor}: ${success ? "✅" : "❌"}`);
+    });
+
+    // Show current positions
+    const positions = directController.getCurrentPositions();
+    console.log("\n📍 Final positions:");
+    Object.entries(positions).forEach(([motor, position]) => {
+      console.log(`   ${motor}: ${Math.round(position as number)}`);
+    });
+  } finally {
+    console.log("\n🛑 Stopping direct control...");
+    teleop.stop();
+    await teleop.disconnect();
+    console.log("✅ Direct control demo completed!");
+  }
+}
+
+demoTeleoperate();

examples/node-quick-start/src/main.ts

@@ -0,0 +1,183 @@
+/**
+ * Node.js Quick Start Example - Complete Workflow
+ *
+ * This example demonstrates the full robot control workflow:
+ * 1. Find and connect to robot hardware
+ * 2. Release motors for manual positioning
+ * 3. Calibrate motor ranges and homing positions
+ * 4. Control robot with keyboard teleoperation
+ */
+
+import {
+  findPort,
+  connectPort,
+  releaseMotors,
+  calibrate,
+  teleoperate,
+} from "@lerobot/node";
+import type { RobotConnection, DiscoveredPort } from "@lerobot/node";
+
+// Utility for user confirmation
+import { createInterface } from "readline";
+
+function askUser(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+async function quickStartDemo() {
+  console.log("🤖 LeRobot.js Node.js Quick Start Demo");
+  console.log("=====================================\n");
+
+  try {
+    // Step 1: Find available robot ports
+    console.log("📡 Step 1: Looking for connected robots...");
+    const findProcess = await findPort();
+    const discoveredPorts = await findProcess.result;
+
+    if (discoveredPorts.length === 0) {
+      throw new Error("No robots found. Please check your connections.");
+    }
+
+    console.log(`✅ Found robot on ${discoveredPorts[0].path}`);
+
+    // Step 2: Connect to the first robot found
+    console.log("🔌 Step 2: Connecting to robot...");
+    const robot = await connectPort(
+      discoveredPorts[0].path,
+      "so100_follower",
+      "demo_robot_arm"
+    );
+    console.log(`✅ Connected: ${robot.robotType} (ID: ${robot.robotId})\n`);
+
+    // Step 3: Release motors for calibration setup
+    const shouldRelease = await askUser(
+      "🔓 Release motors for manual positioning? (y/n): "
+    );
+    if (shouldRelease.toLowerCase() === "y") {
+      console.log("🔓 Step 2: Releasing motors...");
+      await releaseMotors(robot);
+      console.log("✅ Motors released - you can now move the robot by hand\n");
+
+      await askUser(
+        "Move robot to desired starting position, then press Enter to continue..."
+      );
+    }
+
+    // Step 4: Calibrate the robot
+    const shouldCalibrate = await askUser("🎯 Run calibration? (y/n): ");
+    if (shouldCalibrate.toLowerCase() === "y") {
+      console.log("\n🎯 Step 3: Starting calibration...");
+      console.log(
+        "This will record the motor ranges and set homing positions.\n"
+      );
+
+      const calibrationProcess = await calibrate({
+        robot: robot as RobotConnection,
+        onProgress: (message) => {
+          console.log(`   📊 ${message}`);
+        },
+        onLiveUpdate: (data) => {
+          // Show live motor positions during range recording
+          const positions = Object.entries(data)
+            .map(
+              ([name, info]) =>
+                `${name}:${info.current}(${info.min}-${info.max})`
+            )
+            .join(" ");
+          process.stdout.write(`\r   🔄 Live: ${positions}`);
+        },
+      });
+
+      const calibrationData = await calibrationProcess.result;
+      console.log("\n✅ Calibration completed!");
+
+      // Show calibration summary
+      console.log("\n📋 Calibration Results:");
+      Object.entries(calibrationData).forEach(([motorName, config]) => {
+        console.log(
+          `   ${motorName}: range ${config.range_min}-${config.range_max}, offset ${config.homing_offset}`
+        );
+      });
+    }
+
+    // Step 5: Teleoperation
+    const shouldTeleoperate = await askUser(
+      "\n🎮 Start keyboard teleoperation? (y/n): "
+    );
+    if (shouldTeleoperate.toLowerCase() === "y") {
+      console.log("\n🎮 Step 4: Starting teleoperation...");
+      console.log("Use keyboard to control the robot:\n");
+
+      const teleop = await teleoperate({
+        robot: robot as RobotConnection,
+        teleop: { type: "keyboard" },
+        onStateUpdate: (state) => {
+          if (state.isActive) {
+            const motorInfo = state.motorConfigs
+              .map(
+                (motor) => `${motor.name}:${Math.round(motor.currentPosition)}`
+              )
+              .join(" ");
+            process.stdout.write(`\r🤖 Motors: ${motorInfo}`);
+          }
+        },
+      });
+
+      // Start keyboard control
+      teleop.start();
+
+      console.log("✅ Teleoperation active!");
+      console.log("🎯 Use arrow keys, WASD, Q/E, O/C to control");
+      console.log("⚠️  Press ESC for emergency stop, Ctrl+C to exit\n");
+
+      // Handle graceful shutdown
+      process.on("SIGINT", async () => {
+        console.log("\n🛑 Shutting down teleoperation...");
+        teleop.stop();
+        await teleop.disconnect();
+        console.log("✅ Demo completed successfully!");
+        process.exit(0);
+      });
+
+      // Keep the demo running
+      console.log("Demo is running... Press Ctrl+C to stop");
+      await new Promise(() => {}); // Keep alive
+    }
+
+    console.log("\n🎉 Quick Start Demo completed!");
+    console.log(
+      "You can now integrate @lerobot/node into your own applications."
+    );
+  } catch (error) {
+    console.error("\n❌ Demo failed:", error.message);
+    console.log("\n🔧 Troubleshooting tips:");
+    console.log("- Check robot is connected and powered on");
+    console.log("- Verify correct serial port permissions");
+    console.log("- Try running 'npx lerobot find-port' to test connection");
+    process.exit(1);
+  }
+}
+
+// Handle uncaught errors gracefully
+process.on("uncaughtException", (error) => {
+  console.error("\n💥 Unexpected error:", error.message);
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (error) => {
+  console.error("\n💥 Unhandled promise rejection:", error);
+  process.exit(1);
+});
+
+// Run the demo
+quickStartDemo();

examples/node-quick-start/test-homing-offsets.json

@@ -0,0 +1,44 @@
+{
+  "shoulder_pan": {
+    "id": 1,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  },
+  "shoulder_lift": {
+    "id": 2,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  },
+  "elbow_flex": {
+    "id": 3,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  },
+  "wrist_flex": {
+    "id": 4,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  },
+  "wrist_roll": {
+    "id": 5,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  },
+  "gripper": {
+    "id": 6,
+    "drive_mode": 0,
+    "homing_offset": 0,
+    "range_min": 0,
+    "range_max": 4095
+  }
+}

tsconfig.cli.json → examples/node-quick-start/tsconfig.json

@@ -1,15 +1,22 @@
 {
   "compilerOptions": {
     "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
     "outDir": "./dist",
     "rootDir": "./src",
-    "declaration": true,
-    "strict": true,
+    "declaration": false,
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
+    "allowJs": true,
+    "strict": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "types": ["node"]
   },
-  "include": ["src/lerobot/**/*", "src/cli/**/*"]
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
 }

examples/node-quick-start/vite.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from "vite";
+import { resolve } from "path";
+
+export default defineConfig({
+  build: {
+    target: "node18",
+    lib: {
+      entry: {
+        main: resolve(__dirname, "src/main.ts"),
+        "demo-find-port": resolve(__dirname, "src/demo-find-port.ts"),
+        "demo-calibrate": resolve(__dirname, "src/demo-calibrate.ts"),
+        "demo-teleoperate": resolve(__dirname, "src/demo-teleoperate.ts"),
+      },
+      formats: ["es"],
+      fileName: (format, entryName) => `${entryName}.js`,
+    },
+    rollupOptions: {
+      external: [
+        // Node.js built-ins
+        "fs",
+        "fs/promises",
+        "path",
+        "os",
+        "readline",
+        "process",
+        // Dependencies that should remain external
+        "serialport",
+        "@lerobot/node",
+      ],
+    },
+    outDir: "dist",
+    emptyOutDir: true,
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "src"),
+    },
+  },
+});

package.json

@@ -6,10 +6,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "files": [
-    "dist/**/*",
-    "README.md"
-  ],
+  "private": true,
   "keywords": [
     "robotics",
     "ai",
@@ -18,14 +15,13 @@
     "lerobot"
   ],
   "scripts": {
-    "cli:find-port": "tsx src/cli/index.ts find-port",
-    "cli:calibrate": "tsx src/cli/index.ts calibrate",
-    "cli:teleoperate": "tsx src/cli/index.ts teleoperate",
     "example:cyberpunk": "cd examples/cyberpunk-standalone && pnpm dev",
     "example:iframe-test": "cd examples/iframe-dialog-test && pnpm dev",
     "example:sequential-test": "cd examples/test-sequential-operations && pnpm dev",
-    "build": "pnpm run build:cli",
-    "build:cli": "tsc --project tsconfig.cli.json",
+    "dev": "pnpm run dev:node",
+    "dev:node": "pnpm -C packages/node dev",
+    "dev:cli": "pnpm -C packages/cli dev",
+    "build:all": "pnpm -C packages/node build && pnpm -C packages/cli build",
     "build:cyberpunk": "cd examples/cyberpunk-standalone && pnpm install && pnpm build",
     "changeset": "changeset",
     "changeset:version": "changeset version",

packages/cli/.gitignore

@@ -0,0 +1,36 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# Build output
+dist/
+build/
+*.tsbuildinfo
+
+# Environment files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Coverage reports
+coverage/
+*.lcov
+
+# Temporary files
+*.tmp
+*.temp

packages/cli/README.md

@@ -0,0 +1,191 @@
+# lerobot
+
+Python lerobot compatible CLI for Node.js. Provides the same command-line interface as Python lerobot with identical behavior and syntax.
+
+## Installation
+
+```bash
+# Use directly with npx (recommended)
+npx lerobot find-port
+
+# Or install globally
+npm install -g lerobot
+lerobot find-port
+```
+
+## Commands
+
+### Find Port
+
+Discover robot port with interactive cable detection. Matches Python lerobot's `find_port.py` exactly.
+
+```bash
+# Interactive cable detection (always enabled, like Python lerobot)
+lerobot find-port
+```
+
+This command follows Python lerobot's behavior exactly:
+
+1. Lists initial ports
+2. Prompts to unplug USB cable
+3. Detects which port disappeared
+4. Prompts to reconnect cable
+5. Verifies port is restored
+
+### Calibrate
+
+Calibrate robot motors and save calibration data to Hugging Face cache.
+
+```bash
+lerobot calibrate \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0 \
+  --robot.id=my_follower_arm
+```
+
+**Options:**
+
+- `--robot.type` - Robot type (e.g., `so100_follower`)
+- `--robot.port` - Serial port (e.g., `/dev/ttyUSB0`, `COM4`)
+- `--robot.id` - Robot identifier (default: `default`)
+- `--output` - Custom output path for calibration file
+
+**Compatible with:** `python -m lerobot calibrate`
+
+### Teleoperate
+
+Control robot through keyboard teleoperation.
+
+```bash
+lerobot teleoperate \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0 \
+  --robot.id=my_follower_arm
+```
+
+**Options:**
+
+- `--robot.type` - Robot type (e.g., `so100_follower`)
+- `--robot.port` - Serial port (e.g., `/dev/ttyUSB0`, `COM4`)
+- `--robot.id` - Robot identifier (default: `default`)
+- `--teleop.type` - Teleoperator type (default: `keyboard`)
+- `--teleop.stepSize` - Step size for keyboard control (default: `25`)
+- `--duration` - Duration in seconds, 0 = unlimited (default: `0`)
+
+**Controls:**
+
+- `w/s` - Motor 1 up/down
+- `a/d` - Motor 2 left/right
+- `q/e` - Motor 3 up/down
+- `r/f` - Motor 4 forward/back
+- `t/g` - Motor 5 up/down
+- `y/h` - Motor 6 open/close
+- `Ctrl+C` - Stop and exit
+
+**Compatible with:** `python -m lerobot teleoperate`
+
+### Release Motors
+
+Release robot motors for manual movement.
+
+```bash
+lerobot release-motors \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0
+```
+
+**Options:**
+
+- `--robot.type` - Robot type (e.g., `so100_follower`)
+- `--robot.port` - Serial port (e.g., `/dev/ttyUSB0`, `COM4`)
+- `--robot.id` - Robot identifier (default: `default`)
+- `--motors` - Specific motor IDs to release (comma-separated)
+
+**Compatible with:** `python -m lerobot release-motors`
+
+## Python lerobot Compatibility
+
+This CLI provides 100% compatible commands with Python lerobot:
+
+| Python lerobot                     | Node.js lerobot              | Status        |
+| ---------------------------------- | ---------------------------- | ------------- |
+| `python -m lerobot find_port`      | `npx lerobot find-port`      | ✅ Compatible |
+| `python -m lerobot calibrate`      | `npx lerobot calibrate`      | ✅ Compatible |
+| `python -m lerobot teleoperate`    | `npx lerobot teleoperate`    | ✅ Compatible |
+| `python -m lerobot release-motors` | `npx lerobot release-motors` | ✅ Compatible |
+
+### Calibration Data Compatibility
+
+Calibration files are saved to the same location as Python lerobot:
+
+```
+~/.cache/huggingface/lerobot/calibration/robots/{robot_type}/{robot_id}.json
+```
+
+This ensures calibration data is shared between Python and Node.js implementations.
+
+## Examples
+
+### Complete Workflow
+
+```bash
+# 1. Find your robot (interactive mode)
+npx lerobot find-port --interactive
+# Output: Detected port: /dev/ttyUSB0
+
+# 2. Calibrate the robot
+npx lerobot calibrate \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0 \
+  --robot.id=my_arm
+
+# 3. Control the robot
+npx lerobot teleoperate \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0 \
+  --robot.id=my_arm
+
+# 4. Release motors when done
+npx lerobot release-motors \
+  --robot.type=so100_follower \
+  --robot.port=/dev/ttyUSB0
+```
+
+### Automation Scripts
+
+```bash
+#!/bin/bash
+# Automated calibration script
+
+ROBOT_TYPE="so100_follower"
+ROBOT_PORT="/dev/ttyUSB0"
+ROBOT_ID="production_arm_1"
+
+echo "Starting automated calibration..."
+npx lerobot calibrate \
+  --robot.type=$ROBOT_TYPE \
+  --robot.port=$ROBOT_PORT \
+  --robot.id=$ROBOT_ID
+
+echo "Calibration complete. Starting teleoperation..."
+npx lerobot teleoperate \
+  --robot.type=$ROBOT_TYPE \
+  --robot.port=$ROBOT_PORT \
+  --robot.id=$ROBOT_ID \
+  --duration=60  # Run for 60 seconds
+```
+
+## Requirements
+
+- Node.js 18+
+- Compatible with Windows, macOS, and Linux
+- Same hardware requirements as Python lerobot
+
+## Related Packages
+
+- **[@lerobot/node](../node/)** - Node.js library for programmatic control
+- **[@lerobot/web](../web/)** - Browser library for web applications
+
+## License
+
+Apache-2.0

packages/cli/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "lerobot",
+  "version": "0.1.0",
+  "description": "CLI for lerobot.js",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "lerobot": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "keywords": [
+    "robotics",
+    "cli",
+    "lerobot",
+    "python-compatible",
+    "hardware-control"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite-node src/cli.ts",
+    "prepublishOnly": "npm run build",
+    "test": "echo 'No tests defined'"
+  },
+  "dependencies": {
+    "@lerobot/node": "file:../node",
+    "chalk": "^5.3.0",
+    "commander": "^11.0.0",
+    "serialport": "^12.0.0"
+  },
+  "devDependencies": {
+    "vite": "^6.3.5",
+    "vite-node": "^2.0.0",
+    "typescript": "^5.3.0",
+    "@types/node": "^18.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timpietrusky/lerobot.js/tree/main/packages/cli"
+  },
+  "license": "Apache-2.0",
+  "author": "Tim Pietrusky",
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/cli/pnpm-lock.yaml

@@ -0,0 +1,1167 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@lerobot/node':
+        specifier: file:../node
+        version: file:../node([email protected])
+      chalk:
+        specifier: ^5.3.0
+        version: 5.4.1
+      commander:
+        specifier: ^11.0.0
+        version: 11.1.0
+      serialport:
+        specifier: ^12.0.0
+        version: 12.0.0
+    devDependencies:
+      '@types/node':
+        specifier: ^18.0.0
+        version: 18.19.121
+      typescript:
+        specifier: ^5.3.0
+        version: 5.8.3
+      vite:
+        specifier: ^6.3.5
+        version: 6.3.5(@types/[email protected])
+      vite-node:
+        specifier: ^2.0.0
+        version: 2.1.9(@types/[email protected])
+
+packages:
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@lerobot/node@file:../node':
+    resolution: {directory: ../node, type: directory}
+    engines: {node: '>=18.0.0'}
+    peerDependencies:
+      typescript: '>=4.5.0'
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-Zj3Hl6sN34xJtMv7Anwb5Gu01yujyE/cLBDB2gnHTAHaWS1Z38L7kuSG+oAh0giZMqG060f/YBStXtMH6FvPMA==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-nTeCWY83kN64oQ5MGz3CgtPx8NSOhC5lWtsjTs+8JAJNLcP3QbLCtDDgUKQc/Ro/frpMq4SHUaHN6AMltcEoLQ==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-HV7bW2Fb/F5KPdM/9bApunQh68YVDU8sO8BvcW9OngQVN3HHHkw99wFupuUJfGR9pYLLAjcAOA6iO+evsbBaPQ==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-SSj8TlYV5nJixSsm/y3QXfhspSiLYP11zpfwp6G/YDXctf3Xkdnk4woJIF5VQe0of2OjzTt8EsxnJDCdHd2xMA==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-ZyrsG4TIT9xnOlLsSSi9w/X29tCbK1yegE49RYm3tu3wF1L/B6LVMqnEWyDB26d9Ecx9zrmXCiPmIabVuLmNSg==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-pCgHFoOECwVCJ5GFq8+gR8SBKnMO+xe5UEqbemxBpCKYQddRQMgomv1104RnLSg7nNvgKy05sLsY51+OVRyiVw==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-EtP8aquZ0xQg0ETFcxUbU71MZlHaw9MChwrQzatiE8U/bvi5uv/oChExXC4mWhjiqK7azGJBqU0tt5H123SzVA==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-qO7F7U3u1nfxYRPM8HqFtLd+raev2K137dsV08q/LRKRLEc7RsiDWihUnrINdsWQxPR9jqZ8DIIZ1zJJAm5PjQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-3dRaqLfcOXYsfvw5xMrxAk9Lb1f395gkoBYzSFcc/scgRFptRXL9DOaDpMiehf9CO8ZDRJW2z45b6fpU5nwjng==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-fhHFTutA7SM+IrR6lIfiHskxmpmPTJUXpWIsBXpeEwNgZzZZSg/q4i6FU4J8qOGyJ0TR+wXBwx/L7Ho9z0+uDg==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-i7wfGFXu8x4+FRqPymzjD+Hyav8l95UIZ773j7J7zRYc3Xsxy2wIn4x+llpunexXe6laaO72iEjeeGyUFmjKeA==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-B/l0dFcHVUnqcGZWKcWBSV2PF01YUt0Rvlurci5P+neqY/yMKchGU8ullZvIv5e8Y1C6wOn+U03mrDylP5q9Yw==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-32k4ENb5ygtkMwPMucAb8MtV8olkPT03oiTxJbgkJa7lJ7dZMr0GCFJlyvy+K8iq7F/iuOr41ZdUHaOiqyR3iQ==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-t5B2loThlFEauloaQkZg9gxV05BYeITLvLkWOkRXogP4qHXLkWSbSHKM9S6H1schf/0YGP/qNKtiISlxvfmmZw==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-YKjekwTEKgbB7n17gmODSmJVUIvj8CX7q5442/CK80L8nqOUbMtf8b01QkG3jOqyr1rotrAnW6B/qiHwfcuWQA==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-Jj5a9RUoe5ra+MEyERkDKLwTXVu6s3aACP51nkfnK9wJTraCC8IMe3snOfALkrjTYd2G1ViE1hICj0fZ7ALBPA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-7kX69DIrBeD7yNp4A5b81izs8BqoZkCIaxQaOpumcJ1S/kmqNFjPhDu1LHeVXv0SexfHQv5cqHsxLOjETuqDuA==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-wiJWMIpeaak/jsbaq2HMh/rzZxHVW1rU6coyeNNpMwk5isiPjSTx0a4YLSlYDwBH/WBvLz+EtsNqQScZTLJy3g==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-gBgaUDESVzMgWZhcyjfs9QFK16D8K6QZpwAaVNJxYDLHWayOta4ZMjGm/vsAEy3hvlS2GosVFlBlP9/Wb85DqQ==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-CvUo2ixeIQGtF6WvuB87XWqPQkoFAFqW+HUo/WzHwuHDvIwZCtjdWXoYCcr06iKGydiqTclC4jU/TNObC/xKZg==}
+    cpu: [x64]
+    os: [win32]
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-HAFzGhk9OuFMpuor7aT5G1ChPgn5qSsklTFOTUX72Rl6p0xwcSVsRtG/xaGp6bxpN7fI9D/S8THLBWbBgS6ldw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-r2XOwY2dDvbW7dKqSPIk2gzsr6M6Qpe9+/Ngs94fNaNlcTRCV02PfaoDmRgcubpNVVcLATlxSxPTIDw12dbKOg==}
+    engines: {node: '>=16.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-CJaUd5bLvtM9c5dmO9rPBHPXTa9R2UwpkJ0wdh9JCYcbrPWsKz+ErvR0hBLeo7NPeiFdjFO4sonRljiw4d2XiA==}
+    engines: {node: ^12.22 || ^14.13 || >=16}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0ei0txFAj+s6FTiCJFBJ1T2hpKkX8Md0Pu6dqMrYoirjPskDLJRgZGLqoy3/lnU1bkvHpnJO+9oJ3PB9v8rNlg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0PfLzO9t2X5ufKuBO34DQKLXrCCqS9xz2D0pfuaLNeTkyGUBv426zxoMf3rsMRodDOZNbFblu3Ae84MOQXjnZw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-aZLJhlRTjSmEwllLG7S4J8s8ctRAS0cbvCpO87smLvl3e4BgzbVgF6Z6zaJd3Aji2uSiYgfedCdNc4L6W+1E2g==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-gu26tVt5lQoybhorLTPsH2j2LnX3AOP2x/34+DUSTNaUTzu2fBXw+isVjQJpUBFWu6aeQRZw5bJol5X9Gxjblw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-GnCh8K0NAESfhCuXAt+FfBRz1Cf9CzIgXfp7SdMgXwrtuUnCC/yuRTUFWRvuzhYKoAo1TL0hhUo77SFHUH1T/w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-p1hiCRqvGHHLCN/8ZiPUY/G0zrxd7gtZs251n+cfNTn+87rwcdUeu9Dps3Aadx30/sOGGFL6brIRGK4l/t7MuQ==}
+    engines: {node: '>=8.6.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-rRAivhRkT3YO28WjmmG4FQX6L+KMb5/ikhyylRfzWPw0nSXy97+u07peS9CbHqaNvJkMhH1locp2H36aGMOEIA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-O7cywCWC8PiOMvo/gglEBfAkLjp/SENEML46BXDykfKP5mTPM46XMaX1L0waWU6DXJpBgjaL7+yX6VriVPbN4w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-ygDwj3O4SDpZlbrRUraoXIoIqb8sM7aMKryGjYTIF0JRnKeB1ys8+wIp0RFMdFbO62YriUDextHB5Um5cKFSWg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dCAVh4P/pZrLcPv9NJ2mvPRBg64L5jXuiRxIlyxxdZGH4WubwXVXY/kBTihQmiAMPxbT3yshSX8f2+feqWsxqA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0APxDGR9YvJXTRfY+uRGhzOhTpU5akSH183RUcwzN7QXh8/1jwFsFLCu0grmAUfi+fItCkR+Xr1TcNJLR13VNA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dozONxhPC/78pntuxpz/NOtVps8qIc/UZzdc/LuPvVsqCoJXiRxOg6ZtCP/W58iibJDKPZPAWPGYeZt9DJxI+Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-9On64rhzuqKdOQyiYLYv2lQOh3TZU/D3+IWCR5gk0alPel2nwpp4YwDEGiUBfrQZEdQ6xww0PWkzqth4wqwX3Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-bHOrbyztmyYIi4f1R0s17QsPs1uyyYnGcXeZoGEd227oZjry0q6XQBQxd82X1I57zEfwO8h9Xo+Kl5gX1d9MwQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==}
+    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
+    engines: {node: '>=16'}
+
+  [email protected]:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
+    engines: {node: '>=12'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  [email protected]:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
+  [email protected]:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-vgbBJTS4m5/KkE16t5Ly0WW9hz46swAstv0hYYwMtbG7AznRhNyfLRe8HZAiWIpcHzoO7HxhLuBQj9rJ/Ho0ZA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  [email protected]:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  [email protected]:
+    resolution: {integrity: sha512-WMmLFI+Boh6xbop+OAGo9cQ3OgX9MIg7xOQjn+pTCwOkk+FNDAeAemXkJ3HzDJrVXleLOFVa1ipuc1AmEx1Dwg==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-AmH3D9hHPFmnF/oq/rvigfiAouAKyK/TjnrkwZRYSFZxNggJxwvbAbfYrLeuvq7ktUdhuHdVdSjj852Z55R+uA==}
+    engines: {node: '>=16.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
+    engines: {node: '>=12.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || >=20.0.0
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      jiti: '>=1.21.0'
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+snapshots:
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@lerobot/node@file:../node([email protected])':
+    dependencies:
+      serialport: 12.0.0
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.4.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      '@serialport/parser-readline': 11.0.0
+      debug: 4.3.4
+      node-addon-api: 7.0.0
+      node-gyp-build: 4.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 11.0.0
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 12.0.0
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@types/[email protected]': {}
+
+  '@types/[email protected]':
+    dependencies:
+      undici-types: 5.26.5
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.2
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.3
+
+  [email protected]: {}
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.8
+      '@esbuild/android-arm': 0.25.8
+      '@esbuild/android-arm64': 0.25.8
+      '@esbuild/android-x64': 0.25.8
+      '@esbuild/darwin-arm64': 0.25.8
+      '@esbuild/darwin-x64': 0.25.8
+      '@esbuild/freebsd-arm64': 0.25.8
+      '@esbuild/freebsd-x64': 0.25.8
+      '@esbuild/linux-arm': 0.25.8
+      '@esbuild/linux-arm64': 0.25.8
+      '@esbuild/linux-ia32': 0.25.8
+      '@esbuild/linux-loong64': 0.25.8
+      '@esbuild/linux-mips64el': 0.25.8
+      '@esbuild/linux-ppc64': 0.25.8
+      '@esbuild/linux-riscv64': 0.25.8
+      '@esbuild/linux-s390x': 0.25.8
+      '@esbuild/linux-x64': 0.25.8
+      '@esbuild/netbsd-arm64': 0.25.8
+      '@esbuild/netbsd-x64': 0.25.8
+      '@esbuild/openbsd-arm64': 0.25.8
+      '@esbuild/openbsd-x64': 0.25.8
+      '@esbuild/openharmony-arm64': 0.25.8
+      '@esbuild/sunos-x64': 0.25.8
+      '@esbuild/win32-arm64': 0.25.8
+      '@esbuild/win32-ia32': 0.25.8
+      '@esbuild/win32-x64': 0.25.8
+
+  [email protected]([email protected]):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  [email protected]:
+    optional: true
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  [email protected]:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.46.2
+      '@rollup/rollup-android-arm64': 4.46.2
+      '@rollup/rollup-darwin-arm64': 4.46.2
+      '@rollup/rollup-darwin-x64': 4.46.2
+      '@rollup/rollup-freebsd-arm64': 4.46.2
+      '@rollup/rollup-freebsd-x64': 4.46.2
+      '@rollup/rollup-linux-arm-gnueabihf': 4.46.2
+      '@rollup/rollup-linux-arm-musleabihf': 4.46.2
+      '@rollup/rollup-linux-arm64-gnu': 4.46.2
+      '@rollup/rollup-linux-arm64-musl': 4.46.2
+      '@rollup/rollup-linux-loongarch64-gnu': 4.46.2
+      '@rollup/rollup-linux-ppc64-gnu': 4.46.2
+      '@rollup/rollup-linux-riscv64-gnu': 4.46.2
+      '@rollup/rollup-linux-riscv64-musl': 4.46.2
+      '@rollup/rollup-linux-s390x-gnu': 4.46.2
+      '@rollup/rollup-linux-x64-gnu': 4.46.2
+      '@rollup/rollup-linux-x64-musl': 4.46.2
+      '@rollup/rollup-win32-arm64-msvc': 4.46.2
+      '@rollup/rollup-win32-ia32-msvc': 4.46.2
+      '@rollup/rollup-win32-x64-msvc': 4.46.2
+      fsevents: 2.3.3
+
+  [email protected]:
+    dependencies:
+      '@serialport/binding-mock': 10.2.2
+      '@serialport/bindings-cpp': 12.0.1
+      '@serialport/parser-byte-length': 12.0.0
+      '@serialport/parser-cctalk': 12.0.0
+      '@serialport/parser-delimiter': 12.0.0
+      '@serialport/parser-inter-byte-timeout': 12.0.0
+      '@serialport/parser-packet-length': 12.0.0
+      '@serialport/parser-readline': 12.0.0
+      '@serialport/parser-ready': 12.0.0
+      '@serialport/parser-regex': 12.0.0
+      '@serialport/parser-slip-encoder': 12.0.0
+      '@serialport/parser-spacepacket': 12.0.0
+      '@serialport/stream': 12.0.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      cac: 6.7.14
+      debug: 4.4.1
+      es-module-lexer: 1.7.0
+      pathe: 1.1.2
+      vite: 5.4.19(@types/[email protected])
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.46.2
+    optionalDependencies:
+      '@types/node': 18.19.121
+      fsevents: 2.3.3
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      esbuild: 0.25.8
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.46.2
+      tinyglobby: 0.2.14
+    optionalDependencies:
+      '@types/node': 18.19.121
+      fsevents: 2.3.3

packages/cli/src/cli.ts

@@ -0,0 +1,441 @@
+#!/usr/bin/env node
+
+/**
+ * lerobot CLI - Python lerobot compatible command-line interface
+ * Uses @lerobot/node library for core functionality with CLI-specific interactive features
+ */
+
+import { program } from "commander";
+import chalk from "chalk";
+import {
+  findPort,
+  calibrate,
+  teleoperate,
+  releaseMotors,
+  connectPort,
+} from "@lerobot/node";
+import type { RobotConnection } from "@lerobot/node";
+import { SerialPort } from "serialport";
+import { createInterface } from "readline";
+import { platform } from "os";
+import { readdir } from "fs/promises";
+import { join } from "path";
+
+/**
+ * CLI-specific function to list available serial ports
+ * Only used by the CLI, not part of the library API
+ */
+async function findAvailablePorts(): Promise<string[]> {
+  if (platform() === "win32") {
+    // List COM ports using serialport library (equivalent to pyserial)
+    const ports = await SerialPort.list();
+    return ports.map((port) => port.path);
+  } else {
+    // List /dev/tty* ports for Unix-based systems (Linux/macOS)
+    try {
+      const devFiles = await readdir("/dev");
+      const ttyPorts = devFiles
+        .filter((file) => file.startsWith("tty"))
+        .map((file) => join("/dev", file));
+      return ttyPorts;
+    } catch (error) {
+      // Fallback to serialport library if /dev reading fails
+      const ports = await SerialPort.list();
+      return ports.map((port) => port.path);
+    }
+  }
+}
+
+/**
+ * CLI-specific interactive port detection for Python lerobot compatibility
+ * Matches Python lerobot's unplug/replug cable detection exactly
+ */
+async function detectPortInteractive(
+  onMessage?: (message: string) => void
+): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  function waitForInput(prompt: string): Promise<string> {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        resolve(answer);
+      });
+    });
+  }
+
+  try {
+    const message = "Finding all available ports for the MotorsBus.";
+    if (onMessage) onMessage(message);
+    else console.log(message);
+
+    // Get initial port list
+    const portsBefore = await findAvailablePorts();
+
+    // Show initial ports (Python lerobot style)
+    const portsMessage = `Ports before disconnecting: [${portsBefore
+      .map((p) => `'${p}'`)
+      .join(", ")}]`;
+    if (onMessage) onMessage(portsMessage);
+    else console.log(portsMessage);
+
+    const disconnectPrompt =
+      "Remove the USB cable from your MotorsBus and press Enter when done.";
+    await waitForInput(disconnectPrompt);
+
+    // Get port list after disconnect
+    const portsAfter = await findAvailablePorts();
+
+    // Find the difference
+    const portsDiff = portsBefore.filter((port) => !portsAfter.includes(port));
+
+    if (portsDiff.length === 1) {
+      const detectedPort = portsDiff[0];
+
+      // Show empty line then the result (Python lerobot style)
+      if (onMessage) {
+        onMessage("");
+        onMessage(`The port of this MotorsBus is '${detectedPort}'`);
+        onMessage("Reconnect the USB cable.");
+      } else {
+        console.log("");
+        console.log(`The port of this MotorsBus is '${detectedPort}'`);
+        console.log("Reconnect the USB cable.");
+      }
+
+      return detectedPort;
+    } else if (portsDiff.length === 0) {
+      throw new Error(
+        "No port difference detected. Please check cable connection."
+      );
+    } else {
+      throw new Error(
+        `Multiple ports detected: ${portsDiff.join(
+          ", "
+        )}. Please disconnect other devices.`
+      );
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+/**
+ * Create robot connection directly from specified port (Python lerobot style)
+ */
+async function connectToSpecificPort(
+  portPath: string,
+  robotType: string,
+  robotId: string
+): Promise<RobotConnection> {
+  console.log(chalk.gray(`📡 Connecting to ${portPath}...`));
+
+  const connection = await connectPort(portPath);
+
+  if (!connection.isConnected) {
+    throw new Error(
+      `Failed to connect to port ${portPath}: ${connection.error}`
+    );
+  }
+
+  // Configure the robot with CLI parameters
+  connection.robotType = robotType;
+  connection.robotId = robotId;
+  connection.name = `${robotType} on ${portPath}`;
+
+  console.log(chalk.green(`✅ Connected to ${robotType} on ${portPath}`));
+  return connection;
+}
+
+/**
+ * Find port command - matches Python lerobot CLI exactly
+ * Always interactive by default (like Python lerobot)
+ */
+program
+  .command("find-port")
+  .description(
+    "Find robot port with interactive cable detection (Python lerobot compatible)"
+  )
+  .action(async () => {
+    try {
+      console.log(chalk.blue("🔍 Finding robot port..."));
+
+      // Always use interactive cable detection (Python lerobot behavior)
+      await detectPortInteractive((message) =>
+        console.log(chalk.gray(message))
+      );
+      // No additional success message - detectPortInteractive already shows the result
+    } catch (error) {
+      console.error(
+        chalk.red(`❌ Error: ${error instanceof Error ? error.message : error}`)
+      );
+      process.exit(1);
+    }
+  });
+
+/**
+ * Calibrate command - matches Python lerobot exactly
+ */
+program
+  .command("calibrate")
+  .description("Calibrate robot motors")
+  .requiredOption("--robot.type <type>", "Robot type (e.g., so100_follower)")
+  .requiredOption(
+    "--robot.port <port>",
+    "Serial port (e.g., /dev/ttyUSB0, COM4)"
+  )
+  .option("--robot.id <id>", "Robot ID", "default")
+  .option("--output <path>", "Output calibration file path")
+  .action(async (options) => {
+    try {
+      const robotType = options["robot.type"];
+      const robotPort = options["robot.port"];
+      const robotId = options["robot.id"] || "default";
+
+      console.log(chalk.blue(`🔧 Starting calibration for ${robotType}...`));
+
+      // Step 1: Connect directly to specified port (Python lerobot style)
+      const robot = await connectToSpecificPort(robotPort, robotType, robotId);
+
+      // Step 2: Release motors
+      console.log(chalk.gray("🔓 Releasing motors for calibration setup..."));
+      await releaseMotors(robot);
+      console.log(
+        chalk.green("✅ Motors released - robot can now be moved by hand")
+      );
+
+      // Step 3: Wait for user to position robot
+      console.log(
+        chalk.yellow(
+          "\n📍 Move robot to your preferred starting position, then press Enter..."
+        )
+      );
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      await new Promise<void>((resolve) => {
+        rl.question("", () => {
+          rl.close();
+          resolve();
+        });
+      });
+
+      console.log(chalk.blue("\n🎯 Starting calibration process..."));
+      const calibrationProcess = await calibrate({
+        robot,
+        outputPath: options.output,
+        onProgress: (message) => console.log(chalk.gray(message)),
+        onLiveUpdate: (data) => {
+          // Clear previous output and display live data as table
+          process.stdout.write("\x1B[2J\x1B[0f"); // Clear screen and move cursor to top
+
+          console.log(chalk.cyan("📊 Live Motor Data:"));
+          console.log(
+            "┌─────────────────┬─────────┬─────────┬─────────┬─────────┐"
+          );
+          console.log(
+            "│ Motor           │ Current │ Min     │ Max     │ Range   │"
+          );
+          console.log(
+            "├─────────────────┼─────────┼─────────┼─────────┼─────────┤"
+          );
+
+          Object.entries(data).forEach(([name, info]) => {
+            const motorName = name.padEnd(15);
+            const current = info.current.toString().padStart(7);
+            const min = info.min.toString().padStart(7);
+            const max = info.max.toString().padStart(7);
+            const range = info.range.toString().padStart(7);
+            console.log(
+              `│ ${motorName} │ ${current} │ ${min} │ ${max} │ ${range} │`
+            );
+          });
+
+          console.log(
+            "└─────────────────┴─────────┴─────────┴─────────┴─────────┘"
+          );
+          console.log(
+            chalk.yellow(
+              "Move motors through full range, then press Enter when done..."
+            )
+          );
+        },
+      });
+
+      const results = await calibrationProcess.result;
+      console.log(chalk.green("\n✅ Calibration completed successfully!"));
+
+      // CRITICAL: Close robot connection to allow process to exit
+      if (robot.port && robot.port.close) {
+        await robot.port.close();
+      }
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ Calibration failed: ${
+            error instanceof Error ? error.message : error
+          }`
+        )
+      );
+
+      // Close robot connection even on error
+      try {
+        if (robot && robot.port && robot.port.close) {
+          await robot.port.close();
+        }
+      } catch (closeError) {
+        // Ignore close errors
+      }
+
+      process.exit(1);
+    }
+  });
+
+/**
+ * Teleoperate command - matches Python lerobot exactly
+ */
+program
+  .command("teleoperate")
+  .alias("teleop")
+  .description("Control robot through teleoperation")
+  .requiredOption("--robot.type <type>", "Robot type (e.g., so100_follower)")
+  .requiredOption(
+    "--robot.port <port>",
+    "Serial port (e.g., /dev/ttyUSB0, COM4)"
+  )
+  .option("--robot.id <id>", "Robot ID", "default")
+  .option("--teleop.type <type>", "Teleoperator type", "keyboard")
+  .option("--duration <seconds>", "Duration in seconds (0 = unlimited)", "0")
+  .action(async (options) => {
+    try {
+      const robotType = options["robot.type"];
+      const robotPort = options["robot.port"];
+      const robotId = options["robot.id"] || "default";
+      const teleopType = options["teleop.type"] || "keyboard";
+
+      console.log(chalk.blue(`🎮 Starting teleoperation for ${robotType}...`));
+
+      // Connect directly to specified port (Python lerobot style)
+      const robot = await connectToSpecificPort(robotPort, robotType, robotId);
+
+      const teleoperationProcess = await teleoperate({
+        robot,
+        teleop: {
+          type: teleopType,
+        },
+        onStateUpdate: (state) => {
+          if (state.isActive) {
+            const motorInfo = state.motorConfigs
+              .map(
+                (motor) => `${motor.name}:${Math.round(motor.currentPosition)}`
+              )
+              .join(" ");
+            process.stdout.write(`\r${chalk.cyan("🤖 Motors:")} ${motorInfo}`);
+          }
+        },
+      });
+
+      // Start teleoperation
+      teleoperationProcess.start();
+
+      // Handle duration limit
+      const duration = parseInt(options.duration || "0");
+      if (duration > 0) {
+        setTimeout(() => {
+          console.log(
+            chalk.yellow(
+              `\n⏰ Duration limit reached (${duration}s). Stopping...`
+            )
+          );
+          teleoperationProcess.stop();
+          process.exit(0);
+        }, duration * 1000);
+      }
+
+      // Handle process termination
+      process.on("SIGINT", async () => {
+        console.log(chalk.yellow("\n🛑 Stopping teleoperation..."));
+        teleoperationProcess.stop();
+        await teleoperationProcess.disconnect();
+        process.exit(0);
+      });
+
+      console.log(chalk.green("✅ Teleoperation started successfully!"));
+      console.log(chalk.gray("Press Ctrl+C to stop"));
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ Teleoperation failed: ${
+            error instanceof Error ? error.message : error
+          }`
+        )
+      );
+      process.exit(1);
+    }
+  });
+
+/**
+ * Release motors command
+ */
+program
+  .command("release-motors")
+  .description("Release robot motors for manual movement")
+  .requiredOption("--robot.type <type>", "Robot type (e.g., so100_follower)")
+  .requiredOption(
+    "--robot.port <port>",
+    "Serial port (e.g., /dev/ttyUSB0, COM4)"
+  )
+  .option("--robot.id <id>", "Robot ID", "default")
+  .option("--motors <ids>", "Specific motor IDs to release (comma-separated)")
+  .action(async (options) => {
+    try {
+      const robotType = options["robot.type"];
+      const robotPort = options["robot.port"];
+      const robotId = options["robot.id"] || "default";
+
+      console.log(chalk.blue(`🔓 Releasing motors for ${robotType}...`));
+
+      // Connect directly to specified port (Python lerobot style)
+      const robot = await connectToSpecificPort(robotPort, robotType, robotId);
+
+      const motorIds = options.motors
+        ? options.motors.split(",").map((id: string) => parseInt(id.trim()))
+        : undefined;
+
+      await releaseMotors(robot, motorIds);
+
+      console.log(chalk.green("✅ Motors released successfully!"));
+      console.log(chalk.gray("Motors can now be moved freely by hand."));
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `❌ Failed to release motors: ${
+            error instanceof Error ? error.message : error
+          }`
+        )
+      );
+      process.exit(1);
+    }
+  });
+
+/**
+ * Version and help setup
+ */
+program
+  .name("lerobot")
+  .description("Node.js robotics control CLI - Python lerobot compatible")
+  .version("0.1.0");
+
+/**
+ * Parse CLI arguments and run
+ */
+program.parse();
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

packages/cli/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @lerobot/cli - Python lerobot compatible CLI commands
+ *
+ * This package provides CLI commands that match Python lerobot exactly:
+ * - lerobot find-port (with interactive cable detection)
+ * - lerobot calibrate
+ * - lerobot teleoperate
+ * - lerobot release-motors
+ *
+ * Uses @lerobot/node library for core functionality
+ */
+
+export * from "./cli.js";

packages/cli/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": true,
+    "noEmit": false,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["src/**/*.test.ts", "dist", "node_modules"]
+}

packages/cli/vite.config.ts

@@ -0,0 +1,34 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  build: {
+    target: "node18",
+    lib: {
+      entry: {
+        cli: "src/cli.ts",
+        index: "src/index.ts",
+      },
+      formats: ["es"],
+    },
+    rollupOptions: {
+      external: [
+        // Node.js built-ins
+        "fs",
+        "fs/promises",
+        "path",
+        "os",
+        "readline",
+        "util",
+        "events",
+        "stream",
+        // External dependencies
+        "@lerobot/node",
+        "chalk",
+        "commander",
+        "serialport",
+      ],
+    },
+    minify: false,
+    sourcemap: true,
+  },
+});

packages/node/.eslintrc.json

@@ -0,0 +1,23 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "extends": ["eslint:recommended", "@typescript-eslint/recommended"],
+  "parserOptions": {
+    "ecmaVersion": 2022,
+    "sourceType": "module"
+  },
+  "env": {
+    "node": true,
+    "es2022": true
+  },
+  "rules": {
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      { "argsIgnorePattern": "^_" }
+    ],
+    "@typescript-eslint/no-explicit-any": "warn",
+    "@typescript-eslint/no-non-null-assertion": "warn"
+  },
+  "ignorePatterns": ["dist/", "node_modules/"]
+}

packages/node/.gitignore

@@ -0,0 +1,36 @@
+# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+*.tsbuildinfo
+
+# Environment files
+.env
+.env.local
+.env.production
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Test coverage
+coverage/
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock 

packages/node/README.md

@@ -0,0 +1,408 @@
+# @lerobot/node
+
+Control robots with Node.js (serialport), inspired by [LeRobot](https://github.com/huggingface/lerobot)
+
+🚀 **[Try the live (web) demo →](https://huggingface.co/spaces/NERDDISCO/LeRobot.js)**
+
+## Installation
+
+```bash
+# pnpm
+pnpm add @lerobot/node
+
+# npm
+npm install @lerobot/node
+
+# yarn
+yarn add @lerobot/node
+```
+
+## Quick Start
+
+```typescript
+import {
+  findPort,
+  connectPort,
+  releaseMotors,
+  calibrate,
+  teleoperate,
+} from "@lerobot/node";
+
+// 1. find available robot ports
+console.log("🔍 finding available robot ports...");
+const findProcess = await findPort();
+const robots = await findProcess.result;
+
+if (robots.length === 0) {
+  console.log("❌ no robots found. check connections.");
+  process.exit(1);
+}
+
+// 2. connect to the first robot found
+console.log(`✅ found ${robots.length} robot(s). connecting to first one...`);
+const robot = await connectPort(robots[0].path, robots[0].robotType);
+
+// 3. release motors for manual positioning
+console.log("🔓 releasing motors for manual positioning...");
+await releaseMotors(robot);
+
+// 4. calibrate motors by moving through full range
+console.log("⚙️ starting calibration...");
+const calibrationProcess = await calibrate({
+  robot,
+  onProgress: (message) => console.log(message),
+  onLiveUpdate: (data) => console.log("live positions:", data),
+});
+
+// move robot through its range, then stop calibration
+console.log("👋 move robot through full range, press enter when done...");
+process.stdin.once("data", () => {
+  calibrationProcess.stop();
+});
+
+const calibrationData = await calibrationProcess.result;
+console.log("✅ calibration complete!");
+
+// 5. control robot with keyboard
+console.log("🎮 starting keyboard control...");
+const teleop = await teleoperate({
+  robot,
+  calibrationData,
+  teleop: { type: "keyboard" },
+});
+teleop.start();
+
+// stop control after 30 seconds
+setTimeout(() => {
+  teleop.stop();
+  console.log("🛑 control stopped");
+}, 30000);
+```
+
+## How It Works
+
+### **Beginner Flow: `findPort()` → `connectPort()` → Use Robot**
+
+Most users should start with `findPort()` for discovery, then `connectPort()` for connection:
+
+```typescript
+// ✅ recommended: discover then connect
+const findProcess = await findPort();
+const robots = await findProcess.result;
+const robot = await connectPort(robots[0].path, robots[0].robotType);
+```
+
+### **Advanced: Direct Connection with `connectPort()`**
+
+Only use `connectPort()` when you already know the exact port:
+
+```typescript
+// ⚡ advanced: direct connection to known port
+const robot = await connectPort("/dev/ttyUSB0", "so100_follower");
+```
+
+## Core API
+
+### `findPort(config?): Promise<FindPortProcess>`
+
+Discovers available robotics hardware on serial ports. Unlike the web version, this only discovers ports - connection happens separately with `connectPort()`.
+
+```typescript
+// Discover all available robots
+const findProcess = await findPort();
+const robots = await findProcess.result;
+
+console.log(`Found ${robots.length} robot(s):`);
+robots.forEach((robot) => {
+  console.log(`- ${robot.robotType} on ${robot.path}`);
+});
+
+// Connect to specific robot
+const robot = await connectPort(robots[0].path, robots[0].robotType);
+```
+
+#### Options
+
+- `config?: FindPortConfig` - Optional configuration
+  - `onMessage?: (message: string) => void` - Progress messages callback
+
+#### Returns: `FindPortProcess`
+
+- `result: Promise<DiscoveredRobot[]>` - Array of discovered robots with `path`, `robotType`, and other metadata
+- `stop(): void` - Cancel discovery process
+
+#### DiscoveredRobot Structure
+
+```typescript
+interface DiscoveredRobot {
+  path: string; // Serial port path (e.g., "/dev/ttyUSB0")
+  robotType: "so100_follower" | "so100_leader";
+  // Additional metadata...
+}
+```
+
+---
+
+### `connectPort(port): Promise<RobotConnection>`
+
+Creates a connection to a robot on the specified serial port.
+
+```typescript
+// Connect to SO-100 follower arm
+const robot = await connectPort(
+  "/dev/ttyUSB0", // Serial port path
+  "so100_follower", // Robot type
+  "my_robot_arm" // Custom robot ID
+);
+
+// Windows
+const robot = await connectPort("COM4", "so100_follower", "my_robot");
+
+// Connection is ready to use
+console.log(`Connected to ${robot.robotType} on ${robot.port.path}`);
+```
+
+#### Parameters
+
+- `port: string` - Serial port path (e.g., `/dev/ttyUSB0`, `COM4`)
+- `robotType: "so100_follower" | "so100_leader"` - Type of robot
+- `robotId: string` - Custom identifier for your robot
+
+#### Returns: `Promise<RobotConnection>`
+
+- Initialized robot connection ready for calibration/teleoperation
+- Includes configured motor IDs, keyboard controls, and hardware settings
+
+---
+
+### `calibrate(config): Promise<CalibrationProcess>`
+
+Calibrates motor homing offsets and records range of motion. **Identical to Python lerobot behavior.**
+
+```typescript
+const calibrationProcess = await calibrate({
+  robot,
+  onProgress: (message) => {
+    console.log(message); // "⚙️ Setting motor homing offsets"
+  },
+  onLiveUpdate: (data) => {
+    // Real-time motor positions during range recording
+    Object.entries(data).forEach(([motor, info]) => {
+      console.log(`${motor}: ${info.current} (range: ${info.range})`);
+    });
+  },
+});
+
+// Move robot through full range of motion...
+// When finished, stop calibration
+calibrationProcess.stop();
+
+const calibrationData = await calibrationProcess.result;
+
+// Save to file (Python-compatible format)
+import { writeFileSync } from "fs";
+writeFileSync(
+  "./my_robot_calibration.json",
+  JSON.stringify(calibrationData, null, 2)
+);
+```
+
+#### Options
+
+- `config: CalibrateConfig`
+  - `robot: RobotConnection` - Connected robot from `connectPort()`
+  - `onProgress?: (message: string) => void` - Progress messages
+  - `onLiveUpdate?: (data: LiveCalibrationData) => void` - Real-time position updates
+
+#### Returns: `CalibrationProcess`
+
+- `result: Promise<CalibrationResults>` - **Python-compatible** calibration data
+- `stop(): void` - Stop calibration process
+
+#### Calibration Data Format
+
+**Python Compatible**: This format is identical to Python lerobot calibration files - you can use the same calibration data across both implementations.
+
+```json
+{
+  "shoulder_pan": {
+    "id": 1,
+    "drive_mode": 0,
+    "homing_offset": 14,
+    "range_min": 1015,
+    "range_max": 3128
+  },
+  "shoulder_lift": {
+    "id": 2,
+    "drive_mode": 0,
+    "homing_offset": 989,
+    "range_min": 965,
+    "range_max": 3265
+  },
+  "elbow_flex": {
+    "id": 3,
+    "drive_mode": 0,
+    "homing_offset": -879,
+    "range_min": 820,
+    "range_max": 3051
+  },
+  "wrist_flex": {
+    "id": 4,
+    "drive_mode": 0,
+    "homing_offset": 31,
+    "range_min": 758,
+    "range_max": 3277
+  },
+  "wrist_roll": {
+    "id": 5,
+    "drive_mode": 0,
+    "homing_offset": -37,
+    "range_min": 2046,
+    "range_max": 3171
+  },
+  "gripper": {
+    "id": 6,
+    "drive_mode": 0,
+    "homing_offset": -1173,
+    "range_min": 2038,
+    "range_max": 3528
+  }
+}
+```
+
+---
+
+### `teleoperate(config): Promise<TeleoperationProcess>`
+
+Real-time robot control with keyboard input. **Smooth, responsive movement** optimized for Node.js.
+
+#### Keyboard Teleoperation
+
+```typescript
+const teleop = await teleoperate({
+  robot,
+  teleop: { type: "keyboard" },
+  onStateUpdate: (state) => {
+    console.log(`Active: ${state.isActive}`);
+    state.motorConfigs.forEach((motor) => {
+      console.log(`${motor.name}: ${motor.currentPosition}`);
+    });
+  },
+});
+
+// Start keyboard control
+teleop.start();
+
+// Control will be active until stopped
+setTimeout(() => teleop.stop(), 60000);
+```
+
+#### Options
+
+- `config: TeleoperateConfig`
+  - `robot: RobotConnection` - Connected robot
+  - `teleop: TeleoperatorConfig` - Teleoperator configuration:
+    - `{ type: "keyboard" }` - Keyboard control with optimized defaults
+  - `onStateUpdate?: (state: TeleoperationState) => void` - State change callback
+
+#### Returns: `TeleoperationProcess`
+
+- `start(): void` - Begin teleoperation (shows keyboard controls)
+- `stop(): void` - Stop teleoperation
+- `getState(): TeleoperationState` - Current state and motor positions
+
+#### Keyboard Controls (SO-100)
+
+```
+Arrow Keys: Shoulder pan/lift
+WASD: Elbow flex, wrist flex
+Q/E: Wrist roll
+O/C: Gripper open/close
+ESC: Emergency stop
+Ctrl+C: Exit
+```
+
+#### Performance Characteristics
+
+- **120 Hz update rate** for smooth movement
+- **Immediate response** on keypress (no delay)
+- **8-unit step size** matching browser demo
+- **150ms key timeout** for optimal single-tap vs hold behavior
+
+---
+
+### `releaseMotors(robot): Promise<void>`
+
+Releases motor torque so robot can be moved freely by hand.
+
+```typescript
+// Release all motors for calibration
+await releaseMotors(robot);
+console.log("Motors released - you can now move the robot freely");
+```
+
+#### Parameters
+
+- `robot: RobotConnection` - Connected robot
+
+---
+
+## CLI Usage
+
+For command-line usage, install the CLI package:
+
+```bash
+# Install CLI globally
+pnpm add -g lerobot
+
+# Find and connect to robot
+npx lerobot find-port
+
+# Calibrate robot
+npx lerobot calibrate --robot.type so100_follower --robot.port /dev/ttyUSB0 --robot.id my_robot
+
+# Control robot with keyboard
+npx lerobot teleoperate --robot.type so100_follower --robot.port /dev/ttyUSB0 --robot.id my_robot
+
+# Release motors
+npx lerobot release-motors --robot.type so100_follower --robot.port /dev/ttyUSB0 --robot.id my_robot
+```
+
+**CLI commands are identical to Python lerobot** - same syntax, same behavior, seamless migration.
+
+## Node.js Requirements
+
+- **Node.js 18+**
+- **Serial port access** (may require permissions on Linux/macOS)
+- **Supported platforms**: Windows, macOS, Linux
+
+### Serial Port Permissions
+
+**Linux/macOS:**
+
+```bash
+# Add user to dialout group (Linux)
+sudo usermod -a -G dialout $USER
+
+# Set permissions (macOS)
+sudo chmod 666 /dev/tty.usbserial-*
+```
+
+**Windows:** No additional setup required.
+
+## Hardware Support
+
+Currently supports SO-100 follower and leader arms with STS3215 motors. More devices coming soon.
+
+## Migration from lerobot.py
+
+```python
+# Python lerobot
+python -m lerobot.calibrate --robot.type so100_follower --robot.port /dev/ttyUSB0
+
+# Node.js equivalent
+npx lerobot calibrate --robot.type so100_follower --robot.port /dev/ttyUSB0
+```
+
+- **Same commands** - just replace `python -m lerobot.` with `npx lerobot`
+- **Same calibration files** - Python and Node.js calibrations are interchangeable

packages/node/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@lerobot/node",
+  "version": "0.1.0",
+  "description": "Node.js-based robotics control using SerialPort",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./calibrate": {
+      "import": "./dist/calibrate.js",
+      "types": "./dist/calibrate.d.ts"
+    },
+    "./teleoperate": {
+      "import": "./dist/teleoperate.js",
+      "types": "./dist/teleoperate.d.ts"
+    },
+    "./find-port": {
+      "import": "./dist/find_port.js",
+      "types": "./dist/find_port.d.ts"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "keywords": [
+    "robotics",
+    "serialport",
+    "hardware-control",
+    "nodejs",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint src --ext .ts,.tsx --report-unused-disable-directives --max-warnings 0",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "serialport": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.41.0",
+    "@typescript-eslint/parser": "^8.41.0",
+    "@vitest/ui": "^2.0.0",
+    "eslint": "^9.34.0",
+    "typescript": "^5.3.0",
+    "vite": "^6.3.5",
+    "vite-node": "^2.0.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timpietrusky/lerobot.js/tree/main/packages/node"
+  },
+  "license": "Apache-2.0",
+  "author": "Tim Pietrusky",
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/node/pnpm-lock.yaml

@@ -0,0 +1,2396 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      serialport:
+        specifier: ^12.0.0
+        version: 12.0.0
+    devDependencies:
+      '@types/node':
+        specifier: ^18.0.0
+        version: 18.19.123
+      '@typescript-eslint/eslint-plugin':
+        specifier: ^8.41.0
+        version: 8.41.0(@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])
+      '@typescript-eslint/parser':
+        specifier: ^8.41.0
+        version: 8.41.0([email protected])([email protected])
+      '@vitest/ui':
+        specifier: ^2.0.0
+        version: 2.1.9([email protected])
+      eslint:
+        specifier: ^9.34.0
+        version: 9.34.0
+      typescript:
+        specifier: ^5.3.0
+        version: 5.8.3
+      vite:
+        specifier: ^6.3.5
+        version: 6.3.5(@types/[email protected])
+      vite-node:
+        specifier: ^2.0.0
+        version: 2.1.9(@types/[email protected])
+      vitest:
+        specifier: ^2.0.0
+        version: 2.1.9(@types/[email protected])(@vitest/[email protected])
+
+packages:
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-urAvrUedIqEiFR3FYSLTWQgLu5tb+m0qZw0NBEasUeo6wuqatkMDaRT+1uABiGXEu5vqgPd7FGE1BhsAIy9QVA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-OD3p7LYzWpLhZEyATcTSJ67qB5D+20vbtr6vHlHWSQYhKtzUYrETuWThmzFpZtFsBIxRvhO07+UgVA9m0i/O1w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-RONsAvGCz5oWyePVnLdZY/HHwA++nxYWIX1atInlaW6SEkwq6XkP3+cb825EUcRs5Vss/lGh/2YxAb5xqc07Uw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-yJAVPklM5+4+9dTeKwHOaA+LQkmrKFX96BM0A/2zQrbS6ENCmxc4OVoBs5dPkCCak2roAD+jKCdnmOqKszPkjA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Jw0mxgIaYX6R8ODrdkLLPwBqHTtYHJSmzzd+QeytSugzQ0Vg4c5rDky5VgkoowbZQahCbsv1rT1KW72MPIkevw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Vh2gLxxHnuoQ+GjPNvDSDRpoBCUzY4Pu0kBqMBDlK4fuWbKgGtmDIeEC081xi26PPjn+1tct+Bh8FjyLlw1Zlg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YPJ7hDQ9DnNe5vxOm6jaie9QsTwcKedPvizTVlqWG9GBSq+BuyWEDazlGaDTC5NGU4QJd666V0yqCBL2oWKPfA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-MmaEXxQRdXNFsRN/KcIimLnSJrk2r5H8v+WVafRWz5xdSVmWLoITZQXcgehI2ZE6gioE6HirAEToM/RvFBeuhw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-WIgg00ARWv/uYLU7lsuDK00d/hHSfES5BzdWAdAig1ioV5kaFNrtK8EqGcUBJhYqotlUByUKz5Qo6u8tt7iD/w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-FuzEP9BixzZohl1kLf76KEVOsxtIBFwCaLupVuk4eFVnOZfU+Wsn+x5Ryam7nILV2pkq2TqQM9EZPsOBuMC+kg==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-A1D9YzRX1i+1AJZuFFUMP1E9fMaYY+GnSQil9Tlw05utlE86EKTUA7RjwHDkEitmLYiFsRd9HwKBPEftNdBfjg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-O7k1J/dwHkY1RMVvglFHl1HzutGEFFZ3kNiDMSOyUrB7WcoHGf96Sh+64nTRT26l3GMbCW01Ekh/ThKM5iI7hQ==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-uv+dqfRazte3BzfMp8PAQXmdGHQt2oC/y2ovwpTteqrMx2lwaksiFZ/bdkXJC19ttTvNXBuWH53zy/aTj1FgGw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-GyG0KcMi1GBavP5JgAkkstMGyMholMDybAf8wF5A70CALlDM2p/f7YFE7H92eDeH/VBtFJA5MT4nRPDGg4JuzQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-rAqDYFv3yzMrq7GIcen3XP7TUEG/4LK86LUPMIz6RT8A6pRIDn0sDcvjudVZBiiTcZCY9y2SgYX2lgK3AF+1eg==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Xutvh6VjlbcHpsIIbwY8GVRbwoviWT19tFhgdA7DlenLGC/mbc3lBoVb7jxj9Z+eyGqvcnSyIltYUrkKzWqSvg==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-ASFQhgY4ElXh3nDcOMTkQero4b1lgubskNlhIfJrsH5OKZXDpUAKBlNS0Kx81jwOBp+HCeZqmoJuihTv57/jvQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-d1KfruIeohqAi6SA+gENMuObDbEjn22olAR7egqnkCD9DGBG0wsEARotkLgXDu6c4ncgWTZJtN5vcgxzWRMzcw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-nVDCkrvx2ua+XQNyfrujIG38+YGyuy2Ru9kKVNyh5jAys6n+l44tTtToqHjino2My8VAY6Lw9H7RI73XFi66Cg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-j8HgrDuSJFAujkivSMSfPQSAa5Fxbvk4rgNAS5i3K+r8s1X0p1uOO2Hl2xNsGFppOeHOLAVgYwDVlmxhq5h+SQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-1h8MUAwa0VhNCDp6Af0HToI2TJFAn1uqT9Al6DJVzdIBAd21m/G0Yfc77KDM3uF3T/YaOgQq3qTJHPbTOInaIQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-r2nVa5SIK9tSWd0kJd9HCffnDHKchTGikb//9c7HX+r+wHYCpQrSgxhlY6KWV1nFo1l4KFbsMlHk+L6fekLsUg==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-zUlaP2S12YhQ2UzUfcCuMDHQFJyKABkAjvO5YSndMiIkMimPmxA+BYSBikWgsRpvyxuRnow4nS5NPnf9fpv41w==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-YEGFFWESlPva8hGL+zvj2z/SaK+pH0SwOM0Nc/d+rVnW7GSTFlLBGzZkuSU9kFIGIo8q9X3ucpZhu8PDN5A2sQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-hiGgGC6KZ5LZz58OL/+qVVoZiuZlUYlYHNAmczOm7bs2oE1XriPFi5ZHHrS8ACpV5EjySrnoCKmcbQMN+ojnHg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/[email protected]':
+    resolution: {integrity: sha512-cn3Yr7+OaaZq1c+2pe+8yxC8E144SReCQjN6/2ynubzYjvyqZjTXfQJpAcQpsdJq3My7XADANiYGHoFC69pLQw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@eslint-community/[email protected]':
+    resolution: {integrity: sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+
+  '@eslint-community/[email protected]':
+    resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-xR93k9WhrDYpXHORXpxVL5oHj3Era7wo6k/Wd8/IsQNnZUTzkGS29lyn3nAT05v6ltUuTFVCCYDEGfy2Or/sPA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-78Md3/Rrxh83gCxoUc0EiciuOHsIITzLy53m3d9UyiW8y9Dj2D29FeETqyKA+BRK76tnTp6RXWb3pCay8Oyomg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-EoyvqQnBNsV1CWaEJ559rxXL4c8V92gxirbawSmVUOWXlsRxxQXl6LmCpdUblgxgSkDIqKnhzba2SjRTI/A5Rw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/[email protected]':
+    resolution: {integrity: sha512-Z5kJ+wU3oA7MMIqVR9tyZRtjYPr4OC004Q4Rw7pgOKUOKkJfZ3O24nz3WYfGRpMDNmcOi3TwQOmgm7B7Tpii0w==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@humanfs/[email protected]':
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/[email protected]':
+    resolution: {integrity: sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanwhocodes/[email protected]':
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+
+  '@humanwhocodes/[email protected]':
+    resolution: {integrity: sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==}
+    engines: {node: '>=18.18'}
+
+  '@humanwhocodes/[email protected]':
+    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    engines: {node: '>=18.18'}
+
+  '@jridgewell/[email protected]':
+    resolution: {integrity: sha512-VT2+G1VQs/9oz078bLrYbecdZKs912zQlkelYpuf+SXF+QvZDYJlbx/LSx+meSAwdDFnF8FVXW92AVjjkVmgFw==}
+
+  '@nodelib/[email protected]':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/[email protected]':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/[email protected]':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@polka/[email protected]':
+    resolution: {integrity: sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww==}
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-9f3nSTFI2ivfxc7/tHBHcJ8pRnp8ROrELvsVprlQPVvcZ+j5zztYd+PTJGpyIOAdTvNwNrpCXswKSeoQcyGjMQ==}
+    cpu: [arm]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-tFZSEhqJ8Yrpe50TzOdeoYi72gi/jsnT7y8Qrozf3cNu28WX+s6I3XzEPUAqoaT9SAS8Xz9AzGTFlxxCH/w20w==}
+    cpu: [arm64]
+    os: [android]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-+DikIIs+p6yU2hF51UaWG8BnHbq90X0QIOt5zqSKSZxY+G3qqdLih214e9InJal21af2PuuxkDectetGfbVPJw==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-5a+NofhdEB/WimSlFMskbFQn1vqz1FWryYpA99trmZGO6qEmiS0IsX6w4B3d91U878Q2ZQdiaFF1gxX4P147og==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-igr/RlKPS3OCy4jD3XBmAmo3UAcNZkJSubRsw1JeM8bAbwf15k/3eMZXD91bnjheijJiOJcga3kfCLKjV8IXNg==}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-MdigWzPSHlQzB1xZ+MdFDWTAH+kcn7UxjEBoOKuaso7z1DRlnAnrknB1mTtNOQ+GdPI8xgExAGwHeqQjntR0Cg==}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-dmZseE0ZwA/4yy1+BwFrDqFTjjNg24GO9xSrb1weVbt6AFkhp5pz1gVS7IMtfIvoWy8yp6q/zN0bKnefRUImvQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-fzhfn6p9Cfm3W8UrWKIa4l7Wfjs/KGdgaswMBBE3KY3Ta43jg2XsPrAtfezHpsRk0Nx+TFuS3hZk/To2N5kFPQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-vVDD+iPDPmJQ5nAQ5Tifq3ywdv60FartglFI8VOCK+hcU9aoG0qlQTsDJP97O5yiTaTqlneZWoARMcVC5nyUoQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-0d0jx08fzDHCzXqrtCMEEyxKU0SvJrWmUjUDE2/KDQ2UDJql0tfiwYvEx1oHELClKO8CNdE+AGJj+RqXscZpdQ==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-XBYu9oW9eKJadWn8M7hkTZsD4yG+RrsTrVEgyKwb4L72cpJjRbRboTG9Lg9fec8MxJp/cfTHAocg4mnismQR8A==}
+    cpu: [loong64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-wJaRvcT17PoOK6Ggcfo3nouFlybHvARBS4jzT0PC/lg17fIJHcDS2fZz3sD+iA4nRlho2zE6OGbU0HvwATdokQ==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-GZ5bkMFteAGkcmh8x0Ok4LSa+L62Ez0tMsHPX6JtR0wl4Xc3bQcrFHDiR5DGLEDFtGrXih4Nd/UDaFqs968/wA==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-7CjPw6FflFsVOUfWOrVrREiV3IYXG4RzZ1ZQUaT3BtSK8YXN6x286o+sruPZJESIaPebYuFowmg54ZdrkVBYog==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-nmvnl0ZiuysltcB/cKjUh40Rx4FbSyueERDsl2FLvLYr6pCgSsvGr3SocUT84svSpmloS7f1DRWqtRha74Gi1w==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-Cv+moII5C8RM6gZbR3cb21o6rquVDZrN2o81maROg1LFzBz2dZUwIQSxFA8GtGZ/F2KtsqQ2z3eFPBb6akvQNg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-PHcMG8DZTM9RCIjp8QIfN0VYtX0TtBPnWOTRurFhoCDoi9zptUZL2k7pCs+5rgut7JAiUsYy+huyhVKPcmxoog==}
+    cpu: [x64]
+    os: [linux]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-1SI/Rd47e8aQJeFWMDg16ET+fjvCcD/CzeaRmIEPmb05hx+3cCcwIF4ebUag4yTt/D1peE+Mgp0+Po3M358cAA==}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-JwOCYxmumFDfDhx4kNyz6kTVK3gWzBIvVdMNzQMRDubcoGRDniOOmo6DDNP42qwZx3Bp9/6vWJ+kNzNqXoHmeA==}
+    cpu: [ia32]
+    os: [win32]
+
+  '@rollup/[email protected]':
+    resolution: {integrity: sha512-IPMIfrfkG1GaEXi+JSsQEx8x9b4b+hRZXO7KYc2pKio3zO2/VDXDs6B9Ts/nnO+25Fk1tdAVtUn60HKKPPzDig==}
+    cpu: [x64]
+    os: [win32]
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-HAFzGhk9OuFMpuor7aT5G1ChPgn5qSsklTFOTUX72Rl6p0xwcSVsRtG/xaGp6bxpN7fI9D/S8THLBWbBgS6ldw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-r2XOwY2dDvbW7dKqSPIk2gzsr6M6Qpe9+/Ngs94fNaNlcTRCV02PfaoDmRgcubpNVVcLATlxSxPTIDw12dbKOg==}
+    engines: {node: '>=16.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-CJaUd5bLvtM9c5dmO9rPBHPXTa9R2UwpkJ0wdh9JCYcbrPWsKz+ErvR0hBLeo7NPeiFdjFO4sonRljiw4d2XiA==}
+    engines: {node: ^12.22 || ^14.13 || >=16}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0ei0txFAj+s6FTiCJFBJ1T2hpKkX8Md0Pu6dqMrYoirjPskDLJRgZGLqoy3/lnU1bkvHpnJO+9oJ3PB9v8rNlg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0PfLzO9t2X5ufKuBO34DQKLXrCCqS9xz2D0pfuaLNeTkyGUBv426zxoMf3rsMRodDOZNbFblu3Ae84MOQXjnZw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-aZLJhlRTjSmEwllLG7S4J8s8ctRAS0cbvCpO87smLvl3e4BgzbVgF6Z6zaJd3Aji2uSiYgfedCdNc4L6W+1E2g==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-gu26tVt5lQoybhorLTPsH2j2LnX3AOP2x/34+DUSTNaUTzu2fBXw+isVjQJpUBFWu6aeQRZw5bJol5X9Gxjblw==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-GnCh8K0NAESfhCuXAt+FfBRz1Cf9CzIgXfp7SdMgXwrtuUnCC/yuRTUFWRvuzhYKoAo1TL0hhUo77SFHUH1T/w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-p1hiCRqvGHHLCN/8ZiPUY/G0zrxd7gtZs251n+cfNTn+87rwcdUeu9Dps3Aadx30/sOGGFL6brIRGK4l/t7MuQ==}
+    engines: {node: '>=8.6.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-rRAivhRkT3YO28WjmmG4FQX6L+KMb5/ikhyylRfzWPw0nSXy97+u07peS9CbHqaNvJkMhH1locp2H36aGMOEIA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-O7cywCWC8PiOMvo/gglEBfAkLjp/SENEML46BXDykfKP5mTPM46XMaX1L0waWU6DXJpBgjaL7+yX6VriVPbN4w==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-ygDwj3O4SDpZlbrRUraoXIoIqb8sM7aMKryGjYTIF0JRnKeB1ys8+wIp0RFMdFbO62YriUDextHB5Um5cKFSWg==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dCAVh4P/pZrLcPv9NJ2mvPRBg64L5jXuiRxIlyxxdZGH4WubwXVXY/kBTihQmiAMPxbT3yshSX8f2+feqWsxqA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-0APxDGR9YvJXTRfY+uRGhzOhTpU5akSH183RUcwzN7QXh8/1jwFsFLCu0grmAUfi+fItCkR+Xr1TcNJLR13VNA==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-dozONxhPC/78pntuxpz/NOtVps8qIc/UZzdc/LuPvVsqCoJXiRxOg6ZtCP/W58iibJDKPZPAWPGYeZt9DJxI+Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@serialport/[email protected]':
+    resolution: {integrity: sha512-9On64rhzuqKdOQyiYLYv2lQOh3TZU/D3+IWCR5gk0alPel2nwpp4YwDEGiUBfrQZEdQ6xww0PWkzqth4wqwX3Q==}
+    engines: {node: '>=12.0.0'}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/[email protected]':
+    resolution: {integrity: sha512-K7DIaHnh0mzVxreCR9qwgNxp3MH9dltPNIEddW9MYUlcKAzm+3grKNSTe2vCJHI1FaLpvpL5JGJrz1UZDKYvDg==}
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-8fz6oa6wEKZrhXWro/S3n2eRJqlRcIa6SlDh59FXJ5Wp5XRZ8B9ixpJDcjadHq47hMx0u+HW6SNa6LjJQ6NLtw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      '@typescript-eslint/parser': ^8.41.0
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-gTtSdWX9xiMPA/7MV9STjJOOYtWwIJIYxkQxnSV1U3xcE+mnJSH3f6zI0RYP+ew66WSlZ5ed+h0VCxsvdC1jJg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-b8V9SdGBQzQdjJ/IO3eDifGpDBJfvrNTp2QD9P2BeqWTGrRibgfgIlBSw6z3b6R7dPzg752tOs4u/7yCLxksSQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-n6m05bXn/Cd6DZDGyrpXrELCPVaTnLdPToyhBoFkLIMznRUQUEQdSp96s/pcWSQdqOhrgR1mzJ+yItK7T+WPMQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-TDhxYFPUYRFxFhuU5hTIJk+auzM/wKvWgoNYOPcOf6i4ReYlOoYN8q1dV5kOTjNQNJgzWN3TUUQMtlLOcUgdUw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-63qt1h91vg3KsjVVonFJWjgSK7pZHSQFKH6uwqxAH9bBrsyRhO6ONoKyXxyVBzG1lJnFAJcKAcxLS54N1ee1OQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-9EwxsWdVqh42afLbHP90n2VdHaWU/oWgbH2P0CfcNfdKL7CuKpwMQGjwev56vWu9cSKU7FWSu6r9zck6CVfnag==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-D43UwUYJmGhuwHfY7MtNKRZMmfd8+p/eNSfFe6tH5mbVDto+VQCayeAt35rOx3Cs6wxD16DQtIKw/YXxt5E0UQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-udbCVstxZ5jiPIXrdH+BZWnPatjlYwJuJkDA4Tbo3WyYLh8NvB+h/bKeSZHDOFKfphsZYJQqaFtLeXEqurQn1A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0
+      typescript: '>=4.8.4 <6.0.0'
+
+  '@typescript-eslint/[email protected]':
+    resolution: {integrity: sha512-+GeGMebMCy0elMNg67LRNoVnUFPIm37iu5CmHESVx56/9Jsfdpsvbv605DQ81Pi/x11IdKUsS5nzgTYbCQU9fg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-UJCIkTBenHeKT1TTlKMJWy1laZewsRIzYighyYiJKZreqtdxSos/S1t+ktRMQWu2CKqaarrkeszJx1cgC5tGZw==}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-tVL6uJgoUdi6icpxmdrn5YNo3g3Dxv+IHJBr0GXHaEdTcw3F+cPKnsXFhli6nO+f/6SDKPHEK1UN+k+TQv0Ehg==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^5.0.0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-ZXSSqTFIrzduD63btIfEyOmNcBmQvgOVsPNPe0jYtESiXkhd8u2erDLnMxmGrDCwHCCHE7hxwRDCT3pt0esT4g==}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-oBO82rEjsxLNJincVhLhaxxZdEtV0EFHMK5Kmx5sJ6H9L183dHECjiefOAdnqpIgT5eZwT04PoggUnW88vOBNQ==}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-E1B35FwzXXTs9FHNK6bDszs7mtydNi5MIfUWpceJ8Xbfb1gBMscAnwLbEu+B44ed6W3XjL9/ehLPHR1fkf1KLQ==}
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-izzd2zmnk8Nl5ECYkW27328RbQ1nKvkm6Bb5DAaz1Gk59EbLkiCMa6OLT0NoaAYTjOFS6N+SMYW1nh4/9ljPiw==}
+    peerDependencies:
+      vitest: 2.1.9
+
+  '@vitest/[email protected]':
+    resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  [email protected]:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+
+  [email protected]:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  [email protected]:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
+  [email protected]:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-5nFxhUrX0PqtyogoYOA8IPswy5sZFTOsBFl/9bNsmDLgsxYTzSZQJDPppDnZPTQbzSEm0hqGjWPzRemQCYbD6A==}
+    engines: {node: '>=18'}
+
+  [email protected]:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==}
+    engines: {node: '>= 16'}
+
+  [email protected]:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==}
+    engines: {node: '>=12'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-vVC0USHGtMi8+R4Kz8rt6JhEWLxsv9Rnu/lGYbPR8u47B+DCBksq9JarW0zOO7bs37hyOK1l2/oqtbciutL5+Q==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-RNCHRX5EwdrESy3Jc9o8ie8Bog+PeYvvSR8sDGoZxNFTvZ4dlxUB3WzQ3bQMztFrSRODGrLLj8g6OFuGY/aiQg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
+    engines: {node: '>=0.10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  [email protected]:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
+    engines: {node: '>=12.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  [email protected]:
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w==}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==}
+
+  [email protected]:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+
+  [email protected]:
+    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  [email protected]:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
+
+  [email protected]:
+    resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
+
+  [email protected]:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  [email protected]:
+    resolution: {integrity: sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==}
+    engines: {node: '>= 4'}
+
+  [email protected]:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
+  [email protected]:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-2NCfZcT5VGVNX9mSZIxLRkEAegDGBpuQZBy13desuHeVORmBDyAET4TkJr4SjqQy3A8JDofMN6LpkK8Xcm/dlw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  [email protected]:
+    resolution: {integrity: sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
+
+  [email protected]:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-vgbBJTS4m5/KkE16t5Ly0WW9hz46swAstv0hYYwMtbG7AznRhNyfLRe8HZAiWIpcHzoO7HxhLuBQj9rJ/Ho0ZA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==}
+    engines: {node: '>= 14.16'}
+
+  [email protected]:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+
+  [email protected]:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  [email protected]:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  [email protected]:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+
+  [email protected]:
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-ONmkT3Ud3IfW15nl7l4qAZko5/2iZ5ALVBDh02ZSZ5IGVLJSYkRcRa3iB58VyEIyoofs9m2xdVrm+lTi97+3pw==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-AmH3D9hHPFmnF/oq/rvigfiAouAKyK/TjnrkwZRYSFZxNggJxwvbAbfYrLeuvq7ktUdhuHdVdSjj852Z55R+uA==}
+    engines: {node: '>=16.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+  [email protected]:
+    resolution: {integrity: sha512-FoqMu0NCGBLCcAkS1qA+XJIQTR6/JHfQXl+uGteNCQ76T91DMUjPa9xfmeqMY3z80nLSg9yQmNjK0Px6RWsH/A==}
+    engines: {node: '>=18'}
+
+  [email protected]:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==}
+
+  [email protected]:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
+    engines: {node: '>=12.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+
+  [email protected]:
+    resolution: {integrity: sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==}
+    engines: {node: '>=14.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==}
+    engines: {node: '>=14.0.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ==}
+    engines: {node: '>=18.12'}
+    peerDependencies:
+      typescript: '>=4.8.4'
+
+  [email protected]:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
+  [email protected]:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-AM9aQ/IPrW/6ENLQg3AGY4K1N2TGZdR5e4gu/MmmR2xR3Ll1+dib+nook92g4TV3PXVyeyxdWwtaCAiUL0hMxA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || >=20.0.0
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      jiti: '>=1.21.0'
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      sass-embedded: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-MSmPM9REYqDGBI8439mA4mWhV5sKmDlBKWIYbA3lRb2PTHACE0mgKwA8yQ2xq9vxDTuk4iPrECBAEW2aoFXY0Q==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@types/node': ^18.0.0 || >=20.0.0
+      '@vitest/browser': 2.1.9
+      '@vitest/ui': 2.1.9
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  [email protected]:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+
+snapshots:
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@esbuild/[email protected]':
+    optional: true
+
+  '@eslint-community/[email protected]([email protected])':
+    dependencies:
+      eslint: 9.34.0
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/[email protected]': {}
+
+  '@eslint/[email protected]':
+    dependencies:
+      '@eslint/object-schema': 2.1.6
+      debug: 4.4.1
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/[email protected]': {}
+
+  '@eslint/[email protected]':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/[email protected]':
+    dependencies:
+      ajv: 6.12.6
+      debug: 4.4.1
+      espree: 10.4.0
+      globals: 14.0.0
+      ignore: 5.3.2
+      import-fresh: 3.3.1
+      js-yaml: 4.1.0
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/[email protected]': {}
+
+  '@eslint/[email protected]': {}
+
+  '@eslint/[email protected]':
+    dependencies:
+      '@eslint/core': 0.15.2
+      levn: 0.4.1
+
+  '@humanfs/[email protected]': {}
+
+  '@humanfs/[email protected]':
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.3.1
+
+  '@humanwhocodes/[email protected]': {}
+
+  '@humanwhocodes/[email protected]': {}
+
+  '@humanwhocodes/[email protected]': {}
+
+  '@jridgewell/[email protected]': {}
+
+  '@nodelib/[email protected]':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/[email protected]': {}
+
+  '@nodelib/[email protected]':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.19.1
+
+  '@polka/[email protected]': {}
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@rollup/[email protected]':
+    optional: true
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      '@serialport/parser-readline': 11.0.0
+      debug: 4.3.4
+      node-addon-api: 7.0.0
+      node-gyp-build: 4.6.0
+    transitivePeerDependencies:
+      - supports-color
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 11.0.0
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/parser-delimiter': 12.0.0
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]': {}
+
+  '@serialport/[email protected]':
+    dependencies:
+      '@serialport/bindings-interface': 1.2.2
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  '@types/[email protected]': {}
+
+  '@types/[email protected]': {}
+
+  '@types/[email protected]':
+    dependencies:
+      undici-types: 5.26.5
+
+  '@typescript-eslint/[email protected](@typescript-eslint/[email protected]([email protected])([email protected]))([email protected])([email protected])':
+    dependencies:
+      '@eslint-community/regexpp': 4.12.1
+      '@typescript-eslint/parser': 8.41.0([email protected])([email protected])
+      '@typescript-eslint/scope-manager': 8.41.0
+      '@typescript-eslint/type-utils': 8.41.0([email protected])([email protected])
+      '@typescript-eslint/utils': 8.41.0([email protected])([email protected])
+      '@typescript-eslint/visitor-keys': 8.41.0
+      eslint: 9.34.0
+      graphemer: 1.4.0
+      ignore: 7.0.5
+      natural-compare: 1.4.0
+      ts-api-utils: 2.1.0([email protected])
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]([email protected])([email protected])':
+    dependencies:
+      '@typescript-eslint/scope-manager': 8.41.0
+      '@typescript-eslint/types': 8.41.0
+      '@typescript-eslint/typescript-estree': 8.41.0([email protected])
+      '@typescript-eslint/visitor-keys': 8.41.0
+      debug: 4.4.1
+      eslint: 9.34.0
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]([email protected])':
+    dependencies:
+      '@typescript-eslint/tsconfig-utils': 8.41.0([email protected])
+      '@typescript-eslint/types': 8.41.0
+      debug: 4.4.1
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]':
+    dependencies:
+      '@typescript-eslint/types': 8.41.0
+      '@typescript-eslint/visitor-keys': 8.41.0
+
+  '@typescript-eslint/[email protected]([email protected])':
+    dependencies:
+      typescript: 5.8.3
+
+  '@typescript-eslint/[email protected]([email protected])([email protected])':
+    dependencies:
+      '@typescript-eslint/types': 8.41.0
+      '@typescript-eslint/typescript-estree': 8.41.0([email protected])
+      '@typescript-eslint/utils': 8.41.0([email protected])([email protected])
+      debug: 4.4.1
+      eslint: 9.34.0
+      ts-api-utils: 2.1.0([email protected])
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]': {}
+
+  '@typescript-eslint/[email protected]([email protected])':
+    dependencies:
+      '@typescript-eslint/project-service': 8.41.0([email protected])
+      '@typescript-eslint/tsconfig-utils': 8.41.0([email protected])
+      '@typescript-eslint/types': 8.41.0
+      '@typescript-eslint/visitor-keys': 8.41.0
+      debug: 4.4.1
+      fast-glob: 3.3.3
+      is-glob: 4.0.3
+      minimatch: 9.0.5
+      semver: 7.7.2
+      ts-api-utils: 2.1.0([email protected])
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]([email protected])([email protected])':
+    dependencies:
+      '@eslint-community/eslint-utils': 4.7.0([email protected])
+      '@typescript-eslint/scope-manager': 8.41.0
+      '@typescript-eslint/types': 8.41.0
+      '@typescript-eslint/typescript-estree': 8.41.0([email protected])
+      eslint: 9.34.0
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@typescript-eslint/[email protected]':
+    dependencies:
+      '@typescript-eslint/types': 8.41.0
+      eslint-visitor-keys: 4.2.1
+
+  '@vitest/[email protected]':
+    dependencies:
+      '@vitest/spy': 2.1.9
+      '@vitest/utils': 2.1.9
+      chai: 5.2.1
+      tinyrainbow: 1.2.0
+
+  '@vitest/[email protected]([email protected](@types/[email protected]))':
+    dependencies:
+      '@vitest/spy': 2.1.9
+      estree-walker: 3.0.3
+      magic-string: 0.30.17
+    optionalDependencies:
+      vite: 5.4.19(@types/[email protected])
+
+  '@vitest/[email protected]':
+    dependencies:
+      tinyrainbow: 1.2.0
+
+  '@vitest/[email protected]':
+    dependencies:
+      '@vitest/utils': 2.1.9
+      pathe: 1.1.2
+
+  '@vitest/[email protected]':
+    dependencies:
+      '@vitest/pretty-format': 2.1.9
+      magic-string: 0.30.17
+      pathe: 1.1.2
+
+  '@vitest/[email protected]':
+    dependencies:
+      tinyspy: 3.0.2
+
+  '@vitest/[email protected]([email protected])':
+    dependencies:
+      '@vitest/utils': 2.1.9
+      fflate: 0.8.2
+      flatted: 3.3.3
+      pathe: 1.1.2
+      sirv: 3.0.1
+      tinyglobby: 0.2.14
+      tinyrainbow: 1.2.0
+      vitest: 2.1.9(@types/[email protected])(@vitest/[email protected])
+
+  '@vitest/[email protected]':
+    dependencies:
+      '@vitest/pretty-format': 2.1.9
+      loupe: 3.2.0
+      tinyrainbow: 1.2.0
+
+  [email protected]([email protected]):
+    dependencies:
+      acorn: 8.15.0
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  [email protected]:
+    dependencies:
+      color-convert: 2.0.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  [email protected]:
+    dependencies:
+      balanced-match: 1.0.2
+
+  [email protected]:
+    dependencies:
+      fill-range: 7.1.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      assertion-error: 2.0.1
+      check-error: 2.1.1
+      deep-eql: 5.0.2
+      loupe: 3.2.0
+      pathval: 2.0.1
+
+  [email protected]:
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      color-name: 1.1.4
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.2
+
+  [email protected]:
+    dependencies:
+      ms: 2.1.3
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.21.5
+      '@esbuild/android-arm': 0.21.5
+      '@esbuild/android-arm64': 0.21.5
+      '@esbuild/android-x64': 0.21.5
+      '@esbuild/darwin-arm64': 0.21.5
+      '@esbuild/darwin-x64': 0.21.5
+      '@esbuild/freebsd-arm64': 0.21.5
+      '@esbuild/freebsd-x64': 0.21.5
+      '@esbuild/linux-arm': 0.21.5
+      '@esbuild/linux-arm64': 0.21.5
+      '@esbuild/linux-ia32': 0.21.5
+      '@esbuild/linux-loong64': 0.21.5
+      '@esbuild/linux-mips64el': 0.21.5
+      '@esbuild/linux-ppc64': 0.21.5
+      '@esbuild/linux-riscv64': 0.21.5
+      '@esbuild/linux-s390x': 0.21.5
+      '@esbuild/linux-x64': 0.21.5
+      '@esbuild/netbsd-x64': 0.21.5
+      '@esbuild/openbsd-x64': 0.21.5
+      '@esbuild/sunos-x64': 0.21.5
+      '@esbuild/win32-arm64': 0.21.5
+      '@esbuild/win32-ia32': 0.21.5
+      '@esbuild/win32-x64': 0.21.5
+
+  [email protected]:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.25.8
+      '@esbuild/android-arm': 0.25.8
+      '@esbuild/android-arm64': 0.25.8
+      '@esbuild/android-x64': 0.25.8
+      '@esbuild/darwin-arm64': 0.25.8
+      '@esbuild/darwin-x64': 0.25.8
+      '@esbuild/freebsd-arm64': 0.25.8
+      '@esbuild/freebsd-x64': 0.25.8
+      '@esbuild/linux-arm': 0.25.8
+      '@esbuild/linux-arm64': 0.25.8
+      '@esbuild/linux-ia32': 0.25.8
+      '@esbuild/linux-loong64': 0.25.8
+      '@esbuild/linux-mips64el': 0.25.8
+      '@esbuild/linux-ppc64': 0.25.8
+      '@esbuild/linux-riscv64': 0.25.8
+      '@esbuild/linux-s390x': 0.25.8
+      '@esbuild/linux-x64': 0.25.8
+      '@esbuild/netbsd-arm64': 0.25.8
+      '@esbuild/netbsd-x64': 0.25.8
+      '@esbuild/openbsd-arm64': 0.25.8
+      '@esbuild/openbsd-x64': 0.25.8
+      '@esbuild/openharmony-arm64': 0.25.8
+      '@esbuild/sunos-x64': 0.25.8
+      '@esbuild/win32-arm64': 0.25.8
+      '@esbuild/win32-ia32': 0.25.8
+      '@esbuild/win32-x64': 0.25.8
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@eslint-community/eslint-utils': 4.7.0([email protected])
+      '@eslint-community/regexpp': 4.12.1
+      '@eslint/config-array': 0.21.0
+      '@eslint/config-helpers': 0.3.1
+      '@eslint/core': 0.15.2
+      '@eslint/eslintrc': 3.3.1
+      '@eslint/js': 9.34.0
+      '@eslint/plugin-kit': 0.3.5
+      '@humanfs/node': 0.16.6
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.3
+      '@types/estree': 1.0.8
+      '@types/json-schema': 7.0.15
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.6
+      debug: 4.4.1
+      escape-string-regexp: 4.0.0
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      esquery: 1.6.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    transitivePeerDependencies:
+      - supports-color
+
+  [email protected]:
+    dependencies:
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2([email protected])
+      eslint-visitor-keys: 4.2.1
+
+  [email protected]:
+    dependencies:
+      estraverse: 5.3.0
+
+  [email protected]:
+    dependencies:
+      estraverse: 5.3.0
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      reusify: 1.1.0
+
+  [email protected]([email protected]):
+    optionalDependencies:
+      picomatch: 4.0.3
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      flat-cache: 4.0.1
+
+  [email protected]:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  [email protected]:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  [email protected]:
+    dependencies:
+      flatted: 3.3.3
+      keyv: 4.5.4
+
+  [email protected]: {}
+
+  [email protected]:
+    optional: true
+
+  [email protected]:
+    dependencies:
+      is-glob: 4.0.3
+
+  [email protected]:
+    dependencies:
+      is-glob: 4.0.3
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      is-extglob: 2.1.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      argparse: 2.0.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      json-buffer: 3.0.1
+
+  [email protected]:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
+  [email protected]:
+    dependencies:
+      p-locate: 5.0.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.4
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+
+  [email protected]:
+    dependencies:
+      brace-expansion: 1.1.12
+
+  [email protected]:
+    dependencies:
+      brace-expansion: 2.0.2
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+
+  [email protected]:
+    dependencies:
+      yocto-queue: 0.1.0
+
+  [email protected]:
+    dependencies:
+      p-limit: 3.1.0
+
+  [email protected]:
+    dependencies:
+      callsites: 3.1.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@types/estree': 1.0.8
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.46.0
+      '@rollup/rollup-android-arm64': 4.46.0
+      '@rollup/rollup-darwin-arm64': 4.46.0
+      '@rollup/rollup-darwin-x64': 4.46.0
+      '@rollup/rollup-freebsd-arm64': 4.46.0
+      '@rollup/rollup-freebsd-x64': 4.46.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.46.0
+      '@rollup/rollup-linux-arm-musleabihf': 4.46.0
+      '@rollup/rollup-linux-arm64-gnu': 4.46.0
+      '@rollup/rollup-linux-arm64-musl': 4.46.0
+      '@rollup/rollup-linux-loongarch64-gnu': 4.46.0
+      '@rollup/rollup-linux-ppc64-gnu': 4.46.0
+      '@rollup/rollup-linux-riscv64-gnu': 4.46.0
+      '@rollup/rollup-linux-riscv64-musl': 4.46.0
+      '@rollup/rollup-linux-s390x-gnu': 4.46.0
+      '@rollup/rollup-linux-x64-gnu': 4.46.0
+      '@rollup/rollup-linux-x64-musl': 4.46.0
+      '@rollup/rollup-win32-arm64-msvc': 4.46.0
+      '@rollup/rollup-win32-ia32-msvc': 4.46.0
+      '@rollup/rollup-win32-x64-msvc': 4.46.0
+      fsevents: 2.3.3
+
+  [email protected]:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@serialport/binding-mock': 10.2.2
+      '@serialport/bindings-cpp': 12.0.1
+      '@serialport/parser-byte-length': 12.0.0
+      '@serialport/parser-cctalk': 12.0.0
+      '@serialport/parser-delimiter': 12.0.0
+      '@serialport/parser-inter-byte-timeout': 12.0.0
+      '@serialport/parser-packet-length': 12.0.0
+      '@serialport/parser-readline': 12.0.0
+      '@serialport/parser-ready': 12.0.0
+      '@serialport/parser-regex': 12.0.0
+      '@serialport/parser-slip-encoder': 12.0.0
+      '@serialport/parser-spacepacket': 12.0.0
+      '@serialport/stream': 12.0.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+
+  [email protected]:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      '@polka/url': 1.0.0-next.29
+      mrmime: 2.0.1
+      totalist: 3.0.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      has-flag: 4.0.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      is-number: 7.0.0
+
+  [email protected]: {}
+
+  [email protected]([email protected]):
+    dependencies:
+      typescript: 5.8.3
+
+  [email protected]:
+    dependencies:
+      prelude-ls: 1.2.1
+
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      punycode: 2.3.1
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      cac: 6.7.14
+      debug: 4.4.1
+      es-module-lexer: 1.7.0
+      pathe: 1.1.2
+      vite: 5.4.19(@types/[email protected])
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.46.0
+    optionalDependencies:
+      '@types/node': 18.19.123
+      fsevents: 2.3.3
+
+  [email protected](@types/[email protected]):
+    dependencies:
+      esbuild: 0.25.8
+      fdir: 6.4.6([email protected])
+      picomatch: 4.0.3
+      postcss: 8.5.6
+      rollup: 4.46.0
+      tinyglobby: 0.2.14
+    optionalDependencies:
+      '@types/node': 18.19.123
+      fsevents: 2.3.3
+
+  [email protected](@types/[email protected])(@vitest/[email protected]):
+    dependencies:
+      '@vitest/expect': 2.1.9
+      '@vitest/mocker': 2.1.9([email protected](@types/[email protected]))
+      '@vitest/pretty-format': 2.1.9
+      '@vitest/runner': 2.1.9
+      '@vitest/snapshot': 2.1.9
+      '@vitest/spy': 2.1.9
+      '@vitest/utils': 2.1.9
+      chai: 5.2.1
+      debug: 4.4.1
+      expect-type: 1.2.2
+      magic-string: 0.30.17
+      pathe: 1.1.2
+      std-env: 3.9.0
+      tinybench: 2.9.0
+      tinyexec: 0.3.2
+      tinypool: 1.1.1
+      tinyrainbow: 1.2.0
+      vite: 5.4.19(@types/[email protected])
+      vite-node: 2.1.9(@types/[email protected])
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 18.19.123
+      '@vitest/ui': 2.1.9([email protected])
+    transitivePeerDependencies:
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
+  [email protected]:
+    dependencies:
+      isexe: 2.0.0
+
+  [email protected]:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
+  [email protected]: {}
+
+  [email protected]: {}

packages/node/src/calibrate.ts

@@ -0,0 +1,288 @@
+/**
+ * Node.js calibration functionality using serialport API
+ * Provides both Python lerobot compatible CLI behavior and programmatic usage
+ * Uses proven calibration algorithms with web-compatible API
+ */
+
+import { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+import { createSO100Config } from "./robots/so100_config.js";
+import {
+  readAllMotorPositions,
+  releaseMotors as releaseMotorsLowLevel,
+  type MotorCommunicationPort,
+} from "./utils/motor-communication.js";
+import {
+  setHomingOffsets,
+  writeHardwarePositionLimits,
+} from "./utils/motor-calibration.js";
+import { createInterface } from "readline";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+
+// Debug logging removed - calibration working perfectly
+import type {
+  CalibrateConfig,
+  CalibrationResults,
+  LiveCalibrationData,
+  CalibrationProcess,
+} from "./types/calibration.js";
+import type { RobotConnection } from "./types/robot-connection.js";
+
+/**
+ * Get calibration file path (matches Python lerobot location)
+ */
+function getCalibrationFilePath(robotType: string, robotId: string): string {
+  const HF_HOME =
+    process.env.HF_HOME || join(homedir(), ".cache", "huggingface");
+  const calibrationDir = join(
+    HF_HOME,
+    "lerobot",
+    "calibration",
+    "robots",
+    robotType
+  );
+  return join(calibrationDir, `${robotId}.json`);
+}
+
+/**
+ * Create readline interface for user input
+ */
+function createReadlineInterface() {
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+/**
+ * Wait for user input with a prompt
+ */
+function waitForInput(rl: any, prompt: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer: string) => {
+      resolve(answer);
+    });
+  });
+}
+
+/**
+ * Record ranges of motion with live updates
+ */
+async function recordRangesOfMotion(
+  port: MotorCommunicationPort,
+  motorIds: number[],
+  motorNames: string[],
+  shouldStop: () => boolean,
+  onLiveUpdate?: (data: LiveCalibrationData) => void,
+  onProgress?: (message: string) => void
+): Promise<{
+  rangeMins: { [motor: string]: number };
+  rangeMaxes: { [motor: string]: number };
+}> {
+  const rangeMins: { [motor: string]: number } = {};
+  const rangeMaxes: { [motor: string]: number } = {};
+
+  // Read actual current positions (now centered due to applied homing offsets)
+  const startPositions = await readAllMotorPositions(port, motorIds);
+
+  for (let i = 0; i < motorNames.length; i++) {
+    const motorName = motorNames[i];
+    rangeMins[motorName] = startPositions[i];
+    rangeMaxes[motorName] = startPositions[i];
+  }
+
+  if (onProgress) {
+    onProgress(
+      "Move each motor through its full range of motion. The ranges will be recorded automatically."
+    );
+    onProgress(
+      "Press Enter when you have finished moving all motors through their ranges."
+    );
+  } else {
+    console.log(
+      "Move each motor through its full range of motion. The ranges will be recorded automatically."
+    );
+    console.log(
+      "Press Enter when you have finished moving all motors through their ranges."
+    );
+  }
+
+  // Set up readline for user input
+  const rl = createReadlineInterface();
+  let isRecording = true;
+
+  // Start recording in background
+  const recordingInterval = setInterval(async () => {
+    if (!isRecording) return;
+
+    try {
+      const currentPositions = await readAllMotorPositions(port, motorIds);
+      const liveData: LiveCalibrationData = {};
+
+      for (let i = 0; i < motorNames.length; i++) {
+        const motorName = motorNames[i];
+        const position = currentPositions[i];
+
+        // Update ranges
+        rangeMins[motorName] = Math.min(rangeMins[motorName], position);
+        rangeMaxes[motorName] = Math.max(rangeMaxes[motorName], position);
+
+        // Build live data
+        liveData[motorName] = {
+          current: position,
+          min: rangeMins[motorName],
+          max: rangeMaxes[motorName],
+          range: rangeMaxes[motorName] - rangeMins[motorName],
+        };
+      }
+
+      if (onLiveUpdate) {
+        onLiveUpdate(liveData);
+      }
+    } catch (error) {
+      // Silent - continue recording
+    }
+  }, 100); // Update every 100ms
+
+  // Wait for user to finish
+  try {
+    await waitForInput(rl, "");
+    // IMMEDIATELY stop recording and live updates
+    isRecording = false;
+    clearInterval(recordingInterval);
+  } finally {
+    // Ensure cleanup even if there's an error
+    isRecording = false;
+    clearInterval(recordingInterval);
+    rl.close();
+  }
+
+  return { rangeMins, rangeMaxes };
+}
+
+/**
+ * Main calibrate function with web-compatible API
+ */
+export async function calibrate(
+  config: CalibrateConfig
+): Promise<CalibrationProcess> {
+  const { robot, onLiveUpdate, onProgress, outputPath } = config;
+
+  // Validate robot configuration
+  if (!robot.robotType) {
+    throw new Error(
+      "Robot type is required for calibration. Please configure the robot first."
+    );
+  }
+
+  if (!robot.isConnected || !robot.port) {
+    throw new Error(
+      "Robot is not connected. Please use findPort() to connect first."
+    );
+  }
+
+  let shouldStop = false;
+  let port: NodeSerialPortWrapper | null = null;
+
+  const calibrationPromise = (async (): Promise<CalibrationResults> => {
+    try {
+      // Use the EXISTING port connection (don't create new one!)
+      port = robot.port;
+
+      // Get robot-specific configuration
+      let robotConfig;
+      if (robot.robotType.startsWith("so100")) {
+        robotConfig = createSO100Config(robot.robotType);
+      } else {
+        throw new Error(`Unsupported robot type: ${robot.robotType}`);
+      }
+
+      const { motorIds, motorNames, driveModes } = robotConfig;
+
+      // Debug logging removed - calibration working perfectly
+
+      // Starting calibration silently
+
+      // Step 1: Set homing offsets (motors should already be released and positioned)
+      // Note: Motors should be released BEFORE calling calibrate(), not inside it
+      // Setting homing offsets silently
+      const homingOffsets = await setHomingOffsets(port, motorIds, motorNames);
+
+      // Early debug test removed - calibration working perfectly
+
+      if (shouldStop) throw new Error("Calibration stopped by user");
+
+      // Step 2: Record ranges of motion silently
+      const { rangeMins, rangeMaxes } = await recordRangesOfMotion(
+        port,
+        motorIds,
+        motorNames,
+        () => shouldStop,
+        onLiveUpdate,
+        onProgress
+      );
+
+      if (shouldStop) throw new Error("Calibration stopped by user");
+
+      // Step 3: Write hardware position limits silently
+      await writeHardwarePositionLimits(
+        port,
+        motorIds,
+        motorNames,
+        rangeMins,
+        rangeMaxes
+      );
+
+      // Step 4: Skip motor locking (Python lerobot doesn't lock motors after calibration)
+
+      // Build calibration results (Python lerobot compatible format)
+
+      const calibrationResults: CalibrationResults = {};
+      for (let i = 0; i < motorNames.length; i++) {
+        const motorName = motorNames[i];
+        const homingOffsetValue = homingOffsets[motorName];
+
+        calibrationResults[motorName] = {
+          id: motorIds[i],
+          drive_mode: driveModes[i],
+          homing_offset: homingOffsetValue,
+          range_min: rangeMins[motorName],
+          range_max: rangeMaxes[motorName],
+        };
+      }
+
+      // Save calibration file
+      const calibrationPath =
+        outputPath ||
+        getCalibrationFilePath(robot.robotType, robot.robotId || "default");
+
+      // Ensure directory exists
+      const { mkdir } = await import("fs/promises");
+      const { dirname } = await import("path");
+      await mkdir(dirname(calibrationPath), { recursive: true });
+
+      await writeFile(
+        calibrationPath,
+        JSON.stringify(calibrationResults, null, 2)
+      );
+
+      if (onProgress) {
+        onProgress(`Calibration complete! Saved to: ${calibrationPath}`);
+      } else {
+        console.log(`Calibration complete! Saved to: ${calibrationPath}`);
+      }
+
+      return calibrationResults;
+    } finally {
+      // Note: Don't close the port - it belongs to the robot connection
+    }
+  })();
+
+  return {
+    stop(): void {
+      shouldStop = true;
+    },
+    result: calibrationPromise,
+  };
+}

packages/node/src/find_port.ts

@@ -0,0 +1,299 @@
+/**
+ * Node.js port discovery using serialport API
+ * Provides programmatic port discovery compatible with @lerobot/web API
+ */
+
+import { SerialPort } from "serialport";
+import { platform } from "os";
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+import type {
+  FindPortConfig,
+  FindPortProcess,
+  DiscoveredPort,
+  RobotConnection,
+} from "./types/port-discovery.js";
+
+/**
+ * Find available serial ports on the system
+ * Mirrors Python's find_available_ports() function
+ * Exported for CLI usage
+ */
+export async function findAvailablePorts(): Promise<string[]> {
+  if (platform() === "win32") {
+    // List COM ports using serialport library (equivalent to pyserial)
+    const ports = await SerialPort.list();
+    return ports.map((port) => port.path);
+  } else {
+    // List /dev/tty* ports for Unix-based systems (Linux/macOS)
+    try {
+      const devFiles = await readdir("/dev");
+      const ttyPorts = devFiles
+        .filter((file) => file.startsWith("tty"))
+        .map((file) => join("/dev", file));
+      return ttyPorts;
+    } catch (error) {
+      // Fallback to serialport library if /dev reading fails
+      const ports = await SerialPort.list();
+      return ports.map((port) => port.path);
+    }
+  }
+}
+
+/**
+ * Connect directly to a robot port (Python lerobot compatible)
+ * Equivalent to robot.connect() in Python lerobot
+ */
+export async function connectPort(
+  portPath: string,
+  robotType: "so100_follower" | "so100_leader" = "so100_follower",
+  robotId: string = "robot"
+): Promise<RobotConnection> {
+  // Test connection
+  const port = new NodeSerialPortWrapper(portPath);
+  let isConnected = false;
+
+  try {
+    await port.initialize();
+    isConnected = true;
+    await port.close();
+  } catch (error) {
+    // Connection failed
+  }
+
+  // Return the ACTUAL working port, properly initialized!
+  const workingPort = new NodeSerialPortWrapper(portPath);
+
+  // Initialize the working port if connection test succeeded
+  if (isConnected) {
+    try {
+      await workingPort.initialize();
+    } catch (error) {
+      isConnected = false;
+    }
+  }
+
+  return {
+    port: workingPort, // ← Return the initialized working port!
+    name: `Robot on ${portPath}`,
+    robotType,
+    robotId,
+    isConnected,
+    serialNumber: portPath, // Use port path as serial number for Node.js
+    error: isConnected ? undefined : "Connection failed",
+  };
+}
+
+/**
+ * Interactive mode: Return discovered robot ports (Node.js style)
+ * Unlike web version, this only discovers - user must call connectPort() separately
+ */
+async function findPortInteractive(
+  options: FindPortConfig
+): Promise<DiscoveredPort[]> {
+  const { onMessage } = options;
+
+  onMessage?.("🔍 Searching for available robot ports...");
+
+  // Get all available ports
+  const availablePorts = await findAvailablePorts();
+
+  if (availablePorts.length === 0) {
+    throw new Error("No serial ports found");
+  }
+
+  onMessage?.(
+    `Found ${availablePorts.length} port(s), first available: ${availablePorts[0]}`
+  );
+
+  // Return discovered ports (no connection attempt)
+  return availablePorts.map((path) => ({
+    path,
+    robotType: "so100_follower" as const, // Default type, user can override
+  }));
+}
+
+/**
+ * Auto-connect mode: Connect to robots by serial number/port path
+ * Returns all connection attempts (successful and failed)
+ */
+async function findPortAutoConnect(
+  robotConfigs: NonNullable<FindPortConfig["robotConfigs"]>,
+  options: FindPortConfig
+): Promise<RobotConnection[]> {
+  const { onMessage } = options;
+  const results: RobotConnection[] = [];
+
+  onMessage?.(`🔍 Auto-connecting to ${robotConfigs.length} robot(s)...`);
+
+  for (const config of robotConfigs) {
+    try {
+      onMessage?.(
+        `Connecting to ${config.robotId} (${config.serialNumber})...`
+      );
+
+      // Use serialNumber as port path for Node.js
+      const connection = await connectPort(config.serialNumber);
+
+      if (connection.isConnected) {
+        onMessage?.(`✅ Connected to ${config.robotId}`);
+        results.push({
+          ...connection,
+          robotType: config.robotType,
+          robotId: config.robotId,
+          serialNumber: config.serialNumber,
+        });
+      } else {
+        onMessage?.(`❌ Failed to connect to ${config.robotId}`);
+        results.push({
+          ...connection,
+          robotType: config.robotType,
+          robotId: config.robotId,
+          serialNumber: config.serialNumber,
+          isConnected: false,
+          error: connection.error || "Connection failed",
+        });
+      }
+    } catch (error) {
+      onMessage?.(
+        `❌ Error connecting to ${config.robotId}: ${
+          error instanceof Error ? error.message : error
+        }`
+      );
+      results.push({
+        port: {
+          path: config.serialNumber,
+          write: async () => {},
+          read: async () => null,
+          open: async () => {},
+          close: async () => {},
+          isOpen: false,
+        },
+        name: `Failed: ${config.robotId}`,
+        isConnected: false,
+        robotType: config.robotType,
+        robotId: config.robotId,
+        serialNumber: config.serialNumber,
+        error: error instanceof Error ? error.message : "Unknown error",
+      });
+    }
+  }
+
+  const successCount = results.filter((r) => r.isConnected).length;
+  onMessage?.(
+    `🎯 Connected to ${successCount}/${robotConfigs.length} robot(s)`
+  );
+
+  return results;
+}
+
+/**
+ * Main findPort function - Node.js discovery-only API
+ *
+ * Discovers available robot ports without connecting.
+ * User must call connectPort() separately to establish connections.
+ */
+export async function findPort(
+  config: FindPortConfig = {}
+): Promise<FindPortProcess> {
+  const { onMessage } = config;
+  let stopped = false;
+
+  onMessage?.("🤖 Interactive port discovery started");
+
+  // Create result promise
+  const resultPromise = (async () => {
+    if (stopped) {
+      throw new Error("Port discovery was stopped");
+    }
+
+    return await findPortInteractive(config);
+  })();
+
+  // Return process object
+  return {
+    result: resultPromise,
+    stop: () => {
+      stopped = true;
+      onMessage?.("🛑 Port discovery stopped");
+    },
+  };
+}
+
+/**
+ * Interactive port detection for CLI usage only
+ * Matches Python lerobot's unplug/replug cable detection exactly
+ * This function should only be used by the CLI, not the library
+ */
+export async function detectPortInteractive(
+  onMessage?: (message: string) => void
+): Promise<string> {
+  const { createInterface } = await import("readline");
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  function waitForInput(prompt: string): Promise<string> {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        resolve(answer);
+      });
+    });
+  }
+
+  try {
+    const message = "Finding all available ports for the MotorsBus.";
+    if (onMessage) onMessage(message);
+    else console.log(message);
+
+    // Get initial port list
+    const portsBefore = await findAvailablePorts();
+
+    const disconnectPrompt =
+      "Remove the USB cable from your MotorsBus and press Enter when done.";
+    await waitForInput(disconnectPrompt);
+
+    // Get port list after disconnect
+    const portsAfter = await findAvailablePorts();
+
+    // Find the difference
+    const portsDiff = portsBefore.filter((port) => !portsAfter.includes(port));
+
+    if (portsDiff.length === 1) {
+      const detectedPort = portsDiff[0];
+      const successMessage = `Detected port: ${detectedPort}`;
+      if (onMessage) onMessage(successMessage);
+      else console.log(successMessage);
+
+      const reconnectPrompt =
+        "Reconnect the USB cable to your MotorsBus and press Enter when done.";
+      await waitForInput(reconnectPrompt);
+
+      // Verify the port is back
+      const portsReconnected = await findAvailablePorts();
+      if (portsReconnected.includes(detectedPort)) {
+        const verifyMessage = `Verified port: ${detectedPort}`;
+        if (onMessage) onMessage(verifyMessage);
+        else console.log(verifyMessage);
+        return detectedPort;
+      } else {
+        throw new Error("Port not found after reconnection");
+      }
+    } else if (portsDiff.length === 0) {
+      throw new Error(
+        "No port difference detected. Please check cable connection."
+      );
+    } else {
+      throw new Error(
+        `Multiple ports detected: ${portsDiff.join(
+          ", "
+        )}. Please disconnect other devices.`
+      );
+    }
+  } finally {
+    rl.close();
+  }
+}

packages/node/src/index.ts

@@ -0,0 +1,64 @@
+/**
+ * @lerobot/node - Node.js-based robotics control using SerialPort API
+ *
+ * Control robotics hardware directly from Node.js applications, CLI tools, and desktop software.
+ */
+
+// Core functions
+export { calibrate } from "./calibrate.js";
+export { teleoperate } from "./teleoperate.js";
+export { findPort, connectPort } from "./find_port.js";
+export { releaseMotors } from "./release_motors.js";
+
+// Types
+export type {
+  RobotConnection,
+  RobotConfig,
+  SerialPort,
+  SerialPortInfo,
+  SerialOptions,
+} from "./types/robot-connection.js";
+
+export type {
+  FindPortConfig,
+  FindPortProcess,
+  DiscoveredPort,
+} from "./types/port-discovery.js";
+
+export type {
+  CalibrateConfig,
+  CalibrationResults,
+  LiveCalibrationData,
+  CalibrationProcess,
+} from "./types/calibration.js";
+
+export type {
+  MotorConfig,
+  TeleoperationState,
+  TeleoperationProcess,
+  TeleoperateConfig,
+  TeleoperatorConfig,
+  DirectTeleoperatorConfig,
+} from "./types/teleoperation.js";
+
+export type {
+  RobotHardwareConfig,
+  KeyboardControl,
+} from "./types/robot-config.js";
+
+// Utilities (advanced users)
+export { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+export {
+  readAllMotorPositions,
+  readMotorPosition,
+} from "./utils/motor-communication.js";
+export {
+  createSO100Config,
+  SO100_KEYBOARD_CONTROLS,
+} from "./robots/so100_config.js";
+export { KEYBOARD_TELEOPERATOR_DEFAULTS } from "./teleoperators/index.js";
+export {
+  getHfHome,
+  getHfLerobotHome,
+  getCalibrationDir,
+} from "./utils/constants.js";

packages/node/src/release_motors.ts

@@ -0,0 +1,70 @@
+/**
+ * User-facing motor release functionality for Node.js
+ * Simple API - pass in robotConnection, motors get released
+ *
+ * Handles robot configuration and port management internally
+ */
+
+import { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+import { createSO100Config } from "./robots/so100_config.js";
+import { releaseMotors as releaseMotorsLowLevel } from "./utils/motor-communication.js";
+import type { RobotConnection } from "./types/robot-connection.js";
+
+/**
+ * Release robot motors (allows free movement by hand)
+ * Perfect for calibration setup or manual positioning
+ *
+ * @param robotConnection - Connected robot with configured type
+ * @param motorIds - Optional specific motor IDs to release (defaults to all motors for robot type)
+ * @throws Error if robot type not configured or motorIds invalid
+ */
+export async function releaseMotors(
+  robotConnection: RobotConnection,
+  motorIds?: number[]
+): Promise<void> {
+  // Validate robot type is configured
+  if (!robotConnection.robotType) {
+    throw new Error(
+      "Robot type is required to release motors. Please configure the robot first."
+    );
+  }
+
+  // Validate robot connection
+  if (!robotConnection.isConnected || !robotConnection.port) {
+    throw new Error(
+      "Robot is not connected. Please use findPort() to connect first."
+    );
+  }
+
+  // Use the EXISTING port connection (don't create new one!)
+  const port = robotConnection.port;
+
+  // Get robot-specific configuration
+  let robotConfig;
+  if (robotConnection.robotType.startsWith("so100")) {
+    robotConfig = createSO100Config(robotConnection.robotType);
+  } else {
+    throw new Error(`Unsupported robot type: ${robotConnection.robotType}`);
+  }
+
+  // Determine which motors to release
+  const motorsToRelease = motorIds || robotConfig.motorIds;
+
+  // Validate motorIds are valid for this robot type
+  if (motorIds) {
+    const invalidMotors = motorIds.filter(
+      (id) => !robotConfig.motorIds.includes(id)
+    );
+    if (invalidMotors.length > 0) {
+      throw new Error(
+        `Invalid motor IDs [${invalidMotors.join(", ")}] for ${
+          robotConnection.robotType
+        }. Valid IDs: [${robotConfig.motorIds.join(", ")}]`
+      );
+    }
+  }
+
+  // Release the motors using low-level function
+  await releaseMotorsLowLevel(port, motorsToRelease);
+  // Note: Don't close the port - it belongs to the robot connection
+}

packages/node/src/robots/so100_config.ts

@@ -0,0 +1,98 @@
+/**
+ * SO-100 specific hardware configuration
+ */
+
+import type { RobotHardwareConfig } from "../types/robot-config.js";
+
+/**
+ * STS3215 Protocol Configuration for SO-100 devices
+ */
+export const NODE_STS3215_PROTOCOL = {
+  resolution: 4096, // 12-bit resolution (0-4095)
+  homingOffsetAddress: 31, // Address for Homing_Offset register
+  homingOffsetLength: 2, // 2 bytes for Homing_Offset
+  presentPositionAddress: 56, // Address for Present_Position register
+  presentPositionLength: 2, // 2 bytes for Present_Position
+  minPositionLimitAddress: 9, // Address for Min_Position_Limit register
+  minPositionLimitLength: 2, // 2 bytes for Min_Position_Limit
+  maxPositionLimitAddress: 11, // Address for Max_Position_Limit register
+  maxPositionLimitLength: 2, // 2 bytes for Max_Position_Limit
+  signMagnitudeBit: 11, // Bit 11 is sign bit for Homing_Offset encoding
+} as const;
+
+/**
+ * SO-100 Device Configuration
+ * Motor names, IDs, and drive modes for both follower and leader
+ */
+export const SO100_CONFIG = {
+  motorNames: [
+    "shoulder_pan",
+    "shoulder_lift",
+    "elbow_flex",
+    "wrist_flex",
+    "wrist_roll",
+    "gripper",
+  ],
+  motorIds: [1, 2, 3, 4, 5, 6],
+  // All SO-100 motors use drive_mode=0
+  driveModes: [0, 0, 0, 0, 0, 0],
+};
+
+/**
+ * SO-100 Keyboard Controls for Teleoperation
+ * Robot-specific mapping optimized for SO-100 joint layout
+ */
+export const SO100_KEYBOARD_CONTROLS = {
+  // Shoulder controls
+  ArrowUp: { motor: "shoulder_lift", direction: 1, description: "Shoulder up" },
+  ArrowDown: {
+    motor: "shoulder_lift",
+    direction: -1,
+    description: "Shoulder down",
+  },
+  ArrowLeft: {
+    motor: "shoulder_pan",
+    direction: -1,
+    description: "Shoulder left",
+  },
+  ArrowRight: {
+    motor: "shoulder_pan",
+    direction: 1,
+    description: "Shoulder right",
+  },
+
+  // WASD controls
+  w: { motor: "elbow_flex", direction: 1, description: "Elbow flex" },
+  s: { motor: "elbow_flex", direction: -1, description: "Elbow extend" },
+  a: { motor: "wrist_flex", direction: -1, description: "Wrist down" },
+  d: { motor: "wrist_flex", direction: 1, description: "Wrist up" },
+
+  // Wrist roll and gripper
+  q: { motor: "wrist_roll", direction: -1, description: "Wrist roll left" },
+  e: { motor: "wrist_roll", direction: 1, description: "Wrist roll right" },
+  o: { motor: "gripper", direction: 1, description: "Gripper open" },
+  c: { motor: "gripper", direction: -1, description: "Gripper close" },
+
+  // Emergency stop
+  Escape: {
+    motor: "emergency_stop",
+    direction: 0,
+    description: "Emergency stop",
+  },
+} as const;
+
+/**
+ * Create SO-100 hardware configuration
+ */
+export function createSO100Config(
+  deviceType: "so100_follower" | "so100_leader"
+): RobotHardwareConfig {
+  return {
+    deviceType,
+    motorNames: SO100_CONFIG.motorNames,
+    motorIds: SO100_CONFIG.motorIds,
+    driveModes: SO100_CONFIG.driveModes,
+    keyboardControls: SO100_KEYBOARD_CONTROLS,
+    protocol: NODE_STS3215_PROTOCOL,
+  };
+} 

packages/node/src/teleoperate.ts

@@ -0,0 +1,223 @@
+/**
+ * Node.js teleoperation functionality using serialport API
+ * Provides both Python lerobot compatible CLI behavior and programmatic usage
+ * Uses proven teleoperator classes with web-compatible API
+ */
+
+import { NodeSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+import { createSO100Config } from "./robots/so100_config.js";
+import { readAllMotorPositions } from "./utils/motor-communication.js";
+import {
+  KeyboardTeleoperator,
+  DirectTeleoperator,
+} from "./teleoperators/index.js";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import { existsSync } from "fs";
+import type {
+  TeleoperateConfig,
+  TeleoperationProcess,
+  MotorConfig,
+  TeleoperationState,
+} from "./types/teleoperation.js";
+import type { RobotConnection } from "./types/robot-connection.js";
+import type { CalibrationResults } from "./types/calibration.js";
+
+/**
+ * Get calibration file path (matches Python lerobot location)
+ */
+function getCalibrationFilePath(robotType: string, robotId: string): string {
+  const HF_HOME =
+    process.env.HF_HOME || join(homedir(), ".cache", "huggingface");
+  const calibrationDir = join(
+    HF_HOME,
+    "lerobot",
+    "calibration",
+    "robots",
+    robotType
+  );
+  return join(calibrationDir, `${robotId}.json`);
+}
+
+/**
+ * Load calibration data from file system
+ */
+async function loadCalibrationData(
+  robotType: string,
+  robotId: string
+): Promise<CalibrationResults | null> {
+  const calibrationPath = getCalibrationFilePath(robotType, robotId);
+
+  if (!existsSync(calibrationPath)) {
+    return null;
+  }
+
+  try {
+    const calibrationJson = await readFile(calibrationPath, "utf-8");
+    return JSON.parse(calibrationJson) as CalibrationResults;
+  } catch (error) {
+    console.warn(
+      `Failed to load calibration data from ${calibrationPath}:`,
+      error
+    );
+    return null;
+  }
+}
+
+/**
+ * Build motor configurations from robot config and calibration data
+ */
+function buildMotorConfigs(
+  robotConfig: any,
+  calibrationData?: CalibrationResults | null
+): MotorConfig[] {
+  const motorConfigs: MotorConfig[] = [];
+
+  for (let i = 0; i < robotConfig.motorNames.length; i++) {
+    const motorName = robotConfig.motorNames[i];
+    const motorId = robotConfig.motorIds[i];
+
+    let minPosition = 0;
+    let maxPosition = robotConfig.protocol.resolution - 1; // Default full range
+
+    // Use calibration data if available
+    if (calibrationData && calibrationData[motorName]) {
+      minPosition = calibrationData[motorName].range_min;
+      maxPosition = calibrationData[motorName].range_max;
+    }
+
+    motorConfigs.push({
+      id: motorId,
+      name: motorName,
+      currentPosition: Math.floor((minPosition + maxPosition) / 2), // Start at center
+      minPosition,
+      maxPosition,
+    });
+  }
+
+  return motorConfigs;
+}
+
+/**
+ * Main teleoperate function with web-compatible API
+ */
+export async function teleoperate(
+  config: TeleoperateConfig
+): Promise<TeleoperationProcess> {
+  const { robot, teleop, calibrationData, onStateUpdate } = config;
+
+  // Validate robot configuration
+  if (!robot.robotType) {
+    throw new Error(
+      "Robot type is required for teleoperation. Please configure the robot first."
+    );
+  }
+
+  if (!robot.isConnected || !robot.port) {
+    throw new Error(
+      "Robot is not connected. Please use findPort() to connect first."
+    );
+  }
+
+  // Use the EXISTING port connection (don't create new one!)
+  const port = robot.port;
+
+  // Get robot-specific configuration
+  let robotConfig;
+  if (robot.robotType.startsWith("so100")) {
+    robotConfig = createSO100Config(robot.robotType);
+  } else {
+    throw new Error(`Unsupported robot type: ${robot.robotType}`);
+  }
+
+  // Load or use provided calibration data
+  let effectiveCalibrationData = calibrationData;
+  if (!effectiveCalibrationData && robot.robotId) {
+    effectiveCalibrationData = await loadCalibrationData(
+      robot.robotType,
+      robot.robotId
+    );
+  }
+
+  if (!effectiveCalibrationData) {
+    console.warn(
+      "No calibration data found. Using default motor ranges. Consider running calibration first."
+    );
+  }
+
+  // Build motor configurations
+  const motorConfigs = buildMotorConfigs(robotConfig, effectiveCalibrationData);
+
+  // Read current motor positions
+  try {
+    const currentPositions = await readAllMotorPositions(
+      port,
+      robotConfig.motorIds
+    );
+    for (let i = 0; i < motorConfigs.length; i++) {
+      motorConfigs[i].currentPosition = currentPositions[i];
+    }
+  } catch (error) {
+    console.warn("Failed to read initial motor positions:", error);
+  }
+
+  // Create appropriate teleoperator based on configuration
+  let teleoperator;
+  switch (teleop.type) {
+    case "keyboard":
+      teleoperator = new KeyboardTeleoperator(
+        teleop,
+        port,
+        motorConfigs,
+        robotConfig.keyboardControls,
+        onStateUpdate
+      );
+      break;
+
+    case "direct":
+      teleoperator = new DirectTeleoperator(teleop, port, motorConfigs);
+      break;
+
+    default:
+      throw new Error(`Unsupported teleoperator type: ${(teleop as any).type}`);
+  }
+
+  // Initialize teleoperator
+  await teleoperator.initialize();
+
+  // Build process object
+  const process: TeleoperationProcess = {
+    start(): void {
+      teleoperator.start();
+    },
+
+    stop(): void {
+      teleoperator.stop();
+    },
+
+    updateKeyState(key: string, pressed: boolean): void {
+      if ("updateKeyState" in teleoperator) {
+        (teleoperator as any).updateKeyState(key, pressed);
+      }
+    },
+
+    getState(): TeleoperationState {
+      const teleoperatorSpecificState = teleoperator.getState();
+      return {
+        isActive: teleoperator.isActiveTeleoperator,
+        motorConfigs: [...teleoperator.motorConfigs],
+        lastUpdate: Date.now(),
+        ...teleoperatorSpecificState,
+      };
+    },
+
+    teleoperator: teleoperator,
+
+    async disconnect(): Promise<void> {
+      await teleoperator.disconnect();
+    },
+  };
+
+  return process;
+}

packages/node/src/teleoperators/base-teleoperator.ts

@@ -0,0 +1,62 @@
+/**
+ * Base teleoperator interface and abstract class for Node.js platform
+ * Defines the contract that all teleoperators must implement
+ */
+
+import type { MotorConfig } from "../types/teleoperation.js";
+import type { MotorCommunicationPort } from "../utils/motor-communication.js";
+
+/**
+ * Base interface that all Node.js teleoperators must implement
+ */
+export interface NodeTeleoperator {
+  initialize(): Promise<void>;
+  start(): void;
+  stop(): void;
+  disconnect(): Promise<void>;
+  getState(): TeleoperatorSpecificState;
+  onMotorConfigsUpdate(motorConfigs: MotorConfig[]): void;
+  motorConfigs: MotorConfig[];
+}
+
+/**
+ * Teleoperator-specific state (union type for different teleoperator types)
+ */
+export type TeleoperatorSpecificState = {
+  keyStates?: { [key: string]: { pressed: boolean; timestamp: number } }; // keyboard
+  leaderPositions?: { [motor: string]: number }; // leader arm
+};
+
+/**
+ * Base abstract class with common functionality for all teleoperators
+ */
+export abstract class BaseNodeTeleoperator implements NodeTeleoperator {
+  protected port: MotorCommunicationPort;
+  public motorConfigs: MotorConfig[] = [];
+  protected isActive: boolean = false;
+
+  constructor(port: MotorCommunicationPort, motorConfigs: MotorConfig[]) {
+    this.port = port;
+    this.motorConfigs = motorConfigs;
+  }
+
+  abstract initialize(): Promise<void>;
+  abstract start(): void;
+  abstract stop(): void;
+  abstract getState(): TeleoperatorSpecificState;
+
+  async disconnect(): Promise<void> {
+    this.stop();
+    if (this.port && "close" in this.port) {
+      await (this.port as any).close();
+    }
+  }
+
+  onMotorConfigsUpdate(motorConfigs: MotorConfig[]): void {
+    this.motorConfigs = motorConfigs;
+  }
+
+  get isActiveTeleoperator(): boolean {
+    return this.isActive;
+  }
+} 

packages/node/src/teleoperators/direct-teleoperator.ts

@@ -0,0 +1,112 @@
+/**
+ * Direct teleoperator for Node.js platform
+ * Provides programmatic control without user interface
+ */
+
+import {
+  BaseNodeTeleoperator,
+  type TeleoperatorSpecificState,
+} from "./base-teleoperator.js";
+import type {
+  DirectTeleoperatorConfig,
+  MotorConfig,
+} from "../types/teleoperation.js";
+import type { MotorCommunicationPort } from "../utils/motor-communication.js";
+import {
+  readMotorPosition,
+  writeMotorPosition,
+} from "../utils/motor-communication.js";
+
+/**
+ * Direct teleoperator provides programmatic motor control
+ * Use this when you want to control motors directly from code
+ */
+export class DirectTeleoperator extends BaseNodeTeleoperator {
+  constructor(
+    config: DirectTeleoperatorConfig,
+    port: MotorCommunicationPort,
+    motorConfigs: MotorConfig[]
+  ) {
+    super(port, motorConfigs);
+  }
+
+  async initialize(): Promise<void> {
+    // Read current motor positions
+    for (const config of this.motorConfigs) {
+      const position = await readMotorPosition(this.port, config.id);
+      if (position !== null) {
+        config.currentPosition = position;
+      }
+    }
+  }
+
+  start(): void {
+    this.isActive = true;
+  }
+
+  stop(): void {
+    this.isActive = false;
+  }
+
+  getState(): TeleoperatorSpecificState {
+    return {};
+  }
+
+  /**
+   * Move motor to exact position (programmatic control)
+   */
+  async moveMotor(motorName: string, targetPosition: number): Promise<boolean> {
+    if (!this.isActive) return false;
+
+    const motorConfig = this.motorConfigs.find((m) => m.name === motorName);
+    if (!motorConfig) return false;
+
+    const clampedPosition = Math.max(
+      motorConfig.minPosition,
+      Math.min(motorConfig.maxPosition, targetPosition)
+    );
+
+    try {
+      await writeMotorPosition(
+        this.port,
+        motorConfig.id,
+        Math.round(clampedPosition)
+      );
+      motorConfig.currentPosition = clampedPosition;
+      return true;
+    } catch (error) {
+      console.warn(`Failed to move motor ${motorName}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Move multiple motors simultaneously
+   */
+  async moveMotors(
+    positions: { [motorName: string]: number }
+  ): Promise<{ [motorName: string]: boolean }> {
+    const results: { [motorName: string]: boolean } = {};
+    
+    const promises = Object.entries(positions).map(
+      async ([motorName, position]) => {
+        const success = await this.moveMotor(motorName, position);
+        results[motorName] = success;
+      }
+    );
+
+    await Promise.all(promises);
+    return results;
+  }
+
+  /**
+   * Get current motor positions
+   */
+  getCurrentPositions(): { [motorName: string]: number } {
+    const positions: { [motorName: string]: number } = {};
+    for (const config of this.motorConfigs) {
+      positions[config.name] = config.currentPosition;
+    }
+    return positions;
+  }
+} 

packages/node/src/teleoperators/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Teleoperators barrel exports for Node.js
+ */
+
+export {
+  BaseNodeTeleoperator,
+  type NodeTeleoperator,
+  type TeleoperatorSpecificState,
+} from "./base-teleoperator.js";
+export {
+  KeyboardTeleoperator,
+  KEYBOARD_TELEOPERATOR_DEFAULTS,
+} from "./keyboard-teleoperator.js";
+export { DirectTeleoperator } from "./direct-teleoperator.js"; 

packages/node/src/teleoperators/keyboard-teleoperator.ts

@@ -0,0 +1,292 @@
+/**
+ * Keyboard teleoperator for Node.js platform using stdin
+ */
+
+import {
+  BaseNodeTeleoperator,
+  type TeleoperatorSpecificState,
+} from "./base-teleoperator.js";
+import type { KeyboardControl } from "../types/robot-config.js";
+import type {
+  KeyboardTeleoperatorConfig,
+  MotorConfig,
+  TeleoperationState,
+} from "../types/teleoperation.js";
+import type { MotorCommunicationPort } from "../utils/motor-communication.js";
+import {
+  readMotorPosition,
+  writeMotorPosition,
+} from "../utils/motor-communication.js";
+
+/**
+ * Default configuration values for keyboard teleoperator
+ */
+export const KEYBOARD_TELEOPERATOR_DEFAULTS = {
+  stepSize: 8, // Keep browser demo step size
+  updateRate: 120, // Higher frequency for smoother movement (120 Hz)
+  keyTimeout: 150, // Shorter for better single taps, accept some gap on hold
+} as const;
+
+export class KeyboardTeleoperator extends BaseNodeTeleoperator {
+  private keyboardControls: { [key: string]: KeyboardControl } = {};
+  private updateInterval: NodeJS.Timeout | null = null;
+  private keyStates: {
+    [key: string]: { pressed: boolean; timestamp: number };
+  } = {};
+  private onStateUpdate?: (state: TeleoperationState) => void;
+
+  // Configuration values
+  private readonly stepSize: number;
+  private readonly updateRate: number;
+  private readonly keyTimeout: number;
+
+  constructor(
+    config: KeyboardTeleoperatorConfig,
+    port: MotorCommunicationPort,
+    motorConfigs: MotorConfig[],
+    keyboardControls: { [key: string]: KeyboardControl },
+    onStateUpdate?: (state: TeleoperationState) => void
+  ) {
+    super(port, motorConfigs);
+    this.keyboardControls = keyboardControls;
+    this.onStateUpdate = onStateUpdate;
+
+    // Set configuration values
+    this.stepSize = config.stepSize ?? KEYBOARD_TELEOPERATOR_DEFAULTS.stepSize;
+    this.updateRate =
+      config.updateRate ?? KEYBOARD_TELEOPERATOR_DEFAULTS.updateRate;
+    this.keyTimeout =
+      config.keyTimeout ?? KEYBOARD_TELEOPERATOR_DEFAULTS.keyTimeout;
+  }
+
+  async initialize(): Promise<void> {
+    // Set up stdin for raw keyboard input
+    if (process.stdin.setRawMode) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+
+    // Set up keyboard input handler
+    process.stdin.on("data", this.handleKeyboardInput.bind(this));
+
+    // Read current motor positions
+    for (const config of this.motorConfigs) {
+      const position = await readMotorPosition(this.port, config.id);
+      if (position !== null) {
+        config.currentPosition = position;
+      }
+    }
+  }
+
+  start(): void {
+    if (this.isActive) return;
+
+    this.isActive = true;
+    this.updateInterval = setInterval(() => {
+      this.updateMotorPositions();
+    }, 1000 / this.updateRate);
+
+    // Display keyboard controls
+    this.displayControls();
+  }
+
+  stop(): void {
+    if (!this.isActive) return;
+
+    this.isActive = false;
+
+    if (this.updateInterval) {
+      clearInterval(this.updateInterval);
+      this.updateInterval = null;
+    }
+
+    // Clear all key states
+    this.keyStates = {};
+
+    // Notify of state change
+    if (this.onStateUpdate) {
+      this.onStateUpdate(this.buildTeleoperationState());
+    }
+  }
+
+  getState(): TeleoperatorSpecificState {
+    return {
+      keyStates: { ...this.keyStates },
+    };
+  }
+
+  updateKeyState(key: string, pressed: boolean): void {
+    this.keyStates[key] = {
+      pressed,
+      timestamp: Date.now(),
+    };
+  }
+
+  private handleKeyboardInput(key: string): void {
+    if (!this.isActive) return;
+
+    // Handle special keys
+    if (key === "\u0003") {
+      // Ctrl+C
+      process.exit(0);
+    }
+
+    if (key === "\u001b") {
+      // Escape
+      this.stop();
+      return;
+    }
+
+    // Handle regular keys - START IMMEDIATE CONTINUOUS MOVEMENT
+    const keyName = this.mapKeyToName(key);
+    if (keyName && this.keyboardControls[keyName]) {
+      // If key is already active, just refresh timestamp
+      if (this.keyStates[keyName]) {
+        this.keyStates[keyName].timestamp = Date.now();
+      } else {
+        // New key press - start continuous movement immediately
+        this.updateKeyState(keyName, true);
+
+        // Move immediately on first press (don't wait for interval)
+        this.moveMotorForKey(keyName);
+      }
+    }
+  }
+
+  private moveMotorForKey(keyName: string): void {
+    const control = this.keyboardControls[keyName];
+    if (!control || control.motor === "emergency_stop") return;
+
+    const motorConfig = this.motorConfigs.find((m) => m.name === control.motor);
+    if (!motorConfig) return;
+
+    // Calculate new position
+    const newPosition =
+      motorConfig.currentPosition + control.direction * this.stepSize;
+
+    // Apply limits
+    const clampedPosition = Math.max(
+      motorConfig.minPosition,
+      Math.min(motorConfig.maxPosition, newPosition)
+    );
+
+    // Send motor command immediately
+    writeMotorPosition(this.port, motorConfig.id, Math.round(clampedPosition))
+      .then(() => {
+        motorConfig.currentPosition = clampedPosition;
+      })
+      .catch((error) => {
+        console.warn(`Failed to move motor ${motorConfig.id}:`, error);
+      });
+  }
+
+  private updateMotorPositions(): void {
+    const now = Date.now();
+
+    // Clear timed-out keys
+    Object.keys(this.keyStates).forEach((key) => {
+      if (now - this.keyStates[key].timestamp > this.keyTimeout) {
+        delete this.keyStates[key];
+      }
+    });
+
+    // Process active keys
+    const activeKeys = Object.keys(this.keyStates).filter(
+      (key) =>
+        this.keyStates[key].pressed &&
+        now - this.keyStates[key].timestamp <= this.keyTimeout
+    );
+
+    // Emergency stop check
+    if (activeKeys.includes("Escape")) {
+      this.stop();
+      return;
+    }
+
+    // Calculate target positions based on active keys
+    const targetPositions: { [motorName: string]: number } = {};
+
+    for (const key of activeKeys) {
+      const control = this.keyboardControls[key];
+      if (!control || control.motor === "emergency_stop") continue;
+
+      const motorConfig = this.motorConfigs.find(
+        (m) => m.name === control.motor
+      );
+      if (!motorConfig) continue;
+
+      // Calculate new position
+      const currentTarget =
+        targetPositions[motorConfig.name] ?? motorConfig.currentPosition;
+      const newPosition = currentTarget + control.direction * this.stepSize;
+
+      // Apply limits
+      targetPositions[motorConfig.name] = Math.max(
+        motorConfig.minPosition,
+        Math.min(motorConfig.maxPosition, newPosition)
+      );
+    }
+
+    // Send motor commands and update positions
+    Object.entries(targetPositions).forEach(([motorName, targetPosition]) => {
+      const motorConfig = this.motorConfigs.find((m) => m.name === motorName);
+      if (motorConfig && targetPosition !== motorConfig.currentPosition) {
+        writeMotorPosition(
+          this.port,
+          motorConfig.id,
+          Math.round(targetPosition)
+        )
+          .then(() => {
+            motorConfig.currentPosition = targetPosition;
+          })
+          .catch((error) => {
+            console.warn(
+              `Failed to write motor ${motorConfig.id} position:`,
+              error
+            );
+          });
+      }
+    });
+  }
+
+  private mapKeyToName(key: string): string | null {
+    // Map stdin input to key names
+    const keyMap: { [key: string]: string } = {
+      "\u001b[A": "ArrowUp",
+      "\u001b[B": "ArrowDown",
+      "\u001b[C": "ArrowRight",
+      "\u001b[D": "ArrowLeft",
+      w: "w",
+      s: "s",
+      a: "a",
+      d: "d",
+      q: "q",
+      e: "e",
+      o: "o",
+      c: "c",
+    };
+
+    return keyMap[key] || null;
+  }
+
+  private displayControls(): void {
+    console.log("\n=== Robot Teleoperation Controls ===");
+    console.log("Arrow Keys: Shoulder pan/lift");
+    console.log("WASD: Elbow flex / Wrist flex");
+    console.log("Q/E: Wrist roll");
+    console.log("O/C: Gripper open/close");
+    console.log("ESC: Emergency stop");
+    console.log("Ctrl+C: Exit");
+    console.log("=====================================\n");
+  }
+
+  private buildTeleoperationState(): TeleoperationState {
+    return {
+      isActive: this.isActive,
+      motorConfigs: [...this.motorConfigs],
+      lastUpdate: Date.now(),
+      keyStates: { ...this.keyStates },
+    };
+  }
+}

packages/node/src/types/calibration.ts

@@ -0,0 +1,48 @@
+/**
+ * Calibration-related types for Node.js implementation
+ */
+
+import type { RobotConnection } from "./robot-connection.js";
+
+/**
+ * Live calibration data with current positions and ranges
+ */
+export interface LiveCalibrationData {
+  [motorName: string]: {
+    current: number;
+    min: number;
+    max: number;
+    range: number;
+  };
+}
+
+/**
+ * Config for calibrate function
+ */
+export interface CalibrateConfig {
+  robot: RobotConnection;
+  onLiveUpdate?: (data: LiveCalibrationData) => void;
+  onProgress?: (message: string) => void;
+  outputPath?: string; // Node.js specific: custom output path for calibration file
+}
+
+/**
+ * Calibration results structure - Python lerobot compatible format
+ */
+export interface CalibrationResults {
+  [motorName: string]: {
+    id: number;
+    drive_mode: number;
+    homing_offset: number;
+    range_min: number;
+    range_max: number;
+  };
+}
+
+/**
+ * Calibration process control object
+ */
+export interface CalibrationProcess {
+  stop(): void;
+  result: Promise<CalibrationResults>;
+}

packages/node/src/types/port-discovery.ts

@@ -0,0 +1,47 @@
+/**
+ * Port discovery types for Node.js implementation using serialport
+ */
+
+// Import types needed in this file
+import type {
+  RobotConnection,
+  RobotConfig,
+  SerialPort,
+  SerialPortInfo,
+} from "./robot-connection.js";
+
+/**
+ * Config for findPort function
+ */
+export interface FindPortConfig {
+  // Interactive mode: shows Python lerobot compatible prompts
+  interactive?: boolean;
+
+  // Auto-connect mode: provide robot configs to connect to
+  robotConfigs?: RobotConfig[];
+
+  // Callbacks
+  onMessage?: (message: string) => void;
+}
+
+/**
+ * Discovered port information (Node.js discovery-only mode)
+ */
+export interface DiscoveredPort {
+  path: string; // Serial port path (e.g., "/dev/ttyUSB0", "COM4")
+  robotType: "so100_follower" | "so100_leader";
+}
+
+/**
+ * Process object returned by findPort
+ */
+export interface FindPortProcess {
+  // Result promise - Node.js returns discovered ports, user calls connectPort() separately
+  result: Promise<DiscoveredPort[]>;
+
+  // Control
+  stop: () => void;
+}
+
+// Re-export commonly used types for convenience
+export type { RobotConnection, RobotConfig, SerialPort, SerialPortInfo };

packages/node/src/types/robot-config.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared robot hardware configuration types
+ * Used across calibration, teleoperation, and other robot operations
+ */
+
+/**
+ * Keyboard control mapping for teleoperation
+ */
+export interface KeyboardControl {
+  motor: string;
+  direction: number;
+  description: string;
+}
+
+/**
+ * Robot hardware configuration interface
+ * Defines the contract that all robot configurations must implement
+ */
+export interface RobotHardwareConfig {
+  deviceType: string;
+  motorNames: string[];
+  motorIds: number[];
+  driveModes: number[];
+
+  // Keyboard controls for teleoperation (robot-specific)
+  keyboardControls: { [key: string]: KeyboardControl };
+
+  protocol: {
+    resolution: number;
+    homingOffsetAddress: number;
+    homingOffsetLength: number;
+    presentPositionAddress: number;
+    presentPositionLength: number;
+    minPositionLimitAddress: number;
+    minPositionLimitLength: number;
+    maxPositionLimitAddress: number;
+    maxPositionLimitLength: number;
+    signMagnitudeBit: number;
+  };
+} 

packages/node/src/types/robot-connection.ts

@@ -0,0 +1,61 @@
+/**
+ * Core robot connection types used across the lerobot.js Node.js library
+ * These types are shared between findPort, calibrate, teleoperate, and other modules
+ */
+
+import type { RobotHardwareConfig } from "./robot-config.js";
+
+/**
+ * Type definitions for Node.js serialport API
+ */
+export interface SerialPort {
+  path: string;
+  write(buffer: Buffer): Promise<void>;
+  read(): Promise<Buffer | null>;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  isOpen: boolean;
+}
+
+export interface SerialPortInfo {
+  path: string;
+  manufacturer?: string;
+  serialNumber?: string;
+  pnpId?: string;
+  locationId?: string;
+  productId?: string;
+  vendorId?: string;
+}
+
+export interface SerialOptions {
+  baudRate: number;
+  dataBits?: number;
+  stopBits?: number;
+  parity?: "none" | "even" | "odd";
+}
+
+/**
+ * Unified robot connection interface used across all functions
+ * This same object works for findPort, calibrate, teleoperate, etc.
+ * Includes all fields needed by CLI and other applications
+ */
+export interface RobotConnection {
+  port: SerialPort;
+  name: string; // Display name for CLI
+  isConnected: boolean; // Connection status
+  robotType?: "so100_follower" | "so100_leader"; // Optional until user configures
+  robotId?: string; // Optional until user configures
+  serialNumber: string; // Always required for identification
+  error?: string; // Error message if connection failed
+  config?: RobotHardwareConfig; // Robot configuration (motorIds, controls, etc.) - set when robotType is configured
+  portInfo?: SerialPortInfo; // Node.js serial port information
+}
+
+/**
+ * Minimal robot config for finding/connecting to specific robots
+ */
+export interface RobotConfig {
+  robotType: "so100_follower" | "so100_leader";
+  robotId: string; 
+  serialNumber: string;
+} 

packages/node/src/types/teleoperation.ts

@@ -0,0 +1,95 @@
+/**
+ * Teleoperation-related types for Node.js implementation
+ */
+
+import type { RobotConnection } from "./robot-connection.js";
+import type { NodeTeleoperator } from "../teleoperators/index.js";
+
+/**
+ * Motor position and limits for teleoperation
+ */
+export interface MotorConfig {
+  id: number;
+  name: string;
+  currentPosition: number;
+  minPosition: number;
+  maxPosition: number;
+}
+
+/**
+ * Teleoperation state
+ */
+export interface TeleoperationState {
+  isActive: boolean;
+  motorConfigs: MotorConfig[];
+  lastUpdate: number;
+
+  // Teleoperator-specific state (optional fields for different types)
+  keyStates?: { [key: string]: { pressed: boolean; timestamp: number } }; // keyboard
+  leaderPositions?: { [motor: string]: number }; // leader arm
+}
+
+/**
+ * Teleoperation process control object
+ */
+export interface TeleoperationProcess {
+  start(): void;
+  stop(): void;
+  updateKeyState(key: string, pressed: boolean): void;
+  getState(): TeleoperationState;
+  teleoperator: NodeTeleoperator;
+  disconnect(): Promise<void>;
+}
+
+/**
+ * Base interface for all teleoperator configurations
+ */
+export interface BaseTeleoperatorConfig {
+  type: string;
+}
+
+/**
+ * Keyboard teleoperator configuration
+ */
+export interface KeyboardTeleoperatorConfig extends BaseTeleoperatorConfig {
+  type: "keyboard";
+  stepSize?: number; // Default: KEYBOARD_TELEOPERATOR_DEFAULTS.stepSize
+  updateRate?: number; // Default: KEYBOARD_TELEOPERATOR_DEFAULTS.updateRate
+  keyTimeout?: number; // Default: KEYBOARD_TELEOPERATOR_DEFAULTS.keyTimeout
+}
+
+/**
+ * Leader arm teleoperator configuration (future)
+ */
+export interface LeaderArmTeleoperatorConfig extends BaseTeleoperatorConfig {
+  type: "so100_leader";
+  port: string;
+  calibrationData?: any;
+  positionSmoothing?: boolean;
+  scaleFactor?: number;
+}
+
+/**
+ * Direct teleoperator configuration
+ */
+export interface DirectTeleoperatorConfig extends BaseTeleoperatorConfig {
+  type: "direct";
+}
+
+/**
+ * Union type for all teleoperator configurations
+ */
+export type TeleoperatorConfig =
+  | KeyboardTeleoperatorConfig
+  | LeaderArmTeleoperatorConfig
+  | DirectTeleoperatorConfig;
+
+/**
+ * Main teleoperation configuration
+ */
+export interface TeleoperateConfig {
+  robot: RobotConnection;
+  teleop: TeleoperatorConfig;
+  calibrationData?: { [motorName: string]: any };
+  onStateUpdate?: (state: TeleoperationState) => void;
+} 

{src/lerobot/node → packages/node/src}/utils/constants.ts

@@ -1,15 +1,11 @@
 /**
- * Constants for lerobot.js
- * Mirrors Python lerobot/common/constants.py
+ * Constants for @lerobot/node
+ * Mirrors Python lerobot/common/constants.py for directory structure compatibility
  */
 
 import { homedir } from "os";
 import { join } from "path";
 
-// Device types
-export const ROBOTS = "robots";
-export const TELEOPERATORS = "teleoperators";
-
 /**
  * Get HF Home directory
  * Equivalent to Python's huggingface_hub.constants.HF_HOME

packages/node/src/utils/motor-calibration.ts

@@ -0,0 +1,188 @@
+/**
+ * Motor Calibration Utilities
+ * Specialized functions for motor calibration procedures
+ */
+
+import { STS3215_PROTOCOL } from "./sts3215-protocol.js";
+import { encodeSignMagnitude } from "./sign-magnitude.js";
+import {
+  readAllMotorPositions,
+  writeMotorRegister,
+  type MotorCommunicationPort,
+} from "./motor-communication.js";
+
+/**
+ * Reset homing offsets to 0 for all motors
+ */
+export async function resetHomingOffsets(
+  port: MotorCommunicationPort,
+  motorIds: number[]
+): Promise<void> {
+  for (let i = 0; i < motorIds.length; i++) {
+    const motorId = motorIds[i];
+
+    try {
+      const packet = new Uint8Array([
+        0xff,
+        0xff,
+        motorId,
+        0x05,
+        0x03,
+        STS3215_PROTOCOL.HOMING_OFFSET_ADDRESS,
+        0x00, // Low byte of 0
+        0x00, // High byte of 0
+        0x00, // Checksum
+      ]);
+
+      const checksum =
+        ~(
+          motorId +
+          0x05 +
+          0x03 +
+          STS3215_PROTOCOL.HOMING_OFFSET_ADDRESS +
+          0x00 +
+          0x00
+        ) & 0xff;
+      packet[8] = checksum;
+
+      await port.write(packet);
+
+      try {
+        await port.read(200);
+      } catch (error) {
+        // Silent - response not required
+      }
+    } catch (error) {
+      throw new Error(`Failed to reset homing offset for motor ${motorId}`);
+    }
+  }
+}
+
+/**
+ * Write homing offsets to motor registers immediately
+ */
+export async function writeHomingOffsetsToMotors(
+  port: MotorCommunicationPort,
+  motorIds: number[],
+  motorNames: string[],
+  homingOffsets: { [motor: string]: number }
+): Promise<void> {
+  for (let i = 0; i < motorIds.length; i++) {
+    const motorId = motorIds[i];
+    const motorName = motorNames[i];
+    const homingOffset = homingOffsets[motorName];
+
+    try {
+      const encodedOffset = encodeSignMagnitude(
+        homingOffset,
+        STS3215_PROTOCOL.SIGN_MAGNITUDE_BIT
+      );
+
+      const packet = new Uint8Array([
+        0xff,
+        0xff,
+        motorId,
+        0x05,
+        0x03,
+        STS3215_PROTOCOL.HOMING_OFFSET_ADDRESS,
+        encodedOffset & 0xff,
+        (encodedOffset >> 8) & 0xff,
+        0x00,
+      ]);
+
+      const checksum =
+        ~(
+          motorId +
+          0x05 +
+          0x03 +
+          STS3215_PROTOCOL.HOMING_OFFSET_ADDRESS +
+          (encodedOffset & 0xff) +
+          ((encodedOffset >> 8) & 0xff)
+        ) & 0xff;
+      packet[8] = checksum;
+
+      await port.write(packet);
+
+      try {
+        await port.read(200);
+      } catch (error) {
+        // Silent - response not required
+      }
+    } catch (error) {
+      throw new Error(`Failed to write homing offset for ${motorName}`);
+    }
+  }
+}
+
+/**
+ * Set homing offsets with immediate writing
+ */
+export async function setHomingOffsets(
+  port: MotorCommunicationPort,
+  motorIds: number[],
+  motorNames: string[]
+): Promise<{ [motor: string]: number }> {
+  // Reset existing homing offsets to 0 first
+  await resetHomingOffsets(port, motorIds);
+  await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second instead of 100ms
+
+  // Flush any cached position readings first
+  await readAllMotorPositions(port, motorIds); // Dummy read to flush cache
+  await new Promise((resolve) => setTimeout(resolve, 200)); // Small additional wait
+
+  // Read positions (which should now be true physical positions)
+  const currentPositions = await readAllMotorPositions(port, motorIds);
+
+  const homingOffsets: { [motor: string]: number } = {};
+  const halfTurn = Math.floor((STS3215_PROTOCOL.RESOLUTION - 1) / 2);
+
+  for (let i = 0; i < motorNames.length; i++) {
+    const motorName = motorNames[i];
+    const position = currentPositions[i];
+    const calculatedOffset = position - halfTurn;
+    homingOffsets[motorName] = calculatedOffset;
+  }
+
+  // Write homing offsets to motors immediately
+  await writeHomingOffsetsToMotors(port, motorIds, motorNames, homingOffsets);
+
+  return homingOffsets;
+}
+
+/**
+ * Write hardware position limits to motors
+ */
+export async function writeHardwarePositionLimits(
+  port: MotorCommunicationPort,
+  motorIds: number[],
+  motorNames: string[],
+  rangeMins: { [motor: string]: number },
+  rangeMaxes: { [motor: string]: number }
+): Promise<void> {
+  for (let i = 0; i < motorIds.length; i++) {
+    const motorId = motorIds[i];
+    const motorName = motorNames[i];
+    const minLimit = rangeMins[motorName];
+    const maxLimit = rangeMaxes[motorName];
+
+    try {
+      // Write Min_Position_Limit register
+      await writeMotorRegister(
+        port,
+        motorId,
+        STS3215_PROTOCOL.MIN_POSITION_LIMIT_ADDRESS,
+        minLimit
+      );
+
+      // Write Max_Position_Limit register
+      await writeMotorRegister(
+        port,
+        motorId,
+        STS3215_PROTOCOL.MAX_POSITION_LIMIT_ADDRESS,
+        maxLimit
+      );
+    } catch (error) {
+      throw new Error(`Failed to write position limits for ${motorName}`);
+    }
+  }
+}