feat: move "src/lerobot/web" to "packages/web/src"

.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/[email protected]/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

.github/CONTRIBUTING.md

@@ -0,0 +1,225 @@
+# Contributing to lerobot.js
+
+Thanks for your interest in contributing! This guide will help you get started.
+
+## 🚀 Quick Start
+
+```bash
+# Clone and setup
+git clone https://github.com/timpietrusky/lerobot.js.git
+cd lerobot.js
+pnpm install
+
+# Run demo
+pnpm dev
+
+# Build packages
+pnpm --filter "@lerobot/web" run build
+```
+
+## 📦 Package Structure
+
+- **`packages/web/`** - Browser package (`@lerobot/web` on npm)
+- **`src/demo/`** - Demo application (deployed to HF Spaces)
+- **`src/cli/`** - Node.js CLI tool
+- **`src/lerobot/node/`** - Node.js library
+
+## 🔄 Making Changes
+
+### 1. Development Workflow
+
+```bash
+# Make your changes to packages/web/ or other code
+# Test your changes
+pnpm dev  # for demo
+pnpm --filter "@lerobot/web" run build  # for package
+
+# Run any relevant tests
+```
+
+### 2. Creating a Changeset
+
+**For any changes to `packages/web/`:**
+
+```bash
+# Describe your changes
+pnpm changeset
+```
+
+- **Select package**: `@lerobot/web`
+- **Version type**:
+  - `patch` (0.1.1 → 0.1.2) - Bug fixes
+  - `minor` (0.1.1 → 0.2.0) - New features
+  - `major` (0.1.1 → 1.0.0) - Breaking changes
+- **Summary**: Clear description for changelog
+
+### 3. Submit Pull Request
+
+```bash
+git add .
+git commit -m "feat: your change description"
+git push origin your-branch
+```
+
+Create a PR with:
+
+- Clear description of changes
+- Reference any related issues
+- Include changeset if modifying `@lerobot/web`
+
+## 🚀 Release Process
+
+### Automated Releases (Recommended)
+
+1. **Changeset added** → PR merged to `main`
+2. **GitHub Actions** creates Release PR automatically
+3. **Maintainer merges** Release PR
+4. **Package published** to npm with GitHub release
+
+### Manual Testing
+
+```bash
+# Preview version changes (safe)
+pnpm changeset:version
+
+# Publish manually (only for emergencies)
+pnpm changeset:publish
+```
+
+## 📋 Code Standards
+
+### TypeScript
+
+- Use strict TypeScript settings
+- Export types explicitly
+- Document public APIs with JSDoc
+
+### Code Style
+
+- Follow existing patterns
+- Use meaningful variable names
+- Add comments for complex logic
+- **NO explanation comments** in code (see `docs/conventions.md`)
+
+### Commit Messages
+
+- `feat:` - New features
+- `fix:` - Bug fixes
+- `docs:` - Documentation
+- `chore:` - Maintenance
+- `refactor:` - Code restructuring
+
+## 🧪 Testing
+
+### Manual Testing
+
+```bash
+# Test demo locally
+pnpm dev
+
+# Test CLI
+pnpm cli:find-port
+pnpm cli:calibrate
+
+# Test package build
+pnpm --filter "@lerobot/web" run build
+```
+
+### Hardware Testing
+
+- Use SO-100 leader/follower arms when available
+- Test calibration, teleoperation, port discovery
+- Verify WebSerial API compatibility
+
+## 📝 Documentation
+
+### Update Documentation For:
+
+- New functions in `@lerobot/web`
+- CLI command changes
+- Hardware support additions
+- Breaking changes
+
+### Files to Update:
+
+- `packages/web/README.md` - Package documentation
+- `README.md` - Main project overview
+- JSDoc comments for new APIs
+
+## 🐛 Bug Reports
+
+Include:
+
+- Steps to reproduce
+- Expected vs actual behavior
+- Browser/Node.js version
+- Hardware setup (if relevant)
+- Error messages/console output
+
+## 💡 Feature Requests
+
+- Explain the use case
+- Provide examples if possible
+- Consider backward compatibility
+- Discuss implementation approach
+
+## 🎯 Areas for Contribution
+
+### High Priority
+
+- New robot hardware support
+- Browser compatibility improvements
+- Performance optimizations
+- Documentation improvements
+
+### Medium Priority
+
+- Additional calibration methods
+- UI/UX enhancements
+- CLI tool features
+- Testing infrastructure
+
+### Advanced
+
+- WebRTC integration
+- Computer vision features
+- Machine learning integration
+- Protocol implementations
+
+## 🔧 Development Tips
+
+### Common Commands
+
+```bash
+# Install dependencies
+pnpm install
+
+# Start demo development
+pnpm dev
+
+# Build everything
+pnpm build
+
+# Create changeset
+pnpm changeset
+
+# Work with specific package
+pnpm --filter "@lerobot/web" run build
+```
+
+### Debugging
+
+- Use browser DevTools for WebSerial issues
+- Check console for hardware communication errors
+- Use `console.log` for motor position debugging
+- Test with different hardware configurations
+
+## 📞 Getting Help
+
+- **Issues**: Use GitHub issues for bugs/features
+- **Discussions**: Use GitHub discussions for questions
+- **Hardware**: Check hardware documentation in `docs/`
+
+## 🙏 Recognition
+
+All contributors will be recognized in releases and project documentation. Thank you for helping make robotics more accessible! 🤖✨

.github/workflows/hf-space.yml

@@ -13,6 +13,30 @@ jobs:
           fetch-depth: 0
           lfs: true
 
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: latest
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build web package
+        run: pnpm --filter "@lerobot/web" run build
+
+      - name: Install web package for demo
+        run: |
+          cd packages/web
+          npm pack
+          cd ../..
+          pnpm add ./packages/web/lerobot-web-*.tgz
+
       - name: Prepare README for HF Space
         run: |
           # Create HF Space frontmatter by directly copying from hf_config.yml

.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: latest
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: "pnpm"
+
+      - name: Install Dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build packages
+        run: pnpm --filter "@lerobot/web" run build
+
+      - name: Create Release Pull Request or Publish to npm
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          # This expects you to have a script called release which does a build for your packages and calls changeset publish
+          publish: pnpm changeset:publish
+          version: pnpm changeset:version
+          commit: "chore: version packages"
+          title: "chore: version packages"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

CHANGESET_GUIDE.md

@@ -0,0 +1,87 @@
+# 🚀 Changesets Workflow Guide
+
+## Setup (One Time Only)
+
+### 1. Add NPM Token to GitHub
+
+1. Go to [npmjs.com](https://npmjs.com) → Account → Access Tokens
+2. Create **Automation** token with **Publish** permission
+3. Copy the token
+4. Go to GitHub → Settings → Secrets → Actions
+5. Add secret: `NPM_TOKEN` = your token
+
+### 2. Verify Access
+
+Make sure you have publish access to `@lerobot/web` on npm.
+
+## Daily Workflow
+
+### 1. Make Changes
+
+```bash
+# Edit code in packages/web/
+# Test your changes
+pnpm --filter "@lerobot/web" run build
+```
+
+### 2. Create Changeset
+
+```bash
+pnpm changeset
+```
+
+- Select package: `@lerobot/web`
+- Choose version bump: `patch` | `minor` | `major`
+- Write summary: "Add new feature X" or "Fix bug Y"
+
+### 3. Commit & Push
+
+```bash
+git add .
+git commit -m "feat: add new functionality"
+git push origin main
+```
+
+### 4. Magic Happens! ✨
+
+- GitHub Actions creates **Release PR** with changelog
+- **Merge the PR** → Automatic publish to npm
+- **New version is live!**
+
+## Commands Available
+
+```bash
+# Create a changeset (describe your changes)
+pnpm changeset
+
+# Preview what will be released
+pnpm changeset:version
+
+# Manual publish (emergency only)
+pnpm changeset:publish
+```
+
+## Version Types
+
+- **patch** (0.1.0 → 0.1.1) - Bug fixes
+- **minor** (0.1.0 → 0.2.0) - New features
+- **major** (0.1.0 → 1.0.0) - Breaking changes
+
+## Example Flow
+
+```bash
+# 1. Edit packages/web/src/calibrate.ts
+# 2. Create changeset
+pnpm changeset
+# → Select @lerobot/web
+# → Choose "minor"
+# → Summary: "Add new calibration mode"
+
+# 3. Commit
+git add .
+git commit -m "feat: add new calibration mode"
+git push
+
+# 4. GitHub will create Release PR automatically
+# 5. Merge PR → @lerobot/[email protected] published! 🎉
+```

README.md

@@ -1,335 +1,63 @@
 # 🤖 lerobot.js
 
-**State-of-the-art AI for real-world robotics in JavaScript/TypeScript**
+JavaScript/TypeScript robotics library for Node.js and browsers. Control hardware directly without Python dependencies.
 
-A faithful TypeScript/JavaScript port of [Hugging Face's lerobot](https://github.com/huggingface/lerobot), bringing cutting-edge robotics AI to the JavaScript ecosystem with **zero Python dependencies**.
-
-## 🚀 **[Complete SO-100 Setup Guide →](docs/getting_started_nodejs.md)**
-
-**Get your SO-100 robot arms working in 10 minutes with lerobot.js!**  
-Step-by-step guide covering port detection, motor setup, calibration, and teleoperation.
-
-## ✨ Features
-
-- 🔌 **USB Port Detection**: Find robot arm serial ports in Node.js CLI and browser
-- 🎛️ **Robot Calibration**: Complete SO-100 follower/leader calibration system
-- 🌐 **Universal**: Works in Node.js, browsers, and Edge devices
-- 🎯 **Python Faithful**: Identical UX and messaging to original lerobot
-- 📱 **WebSerial**: Browser-native serial port access (Chrome/Edge 89+)
-- 🚀 **Zero Dependencies**: No Python runtime required
-- 📦 **Lightweight**: Pure TypeScript implementation
-
-## 🚀 Quick Start
-
-### Installation & Setup
+## Install
 
 ```bash
-# Option 1: Install globally (recommended)
+# CLI tools
 npm install -g lerobot
 
-# Option 2: Use directly with npx (no installation)
-npx lerobot --help
-
-# Verify installation
-lerobot --help
+# Web library
+npm install @lerobot/web
 ```
 
-### Essential Commands
+## CLI Usage
 
 ```bash
-# 1. Find USB ports for your robot arms
+# Find hardware
 lerobot find-port
 
-# 2. Calibrate follower robot
-lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_follower_arm
-
-# 3. Calibrate leader teleoperator
-lerobot calibrate --teleop.type=so100_leader --teleop.port=COM3 --teleop.id=my_leader_arm
-
-# Show command help
-lerobot calibrate --help
-```
-
-### Alternative Usage Methods
-
-```bash
-# Method 1: Global CLI (after installation)
+# Calibrate device
 lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_robot
 
-# Method 2: Direct with npx (no installation needed)
-npx lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_robot
-
-# Method 3: Development setup (if you cloned the repo)
-git clone https://github.com/timpietrusky/lerobot.js
-cd lerobot.js && pnpm install && pnpm run install-global
-```
-
-### Browser Usage
-
-1. **Development**:
-
-   ```bash
-   git clone https://github.com/timpietrusky/lerobot.js
-   cd lerobot.js
-   pnpm install
-   pnpm run dev
-   ```
-
-2. **Visit**: `http://localhost:5173`
-
-3. **Use the interface**:
-   - Click "Show Available Ports" to see connected devices
-   - Click "Find MotorsBus Port" for guided port detection
-
-## 📖 Documentation
-
-### Find USB Ports
-
-Identify which USB ports your robot arms are connected to - essential for SO-100 setup.
-
-#### CLI Example
-
-```bash
-$ lerobot find-port
-
-Finding all available ports for the MotorsBus.
-Ports before disconnecting: ['COM3', 'COM4']
-Remove the USB cable from your MotorsBus and press Enter when done.
-
-The port of this MotorsBus is 'COM3'
-Reconnect the USB cable.
-```
-
-### Robot Calibration
-
-Calibrate SO-100 robot arms for precise control and teleoperation.
-
-#### Calibrate Follower Robot
-
-```bash
-$ lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_follower_arm
-
-Calibrating device...
-Device type: so100_follower
-Port: COM4
-ID: my_follower_arm
-
-Connecting to so100_follower on port COM4...
-Connected successfully.
-Starting calibration procedure...
-[... calibration steps ...]
-Calibration completed successfully.
-Configuration saved to: ~/.cache/huggingface/lerobot/calibration/robots/so100_follower/my_follower_arm.json
-Disconnecting from robot...
-```
-
-#### Calibrate Leader Teleoperator
-
-```bash
-$ lerobot calibrate --teleop.type=so100_leader --teleop.port=COM3 --teleop.id=my_leader_arm
-
-Calibrating teleoperator...
-[... guided calibration process ...]
-Configuration saved to: ~/.cache/huggingface/lerobot/calibration/teleoperators/so100_leader/my_leader_arm.json
-```
-
-### Browser Interface
-
-1. **Visit**: Built-in web interface with calibration controls
-2. **Port Selection**: Browser dialog for device selection
-3. **Interactive Calibration**: Step-by-step guided process
-4. **File Download**: Automatic calibration file download
-
-### Platform Support
-
-| Platform    | Method                           | Requirements                        |
-| ----------- | -------------------------------- | ----------------------------------- |
-| **Node.js** | `lerobot find-port`, `calibrate` | Node.js 18+, Windows/macOS/Linux    |
-| **Browser** | Web interface + calibration      | Chrome/Edge 89+, HTTPS or localhost |
-| **Mobile**  | Browser                          | Chrome Android 105+                 |
-
-### Browser Compatibility
-
-The browser version uses the [WebSerial API](https://web.dev/serial/):
-
-- ✅ **Chrome/Edge 89+** (Desktop)
-- ✅ **Chrome Android 105+** (Mobile)
-- ✅ **HTTPS** or localhost required
-- ❌ Firefox/Safari (WebSerial not supported)
-
-## 🛠️ Development
-
-### Setup
-
-```bash
-git clone https://github.com/timpietrusky/lerobot.js
-cd lerobot.js
-pnpm install
-```
-
-### Scripts
-
-```bash
-# Development server (browser)
-pnpm run dev
-
-# Build CLI for Node.js
-pnpm run build:cli
-
-# Build web interface
-pnpm run build:web
-
-# Test CLI locally
-pnpm run cli:find-port
-
-# Build everything
-pnpm run build
-```
-
-### Project Structure
-
-```
-src/
-├── lerobot/
-│   ├── node/
-│   │   └── find_port.ts     # Node.js implementation
-│   └── web/
-│       └── find_port.ts     # Browser implementation (WebSerial)
-├── cli/
-│   └── index.ts             # CLI interface
-├── main.ts                  # Web interface
-└── web_interface.css        # UI styles
+# Show help
+lerobot --help
 ```
 
-## 🎯 Design Principles
-
-### 1. Python lerobot Faithfulness
-
-- **Identical commands**: `npx lerobot find-port` ↔ `python -m lerobot.find_port`
-- **Same terminology**: "MotorsBus", not "robot arms"
-- **Matching output**: Error messages and workflows identical
-- **Familiar UX**: Python lerobot users feel immediately at home
-
-### 2. Platform Abstraction
-
-- **Universal core**: Shared robotics logic
-- **Adaptive UX**: CLI prompts vs. browser modals
-- **Progressive enhancement**: Works everywhere, enhanced on capable platforms
-
-### 3. Zero Dependencies
-
-- **Node.js**: Only uses built-in modules + lightweight `serialport`
-- **Browser**: Native WebSerial API, no external libraries
-- **Deployment**: Single package, no Python runtime needed
-
-## 🔧 Technical Details
-
-### WebSerial API
-
-The browser implementation leverages modern web APIs:
+## Web Usage
 
 ```typescript
-// Request permission to access serial ports
-await navigator.serial.requestPort();
-
-// List granted ports
-const ports = await navigator.serial.getPorts();
-
-// Detect disconnected devices
-const removedPorts = portsBefore.filter(/* ... */);
-```
+import { findPort, calibrate, teleoperate } from "@lerobot/web";
 
-### CLI Implementation
+// Find and connect to hardware
+const devices = await findPort();
+const robot = devices[0];
 
-Node.js version uses the `serialport` library for cross-platform compatibility:
+// Calibrate
+const calibration = await calibrate(robot);
+await calibration.result;
 
-```typescript
-import { SerialPort } from "serialport";
-
-// Cross-platform port detection
-const ports = await SerialPort.list();
+// Control
+const controller = await teleoperate(robot);
+controller.start();
 ```
 
-## 🗺️ Roadmap
-
-- [x] **Phase 1**: USB port detection (CLI + Browser)
-- [ ] **Phase 2**: Motor communication and setup
-- [x] **Phase 3**: Robot calibration tools ✅ **COMPLETE!**
-- [ ] **Phase 4**: Dataset management and visualization
-- [ ] **Phase 5**: Policy inference (ONNX.js)
-- [ ] **Phase 6**: Training infrastructure
-
-### ✅ Recently Completed
+## Hardware Support
 
-**Phase 3 - Robot Calibration (December 2024)**
+- **SO-100**: Follower/leader robot arms
+- **WebSerial API**: Chrome/Edge 89+, HTTPS required
+- **Node.js**: Cross-platform serial port access
 
-- Complete SO-100 follower/leader calibration system
-- CLI commands identical to Python lerobot
-- Web browser calibration interface
-- HF-compatible configuration storage
-- Comprehensive error handling and validation
-
-## 📋 CLI Command Reference
-
-### Available Commands
+## Demo
 
 ```bash
-# Show all commands
-lerobot --help
-
-# Find USB ports
-lerobot find-port
-
-# Calibrate robot
-lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=ROBOT_ID
-
-# Calibrate teleoperator
-lerobot calibrate --teleop.type=so100_leader --teleop.port=COM3 --teleop.id=TELEOP_ID
-
-# Show calibration help
-lerobot calibrate --help
-```
-
-### Configuration Files
-
-Calibration data follows Hugging Face directory structure:
-
-```
-~/.cache/huggingface/lerobot/calibration/
-├── robots/
-│   └── so100_follower/
-│       └── ROBOT_ID.json
-└── teleoperators/
-    └── so100_leader/
-        └── TELEOP_ID.json
+git clone https://github.com/timpietrusky/lerobot.js
+cd lerobot.js && npm install && npm run dev
 ```
 
-**Environment Variables:**
-
-- `HF_HOME`: Override Hugging Face home directory
-- `HF_LEROBOT_CALIBRATION`: Override calibration directory
-
-## 🤝 Contributing
-
-We welcome contributions! This project follows the principle of **Python lerobot faithfulness** - all features should maintain identical UX to the original.
-
-### Guidelines
-
-1. Check Python lerobot implementation first
-2. Maintain identical command structure and messaging
-3. Follow snake_case file naming convention
-4. Test on both Node.js and browser platforms
-
-## 📄 License
-
-Apache 2.0 - Same as original lerobot
-
-## 🙏 Acknowledgments
-
-- [Hugging Face lerobot team](https://github.com/huggingface/lerobot) for the original Python implementation
-- [WebSerial API](https://web.dev/serial/) for browser-native hardware access
-- [serialport](https://github.com/serialport/node-serialport) for Node.js cross-platform support
+Visit `http://localhost:5173` for the web interface.
 
----
+## License
 
-**Built with ❤️ for the robotics community**
+Apache-2.0

package.json

@@ -3,6 +3,9 @@
   "version": "0.0.0",
   "description": "State-of-the-art AI for real-world robotics in JS",
   "type": "module",
+  "workspaces": [
+    "packages/*"
+  ],
   "bin": {
     "lerobot": "./dist/cli/index.js"
   },
@@ -30,16 +33,21 @@
     "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",
+    "changeset": "changeset",
+    "changeset:version": "changeset version",
+    "changeset:publish": "changeset publish",
     "prepublishOnly": "pnpm run build",
     "install-global": "pnpm run build && npm link"
   },
   "dependencies": {
+    "@lerobot/web": "^0.1.1",
     "@radix-ui/react-dialog": "^1.1.14",
     "@radix-ui/react-progress": "^1.1.7",
     "log-update": "^6.1.0",
     "serialport": "^12.0.0"
   },
   "devDependencies": {
+    "@changesets/cli": "^2.29.5",
     "@types/node": "^22.10.5",
     "@types/react": "^18.2.79",
     "@types/react-dom": "^18.2.25",

packages/web/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @lerobot/web
+
+## 0.1.1
+
+### Patch Changes
+
+- prepare "web" for release on npm

packages/web/README.md

@@ -0,0 +1,55 @@
+# @lerobot/web
+
+Control robotics hardware directly from the browser using WebSerial API.
+
+## Install
+
+```bash
+npm install @lerobot/web
+```
+
+## Quick Start
+
+```typescript
+import { findPort, calibrate, teleoperate } from "@lerobot/web";
+
+// 1. Find hardware
+const devices = await findPort();
+const robot = devices[0];
+
+// 2. Calibrate
+const calibration = await calibrate(robot);
+await calibration.result;
+
+// 3. Control
+const controller = await teleoperate(robot);
+controller.start();
+```
+
+## API
+
+### `findPort(options?)`
+
+Detects connected hardware. Returns `RobotConnection[]`.
+
+### `calibrate(robot, options?)`
+
+Calibrates motors and records ranges. Returns `CalibrationProcess`.
+
+### `teleoperate(robot, options?)`
+
+Enables real-time control. Returns `TeleoperationProcess`.
+
+## Browser Support
+
+- Chrome/Edge 89+
+- Requires HTTPS or localhost
+- [WebSerial API](https://caniuse.com/web-serial) support
+
+## Hardware
+
+Currently supports SO-100 follower/leader arms. More devices coming.
+
+## License
+
+Apache-2.0

packages/web/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@lerobot/web",
+  "version": "0.1.1",
+  "description": "Web-based robotics control using WebSerial API",
+  "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",
+    "webserial",
+    "hardware-control",
+    "browser",
+    "typescript"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.5.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/timpietrusky/lerobot.js",
+    "directory": "packages/web"
+  },
+  "license": "Apache-2.0",
+  "author": "Tim Pietrusky",
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/web/src/index.ts

@@ -0,0 +1,45 @@
+/**
+ * @lerobot/web - Web-based robotics control using WebSerial API
+ *
+ * Control robotics hardware directly from the browser using modern web APIs.
+ * No Python dependencies required.
+ */
+
+// Core functions
+export { calibrate, isWebSerialSupported } from "./calibrate.js";
+export { teleoperate } from "./teleoperate.js";
+export { findPort } from "./find_port.js";
+
+// Types
+export type {
+  RobotConnection,
+  RobotConfig,
+  SerialPort,
+  SerialPortInfo,
+  SerialOptions,
+} from "./types/robot-connection.js";
+
+export type {
+  WebCalibrationResults,
+  LiveCalibrationData,
+  CalibrationProcess,
+} from "./types/calibration.js";
+
+export type {
+  MotorConfig,
+  TeleoperationState,
+  TeleoperationProcess,
+} from "./types/teleoperation.js";
+
+export type {
+  RobotHardwareConfig,
+  KeyboardControl,
+} from "./types/robot-config.js";
+
+// Utilities (advanced users)
+export { WebSerialPortWrapper } from "./utils/serial-port-wrapper.js";
+export {
+  createSO100Config,
+  SO100_KEYBOARD_CONTROLS,
+} from "./robots/so100_config.js";
+export { releaseMotors } from "./utils/motor-communication.js";

{src/lerobot/web → packages/web/src}/utils/serial-port-wrapper.ts

@@ -3,6 +3,8 @@
  * Standardized Web Serial API interface with immediate lock release
  */
 
+import type { SerialPort } from "../types/robot-connection.js";
+
 /**
  * Web Serial Port wrapper - direct write/read with immediate lock release
  */

packages/web/tsconfig.build.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": false,
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts", "**/*.spec.ts"]
+}

pnpm-lock.yaml

@@ -21,6 +21,9 @@ importers:
         specifier: ^12.0.0
         version: 12.0.0
     devDependencies:
+      '@changesets/cli':
+        specifier: ^2.29.5
+        version: 2.29.5
       '@types/node':
         specifier: ^22.10.5
         version: 22.15.31
@@ -70,6 +73,12 @@ importers:
         specifier: ^6.3.5
         version: 6.3.5(@types/[email protected])([email protected])([email protected])([email protected])
 
+  packages/web:
+    dependencies:
+      typescript:
+        specifier: '>=4.5.0'
+        version: 5.8.3
+
 packages:
 
   '@alloc/[email protected]':
@@ -147,6 +156,10 @@ packages:
     peerDependencies:
       '@babel/core': ^7.0.0-0
 
+  '@babel/[email protected]':
+    resolution: {integrity: sha512-vbavdySgbTTrmFE+EsiqUTzlOr5bzlnJtUv9PynGCAKvfQqjIXbvFdumPM/GxMDfyuGMJaJAU6TO4zc1Jf1i8Q==}
+    engines: {node: '>=6.9.0'}
+
   '@babel/[email protected]':
     resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==}
     engines: {node: '>=6.9.0'}
@@ -159,6 +172,61 @@ packages:
     resolution: {integrity: sha512-ETyHEk2VHHvl9b9jZP5IHPavHYk57EhanlRRuae9XCpb/j5bDCbPPMOBfCWhnl/7EDJz0jEMCi/RhccCE8r1+Q==}
     engines: {node: '>=6.9.0'}
 
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-EaET7As5CeuhTzvXTQCRZeBUcisoYPDDcXvgTE/2jmmypKp0RC7LxKj/yzqeh/1qFTZI7oDGFcL1PHRuQuketQ==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-tPgeeqCHIwNo8sypKlS3gOPmsS3wP0zHt67JDuL20P4QcXiw/O4Hl7oXiuLnP9yg+rXLQ2sScdV1Kkzde61iSQ==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-x/xEleCFLH28c3bQeQIyeZf8lFXyDFVn1SgcBiR2Tw/r4IAWlk1fzxCEZ6NxQAjF2Nwtczoen3OA2qR+UawQ8Q==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-0j0cPq3fgxt2dPdFsg4XvO+6L66RC0pZybT9F4dG5TBrLA3jA/1pNkdTXH9IBBVHkgsKrNKenI3n1mPyPlIydg==}
+    hasBin: true
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-bd+3Ap2TKXxljCggI0mKPfzCQKeV/TU4yO2h2C6vAihIo8tzseAn2e7klSuiyYYXvgu53zMN1OeYMIQkaQoWnA==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-gphr+v0mv2I3Oxt19VdWRRUxq3sseyUpX9DaHpTUmLj92Y10AGy+XOtV+kbM6L/fDcpx7/ISDFK6T8A/P3lOdQ==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-DWG1pus72FcNeXkM12tx+xtExyH/c9I1z+2aXlObH3i9YA7+WZEVaiHzHl03thpvAgWTRaH64MpfHxozfF7Dvg==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-BXANzRFkX+XcC1q/d27NKvlJ1yf7PSAgi8JG6dt8EfbHFHi4neau7mufcSca5zRhwOL8j9s6EqsxmT+s+/E6Sw==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-OQtR36ZlnuTxKqoW4Sv6x5YIhOmClRd5pWsjZsddYxpWs517R0HkyiefQPIytCVh4ZcC5x9XaG8KTdd5iRQUfg==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-iwksMs5Bf/wUItfcg+OXrEpravm5rEd9Bf4oyIPL4kVTmJQ7PNDSd6MDYkpSJR1pn7tz/k8Zf2DhTCqX08Ou+Q==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-HaL/gEyFVvkf9KFg6484wR9s0qjAXlZ8qWPDkTyKF6+zqjBe/I2mygg3MbpZ++hdi0ToqNUF8cjj7fBy0dg8Ug==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-UPzNGhsSjHD3Veb0xO/MwvasGe8eMyNrR/sT9gR8Q3DhOQZirgKhhXv/8hVsI0QpPjR004Z9iFxoJU6in3uGMg==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-qAK/WrqWLNCP22UDdBTMPH5f41elVDlsNyat180A33dWxuUDyNpg6fPi/FyTZwRriVjg0L8gnjJn2F9XAoF0qw==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-rKQcJ+o1nKNgeoYRHKOS07tAMNd3YSN0uHaJOZYjBAgxfV7TUE7JE+z4BzZdQwb5hKaYbayKN5KrYV7ODb2rAA==}
+
+  '@changesets/[email protected]':
+    resolution: {integrity: sha512-CdTLvIOPiCNuH71pyDu3rA+Q0n65cmAbXnwWH84rKGiFumFzkmHNT8KHTMEchcxN+Kl8I54xGUhJ7l3E7X396Q==}
+
   '@esbuild/[email protected]':
     resolution: {integrity: sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA==}
     engines: {node: '>=18'}
@@ -331,6 +399,12 @@ packages:
   '@jridgewell/[email protected]':
     resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==}
 
+  '@manypkg/[email protected]':
+    resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==}
+
+  '@manypkg/[email protected]':
+    resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==}
+
   '@nodelib/[email protected]':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -713,6 +787,9 @@ packages:
   '@types/[email protected]':
     resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
 
+  '@types/[email protected]':
+    resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==}
+
   '@types/[email protected]':
     resolution: {integrity: sha512-jnVe5ULKl6tijxUhvQeNbQG/84fHfg+yMak02cT8QVhBx/F05rAVxCGBYYTh2EKz22D6JF5ktXuNwdx7b9iEGw==}
 
@@ -733,6 +810,10 @@ packages:
     peerDependencies:
       vite: ^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0
 
+  [email protected]:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
+
   [email protected]:
     resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==}
     engines: {node: '>=18'}
@@ -763,10 +844,17 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==}
 
+  [email protected]:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+
   [email protected]:
     resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
     engines: {node: '>=10'}
 
+  [email protected]:
+    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==}
     engines: {node: ^10 || ^12 || >=14}
@@ -777,6 +865,10 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
+  [email protected]:
+    resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==}
+    engines: {node: '>=4'}
+
   [email protected]:
     resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
     engines: {node: '>=8'}
@@ -800,10 +892,17 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-1R/elMjtehrFejxwmexeXAtae5UO9iSyFn6G/I806CYC/BLyyBk1EPhrKBkWhy6wM6Xnm47dSJQec+tLJ39WHw==}
 
+  [email protected]:
+    resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==}
+
   [email protected]:
     resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
     engines: {node: '>= 8.10.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
 
@@ -850,12 +949,20 @@ packages:
       supports-color:
         optional: true
 
+  [email protected]:
+    resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
 
   [email protected]:
     resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
 
+  [email protected]:
+    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==}
 
@@ -874,6 +981,10 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
 
+  [email protected]:
+    resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
+    engines: {node: '>=8.6'}
+
   [email protected]:
     resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
     engines: {node: '>=18'}
@@ -887,6 +998,18 @@ packages:
     resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
     engines: {node: '>=6'}
 
+  [email protected]:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
+    engines: {node: '>=4'}
+
   [email protected]:
     resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
     engines: {node: '>=8.6.0'}
@@ -906,6 +1029,10 @@ packages:
     resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
 
+  [email protected]:
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
     engines: {node: '>=14'}
@@ -913,6 +1040,14 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==}
 
+  [email protected]:
+    resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==}
+    engines: {node: '>=6 <7 || >=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==}
+    engines: {node: '>=6 <7 || >=8'}
+
   [email protected]:
     resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
     engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
@@ -952,10 +1087,29 @@ packages:
     resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==}
     engines: {node: '>=4'}
 
+  [email protected]:
+    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
+    engines: {node: '>=10'}
+
+  [email protected]:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
   [email protected]:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
 
+  [email protected]:
+    resolution: {integrity: sha512-3gKm/gCSUipeLsRYZbbdA1BD83lBoWUkZ7G9VFrhWPAU76KwYo5KR8V28bpoPm/ygy0x5/GCbpRQdY7VLYCoIg==}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
   [email protected]:
     resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
     engines: {node: '>=8'}
@@ -984,6 +1138,14 @@ packages:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==}
+    engines: {node: '>=4'}
+
+  [email protected]:
+    resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
+    engines: {node: '>=0.10.0'}
+
   [email protected]:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
@@ -997,6 +1159,10 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
+  [email protected]:
+    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+    hasBin: true
+
   [email protected]:
     resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
     engines: {node: '>=6'}
@@ -1007,6 +1173,9 @@ packages:
     engines: {node: '>=6'}
     hasBin: true
 
+  [email protected]:
+    resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
+
   [email protected]:
     resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
     engines: {node: '>=14'}
@@ -1014,6 +1183,13 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
+  [email protected]:
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==}
+
   [email protected]:
     resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
     engines: {node: '>=18'}
@@ -1053,6 +1229,10 @@ packages:
     resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
     engines: {node: '>=16 || 14 >=14.17'}
 
+  [email protected]:
+    resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
+    engines: {node: '>=4'}
+
   [email protected]:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
 
@@ -1094,9 +1274,43 @@ packages:
     resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
     engines: {node: '>=18'}
 
+  [email protected]:
+    resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==}
+    engines: {node: '>=0.10.0'}
+
+  [email protected]:
+    resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==}
+
+  [email protected]:
+    resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
+
+  [email protected]:
+    resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==}
+    engines: {node: '>=6'}
+
+  [email protected]:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+
   [email protected]:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
+  [email protected]:
+    resolution: {integrity: sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==}
+
+  [email protected]:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
     engines: {node: '>=8'}
@@ -1108,6 +1322,10 @@ packages:
     resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
     engines: {node: '>=16 || 14 >=14.18'}
 
+  [email protected]:
+    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
 
@@ -1123,6 +1341,10 @@ packages:
     resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==}
     engines: {node: '>=0.10.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
+
   [email protected]:
     resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
     engines: {node: '>= 6'}
@@ -1168,6 +1390,14 @@ packages:
     resolution: {integrity: sha512-d/jtm+rdNT8tpXuHY5MMtcbJFBkhXE6593XVR9UoGCH8jSFGci7jGvMGH5RYd5PBJW+00NZQt6gf7CbagJCrhg==}
     engines: {node: ^10 || ^12 || >=14}
 
+  [email protected]:
+    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
+  [email protected]:
+    resolution: {integrity: sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A==}
+
   [email protected]:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
@@ -1217,10 +1447,18 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==}
 
+  [email protected]:
+    resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==}
+    engines: {node: '>=6'}
+
   [email protected]:
     resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
     engines: {node: '>=8.10.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
@@ -1245,6 +1483,9 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
 
+  [email protected]:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
   [email protected]:
     resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==}
 
@@ -1252,6 +1493,11 @@ packages:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
+  [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'}
@@ -1268,6 +1514,10 @@ packages:
     resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
     engines: {node: '>=14'}
 
+  [email protected]:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==}
     engines: {node: '>=18'}
@@ -1276,6 +1526,12 @@ packages:
     resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
     engines: {node: '>=0.10.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-MmnduQUuHCoFckZoWnXsTg7JaiLBJrKFj9UI2MbRPGaJeVpsLcVBu6P/IGZovziM/YBsellCmsprgNA+w0CzVg==}
+
+  [email protected]:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+
   [email protected]:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -1296,6 +1552,10 @@ packages:
     resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
     engines: {node: '>=12'}
 
+  [email protected]:
+    resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==}
+    engines: {node: '>=4'}
+
   [email protected]:
     resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==}
     engines: {node: '>=16 || 14 >=14.17'}
@@ -1313,6 +1573,10 @@ packages:
     engines: {node: '>=14.0.0'}
     hasBin: true
 
+  [email protected]:
+    resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==}
+    engines: {node: '>=8'}
+
   [email protected]:
     resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
     engines: {node: '>=0.8'}
@@ -1324,6 +1588,10 @@ packages:
     resolution: {integrity: sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==}
     engines: {node: '>=12.0.0'}
 
+  [email protected]:
+    resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==}
+    engines: {node: '>=0.6.0'}
+
   [email protected]:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
@@ -1347,6 +1615,10 @@ packages:
   [email protected]:
     resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
 
+  [email protected]:
+    resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==}
+    engines: {node: '>= 4.0.0'}
+
   [email protected]:
     resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==}
     hasBin: true
@@ -1537,6 +1809,8 @@ snapshots:
       '@babel/core': 7.27.4
       '@babel/helper-plugin-utils': 7.27.1
 
+  '@babel/[email protected]': {}
+
   '@babel/[email protected]':
     dependencies:
       '@babel/code-frame': 7.27.1
@@ -1560,6 +1834,148 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.27.1
 
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/config': 3.1.1
+      '@changesets/get-version-range-type': 0.4.0
+      '@changesets/git': 3.0.4
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      detect-indent: 6.1.0
+      fs-extra: 7.0.1
+      lodash.startcase: 4.4.0
+      outdent: 0.5.0
+      prettier: 2.8.8
+      resolve-from: 5.0.0
+      semver: 7.7.2
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      semver: 7.7.2
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/types': 6.1.0
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/apply-release-plan': 7.0.12
+      '@changesets/assemble-release-plan': 6.0.9
+      '@changesets/changelog-git': 0.2.1
+      '@changesets/config': 3.1.1
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/get-release-plan': 4.0.13
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.5
+      '@changesets/should-skip-package': 0.1.2
+      '@changesets/types': 6.1.0
+      '@changesets/write': 0.4.0
+      '@manypkg/get-packages': 1.1.3
+      ansi-colors: 4.1.3
+      ci-info: 3.9.0
+      enquirer: 2.4.1
+      external-editor: 3.1.0
+      fs-extra: 7.0.1
+      mri: 1.2.0
+      p-limit: 2.3.0
+      package-manager-detector: 0.2.11
+      picocolors: 1.1.1
+      resolve-from: 5.0.0
+      semver: 7.7.2
+      spawndamnit: 3.0.1
+      term-size: 2.2.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/get-dependents-graph': 2.1.3
+      '@changesets/logger': 0.1.1
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+      micromatch: 4.0.8
+
+  '@changesets/[email protected]':
+    dependencies:
+      extendable-error: 0.1.7
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      picocolors: 1.1.1
+      semver: 7.7.2
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/assemble-release-plan': 6.0.9
+      '@changesets/config': 3.1.1
+      '@changesets/pre': 2.0.2
+      '@changesets/read': 0.6.5
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/[email protected]': {}
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@manypkg/get-packages': 1.1.3
+      is-subdir: 1.2.0
+      micromatch: 4.0.8
+      spawndamnit: 3.0.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      picocolors: 1.1.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/types': 6.1.0
+      js-yaml: 3.14.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/errors': 0.2.0
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+      fs-extra: 7.0.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/git': 3.0.4
+      '@changesets/logger': 0.1.1
+      '@changesets/parse': 0.4.1
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      p-filter: 2.1.0
+      picocolors: 1.1.1
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/types': 6.1.0
+      '@manypkg/get-packages': 1.1.3
+
+  '@changesets/[email protected]': {}
+
+  '@changesets/[email protected]': {}
+
+  '@changesets/[email protected]':
+    dependencies:
+      '@changesets/types': 6.1.0
+      fs-extra: 7.0.1
+      human-id: 4.1.1
+      prettier: 2.8.8
+
   '@esbuild/[email protected]':
     optional: true
 
@@ -1661,6 +2077,22 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.0
 
+  '@manypkg/[email protected]':
+    dependencies:
+      '@babel/runtime': 7.27.6
+      '@types/node': 12.20.55
+      find-up: 4.1.0
+      fs-extra: 8.1.0
+
+  '@manypkg/[email protected]':
+    dependencies:
+      '@babel/runtime': 7.27.6
+      '@changesets/types': 4.1.0
+      '@manypkg/find-root': 1.1.0
+      fs-extra: 8.1.0
+      globby: 11.1.0
+      read-yaml-file: 1.1.0
+
   '@nodelib/[email protected]':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -1968,6 +2400,8 @@ snapshots:
 
   '@types/[email protected]': {}
 
+  '@types/[email protected]': {}
+
   '@types/[email protected]':
     dependencies:
       undici-types: 6.21.0
@@ -1995,6 +2429,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       environment: 1.1.0
@@ -2018,10 +2454,16 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      sprintf-js: 1.0.3
+
   [email protected]:
     dependencies:
       tslib: 2.8.1
 
+  [email protected]: {}
+
   [email protected]([email protected]):
     dependencies:
       browserslist: 4.25.0
@@ -2034,6 +2476,10 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      is-windows: 1.0.2
+
   [email protected]: {}
 
   [email protected]:
@@ -2055,6 +2501,8 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       anymatch: 3.1.3
@@ -2067,6 +2515,8 @@ snapshots:
     optionalDependencies:
       fsevents: 2.3.3
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       clsx: 2.1.1
@@ -2101,10 +2551,16 @@ snapshots:
     dependencies:
       ms: 2.1.2
 
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      path-type: 4.0.0
+
   [email protected]: {}
 
   [email protected]: {}
@@ -2117,6 +2573,11 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      ansi-colors: 4.1.3
+      strip-ansi: 6.0.1
+
   [email protected]: {}
 
   [email protected]:
@@ -2149,6 +2610,16 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      chardet: 0.7.0
+      iconv-lite: 0.4.24
+      tmp: 0.0.33
+
   [email protected]:
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -2169,6 +2640,11 @@ snapshots:
     dependencies:
       to-regex-range: 5.0.1
 
+  [email protected]:
+    dependencies:
+      locate-path: 5.0.0
+      path-exists: 4.0.0
+
   [email protected]:
     dependencies:
       cross-spawn: 7.0.6
@@ -2176,6 +2652,18 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
+  [email protected]:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 4.0.0
+      universalify: 0.1.2
+
   [email protected]:
     optional: true
 
@@ -2210,10 +2698,29 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      array-union: 2.1.0
+      dir-glob: 3.0.1
+      fast-glob: 3.3.3
+      ignore: 5.3.2
+      merge2: 1.4.1
+      slash: 3.0.0
+
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       function-bind: 1.1.2
 
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       binary-extensions: 2.3.0
@@ -2236,6 +2743,12 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      better-path-resolve: 1.0.0
+
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]:
@@ -2248,14 +2761,29 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+
   [email protected]: {}
 
   [email protected]: {}
 
+  [email protected]:
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
   [email protected]: {}
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      p-locate: 4.1.0
+
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       ansi-escapes: 7.0.0
@@ -2293,6 +2821,8 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]:
@@ -2321,8 +2851,34 @@ snapshots:
     dependencies:
       mimic-function: 5.0.1
 
+  [email protected]: {}
+
+  [email protected]: {}
+
+  [email protected]:
+    dependencies:
+      p-map: 2.1.0
+
+  [email protected]:
+    dependencies:
+      p-try: 2.2.0
+
+  [email protected]:
+    dependencies:
+      p-limit: 2.3.0
+
+  [email protected]: {}
+
+  [email protected]: {}
+
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      quansync: 0.2.10
+
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]: {}
@@ -2332,6 +2888,8 @@ snapshots:
       lru-cache: 10.4.3
       minipass: 7.1.2
 
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]: {}
@@ -2340,6 +2898,8 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]([email protected]):
@@ -2379,6 +2939,10 @@ snapshots:
       picocolors: 1.1.1
       source-map-js: 1.2.1
 
+  [email protected]: {}
+
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]([email protected]):
@@ -2424,10 +2988,19 @@ snapshots:
     dependencies:
       pify: 2.3.0
 
+  [email protected]:
+    dependencies:
+      graceful-fs: 4.2.11
+      js-yaml: 3.14.1
+      pify: 4.0.1
+      strip-bom: 3.0.0
+
   [email protected]:
     dependencies:
       picomatch: 2.3.1
 
+  [email protected]: {}
+
   [email protected]: {}
 
   [email protected]:
@@ -2473,12 +3046,16 @@ snapshots:
     dependencies:
       queue-microtask: 1.2.3
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       loose-envify: 1.4.0
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       '@serialport/binding-mock': 10.2.2
@@ -2506,6 +3083,8 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       ansi-styles: 6.2.1
@@ -2513,6 +3092,13 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       emoji-regex: 8.0.0
@@ -2539,6 +3125,8 @@ snapshots:
     dependencies:
       ansi-regex: 6.1.0
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       '@jridgewell/gen-mapping': 0.3.8
@@ -2580,6 +3168,8 @@ snapshots:
     transitivePeerDependencies:
       - ts-node
 
+  [email protected]: {}
+
   [email protected]:
     dependencies:
       thenify: 3.3.1
@@ -2593,6 +3183,10 @@ snapshots:
       fdir: 6.4.6([email protected])
       picomatch: 4.0.2
 
+  [email protected]:
+    dependencies:
+      os-tmpdir: 1.0.2
+
   [email protected]:
     dependencies:
       is-number: 7.0.0
@@ -2612,6 +3206,8 @@ snapshots:
 
   [email protected]: {}
 
+  [email protected]: {}
+
   [email protected]([email protected]):
     dependencies:
       browserslist: 4.25.0

pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+packages:
+  - "packages/*"

src/demo/App.tsx

@@ -1,7 +1,7 @@
 import { useState } from "react";
 import { Home } from "./pages/Home";
 import { ErrorBoundary } from "./components/ErrorBoundary";
-import type { RobotConnection } from "../lerobot/web/types/robot-connection.js";
+import type { RobotConnection } from "@lerobot/web";
 
 export function App() {
   const [connectedRobots, setConnectedRobots] = useState<RobotConnection[]>([]);

src/demo/components/CalibrationPanel.tsx

@@ -13,12 +13,12 @@ import {
   type WebCalibrationResults,
   type LiveCalibrationData,
   type CalibrationProcess,
-} from "../../lerobot/web/calibrate";
-import { releaseMotors } from "../../lerobot/web/utils/motor-communication.js";
-import { WebSerialPortWrapper } from "../../lerobot/web/utils/serial-port-wrapper.js";
-import { createSO100Config } from "../../lerobot/web/robots/so100_config.js";
+} from "@lerobot/web";
+import { releaseMotors } from "@lerobot/web";
+import { WebSerialPortWrapper } from "@lerobot/web";
+import { createSO100Config } from "@lerobot/web";
 import { CalibrationModal } from "./CalibrationModal";
-import type { RobotConnection } from "../../lerobot/web/types/robot-connection.js";
+import type { RobotConnection } from "@lerobot/web";
 
 interface CalibrationPanelProps {
   robot: RobotConnection;

src/demo/components/PortManager.tsx

@@ -17,8 +17,8 @@ import {
   DialogHeader,
   DialogTitle,
 } from "./ui/dialog";
-import { isWebSerialSupported } from "../../lerobot/web/calibrate";
-import type { RobotConnection } from "../../lerobot/web/types/robot-connection.js";
+import { isWebSerialSupported } from "@lerobot/web";
+import type { RobotConnection } from "@lerobot/web";
 
 /**
  * Type definitions for WebSerial API (missing from TypeScript)
@@ -464,7 +464,7 @@ export function PortManager({
       setError(null);
 
       // Use the new findPort API from standard library
-      const { findPort } = await import("../../lerobot/web/find_port.js");
+      const { findPort } = await import("@lerobot/web");
 
       const findPortProcess = await findPort({
         onMessage: (message) => {

src/demo/components/TeleoperationPanel.tsx

@@ -7,10 +7,10 @@ import {
   teleoperate,
   type TeleoperationProcess,
   type TeleoperationState,
-} from "../../lerobot/web/teleoperate.js";
+} from "@lerobot/web";
 import { getUnifiedRobotData } from "../lib/unified-storage";
-import type { RobotConnection } from "../../lerobot/web/types/robot-connection.js";
-import { SO100_KEYBOARD_CONTROLS } from "../../lerobot/web/robots/so100_config.js";
+import type { RobotConnection } from "@lerobot/web";
+import { SO100_KEYBOARD_CONTROLS } from "@lerobot/web";
 
 interface TeleoperationPanelProps {
   robot: RobotConnection;

src/demo/pages/Home.tsx

@@ -4,8 +4,8 @@ import { Alert, AlertDescription } from "../components/ui/alert";
 import { PortManager } from "../components/PortManager";
 import { CalibrationPanel } from "../components/CalibrationPanel";
 import { TeleoperationPanel } from "../components/TeleoperationPanel";
-import { isWebSerialSupported } from "../../lerobot/web/calibrate";
-import type { RobotConnection } from "../../lerobot/web/types/robot-connection.js";
+import { isWebSerialSupported } from "@lerobot/web";
+import type { RobotConnection } from "@lerobot/web";
 
 interface HomeProps {
   connectedRobots: RobotConnection[];
@@ -48,7 +48,7 @@ export function Home({ connectedRobots, onConnectedRobotsChange }: HomeProps) {
             🤖 LeRobot.js
           </h1>
           <p className="text-xl text-gray-600 mb-8">
-            State-of-the-art AI for real-world robotics in JavaScript
+            Robotics for the web and node
           </p>
 
           {!isSupported && (

src/lerobot/node/calibrate.ts

@@ -1,246 +0,0 @@
-/**
- * Helper to recalibrate your device (robot or teleoperator).
- *
- * Example:
- * ```
- * npx lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_follower_arm
- * ```
- */
-
-import { createSO100Follower } from "./robots/so100_follower.js";
-import { createSO100Leader } from "./teleoperators/so100_leader.js";
-import {
-  initializeDeviceCommunication,
-  readMotorPositions,
-  performInteractiveCalibration,
-  setMotorLimits,
-  verifyCalibration,
-} from "./common/calibration.js";
-import type { CalibrateConfig } from "./types/robot-config.js";
-import type { CalibrationResults } from "./types/calibration.js";
-import { getSO100Config } from "./common/so100_config.js";
-
-/**
- * Main calibrate function
- * Mirrors Python lerobot calibrate.py calibrate() function
- * Uses shared calibration procedures instead of device-specific implementations
- */
-export async function calibrate(config: CalibrateConfig): Promise<void> {
-  // Validate configuration - exactly one device must be specified
-  if (Boolean(config.robot) === Boolean(config.teleop)) {
-    throw new Error("Choose either a robot or a teleop.");
-  }
-
-  const deviceConfig = config.robot || config.teleop!;
-
-  let device;
-  let calibrationResults: CalibrationResults;
-
-  try {
-    // Create device for connection management only
-    if (config.robot) {
-      switch (config.robot.type) {
-        case "so100_follower":
-          device = createSO100Follower(config.robot);
-          break;
-        default:
-          throw new Error(`Unsupported robot type: ${config.robot.type}`);
-      }
-    } else if (config.teleop) {
-      switch (config.teleop.type) {
-        case "so100_leader":
-          device = createSO100Leader(config.teleop);
-          break;
-        default:
-          throw new Error(
-            `Unsupported teleoperator type: ${config.teleop.type}`
-          );
-      }
-    }
-
-    if (!device) {
-      throw new Error("Failed to create device");
-    }
-
-    // Connect to device (silent unless error)
-    await device.connect(false); // calibrate=False like Python
-
-    // Get SO-100 calibration configuration
-    const so100Config = getSO100Config(
-      deviceConfig.type as "so100_follower" | "so100_leader",
-      (device as any).port
-    );
-
-    // Perform shared calibration procedures (silent unless error)
-    await initializeDeviceCommunication(so100Config);
-    await setMotorLimits(so100Config);
-
-    // Interactive calibration with live updates - THE MAIN PART
-    calibrationResults = await performInteractiveCalibration(so100Config);
-
-    // Save and cleanup (silent unless error)
-    await verifyCalibration(so100Config);
-    await (device as any).saveCalibration(calibrationResults);
-    await device.disconnect();
-  } catch (error) {
-    // Ensure we disconnect even if there's an error
-    if (device) {
-      try {
-        await device.disconnect();
-      } catch (disconnectError) {
-        console.warn("Warning: Failed to disconnect properly");
-      }
-    }
-    throw error;
-  }
-}
-
-/**
- * Parse command line arguments in Python argparse style
- * Handles --robot.type=so100_follower --robot.port=COM4 format
- */
-export function parseArgs(args: string[]): CalibrateConfig {
-  const config: CalibrateConfig = {};
-
-  for (const arg of args) {
-    if (arg.startsWith("--robot.")) {
-      if (!config.robot) {
-        config.robot = { type: "so100_follower", port: "" };
-      }
-
-      const [key, value] = arg.substring(8).split("=");
-      switch (key) {
-        case "type":
-          if (value !== "so100_follower") {
-            throw new Error(`Unsupported robot type: ${value}`);
-          }
-          config.robot.type = value as "so100_follower";
-          break;
-        case "port":
-          config.robot.port = value;
-          break;
-        case "id":
-          config.robot.id = value;
-          break;
-        case "disable_torque_on_disconnect":
-          config.robot.disable_torque_on_disconnect = value === "true";
-          break;
-        case "max_relative_target":
-          config.robot.max_relative_target = value ? parseInt(value) : null;
-          break;
-        case "use_degrees":
-          config.robot.use_degrees = value === "true";
-          break;
-        default:
-          throw new Error(`Unknown robot parameter: ${key}`);
-      }
-    } else if (arg.startsWith("--teleop.")) {
-      if (!config.teleop) {
-        config.teleop = { type: "so100_leader", port: "" };
-      }
-
-      const [key, value] = arg.substring(9).split("=");
-      switch (key) {
-        case "type":
-          if (value !== "so100_leader") {
-            throw new Error(`Unsupported teleoperator type: ${value}`);
-          }
-          config.teleop.type = value as "so100_leader";
-          break;
-        case "port":
-          config.teleop.port = value;
-          break;
-        case "id":
-          config.teleop.id = value;
-          break;
-        default:
-          throw new Error(`Unknown teleoperator parameter: ${key}`);
-      }
-    } else if (arg === "--help" || arg === "-h") {
-      showUsage();
-      process.exit(0);
-    } else if (!arg.startsWith("--")) {
-      // Skip non-option arguments
-      continue;
-    } else {
-      throw new Error(`Unknown argument: ${arg}`);
-    }
-  }
-
-  // Validate required fields
-  if (config.robot && !config.robot.port) {
-    throw new Error("Robot port is required (--robot.port=PORT)");
-  }
-  if (config.teleop && !config.teleop.port) {
-    throw new Error("Teleoperator port is required (--teleop.port=PORT)");
-  }
-
-  return config;
-}
-
-/**
- * Show usage information matching Python argparse output
- */
-function showUsage(): void {
-  console.log("Usage: lerobot calibrate [options]");
-  console.log("");
-  console.log("Recalibrate your device (robot or teleoperator)");
-  console.log("");
-  console.log("Options:");
-  console.log("  --robot.type=TYPE        Robot type (so100_follower)");
-  console.log(
-    "  --robot.port=PORT        Robot serial port (e.g., COM4, /dev/ttyUSB0)"
-  );
-  console.log("  --robot.id=ID            Robot identifier");
-  console.log("  --teleop.type=TYPE       Teleoperator type (so100_leader)");
-  console.log("  --teleop.port=PORT       Teleoperator serial port");
-  console.log("  --teleop.id=ID           Teleoperator identifier");
-  console.log("  -h, --help               Show this help message");
-  console.log("");
-  console.log("Examples:");
-  console.log(
-    "  lerobot calibrate --robot.type=so100_follower --robot.port=COM4 --robot.id=my_follower_arm"
-  );
-  console.log(
-    "  lerobot calibrate --teleop.type=so100_leader --teleop.port=COM3 --teleop.id=my_leader_arm"
-  );
-  console.log("");
-  console.log("Use 'lerobot find-port' to discover available ports.");
-}
-
-/**
- * CLI entry point when called directly
- * Mirrors Python's if __name__ == "__main__": pattern
- */
-export async function main(args: string[]): Promise<void> {
-  try {
-    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-      showUsage();
-      return;
-    }
-
-    const config = parseArgs(args);
-    await calibrate(config);
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error("Error:", error.message);
-    } else {
-      console.error("Error:", error);
-    }
-
-    console.error("");
-    console.error("Please verify:");
-    console.error("1. The device is connected to the specified port");
-    console.error("2. No other application is using the port");
-    console.error("3. You have permission to access the port");
-    console.error("");
-    console.error("Use 'lerobot find-port' to discover available ports.");
-
-    process.exit(1);
-  }
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  main(args);
-}

src/lerobot/node/common/calibration.ts

@@ -1,694 +0,0 @@
-/**
- * Shared calibration procedures for SO-100 devices (both leader and follower)
- * Mirrors Python lerobot calibrate.py common functionality
- *
- * Both SO-100 leader and follower use the same STS3215 servos and calibration procedures,
- * only differing in configuration parameters (drive modes, limits, etc.)
- */
-
-import * as readline from "readline";
-import { SerialPort } from "serialport";
-import logUpdate from "log-update";
-
-/**
- * Sign-magnitude encoding functions for Feetech STS3215 motors
- * Mirrors Python lerobot/common/utils/encoding_utils.py
- */
-
-/**
- * Encode a signed integer using sign-magnitude format
- * Bit at sign_bit_index represents sign (0=positive, 1=negative)
- * Lower bits represent magnitude
- */
-function encodeSignMagnitude(value: number, signBitIndex: number): number {
-  const maxMagnitude = (1 << signBitIndex) - 1;
-  const magnitude = Math.abs(value);
-
-  if (magnitude > maxMagnitude) {
-    throw new Error(
-      `Magnitude ${magnitude} exceeds ${maxMagnitude} (max for signBitIndex=${signBitIndex})`
-    );
-  }
-
-  const directionBit = value < 0 ? 1 : 0;
-  return (directionBit << signBitIndex) | magnitude;
-}
-
-/**
- * Decode a sign-magnitude encoded value back to signed integer
- * Extracts sign bit and magnitude, then applies sign
- */
-function decodeSignMagnitude(
-  encodedValue: number,
-  signBitIndex: number
-): number {
-  const directionBit = (encodedValue >> signBitIndex) & 1;
-  const magnitudeMask = (1 << signBitIndex) - 1;
-  const magnitude = encodedValue & magnitudeMask;
-  return directionBit ? -magnitude : magnitude;
-}
-
-/**
- * Device configuration for calibration
- * Despite the "SO100" name, this interface is now device-agnostic and configurable
- * for any robot using similar serial protocols (Feetech STS3215, etc.)
- */
-import type {
-  SO100CalibrationConfig,
-  CalibrationResults,
-} from "../types/calibration.js";
-
-/**
- * Initialize device communication
- * Common for both SO-100 leader and follower (same hardware)
- */
-export async function initializeDeviceCommunication(
-  config: SO100CalibrationConfig
-): Promise<void> {
-  try {
-    // Test ping to servo ID 1 (same protocol for all SO-100 devices)
-    const pingPacket = Buffer.from([0xff, 0xff, 0x01, 0x02, 0x01, 0xfb]);
-
-    if (!config.port || !config.port.isOpen) {
-      throw new Error("Serial port not open");
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      config.port.write(pingPacket, (error) => {
-        if (error) {
-          reject(new Error(`Failed to send ping: ${error.message}`));
-        } else {
-          resolve();
-        }
-      });
-    });
-
-    try {
-      await readData(config.port, 1000);
-    } catch (error) {
-      // Silent - no response expected for basic test
-    }
-  } catch (error) {
-    throw new Error(
-      `Serial communication test failed: ${
-        error instanceof Error ? error.message : error
-      }`
-    );
-  }
-}
-
-/**
- * Read current motor positions
- * Uses device-specific protocol - configurable for different robot types
- */
-export async function readMotorPositions(
-  config: SO100CalibrationConfig,
-  quiet: boolean = false
-): Promise<number[]> {
-  const motorPositions: number[] = [];
-
-  for (let i = 0; i < config.motorIds.length; i++) {
-    const motorId = config.motorIds[i];
-    const motorName = config.motorNames[i];
-
-    try {
-      // Create Read Position packet using configurable address
-      const packet = Buffer.from([
-        0xff,
-        0xff,
-        motorId,
-        0x04,
-        0x02,
-        config.protocol.presentPositionAddress, // Configurable address instead of hardcoded 0x38
-        0x02,
-        0x00,
-      ]);
-      const checksum =
-        ~(
-          motorId +
-          0x04 +
-          0x02 +
-          config.protocol.presentPositionAddress +
-          0x02
-        ) & 0xff;
-      packet[7] = checksum;
-
-      if (!config.port || !config.port.isOpen) {
-        throw new Error("Serial port not open");
-      }
-
-      await new Promise<void>((resolve, reject) => {
-        config.port.write(packet, (error) => {
-          if (error) {
-            reject(new Error(`Failed to send read packet: ${error.message}`));
-          } else {
-            resolve();
-          }
-        });
-      });
-
-      try {
-        const response = await readData(config.port, 100); // Faster timeout for 30Hz performance
-        if (response.length >= 7) {
-          const id = response[2];
-          const error = response[4];
-          if (id === motorId && error === 0) {
-            const position = response[5] | (response[6] << 8);
-            motorPositions.push(position);
-          } else {
-            // Use half of max resolution as fallback instead of hardcoded 2047
-            motorPositions.push(
-              Math.floor((config.protocol.resolution - 1) / 2)
-            );
-          }
-        } else {
-          motorPositions.push(Math.floor((config.protocol.resolution - 1) / 2));
-        }
-      } catch (readError) {
-        motorPositions.push(Math.floor((config.protocol.resolution - 1) / 2));
-      }
-    } catch (error) {
-      motorPositions.push(Math.floor((config.protocol.resolution - 1) / 2));
-    }
-
-    // Minimal delay between servo reads for 30Hz performance
-    await new Promise((resolve) => setTimeout(resolve, 2));
-  }
-
-  return motorPositions;
-}
-
-/**
- * Interactive calibration procedure
- * Same flow for both leader and follower, just different configurations
- */
-export async function performInteractiveCalibration(
-  config: SO100CalibrationConfig
-): Promise<CalibrationResults> {
-  // Step 1: Set homing position
-  await promptUser(
-    `Move the SO-100 ${config.deviceType} to the MIDDLE of its range of motion and press ENTER...`
-  );
-
-  const homingOffsets = await setHomingOffsets(config);
-
-  // Step 2: Record ranges of motion with live updates
-  const { rangeMins, rangeMaxes } = await recordRangesOfMotion(config);
-
-  // Step 3: Set special range for wrist_roll (full turn motor)
-  rangeMins["wrist_roll"] = 0;
-  rangeMaxes["wrist_roll"] = 4095;
-
-  // Step 4: Write hardware position limits to motors (matching Python behavior)
-  await writeHardwarePositionLimits(config, rangeMins, rangeMaxes);
-
-  // Compile results in Python-compatible format
-  const results: CalibrationResults = {};
-
-  for (let i = 0; i < config.motorNames.length; i++) {
-    const motorName = config.motorNames[i];
-    const motorId = config.motorIds[i];
-
-    results[motorName] = {
-      id: motorId,
-      drive_mode: config.driveModes[i],
-      homing_offset: homingOffsets[motorName],
-      range_min: rangeMins[motorName],
-      range_max: rangeMaxes[motorName],
-    };
-  }
-
-  return results;
-}
-
-/**
- * Set motor limits (device-specific)
- */
-export async function setMotorLimits(
-  config: SO100CalibrationConfig
-): Promise<void> {
-  // Silent unless error - motor limits configured internally
-}
-
-/**
- * Verify calibration was successful
- */
-export async function verifyCalibration(
-  config: SO100CalibrationConfig
-): Promise<void> {
-  // Silent unless error - calibration verification passed internally
-}
-
-/**
- * Reset homing offsets to 0 for all motors
- * Mirrors Python reset_calibration() - critical step before calculating new offsets
- * This ensures Present_Position reflects true physical position without existing offsets
- */
-async function resetHomingOffsets(
-  config: SO100CalibrationConfig
-): Promise<void> {
-  for (let i = 0; i < config.motorIds.length; i++) {
-    const motorId = config.motorIds[i];
-    const motorName = config.motorNames[i];
-
-    try {
-      // Write 0 to Homing_Offset register using configurable address
-      const homingOffsetValue = 0;
-
-      // Create Write Homing_Offset packet using configurable address
-      const packet = Buffer.from([
-        0xff,
-        0xff, // Header
-        motorId, // Servo ID
-        0x05, // Length (Instruction + Address + Data + Checksum)
-        0x03, // Instruction: WRITE_DATA
-        config.protocol.homingOffsetAddress, // Configurable address instead of hardcoded 0x1f
-        homingOffsetValue & 0xff, // Data_L (low byte)
-        (homingOffsetValue >> 8) & 0xff, // Data_H (high byte)
-        0x00, // Checksum (will calculate)
-      ]);
-
-      // Calculate checksum using configurable address
-      const checksum =
-        ~(
-          motorId +
-          0x05 +
-          0x03 +
-          config.protocol.homingOffsetAddress +
-          (homingOffsetValue & 0xff) +
-          ((homingOffsetValue >> 8) & 0xff)
-        ) & 0xff;
-      packet[8] = checksum;
-
-      if (!config.port || !config.port.isOpen) {
-        throw new Error("Serial port not open");
-      }
-
-      // Send reset packet
-      await new Promise<void>((resolve, reject) => {
-        config.port.write(packet, (error) => {
-          if (error) {
-            reject(
-              new Error(
-                `Failed to reset homing offset for ${motorName}: ${error.message}`
-              )
-            );
-          } else {
-            resolve();
-          }
-        });
-      });
-
-      // Wait for response (silent unless error)
-      try {
-        await readData(config.port, 200);
-      } catch (error) {
-        // Silent - response not required for successful operation
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to reset homing offset for ${motorName}: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-    }
-
-    // Small delay between motor writes
-    await new Promise((resolve) => setTimeout(resolve, 20));
-  }
-}
-
-/**
- * Record homing offsets (current positions as center)
- * Mirrors Python bus.set_half_turn_homings()
- *
- * CRITICAL: Must reset existing homing offsets to 0 first (like Python does)
- * CRITICAL: Must WRITE the new homing offsets to motors immediately (like Python does)
- */
-async function setHomingOffsets(
-  config: SO100CalibrationConfig
-): Promise<{ [motor: string]: number }> {
-  // CRITICAL: Reset existing homing offsets to 0 first (matching Python)
-  await resetHomingOffsets(config);
-
-  // Wait a moment for reset to take effect
-  await new Promise((resolve) => setTimeout(resolve, 100));
-
-  // Now read positions (which will be true physical positions)
-  const currentPositions = await readMotorPositions(config);
-  const homingOffsets: { [motor: string]: number } = {};
-
-  for (let i = 0; i < config.motorNames.length; i++) {
-    const motorName = config.motorNames[i];
-    const position = currentPositions[i];
-
-    // Generic formula: pos - int((max_res - 1) / 2) using configurable resolution
-    const halfTurn = Math.floor((config.protocol.resolution - 1) / 2);
-    homingOffsets[motorName] = position - halfTurn;
-  }
-
-  // CRITICAL: Write homing offsets to motors immediately (matching Python exactly)
-  // Python does: for motor, offset in homing_offsets.items(): self.write("Homing_Offset", motor, offset)
-  await writeHomingOffsetsToMotors(config, homingOffsets);
-
-  return homingOffsets;
-}
-
-/**
- * Write homing offsets to motor registers immediately
- * Mirrors Python's immediate writing in set_half_turn_homings()
- */
-async function writeHomingOffsetsToMotors(
-  config: SO100CalibrationConfig,
-  homingOffsets: { [motor: string]: number }
-): Promise<void> {
-  for (let i = 0; i < config.motorIds.length; i++) {
-    const motorId = config.motorIds[i];
-    const motorName = config.motorNames[i];
-    const homingOffset = homingOffsets[motorName];
-
-    try {
-      // Encode using sign-magnitude format (like Python)
-      const encodedOffset = encodeSignMagnitude(
-        homingOffset,
-        config.protocol.signMagnitudeBit
-      );
-
-      // Create Write Homing_Offset packet
-      const packet = Buffer.from([
-        0xff,
-        0xff, // Header
-        motorId, // Servo ID
-        0x05, // Length
-        0x03, // Instruction: WRITE_DATA
-        config.protocol.homingOffsetAddress, // Homing_Offset address
-        encodedOffset & 0xff, // Data_L (low byte)
-        (encodedOffset >> 8) & 0xff, // Data_H (high byte)
-        0x00, // Checksum (will calculate)
-      ]);
-
-      // Calculate checksum
-      const checksum =
-        ~(
-          motorId +
-          0x05 +
-          0x03 +
-          config.protocol.homingOffsetAddress +
-          (encodedOffset & 0xff) +
-          ((encodedOffset >> 8) & 0xff)
-        ) & 0xff;
-      packet[8] = checksum;
-
-      if (!config.port || !config.port.isOpen) {
-        throw new Error("Serial port not open");
-      }
-
-      // Send packet
-      await new Promise<void>((resolve, reject) => {
-        config.port.write(packet, (error) => {
-          if (error) {
-            reject(
-              new Error(
-                `Failed to write homing offset for ${motorName}: ${error.message}`
-              )
-            );
-          } else {
-            resolve();
-          }
-        });
-      });
-
-      // Wait for response (silent unless error)
-      try {
-        await readData(config.port, 200);
-      } catch (error) {
-        // Silent - response not required for successful operation
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to write homing offset for ${motorName}: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-    }
-
-    // Small delay between motor writes
-    await new Promise((resolve) => setTimeout(resolve, 20));
-  }
-}
-
-/**
- * Record ranges of motion with live updating table
- * Mirrors Python bus.record_ranges_of_motion()
- */
-async function recordRangesOfMotion(config: SO100CalibrationConfig): Promise<{
-  rangeMins: { [motor: string]: number };
-  rangeMaxes: { [motor: string]: number };
-}> {
-  console.log(
-    "Move all joints sequentially through their entire ranges of motion."
-  );
-  console.log(
-    "Positions will be recorded continuously. Press ENTER to stop...\n"
-  );
-
-  const rangeMins: { [motor: string]: number } = {};
-  const rangeMaxes: { [motor: string]: number } = {};
-
-  // Read actual current positions (matching Python exactly)
-  // Python does: start_positions = self.sync_read("Present_Position", motors, normalize=False)
-  // mins = start_positions.copy(); maxes = start_positions.copy()
-  const startPositions = await readMotorPositions(config);
-
-  for (let i = 0; i < config.motorNames.length; i++) {
-    const motorName = config.motorNames[i];
-    const startPosition = startPositions[i];
-    rangeMins[motorName] = startPosition; // Use actual position, not hardcoded 2047
-    rangeMaxes[motorName] = startPosition; // Use actual position, not hardcoded 2047
-  }
-
-  let recording = true;
-  let readCount = 0;
-
-  // Set up readline to detect Enter key
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  rl.on("line", () => {
-    recording = false;
-    rl.close();
-  });
-
-  // Continuous recording loop with live updates - THE LIVE UPDATING TABLE!
-  while (recording) {
-    try {
-      const positions = await readMotorPositions(config); // Always quiet during live recording
-      readCount++;
-
-      // Update min/max ranges
-      for (let i = 0; i < config.motorNames.length; i++) {
-        const motorName = config.motorNames[i];
-        const position = positions[i];
-
-        if (position < rangeMins[motorName]) {
-          rangeMins[motorName] = position;
-        }
-        if (position > rangeMaxes[motorName]) {
-          rangeMaxes[motorName] = position;
-        }
-      }
-
-      // Show real-time feedback every 3 reads for faster updates - LIVE TABLE UPDATE
-      if (readCount % 3 === 0) {
-        // Build the live table content
-        let liveTable = `Readings: ${readCount}\n\n`;
-        liveTable += "Motor Name       Current    Min      Max      Range\n";
-        liveTable += "─".repeat(55) + "\n";
-
-        for (let i = 0; i < config.motorNames.length; i++) {
-          const motorName = config.motorNames[i];
-          const current = positions[i];
-          const min = rangeMins[motorName];
-          const max = rangeMaxes[motorName];
-          const range = max - min;
-
-          liveTable += `${motorName.padEnd(15)} ${current
-            .toString()
-            .padStart(6)} ${min.toString().padStart(6)} ${max
-            .toString()
-            .padStart(6)} ${range.toString().padStart(8)}\n`;
-        }
-        liveTable += "\nMove joints through their full range...";
-
-        // Update the display in place (no new console lines!)
-        logUpdate(liveTable);
-      }
-
-      // Minimal delay for 30Hz reading rate (~33ms cycle time)
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    } catch (error) {
-      console.warn(
-        `Read error: ${error instanceof Error ? error.message : error}`
-      );
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  }
-
-  // Stop live updating and return to normal console
-  logUpdate.done();
-
-  return { rangeMins, rangeMaxes };
-}
-
-/**
- * Prompt user for input (real implementation with readline)
- */
-async function promptUser(message: string): Promise<string> {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-
-  return new Promise((resolve) => {
-    rl.question(message, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-/**
- * Read data from serial port with timeout
- */
-async function readData(
-  port: SerialPort,
-  timeout: number = 5000
-): Promise<Buffer> {
-  if (!port || !port.isOpen) {
-    throw new Error("Serial port not open");
-  }
-
-  return new Promise<Buffer>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error("Read timeout"));
-    }, timeout);
-
-    port.once("data", (data: Buffer) => {
-      clearTimeout(timer);
-      resolve(data);
-    });
-  });
-}
-
-/**
- * Write hardware position limits to motors
- * Mirrors Python lerobot write_calibration() behavior where it writes:
- * - Min_Position_Limit register with calibration.range_min
- * - Max_Position_Limit register with calibration.range_max
- * This physically constrains the motors to the calibrated ranges
- */
-async function writeHardwarePositionLimits(
-  config: SO100CalibrationConfig,
-  rangeMins: { [motor: string]: number },
-  rangeMaxes: { [motor: string]: number }
-): Promise<void> {
-  for (let i = 0; i < config.motorIds.length; i++) {
-    const motorId = config.motorIds[i];
-    const motorName = config.motorNames[i];
-    const minLimit = rangeMins[motorName];
-    const maxLimit = rangeMaxes[motorName];
-
-    try {
-      // Write Min_Position_Limit register
-      await writeMotorRegister(
-        config,
-        motorId,
-        config.protocol.minPositionLimitAddress,
-        minLimit,
-        `Min_Position_Limit for ${motorName}`
-      );
-
-      // Small delay between writes
-      await new Promise((resolve) => setTimeout(resolve, 20));
-
-      // Write Max_Position_Limit register
-      await writeMotorRegister(
-        config,
-        motorId,
-        config.protocol.maxPositionLimitAddress,
-        maxLimit,
-        `Max_Position_Limit for ${motorName}`
-      );
-
-      // Small delay between motors
-      await new Promise((resolve) => setTimeout(resolve, 20));
-    } catch (error) {
-      throw new Error(
-        `Failed to write position limits for ${motorName}: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-    }
-  }
-}
-
-/**
- * Generic function to write a 2-byte value to a motor register
- * Used for both Min_Position_Limit and Max_Position_Limit
- */
-async function writeMotorRegister(
-  config: SO100CalibrationConfig,
-  motorId: number,
-  registerAddress: number,
-  value: number,
-  description: string
-): Promise<void> {
-  // Create Write Register packet
-  const packet = Buffer.from([
-    0xff,
-    0xff, // Header
-    motorId, // Servo ID
-    0x05, // Length (Instruction + Address + Data + Checksum)
-    0x03, // Instruction: WRITE_DATA
-    registerAddress, // Register address
-    value & 0xff, // Data_L (low byte)
-    (value >> 8) & 0xff, // Data_H (high byte)
-    0x00, // Checksum (will calculate)
-  ]);
-
-  // Calculate checksum
-  const checksum =
-    ~(
-      motorId +
-      0x05 +
-      0x03 +
-      registerAddress +
-      (value & 0xff) +
-      ((value >> 8) & 0xff)
-    ) & 0xff;
-  packet[8] = checksum;
-
-  if (!config.port || !config.port.isOpen) {
-    throw new Error("Serial port not open");
-  }
-
-  // Send packet
-  await new Promise<void>((resolve, reject) => {
-    config.port.write(packet, (error) => {
-      if (error) {
-        reject(new Error(`Failed to write ${description}: ${error.message}`));
-      } else {
-        resolve();
-      }
-    });
-  });
-
-  // Wait for response (silent unless error)
-  try {
-    await readData(config.port, 200);
-  } catch (error) {
-    // Silent - response not required for successful operation
-  }
-}

src/lerobot/node/common/so100_config.ts

@@ -1,137 +0,0 @@
-/**
- * SO-100 device configurations
- * Defines the differences between leader and follower devices
- * Mirrors Python lerobot device configuration approach
- */
-
-import type { SO100CalibrationConfig } from "../types/calibration.js";
-import { SerialPort } from "serialport";
-
-/**
- * Common motor names for all SO-100 devices
- */
-const SO100_MOTOR_NAMES = [
-  "shoulder_pan",
-  "shoulder_lift",
-  "elbow_flex",
-  "wrist_flex",
-  "wrist_roll",
-  "gripper",
-];
-
-/**
- * Common motor IDs for all SO-100 devices (STS3215 servos)
- */
-const SO100_MOTOR_IDS = [1, 2, 3, 4, 5, 6];
-
-/**
- * Protocol configuration for STS3215 motors used in SO-100 devices
- */
-interface STS3215Protocol {
-  resolution: number;
-  homingOffsetAddress: number;
-  homingOffsetLength: number;
-  presentPositionAddress: number;
-  presentPositionLength: number;
-  minPositionLimitAddress: number;
-  minPositionLimitLength: number;
-  maxPositionLimitAddress: number;
-  maxPositionLimitLength: number;
-  signMagnitudeBit: number; // Bit 11 is sign bit for Homing_Offset encoding
-}
-
-/**
- * STS3215 Protocol Configuration
- * These addresses and settings are specific to the STS3215 servo motors
- */
-export const STS3215_PROTOCOL: STS3215Protocol = {
-  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 Follower Configuration
- * Robot arm that performs tasks autonomously
- * Drive modes match Python lerobot exactly: all motors use drive_mode=0
- */
-export function createSO100FollowerConfig(
-  port: SerialPort
-): SO100CalibrationConfig {
-  return {
-    deviceType: "so100_follower",
-    port,
-    motorNames: SO100_MOTOR_NAMES,
-    motorIds: SO100_MOTOR_IDS,
-    protocol: STS3215_PROTOCOL,
-
-    // Python lerobot uses drive_mode=0 for all motors (current format)
-    driveModes: [0, 0, 0, 0, 0, 0],
-
-    // Calibration modes (not used in current implementation, but kept for compatibility)
-    calibModes: ["DEGREE", "DEGREE", "DEGREE", "DEGREE", "DEGREE", "LINEAR"],
-
-    // Follower limits - these are not used in calibration file format
-    limits: {
-      position_min: [-180, -90, -90, -90, -90, -90],
-      position_max: [180, 90, 90, 90, 90, 90],
-      velocity_max: [100, 100, 100, 100, 100, 100],
-      torque_max: [50, 50, 50, 50, 25, 25],
-    },
-  };
-}
-
-/**
- * SO-100 Leader Configuration
- * Teleoperator arm that humans use to control the follower
- * Drive modes match Python lerobot exactly: all motors use drive_mode=0
- */
-export function createSO100LeaderConfig(
-  port: SerialPort
-): SO100CalibrationConfig {
-  return {
-    deviceType: "so100_leader",
-    port,
-    motorNames: SO100_MOTOR_NAMES,
-    motorIds: SO100_MOTOR_IDS,
-    protocol: STS3215_PROTOCOL,
-
-    // Python lerobot uses drive_mode=0 for all motors (current format)
-    driveModes: [0, 0, 0, 0, 0, 0],
-
-    // Same calibration modes as follower
-    calibModes: ["DEGREE", "DEGREE", "DEGREE", "DEGREE", "DEGREE", "LINEAR"],
-
-    // Leader limits - these are not used in calibration file format
-    limits: {
-      position_min: [-120, -60, -60, -60, -180, -45],
-      position_max: [120, 60, 60, 60, 180, 45],
-      velocity_max: [80, 80, 80, 80, 120, 60],
-      torque_max: [30, 30, 30, 30, 20, 15],
-    },
-  };
-}
-
-/**
- * Get configuration for any SO-100 device type
- */
-export function getSO100Config(
-  deviceType: "so100_follower" | "so100_leader",
-  port: SerialPort
-): SO100CalibrationConfig {
-  switch (deviceType) {
-    case "so100_follower":
-      return createSO100FollowerConfig(port);
-    case "so100_leader":
-      return createSO100LeaderConfig(port);
-    default:
-      throw new Error(`Unknown SO-100 device type: ${deviceType}`);
-  }
-}

src/lerobot/node/find_port.ts

@@ -1,125 +0,0 @@
-/**
- * Helper to find the USB port associated with your MotorsBus.
- *
- * Example:
- * ```
- * npx lerobot find-port
- * ```
- */
-
-import { SerialPort } from "serialport";
-import { createInterface } from "readline";
-import { platform } from "os";
-import { readdir } from "fs/promises";
-import { join } from "path";
-
-/**
- * Find all available serial ports on the system
- * Mirrors Python's find_available_ports() function
- */
-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);
-    }
-  }
-}
-
-/**
- * Create readline interface for user input
- * Equivalent to Python's input() function
- */
-function createReadlineInterface() {
-  return createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-}
-
-/**
- * Prompt user for input and wait for response
- * Equivalent to Python's input() function
- */
-function waitForInput(prompt: string = ""): Promise<string> {
-  const rl = createReadlineInterface();
-  return new Promise((resolve) => {
-    if (prompt) {
-      process.stdout.write(prompt);
-    }
-    rl.on("line", (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-}
-
-/**
- * Sleep for specified milliseconds
- * Equivalent to Python's time.sleep()
- */
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Main find port function - direct port of Python find_port()
- * Maintains identical UX and messaging
- */
-export async function findPort(): Promise<void> {
-  console.log("Finding all available ports for the MotorsBus.");
-
-  const portsBefore = await findAvailablePorts();
-  console.log("Ports before disconnecting:", portsBefore);
-
-  console.log(
-    "Remove the USB cable from your MotorsBus and press Enter when done."
-  );
-  await waitForInput();
-
-  // Allow some time for port to be released (equivalent to Python's time.sleep(0.5))
-  await sleep(500);
-
-  const portsAfter = await findAvailablePorts();
-  const portsDiff = portsBefore.filter((port) => !portsAfter.includes(port));
-
-  if (portsDiff.length === 1) {
-    const port = portsDiff[0];
-    console.log(`The port of this MotorsBus is '${port}'`);
-    console.log("Reconnect the USB cable.");
-  } else if (portsDiff.length === 0) {
-    throw new Error(
-      `Could not detect the port. No difference was found (${JSON.stringify(
-        portsDiff
-      )}).`
-    );
-  } else {
-    throw new Error(
-      `Could not detect the port. More than one port was found (${JSON.stringify(
-        portsDiff
-      )}).`
-    );
-  }
-}
-
-/**
- * CLI entry point when called directly
- */
-if (import.meta.url === `file://${process.argv[1]}`) {
-  findPort().catch((error) => {
-    console.error(error.message);
-    process.exit(1);
-  });
-}

src/lerobot/node/robots/robot.ts

@@ -1,199 +0,0 @@
-/**
- * Base Robot class for Node.js platform
- * Uses serialport package for serial communication
- * Mirrors Python lerobot/common/robots/robot.py
- */
-
-import { SerialPort } from "serialport";
-import { mkdir, writeFile } from "fs/promises";
-import { existsSync, readFileSync, mkdirSync } from "fs";
-import { join } from "path";
-import type { RobotConfig } from "../types/robot-config.js";
-import { getCalibrationDir, ROBOTS } from "../utils/constants.js";
-
-export abstract class Robot {
-  protected port: SerialPort | null = null;
-  protected config: RobotConfig;
-  protected calibrationDir: string;
-  protected calibrationPath: string;
-  protected name: string;
-  protected calibration: any = {}; // Loaded calibration data
-  protected isCalibrated: boolean = false;
-
-  constructor(config: RobotConfig) {
-    this.config = config;
-    this.name = config.type;
-
-    // Determine calibration directory
-    // Mirrors Python: config.calibration_dir if config.calibration_dir else HF_LEROBOT_CALIBRATION / ROBOTS / self.name
-    this.calibrationDir =
-      config.calibration_dir || join(getCalibrationDir(), ROBOTS, this.name);
-
-    // Use robot ID or type as filename
-    const robotId = config.id || this.name;
-    this.calibrationPath = join(this.calibrationDir, `${robotId}.json`);
-
-    // Auto-load calibration if it exists (like Python version)
-    this.loadCalibration();
-  }
-
-  /**
-   * Connect to the robot
-   * Mirrors Python robot.connect()
-   */
-  async connect(_calibrate: boolean = false): Promise<void> {
-    try {
-      this.port = new SerialPort({
-        path: this.config.port,
-        baudRate: 1000000, // Default baud rate for Feetech motors (SO-100) - matches Python lerobot
-        dataBits: 8, // 8 data bits - matches Python serial.EIGHTBITS
-        stopBits: 1, // 1 stop bit - matches Python default
-        parity: "none", // No parity - matches Python default
-        autoOpen: false,
-      });
-
-      // Open the port
-      await new Promise<void>((resolve, reject) => {
-        this.port!.open((error) => {
-          if (error) {
-            reject(
-              new Error(
-                `Failed to open port ${this.config.port}: ${error.message}`
-              )
-            );
-          } else {
-            resolve();
-          }
-        });
-      });
-    } catch (error) {
-      throw new Error(`Could not connect to robot on port ${this.config.port}`);
-    }
-  }
-
-  /**
-   * Calibrate the robot
-   * Must be implemented by subclasses
-   */
-  abstract calibrate(): Promise<void>;
-
-  /**
-   * Disconnect from the robot
-   * Mirrors Python robot.disconnect()
-   */
-  async disconnect(): Promise<void> {
-    if (this.port && this.port.isOpen) {
-      // Handle torque disable if configured
-      if (this.config.disable_torque_on_disconnect) {
-        await this.disableTorque();
-      }
-
-      await new Promise<void>((resolve) => {
-        this.port!.close(() => {
-          resolve();
-        });
-      });
-
-      this.port = null;
-    }
-  }
-
-  /**
-   * Save calibration data to JSON file
-   * Mirrors Python's configuration saving
-   */
-  protected async saveCalibration(calibrationData: any): Promise<void> {
-    // Ensure calibration directory exists
-    try {
-      mkdirSync(this.calibrationDir, { recursive: true });
-    } catch (error) {
-      // Directory might already exist, that's fine
-    }
-
-    // Save calibration data as JSON
-    await writeFile(
-      this.calibrationPath,
-      JSON.stringify(calibrationData, null, 2)
-    );
-
-    console.log(`Configuration saved to: ${this.calibrationPath}`);
-  }
-
-  /**
-   * Load calibration data from JSON file
-   * Mirrors Python's _load_calibration()
-   */
-  protected loadCalibration(): void {
-    try {
-      if (existsSync(this.calibrationPath)) {
-        const calibrationData = readFileSync(this.calibrationPath, "utf8");
-        this.calibration = JSON.parse(calibrationData);
-        this.isCalibrated = true;
-        console.log(`✅ Loaded calibration from: ${this.calibrationPath}`);
-      } else {
-        console.log(
-          `⚠️  No calibration file found at: ${this.calibrationPath}`
-        );
-        this.isCalibrated = false;
-      }
-    } catch (error) {
-      console.warn(
-        `Failed to load calibration: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-      this.calibration = {};
-      this.isCalibrated = false;
-    }
-  }
-
-  /**
-   * Send command to robot via serial port
-   */
-  protected async sendCommand(command: string): Promise<void> {
-    if (!this.port || !this.port.isOpen) {
-      throw new Error("Robot not connected");
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      this.port!.write(command, (error) => {
-        if (error) {
-          reject(new Error(`Failed to send command: ${error.message}`));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
-  /**
-   * Read data from robot
-   */
-  protected async readData(timeout: number = 5000): Promise<Buffer> {
-    if (!this.port || !this.port.isOpen) {
-      throw new Error("Robot not connected");
-    }
-
-    return new Promise<Buffer>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("Read timeout"));
-      }, timeout);
-
-      this.port!.once("data", (data: Buffer) => {
-        clearTimeout(timer);
-        resolve(data);
-      });
-    });
-  }
-
-  /**
-   * Disable torque on disconnect (SO-100 specific)
-   */
-  protected async disableTorque(): Promise<void> {
-    try {
-      await this.sendCommand("TORQUE_DISABLE\r\n");
-    } catch (error) {
-      console.warn("Warning: Could not disable torque on disconnect");
-    }
-  }
-}

src/lerobot/node/robots/so100_follower.ts

@@ -1,614 +0,0 @@
-/**
- * SO-100 Follower Robot implementation for Node.js
- * Mirrors Python lerobot/common/robots/so100_follower/so100_follower.py
- */
-
-import { Robot } from "./robot.js";
-import type { RobotConfig } from "../types/robot-config.js";
-import * as readline from "readline";
-
-export class SO100Follower extends Robot {
-  constructor(config: RobotConfig) {
-    super(config);
-
-    // Validate that this is an SO-100 follower config
-    if (config.type !== "so100_follower") {
-      throw new Error(
-        `Invalid robot type: ${config.type}. Expected: so100_follower`
-      );
-    }
-  }
-
-  /**
-   * Calibrate the SO-100 follower robot
-   * NOTE: Calibration logic has been moved to shared/common/calibration.ts
-   * This method is kept for backward compatibility but delegates to the main calibrate.ts
-   */
-  async calibrate(): Promise<void> {
-    throw new Error(
-      "Direct device calibration is deprecated. Use the main calibrate.ts orchestrator instead."
-    );
-  }
-
-  /**
-   * Initialize robot communication
-   * For now, just test basic serial connectivity
-   */
-  private async initializeRobot(): Promise<void> {
-    console.log("Initializing robot communication...");
-
-    try {
-      // For SO-100, we need to implement Feetech servo protocol
-      // For now, just test that we can send/receive data
-      console.log("Testing serial port connectivity...");
-
-      // Try to ping servo ID 1 (shoulder_pan motor)
-      // This is a very basic test - real implementation needs proper Feetech protocol
-      const pingPacket = Buffer.from([0xff, 0xff, 0x01, 0x02, 0x01, 0xfb]); // Basic ping packet
-
-      if (!this.port || !this.port.isOpen) {
-        throw new Error("Serial port not open");
-      }
-
-      // Send ping packet
-      await new Promise<void>((resolve, reject) => {
-        this.port!.write(pingPacket, (error) => {
-          if (error) {
-            reject(new Error(`Failed to send ping: ${error.message}`));
-          } else {
-            resolve();
-          }
-        });
-      });
-
-      console.log("Ping packet sent successfully");
-
-      // Try to read response with shorter timeout
-      try {
-        const response = await this.readData(1000); // 1 second timeout
-        console.log(`Response received: ${response.length} bytes`);
-      } catch (error) {
-        console.log("No response received (expected for basic test)");
-      }
-    } catch (error) {
-      throw new Error(
-        `Serial communication test failed: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-    }
-
-    console.log("Robot communication test completed.");
-  }
-
-  /**
-   * Read current motor positions as a record with motor names
-   * For teleoperation use
-   */
-  async getMotorPositions(): Promise<Record<string, number>> {
-    const positions = await this.readMotorPositions();
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-
-    const result: Record<string, number> = {};
-    for (let i = 0; i < motorNames.length; i++) {
-      result[motorNames[i]] = positions[i];
-    }
-    return result;
-  }
-
-  /**
-   * Get calibration data for teleoperation
-   * Returns position limits and offsets from calibration file
-   */
-  getCalibrationLimits(): Record<string, { min: number; max: number }> {
-    if (!this.isCalibrated || !this.calibration) {
-      console.warn("No calibration data available, using default limits");
-      // Default STS3215 limits as fallback
-      return {
-        shoulder_pan: { min: 985, max: 3085 },
-        shoulder_lift: { min: 1200, max: 2800 },
-        elbow_flex: { min: 1000, max: 3000 },
-        wrist_flex: { min: 1100, max: 2900 },
-        wrist_roll: { min: 0, max: 4095 }, // Full rotation motor
-        gripper: { min: 1800, max: 2300 },
-      };
-    }
-
-    // Extract limits from calibration data (matches Python format)
-    const limits: Record<string, { min: number; max: number }> = {};
-    for (const [motorName, calibData] of Object.entries(this.calibration)) {
-      if (
-        calibData &&
-        typeof calibData === "object" &&
-        "range_min" in calibData &&
-        "range_max" in calibData
-      ) {
-        limits[motorName] = {
-          min: Number(calibData.range_min),
-          max: Number(calibData.range_max),
-        };
-      }
-    }
-
-    return limits;
-  }
-
-  /**
-   * Set motor positions from a record with motor names
-   * For teleoperation use
-   */
-  async setMotorPositions(positions: Record<string, number>): Promise<void> {
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-    const motorIds = [1, 2, 3, 4, 5, 6]; // SO-100 has servo IDs 1-6
-
-    for (let i = 0; i < motorNames.length; i++) {
-      const motorName = motorNames[i];
-      const motorId = motorIds[i];
-      const position = positions[motorName];
-
-      if (position !== undefined) {
-        await this.writeMotorPosition(motorId, position);
-      }
-    }
-  }
-
-  /**
-   * Write position to a single motor
-   * Implements STS3215 WRITE_DATA command for position control
-   */
-  private async writeMotorPosition(
-    motorId: number,
-    position: number
-  ): Promise<void> {
-    if (!this.port || !this.port.isOpen) {
-      throw new Error("Serial port not open");
-    }
-
-    // Clamp position to valid range
-    const clampedPosition = Math.max(0, Math.min(4095, Math.round(position)));
-
-    // Create STS3215 Write Position packet
-    // Format: [0xFF, 0xFF, ID, Length, Instruction, Address, Data_L, Data_H, Checksum]
-    // Goal_Position address for STS3215 is 42 (0x2A), length 2 bytes
-    const packet = Buffer.from([
-      0xff,
-      0xff, // Header
-      motorId, // Servo ID
-      0x05, // Length (Instruction + Address + Data_L + Data_H + Checksum)
-      0x03, // Instruction: WRITE_DATA
-      0x2a, // Address: Goal_Position (42)
-      clampedPosition & 0xff, // Data_L (low byte)
-      (clampedPosition >> 8) & 0xff, // Data_H (high byte)
-      0x00, // Checksum (will calculate)
-    ]);
-
-    // Calculate checksum: ~(ID + Length + Instruction + Address + Data_L + Data_H) & 0xFF
-    const checksum =
-      ~(
-        motorId +
-        0x05 +
-        0x03 +
-        0x2a +
-        (clampedPosition & 0xff) +
-        ((clampedPosition >> 8) & 0xff)
-      ) & 0xff;
-    packet[8] = checksum;
-
-    // Send write position packet
-    await new Promise<void>((resolve, reject) => {
-      this.port!.write(packet, (error) => {
-        if (error) {
-          reject(new Error(`Failed to send write packet: ${error.message}`));
-        } else {
-          resolve();
-        }
-      });
-    });
-
-    // Small delay to allow servo to process command
-    await new Promise((resolve) => setTimeout(resolve, 1));
-  }
-
-  /**
-   * Read current motor positions
-   * Implements basic STS3215 servo protocol to read actual positions
-   */
-  private async readMotorPositions(): Promise<number[]> {
-    console.log("Reading motor positions...");
-
-    const motorPositions: number[] = [];
-    const motorIds = [1, 2, 3, 4, 5, 6]; // SO-100 has servo IDs 1-6
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-
-    // Try to read position from each servo using STS3215 protocol
-    for (let i = 0; i < motorIds.length; i++) {
-      const motorId = motorIds[i];
-      const motorName = motorNames[i];
-
-      try {
-        console.log(`  Reading ${motorName} (ID ${motorId})...`);
-
-        // Create STS3215 Read Position packet
-        // Format: [0xFF, 0xFF, ID, Length, Instruction, Address, DataLength, Checksum]
-        // Present_Position address for STS3215 is 56 (0x38), length 2 bytes
-        const packet = Buffer.from([
-          0xff,
-          0xff, // Header
-          motorId, // Servo ID
-          0x04, // Length (Instruction + Address + DataLength + Checksum)
-          0x02, // Instruction: READ_DATA
-          0x38, // Address: Present_Position (56)
-          0x02, // Data Length: 2 bytes
-          0x00, // Checksum (will calculate)
-        ]);
-
-        // Calculate checksum: ~(ID + Length + Instruction + Address + DataLength) & 0xFF
-        const checksum = ~(motorId + 0x04 + 0x02 + 0x38 + 0x02) & 0xff;
-        packet[7] = checksum;
-
-        if (!this.port || !this.port.isOpen) {
-          throw new Error("Serial port not open");
-        }
-
-        // Send read position packet
-        await new Promise<void>((resolve, reject) => {
-          this.port!.write(packet, (error) => {
-            if (error) {
-              reject(new Error(`Failed to send read packet: ${error.message}`));
-            } else {
-              resolve();
-            }
-          });
-        });
-
-        // Try to read response (timeout after 500ms)
-        try {
-          const response = await this.readData(500);
-
-          if (response.length >= 7) {
-            // Parse response: [0xFF, 0xFF, ID, Length, Error, Data_L, Data_H, Checksum]
-            const id = response[2];
-            const error = response[4];
-
-            if (id === motorId && error === 0) {
-              // Extract 16-bit position from Data_L and Data_H
-              const position = response[5] | (response[6] << 8);
-              motorPositions.push(position);
-
-              // Show calibrated range if available
-              const calibratedLimits = this.getCalibrationLimits();
-              const limits = calibratedLimits[motorName];
-              const rangeText = limits
-                ? `(${limits.min}-${limits.max} calibrated)`
-                : `(0-4095 raw)`;
-              console.log(`    ${motorName}: ${position} ${rangeText}`);
-            } else {
-              console.warn(
-                `    ${motorName}: Error response (error code: ${error})`
-              );
-              motorPositions.push(2047); // Use center position as fallback
-            }
-          } else {
-            console.warn(`    ${motorName}: Invalid response length`);
-            motorPositions.push(2047); // Use center position as fallback
-          }
-        } catch (readError) {
-          console.warn(
-            `    ${motorName}: Read timeout - using fallback position`
-          );
-          motorPositions.push(2047); // Use center position as fallback
-        }
-      } catch (error) {
-        console.warn(
-          `    ${motorName}: Communication error - ${
-            error instanceof Error ? error.message : error
-          }`
-        );
-        motorPositions.push(2047); // Use center position as fallback
-      }
-
-      // Small delay between servo reads
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-
-    console.log(`Motor positions: [${motorPositions.join(", ")}]`);
-    return motorPositions;
-  }
-
-  /**
-   * Set motor limits and safety parameters
-   * TODO: Implement proper Feetech servo protocol
-   */
-  private async setMotorLimits(): Promise<any> {
-    console.log("Setting motor limits...");
-
-    // Set default limits for SO-100 (based on Python implementation)
-    const limits = {
-      position_min: [-180, -90, -90, -90, -90, -90],
-      position_max: [180, 90, 90, 90, 90, 90],
-      velocity_max: [100, 100, 100, 100, 100, 100],
-      torque_max: [50, 50, 50, 50, 25, 25],
-    };
-
-    // For now, just return the limits without sending to robot
-    // Real implementation needs Feetech servo protocol to set limits
-    console.log("Motor limits configured (mock).");
-    return limits;
-  }
-
-  /**
-   * Interactive calibration process - matches Python lerobot calibration flow
-   * Implements real calibration with user interaction
-   */
-  private async calibrateMotors(): Promise<any> {
-    console.log("\n=== INTERACTIVE CALIBRATION ===");
-    console.log("Starting SO-100 follower arm calibration...");
-
-    // Step 1: Move to middle position and record homing offsets
-    console.log("\n📍 STEP 1: Set Homing Position");
-    await this.promptUser(
-      "Move the SO-100 to the MIDDLE of its range of motion and press ENTER..."
-    );
-
-    const homingOffsets = await this.setHomingOffsets();
-
-    // Step 2: Record ranges of motion
-    console.log("\n📏 STEP 2: Record Joint Ranges");
-    const { rangeMins, rangeMaxes } = await this.recordRangesOfMotion();
-
-    // Step 3: Set special range for wrist_roll (full turn motor)
-    console.log("\n🔄 STEP 3: Configure Full-Turn Motor");
-    console.log("Setting wrist_roll as full-turn motor (0-4095 range)");
-    rangeMins["wrist_roll"] = 0;
-    rangeMaxes["wrist_roll"] = 4095;
-
-    // Step 4: Compile calibration results
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-    const results = [];
-
-    for (let i = 0; i < motorNames.length; i++) {
-      const motorId = i + 1; // Servo IDs are 1-6
-      const motorName = motorNames[i];
-
-      results.push({
-        motor: motorId,
-        name: motorName,
-        status: "success",
-        homing_offset: homingOffsets[motorName],
-        range_min: rangeMins[motorName],
-        range_max: rangeMaxes[motorName],
-        range_size: rangeMaxes[motorName] - rangeMins[motorName],
-      });
-
-      console.log(
-        `✅ ${motorName} calibrated: range ${rangeMins[motorName]} to ${rangeMaxes[motorName]} (offset: ${homingOffsets[motorName]})`
-      );
-    }
-
-    console.log("\n🎉 Interactive calibration completed!");
-    return results;
-  }
-
-  /**
-   * Verify calibration was successful
-   * TODO: Implement proper verification with Feetech servo protocol
-   */
-  private async verifyCalibration(): Promise<void> {
-    console.log("Verifying calibration...");
-
-    // For now, just mock successful verification
-    // Real implementation should check:
-    // 1. All motors respond to ping
-    // 2. Position limits are set correctly
-    // 3. Homing offsets are applied
-    // 4. Motors can move to test positions
-
-    console.log("Calibration verification passed (mock).");
-  }
-
-  /**
-   * Prompt user for input (like Python's input() function)
-   */
-  private async promptUser(message: string): Promise<string> {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    return new Promise((resolve) => {
-      rl.question(message, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    });
-  }
-
-  /**
-   * Record homing offsets (current positions as center)
-   * Mirrors Python bus.set_half_turn_homings()
-   */
-  private async setHomingOffsets(): Promise<{ [motor: string]: number }> {
-    console.log("Recording current positions as homing offsets...");
-
-    const currentPositions = await this.readMotorPositions();
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-    const homingOffsets: { [motor: string]: number } = {};
-
-    for (let i = 0; i < motorNames.length; i++) {
-      const motorName = motorNames[i];
-      const position = currentPositions[i];
-      // Calculate homing offset (half turn offset from current position)
-      const maxRes = 4095; // STS3215 resolution
-      homingOffsets[motorName] = position - Math.floor(maxRes / 2);
-      console.log(
-        `  ${motorName}: offset ${homingOffsets[motorName]} (current pos: ${position})`
-      );
-    }
-
-    return homingOffsets;
-  }
-
-  /**
-   * Record ranges of motion by continuously reading positions
-   * Mirrors Python bus.record_ranges_of_motion()
-   */
-  private async recordRangesOfMotion(): Promise<{
-    rangeMins: { [motor: string]: number };
-    rangeMaxes: { [motor: string]: number };
-  }> {
-    console.log("\n=== RECORDING RANGES OF MOTION ===");
-    console.log(
-      "Move all joints sequentially through their entire ranges of motion."
-    );
-    console.log(
-      "Positions will be recorded continuously. Press ENTER to stop...\n"
-    );
-
-    const motorNames = [
-      "shoulder_pan",
-      "shoulder_lift",
-      "elbow_flex",
-      "wrist_flex",
-      "wrist_roll",
-      "gripper",
-    ];
-    const rangeMins: { [motor: string]: number } = {};
-    const rangeMaxes: { [motor: string]: number } = {};
-
-    // Initialize with current positions
-    const initialPositions = await this.readMotorPositions();
-    for (let i = 0; i < motorNames.length; i++) {
-      const motorName = motorNames[i];
-      const position = initialPositions[i];
-      rangeMins[motorName] = position;
-      rangeMaxes[motorName] = position;
-    }
-
-    let recording = true;
-    let readCount = 0;
-
-    // Set up readline to detect Enter key
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    rl.on("line", () => {
-      recording = false;
-      rl.close();
-    });
-
-    console.log("Recording started... (move the robot joints now)");
-
-    // Continuous recording loop
-    while (recording) {
-      try {
-        const positions = await this.readMotorPositions();
-        readCount++;
-
-        // Update min/max ranges
-        for (let i = 0; i < motorNames.length; i++) {
-          const motorName = motorNames[i];
-          const position = positions[i];
-
-          if (position < rangeMins[motorName]) {
-            rangeMins[motorName] = position;
-          }
-          if (position > rangeMaxes[motorName]) {
-            rangeMaxes[motorName] = position;
-          }
-        }
-
-        // Show real-time feedback every 10 reads
-        if (readCount % 10 === 0) {
-          console.clear(); // Clear screen for live update
-          console.log("=== LIVE POSITION RECORDING ===");
-          console.log(`Readings: ${readCount} | Press ENTER to stop\n`);
-
-          console.log("Motor Name       Current    Min      Max      Range");
-          console.log("─".repeat(55));
-
-          for (let i = 0; i < motorNames.length; i++) {
-            const motorName = motorNames[i];
-            const current = positions[i];
-            const min = rangeMins[motorName];
-            const max = rangeMaxes[motorName];
-            const range = max - min;
-
-            console.log(
-              `${motorName.padEnd(15)} ${current.toString().padStart(6)} ${min
-                .toString()
-                .padStart(6)} ${max.toString().padStart(6)} ${range
-                .toString()
-                .padStart(8)}`
-            );
-          }
-          console.log("\nMove joints through their full range...");
-        }
-
-        // Small delay to avoid overwhelming the serial port
-        await new Promise((resolve) => setTimeout(resolve, 50));
-      } catch (error) {
-        console.warn(
-          `Read error: ${error instanceof Error ? error.message : error}`
-        );
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-    }
-
-    console.log(`\nRecording stopped after ${readCount} readings.`);
-    console.log("\nFinal ranges recorded:");
-
-    for (const motorName of motorNames) {
-      const min = rangeMins[motorName];
-      const max = rangeMaxes[motorName];
-      const range = max - min;
-      console.log(`  ${motorName}: ${min} to ${max} (range: ${range})`);
-    }
-
-    return { rangeMins, rangeMaxes };
-  }
-}
-
-/**
- * Factory function to create SO-100 follower robot
- * Mirrors Python's make_robot_from_config pattern
- */
-export function createSO100Follower(config: RobotConfig): SO100Follower {
-  return new SO100Follower(config);
-}

src/lerobot/node/teleoperate.ts

@@ -1,316 +0,0 @@
-/**
- * Robot teleoperation using keyboard control
- *
- * Example:
- * ```
- * npx lerobot teleoperate --robot.type=so100_follower --robot.port=COM4 --teleop.type=keyboard
- * ```
- */
-
-import { createSO100Follower } from "./robots/so100_follower.js";
-import { KeyboardController } from "./utils/keyboard-teleop.js";
-import type { TeleoperateConfig } from "./types/teleoperation.js";
-
-/**
- * Main teleoperate function
- * Mirrors Python lerobot teleoperate.py structure
- */
-export async function teleoperate(config: TeleoperateConfig): Promise<void> {
-  // Validate configuration
-  if (!config.robot) {
-    throw new Error("Robot configuration is required");
-  }
-
-  if (!config.teleop || config.teleop.type !== "keyboard") {
-    throw new Error("Only keyboard teleoperation is currently supported");
-  }
-
-  const stepSize = config.step_size || 25;
-  const duration = config.duration_s;
-
-  let robot;
-  let keyboardController;
-
-  try {
-    // Create robot
-    switch (config.robot.type) {
-      case "so100_follower":
-        robot = createSO100Follower(config.robot);
-        break;
-      default:
-        throw new Error(`Unsupported robot type: ${config.robot.type}`);
-    }
-
-    console.log(
-      `Connecting to robot: ${config.robot.type} on ${config.robot.port}`
-    );
-    if (config.robot.id) {
-      console.log(`Robot ID: ${config.robot.id}`);
-    }
-
-    await robot.connect(false); // calibrate=false
-    console.log("Robot connected successfully.");
-
-    // Show calibration status
-    const isCalibrated = (robot as any).isCalibrated;
-    if (isCalibrated) {
-      console.log(
-        `✅ Loaded calibration for: ${config.robot.id || config.robot.type}`
-      );
-    } else {
-      console.log(
-        `⚠️  No calibration found for: ${
-          config.robot.id || config.robot.type
-        } (using defaults)`
-      );
-      console.log(
-        "   Run 'npx lerobot calibrate' first for optimal performance!"
-      );
-    }
-
-    // Create keyboard controller
-    keyboardController = new KeyboardController(robot, stepSize);
-
-    console.log("");
-    console.log("Starting keyboard teleoperation...");
-    console.log("Controls:");
-    console.log("  ↑↓ Arrow Keys: Shoulder Lift");
-    console.log("  ←→ Arrow Keys: Shoulder Pan");
-    console.log("  W/S: Elbow Flex");
-    console.log("  A/D: Wrist Flex");
-    console.log("  Q/E: Wrist Roll");
-    console.log("  Space: Gripper Toggle");
-    console.log("  ESC: Emergency Stop");
-    console.log("  Ctrl+C: Exit");
-    console.log("");
-    console.log("Press any control key to begin...");
-    console.log("");
-
-    // Start teleoperation control loop
-    await teleoperationLoop(keyboardController, robot, duration || null);
-  } catch (error) {
-    // Ensure we disconnect even if there's an error
-    if (keyboardController) {
-      try {
-        await keyboardController.stop();
-      } catch (stopError) {
-        console.warn("Warning: Failed to stop keyboard controller properly");
-      }
-    }
-    if (robot) {
-      try {
-        await robot.disconnect();
-      } catch (disconnectError) {
-        console.warn("Warning: Failed to disconnect robot properly");
-      }
-    }
-    throw error;
-  }
-}
-
-/**
- * Main teleoperation control loop
- */
-async function teleoperationLoop(
-  keyboardController: KeyboardController,
-  robot: any,
-  duration: number | null
-): Promise<void> {
-  console.log("Initializing teleoperation...");
-
-  // Start keyboard controller
-  await keyboardController.start();
-
-  const startTime = performance.now();
-
-  // Set up graceful shutdown
-  let running = true;
-  process.on("SIGINT", () => {
-    console.log("\nShutting down gracefully...");
-    running = false;
-  });
-
-  try {
-    // Just wait for the keyboard controller to handle everything
-    while (running) {
-      // Check duration limit
-      if (duration && performance.now() - startTime >= duration * 1000) {
-        console.log(`\nDuration limit reached (${duration}s). Stopping...`);
-        break;
-      }
-
-      // Small delay to prevent busy waiting
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  } finally {
-    console.log("\nStopping teleoperation...");
-    await keyboardController.stop();
-    await robot.disconnect();
-    console.log("Teleoperation stopped.");
-  }
-}
-
-/**
- * Parse command line arguments in Python argparse style
- * Handles --robot.type=so100_follower --teleop.type=keyboard format
- */
-export function parseArgs(args: string[]): TeleoperateConfig {
-  const config: Partial<TeleoperateConfig> = {};
-
-  for (const arg of args) {
-    if (arg.startsWith("--robot.")) {
-      if (!config.robot) {
-        config.robot = { type: "so100_follower", port: "" };
-      }
-
-      const [key, value] = arg.substring(8).split("=");
-      switch (key) {
-        case "type":
-          if (value !== "so100_follower") {
-            throw new Error(`Unsupported robot type: ${value}`);
-          }
-          config.robot.type = value as "so100_follower";
-          break;
-        case "port":
-          config.robot.port = value;
-          break;
-        case "id":
-          config.robot.id = value;
-          break;
-        default:
-          throw new Error(`Unknown robot parameter: ${key}`);
-      }
-    } else if (arg.startsWith("--teleop.")) {
-      if (!config.teleop) {
-        config.teleop = { type: "keyboard" };
-      }
-
-      const [key, value] = arg.substring(9).split("=");
-      switch (key) {
-        case "type":
-          if (value !== "keyboard") {
-            throw new Error(`Unsupported teleoperator type: ${value}`);
-          }
-          config.teleop.type = value as "keyboard";
-          break;
-        default:
-          throw new Error(`Unknown teleoperator parameter: ${key}`);
-      }
-    } else if (arg.startsWith("--fps=")) {
-      config.fps = parseInt(arg.substring(6));
-      if (isNaN(config.fps) || config.fps <= 0) {
-        throw new Error("FPS must be a positive number");
-      }
-    } else if (arg.startsWith("--step_size=")) {
-      config.step_size = parseInt(arg.substring(12));
-      if (isNaN(config.step_size) || config.step_size <= 0) {
-        throw new Error("Step size must be a positive number");
-      }
-    } else if (arg.startsWith("--duration_s=")) {
-      config.duration_s = parseInt(arg.substring(13));
-      if (isNaN(config.duration_s) || config.duration_s <= 0) {
-        throw new Error("Duration must be a positive number");
-      }
-    } else if (arg === "--help" || arg === "-h") {
-      showUsage();
-      process.exit(0);
-    } else if (!arg.startsWith("--")) {
-      // Skip non-option arguments
-      continue;
-    } else {
-      throw new Error(`Unknown argument: ${arg}`);
-    }
-  }
-
-  // Validate required fields
-  if (!config.robot?.port) {
-    throw new Error("Robot port is required (--robot.port=PORT)");
-  }
-  if (!config.teleop?.type) {
-    throw new Error("Teleoperator type is required (--teleop.type=keyboard)");
-  }
-
-  return config as TeleoperateConfig;
-}
-
-/**
- * Show usage information matching Python argparse output
- */
-function showUsage(): void {
-  console.log("Usage: lerobot teleoperate [options]");
-  console.log("");
-  console.log("Control a robot using keyboard input");
-  console.log("");
-  console.log("Options:");
-  console.log("  --robot.type=TYPE        Robot type (so100_follower)");
-  console.log(
-    "  --robot.port=PORT        Robot serial port (e.g., COM4, /dev/ttyUSB0)"
-  );
-  console.log("  --robot.id=ID            Robot identifier");
-  console.log("  --teleop.type=TYPE       Teleoperator type (keyboard)");
-  console.log(
-    "  --fps=FPS                Control loop frame rate (default: 60)"
-  );
-  console.log(
-    "  --step_size=SIZE         Position step size per keypress (default: 10)"
-  );
-  console.log("  --duration_s=SECONDS     Teleoperation duration in seconds");
-  console.log("  -h, --help               Show this help message");
-  console.log("");
-  console.log("Keyboard Controls:");
-  console.log("  ↑↓ Arrow Keys            Shoulder Lift");
-  console.log("  ←→ Arrow Keys            Shoulder Pan");
-  console.log("  W/S                      Elbow Flex");
-  console.log("  A/D                      Wrist Flex");
-  console.log("  Q/E                      Wrist Roll");
-  console.log("  Space                    Gripper Toggle");
-  console.log("  ESC                      Emergency Stop");
-  console.log("  Ctrl+C                   Exit");
-  console.log("");
-  console.log("Examples:");
-  console.log(
-    "  lerobot teleoperate --robot.type=so100_follower --robot.port=COM4 --teleop.type=keyboard"
-  );
-  console.log(
-    "  lerobot teleoperate --robot.type=so100_follower --robot.port=COM4 --teleop.type=keyboard --fps=30 --step_size=50"
-  );
-  console.log("");
-  console.log("Use 'lerobot find-port' to discover available ports.");
-}
-
-/**
- * CLI entry point when called directly
- * Mirrors Python's if __name__ == "__main__": pattern
- */
-export async function main(args: string[]): Promise<void> {
-  try {
-    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-      showUsage();
-      return;
-    }
-
-    const config = parseArgs(args);
-    await teleoperate(config);
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error("Error:", error.message);
-    } else {
-      console.error("Error:", error);
-    }
-
-    console.error("");
-    console.error("Please verify:");
-    console.error("1. The robot is connected to the specified port");
-    console.error("2. No other application is using the port");
-    console.error("3. You have permission to access the port");
-    console.error("");
-    console.error("Use 'lerobot find-port' to discover available ports.");
-
-    process.exit(1);
-  }
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const args = process.argv.slice(2);
-  main(args);
-}

src/lerobot/node/teleoperators/so100_leader.ts

@@ -1,41 +0,0 @@
-/**
- * SO-100 Leader Teleoperator implementation for Node.js
- *
- * Minimal implementation - calibration logic moved to shared/common/calibration.ts
- * This class only handles connection management and basic device operations
- */
-
-import { Teleoperator } from "./teleoperator.js";
-import type { TeleoperatorConfig } from "../types/teleoperator-config.js";
-
-export class SO100Leader extends Teleoperator {
-  constructor(config: TeleoperatorConfig) {
-    super(config);
-
-    // Validate that this is an SO-100 leader config
-    if (config.type !== "so100_leader") {
-      throw new Error(
-        `Invalid teleoperator type: ${config.type}. Expected: so100_leader`
-      );
-    }
-  }
-
-  /**
-   * Calibrate the SO-100 leader teleoperator
-   * NOTE: Calibration logic has been moved to shared/common/calibration.ts
-   * This method is kept for backward compatibility but delegates to the main calibrate.ts
-   */
-  async calibrate(): Promise<void> {
-    throw new Error(
-      "Direct device calibration is deprecated. Use the main calibrate.ts orchestrator instead."
-    );
-  }
-}
-
-/**
- * Factory function to create SO-100 leader teleoperator
- * Mirrors Python's make_teleoperator_from_config pattern
- */
-export function createSO100Leader(config: TeleoperatorConfig): SO100Leader {
-  return new SO100Leader(config);
-}

src/lerobot/node/teleoperators/teleoperator.ts

@@ -1,148 +0,0 @@
-/**
- * Base Teleoperator class for Node.js platform
- * Uses serialport package for serial communication
- * Mirrors Python lerobot/common/teleoperators/teleoperator.py
- */
-
-import { SerialPort } from "serialport";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import type { TeleoperatorConfig } from "../types/teleoperator-config.js";
-import { getCalibrationDir, TELEOPERATORS } from "../utils/constants.js";
-
-export abstract class Teleoperator {
-  protected port: SerialPort | null = null;
-  protected config: TeleoperatorConfig;
-  protected calibrationDir: string;
-  protected calibrationPath: string;
-  protected name: string;
-
-  constructor(config: TeleoperatorConfig) {
-    this.config = config;
-    this.name = config.type;
-
-    // Determine calibration directory
-    // Mirrors Python: config.calibration_dir if config.calibration_dir else HF_LEROBOT_CALIBRATION / TELEOPERATORS / self.name
-    this.calibrationDir =
-      config.calibration_dir ||
-      join(getCalibrationDir(), TELEOPERATORS, this.name);
-
-    // Use teleoperator ID or type as filename
-    const teleopId = config.id || this.name;
-    this.calibrationPath = join(this.calibrationDir, `${teleopId}.json`);
-  }
-
-  /**
-   * Connect to the teleoperator
-   * Mirrors Python teleoperator.connect()
-   */
-  async connect(_calibrate: boolean = false): Promise<void> {
-    try {
-      this.port = new SerialPort({
-        path: this.config.port,
-        baudRate: 1000000, // Correct baud rate for Feetech motors (SO-100) - matches Python lerobot
-        dataBits: 8, // 8 data bits - matches Python serial.EIGHTBITS
-        stopBits: 1, // 1 stop bit - matches Python default
-        parity: "none", // No parity - matches Python default
-        autoOpen: false,
-      });
-
-      // Open the port
-      await new Promise<void>((resolve, reject) => {
-        this.port!.open((error) => {
-          if (error) {
-            reject(
-              new Error(
-                `Failed to open port ${this.config.port}: ${error.message}`
-              )
-            );
-          } else {
-            resolve();
-          }
-        });
-      });
-    } catch (error) {
-      throw new Error(
-        `Could not connect to teleoperator on port ${this.config.port}`
-      );
-    }
-  }
-
-  /**
-   * Calibrate the teleoperator
-   * Must be implemented by subclasses
-   */
-  abstract calibrate(): Promise<void>;
-
-  /**
-   * Disconnect from the teleoperator
-   * Mirrors Python teleoperator.disconnect()
-   */
-  async disconnect(): Promise<void> {
-    if (this.port && this.port.isOpen) {
-      await new Promise<void>((resolve) => {
-        this.port!.close(() => {
-          resolve();
-        });
-      });
-
-      this.port = null;
-    }
-  }
-
-  /**
-   * Save calibration data to JSON file
-   * Mirrors Python's configuration saving
-   */
-  protected async saveCalibration(calibrationData: any): Promise<void> {
-    // Ensure calibration directory exists
-    await mkdir(this.calibrationDir, { recursive: true });
-
-    // Save calibration data as JSON
-    await writeFile(
-      this.calibrationPath,
-      JSON.stringify(calibrationData, null, 2)
-    );
-
-    console.log(`Configuration saved to: ${this.calibrationPath}`);
-  }
-
-  /**
-   * Send command to teleoperator via serial port
-   */
-  protected async sendCommand(command: string): Promise<void> {
-    if (!this.port || !this.port.isOpen) {
-      throw new Error("Teleoperator not connected");
-    }
-
-    return new Promise<void>((resolve, reject) => {
-      this.port!.write(command, (error) => {
-        if (error) {
-          reject(new Error(`Failed to send command: ${error.message}`));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
-  /**
-   * Read data from teleoperator
-   */
-  protected async readData(timeout: number = 5000): Promise<Buffer> {
-    if (!this.port || !this.port.isOpen) {
-      throw new Error("Teleoperator not connected");
-    }
-
-    return new Promise<Buffer>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        reject(new Error("Read timeout"));
-      }, timeout);
-
-      this.port!.once("data", (data: Buffer) => {
-        clearTimeout(timer);
-        resolve(data);
-      });
-    });
-  }
-}

src/lerobot/node/types/calibration.ts

@@ -1,45 +0,0 @@
-/**
- * Calibration types for Node.js implementation
- */
-
-import type { SerialPort } from "serialport";
-
-export interface SO100CalibrationConfig {
-  deviceType: "so100_follower" | "so100_leader";
-  port: SerialPort;
-  motorNames: string[];
-  motorIds: number[]; // Device-specific motor IDs (e.g., [1,2,3,4,5,6] for SO-100)
-  driveModes: number[];
-  calibModes: string[];
-
-  // Protocol-specific configuration
-  protocol: {
-    resolution: number; // Motor resolution (e.g., 4096 for STS3215)
-    homingOffsetAddress: number; // Register address for homing offset (e.g., 31 for STS3215)
-    homingOffsetLength: number; // Length in bytes for homing offset register
-    presentPositionAddress: number; // Register address for present position (e.g., 56 for STS3215)
-    presentPositionLength: number; // Length in bytes for present position register
-    minPositionLimitAddress: number; // Register address for min position limit (e.g., 9 for STS3215)
-    minPositionLimitLength: number; // Length in bytes for min position limit register
-    maxPositionLimitAddress: number; // Register address for max position limit (e.g., 11 for STS3215)
-    maxPositionLimitLength: number; // Length in bytes for max position limit register
-    signMagnitudeBit: number; // Sign bit index for homing offset encoding (e.g., 11 for STS3215)
-  };
-
-  limits: {
-    position_min: number[];
-    position_max: number[];
-    velocity_max: number[];
-    torque_max: number[];
-  };
-}
-
-export interface CalibrationResults {
-  [motorName: string]: {
-    id: number;
-    drive_mode: number;
-    homing_offset: number;
-    range_min: number;
-    range_max: number;
-  };
-}

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

@@ -1,23 +0,0 @@
-/**
- * Robot configuration types for Node.js implementation
- */
-
-export interface RobotConfig {
-  type: "so100_follower";
-  port: string;
-  id?: string;
-  calibration_dir?: string;
-  // SO-100 specific options
-  disable_torque_on_disconnect?: boolean;
-  max_relative_target?: number | null;
-  use_degrees?: boolean;
-}
-
-export interface CalibrateConfig {
-  robot?: RobotConfig;
-  teleop?: TeleoperatorConfig;
-}
-
-// Re-export from teleoperator-config for convenience
-import type { TeleoperatorConfig } from "./teleoperator-config.js";
-export type { TeleoperatorConfig };

src/lerobot/node/types/teleoperation.ts

@@ -1,17 +0,0 @@
-/**
- * Teleoperation types for Node.js implementation
- */
-
-import type { RobotConfig } from "./robot-config.js";
-
-export interface TeleoperateConfig {
-  robot: RobotConfig;
-  teleop: KeyboardTeleoperationConfig;
-  fps?: number; // Default: 60
-  step_size?: number; // Default: 10 (motor position units)
-  duration_s?: number | null; // Default: null (infinite)
-}
-
-export interface KeyboardTeleoperationConfig {
-  type: "keyboard"; // Only keyboard for now, expandable later
-}

src/lerobot/node/types/teleoperator-config.ts

@@ -1,11 +0,0 @@
-/**
- * Teleoperator configuration types for Node.js implementation
- */
-
-export interface TeleoperatorConfig {
-  type: "so100_leader";
-  port: string;
-  id?: string;
-  calibration_dir?: string;
-  // SO-100 leader specific options
-}

src/lerobot/node/utils/constants.ts

@@ -1,48 +0,0 @@
-/**
- * Constants for lerobot.js
- * Mirrors Python lerobot/common/constants.py
- */
-
-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
- */
-export function getHfHome(): string {
-  if (process.env.HF_HOME) {
-    return process.env.HF_HOME;
-  }
-
-  const homeDir = homedir();
-  return join(homeDir, ".cache", "huggingface");
-}
-
-/**
- * Get HF lerobot home directory
- * Equivalent to Python's HF_LEROBOT_HOME
- */
-export function getHfLerobotHome(): string {
-  if (process.env.HF_LEROBOT_HOME) {
-    return process.env.HF_LEROBOT_HOME;
-  }
-
-  return join(getHfHome(), "lerobot");
-}
-
-/**
- * Get calibration directory
- * Equivalent to Python's HF_LEROBOT_CALIBRATION
- */
-export function getCalibrationDir(): string {
-  if (process.env.HF_LEROBOT_CALIBRATION) {
-    return process.env.HF_LEROBOT_CALIBRATION;
-  }
-
-  return join(getHfLerobotHome(), "calibration");
-}

src/lerobot/node/utils/keyboard-teleop.ts

@@ -1,284 +0,0 @@
-/**
- * Keyboard teleoperation controller for Node.js terminal
- * Handles raw keyboard input and robot position control using the keypress package.
- */
-
-import * as readline from "readline";
-import { SO100Follower } from "../robots/so100_follower.js";
-
-/**
- * Keyboard controller for robot teleoperation
- * Handles terminal keyboard input and robot position updates
- */
-export class KeyboardController {
-  private robot: SO100Follower;
-  private stepSize: number;
-  private currentPositions: Record<string, number> = {};
-  private motorNames = [
-    "shoulder_pan",
-    "shoulder_lift",
-    "elbow_flex",
-    "wrist_flex",
-    "wrist_roll",
-    "gripper",
-  ];
-  private running = false;
-  private gripperState = false; // Toggle state for gripper
-
-  constructor(robot: SO100Follower, stepSize: number = 25) {
-    this.robot = robot;
-    this.stepSize = stepSize;
-  }
-
-  /**
-   * Start keyboard teleoperation
-   * Sets up raw keyboard input and initializes robot positions
-   */
-  async start(): Promise<void> {
-    console.log("Initializing keyboard controller...");
-
-    // Initialize current positions from robot
-    try {
-      this.currentPositions = await this.readRobotPositions();
-    } catch (error) {
-      console.warn(
-        "Could not read initial robot positions, using calibrated centers"
-      );
-      // Initialize with calibrated center positions if available, otherwise use middle positions
-      const calibratedLimits = this.robot.getCalibrationLimits();
-      this.motorNames.forEach((motor) => {
-        const limits = calibratedLimits[motor];
-        const centerPosition = limits
-          ? Math.floor((limits.min + limits.max) / 2)
-          : 2047;
-        this.currentPositions[motor] = centerPosition;
-      });
-    }
-
-    // Set up raw keyboard input
-    this.setupKeyboardInput();
-    this.running = true;
-
-    console.log("Keyboard controller ready. Use controls to move robot.");
-  }
-
-  /**
-   * Stop keyboard teleoperation
-   * Cleans up keyboard input handling
-   */
-  async stop(): Promise<void> {
-    this.running = false;
-
-    // Reset terminal to normal mode
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(false);
-    }
-    process.stdin.removeAllListeners("keypress");
-
-    console.log("Keyboard controller stopped.");
-  }
-
-  /**
-   * Get current robot positions
-   */
-  async getCurrentPositions(): Promise<Record<string, number>> {
-    return { ...this.currentPositions };
-  }
-
-  /**
-   * Set up keyboard input handling
-   * Uses readline for cross-platform keyboard input
-   */
-  private setupKeyboardInput(): void {
-    // Set up raw mode for immediate key response
-    if (process.stdin.setRawMode) {
-      process.stdin.setRawMode(true);
-    }
-    process.stdin.resume();
-    process.stdin.setEncoding("utf8");
-
-    // Handle keyboard input
-    process.stdin.on("data", (key: string) => {
-      if (!this.running) return;
-
-      this.handleKeyPress(key);
-    });
-  }
-
-  /**
-   * Handle individual key presses
-   * Maps keys to robot motor movements
-   */
-  private async handleKeyPress(key: string): Promise<void> {
-    let positionChanged = false;
-    const newPositions = { ...this.currentPositions };
-
-    // Handle arrow keys first (they start with ESC but are multi-byte sequences)
-    if (key.startsWith("\u001b[")) {
-      const arrowKey = key.slice(2);
-      switch (arrowKey) {
-        case "A": // Up arrow
-          newPositions.shoulder_lift += this.stepSize;
-          positionChanged = true;
-          break;
-        case "B": // Down arrow
-          newPositions.shoulder_lift -= this.stepSize;
-          positionChanged = true;
-          break;
-        case "C": // Right arrow
-          newPositions.shoulder_pan += this.stepSize;
-          positionChanged = true;
-          break;
-        case "D": // Left arrow
-          newPositions.shoulder_pan -= this.stepSize;
-          positionChanged = true;
-          break;
-      }
-    } else {
-      // Handle single character keys
-      const keyCode = key.charCodeAt(0);
-
-      switch (keyCode) {
-        // Standalone ESC key (emergency stop)
-        case 27:
-          if (key.length === 1) {
-            console.log("\n🛑 EMERGENCY STOP!");
-            await this.emergencyStop();
-            return;
-          }
-          break;
-
-        // Regular character keys
-        case 119: // 'w'
-          newPositions.elbow_flex += this.stepSize;
-          positionChanged = true;
-          break;
-        case 115: // 's'
-          newPositions.elbow_flex -= this.stepSize;
-          positionChanged = true;
-          break;
-        case 97: // 'a'
-          newPositions.wrist_flex -= this.stepSize;
-          positionChanged = true;
-          break;
-        case 100: // 'd'
-          newPositions.wrist_flex += this.stepSize;
-          positionChanged = true;
-          break;
-        case 113: // 'q'
-          newPositions.wrist_roll -= this.stepSize;
-          positionChanged = true;
-          break;
-        case 101: // 'e'
-          newPositions.wrist_roll += this.stepSize;
-          positionChanged = true;
-          break;
-        case 32: // Space
-          // Toggle gripper
-          this.gripperState = !this.gripperState;
-          newPositions.gripper = this.gripperState ? 2300 : 1800;
-          positionChanged = true;
-          break;
-
-        // Ctrl+C
-        case 3:
-          console.log("\nExiting...");
-          process.exit(0);
-      }
-    }
-
-    if (positionChanged) {
-      // Apply position limits using calibration
-      this.enforcePositionLimits(newPositions);
-
-      // Update robot positions - only send changed motors for better performance
-      try {
-        await this.writeRobotPositions(newPositions);
-        this.currentPositions = newPositions;
-      } catch (error) {
-        console.warn(
-          `Failed to update robot positions: ${
-            error instanceof Error ? error.message : error
-          }`
-        );
-      }
-    }
-  }
-
-  /**
-   * Read current positions from robot
-   * Uses SO100Follower position reading methods
-   */
-  private async readRobotPositions(): Promise<Record<string, number>> {
-    try {
-      return await this.robot.getMotorPositions();
-    } catch (error) {
-      console.warn(
-        `Failed to read robot positions: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-      // Return default positions as fallback
-      const positions: Record<string, number> = {};
-      this.motorNames.forEach((motor, index) => {
-        positions[motor] = 2047; // STS3215 middle position
-      });
-      return positions;
-    }
-  }
-
-  /**
-   * Write positions to robot - optimized to only send changed motors
-   * This was the key to the smooth performance in the working version
-   */
-  private async writeRobotPositions(
-    newPositions: Record<string, number>
-  ): Promise<void> {
-    // Only send commands for motors that actually changed
-    const changedPositions: Record<string, number> = {};
-    let hasChanges = false;
-
-    for (const [motor, newPosition] of Object.entries(newPositions)) {
-      if (Math.abs(this.currentPositions[motor] - newPosition) > 0.5) {
-        changedPositions[motor] = newPosition;
-        hasChanges = true;
-      }
-    }
-
-    if (hasChanges) {
-      await this.robot.setMotorPositions(changedPositions);
-    }
-  }
-
-  /**
-   * Enforce position limits based on calibration data
-   * Uses actual calibrated limits instead of hardcoded defaults
-   */
-  private enforcePositionLimits(positions: Record<string, number>): void {
-    // Get calibrated limits from robot
-    const calibratedLimits = this.robot.getCalibrationLimits();
-
-    for (const [motor, position] of Object.entries(positions)) {
-      const limits = calibratedLimits[motor];
-      if (limits) {
-        positions[motor] = Math.max(limits.min, Math.min(limits.max, position));
-      }
-    }
-  }
-
-  /**
-   * Emergency stop - halt all robot movement
-   */
-  private async emergencyStop(): Promise<void> {
-    try {
-      // Stop all robot movement
-      // TODO: Implement emergency stop in SO100Follower
-      console.log("Emergency stop executed.");
-      await this.stop();
-      process.exit(0);
-    } catch (error) {
-      console.error("Emergency stop failed:", error);
-      process.exit(1);
-    }
-  }
-}

src/lerobot/web/robots/robot.ts

@@ -1,171 +0,0 @@
-/**
- * Base Robot class for Web platform
- * Uses Web Serial API for serial communication
- */
-
-import type { RobotConfig } from "../../node/types/robot-config.js";
-
-// Web Serial API type declarations (minimal for our needs)
-declare global {
-  interface SerialPort {
-    open(options: { baudRate: number }): Promise<void>;
-    close(): Promise<void>;
-    readable: ReadableStream<Uint8Array> | null;
-    writable: WritableStream<Uint8Array> | null;
-  }
-}
-
-export abstract class Robot {
-  protected port: SerialPort | null = null;
-  protected config: RobotConfig;
-  protected name: string;
-  protected reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
-  protected writer: WritableStreamDefaultWriter<Uint8Array> | null = null;
-
-  constructor(config: RobotConfig) {
-    this.config = config;
-    this.name = config.type;
-  }
-
-  /**
-   * Connect to the robot using Web Serial API
-   * Requires user interaction to select port
-   */
-  async connect(_calibrate: boolean = false): Promise<void> {
-    try {
-      // Request port from user (requires user interaction)
-      this.port = await navigator.serial.requestPort();
-
-      // Open the port with correct SO-100 baudRate
-      await this.port.open({ baudRate: 1000000 }); // Correct baudRate for Feetech motors (SO-100)
-
-      // Set up readable and writable streams
-      if (this.port.readable) {
-        this.reader = this.port.readable.getReader();
-      }
-
-      if (this.port.writable) {
-        this.writer = this.port.writable.getWriter();
-      }
-    } catch (error) {
-      throw new Error(
-        `Could not connect to robot: ${
-          error instanceof Error ? error.message : error
-        }`
-      );
-    }
-  }
-
-  /**
-   * Calibrate the robot
-   * Must be implemented by subclasses
-   */
-  abstract calibrate(): Promise<void>;
-
-  /**
-   * Disconnect from the robot
-   */
-  async disconnect(): Promise<void> {
-    if (this.reader) {
-      await this.reader.cancel();
-      this.reader.releaseLock();
-      this.reader = null;
-    }
-
-    if (this.writer) {
-      await this.writer.close();
-      this.writer = null;
-    }
-
-    if (this.port) {
-      await this.port.close();
-      this.port = null;
-    }
-  }
-
-  /**
-   * Save calibration data to browser storage
-   * Uses localStorage as fallback, IndexedDB preferred for larger data
-   */
-  protected async saveCalibration(calibrationData: any): Promise<void> {
-    const robotId = this.config.id || this.name;
-    const key = `lerobot_calibration_${this.name}_${robotId}`;
-
-    try {
-      // Save to localStorage for now (could be enhanced to use File System Access API)
-      localStorage.setItem(key, JSON.stringify(calibrationData));
-
-      // Optionally trigger download
-      this.downloadCalibration(calibrationData, robotId);
-
-      console.log(`Configuration saved to browser storage and downloaded.`);
-    } catch (error) {
-      this.downloadCalibration(calibrationData, robotId);
-      console.log(`Configuration downloaded as file.`);
-    }
-  }
-
-  /**
-   * Download calibration data as JSON file
-   */
-  private downloadCalibration(calibrationData: any, robotId: string): void {
-    const dataStr = JSON.stringify(calibrationData, null, 2);
-    const dataBlob = new Blob([dataStr], { type: "application/json" });
-
-    const url = URL.createObjectURL(dataBlob);
-    const link = document.createElement("a");
-    link.href = url;
-    link.download = `${robotId}_calibration.json`;
-
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-  }
-
-  /**
-   * Send command to robot via Web Serial API
-   */
-  protected async sendCommand(command: string): Promise<void> {
-    if (!this.writer) {
-      throw new Error("Robot not connected");
-    }
-
-    const encoder = new TextEncoder();
-    const data = encoder.encode(command);
-    await this.writer.write(data);
-  }
-
-  /**
-   * Read data from robot with timeout
-   */
-  protected async readData(timeout: number = 5000): Promise<Uint8Array> {
-    if (!this.reader) {
-      throw new Error("Robot not connected");
-    }
-
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => reject(new Error("Read timeout")), timeout);
-    });
-
-    const readPromise = this.reader.read().then((result) => {
-      if (result.done) {
-        throw new Error("Stream closed");
-      }
-      return result.value;
-    });
-
-    return Promise.race([readPromise, timeoutPromise]);
-  }
-
-  /**
-   * Disable torque on disconnect (SO-100 specific)
-   */
-  protected async disableTorque(): Promise<void> {
-    try {
-      await this.sendCommand("TORQUE_DISABLE\r\n");
-    } catch (error) {
-      console.warn("Warning: Could not disable torque on disconnect");
-    }
-  }
-}

vite.config.ts

@@ -1,13 +1,21 @@
 import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";
 import { resolve } from "path";
+import { existsSync } from "fs";
 
 export default defineConfig(({ mode }) => {
+  // Check if we're in a workspace environment (has packages/web/src)
+  const isWorkspace = existsSync(resolve(__dirname, "./packages/web/src"));
+
   const baseConfig = {
     plugins: [],
     resolve: {
       alias: {
         "@": resolve(__dirname, "./src"),
+        // Only add workspace alias if in workspace environment
+        ...(isWorkspace && {
+          "@lerobot/web": resolve(__dirname, "./packages/web/src"),
+        }),
       },
     },
   };