Initial commit

.dockerignore

@@ -0,0 +1,52 @@
+# Git
+.git
+.gitignore
+
+# Node modules and build artifacts
+node_modules
+.svelte-kit
+demo/build
+demo/node_modules
+client/js/node_modules
+client/js/dist
+
+# Python cache and virtual environments
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+.venv
+.pytest_cache
+*.egg-info
+
+# Development files
+*.log
+logs/
+.DS_Store
+Thumbs.db
+
+# IDE files
+.vscode
+.idea
+*.swp
+*.swo
+
+# Temporary files
+*.tmp
+*.temp
+
+# Documentation
+*.md
+!README.md
+
+# Test files
+tests/
+test_*
+
+# Development configs
+.eslintrc*
+.prettierrc*
+*.config.js
+!svelte.config.js
+!vite.config.ts 

.github/workflows/docker.yml

@@ -0,0 +1,120 @@
+name: Docker Build and Test
+
+on:
+  push:
+    branches: [ main, develop ]
+    paths:
+      - 'services/transport-server/**'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'services/transport-server/**'
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: lerobot-arena/transport-server
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Log in to Container Registry
+      if: github.event_name != 'pull_request'
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Extract metadata
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=sha,prefix={{branch}}-
+          type=raw,value=latest,enable={{is_default_branch}}
+
+    - name: Build Docker image
+      uses: docker/build-push-action@v5
+      with:
+        context: ./services/transport-server
+        file: ./services/transport-server/Dockerfile
+        push: false
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+        load: true
+
+    - name: Test Docker image
+      run: |
+        # Start the container in background
+        docker run -d --name test-container -p 7860:7860 -e SERVE_FRONTEND=true ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+        
+        # Wait for container to start
+        sleep 30
+        
+        # Test health endpoint
+        curl -f http://localhost:7860/health || exit 1
+        
+        # Test API health endpoint
+        curl -f http://localhost:7860/api/health || exit 1
+        
+        # Test frontend is served
+        curl -f http://localhost:7860/ | grep -q "LeRobot Arena" || exit 1
+        
+        # Check logs for errors
+        docker logs test-container
+        
+        # Stop container
+        docker stop test-container
+        docker rm test-container
+
+    - name: Push Docker image
+      if: github.event_name != 'pull_request'
+      uses: docker/build-push-action@v5
+      with:
+        context: ./services/transport-server
+        file: ./services/transport-server/Dockerfile
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+
+  security-scan:
+    runs-on: ubuntu-latest
+    needs: build-and-test
+    permissions:
+      contents: read
+      security-events: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Run Trivy vulnerability scanner
+      uses: aquasecurity/trivy-action@master
+      with:
+        image-ref: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+        format: 'sarif'
+        output: 'trivy-results.sarif'
+
+    - name: Upload Trivy scan results to GitHub Security tab
+      uses: github/codeql-action/upload-sarif@v2
+      if: always()
+      with:
+        sarif_file: 'trivy-results.sarif' 

Dockerfile

@@ -0,0 +1,65 @@
+# Multi-stage Dockerfile for LeRobot Arena Transport Server
+# Stage 1: Build frontend with Bun (client library + demo)
+FROM oven/bun:1-alpine AS frontend-builder
+
+WORKDIR /app
+
+# Install git for dependencies that might need it
+RUN apk add --no-cache git
+
+# Copy all JavaScript/TypeScript files
+COPY client/js/ ./client/js/
+COPY demo/ ./demo/
+
+# Build and link client library
+WORKDIR /app/client/js
+RUN bun install
+RUN bun run build
+RUN bun link
+
+# Build demo with linked client library
+WORKDIR /app/demo
+RUN bun link lerobot-arena-client
+RUN bun install
+RUN bun run build
+
+# Stage 2: Python backend with uv
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
+
+# Set up a new user named "user" with user ID 1000 (required for HF Spaces)
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Copy Python project files for dependency resolution
+COPY --chown=user server/pyproject.toml server/uv.lock* ./server/
+
+# Install dependencies first (better caching)
+WORKDIR $HOME/app/server
+RUN uv sync --no-install-project
+
+# Copy the rest of the Python backend
+COPY --chown=user server/ ./
+
+# Install the project itself
+RUN uv sync
+
+# Copy built frontend from previous stage with proper ownership
+COPY --chown=user --from=frontend-builder /app/demo/build $HOME/app/static-frontend
+
+# Set working directory back to app root
+WORKDIR $HOME/app
+
+# Expose port 7860 (HF Spaces default)
+EXPOSE 7860
+
+# Start the FastAPI server (serves both frontend and backend)
+CMD ["sh", "-c", "cd server && SERVE_FRONTEND=true uv run python launch_with_ui.py"] 

README.md

@@ -0,0 +1,353 @@
+---
+title: LeRobot Arena Transport Server
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+dockerfile_path: services/transport-server/Dockerfile
+suggested_hardware: cpu-upgrade
+suggested_storage: small
+short_description: Real-time robotics control 
+tags:
+  - robotics
+  - control
+  - websocket
+  - fastapi
+  - svelte
+  - real-time
+  - video-streaming
+  - transport-server
+pinned: true
+fullWidth: true
+---
+
+# 🤖 LeRobot Arena Transport Server with UI
+
+A complete Docker deployment of the LeRobot Arena Transport Server with integrated web UI. This combines the FastAPI backend with a SvelteKit frontend in a single container, inspired by the [LeRobot Arena Hugging Face Space](https://huggingface.co/spaces/blanchon/LeRobot-Arena).
+
+## 🚀 Quick Start with Docker
+
+The easiest way to run the complete LeRobot Arena Transport Server is using Docker, which sets up both the frontend and backend automatically.
+
+### Prerequisites
+
+- [Docker](https://www.docker.com/get-started) installed on your system
+- [Docker Compose](https://docs.docker.com/compose/install/) (usually included with Docker Desktop)
+
+### Step-by-Step Instructions
+
+1. **Navigate to the transport server directory**
+   ```bash
+   cd services/transport-server
+   ```
+
+2. **Build the Docker image**
+   ```bash
+   docker build -t lerobot-arena-transport .
+   ```
+
+3. **Run the container**
+   ```bash
+   docker run -p 7860:7860 -e SERVE_FRONTEND=true lerobot-arena-transport
+   ```
+
+4. **Access the application**
+   - **Frontend**: http://localhost:7860
+   - **Backend API**: http://localhost:7860/api
+   - **API Documentation**: http://localhost:7860/api/docs
+
+5. **Stop the container**
+   ```bash
+   # Find the container ID
+   docker ps
+   
+   # Stop the container
+   docker stop <container_id>
+   ```
+
+### Alternative Build & Run Options
+
+**One-liner build and run:**
+```bash
+docker build -t lerobot-arena-transport . && docker run -p 7860:7860 -e SERVE_FRONTEND=true lerobot-arena-transport
+```
+
+**Run with custom environment variables:**
+```bash
+docker run -p 8080:7860 \
+  -e SERVE_FRONTEND=true \
+  -e PORT=7860 \
+  -e HOST=0.0.0.0 \
+  lerobot-arena-transport
+```
+
+**Run with volume mounts for logs:**
+```bash
+docker run -p 7860:7860 \
+  -e SERVE_FRONTEND=true \
+  -v $(pwd)/logs:/home/user/app/logs \
+  lerobot-arena-transport
+```
+
+## 🛠️ Development Setup
+
+For local development with hot-reload capabilities:
+
+### Backend Development
+
+```bash
+# Navigate to server directory
+cd server
+
+# Install Python dependencies (using uv)
+uv sync
+
+# Start the backend server only
+python api.py
+```
+
+### Frontend Development
+
+```bash
+# Navigate to demo directory
+cd demo
+
+# Install dependencies
+bun install
+
+# Start the development server
+bun run dev
+```
+
+### Client Library Development
+
+```bash
+# Navigate to client library
+cd client/js
+
+# Install dependencies
+bun install
+
+# Build the client library
+bun run build
+```
+
+## 📋 Project Structure
+
+```
+services/transport-server/
+├── server/                     # Python FastAPI backend
+│   ├── src/                   # Source code
+│   ├── api.py                 # Main API application
+│   ├── launch_with_ui.py      # Combined launcher
+│   └── pyproject.toml         # Python dependencies
+├── demo/                      # SvelteKit frontend
+│   ├── src/                   # Frontend source code
+│   ├── package.json           # Node.js dependencies
+│   └── svelte.config.js       # SvelteKit configuration
+├── client/js/                 # TypeScript client library
+│   ├── src/                   # Client library source
+│   └── package.json           # Client dependencies
+├── Dockerfile                 # Docker configuration
+├── docker-compose.yml         # Docker Compose setup
+└── README.md                  # This file
+```
+
+## 🐳 Docker Information
+
+The Docker setup includes:
+
+- **Multi-stage build**: Optimized for production using Bun and uv
+- **Client library build**: Builds the TypeScript client first
+- **Frontend build**: Compiles SvelteKit app to static files
+- **Backend integration**: FastAPI serves both API and static files
+- **Port mapping**: Single port 7860 for both frontend and API
+- **User permissions**: Properly configured for Hugging Face Spaces
+- **Environment variables**: Configurable via environment
+
+### Environment Variables
+
+- `SERVE_FRONTEND=true`: Enable frontend serving (default: false)
+- `PORT=7860`: Port to run the server on (default: 7860)
+- `HOST=0.0.0.0`: Host to bind to (default: 0.0.0.0)
+
+## 🌐 What's Included
+
+### Backend Features
+- **Real-time Robot Control**: WebSocket-based communication
+- **Video Streaming**: WebRTC video streaming capabilities
+- **REST API**: Complete robotics control API
+- **Room Management**: Create and manage robot control sessions
+- **Health Monitoring**: Built-in health checks and logging
+
+### Frontend Features
+- **Dashboard**: Server status and room overview
+- **Robot Control**: 6-DOF robot arm control interface
+- **Real-time Monitoring**: Live joint state visualization
+- **Workspace Management**: Isolated environments for different sessions
+- **Modern UI**: Responsive design with Tailwind CSS
+
+### Architecture
+- **Frontend**: Svelte 5, TypeScript, Tailwind CSS
+- **Backend**: FastAPI, Python 3.12, uvicorn
+- **Client Library**: TypeScript with WebSocket support
+- **Build System**: Bun for frontend, uv for Python
+- **Container**: Multi-stage Docker build
+
+## 🔧 API Endpoints
+
+### Health Check
+- `GET /health` - Server health status
+- `GET /api/health` - API health status
+
+### Robotics API
+- `GET /api/robotics/rooms` - List active rooms
+- `POST /api/robotics/rooms` - Create new room
+- `DELETE /api/robotics/rooms/{room_id}` - Delete room
+- `WebSocket /api/robotics/ws/{room_id}` - Real-time control
+
+### Video API
+- `GET /api/video/rooms` - List video rooms
+- `WebSocket /api/video/ws/{room_id}` - Video streaming
+
+## 🧪 Testing the Setup
+
+Run the included test script to verify everything works:
+
+```bash
+./test-docker.sh
+```
+
+This script will build the image, start a container, test all endpoints, and clean up automatically.
+
+## 🚨 Troubleshooting
+
+### Port Conflicts
+If port 7860 is already in use:
+
+```bash
+# Check what's using the port
+lsof -i :7860
+
+# Use different port
+docker run -p 8080:7860 -e SERVE_FRONTEND=true lerobot-arena-transport
+```
+
+### Container Issues
+
+```bash
+# View logs
+docker logs <container_id>
+
+# Rebuild without cache
+docker build --no-cache -t lerobot-arena-transport .
+
+# Run with verbose logging
+docker run -p 7860:7860 -e SERVE_FRONTEND=true -e LOG_LEVEL=debug lerobot-arena-transport
+```
+
+### Development Issues
+
+```bash
+# Clear node modules and reinstall (for local development)
+cd demo
+rm -rf node_modules
+bun install
+
+# Clear SvelteKit cache
+rm -rf .svelte-kit
+bun run dev
+
+# Re-link client library (if needed for local development)
+cd ../client/js
+bun link
+cd ../../demo
+bun link lerobot-arena-client
+```
+
+### Client Library Issues
+
+```bash
+# Rebuild client library
+cd client/js
+bun run clean
+bun run build
+```
+
+## 🚀 Hugging Face Spaces Deployment
+
+This project is configured for deployment on Hugging Face Spaces:
+
+1. **Fork** this repository to your GitHub account
+2. **Create a new Space** on Hugging Face Spaces
+3. **Connect** your GitHub repository
+4. **Select Docker SDK** (should be auto-detected)
+5. **Set the Dockerfile path** to `services/transport-server/Dockerfile`
+6. **Deploy**
+
+The Space will automatically build and run both the frontend and backend.
+
+### Hugging Face Spaces Configuration
+
+Add this to your Space's README.md frontmatter:
+
+```yaml
+---
+title: LeRobot Arena Transport Server
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+dockerfile_path: services/transport-server/Dockerfile
+suggested_hardware: cpu-upgrade
+suggested_storage: small
+short_description: Real-time robotics control and video streaming
+tags:
+  - robotics
+  - control
+  - websocket
+  - fastapi
+  - svelte
+pinned: true
+fullWidth: true
+---
+```
+
+## 🎯 Use Cases
+
+### Development & Testing
+- **API Development**: Test robotics control APIs
+- **Frontend Development**: Develop robotics UIs
+- **Integration Testing**: Test real-time communication
+
+### Production Deployment
+- **Robot Control**: Remote robot operation
+- **Multi-user**: Multiple operators on same robot
+- **Monitoring**: Real-time robot state monitoring
+
+### Education & Demos
+- **Learning**: Robotics programming education
+- **Demonstrations**: Showcase robotics capabilities
+- **Prototyping**: Rapid robotics application development
+
+## 🤝 Contributing
+
+1. **Fork** the repository
+2. **Create feature branch** (`git checkout -b feature/amazing-feature`)
+3. **Make changes** and add tests
+4. **Test with Docker** (`./test-docker.sh`)
+5. **Commit changes** (`git commit -m 'Add amazing feature'`)
+6. **Push to branch** (`git push origin feature/amazing-feature`)
+7. **Open Pull Request**
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+---
+
+**Built with ❤️ for the robotics community** 🤖
+
+For more information, visit the [main LeRobot Arena project](https://github.com/lerobot-arena/lerobot-arena). 

client/js/.cursor/rules/use-bun-instead-of-node-vite-npm-pnpm.mdc

@@ -0,0 +1,98 @@
+---
+description: Use Bun instead of Node.js, npm, pnpm, or vite.
+globs: *.ts, *.tsx, *.html, *.css, *.js, *.jsx, package.json
+alwaysApply: false
+---
+
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.html|file.ts|file.css>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `Bun.serve()` supports WebSockets, HTTPS, and routes. Don't use `express`.
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.redis` for Redis. Don't use `ioredis`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- `WebSocket` is built-in. Don't use `ws`.
+- Bun.$`ls` instead of execa.
+
+## Frontend
+
+Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
+
+Server:
+
+```ts#index.ts
+import index from "./index.html"
+
+Bun.serve({
+  routes: {
+    "/": index,
+    "/api/users/:id": {
+      GET: (req) => {
+        return new Response(JSON.stringify({ id: req.params.id }));
+      },
+    },
+  },
+  // optional websocket support
+  websocket: {
+    open: (ws) => {
+      ws.send("Hello, world!");
+    },
+    message: (ws, message) => {
+      ws.send(message);
+    },
+    close: (ws) => {
+      // handle close
+    }
+  },
+  development: {
+    hmr: true,
+    console: true,
+  }
+})
+```
+
+HTML files can import .tsx, .jsx or .js files directly and Bun's bundler will transpile & bundle automatically. `<link>` tags can point to stylesheets and Bun's CSS bundler will bundle.
+
+```html#index.html
+<html>
+  <body>
+    <h1>Hello, world!</h1>
+    <script type="module" src="./frontend.tsx"></script>
+  </body>
+</html>
+```
+
+With the following `frontend.tsx`:
+
+```tsx#frontend.tsx
+import React from "react";
+
+// import .css files directly and it works
+import './index.css';
+
+import { createRoot } from "react-dom/client";
+
+const root = createRoot(document.body);
+
+export default function Frontend() {
+  return <h1>Hello, world!</h1>;
+}
+
+root.render(<Frontend />);
+```
+
+Then, run index.ts
+
+```sh
+bun --hot ./index.ts
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.md`.

client/js/.gitignore

@@ -0,0 +1,34 @@
+# dependencies (bun install)
+node_modules
+
+# output
+out
+dist
+*.tgz
+
+# code coverage
+coverage
+*.lcov
+
+# logs
+logs
+_.log
+report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# caches
+.eslintcache
+.cache
+*.tsbuildinfo
+
+# IntelliJ based IDEs
+.idea
+
+# Finder (MacOS) folder config
+.DS_Store

client/js/README.md

@@ -0,0 +1,396 @@
+# LeRobot Arena JavaScript/TypeScript Client
+
+A modern TypeScript/JavaScript client library for LeRobot Arena robotics system, providing real-time communication for robot control and monitoring.
+
+## Features
+
+- 🤖 **Producer/Consumer Pattern**: Control robots as producer, monitor as consumer
+- 🔄 **Real-time Communication**: WebSocket-based bidirectional communication
+- 📡 **REST API Support**: Complete CRUD operations for rooms and state
+- 🎯 **Type Safety**: Full TypeScript support with comprehensive type definitions
+- 🚨 **Safety Features**: Emergency stop functionality built-in
+- 🔧 **Modular Design**: Import only what you need
+- 🧪 **Well Tested**: Comprehensive test suite with Bun test
+
+## Installation
+
+```bash
+# Install the package (when published)
+npm install lerobot-arena-client
+
+# Or for local development
+git clone <repository>
+cd client/js
+bun install
+bun run build
+```
+
+## Quick Start
+
+### Producer (Robot Controller)
+
+```typescript
+import { RoboticsProducer, createProducerClient } from 'lerobot-arena-client';
+
+// Method 1: Manual setup
+const producer = new RoboticsProducer('http://localhost:8000');
+const roomId = await producer.createRoom();
+await producer.connect(roomId);
+
+// Method 2: Factory function (recommended)
+const producer = await createProducerClient('http://localhost:8000');
+
+// Send robot commands
+await producer.sendJointUpdate([
+  { name: 'shoulder', value: 45.0 },
+  { name: 'elbow', value: -30.0 }
+]);
+
+// Send complete state
+await producer.sendStateSync({
+  base: 0.0,
+  shoulder: 45.0,
+  elbow: -30.0,
+  wrist: 0.0
+});
+
+// Emergency stop
+await producer.sendEmergencyStop('Safety stop triggered');
+```
+
+### Consumer (Robot Monitor)
+
+```typescript
+import { RoboticsConsumer, createConsumerClient } from 'lerobot-arena-client';
+
+// Connect to existing room
+const consumer = await createConsumerClient(roomId, 'http://localhost:8000');
+
+// Set up event listeners
+consumer.onJointUpdate((joints) => {
+  console.log('Joints updated:', joints);
+});
+
+consumer.onStateSync((state) => {
+  console.log('State synced:', state);
+});
+
+consumer.onError((error) => {
+  console.error('Error:', error);
+});
+
+// Get current state
+const currentState = await consumer.getStateSyncAsync();
+```
+
+## API Reference
+
+### Core Classes
+
+#### `RoboticsClientCore`
+Base class providing common functionality:
+
+```typescript
+// REST API methods
+await client.listRooms();
+await client.createRoom(roomId?);
+await client.deleteRoom(roomId);
+await client.getRoomInfo(roomId);
+await client.getRoomState(roomId);
+
+// Connection management
+await client.connectToRoom(roomId, role, participantId?);
+await client.disconnect();
+client.isConnected();
+client.getConnectionInfo();
+
+// Utility
+await client.sendHeartbeat();
+```
+
+#### `RoboticsProducer`
+Producer-specific functionality:
+
+```typescript
+const producer = new RoboticsProducer('http://localhost:8000');
+
+// Connection
+await producer.connect(roomId, participantId?);
+
+// Commands
+await producer.sendJointUpdate(joints);
+await producer.sendStateSync(state);
+await producer.sendEmergencyStop(reason?);
+
+// Static factory
+const producer = await RoboticsProducer.createAndConnect(baseUrl, roomId?, participantId?);
+```
+
+#### `RoboticsConsumer`
+Consumer-specific functionality:
+
+```typescript
+const consumer = new RoboticsConsumer('http://localhost:8000');
+
+// Connection
+await consumer.connect(roomId, participantId?);
+
+// Data access
+await consumer.getStateSyncAsync();
+
+// Event callbacks
+consumer.onJointUpdate(callback);
+consumer.onStateSync(callback);
+consumer.onError(callback);
+consumer.onConnected(callback);
+consumer.onDisconnected(callback);
+
+// Static factory
+const consumer = await RoboticsConsumer.createAndConnect(roomId, baseUrl, participantId?);
+```
+
+### Factory Functions
+
+```typescript
+import { createClient, createProducerClient, createConsumerClient } from 'lerobot-arena-client';
+
+// Generic factory
+const client = createClient('producer', 'http://localhost:8000');
+
+// Specialized factories (auto-connect)
+const producer = await createProducerClient('http://localhost:8000', roomId?, participantId?);
+const consumer = await createConsumerClient(roomId, 'http://localhost:8000', participantId?);
+```
+
+### Type Definitions
+
+```typescript
+interface JointData {
+  name: string;
+  value: number;
+  speed?: number;
+}
+
+interface RoomInfo {
+  id: string;
+  participants: {
+    producer: string | null;
+    consumers: string[];
+    total: number;
+  };
+  joints_count: number;
+  has_producer?: boolean;
+  active_consumers?: number;
+}
+
+interface RoomState {
+  room_id: string;
+  joints: Record<string, number>;
+  participants: {
+    producer: string | null;
+    consumers: string[];
+    total: number;
+  };
+  timestamp: string;
+}
+
+type ParticipantRole = 'producer' | 'consumer';
+type MessageType = 'joint_update' | 'state_sync' | 'heartbeat' | 'emergency_stop' | 'joined' | 'error';
+```
+
+## Examples
+
+The `examples/` directory contains complete working examples:
+
+### Running Examples
+
+```bash
+# Build the library first
+bun run build
+
+# Run producer example
+node examples/basic-producer.js
+
+# Run consumer example (in another terminal)
+node examples/basic-consumer.js
+```
+
+### Example Files
+
+- **`basic-producer.js`**: Complete producer workflow
+- **`basic-consumer.js`**: Interactive consumer example
+- **`room-management.js`**: REST API operations
+- **`producer-consumer-demo.js`**: Full integration demo
+
+## Development
+
+### Prerequisites
+
+- [Bun](https://bun.sh/) >= 1.0.0
+- LeRobot Arena server running on `http://localhost:8000`
+
+### Setup
+
+```bash
+# Clone and install
+git clone <repository>
+cd client/js
+bun install
+
+# Development build (watch mode)
+bun run dev
+
+# Production build
+bun run build
+
+# Run tests
+bun test
+
+# Type checking
+bun run typecheck
+
+# Linting
+bun run lint
+bun run lint:fix
+```
+
+### Testing
+
+The library includes comprehensive tests:
+
+```bash
+# Run all tests
+bun test
+
+# Run specific test files
+bun test tests/producer.test.ts
+bun test tests/consumer.test.ts
+bun test tests/integration.test.ts
+bun test tests/rest-api.test.ts
+
+# Run tests with coverage
+bun test --coverage
+```
+
+### Project Structure
+
+```
+client/js/
+├── src/
+│   ├── index.ts              # Main entry point
+│   ├── robotics/
+│   │   ├── index.ts          # Robotics module exports
+│   │   ├── types.ts          # TypeScript type definitions
+│   │   ├── core.ts           # Base client class
+│   │   ├── producer.ts       # Producer client
+│   │   ├── consumer.ts       # Consumer client
+│   │   └── factory.ts        # Factory functions
+│   ├── video/               # Video module (placeholder)
+│   └── audio/               # Audio module (placeholder)
+├── tests/
+│   ├── producer.test.ts      # Producer tests
+│   ├── consumer.test.ts      # Consumer tests
+│   ├── integration.test.ts   # Integration tests
+│   └── rest-api.test.ts      # REST API tests
+├── examples/
+│   ├── basic-producer.js     # Producer example
+│   ├── basic-consumer.js     # Consumer example
+│   └── README.md            # Examples documentation
+├── dist/                    # Built output
+├── package.json
+├── tsconfig.json
+├── vite.config.ts
+└── README.md
+```
+
+## Error Handling
+
+The client provides comprehensive error handling:
+
+```typescript
+// Connection errors
+try {
+  await producer.connect(roomId);
+} catch (error) {
+  console.error('Connection failed:', error.message);
+}
+
+// Operation errors
+producer.onError((error) => {
+  console.error('Producer error:', error);
+});
+
+// Network timeouts
+const options = { timeout: 10000 }; // 10 seconds
+const client = new RoboticsProducer('http://localhost:8000', options);
+```
+
+## Configuration
+
+### Client Options
+
+```typescript
+interface ClientOptions {
+  timeout?: number;           // Request timeout (default: 5000ms)
+  reconnect_attempts?: number; // Auto-reconnect attempts (default: 3)
+  heartbeat_interval?: number; // Heartbeat interval (default: 30000ms)
+}
+
+const producer = new RoboticsProducer('http://localhost:8000', {
+  timeout: 10000,
+  reconnect_attempts: 5,
+  heartbeat_interval: 15000
+});
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Failed**: Ensure the server is running on `http://localhost:8000`
+2. **Import Errors**: Make sure you've built the library (`bun run build`)
+3. **Room Not Found**: Check that the room ID exists
+4. **Permission Denied**: Only one producer per room is allowed
+5. **WebSocket Errors**: Check firewall settings and network connectivity
+
+### Debug Mode
+
+Enable detailed logging:
+
+```typescript
+// Set up detailed error handling
+producer.onError((error) => {
+  console.error('Detailed error:', error);
+});
+
+// Monitor connection events
+producer.onConnected(() => console.log('Connected'));
+producer.onDisconnected(() => console.log('Disconnected'));
+```
+
+### Performance Tips
+
+- Use the factory functions for simpler setup
+- Batch joint updates when possible
+- Monitor connection state before sending commands
+- Implement proper cleanup in your applications
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature/amazing-feature`
+3. Make your changes and add tests
+4. Run the test suite: `bun test`
+5. Commit your changes: `git commit -m 'Add amazing feature'`
+6. Push to the branch: `git push origin feature/amazing-feature`
+7. Open a Pull Request
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Support
+
+- 📚 [Documentation](./examples/README.md)
+- 🐛 [Issue Tracker](https://github.com/lerobot-arena/lerobot-arena/issues)
+- 💬 [Discussions](https://github.com/lerobot-arena/lerobot-arena/discussions)

client/js/bun.lock

@@ -0,0 +1,409 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "lerobot_arena_client",
+      "dependencies": {
+        "@hey-api/client-fetch": "^0.2.1",
+        "eventemitter3": "^5.0.1",
+      },
+      "devDependencies": {
+        "@hey-api/openapi-ts": "^0.53.8",
+        "@types/bun": "^1.2.15",
+        "typescript": "^5.3.3",
+        "vite": "6.3.5",
+        "vite-plugin-dts": "4.5.4",
+      },
+      "peerDependencies": {
+        "typescript": ">=5.0.0",
+      },
+    },
+  },
+  "packages": {
+    "@apidevtools/json-schema-ref-parser": ["@apidevtools/json-schema-ref-parser@11.7.2", "", { "dependencies": { "@jsdevtools/ono": "^7.1.3", "@types/json-schema": "^7.0.15", "js-yaml": "^4.1.0" } }, "sha512-4gY54eEGEstClvEkGnwVkTkrx0sqwemEFG5OSRRn3tD91XH0+Q8XIkYIfo7IwEWPpJZwILb9GUXeShtplRc/eA=="],
+
+    "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="],
+
+    "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="],
+
+    "@babel/parser": ["@babel/parser@7.27.5", "", { "dependencies": { "@babel/types": "^7.27.3" }, "bin": "./bin/babel-parser.js" }, "sha512-OsQd175SxWkGlzbny8J3K8TnnDD0N3lrIUtB92xwyRpzaenGZhxDvxN/JgU00U3CDZNj9tPuDJ5H0WS4Nt3vKg=="],
+
+    "@babel/types": ["@babel/types@7.27.6", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-ETyHEk2VHHvl9b9jZP5IHPavHYk57EhanlRRuae9XCpb/j5bDCbPPMOBfCWhnl/7EDJz0jEMCi/RhccCE8r1+Q=="],
+
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.5", "", { "os": "aix", "cpu": "ppc64" }, "sha512-9o3TMmpmftaCMepOdA5k/yDw8SfInyzWWTjYTFCX3kPSDJMROQTb8jg+h9Cnwnmm1vOzvxN7gIfB5V2ewpjtGA=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.25.5", "", { "os": "android", "cpu": "arm" }, "sha512-AdJKSPeEHgi7/ZhuIPtcQKr5RQdo6OO2IL87JkianiMYMPbCtot9fxPbrMiBADOWWm3T2si9stAiVsGbTQFkbA=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.5", "", { "os": "android", "cpu": "arm64" }, "sha512-VGzGhj4lJO+TVGV1v8ntCZWJktV7SGCs3Pn1GRWI1SBFtRALoomm8k5E9Pmwg3HOAal2VDc2F9+PM/rEY6oIDg=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.25.5", "", { "os": "android", "cpu": "x64" }, "sha512-D2GyJT1kjvO//drbRT3Hib9XPwQeWd9vZoBJn+bu/lVsOZ13cqNdDeqIF/xQ5/VmWvMduP6AmXvylO/PIc2isw=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-GtaBgammVvdF7aPIgH2jxMDdivezgFu6iKpmT+48+F8Hhg5J/sfnDieg0aeG/jfSvkYQU2/pceFPDKlqZzwnfQ=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-1iT4FVL0dJ76/q1wd7XDsXrSW+oLoquptvh4CLR4kITDtqi2e/xwXwdCVH8hVHU43wgJdsq7Gxuzcs6Iq/7bxQ=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-nk4tGP3JThz4La38Uy/gzyXtpkPW8zSAmoUhK9xKKXdBCzKODMc2adkB2+8om9BDYugz+uGV7sLmpTYzvmz6Sw=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-PrikaNjiXdR2laW6OIjlbeuCPrPaAl0IwPIaRv+SMV8CiM8i2LqVUHFC1+8eORgWyY7yhQY+2U2fA55mBzReaw=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.5", "", { "os": "linux", "cpu": "arm" }, "sha512-cPzojwW2okgh7ZlRpcBEtsX7WBuqbLrNXqLU89GxWbNt6uIg78ET82qifUy3W6OVww6ZWobWub5oqZOVtwolfw=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-Z9kfb1v6ZlGbWj8EJk9T6czVEjjq2ntSYLY2cw6pAZl4oKtfgQuS4HOq41M/BcoLPzrUbNd+R4BXFyH//nHxVg=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.5", "", { "os": "linux", "cpu": "ia32" }, "sha512-sQ7l00M8bSv36GLV95BVAdhJ2QsIbCuCjh/uYrWiMQSUuV+LpXwIqhgJDcvMTj+VsQmqAHL2yYaasENvJ7CDKA=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-0ur7ae16hDUC4OL5iEnDb0tZHDxYmuQyhKhsPBV8f99f6Z9KQM02g33f93rNH5A30agMS46u2HP6qTdEt6Q1kg=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-kB/66P1OsHO5zLz0i6X0RxlQ+3cu0mkxS3TKFvkb5lin6uwZ/ttOkP3Z8lfR9mJOBk14ZwZ9182SIIWFGNmqmg=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-UZCmJ7r9X2fe2D6jBmkLBMQetXPXIsZjQJCjgwpVDz+YMcS6oFR27alkgGv3Oqkv07bxdvw7fyB71/olceJhkQ=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.5", "", { "os": "linux", "cpu": "none" }, "sha512-kTxwu4mLyeOlsVIFPfQo+fQJAV9mh24xL+y+Bm6ej067sYANjyEw1dNHmvoqxJUCMnkBdKpvOn0Ahql6+4VyeA=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-K2dSKTKfmdh78uJ3NcWFiqyRrimfdinS5ErLSn3vluHNeHVnBAFWC8a4X5N+7FgVE1EjXS1QDZbpqZBjfrqMTQ=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.5", "", { "os": "linux", "cpu": "x64" }, "sha512-uhj8N2obKTE6pSZ+aMUbqq+1nXxNjZIIjCjGLfsWvVpy7gKCOL6rsY1MhRh9zLtUtAI7vpgLMK6DxjO8Qm9lJw=="],
+
+    "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.5", "", { "os": "none", "cpu": "arm64" }, "sha512-pwHtMP9viAy1oHPvgxtOv+OkduK5ugofNTVDilIzBLpoWAM16r7b/mxBvfpuQDpRQFMfuVr5aLcn4yveGvBZvw=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.5", "", { "os": "none", "cpu": "x64" }, "sha512-WOb5fKrvVTRMfWFNCroYWWklbnXH0Q5rZppjq0vQIdlsQKuw6mdSihwSo4RV/YdQ5UCKKvBy7/0ZZYLBZKIbwQ=="],
+
+    "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.5", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-7A208+uQKgTxHd0G0uqZO8UjK2R0DDb4fDmERtARjSHWxqMTye4Erz4zZafx7Di9Cv+lNHYuncAkiGFySoD+Mw=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.5", "", { "os": "openbsd", "cpu": "x64" }, "sha512-G4hE405ErTWraiZ8UiSoesH8DaCsMm0Cay4fsFWOOUcz8b8rC6uCvnagr+gnioEjWn0wC+o1/TAHt+It+MpIMg=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.5", "", { "os": "sunos", "cpu": "x64" }, "sha512-l+azKShMy7FxzY0Rj4RCt5VD/q8mG/e+mDivgspo+yL8zW7qEwctQ6YqKX34DTEleFAvCIUviCFX1SDZRSyMQA=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-O2S7SNZzdcFG7eFKgvwUEZ2VG9D/sn/eIiz8XRZ1Q/DO5a3s76Xv0mdBzVM5j5R639lXQmPmSo0iRpHqUUrsxw=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-onOJ02pqs9h1iMJ1PQphR+VZv8qBMQ77Klcsqv9CNW2w6yLqoURLcgERAIurY6QE63bbLuqgP9ATqajFLK5AMQ=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.5", "", { "os": "win32", "cpu": "x64" }, "sha512-TXv6YnJ8ZMVdX+SXWVBo/0p8LTcrUYngpWjvm91TMjjBQii7Oz11Lw5lbDV5Y0TzuhSJHwiH4hEtC1I42mMS0g=="],
+
+    "@hey-api/client-fetch": ["@hey-api/client-fetch@0.2.4", "", {}, "sha512-SGTVAVw3PlKDLw+IyhNhb/jCH3P1P2xJzLxA8Kyz1g95HrkYOJdRpl9F5I7LLwo9aCIB7nwR2NrSeX7QaQD7vQ=="],
+
+    "@hey-api/openapi-ts": ["@hey-api/openapi-ts@0.53.12", "", { "dependencies": { "@apidevtools/json-schema-ref-parser": "11.7.2", "c12": "2.0.1", "commander": "12.1.0", "handlebars": "4.7.8" }, "peerDependencies": { "typescript": "^5.x" }, "bin": { "openapi-ts": "bin/index.cjs" } }, "sha512-cOm8AlUqJIWdLXq+Pk4mTXhEApRSc9xEWTVT8MZAyEqrN1Yhiisl2wyZGH9quzKpolq+oqvgcx61txtwHwi8vQ=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.0", "", {}, "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="],
+
+    "@jsdevtools/ono": ["@jsdevtools/ono@7.1.3", "", {}, "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg=="],
+
+    "@microsoft/api-extractor": ["@microsoft/api-extractor@7.52.8", "", { "dependencies": { "@microsoft/api-extractor-model": "7.30.6", "@microsoft/tsdoc": "~0.15.1", "@microsoft/tsdoc-config": "~0.17.1", "@rushstack/node-core-library": "5.13.1", "@rushstack/rig-package": "0.5.3", "@rushstack/terminal": "0.15.3", "@rushstack/ts-command-line": "5.0.1", "lodash": "~4.17.15", "minimatch": "~3.0.3", "resolve": "~1.22.1", "semver": "~7.5.4", "source-map": "~0.6.1", "typescript": "5.8.2" }, "bin": { "api-extractor": "bin/api-extractor" } }, "sha512-cszYIcjiNscDoMB1CIKZ3My61+JOhpERGlGr54i6bocvGLrcL/wo9o+RNXMBrb7XgLtKaizZWUpqRduQuHQLdg=="],
+
+    "@microsoft/api-extractor-model": ["@microsoft/api-extractor-model@7.30.6", "", { "dependencies": { "@microsoft/tsdoc": "~0.15.1", "@microsoft/tsdoc-config": "~0.17.1", "@rushstack/node-core-library": "5.13.1" } }, "sha512-znmFn69wf/AIrwHya3fxX6uB5etSIn6vg4Q4RB/tb5VDDs1rqREc+AvMC/p19MUN13CZ7+V/8pkYPTj7q8tftg=="],
+
+    "@microsoft/tsdoc": ["@microsoft/tsdoc@0.15.1", "", {}, "sha512-4aErSrCR/On/e5G2hDP0wjooqDdauzEbIq8hIkIe5pXV0rtWJZvdCEKL0ykZxex+IxIwBp0eGeV48hQN07dXtw=="],
+
+    "@microsoft/tsdoc-config": ["@microsoft/tsdoc-config@0.17.1", "", { "dependencies": { "@microsoft/tsdoc": "0.15.1", "ajv": "~8.12.0", "jju": "~1.4.0", "resolve": "~1.22.2" } }, "sha512-UtjIFe0C6oYgTnad4q1QP4qXwLhe6tIpNTRStJ2RZEPIkqQPREAwE5spzVxsdn9UaEMUqhh0AqSx3X4nWAKXWw=="],
+
+    "@rollup/pluginutils": ["@rollup/pluginutils@5.1.4", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ=="],
+
+    "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.41.1", "", { "os": "android", "cpu": "arm" }, "sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw=="],
+
+    "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.41.1", "", { "os": "android", "cpu": "arm64" }, "sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA=="],
+
+    "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.41.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w=="],
+
+    "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.41.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg=="],
+
+    "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.41.1", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg=="],
+
+    "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.41.1", "", { "os": "freebsd", "cpu": "x64" }, "sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA=="],
+
+    "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.41.1", "", { "os": "linux", "cpu": "arm" }, "sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg=="],
+
+    "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.41.1", "", { "os": "linux", "cpu": "arm" }, "sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA=="],
+
+    "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.41.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA=="],
+
+    "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.41.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg=="],
+
+    "@rollup/rollup-linux-loongarch64-gnu": ["@rollup/rollup-linux-loongarch64-gnu@4.41.1", "", { "os": "linux", "cpu": "none" }, "sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw=="],
+
+    "@rollup/rollup-linux-powerpc64le-gnu": ["@rollup/rollup-linux-powerpc64le-gnu@4.41.1", "", { "os": "linux", "cpu": "ppc64" }, "sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A=="],
+
+    "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.41.1", "", { "os": "linux", "cpu": "none" }, "sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw=="],
+
+    "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.41.1", "", { "os": "linux", "cpu": "none" }, "sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw=="],
+
+    "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.41.1", "", { "os": "linux", "cpu": "s390x" }, "sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g=="],
+
+    "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.41.1", "", { "os": "linux", "cpu": "x64" }, "sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A=="],
+
+    "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.41.1", "", { "os": "linux", "cpu": "x64" }, "sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ=="],
+
+    "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.41.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ=="],
+
+    "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.41.1", "", { "os": "win32", "cpu": "ia32" }, "sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg=="],
+
+    "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.41.1", "", { "os": "win32", "cpu": "x64" }, "sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw=="],
+
+    "@rushstack/node-core-library": ["@rushstack/node-core-library@5.13.1", "", { "dependencies": { "ajv": "~8.13.0", "ajv-draft-04": "~1.0.0", "ajv-formats": "~3.0.1", "fs-extra": "~11.3.0", "import-lazy": "~4.0.0", "jju": "~1.4.0", "resolve": "~1.22.1", "semver": "~7.5.4" }, "peerDependencies": { "@types/node": "*" }, "optionalPeers": ["@types/node"] }, "sha512-5yXhzPFGEkVc9Fu92wsNJ9jlvdwz4RNb2bMso+/+TH0nMm1jDDDsOIf4l8GAkPxGuwPw5DH24RliWVfSPhlW/Q=="],
+
+    "@rushstack/rig-package": ["@rushstack/rig-package@0.5.3", "", { "dependencies": { "resolve": "~1.22.1", "strip-json-comments": "~3.1.1" } }, "sha512-olzSSjYrvCNxUFZowevC3uz8gvKr3WTpHQ7BkpjtRpA3wK+T0ybep/SRUMfr195gBzJm5gaXw0ZMgjIyHqJUow=="],
+
+    "@rushstack/terminal": ["@rushstack/terminal@0.15.3", "", { "dependencies": { "@rushstack/node-core-library": "5.13.1", "supports-color": "~8.1.1" }, "peerDependencies": { "@types/node": "*" }, "optionalPeers": ["@types/node"] }, "sha512-DGJ0B2Vm69468kZCJkPj3AH5nN+nR9SPmC0rFHtzsS4lBQ7/dgOwtwVxYP7W9JPDMuRBkJ4KHmWKr036eJsj9g=="],
+
+    "@rushstack/ts-command-line": ["@rushstack/ts-command-line@5.0.1", "", { "dependencies": { "@rushstack/terminal": "0.15.3", "@types/argparse": "1.0.38", "argparse": "~1.0.9", "string-argv": "~0.3.1" } }, "sha512-bsbUucn41UXrQK7wgM8CNM/jagBytEyJqXw/umtI8d68vFm1Jwxh1OtLrlW7uGZgjCWiiPH6ooUNa1aVsuVr3Q=="],
+
+    "@types/argparse": ["@types/argparse@1.0.38", "", {}, "sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA=="],
+
+    "@types/bun": ["@types/bun@1.2.15", "", { "dependencies": { "bun-types": "1.2.15" } }, "sha512-U1ljPdBEphF0nw1MIk0hI7kPg7dFdPyM7EenHsp6W5loNHl7zqy6JQf/RKCgnUn2KDzUpkBwHPnEJEjII594bA=="],
+
+    "@types/estree": ["@types/estree@1.0.7", "", {}, "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ=="],
+
+    "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
+
+    "@types/node": ["@types/node@22.15.30", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-6Q7lr06bEHdlfplU6YRbgG1SFBdlsfNC4/lX+SkhiTs0cpJkOElmWls8PxDFv4yY/xKb8Y6SO0OmSX4wgqTZbA=="],
+
+    "@volar/language-core": ["@volar/language-core@2.4.14", "", { "dependencies": { "@volar/source-map": "2.4.14" } }, "sha512-X6beusV0DvuVseaOEy7GoagS4rYHgDHnTrdOj5jeUb49fW5ceQyP9Ej5rBhqgz2wJggl+2fDbbojq1XKaxDi6w=="],
+
+    "@volar/source-map": ["@volar/source-map@2.4.14", "", {}, "sha512-5TeKKMh7Sfxo8021cJfmBzcjfY1SsXsPMMjMvjY7ivesdnybqqS+GxGAoXHAOUawQTwtdUxgP65Im+dEmvWtYQ=="],
+
+    "@volar/typescript": ["@volar/typescript@2.4.14", "", { "dependencies": { "@volar/language-core": "2.4.14", "path-browserify": "^1.0.1", "vscode-uri": "^3.0.8" } }, "sha512-p8Z6f/bZM3/HyCdRNFZOEEzts51uV8WHeN8Tnfnm2EBv6FDB2TQLzfVx7aJvnl8ofKAOnS64B2O8bImBFaauRw=="],
+
+    "@vue/compiler-core": ["@vue/compiler-core@3.5.16", "", { "dependencies": { "@babel/parser": "^7.27.2", "@vue/shared": "3.5.16", "entities": "^4.5.0", "estree-walker": "^2.0.2", "source-map-js": "^1.2.1" } }, "sha512-AOQS2eaQOaaZQoL1u+2rCJIKDruNXVBZSiUD3chnUrsoX5ZTQMaCvXlWNIfxBJuU15r1o7+mpo5223KVtIhAgQ=="],
+
+    "@vue/compiler-dom": ["@vue/compiler-dom@3.5.16", "", { "dependencies": { "@vue/compiler-core": "3.5.16", "@vue/shared": "3.5.16" } }, "sha512-SSJIhBr/teipXiXjmWOVWLnxjNGo65Oj/8wTEQz0nqwQeP75jWZ0n4sF24Zxoht1cuJoWopwj0J0exYwCJ0dCQ=="],
+
+    "@vue/compiler-vue2": ["@vue/compiler-vue2@2.7.16", "", { "dependencies": { "de-indent": "^1.0.2", "he": "^1.2.0" } }, "sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A=="],
+
+    "@vue/language-core": ["@vue/language-core@2.2.0", "", { "dependencies": { "@volar/language-core": "~2.4.11", "@vue/compiler-dom": "^3.5.0", "@vue/compiler-vue2": "^2.7.16", "@vue/shared": "^3.5.0", "alien-signals": "^0.4.9", "minimatch": "^9.0.3", "muggle-string": "^0.4.1", "path-browserify": "^1.0.1" }, "peerDependencies": { "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-O1ZZFaaBGkKbsRfnVH1ifOK1/1BUkyK+3SQsfnh6PmMmD4qJcTU8godCeA96jjDRTL6zgnK7YzCHfaUlH2r0Mw=="],
+
+    "@vue/shared": ["@vue/shared@3.5.16", "", {}, "sha512-c/0fWy3Jw6Z8L9FmTyYfkpM5zklnqqa9+a6dz3DvONRKW2NEbh46BP0FHuLFSWi2TnQEtp91Z6zOWNrU6QiyPg=="],
+
+    "acorn": ["acorn@8.14.1", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg=="],
+
+    "ajv": ["ajv@8.12.0", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2", "uri-js": "^4.2.2" } }, "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA=="],
+
+    "ajv-draft-04": ["ajv-draft-04@1.0.0", "", { "peerDependencies": { "ajv": "^8.5.0" }, "optionalPeers": ["ajv"] }, "sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw=="],
+
+    "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="],
+
+    "alien-signals": ["alien-signals@0.4.14", "", {}, "sha512-itUAVzhczTmP2U5yX67xVpsbbOiquusbWVyA9N+sy6+r6YVbFkahXvNCeEPWEOMhwDYwbVbGHFkVL03N9I5g+Q=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="],
+
+    "bun-types": ["bun-types@1.2.15", "", { "dependencies": { "@types/node": "*" } }, "sha512-NarRIaS+iOaQU1JPfyKhZm4AsUOrwUOqRNHY0XxI8GI8jYxiLXLcdjYMG9UKS+fwWasc1uw1htV9AX24dD+p4w=="],
+
+    "c12": ["c12@2.0.1", "", { "dependencies": { "chokidar": "^4.0.1", "confbox": "^0.1.7", "defu": "^6.1.4", "dotenv": "^16.4.5", "giget": "^1.2.3", "jiti": "^2.3.0", "mlly": "^1.7.1", "ohash": "^1.1.4", "pathe": "^1.1.2", "perfect-debounce": "^1.0.0", "pkg-types": "^1.2.0", "rc9": "^2.1.2" }, "peerDependencies": { "magicast": "^0.3.5" }, "optionalPeers": ["magicast"] }, "sha512-Z4JgsKXHG37C6PYUtIxCfLJZvo6FyhHJoClwwb9ftUkLpPSkuYqn6Tr+vnaN8hymm0kIbcg6Ey3kv/Q71k5w/A=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "chownr": ["chownr@2.0.0", "", {}, "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ=="],
+
+    "citty": ["citty@0.1.6", "", { "dependencies": { "consola": "^3.2.3" } }, "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ=="],
+
+    "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="],
+
+    "compare-versions": ["compare-versions@6.1.1", "", {}, "sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "confbox": ["confbox@0.1.8", "", {}, "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w=="],
+
+    "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="],
+
+    "de-indent": ["de-indent@1.0.2", "", {}, "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg=="],
+
+    "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+
+    "defu": ["defu@6.1.4", "", {}, "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg=="],
+
+    "destr": ["destr@2.0.5", "", {}, "sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA=="],
+
+    "dotenv": ["dotenv@16.5.0", "", {}, "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg=="],
+
+    "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
+
+    "esbuild": ["esbuild@0.25.5", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.5", "@esbuild/android-arm": "0.25.5", "@esbuild/android-arm64": "0.25.5", "@esbuild/android-x64": "0.25.5", "@esbuild/darwin-arm64": "0.25.5", "@esbuild/darwin-x64": "0.25.5", "@esbuild/freebsd-arm64": "0.25.5", "@esbuild/freebsd-x64": "0.25.5", "@esbuild/linux-arm": "0.25.5", "@esbuild/linux-arm64": "0.25.5", "@esbuild/linux-ia32": "0.25.5", "@esbuild/linux-loong64": "0.25.5", "@esbuild/linux-mips64el": "0.25.5", "@esbuild/linux-ppc64": "0.25.5", "@esbuild/linux-riscv64": "0.25.5", "@esbuild/linux-s390x": "0.25.5", "@esbuild/linux-x64": "0.25.5", "@esbuild/netbsd-arm64": "0.25.5", "@esbuild/netbsd-x64": "0.25.5", "@esbuild/openbsd-arm64": "0.25.5", "@esbuild/openbsd-x64": "0.25.5", "@esbuild/sunos-x64": "0.25.5", "@esbuild/win32-arm64": "0.25.5", "@esbuild/win32-ia32": "0.25.5", "@esbuild/win32-x64": "0.25.5" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-P8OtKZRv/5J5hhz0cUAdu/cLuPIKXpQl1R9pZtvmHWQvrAUVd0UNIPT4IB4W3rNOqVO0rlqHmCIbSwxh/c9yUQ=="],
+
+    "estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="],
+
+    "eventemitter3": ["eventemitter3@5.0.1", "", {}, "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA=="],
+
+    "exsolve": ["exsolve@1.0.5", "", {}, "sha512-pz5dvkYYKQ1AHVrgOzBKWeP4u4FRb3a6DNK2ucr0OoNwYIU4QWsJ+NM36LLzORT+z845MzKHHhpXiUF5nvQoJg=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fdir": ["fdir@6.4.5", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-4BG7puHpVsIYxZUbiUE3RqGloLaSSwzYie5jvasC4LWuBWzZawynvYouhjbQKw2JuIGYdm0DzIxl8iVidKlUEw=="],
+
+    "fs-extra": ["fs-extra@11.3.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew=="],
+
+    "fs-minipass": ["fs-minipass@2.1.0", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "giget": ["giget@1.2.5", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "defu": "^6.1.4", "node-fetch-native": "^1.6.6", "nypm": "^0.5.4", "pathe": "^2.0.3", "tar": "^6.2.1" }, "bin": { "giget": "dist/cli.mjs" } }, "sha512-r1ekGw/Bgpi3HLV3h1MRBIlSAdHoIMklpaQ3OQLFcRw9PwAj2rqigvIbg+dBUI51OxVI2jsEtDywDBjSiuf7Ug=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "handlebars": ["handlebars@4.7.8", "", { "dependencies": { "minimist": "^1.2.5", "neo-async": "^2.6.2", "source-map": "^0.6.1", "wordwrap": "^1.0.0" }, "optionalDependencies": { "uglify-js": "^3.1.4" }, "bin": { "handlebars": "bin/handlebars" } }, "sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
+
+    "he": ["he@1.2.0", "", { "bin": { "he": "bin/he" } }, "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw=="],
+
+    "import-lazy": ["import-lazy@4.0.0", "", {}, "sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw=="],
+
+    "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="],
+
+    "jiti": ["jiti@2.4.2", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A=="],
+
+    "jju": ["jju@1.4.0", "", {}, "sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA=="],
+
+    "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
+
+    "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="],
+
+    "jsonfile": ["jsonfile@6.1.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ=="],
+
+    "kolorist": ["kolorist@1.8.0", "", {}, "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ=="],
+
+    "local-pkg": ["local-pkg@1.1.1", "", { "dependencies": { "mlly": "^1.7.4", "pkg-types": "^2.0.1", "quansync": "^0.2.8" } }, "sha512-WunYko2W1NcdfAFpuLUoucsgULmgDBRkdxHxWQ7mK0cQqwPiy8E1enjuRBrhLtZkB5iScJ1XIPdhVEFK8aOLSg=="],
+
+    "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="],
+
+    "lru-cache": ["lru-cache@6.0.0", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA=="],
+
+    "magic-string": ["magic-string@0.30.17", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0" } }, "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA=="],
+
+    "minimatch": ["minimatch@3.0.8", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-6FsRAQsxQ61mw+qP1ZzbL9Bc78x2p5OqNgNpnoAFLTrX8n5Kxph0CsnhmKKNXTWjXqU5L0pGPR7hYk+XWZr60Q=="],
+
+    "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
+
+    "minipass": ["minipass@5.0.0", "", {}, "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ=="],
+
+    "minizlib": ["minizlib@2.1.2", "", { "dependencies": { "minipass": "^3.0.0", "yallist": "^4.0.0" } }, "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg=="],
+
+    "mkdirp": ["mkdirp@1.0.4", "", { "bin": { "mkdirp": "bin/cmd.js" } }, "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="],
+
+    "mlly": ["mlly@1.7.4", "", { "dependencies": { "acorn": "^8.14.0", "pathe": "^2.0.1", "pkg-types": "^1.3.0", "ufo": "^1.5.4" } }, "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "muggle-string": ["muggle-string@0.4.1", "", {}, "sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
+
+    "node-fetch-native": ["node-fetch-native@1.6.6", "", {}, "sha512-8Mc2HhqPdlIfedsuZoc3yioPuzp6b+L5jRCRY1QzuWZh2EGJVQrGppC6V6cF0bLdbW0+O2YpqCA25aF/1lvipQ=="],
+
+    "nypm": ["nypm@0.5.4", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "pathe": "^2.0.3", "pkg-types": "^1.3.1", "tinyexec": "^0.3.2", "ufo": "^1.5.4" }, "bin": { "nypm": "dist/cli.mjs" } }, "sha512-X0SNNrZiGU8/e/zAB7sCTtdxWTMSIO73q+xuKgglm2Yvzwlo8UoC5FNySQFCvl84uPaeADkqHUZUkWy4aH4xOA=="],
+
+    "ohash": ["ohash@1.1.6", "", {}, "sha512-TBu7PtV8YkAZn0tSxobKY2n2aAQva936lhRrj6957aDaCf9IEtqsKbgMzXE/F/sjqYOwmrukeORHNLe5glk7Cg=="],
+
+    "path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
+
+    "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="],
+
+    "pathe": ["pathe@1.1.2", "", {}, "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ=="],
+
+    "perfect-debounce": ["perfect-debounce@1.0.0", "", {}, "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="],
+
+    "pkg-types": ["pkg-types@1.3.1", "", { "dependencies": { "confbox": "^0.1.8", "mlly": "^1.7.4", "pathe": "^2.0.1" } }, "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ=="],
+
+    "postcss": ["postcss@8.5.4", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "quansync": ["quansync@0.2.10", "", {}, "sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A=="],
+
+    "rc9": ["rc9@2.1.2", "", { "dependencies": { "defu": "^6.1.4", "destr": "^2.0.3" } }, "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg=="],
+
+    "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
+
+    "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="],
+
+    "resolve": ["resolve@1.22.10", "", { "dependencies": { "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w=="],
+
+    "rollup": ["rollup@4.41.1", "", { "dependencies": { "@types/estree": "1.0.7" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.41.1", "@rollup/rollup-android-arm64": "4.41.1", "@rollup/rollup-darwin-arm64": "4.41.1", "@rollup/rollup-darwin-x64": "4.41.1", "@rollup/rollup-freebsd-arm64": "4.41.1", "@rollup/rollup-freebsd-x64": "4.41.1", "@rollup/rollup-linux-arm-gnueabihf": "4.41.1", "@rollup/rollup-linux-arm-musleabihf": "4.41.1", "@rollup/rollup-linux-arm64-gnu": "4.41.1", "@rollup/rollup-linux-arm64-musl": "4.41.1", "@rollup/rollup-linux-loongarch64-gnu": "4.41.1", "@rollup/rollup-linux-powerpc64le-gnu": "4.41.1", "@rollup/rollup-linux-riscv64-gnu": "4.41.1", "@rollup/rollup-linux-riscv64-musl": "4.41.1", "@rollup/rollup-linux-s390x-gnu": "4.41.1", "@rollup/rollup-linux-x64-gnu": "4.41.1", "@rollup/rollup-linux-x64-musl": "4.41.1", "@rollup/rollup-win32-arm64-msvc": "4.41.1", "@rollup/rollup-win32-ia32-msvc": "4.41.1", "@rollup/rollup-win32-x64-msvc": "4.41.1", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw=="],
+
+    "semver": ["semver@7.5.4", "", { "dependencies": { "lru-cache": "^6.0.0" }, "bin": { "semver": "bin/semver.js" } }, "sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA=="],
+
+    "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="],
+
+    "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="],
+
+    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
+
+    "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
+
+    "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="],
+
+    "tar": ["tar@6.2.1", "", { "dependencies": { "chownr": "^2.0.0", "fs-minipass": "^2.0.0", "minipass": "^5.0.0", "minizlib": "^2.1.1", "mkdirp": "^1.0.3", "yallist": "^4.0.0" } }, "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A=="],
+
+    "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="],
+
+    "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "ufo": ["ufo@1.6.1", "", {}, "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA=="],
+
+    "uglify-js": ["uglify-js@3.19.3", "", { "bin": { "uglifyjs": "bin/uglifyjs" } }, "sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
+
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
+    "vite": ["vite@6.3.5", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.13" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ=="],
+
+    "vite-plugin-dts": ["vite-plugin-dts@4.5.4", "", { "dependencies": { "@microsoft/api-extractor": "^7.50.1", "@rollup/pluginutils": "^5.1.4", "@volar/typescript": "^2.4.11", "@vue/language-core": "2.2.0", "compare-versions": "^6.1.1", "debug": "^4.4.0", "kolorist": "^1.8.0", "local-pkg": "^1.0.0", "magic-string": "^0.30.17" }, "peerDependencies": { "typescript": "*", "vite": "*" }, "optionalPeers": ["vite"] }, "sha512-d4sOM8M/8z7vRXHHq/ebbblfaxENjogAAekcfcDCCwAyvGqnPrc7f4NZbvItS+g4WTgerW0xDwSz5qz11JT3vg=="],
+
+    "vscode-uri": ["vscode-uri@3.1.0", "", {}, "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ=="],
+
+    "wordwrap": ["wordwrap@1.0.0", "", {}, "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q=="],
+
+    "yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
+
+    "@microsoft/api-extractor/typescript": ["typescript@5.8.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ=="],
+
+    "@rushstack/node-core-library/ajv": ["ajv@8.13.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2", "uri-js": "^4.4.1" } }, "sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA=="],
+
+    "@rushstack/ts-command-line/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="],
+
+    "@vue/language-core/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="],
+
+    "ajv-formats/ajv": ["ajv@8.13.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2", "uri-js": "^4.4.1" } }, "sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA=="],
+
+    "fs-minipass/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "giget/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "local-pkg/pkg-types": ["pkg-types@2.1.0", "", { "dependencies": { "confbox": "^0.2.1", "exsolve": "^1.0.1", "pathe": "^2.0.3" } }, "sha512-wmJwA+8ihJixSoHKxZJRBQG1oY8Yr9pGLzRmSsNms0iNWyHHAlZCa7mmKiFR10YPZuz/2k169JiS/inOjBCZ2A=="],
+
+    "minizlib/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="],
+
+    "mlly/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "nypm/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "pkg-types/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+
+    "@vue/language-core/minimatch/brace-expansion": ["brace-expansion@2.0.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="],
+
+    "local-pkg/pkg-types/confbox": ["confbox@0.2.2", "", {}, "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ=="],
+
+    "local-pkg/pkg-types/pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="],
+  }
+}

client/js/examples/basic-consumer.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+/**
+ * Basic Consumer Example - LeRobot Arena
+ * 
+ * This example demonstrates:
+ * - Connecting to an existing room as a consumer
+ * - Receiving joint updates and state sync
+ * - Setting up callbacks
+ * - Getting current state
+ */
+
+import { RoboticsConsumer } from '../dist/robotics/index.js';
+import { createInterface } from 'readline';
+
+async function main() {
+  console.log('🤖 LeRobot Arena Basic Consumer Example 🤖');
+
+  // Get room ID from user
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const roomId = await new Promise((resolve) => {
+    rl.question('Enter room ID to connect to: ', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+
+  if (!roomId) {
+    console.error('❌ Room ID is required!');
+    return;
+  }
+
+  // Create consumer client
+  const consumer = new RoboticsConsumer('http://localhost:8000');
+
+  // Track received updates
+  let updateCount = 0;
+  let stateCount = 0;
+  const receivedUpdates = [];
+  const receivedStates = [];
+
+  // Set up callbacks
+  consumer.onJointUpdate((joints) => {
+    updateCount++;
+    console.log(`📥 [${updateCount}] Joint update: ${joints.length} joints`);
+    
+    // Show joint details
+    joints.forEach(joint => {
+      console.log(`    ${joint.name}: ${joint.value}${joint.speed ? ` (speed: ${joint.speed})` : ''}`);
+    });
+    
+    receivedUpdates.push(joints);
+  });
+
+  consumer.onStateSync((state) => {
+    stateCount++;
+    console.log(`📊 [${stateCount}] State sync: ${Object.keys(state).length} joints`);
+    
+    // Show state details
+    Object.entries(state).forEach(([name, value]) => {
+      console.log(`    ${name}: ${value}`);
+    });
+    
+    receivedStates.push(state);
+  });
+
+  consumer.onError((errorMsg) => {
+    console.error('❌ Consumer error:', errorMsg);
+  });
+
+  consumer.onConnected(() => {
+    console.log('✅ Consumer connected!');
+  });
+
+  consumer.onDisconnected(() => {
+    console.log('👋 Consumer disconnected!');
+  });
+
+  try {
+    // Connect to the room
+    console.log(`\n🔌 Connecting to room ${roomId}...`);
+    const success = await consumer.connect(roomId, 'demo-consumer');
+    
+    if (!success) {
+      console.error('❌ Failed to connect to room!');
+      console.log('💡 Make sure the room exists and the server is running');
+      return;
+    }
+
+    console.log(`✅ Connected to room ${roomId} as consumer`);
+
+    // Show connection info
+    const info = consumer.getConnectionInfo();
+    console.log('\n📊 Connection Info:');
+    console.log(`  Room ID: ${info.room_id}`);
+    console.log(`  Role: ${info.role}`);
+    console.log(`  Participant ID: ${info.participant_id}`);
+
+    // Get initial state
+    console.log('\n📋 Getting initial state...');
+    const initialState = await consumer.getStateSyncAsync();
+    console.log('Initial state:', Object.keys(initialState).length, 'joints');
+    
+    if (Object.keys(initialState).length > 0) {
+      Object.entries(initialState).forEach(([name, value]) => {
+        console.log(`  ${name}: ${value}`);
+      });
+    } else {
+      console.log('  (Empty - no joints set yet)');
+    }
+
+    // Listen for updates
+    console.log('\n👂 Listening for updates for 60 seconds...');
+    console.log('   (Producer can send commands during this time)');
+    
+    const startTime = Date.now();
+    const duration = 60000; // 60 seconds
+
+    // Show periodic status
+    const statusInterval = setInterval(() => {
+      const elapsed = Date.now() - startTime;
+      const remaining = Math.max(0, duration - elapsed);
+      
+      if (remaining > 0) {
+        console.log(`\n📊 Status (${Math.floor(remaining / 1000)}s remaining):`);
+        console.log(`   Updates received: ${updateCount}`);
+        console.log(`   State syncs received: ${stateCount}`);
+      }
+    }, 10000); // Every 10 seconds
+
+    await new Promise(resolve => setTimeout(resolve, duration));
+    clearInterval(statusInterval);
+
+    // Show final summary
+    console.log('\n📊 Final Summary:');
+    console.log(`   Total updates received: ${updateCount}`);
+    console.log(`   Total state syncs received: ${stateCount}`);
+    
+    // Get final state
+    const finalState = await consumer.getStateSyncAsync();
+    console.log('\n📋 Final state:');
+    if (Object.keys(finalState).length > 0) {
+      Object.entries(finalState).forEach(([name, value]) => {
+        console.log(`  ${name}: ${value}`);
+      });
+    } else {
+      console.log('  (Empty)');
+    }
+
+    console.log('\n✅ Basic consumer example completed!');
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+  } finally {
+    // Always disconnect
+    if (consumer.isConnected()) {
+      console.log('\n🧹 Disconnecting...');
+      await consumer.disconnect();
+    }
+    console.log('👋 Goodbye!');
+  }
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Received SIGINT, shutting down gracefully...');
+  process.exit(0);
+});
+
+main().catch(console.error); 

client/js/examples/basic-producer.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+/**
+ * Basic Producer Example - LeRobot Arena
+ * 
+ * This example demonstrates:
+ * - Creating a room
+ * - Connecting as a producer
+ * - Sending joint updates and state sync
+ * - Basic error handling
+ */
+
+import { RoboticsProducer } from '../dist/robotics/index.js';
+
+async function main() {
+  console.log('🤖 LeRobot Arena Basic Producer Example 🤖');
+
+  // Create producer client
+  const producer = new RoboticsProducer('http://localhost:8000');
+
+  // Set up event callbacks
+  producer.onConnected(() => {
+    console.log('✅ Producer connected!');
+  });
+
+  producer.onDisconnected(() => {
+    console.log('👋 Producer disconnected!');
+  });
+
+  producer.onError((error) => {
+    console.error('❌ Producer error:', error);
+  });
+
+  try {
+    // Create a room
+    console.log('\n📦 Creating room...');
+    const roomId = await producer.createRoom();
+    console.log(`✅ Room created: ${roomId}`);
+
+    // Connect as producer
+    console.log('\n🔌 Connecting as producer...');
+    const success = await producer.connect(roomId, 'demo-producer');
+    
+    if (!success) {
+      console.error('❌ Failed to connect as producer!');
+      return;
+    }
+
+    console.log(`✅ Connected to room ${roomId} as producer`);
+
+    // Show connection info
+    const info = producer.getConnectionInfo();
+    console.log('\n📊 Connection Info:');
+    console.log(`  Room ID: ${info.room_id}`);
+    console.log(`  Role: ${info.role}`);
+    console.log(`  Participant ID: ${info.participant_id}`);
+
+    // Send initial state sync
+    console.log('\n📤 Sending initial state...');
+    await producer.sendStateSync({
+      base: 0.0,
+      shoulder: 0.0,
+      elbow: 0.0,
+      wrist: 0.0,
+      gripper: 0.0
+    });
+    console.log('✅ Initial state sent');
+
+    // Simulate robot movement
+    console.log('\n🤖 Simulating robot movement...');
+    
+    const movements = [
+      { name: 'shoulder', value: 45.0, description: 'Raise shoulder' },
+      { name: 'elbow', value: -30.0, description: 'Bend elbow' },
+      { name: 'wrist', value: 15.0, description: 'Turn wrist' },
+      { name: 'gripper', value: 0.5, description: 'Close gripper' },
+    ];
+
+    for (let i = 0; i < movements.length; i++) {
+      const movement = movements[i];
+      console.log(`  ${i + 1}. ${movement.description}: ${movement.value}°`);
+      
+      await producer.sendJointUpdate([{
+        name: movement.name,
+        value: movement.value
+      }]);
+
+      // Wait between movements
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    // Send combined update
+    console.log('\n📤 Sending combined update...');
+    await producer.sendJointUpdate([
+      { name: 'base', value: 90.0 },
+      { name: 'shoulder', value: 60.0 },
+      { name: 'elbow', value: -45.0 }
+    ]);
+    console.log('✅ Combined update sent');
+
+    // Send heartbeat
+    console.log('\n💓 Sending heartbeat...');
+    await producer.sendHeartbeat();
+    console.log('✅ Heartbeat sent');
+
+    // Demonstrate emergency stop
+    console.log('\n🚨 Testing emergency stop...');
+    await producer.sendEmergencyStop('Demo emergency stop - testing safety');
+    console.log('✅ Emergency stop sent');
+
+    console.log('\n✅ Basic producer example completed!');
+    console.log(`\n💡 Room ID: ${roomId}`);
+    console.log('   You can use this room ID with the consumer example');
+
+    // Keep running for a bit to allow consumers to connect
+    console.log('\n⏳ Keeping producer alive for 30 seconds...');
+    console.log('   (Consumers can connect during this time)');
+    await new Promise(resolve => setTimeout(resolve, 30000));
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+  } finally {
+    // Always disconnect and cleanup
+    if (producer.isConnected()) {
+      console.log('\n🧹 Cleaning up...');
+      await producer.disconnect();
+      
+      // Optionally delete the room
+      const roomId = producer.currentRoomId;
+      if (roomId) {
+        await producer.deleteRoom(roomId);
+        console.log(`🗑️  Deleted room ${roomId}`);
+      }
+    }
+    console.log('👋 Goodbye!');
+  }
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Received SIGINT, shutting down gracefully...');
+  process.exit(0);
+});
+
+main().catch(console.error); 

client/js/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "lerobot-arena-client",
+  "version": "1.0.0",
+  "description": "Modular TypeScript client library for LeRobot Arena - video streaming, robotics control, and sensor data",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./video": {
+      "import": "./dist/video.js",
+      "types": "./dist/video.d.ts"
+    },
+    "./robotics": {
+      "import": "./dist/robotics.js", 
+      "types": "./dist/robotics.d.ts"
+    },
+    "./audio": {
+      "import": "./dist/audio.js",
+      "types": "./dist/audio.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run vite build",
+    "dev": "bun run vite build --watch", 
+    "test": "bun test",
+    "lint": "bun run eslint src --ext ts,tsx",
+    "lint:fix": "bun run eslint src --ext ts,tsx --fix",
+    "typecheck": "bun run tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prebuild": "bun run clean"
+  },
+  "keywords": [
+    "lerobot",
+    "arena", 
+    "webrtc",
+    "video-streaming",
+    "robotics",
+    "real-time",
+    "typescript",
+    "client-library"
+  ],
+  "author": "LeRobot Arena Team",
+  "license": "MIT",
+  "dependencies": {
+    "eventemitter3": "^5.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.15",
+    "typescript": "^5.3.3",
+    "vite": "6.3.5",
+    "vite-plugin-dts": "4.5.4"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lerobot-arena/lerobot-arena.git",
+    "directory": "src-python-video/clients/js"
+  },
+  "bugs": {
+    "url": "https://github.com/lerobot-arena/lerobot-arena/issues"
+  },
+  "homepage": "https://github.com/lerobot-arena/lerobot-arena#readme",
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "private": true
+}

client/js/src/index.ts

@@ -0,0 +1,12 @@
+/**
+ * LeRobot Arena Client Library - TypeScript/JavaScript
+ * 
+ * Main entry point for the robotics client library.
+ */
+
+// Re-export everything from robotics module
+export * as robotics from './robotics/index.js';
+export * as video from './video/index.js';
+
+// Version info
+export const VERSION = '1.0.0';

client/js/src/robotics/consumer.ts

@@ -0,0 +1,108 @@
+/**
+ * Consumer client for receiving robot commands in LeRobot Arena
+ */
+
+import { RoboticsClientCore } from './core.js';
+import type {
+  WebSocketMessage,
+  JointUpdateMessage,
+  StateSyncMessage,
+  ClientOptions,
+  JointUpdateCallback,
+  StateSyncCallback,
+} from './types.js';
+
+export class RoboticsConsumer extends RoboticsClientCore {
+  // Event callbacks
+  private onStateSyncCallback: StateSyncCallback | null = null;
+  private onJointUpdateCallback: JointUpdateCallback | null = null;
+
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super(baseUrl, options);
+  }
+
+  // ============= CONSUMER CONNECTION =============
+
+  async connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean> {
+    return this.connectToRoom(workspaceId, roomId, 'consumer', participantId);
+  }
+
+  // ============= CONSUMER METHODS =============
+
+  async getStateSyncAsync(): Promise<Record<string, number>> {
+    if (!this.workspaceId || !this.roomId) {
+      throw new Error('Must be connected to a room');
+    }
+
+    const state = await this.getRoomState(this.workspaceId, this.roomId);
+    return state.joints;
+  }
+
+  // ============= EVENT CALLBACKS =============
+
+  onStateSync(callback: StateSyncCallback): void {
+    this.onStateSyncCallback = callback;
+  }
+
+  onJointUpdate(callback: JointUpdateCallback): void {
+    this.onJointUpdateCallback = callback;
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected override handleRoleSpecificMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'state_sync':
+        this.handleStateSync(message as StateSyncMessage);
+        break;
+      case 'joint_update':
+        this.handleJointUpdate(message as JointUpdateMessage);
+        break;
+      case 'emergency_stop':
+        console.warn(`🚨 Emergency stop: ${message.reason || 'Unknown reason'}`);
+        this.handleError(`Emergency stop: ${message.reason || 'Unknown reason'}`);
+        break;
+      case 'error':
+        console.error(`Server error: ${message.message}`);
+        this.handleError(message.message);
+        break;
+      default:
+        console.warn(`Unknown message type for consumer: ${message.type}`);
+    }
+  }
+
+  private handleStateSync(message: StateSyncMessage): void {
+    if (this.onStateSyncCallback) {
+      this.onStateSyncCallback(message.data);
+    }
+    this.emit('stateSync', message.data);
+  }
+
+  private handleJointUpdate(message: JointUpdateMessage): void {
+    if (this.onJointUpdateCallback) {
+      this.onJointUpdateCallback(message.data);
+    }
+    this.emit('jointUpdate', message.data);
+  }
+
+  // ============= UTILITY METHODS =============
+
+  /**
+   * Create a consumer and automatically connect to a room
+   */
+  static async createAndConnect(
+    workspaceId: string,
+    roomId: string,
+    baseUrl = 'http://localhost:8000',
+    participantId?: string
+  ): Promise<RoboticsConsumer> {
+    const consumer = new RoboticsConsumer(baseUrl);
+    const connected = await consumer.connect(workspaceId, roomId, participantId);
+    
+    if (!connected) {
+      throw new Error('Failed to connect as consumer');
+    }
+    
+    return consumer;
+  }
+} 

client/js/src/robotics/core.ts

@@ -0,0 +1,295 @@
+/**
+ * Core robotics client for LeRobot Arena
+ * Base class providing REST API and WebSocket functionality
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import type {
+  ParticipantRole,
+  RoomInfo,
+  RoomState,
+  ConnectionInfo,
+  WebSocketMessage,
+  JoinMessage,
+  ListRoomsResponse,
+  CreateRoomResponse,
+  GetRoomResponse,
+  GetRoomStateResponse,
+  DeleteRoomResponse,
+  ClientOptions,
+  ErrorCallback,
+  ConnectedCallback,
+  DisconnectedCallback,
+} from './types.js';
+
+export class RoboticsClientCore extends EventEmitter {
+  protected baseUrl: string;
+  protected apiBase: string;
+  protected websocket: WebSocket | null = null;
+  protected workspaceId: string | null = null;
+  protected roomId: string | null = null;
+  protected role: ParticipantRole | null = null;
+  protected participantId: string | null = null;
+  protected connected = false;
+  protected options: ClientOptions;
+
+  // Event callbacks
+  protected onErrorCallback: ErrorCallback | null = null;
+  protected onConnectedCallback: ConnectedCallback | null = null;
+  protected onDisconnectedCallback: DisconnectedCallback | null = null;
+
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super();
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.apiBase = `${this.baseUrl}/robotics`;
+    this.options = {
+      timeout: 5000,
+      reconnect_attempts: 3,
+      heartbeat_interval: 30000,
+      ...options,
+    };
+  }
+
+  // ============= REST API METHODS =============
+
+  async listRooms(workspaceId: string): Promise<RoomInfo[]> {
+    const response = await this.fetchApi<ListRoomsResponse>(`/workspaces/${workspaceId}/rooms`);
+    return response.rooms;
+  }
+
+  async createRoom(workspaceId?: string, roomId?: string): Promise<{ workspaceId: string; roomId: string }> {
+    // Generate workspace ID if not provided
+    const finalWorkspaceId = workspaceId || this.generateWorkspaceId();
+    
+    const payload = roomId ? { room_id: roomId, workspace_id: finalWorkspaceId } : { workspace_id: finalWorkspaceId };
+    const response = await this.fetchApi<CreateRoomResponse>(`/workspaces/${finalWorkspaceId}/rooms`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    return { workspaceId: response.workspace_id, roomId: response.room_id };
+  }
+
+  async deleteRoom(workspaceId: string, roomId: string): Promise<boolean> {
+    try {
+      const response = await this.fetchApi<DeleteRoomResponse>(`/workspaces/${workspaceId}/rooms/${roomId}`, {
+        method: 'DELETE',
+      });
+      return response.success;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  async getRoomState(workspaceId: string, roomId: string): Promise<RoomState> {
+    const response = await this.fetchApi<GetRoomStateResponse>(`/workspaces/${workspaceId}/rooms/${roomId}/state`);
+    return response.state;
+  }
+
+  async getRoomInfo(workspaceId: string, roomId: string): Promise<RoomInfo> {
+    const response = await this.fetchApi<GetRoomResponse>(`/workspaces/${workspaceId}/rooms/${roomId}`);
+    return response.room;
+  }
+
+  // ============= WEBSOCKET CONNECTION =============
+
+  async connectToRoom(
+    workspaceId: string,
+    roomId: string,
+    role: ParticipantRole,
+    participantId?: string
+  ): Promise<boolean> {
+    if (this.connected) {
+      await this.disconnect();
+    }
+
+    this.workspaceId = workspaceId;
+    this.roomId = roomId;
+    this.role = role;
+    this.participantId = participantId || `${role}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Convert HTTP URL to WebSocket URL
+    const wsUrl = this.baseUrl
+      .replace(/^http/, 'ws')
+      .replace(/^https/, 'wss');
+    const wsEndpoint = `${wsUrl}/robotics/workspaces/${workspaceId}/rooms/${roomId}/ws`;
+
+    try {
+      this.websocket = new WebSocket(wsEndpoint);
+
+      // Set up WebSocket event handlers
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Connection timeout'));
+        }, this.options.timeout || 5000);
+
+        this.websocket!.onopen = () => {
+          clearTimeout(timeout);
+          this.sendJoinMessage();
+        };
+
+        this.websocket!.onmessage = (event) => {
+          try {
+            const message: WebSocketMessage = JSON.parse(event.data);
+            this.handleMessage(message);
+
+            // Handle initial connection responses
+            if (message.type === 'joined') {
+              this.connected = true;
+              this.onConnectedCallback?.();
+              this.emit('connected');
+              resolve(true);
+            } else if (message.type === 'error') {
+              this.handleError(message.message);
+              resolve(false);
+            }
+          } catch (error) {
+            console.error('Failed to parse WebSocket message:', error);
+          }
+        };
+
+        this.websocket!.onerror = (error) => {
+          clearTimeout(timeout);
+          console.error('WebSocket error:', error);
+          this.handleError('WebSocket connection error');
+          reject(error);
+        };
+
+        this.websocket!.onclose = () => {
+          clearTimeout(timeout);
+          this.connected = false;
+          this.onDisconnectedCallback?.();
+          this.emit('disconnected');
+        };
+      });
+    } catch (error) {
+      console.error('Failed to connect to room:', error);
+      return false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+      this.websocket.close();
+    }
+
+    this.websocket = null;
+    this.connected = false;
+    this.workspaceId = null;
+    this.roomId = null;
+    this.role = null;
+    this.participantId = null;
+
+    this.onDisconnectedCallback?.();
+    this.emit('disconnected');
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected sendJoinMessage(): void {
+    if (!this.websocket || !this.participantId || !this.role) return;
+
+    const joinMessage: JoinMessage = {
+      participant_id: this.participantId,
+      role: this.role,
+    };
+
+    this.websocket.send(JSON.stringify(joinMessage));
+  }
+
+  protected handleMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'joined':
+        console.log(`Successfully joined room ${message.room_id} as ${message.role}`);
+        break;
+      case 'heartbeat_ack':
+        console.debug('Heartbeat acknowledged');
+        break;
+      case 'error':
+        this.handleError(message.message);
+        break;
+      default:
+        // Let subclasses handle specific message types
+        this.handleRoleSpecificMessage(message);
+    }
+  }
+
+  protected handleRoleSpecificMessage(message: WebSocketMessage): void {
+    // To be overridden by subclasses
+    this.emit('message', message);
+  }
+
+  protected handleError(errorMessage: string): void {
+    console.error('Client error:', errorMessage);
+    this.onErrorCallback?.(errorMessage);
+    this.emit('error', errorMessage);
+  }
+
+  // ============= UTILITY METHODS =============
+
+  async sendHeartbeat(): Promise<void> {
+    if (!this.connected || !this.websocket) return;
+
+    const message = { type: 'heartbeat' as const };
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  getConnectionInfo(): ConnectionInfo {
+    return {
+      connected: this.connected,
+      workspace_id: this.workspaceId,
+      room_id: this.roomId,
+      role: this.role,
+      participant_id: this.participantId,
+      base_url: this.baseUrl,
+    };
+  }
+
+  // ============= EVENT CALLBACK SETTERS =============
+
+  onError(callback: ErrorCallback): void {
+    this.onErrorCallback = callback;
+  }
+
+  onConnected(callback: ConnectedCallback): void {
+    this.onConnectedCallback = callback;
+  }
+
+  onDisconnected(callback: DisconnectedCallback): void {
+    this.onDisconnectedCallback = callback;
+  }
+
+  // ============= PRIVATE HELPERS =============
+
+  private async fetchApi<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.apiBase}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      signal: AbortSignal.timeout(this.options.timeout || 5000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  // ============= WORKSPACE HELPERS =============
+
+  protected generateWorkspaceId(): string {
+    // Generate a UUID-like workspace ID
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+} 

client/js/src/robotics/factory.ts

@@ -0,0 +1,66 @@
+/**
+ * Factory functions for creating LeRobot Arena robotics clients
+ */
+
+import { RoboticsProducer } from './producer.js';
+import { RoboticsConsumer } from './consumer.js';
+import type { ParticipantRole, ClientOptions } from './types.js';
+
+/**
+ * Factory function to create the appropriate client based on role
+ */
+export function createClient(
+  role: ParticipantRole,
+  baseUrl = 'http://localhost:8000',
+  options: ClientOptions = {}
+): RoboticsProducer | RoboticsConsumer {
+  if (role === 'producer') {
+    return new RoboticsProducer(baseUrl, options);
+  }
+  if (role === 'consumer') {
+    return new RoboticsConsumer(baseUrl, options);
+  }
+  throw new Error(`Invalid role: ${role}. Must be 'producer' or 'consumer'`);
+}
+
+/**
+ * Create and connect a producer client
+ */
+export async function createProducerClient(
+  baseUrl = 'http://localhost:8000',
+  workspaceId?: string,
+  roomId?: string,
+  participantId?: string,
+  options: ClientOptions = {}
+): Promise<RoboticsProducer> {
+  const producer = new RoboticsProducer(baseUrl, options);
+
+  const roomData = await producer.createRoom(workspaceId, roomId);
+  const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
+
+  if (!connected) {
+    throw new Error('Failed to connect as producer');
+  }
+
+  return producer;
+}
+
+/**
+ * Create and connect a consumer client
+ */
+export async function createConsumerClient(
+  workspaceId: string,
+  roomId: string,
+  baseUrl = 'http://localhost:8000',
+  participantId?: string,
+  options: ClientOptions = {}
+): Promise<RoboticsConsumer> {
+  const consumer = new RoboticsConsumer(baseUrl, options);
+  const connected = await consumer.connect(workspaceId, roomId, participantId);
+
+  if (!connected) {
+    throw new Error('Failed to connect as consumer');
+  }
+
+  return consumer;
+} 

client/js/src/robotics/index.ts

@@ -0,0 +1,16 @@
+/**
+ * LeRobot Arena Robotics Client - Main Module
+ * 
+ * TypeScript/JavaScript client for robotics control and monitoring
+ */
+
+// Export core classes
+export { RoboticsClientCore } from './core.js';
+export { RoboticsProducer } from './producer.js';
+export { RoboticsConsumer } from './consumer.js';
+
+// Export all types
+export * from './types.js';
+
+// Export factory functions for convenience
+export { createProducerClient, createConsumerClient, createClient } from './factory.js';

client/js/src/robotics/producer.ts

@@ -0,0 +1,114 @@
+/**
+ * Producer client for controlling robots in LeRobot Arena
+ */
+
+import { RoboticsClientCore } from './core.js';
+import type {
+  JointData,
+  WebSocketMessage,
+  JointUpdateMessage,
+  ClientOptions,
+} from './types.js';
+
+export class RoboticsProducer extends RoboticsClientCore {
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super(baseUrl, options);
+  }
+
+  // ============= PRODUCER CONNECTION =============
+
+  async connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean> {
+    return this.connectToRoom(workspaceId, roomId, 'producer', participantId);
+  }
+
+  // ============= PRODUCER METHODS =============
+
+  async sendJointUpdate(joints: JointData[]): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to send joint updates');
+    }
+
+    const message: JointUpdateMessage = {
+      type: 'joint_update',
+      data: joints,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  async sendStateSync(state: Record<string, number>): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to send state sync');
+    }
+
+    // Convert state object to joint updates format
+    const joints: JointData[] = Object.entries(state).map(([name, value]) => ({
+      name,
+      value,
+    }));
+
+    await this.sendJointUpdate(joints);
+  }
+
+  async sendEmergencyStop(reason = 'Emergency stop'): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to send emergency stop');
+    }
+
+    const message = {
+      type: 'emergency_stop' as const,
+      reason,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected override handleRoleSpecificMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'emergency_stop':
+        console.warn(`🚨 Emergency stop: ${message.reason || 'Unknown reason'}`);
+        this.handleError(`Emergency stop: ${message.reason || 'Unknown reason'}`);
+        break;
+      case 'error':
+        console.error(`Server error: ${message.message}`);
+        this.handleError(message.message);
+        break;
+      default:
+        console.warn(`Unknown message type for producer: ${message.type}`);
+    }
+  }
+
+  // ============= UTILITY METHODS =============
+
+  /**
+   * Create a room and automatically connect as producer
+   */
+  static async createAndConnect(
+    baseUrl = 'http://localhost:8000',
+    workspaceId?: string,
+    roomId?: string,
+    participantId?: string
+  ): Promise<RoboticsProducer> {
+    const producer = new RoboticsProducer(baseUrl);
+    
+    const roomData = await producer.createRoom(workspaceId, roomId);
+    const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
+    
+    if (!connected) {
+      throw new Error('Failed to connect as producer');
+    }
+    
+    return producer;
+  }
+
+  /**
+   * Get the current room ID (useful when auto-created)
+   */
+  get currentRoomId(): string | null {
+    return this.roomId;
+  }
+} 

client/js/src/robotics/types.ts

@@ -0,0 +1,180 @@
+/**
+ * Type definitions for LeRobot Arena Robotics Client
+ */
+
+// ============= CORE TYPES =============
+
+export type ParticipantRole = 'producer' | 'consumer';
+
+export type MessageType = 
+  | 'joint_update'
+  | 'state_sync' 
+  | 'heartbeat'
+  | 'heartbeat_ack'
+  | 'emergency_stop'
+  | 'joined'
+  | 'error';
+
+// ============= DATA STRUCTURES =============
+
+export interface JointData {
+  name: string;
+  value: number;
+  speed?: number;
+}
+
+export interface RoomInfo {
+  id: string;
+  workspace_id: string;
+  participants: {
+    producer: string | null;
+    consumers: string[];
+    total: number;
+  };
+  joints_count: number;
+  has_producer?: boolean;
+  active_consumers?: number;
+}
+
+export interface RoomState {
+  room_id: string;
+  workspace_id: string;
+  joints: Record<string, number>;
+  participants: {
+    producer: string | null;
+    consumers: string[];
+    total: number;
+  };
+  timestamp: string;
+}
+
+export interface ConnectionInfo {
+  connected: boolean;
+  workspace_id: string | null;
+  room_id: string | null;
+  role: ParticipantRole | null;
+  participant_id: string | null;
+  base_url: string;
+}
+
+// ============= MESSAGE TYPES =============
+
+export interface BaseMessage {
+  type: MessageType;
+  timestamp?: string;
+}
+
+export interface JointUpdateMessage extends BaseMessage {
+  type: 'joint_update';
+  data: JointData[];
+  source?: string;
+}
+
+export interface StateSyncMessage extends BaseMessage {
+  type: 'state_sync';
+  data: Record<string, number>;
+}
+
+export interface HeartbeatMessage extends BaseMessage {
+  type: 'heartbeat';
+}
+
+export interface HeartbeatAckMessage extends BaseMessage {
+  type: 'heartbeat_ack';
+}
+
+export interface EmergencyStopMessage extends BaseMessage {
+  type: 'emergency_stop';
+  reason: string;
+  source?: string;
+}
+
+export interface JoinedMessage extends BaseMessage {
+  type: 'joined';
+  room_id: string;
+  role: ParticipantRole;
+}
+
+export interface ErrorMessage extends BaseMessage {
+  type: 'error';
+  message: string;
+}
+
+export type WebSocketMessage = 
+  | JointUpdateMessage
+  | StateSyncMessage
+  | HeartbeatMessage
+  | HeartbeatAckMessage
+  | EmergencyStopMessage
+  | JoinedMessage
+  | ErrorMessage;
+
+// ============= API RESPONSE TYPES =============
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface ListRoomsResponse {
+  success: boolean;
+  workspace_id: string;
+  rooms: RoomInfo[];
+  total: number;
+}
+
+export interface CreateRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  room_id: string;
+  message: string;
+}
+
+export interface GetRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  room: RoomInfo;
+}
+
+export interface GetRoomStateResponse {
+  success: boolean;
+  workspace_id: string;
+  state: RoomState;
+}
+
+export interface DeleteRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  message: string;
+}
+
+// ============= REQUEST TYPES =============
+
+export interface CreateRoomRequest {
+  room_id?: string;
+  workspace_id?: string;  // Optional - will be generated if not provided
+}
+
+export interface JoinMessage {
+  participant_id: string;
+  role: ParticipantRole;
+}
+
+// ============= EVENT CALLBACK TYPES =============
+
+export type JointUpdateCallback = (joints: JointData[]) => void;
+export type StateSyncCallback = (state: Record<string, number>) => void;
+export type ErrorCallback = (error: string) => void;
+export type ConnectedCallback = () => void;
+export type DisconnectedCallback = () => void;
+
+// ============= CLIENT OPTIONS =============
+
+export interface ClientOptions {
+  base_url?: string;
+  timeout?: number;
+  reconnect_attempts?: number;
+  heartbeat_interval?: number;
+} 

client/js/src/video/consumer.ts

@@ -0,0 +1,430 @@
+/**
+ * Consumer client for receiving video streams in LeRobot Arena
+ */
+
+import { VideoClientCore } from './core.js';
+import type {
+  WebSocketMessage,
+  FrameUpdateMessage,
+  VideoConfigUpdateMessage,
+  StreamStartedMessage,
+  StreamStoppedMessage,
+  RecoveryTriggeredMessage,
+  StatusUpdateMessage,
+  StreamStatsMessage,
+  ClientOptions,
+  WebRTCStats,
+  FrameUpdateCallback,
+  VideoConfigUpdateCallback,
+  StreamStartedCallback,
+  StreamStoppedCallback,
+  RecoveryTriggeredCallback,
+  StatusUpdateCallback,
+  StreamStatsCallback,
+  WebRTCOfferMessage,
+  WebRTCIceMessage,
+} from './types.js';
+
+export class VideoConsumer extends VideoClientCore {
+  // Event callbacks
+  private onFrameUpdateCallback: FrameUpdateCallback | null = null;
+  private onVideoConfigUpdateCallback: VideoConfigUpdateCallback | null = null;
+  private onStreamStartedCallback: StreamStartedCallback | null = null;
+  private onStreamStoppedCallback: StreamStoppedCallback | null = null;
+  private onRecoveryTriggeredCallback: RecoveryTriggeredCallback | null = null;
+  private onStatusUpdateCallback: StatusUpdateCallback | null = null;
+  private onStreamStatsCallback: StreamStatsCallback | null = null;
+
+  // ICE candidate queuing for proper timing
+  private iceCandidateQueue: { candidate: RTCIceCandidate; fromProducer: string }[] = [];
+  private hasRemoteDescription = false;
+
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super(baseUrl, options);
+  }
+
+  // ============= CONSUMER CONNECTION =============
+
+  async connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean> {
+    const connected = await this.connectToRoom(workspaceId, roomId, 'consumer', participantId);
+    
+    if (connected) {
+      // Create peer connection immediately so we're ready for WebRTC offers
+      console.info('🔧 Creating peer connection for consumer...');
+      await this.startReceiving();
+    }
+    
+    return connected;
+  }
+
+  // ============= CONSUMER METHODS =============
+
+  async startReceiving(): Promise<void> {
+    if (!this.connected) {
+      throw new Error('Must be connected to start receiving');
+    }
+
+    // Reset WebRTC state
+    this.hasRemoteDescription = false;
+    this.iceCandidateQueue = [];
+
+    // Create peer connection for receiving
+    this.createPeerConnection();
+    
+    // Set up to receive remote stream
+    if (this.peerConnection) {
+      this.peerConnection.ontrack = (event: RTCTrackEvent) => {
+        console.info('📺 Received remote track:', event.track.kind);
+        this.remoteStream = event.streams[0] || null;
+        this.emit('remoteStream', this.remoteStream);
+        this.emit('streamReceived', this.remoteStream);
+      };
+    }
+  }
+
+  async stopReceiving(): Promise<void> {
+    if (this.peerConnection) {
+      this.peerConnection.close();
+      this.peerConnection = null;
+    }
+    this.remoteStream = null;
+    this.emit('streamStopped');
+  }
+
+  // ============= WEBRTC NEGOTIATION =============
+
+  async handleWebRTCOffer(message: WebRTCOfferMessage): Promise<void> {
+    try {
+      console.info(`📥 Received WebRTC offer from producer ${message.from_producer}`);
+      
+      if (!this.peerConnection) {
+        console.warn('No peer connection available to handle offer');
+        return;
+      }
+
+      // Reset state for new offer
+      this.hasRemoteDescription = false;
+      this.iceCandidateQueue = [];
+
+      // Set remote description (the offer)
+      await this.setRemoteDescription(message.offer);
+      this.hasRemoteDescription = true;
+      
+      // Process any queued ICE candidates now that we have remote description
+      await this.processQueuedIceCandidates();
+      
+      // Create answer
+      const answer = await this.createAnswer(message.offer);
+      
+      console.info(`📤 Sending WebRTC answer to producer ${message.from_producer}`);
+      
+      // Send answer back through server to producer
+      if (this.workspaceId && this.roomId && this.participantId) {
+        await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
+          type: 'answer',
+          sdp: answer.sdp,
+          target_producer: message.from_producer,
+        } as Record<string, unknown>);
+      }
+      
+      console.info('✅ WebRTC negotiation completed from consumer side');
+    } catch (error) {
+      console.error('Failed to handle WebRTC offer:', error);
+      this.handleError(`Failed to handle WebRTC offer: ${error}`);
+    }
+  }
+
+  private async handleWebRTCIce(message: WebRTCIceMessage): Promise<void> {
+    if (!this.peerConnection) {
+      console.warn('No peer connection available to handle ICE');
+      return;
+    }
+
+    try {
+      console.info(`📥 Received WebRTC ICE from producer ${message.from_producer}`);
+      
+      const candidate = new RTCIceCandidate(message.candidate);
+      
+      if (!this.hasRemoteDescription) {
+        // Queue ICE candidate until we have remote description
+        console.info(`🔄 Queuing ICE candidate from ${message.from_producer} (no remote description yet)`);
+        this.iceCandidateQueue.push({
+          candidate,
+          fromProducer: message.from_producer || 'unknown'
+        });
+        return;
+      }
+      
+      // Add ICE candidate to peer connection
+      await this.peerConnection.addIceCandidate(candidate);
+      
+      console.info(`✅ WebRTC ICE handled from producer ${message.from_producer}`);
+    } catch (error) {
+      console.error(`Failed to handle WebRTC ICE from ${message.from_producer}:`, error);
+      this.handleError(`Failed to handle WebRTC ICE: ${error}`);
+    }
+  }
+
+  private async processQueuedIceCandidates(): Promise<void> {
+    if (this.iceCandidateQueue.length === 0) {
+      return;
+    }
+
+    console.info(`🔄 Processing ${this.iceCandidateQueue.length} queued ICE candidates`);
+    
+    for (const { candidate, fromProducer } of this.iceCandidateQueue) {
+      try {
+        if (this.peerConnection) {
+          await this.peerConnection.addIceCandidate(candidate);
+          console.info(`✅ Processed queued ICE candidate from ${fromProducer}`);
+        }
+      } catch (error) {
+        console.error(`Failed to process queued ICE candidate from ${fromProducer}:`, error);
+      }
+    }
+    
+    // Clear the queue
+    this.iceCandidateQueue = [];
+  }
+
+  // Override to add producer targeting for ICE candidates
+  override createPeerConnection(): RTCPeerConnection {
+    const config: RTCConfiguration = {
+      iceServers: this.webrtcConfig.iceServers || [
+        { urls: 'stun:stun.l.google.com:19302' }
+      ]
+    };
+
+    this.peerConnection = new RTCPeerConnection(config);
+
+    // Connection state changes
+    this.peerConnection.onconnectionstatechange = () => {
+      const state = this.peerConnection?.connectionState;
+      console.info(`🔌 WebRTC connection state: ${state}`);
+    };
+
+    // ICE connection state
+    this.peerConnection.oniceconnectionstatechange = () => {
+      const state = this.peerConnection?.iceConnectionState;
+      console.info(`🧊 ICE connection state: ${state}`);
+    };
+
+    // ICE candidate handling - send to producer
+    this.peerConnection.onicecandidate = (event: RTCPeerConnectionIceEvent) => {
+      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
+        // Send ICE candidate to producer
+        this.sendIceCandidateToProducer(event.candidate);
+      }
+    };
+
+    // Handle remote stream
+    this.peerConnection.ontrack = (event: RTCTrackEvent) => {
+      console.info('📺 Received remote track:', event.track.kind);
+      this.remoteStream = event.streams[0] || null;
+      this.emit('remoteStream', this.remoteStream);
+      this.emit('streamReceived', this.remoteStream);
+    };
+
+    return this.peerConnection;
+  }
+
+  private async sendIceCandidateToProducer(candidate: RTCIceCandidate): Promise<void> {
+    if (!this.workspaceId || !this.roomId || !this.participantId) return;
+
+    try {
+      // Get room info to find the producer
+      const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
+      
+      if (roomInfo.participants.producer) {
+        await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
+          type: 'ice',
+          candidate: candidate.toJSON(),
+          target_producer: roomInfo.participants.producer,
+        } as Record<string, unknown>);
+      }
+    } catch (error) {
+      console.error('Failed to send ICE candidate to producer:', error);
+    }
+  }
+
+  private async handleStreamStarted(message: StreamStartedMessage): Promise<void> {
+    if (this.onStreamStartedCallback) {
+      this.onStreamStartedCallback(message.config, message.participant_id);
+    }
+    this.emit('streamStarted', message.config, message.participant_id);
+
+    console.info(`🚀 Stream started by producer ${message.participant_id}, ready to receive video`);
+  }
+
+  // ============= EVENT CALLBACKS =============
+
+  onFrameUpdate(callback: FrameUpdateCallback): void {
+    this.onFrameUpdateCallback = callback;
+  }
+
+  onVideoConfigUpdate(callback: VideoConfigUpdateCallback): void {
+    this.onVideoConfigUpdateCallback = callback;
+  }
+
+  onStreamStarted(callback: StreamStartedCallback): void {
+    this.onStreamStartedCallback = callback;
+  }
+
+  onStreamStopped(callback: StreamStoppedCallback): void {
+    this.onStreamStoppedCallback = callback;
+  }
+
+  onRecoveryTriggered(callback: RecoveryTriggeredCallback): void {
+    this.onRecoveryTriggeredCallback = callback;
+  }
+
+  onStatusUpdate(callback: StatusUpdateCallback): void {
+    this.onStatusUpdateCallback = callback;
+  }
+
+  onStreamStats(callback: StreamStatsCallback): void {
+    this.onStreamStatsCallback = callback;
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected override handleRoleSpecificMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'frame_update':
+        this.handleFrameUpdate(message as FrameUpdateMessage);
+        break;
+      case 'video_config_update':
+        this.handleVideoConfigUpdate(message as VideoConfigUpdateMessage);
+        break;
+      case 'stream_started':
+        this.handleStreamStarted(message as StreamStartedMessage);
+        break;
+      case 'stream_stopped':
+        this.handleStreamStopped(message as StreamStoppedMessage);
+        break;
+      case 'recovery_triggered':
+        this.handleRecoveryTriggered(message as RecoveryTriggeredMessage);
+        break;
+      case 'status_update':
+        this.handleStatusUpdate(message as StatusUpdateMessage);
+        break;
+      case 'stream_stats':
+        this.handleStreamStats(message as StreamStatsMessage);
+        break;
+      case 'participant_joined':
+        console.info(`📥 Participant joined: ${message.participant_id} as ${message.role}`);
+        break;
+      case 'participant_left':
+        console.info(`📤 Participant left: ${message.participant_id} (${message.role})`);
+        break;
+      case 'webrtc_offer':
+        this.handleWebRTCOffer(message as WebRTCOfferMessage);
+        break;
+      case 'webrtc_answer':
+        console.info('📨 Received WebRTC answer (consumer should not receive this)');
+        break;
+      case 'webrtc_ice':
+        this.handleWebRTCIce(message as WebRTCIceMessage);
+        break;
+      case 'emergency_stop':
+        console.warn(`🚨 Emergency stop: ${message.reason || 'Unknown reason'}`);
+        this.handleError(`Emergency stop: ${message.reason || 'Unknown reason'}`);
+        break;
+      case 'error':
+        console.error(`Server error: ${message.message}`);
+        this.handleError(message.message);
+        break;
+      default:
+        console.warn(`Unknown message type for consumer: ${message.type}`);
+    }
+  }
+
+  private handleFrameUpdate(message: FrameUpdateMessage): void {
+    if (this.onFrameUpdateCallback) {
+      const frameData = {
+        data: message.data,
+        metadata: message.metadata
+      };
+      this.onFrameUpdateCallback(frameData);
+    }
+    this.emit('frameUpdate', message.data);
+  }
+
+  private handleVideoConfigUpdate(message: VideoConfigUpdateMessage): void {
+    if (this.onVideoConfigUpdateCallback) {
+      this.onVideoConfigUpdateCallback(message.config);
+    }
+    this.emit('videoConfigUpdate', message.config);
+  }
+
+  private handleStreamStopped(message: StreamStoppedMessage): void {
+    if (this.onStreamStoppedCallback) {
+      this.onStreamStoppedCallback(message.participant_id, message.reason);
+    }
+    this.emit('streamStopped', message.participant_id, message.reason);
+  }
+
+  private handleRecoveryTriggered(message: RecoveryTriggeredMessage): void {
+    if (this.onRecoveryTriggeredCallback) {
+      this.onRecoveryTriggeredCallback(message.policy, message.reason);
+    }
+    this.emit('recoveryTriggered', message.policy, message.reason);
+  }
+
+  private handleStatusUpdate(message: StatusUpdateMessage): void {
+    if (this.onStatusUpdateCallback) {
+      this.onStatusUpdateCallback(message.status, message.data);
+    }
+    this.emit('statusUpdate', message.status, message.data);
+  }
+
+  private handleStreamStats(message: StreamStatsMessage): void {
+    if (this.onStreamStatsCallback) {
+      this.onStreamStatsCallback(message.stats);
+    }
+    this.emit('streamStats', message.stats);
+  }
+
+  // ============= UTILITY METHODS =============
+
+  /**
+   * Create a consumer and automatically connect to a room
+   */
+  static async createAndConnect(
+    workspaceId: string,
+    roomId: string,
+    baseUrl = 'http://localhost:8000',
+    participantId?: string
+  ): Promise<VideoConsumer> {
+    const consumer = new VideoConsumer(baseUrl);
+    const connected = await consumer.connect(workspaceId, roomId, participantId);
+    
+    if (!connected) {
+      throw new Error('Failed to connect as video consumer');
+    }
+    
+    return consumer;
+  }
+
+  /**
+   * Get the video element for displaying the remote stream
+   */
+  attachToVideoElement(videoElement: HTMLVideoElement): void {
+    if (this.remoteStream) {
+      videoElement.srcObject = this.remoteStream;
+    }
+    
+    // Listen for future stream updates
+    this.on('remoteStream', (stream: MediaStream) => {
+      videoElement.srcObject = stream;
+    });
+  }
+
+  /**
+   * Get current video statistics
+   */
+  async getVideoStats(): Promise<WebRTCStats | null> {
+    const stats = await this.getStats();
+    return stats;
+  }
+} 

client/js/src/video/core.ts

@@ -0,0 +1,533 @@
+/**
+ * Core video client for LeRobot Arena
+ * Base class providing REST API, WebSocket, and WebRTC functionality
+ */
+
+import { EventEmitter } from 'eventemitter3';
+import type {
+  ParticipantRole,
+  RoomInfo,
+  RoomState,
+  ConnectionInfo,
+  WebSocketMessage,
+  JoinMessage,
+  ListRoomsResponse,
+  CreateRoomResponse,
+  GetRoomResponse,
+  GetRoomStateResponse,
+  DeleteRoomResponse,
+  WebRTCSignalResponse,
+  WebRTCSignalRequest,
+  ClientOptions,
+  WebRTCConfig,
+  WebRTCStats,
+  VideoConfig,
+  RecoveryConfig,
+  ErrorCallback,
+  ConnectedCallback,
+  DisconnectedCallback,
+} from './types.js';
+
+export class VideoClientCore extends EventEmitter {
+  protected baseUrl: string;
+  protected apiBase: string;
+  protected websocket: WebSocket | null = null;
+  protected peerConnection: RTCPeerConnection | null = null;
+  protected localStream: MediaStream | null = null;
+  protected remoteStream: MediaStream | null = null;
+  protected workspaceId: string | null = null;
+  protected roomId: string | null = null;
+  protected role: ParticipantRole | null = null;
+  protected participantId: string | null = null;
+  protected connected = false;
+  protected options: ClientOptions;
+  protected webrtcConfig: WebRTCConfig;
+
+  // Event callbacks
+  protected onErrorCallback: ErrorCallback | null = null;
+  protected onConnectedCallback: ConnectedCallback | null = null;
+  protected onDisconnectedCallback: DisconnectedCallback | null = null;
+
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super();
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.apiBase = `${this.baseUrl}/video`;
+    this.options = {
+      timeout: 5000,
+      reconnect_attempts: 3,
+      heartbeat_interval: 30000,
+      ...options,
+    };
+    this.webrtcConfig = {
+      iceServers: [{ urls: 'stun:stun.l.google.com:19302' }],
+      constraints: { 
+        video: {
+          width: { ideal: 640 },
+          height: { ideal: 480 },
+          frameRate: { ideal: 30 }
+        }, 
+        audio: false 
+      },
+      bitrate: 1000000,
+      framerate: 30,
+      resolution: { width: 640, height: 480 },
+      codecPreferences: ['VP8', 'H264'],
+      ...this.options.webrtc_config,
+    };
+  }
+
+  // ============= REST API METHODS =============
+
+  async listRooms(workspaceId: string): Promise<RoomInfo[]> {
+    const response = await this.fetchApi<ListRoomsResponse>(`/workspaces/${workspaceId}/rooms`);
+    return response.rooms;
+  }
+
+  async createRoom(workspaceId?: string, roomId?: string, config?: VideoConfig, recoveryConfig?: RecoveryConfig): Promise<{ workspaceId: string; roomId: string }> {
+    // Generate workspace ID if not provided
+    const finalWorkspaceId = workspaceId || this.generateWorkspaceId();
+    
+    const payload = { 
+      room_id: roomId, 
+      workspace_id: finalWorkspaceId,
+      config, 
+      recovery_config: recoveryConfig 
+    };
+    const response = await this.fetchApi<CreateRoomResponse>(`/workspaces/${finalWorkspaceId}/rooms`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    return { workspaceId: response.workspace_id, roomId: response.room_id };
+  }
+
+  async deleteRoom(workspaceId: string, roomId: string): Promise<boolean> {
+    try {
+      const response = await this.fetchApi<DeleteRoomResponse>(`/workspaces/${workspaceId}/rooms/${roomId}`, {
+        method: 'DELETE',
+      });
+      return response.success;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('404')) {
+        return false;
+      }
+      throw error;
+    }
+  }
+
+  async getRoomState(workspaceId: string, roomId: string): Promise<RoomState> {
+    const response = await this.fetchApi<GetRoomStateResponse>(`/workspaces/${workspaceId}/rooms/${roomId}/state`);
+    return response.state;
+  }
+
+  async getRoomInfo(workspaceId: string, roomId: string): Promise<RoomInfo> {
+    const response = await this.fetchApi<GetRoomResponse>(`/workspaces/${workspaceId}/rooms/${roomId}`);
+    return response.room;
+  }
+
+  // ============= WEBRTC SIGNALING =============
+
+  async sendWebRTCSignal(workspaceId: string, roomId: string, clientId: string, message: RTCSessionDescriptionInit | RTCIceCandidateInit | Record<string, unknown>): Promise<WebRTCSignalResponse> {
+    const request: WebRTCSignalRequest = { client_id: clientId, message };
+    return this.fetchApi<WebRTCSignalResponse>(`/workspaces/${workspaceId}/rooms/${roomId}/webrtc/signal`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(request),
+    });
+  }
+
+  // ============= WEBSOCKET CONNECTION =============
+
+  async connectToRoom(
+    workspaceId: string,
+    roomId: string,
+    role: ParticipantRole,
+    participantId?: string
+  ): Promise<boolean> {
+    if (this.connected) {
+      await this.disconnect();
+    }
+
+    this.workspaceId = workspaceId;
+    this.roomId = roomId;
+    this.role = role;
+    this.participantId = participantId || `${role}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Convert HTTP URL to WebSocket URL
+    const wsUrl = this.baseUrl
+      .replace(/^http/, 'ws')
+      .replace(/^https/, 'wss');
+    const wsEndpoint = `${wsUrl}/video/workspaces/${workspaceId}/rooms/${roomId}/ws`;
+
+    try {
+      this.websocket = new WebSocket(wsEndpoint);
+
+      // Set up WebSocket event handlers
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error('Connection timeout'));
+        }, this.options.timeout || 5000);
+
+        this.websocket!.onopen = () => {
+          clearTimeout(timeout);
+          this.sendJoinMessage();
+        };
+
+        this.websocket!.onmessage = (event) => {
+          try {
+            const message: WebSocketMessage = JSON.parse(event.data);
+            this.handleMessage(message);
+
+            // Handle initial connection responses
+            if (message.type === 'joined') {
+              this.connected = true;
+              this.onConnectedCallback?.();
+              this.emit('connected');
+              resolve(true);
+            } else if (message.type === 'error') {
+              this.handleError(message.message);
+              resolve(false);
+            }
+          } catch (error) {
+            console.error('Failed to parse WebSocket message:', error);
+          }
+        };
+
+        this.websocket!.onerror = (error) => {
+          clearTimeout(timeout);
+          console.error('WebSocket error:', error);
+          this.handleError('WebSocket connection error');
+          reject(error);
+        };
+
+        this.websocket!.onclose = () => {
+          clearTimeout(timeout);
+          this.connected = false;
+          this.onDisconnectedCallback?.();
+          this.emit('disconnected');
+        };
+      });
+    } catch (error) {
+      console.error('Failed to connect to room:', error);
+      return false;
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    // Close WebRTC connection
+    if (this.peerConnection) {
+      this.peerConnection.close();
+      this.peerConnection = null;
+    }
+
+    // Stop local streams
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(track => track.stop());
+      this.localStream = null;
+    }
+
+    // Close WebSocket
+    if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+      this.websocket.close();
+    }
+
+    this.websocket = null;
+    this.remoteStream = null;
+    this.connected = false;
+    this.workspaceId = null;
+    this.roomId = null;
+    this.role = null;
+    this.participantId = null;
+
+    this.onDisconnectedCallback?.();
+    this.emit('disconnected');
+  }
+
+  // ============= WEBRTC METHODS =============
+
+  createPeerConnection(): RTCPeerConnection {
+    const config: RTCConfiguration = {
+      iceServers: this.webrtcConfig.iceServers || [
+        { urls: 'stun:stun.l.google.com:19302' }
+      ]
+    };
+
+    this.peerConnection = new RTCPeerConnection(config);
+
+    // Connection state changes
+    this.peerConnection.onconnectionstatechange = () => {
+      const state = this.peerConnection?.connectionState;
+      console.info(`🔌 WebRTC connection state: ${state}`);
+    };
+
+    // ICE connection state
+    this.peerConnection.oniceconnectionstatechange = () => {
+      const state = this.peerConnection?.iceConnectionState;
+      console.info(`🧊 ICE connection state: ${state}`);
+    };
+
+    // ICE candidate handling
+    this.peerConnection.onicecandidate = (event: RTCPeerConnectionIceEvent) => {
+      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
+        // Send ICE candidate via signaling
+        this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
+          type: 'ice',
+          candidate: event.candidate.toJSON()
+        } as Record<string, unknown>);
+      }
+    };
+
+    // Handle remote stream
+    this.peerConnection.ontrack = (event: RTCTrackEvent) => {
+      console.info('📺 Received remote track:', event.track.kind);
+      this.remoteStream = event.streams[0] || null;
+      this.emit('remoteStream', this.remoteStream);
+    };
+
+    return this.peerConnection;
+  }
+
+  async createOffer(): Promise<RTCSessionDescriptionInit> {
+    if (!this.peerConnection) {
+      throw new Error('Peer connection not created');
+    }
+
+    const offer = await this.peerConnection.createOffer();
+    await this.peerConnection.setLocalDescription(offer);
+    
+    return offer;
+  }
+
+  async createAnswer(offer: RTCSessionDescriptionInit): Promise<RTCSessionDescriptionInit> {
+    if (!this.peerConnection) {
+      throw new Error('Peer connection not created');
+    }
+
+    await this.peerConnection.setRemoteDescription(offer);
+    const answer = await this.peerConnection.createAnswer();
+    await this.peerConnection.setLocalDescription(answer);
+    
+    return answer;
+  }
+
+  async setRemoteDescription(description: RTCSessionDescriptionInit): Promise<void> {
+    if (!this.peerConnection) {
+      throw new Error('Peer connection not created');
+    }
+
+    await this.peerConnection.setRemoteDescription(description);
+  }
+
+  async addIceCandidate(candidate: RTCIceCandidateInit): Promise<void> {
+    if (!this.peerConnection) {
+      throw new Error('Peer connection not created');
+    }
+
+    await this.peerConnection.addIceCandidate(candidate);
+  }
+
+  // ============= MEDIA METHODS =============
+
+  async startProducing(constraints?: MediaStreamConstraints): Promise<MediaStream> {
+    const mediaConstraints = constraints || this.webrtcConfig.constraints;
+    
+    try {
+      this.localStream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
+      return this.localStream;
+    } catch (error) {
+      throw new Error(`Failed to start video production: ${error}`);
+    }
+  }
+
+  async startScreenShare(): Promise<MediaStream> {
+    try {
+      this.localStream = await navigator.mediaDevices.getDisplayMedia({
+        video: {
+          width: this.webrtcConfig.resolution?.width || 1920,
+          height: this.webrtcConfig.resolution?.height || 1080,
+          frameRate: this.webrtcConfig.framerate || 30
+        },
+        audio: false
+      });
+      
+      return this.localStream;
+    } catch (error) {
+      throw new Error(`Failed to start screen share: ${error}`);
+    }
+  }
+
+  stopProducing(): void {
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(track => track.stop());
+      this.localStream = null;
+    }
+  }
+
+  // ============= GETTERS =============
+
+  getLocalStream(): MediaStream | null {
+    return this.localStream;
+  }
+
+  getRemoteStream(): MediaStream | null {
+    return this.remoteStream;
+  }
+
+  getPeerConnection(): RTCPeerConnection | null {
+    return this.peerConnection;
+  }
+
+  async getStats(): Promise<WebRTCStats | null> {
+    if (!this.peerConnection) {
+      return null;
+    }
+
+    const stats = await this.peerConnection.getStats();
+    return this.extractVideoStats(stats);
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected sendJoinMessage(): void {
+    if (!this.websocket || !this.participantId || !this.role) return;
+
+    const joinMessage: JoinMessage = {
+      participant_id: this.participantId,
+      role: this.role,
+    };
+
+    this.websocket.send(JSON.stringify(joinMessage));
+  }
+
+  protected handleMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'joined':
+        console.log(`Successfully joined room ${message.room_id} as ${message.role}`);
+        break;
+      case 'heartbeat_ack':
+        console.debug('Heartbeat acknowledged');
+        break;
+      case 'error':
+        this.handleError(message.message);
+        break;
+      default:
+        // Let subclasses handle specific message types
+        this.handleRoleSpecificMessage(message);
+    }
+  }
+
+  protected handleRoleSpecificMessage(message: WebSocketMessage): void {
+    // To be overridden by subclasses
+    this.emit('message', message);
+  }
+
+  protected handleError(errorMessage: string): void {
+    console.error('Video client error:', errorMessage);
+    this.onErrorCallback?.(errorMessage);
+    this.emit('error', errorMessage);
+  }
+
+  // ============= UTILITY METHODS =============
+
+  async sendHeartbeat(): Promise<void> {
+    if (!this.connected || !this.websocket) return;
+
+    const message = { type: 'heartbeat' as const };
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+
+  getConnectionInfo(): ConnectionInfo {
+    return {
+      connected: this.connected,
+      workspace_id: this.workspaceId,
+      room_id: this.roomId,
+      role: this.role,
+      participant_id: this.participantId,
+      base_url: this.baseUrl,
+    };
+  }
+
+  // ============= EVENT CALLBACK SETTERS =============
+
+  onError(callback: ErrorCallback): void {
+    this.onErrorCallback = callback;
+  }
+
+  onConnected(callback: ConnectedCallback): void {
+    this.onConnectedCallback = callback;
+  }
+
+  onDisconnected(callback: DisconnectedCallback): void {
+    this.onDisconnectedCallback = callback;
+  }
+
+  // ============= PRIVATE HELPERS =============
+
+  private async fetchApi<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.apiBase}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      signal: AbortSignal.timeout(this.options.timeout || 5000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  private extractVideoStats(stats: RTCStatsReport): WebRTCStats | null {
+    let inboundVideoStats: RTCInboundRtpStreamStats | null = null;
+    let outboundVideoStats: RTCOutboundRtpStreamStats | null = null;
+
+    stats.forEach((report) => {
+      if (report.type === 'inbound-rtp' && 'kind' in report && report.kind === 'video') {
+        inboundVideoStats = report as RTCInboundRtpStreamStats;
+      } else if (report.type === 'outbound-rtp' && 'kind' in report && report.kind === 'video') {
+        outboundVideoStats = report as RTCOutboundRtpStreamStats;
+      }
+    });
+
+    // Handle inbound stats (consumer)
+    if (inboundVideoStats) {
+      return {
+        videoBitsPerSecond: (inboundVideoStats as any).bytesReceived || 0,
+        framesPerSecond: (inboundVideoStats as any).framesPerSecond || 0,
+        frameWidth: (inboundVideoStats as any).frameWidth || 0,
+        frameHeight: (inboundVideoStats as any).frameHeight || 0,
+        packetsLost: (inboundVideoStats as any).packetsLost || 0,
+        totalPackets: (inboundVideoStats as any).packetsReceived || (inboundVideoStats as any).framesDecoded || 0
+      };
+    }
+    
+    // Handle outbound stats (producer)
+    if (outboundVideoStats) {
+      return {
+        videoBitsPerSecond: (outboundVideoStats as any).bytesSent || 0,
+        framesPerSecond: (outboundVideoStats as any).framesPerSecond || 0,
+        frameWidth: (outboundVideoStats as any).frameWidth || 0,
+        frameHeight: (outboundVideoStats as any).frameHeight || 0,
+        packetsLost: (outboundVideoStats as any).packetsLost || 0,
+        totalPackets: (outboundVideoStats as any).packetsSent || (outboundVideoStats as any).framesSent || 0
+      };
+    }
+    
+    return null;
+  }
+
+  // ============= WORKSPACE HELPERS =============
+
+  protected generateWorkspaceId(): string {
+    // Generate a UUID-like workspace ID
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+} 

client/js/src/video/factory.ts

@@ -0,0 +1,66 @@
+/**
+ * Factory functions for creating LeRobot Arena video clients
+ */
+
+import { VideoProducer } from './producer.js';
+import { VideoConsumer } from './consumer.js';
+import type { ParticipantRole, ClientOptions } from './types.js';
+
+/**
+ * Factory function to create the appropriate client based on role
+ */
+export function createClient(
+  role: ParticipantRole,
+  baseUrl = 'http://localhost:8000',
+  options: ClientOptions = {}
+): VideoProducer | VideoConsumer {
+  if (role === 'producer') {
+    return new VideoProducer(baseUrl, options);
+  }
+  if (role === 'consumer') {
+    return new VideoConsumer(baseUrl, options);
+  }
+  throw new Error(`Invalid role: ${role}. Must be 'producer' or 'consumer'`);
+}
+
+/**
+ * Create and connect a producer client
+ */
+export async function createProducerClient(
+  baseUrl = 'http://localhost:8000',
+  workspaceId?: string,
+  roomId?: string,
+  participantId?: string,
+  options: ClientOptions = {}
+): Promise<VideoProducer> {
+  const producer = new VideoProducer(baseUrl, options);
+
+  const roomData = await producer.createRoom(workspaceId, roomId);
+  const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
+
+  if (!connected) {
+    throw new Error('Failed to connect as video producer');
+  }
+
+  return producer;
+}
+
+/**
+ * Create and connect a consumer client
+ */
+export async function createConsumerClient(
+  workspaceId: string,
+  roomId: string,
+  baseUrl = 'http://localhost:8000',
+  participantId?: string,
+  options: ClientOptions = {}
+): Promise<VideoConsumer> {
+  const consumer = new VideoConsumer(baseUrl, options);
+  const connected = await consumer.connect(workspaceId, roomId, participantId);
+
+  if (!connected) {
+    throw new Error('Failed to connect as video consumer');
+  }
+
+  return consumer;
+} 

client/js/src/video/index.ts

@@ -0,0 +1,16 @@
+/**
+ * LeRobot Arena Video Client - Main Module
+ * 
+ * TypeScript/JavaScript client for video streaming and monitoring
+ */
+
+// Export core classes
+export { VideoClientCore } from './core.js';
+export { VideoProducer } from './producer.js';
+export { VideoConsumer } from './consumer.js';
+
+// Export all types
+export * from './types.js';
+
+// Export factory functions for convenience
+export { createProducerClient, createConsumerClient, createClient } from './factory.js';

client/js/src/video/producer.ts

@@ -0,0 +1,439 @@
+/**
+ * Producer client for video streaming in LeRobot Arena
+ */
+
+import { VideoClientCore } from './core.js';
+import type {
+  WebSocketMessage,
+  VideoConfigUpdateMessage,
+  StreamStartedMessage,
+  StreamStoppedMessage,
+  StatusUpdateMessage,
+  StreamStatsMessage,
+  ClientOptions,
+  VideoConfig,
+  WebRTCAnswerMessage,
+  WebRTCIceMessage,
+} from './types.js';
+
+export class VideoProducer extends VideoClientCore {
+  // Multiple peer connections - one per consumer
+  private consumerConnections: Map<string, RTCPeerConnection> = new Map();
+
+  constructor(baseUrl = 'http://localhost:8000', options: ClientOptions = {}) {
+    super(baseUrl, options);
+  }
+
+  // ============= PRODUCER CONNECTION =============
+
+  async connect(workspaceId: string, roomId: string, participantId?: string): Promise<boolean> {
+    const success = await this.connectToRoom(workspaceId, roomId, 'producer', participantId);
+    
+    if (success) {
+      // Listen for consumer join events to initiate WebRTC
+      this.on('consumer_joined', (consumerId: string) => {
+        console.info(`🎯 Consumer ${consumerId} joined, initiating WebRTC...`);
+        this.initiateWebRTCWithConsumer(consumerId);
+      });
+
+      // Also check for existing consumers and initiate connections after a delay
+      setTimeout(() => this.connectToExistingConsumers(), 1000);
+    }
+    
+    return success;
+  }
+
+  private async connectToExistingConsumers(): Promise<void> {
+    if (!this.workspaceId || !this.roomId) return;
+    
+    try {
+      const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
+      for (const consumerId of roomInfo.participants.consumers) {
+        if (!this.consumerConnections.has(consumerId)) {
+          console.info(`🔄 Connecting to existing consumer ${consumerId}`);
+          await this.initiateWebRTCWithConsumer(consumerId);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to connect to existing consumers:', error);
+    }
+  }
+
+  private createPeerConnectionForConsumer(consumerId: string): RTCPeerConnection {
+    const config: RTCConfiguration = {
+      iceServers: this.webrtcConfig.iceServers || [
+        { urls: 'stun:stun.l.google.com:19302' }
+      ]
+    };
+
+    const peerConnection = new RTCPeerConnection(config);
+
+    // Add local stream tracks to this connection
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(track => {
+        peerConnection.addTrack(track, this.localStream!);
+      });
+    }
+
+    // Connection state changes
+    peerConnection.onconnectionstatechange = () => {
+      const state = peerConnection.connectionState;
+      console.info(`🔌 WebRTC connection state for ${consumerId}: ${state}`);
+      
+      if (state === 'failed' || state === 'disconnected') {
+        console.warn(`Connection to ${consumerId} failed, attempting restart...`);
+        setTimeout(() => this.restartConnectionToConsumer(consumerId), 2000);
+      }
+    };
+
+    // ICE connection state
+    peerConnection.oniceconnectionstatechange = () => {
+      const state = peerConnection.iceConnectionState;
+      console.info(`🧊 ICE connection state for ${consumerId}: ${state}`);
+    };
+
+    // ICE candidate handling for this specific consumer
+    peerConnection.onicecandidate = (event) => {
+      if (event.candidate && this.workspaceId && this.roomId && this.participantId) {
+        this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
+          type: 'ice',
+          candidate: event.candidate.toJSON(),
+          target_consumer: consumerId,
+        } as Record<string, unknown>);
+      }
+    };
+
+    // Store the connection
+    this.consumerConnections.set(consumerId, peerConnection);
+    
+    return peerConnection;
+  }
+
+  private async restartConnectionToConsumer(consumerId: string): Promise<void> {
+    console.info(`🔄 Restarting connection to consumer ${consumerId}`);
+    await this.initiateWebRTCWithConsumer(consumerId);
+  }
+
+  private handleConsumerLeft(consumerId: string): void {
+    const peerConnection = this.consumerConnections.get(consumerId);
+    if (peerConnection) {
+      peerConnection.close();
+      this.consumerConnections.delete(consumerId);
+      console.info(`🧹 Cleaned up peer connection for consumer ${consumerId}`);
+    }
+  }
+
+  private async restartConnectionsWithNewStream(stream: MediaStream): Promise<void> {
+    console.info('🔄 Restarting connections with new stream...');
+    
+    // Close all existing connections
+    for (const [consumerId, peerConnection] of this.consumerConnections) {
+      peerConnection.close();
+      console.info(`🧹 Closed existing connection to consumer ${consumerId}`);
+    }
+    this.consumerConnections.clear();
+
+    // Get current consumers and restart connections
+    try {
+      if (this.workspaceId && this.roomId) {
+        const roomInfo = await this.getRoomInfo(this.workspaceId, this.roomId);
+        for (const consumerId of roomInfo.participants.consumers) {
+          console.info(`🔄 Creating new connection to consumer ${consumerId}...`);
+          await this.initiateWebRTCWithConsumer(consumerId);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to restart connections:', error);
+    }
+  }
+
+  // ============= PRODUCER METHODS =============
+
+  async startCamera(constraints?: MediaStreamConstraints): Promise<MediaStream> {
+    if (!this.connected) {
+      throw new Error('Must be connected to start camera');
+    }
+
+    const stream = await this.startProducing(constraints);
+    
+    // Store the stream and restart connections with new tracks
+    this.localStream = stream;
+    await this.restartConnectionsWithNewStream(stream);
+
+    // Notify about stream start
+    this.notifyStreamStarted(stream);
+    
+    return stream;
+  }
+
+  override async startScreenShare(): Promise<MediaStream> {
+    if (!this.connected) {
+      throw new Error('Must be connected to start screen share');
+    }
+
+    const stream = await super.startScreenShare();
+    
+    // Store the stream and restart connections with new tracks
+    this.localStream = stream;
+    await this.restartConnectionsWithNewStream(stream);
+
+    // Notify about stream start
+    this.notifyStreamStarted(stream);
+    
+    return stream;
+  }
+
+  async stopStreaming(): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to stop streaming');
+    }
+
+    // Close all consumer connections
+    for (const [consumerId, peerConnection] of this.consumerConnections) {
+      peerConnection.close();
+      console.info(`🧹 Closed connection to consumer ${consumerId}`);
+    }
+    this.consumerConnections.clear();
+
+    // Stop local stream
+    this.stopProducing();
+
+    // Notify about stream stop
+    this.notifyStreamStopped();
+  }
+
+  async updateVideoConfig(config: VideoConfig): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to update video config');
+    }
+
+    const message: VideoConfigUpdateMessage = {
+      type: 'video_config_update',
+      config,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  async sendEmergencyStop(reason = 'Emergency stop'): Promise<void> {
+    if (!this.connected || !this.websocket) {
+      throw new Error('Must be connected to send emergency stop');
+    }
+
+    const message = {
+      type: 'emergency_stop' as const,
+      reason,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+  }
+
+  // ============= WEBRTC NEGOTIATION =============
+
+  async initiateWebRTCWithConsumer(consumerId: string): Promise<void> {
+    if (!this.workspaceId || !this.roomId || !this.participantId) {
+      console.warn('WebRTC not ready, skipping negotiation with consumer');
+      return;
+    }
+
+    // Clean up existing connection if any
+    if (this.consumerConnections.has(consumerId)) {
+      const existingConn = this.consumerConnections.get(consumerId);
+      existingConn?.close();
+      this.consumerConnections.delete(consumerId);
+    }
+
+    try {
+      console.info(`🔄 Creating WebRTC offer for consumer ${consumerId}...`);
+      
+      // Create a new peer connection specifically for this consumer
+      const peerConnection = this.createPeerConnectionForConsumer(consumerId);
+      
+      // Create offer with this consumer's peer connection
+      const offer = await peerConnection.createOffer();
+      await peerConnection.setLocalDescription(offer);
+      
+      console.info(`📤 Sending WebRTC offer to consumer ${consumerId}...`);
+      
+      // Send offer to server/consumer
+      await this.sendWebRTCSignal(this.workspaceId, this.roomId, this.participantId, {
+        type: 'offer',
+        sdp: offer.sdp,
+        target_consumer: consumerId,
+      } as Record<string, unknown>);
+      
+      console.info(`✅ WebRTC offer sent to consumer ${consumerId}`);
+    } catch (error) {
+      console.error(`Failed to initiate WebRTC with consumer ${consumerId}:`, error);
+    }
+  }
+
+  private async handleWebRTCAnswer(message: WebRTCAnswerMessage): Promise<void> {
+    try {
+      const consumerId = message.from_consumer;
+      console.info(`📥 Received WebRTC answer from consumer ${consumerId}`);
+      
+      const peerConnection = this.consumerConnections.get(consumerId);
+      if (!peerConnection) {
+        console.warn(`No peer connection found for consumer ${consumerId}`);
+        return;
+      }
+
+      // Set remote description on the correct peer connection
+      const answer = new RTCSessionDescription({
+        type: 'answer',
+        sdp: message.answer.sdp
+      });
+      
+      await peerConnection.setRemoteDescription(answer);
+      
+      console.info(`✅ WebRTC negotiation completed with consumer ${consumerId}`);
+    } catch (error) {
+      console.error(`Failed to handle WebRTC answer from ${message.from_consumer}:`, error);
+      this.handleError(`Failed to handle WebRTC answer: ${error}`);
+    }
+  }
+
+  private async handleWebRTCIce(message: WebRTCIceMessage): Promise<void> {
+    try {
+      const consumerId = message.from_consumer;
+      if (!consumerId) {
+        console.warn('No consumer ID in ICE message');
+        return;
+      }
+
+      const peerConnection = this.consumerConnections.get(consumerId);
+      if (!peerConnection) {
+        console.warn(`No peer connection found for consumer ${consumerId}`);
+        return;
+      }
+
+      console.info(`📥 Received WebRTC ICE from consumer ${consumerId}`);
+      
+      // Add ICE candidate to the correct peer connection
+      const candidate = new RTCIceCandidate(message.candidate);
+      await peerConnection.addIceCandidate(candidate);
+      
+      console.info(`✅ WebRTC ICE handled with consumer ${consumerId}`);
+    } catch (error) {
+      console.error(`Failed to handle WebRTC ICE from ${message.from_consumer}:`, error);
+      this.handleError(`Failed to handle WebRTC ICE: ${error}`);
+    }
+  }
+
+  // ============= MESSAGE HANDLING =============
+
+  protected override handleRoleSpecificMessage(message: WebSocketMessage): void {
+    switch (message.type) {
+      case 'participant_joined':
+        // Check if this is a consumer joining
+        if (message.role === 'consumer' && message.participant_id !== this.participantId) {
+          console.info(`🎯 Consumer ${message.participant_id} joined room`);
+          this.emit('consumer_joined', message.participant_id);
+        }
+        break;
+      case 'participant_left':
+        // Check if this is a consumer leaving
+        if (message.role === 'consumer') {
+          console.info(`👋 Consumer ${message.participant_id} left room`);
+          this.handleConsumerLeft(message.participant_id);
+        }
+        break;
+      case 'webrtc_answer':
+        this.handleWebRTCAnswer(message as WebRTCAnswerMessage);
+        break;
+      case 'webrtc_ice':
+        this.handleWebRTCIce(message as WebRTCIceMessage);
+        break;
+      case 'status_update':
+        this.handleStatusUpdate(message as StatusUpdateMessage);
+        break;
+      case 'stream_stats':
+        this.handleStreamStats(message as StreamStatsMessage);
+        break;
+      case 'emergency_stop':
+        console.warn(`🚨 Emergency stop: ${message.reason || 'Unknown reason'}`);
+        this.handleError(`Emergency stop: ${message.reason || 'Unknown reason'}`);
+        break;
+      case 'error':
+        console.error(`Server error: ${message.message}`);
+        this.handleError(message.message);
+        break;
+      default:
+        console.warn(`Unknown message type for producer: ${message.type}`);
+    }
+  }
+
+  private handleStatusUpdate(message: StatusUpdateMessage): void {
+    console.info(`📊 Status update: ${message.status}`, message.data);
+    this.emit('statusUpdate', message.status, message.data);
+  }
+
+  private handleStreamStats(message: StreamStatsMessage): void {
+    console.debug(`📈 Stream stats:`, message.stats);
+    this.emit('streamStats', message.stats);
+  }
+
+  // ============= UTILITY METHODS =============
+
+  private async notifyStreamStarted(stream: MediaStream): Promise<void> {
+    if (!this.websocket) return;
+
+    const message: StreamStartedMessage = {
+      type: 'stream_started',
+      config: {
+        resolution: this.webrtcConfig.resolution,
+        framerate: this.webrtcConfig.framerate,
+        bitrate: this.webrtcConfig.bitrate,
+      },
+      participant_id: this.participantId!,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+    this.emit('streamStarted', stream);
+  }
+
+  private async notifyStreamStopped(): Promise<void> {
+    if (!this.websocket) return;
+
+    const message: StreamStoppedMessage = {
+      type: 'stream_stopped',
+      participant_id: this.participantId!,
+      timestamp: new Date().toISOString(),
+    };
+
+    this.websocket.send(JSON.stringify(message));
+    this.emit('streamStopped');
+  }
+
+  /**
+   * Create a room and automatically connect as producer
+   */
+  static async createAndConnect(
+    baseUrl = 'http://localhost:8000',
+    workspaceId?: string,
+    roomId?: string,
+    participantId?: string
+  ): Promise<VideoProducer> {
+    const producer = new VideoProducer(baseUrl);
+    
+    const roomData = await producer.createRoom(workspaceId, roomId);
+    const connected = await producer.connect(roomData.workspaceId, roomData.roomId, participantId);
+    
+    if (!connected) {
+      throw new Error('Failed to connect as video producer');
+    }
+    
+    return producer;
+  }
+
+  /**
+   * Get the current room ID (useful when auto-created)
+   */
+  get currentRoomId(): string | null {
+    return this.roomId;
+  }
+} 

client/js/src/video/types.ts

@@ -0,0 +1,352 @@
+/**
+ * Type definitions for LeRobot Arena Video Client
+ * ✅ Fully synchronized with server-side models.py
+ */
+
+// ============= CORE TYPES =============
+
+export type ParticipantRole = 'producer' | 'consumer';
+
+export type MessageType = 
+  | 'frame_update'
+  | 'video_config_update'
+  | 'stream_started'
+  | 'stream_stopped'
+  | 'recovery_triggered'
+  | 'heartbeat'
+  | 'heartbeat_ack'
+  | 'emergency_stop'
+  | 'joined'
+  | 'error'
+  | 'participant_joined'
+  | 'participant_left'
+  | 'webrtc_offer'
+  | 'webrtc_answer'
+  | 'webrtc_ice'
+  | 'status_update'
+  | 'stream_stats';
+
+// ============= VIDEO CONFIGURATION =============
+
+export interface VideoConfig {
+  encoding?: VideoEncoding;
+  resolution?: Resolution;
+  framerate?: number;
+  bitrate?: number;
+  quality?: number;
+}
+
+export interface Resolution {
+  width: number;
+  height: number;
+}
+
+export type VideoEncoding = 'jpeg' | 'h264' | 'vp8' | 'vp9';
+
+export type RecoveryPolicy = 
+  | 'freeze_last_frame'
+  | 'connection_info' 
+  | 'black_screen'
+  | 'fade_to_black'
+  | 'overlay_status';
+
+export interface RecoveryConfig {
+  frame_timeout_ms?: number;
+  max_frame_reuse_count?: number;
+  recovery_policy?: RecoveryPolicy;
+  fallback_policy?: RecoveryPolicy;
+  show_hold_indicators?: boolean;
+  info_frame_bg_color?: [number, number, number];
+  info_frame_text_color?: [number, number, number];
+  fade_intensity?: number;
+  overlay_opacity?: number;
+}
+
+// ============= DATA STRUCTURES =============
+
+export interface FrameData {
+  data: ArrayBuffer;
+  metadata?: Record<string, unknown>;
+}
+
+export interface StreamStats {
+  stream_id: string;
+  duration_seconds: number;
+  frame_count: number;
+  total_bytes: number;
+  average_fps: number;
+  average_bitrate: number;
+}
+
+export interface ParticipantInfo {
+  producer: string | null;
+  consumers: string[];
+  total: number;
+}
+
+export interface RoomInfo {
+  id: string;
+  workspace_id: string;
+  participants: ParticipantInfo;
+  frame_count: number;
+  config: VideoConfig;
+  has_producer: boolean;
+  active_consumers: number;
+}
+
+export interface RoomState {
+  room_id: string;
+  workspace_id: string;
+  participants: ParticipantInfo;
+  frame_count: number;
+  last_frame_time: string | null;
+  current_config: VideoConfig;
+  timestamp: string;
+}
+
+export interface ConnectionInfo {
+  connected: boolean;
+  workspace_id: string | null;
+  room_id: string | null;
+  role: ParticipantRole | null;
+  participant_id: string | null;
+  base_url: string;
+}
+
+// ============= MESSAGE TYPES =============
+
+export interface BaseMessage {
+  type: MessageType;
+  timestamp?: string;
+}
+
+export interface FrameUpdateMessage extends BaseMessage {
+  type: 'frame_update';
+  data: ArrayBuffer;
+  metadata?: Record<string, unknown>;
+}
+
+export interface VideoConfigUpdateMessage extends BaseMessage {
+  type: 'video_config_update';
+  config: VideoConfig;
+  source?: string;
+}
+
+export interface StreamStartedMessage extends BaseMessage {
+  type: 'stream_started';
+  config: VideoConfig;
+  participant_id: string;
+}
+
+export interface StreamStoppedMessage extends BaseMessage {
+  type: 'stream_stopped';
+  participant_id: string;
+  reason?: string;
+}
+
+export interface RecoveryTriggeredMessage extends BaseMessage {
+  type: 'recovery_triggered';
+  policy: RecoveryPolicy;
+  reason: string;
+}
+
+export interface HeartbeatMessage extends BaseMessage {
+  type: 'heartbeat';
+}
+
+export interface HeartbeatAckMessage extends BaseMessage {
+  type: 'heartbeat_ack';
+}
+
+export interface EmergencyStopMessage extends BaseMessage {
+  type: 'emergency_stop';
+  reason: string;
+  source?: string;
+}
+
+export interface JoinedMessage extends BaseMessage {
+  type: 'joined';
+  room_id: string;
+  role: ParticipantRole;
+}
+
+export interface ErrorMessage extends BaseMessage {
+  type: 'error';
+  message: string;
+  code?: string;
+}
+
+export interface ParticipantJoinedMessage extends BaseMessage {
+  type: 'participant_joined';
+  room_id: string;
+  participant_id: string;
+  role: ParticipantRole;
+}
+
+export interface ParticipantLeftMessage extends BaseMessage {
+  type: 'participant_left';
+  room_id: string;
+  participant_id: string;
+  role: ParticipantRole;
+}
+
+export interface WebRTCOfferMessage extends BaseMessage {
+  type: 'webrtc_offer';
+  offer: RTCSessionDescriptionInit;
+  from_producer: string;
+}
+
+export interface WebRTCAnswerMessage extends BaseMessage {
+  type: 'webrtc_answer';
+  answer: RTCSessionDescriptionInit;
+  from_consumer: string;
+}
+
+export interface WebRTCIceMessage extends BaseMessage {
+  type: 'webrtc_ice';
+  candidate: RTCIceCandidateInit;
+  from_producer?: string;
+  from_consumer?: string;
+}
+
+export interface StatusUpdateMessage extends BaseMessage {
+  type: 'status_update';
+  status: string;
+  data?: Record<string, unknown>;
+}
+
+export interface StreamStatsMessage extends BaseMessage {
+  type: 'stream_stats';
+  stats: StreamStats;
+}
+
+export type WebSocketMessage = 
+  | FrameUpdateMessage
+  | VideoConfigUpdateMessage
+  | StreamStartedMessage
+  | StreamStoppedMessage
+  | RecoveryTriggeredMessage
+  | HeartbeatMessage
+  | HeartbeatAckMessage
+  | EmergencyStopMessage
+  | JoinedMessage
+  | ErrorMessage
+  | ParticipantJoinedMessage
+  | ParticipantLeftMessage
+  | WebRTCOfferMessage
+  | WebRTCAnswerMessage
+  | WebRTCIceMessage
+  | StatusUpdateMessage
+  | StreamStatsMessage;
+
+// ============= API RESPONSE TYPES =============
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface ListRoomsResponse {
+  success: boolean;
+  workspace_id: string;
+  rooms: RoomInfo[];
+  total: number;
+}
+
+export interface CreateRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  room_id: string;
+  message: string;
+}
+
+export interface GetRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  room: RoomInfo;
+}
+
+export interface GetRoomStateResponse {
+  success: boolean;
+  workspace_id: string;
+  state: RoomState;
+}
+
+export interface DeleteRoomResponse {
+  success: boolean;
+  workspace_id: string;
+  message: string;
+}
+
+export interface WebRTCSignalResponse {
+  success: boolean;
+  workspace_id: string;
+  response?: RTCSessionDescriptionInit | RTCIceCandidateInit;
+  message?: string;
+}
+
+// ============= REQUEST TYPES =============
+
+export interface CreateRoomRequest {
+  room_id?: string;
+  workspace_id?: string;
+  name?: string;
+  config?: VideoConfig;
+  recovery_config?: RecoveryConfig;
+  max_consumers?: number;
+}
+
+export interface WebRTCSignalRequest {
+  client_id: string;
+  message: RTCSessionDescriptionInit | RTCIceCandidateInit | Record<string, unknown>;
+}
+
+export interface JoinMessage {
+  participant_id: string;
+  role: ParticipantRole;
+}
+
+// ============= WEBRTC TYPES =============
+
+export interface WebRTCConfig {
+  iceServers?: RTCIceServer[];
+  constraints?: MediaStreamConstraints;
+  bitrate?: number;
+  framerate?: number;
+  resolution?: Resolution;
+  codecPreferences?: string[];
+}
+
+export interface WebRTCStats {
+  videoBitsPerSecond: number;
+  framesPerSecond: number;
+  frameWidth: number;
+  frameHeight: number;
+  packetsLost: number;
+  totalPackets: number;
+}
+
+// ============= EVENT CALLBACK TYPES =============
+
+export type FrameUpdateCallback = (frame: FrameData) => void;
+export type VideoConfigUpdateCallback = (config: VideoConfig) => void;
+export type StreamStartedCallback = (config: VideoConfig, participantId: string) => void;
+export type StreamStoppedCallback = (participantId: string, reason?: string) => void;
+export type RecoveryTriggeredCallback = (policy: RecoveryPolicy, reason: string) => void;
+export type StatusUpdateCallback = (status: string, data?: Record<string, unknown>) => void;
+export type StreamStatsCallback = (stats: StreamStats) => void;
+export type ErrorCallback = (error: string) => void;
+export type ConnectedCallback = () => void;
+export type DisconnectedCallback = () => void;
+
+// ============= CLIENT OPTIONS =============
+
+export interface ClientOptions {
+  base_url?: string;
+  timeout?: number;
+  reconnect_attempts?: number;
+  heartbeat_interval?: number;
+  webrtc_config?: WebRTCConfig;
+} 

client/js/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Enable Bun types
+    "types": ["bun-types"],
+
+    // Bundler mode (for Vite)
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

client/js/vite.config.ts

@@ -0,0 +1,38 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import dts from 'vite-plugin-dts';
+
+export default defineConfig({
+  plugins: [
+    dts({
+      insertTypesEntry: true,
+      rollupTypes: true,
+    }),
+  ],
+  build: {
+    lib: {
+      entry: {
+        index: resolve('src/index.ts'),
+        video: resolve('src/video/index.ts'),
+        robotics: resolve('src/robotics/index.ts'),
+      },
+      formats: ['es'],
+    },
+    rollupOptions: {
+      external: ['eventemitter3'],
+      output: {
+        preserveModules: false,
+        exports: 'named',
+      },
+    },
+    target: 'esnext',
+    minify: false,
+  },
+  resolve: {
+    alias: {
+      '@': resolve('src'),
+      '@/video': resolve('src/video'),
+      '@/robotics': resolve('src/robotics'),
+    },
+  },
+}); 

client/python/README.md

@@ -0,0 +1,242 @@
+# LeRobot Arena Python Client
+
+Python client library for the LeRobot Arena robotics API with separate Producer and Consumer classes.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Basic Usage
+
+### Producer (Controller) Example
+
+```python
+import asyncio
+from lerobot_arena_client import RoboticsProducer
+
+async def main():
+    # Create producer client
+    producer = RoboticsProducer('http://localhost:8000')
+    
+    # List available rooms
+    rooms = await producer.list_rooms()
+    print('Available rooms:', rooms)
+    
+    # Create new room and connect
+    room_id = await producer.create_room()
+    await producer.connect(room_id)
+    
+    # Send initial state
+    await producer.send_state_sync({
+        'shoulder': 45.0,
+        'elbow': -20.0
+    })
+    
+    # Send joint updates (only changed values will be forwarded!)
+    await producer.send_joint_update([
+        {'name': 'shoulder', 'value': 45.0},
+        {'name': 'elbow', 'value': -20.0}
+    ])
+    
+    # Handle errors
+    producer.on_error(lambda err: print(f'Error: {err}'))
+    
+    # Disconnect
+    await producer.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Consumer (Robot Executor) Example
+
+```python
+import asyncio
+from lerobot_arena_client import RoboticsConsumer
+
+async def main():
+    consumer = RoboticsConsumer('http://localhost:8000')
+    
+    # Connect to existing room
+    room_id = "your-room-id"
+    await consumer.connect(room_id)
+    
+    # Get initial state
+    initial_state = await consumer.get_state_sync()
+    print('Initial state:', initial_state)
+    
+    # Set up event handlers
+    def on_state_sync(state):
+        print('State sync:', state)
+    
+    def on_joint_update(joints):
+        print('Execute joints:', joints)
+        # Execute on actual robot hardware
+        for joint in joints:
+            print(f"Moving {joint['name']} to {joint['value']}")
+    
+    def on_error(error):
+        print(f'Error: {error}')
+    
+    # Register callbacks
+    consumer.on_state_sync(on_state_sync)
+    consumer.on_joint_update(on_joint_update)
+    consumer.on_error(on_error)
+    
+    # Keep running
+    try:
+        await asyncio.sleep(60)  # Run for 60 seconds
+    finally:
+        await consumer.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Factory Function Usage
+
+```python
+import asyncio
+from lerobot_arena_client import create_client
+
+async def main():
+    # Create clients using factory function
+    producer = create_client("producer", "http://localhost:8000")
+    consumer = create_client("consumer", "http://localhost:8000")
+    
+    # Or use convenience functions
+    from lerobot_arena_client import create_producer_client, create_consumer_client
+    
+    # Quick producer setup (auto-creates room and connects)
+    producer = await create_producer_client('http://localhost:8000')
+    print(f"Producer connected to room: {producer.room_id}")
+    
+    # Quick consumer setup (connects to existing room)
+    consumer = await create_consumer_client(producer.room_id, 'http://localhost:8000')
+    
+    # Use context managers for automatic cleanup
+    async with RoboticsProducer('http://localhost:8000') as producer:
+        room_id = await producer.create_room()
+        await producer.connect(room_id)
+        await producer.send_state_sync({'joint1': 10.0})
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Advanced Example: Producer-Consumer Pair
+
+```python
+import asyncio
+from lerobot_arena_client import RoboticsProducer, RoboticsConsumer
+
+async def run_producer(room_id: str):
+    async with RoboticsProducer() as producer:
+        await producer.connect(room_id)
+        
+        # Simulate sending commands
+        for i in range(10):
+            await producer.send_state_sync({
+                'joint1': i * 10.0,
+                'joint2': i * -5.0
+            })
+            await asyncio.sleep(1)
+
+async def run_consumer(room_id: str):
+    async with RoboticsConsumer() as consumer:
+        await consumer.connect(room_id)
+        
+        def handle_joint_update(joints):
+            print(f"🤖 Executing: {joints}")
+            # Your robot control code here
+        
+        consumer.on_joint_update(handle_joint_update)
+        
+        # Keep listening
+        await asyncio.sleep(15)
+
+async def main():
+    # Create room
+    producer = RoboticsProducer()
+    room_id = await producer.create_room()
+    
+    # Run producer and consumer concurrently
+    await asyncio.gather(
+        run_producer(room_id),
+        run_consumer(room_id)
+    )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## API Reference
+
+### RoboticsProducer
+
+**Connection Methods:**
+- `connect(room_id, participant_id=None)` - Connect as producer to room
+
+**Control Methods:**
+- `send_joint_update(joints)` - Send joint updates
+- `send_state_sync(state)` - Send state synchronization (dict format)
+- `send_emergency_stop(reason)` - Send emergency stop
+
+**Event Callbacks:**
+- `on_error(callback)` - Set error callback
+- `on_connected(callback)` - Set connection callback  
+- `on_disconnected(callback)` - Set disconnection callback
+
+### RoboticsConsumer
+
+**Connection Methods:**
+- `connect(room_id, participant_id=None)` - Connect as consumer to room
+
+**State Methods:**
+- `get_state_sync()` - Get current state synchronously
+
+**Event Callbacks:**
+- `on_state_sync(callback)` - Set state sync callback
+- `on_joint_update(callback)` - Set joint update callback
+- `on_error(callback)` - Set error callback
+- `on_connected(callback)` - Set connection callback
+- `on_disconnected(callback)` - Set disconnection callback
+
+### RoboticsClientCore (Base Class)
+
+**REST API Methods:**
+- `list_rooms()` - List all available rooms
+- `create_room(room_id=None)` - Create a new room
+- `delete_room(room_id)` - Delete a room
+- `get_room_state(room_id)` - Get current room state
+- `get_room_info(room_id)` - Get basic room information
+
+**Utility Methods:**
+- `send_heartbeat()` - Send heartbeat to server
+- `is_connected()` - Check connection status
+- `get_connection_info()` - Get connection details
+- `disconnect()` - Disconnect from room
+
+### Factory Functions
+
+- `create_client(role, base_url)` - Create client by role ("producer" or "consumer")
+- `create_producer_client(base_url, room_id=None)` - Create connected producer
+- `create_consumer_client(room_id, base_url)` - Create connected consumer
+
+## Requirements
+
+- Python 3.12+
+- aiohttp>=3.9.0
+- websockets>=12.0
+
+## Migration from v1
+
+The old `RoboticsClient` is still available for backward compatibility but is now an alias to `RoboticsClientCore`. For new code, use the specific `RoboticsProducer` or `RoboticsConsumer` classes for better type safety and cleaner APIs.

client/python/examples/README.md

@@ -0,0 +1,189 @@
+# LeRobot Arena Examples
+
+This directory contains example scripts demonstrating various aspects of the LeRobot Arena robotics system.
+
+## Prerequisites
+
+Before running these examples, ensure you have:
+
+1. **Server running**: Start the LeRobot Arena server
+   ```bash
+   # From the server directory
+   uvicorn src.api.main:app --reload
+   ```
+
+2. **Dependencies installed**: Install the Python client
+   ```bash
+   # From client/python directory
+   pip install -e .
+   ```
+
+## Examples Overview
+
+### 1. `basic_producer.py`
+**Basic Producer Usage**
+
+Demonstrates core producer functionality:
+- Creating a room
+- Connecting as a producer
+- Sending joint updates
+- Sending state synchronization
+- Basic error handling
+
+```bash
+python examples/basic_producer.py
+```
+
+### 2. `basic_consumer.py`
+**Basic Consumer Usage**
+
+Shows how to connect as a consumer and receive data:
+- Connecting to an existing room
+- Setting up event callbacks
+- Receiving joint updates and state sync
+- Getting current room state
+
+```bash
+python examples/basic_consumer.py
+# You'll need to enter a room ID from a running producer
+```
+
+### 3. `room_management.py`
+**Room Management Operations**
+
+Demonstrates REST API operations:
+- Listing all rooms
+- Creating rooms (auto-generated and custom IDs)
+- Getting room information and state
+- Deleting rooms
+
+```bash
+python examples/room_management.py
+```
+
+### 4. `producer_consumer_demo.py`
+**Complete Producer-Consumer Demo**
+
+Comprehensive demonstration featuring:
+- Producer and multiple consumers working together
+- Realistic robot movement simulation
+- Emergency stop functionality
+- State synchronization
+- Connection management and cleanup
+
+```bash
+python examples/producer_consumer_demo.py
+```
+
+### 5. `context_manager_example.py`
+**Context Managers and Advanced Patterns**
+
+Shows advanced usage patterns:
+- Using clients as context managers for automatic cleanup
+- Exception handling with proper resource management
+- Factory functions for quick client setup
+- Managing multiple clients
+
+```bash
+python examples/context_manager_example.py
+```
+
+## Running Examples
+
+### Quick Start (All-in-One Demo)
+For a complete demonstration, run:
+```bash
+python examples/producer_consumer_demo.py
+```
+
+### Step-by-Step Testing
+1. **Start with room management**:
+   ```bash
+   python examples/room_management.py
+   ```
+
+2. **Run producer in one terminal**:
+   ```bash
+   python examples/basic_producer.py
+   ```
+
+3. **Run consumer in another terminal**:
+   ```bash
+   python examples/basic_consumer.py
+   # Use the room ID from the producer
+   ```
+
+### Advanced Examples
+For more sophisticated patterns:
+```bash
+python examples/context_manager_example.py
+```
+
+## Key Concepts Demonstrated
+
+### Producer Capabilities
+- **Room Creation**: Creating and managing robotics rooms
+- **Joint Control**: Sending individual joint position updates
+- **State Synchronization**: Sending complete robot state
+- **Emergency Stop**: Triggering safety stops
+- **Error Handling**: Managing connection and communication errors
+
+### Consumer Capabilities
+- **Real-time Updates**: Receiving joint position updates
+- **State Monitoring**: Getting current robot state
+- **Event Callbacks**: Responding to various message types
+- **Multiple Consumers**: Supporting multiple clients per room
+
+### Connection Management
+- **WebSocket Communication**: Real-time bidirectional communication
+- **Auto-reconnection**: Handling connection failures
+- **Resource Cleanup**: Proper disconnection and cleanup
+- **Context Managers**: Automatic resource management
+
+### Error Handling
+- **Connection Failures**: Graceful handling of network issues
+- **Invalid Operations**: Handling invalid commands or states
+- **Emergency Scenarios**: Safety system demonstrations
+- **Resource Management**: Proper cleanup in error conditions
+
+## Example Output
+
+When running the examples, you'll see detailed logging output showing:
+- Connection status and events
+- Data being sent and received
+- Error conditions and handling
+- Resource cleanup operations
+
+Example log output:
+```
+INFO:__main__:Created room: abc123-def456-ghi789
+INFO:__main__:[Producer] Connected!
+INFO:__main__:[visualizer] Joint update #1: 4 joints
+INFO:__main__:[logger] Joint update #1: 4 joints
+INFO:__main__:🚨 [Producer] Sending emergency stop!
+INFO:__main__:[safety-monitor] ERROR: Emergency stop: Demo emergency stop
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Failed**: Ensure the server is running on `http://localhost:8000`
+2. **Import Errors**: Make sure you've installed the client package (`pip install -e .`)
+3. **Room Not Found**: Check that the room ID exists (run `room_management.py` to see active rooms)
+4. **Permission Denied**: Only one producer per room is allowed
+
+### Debug Mode
+Enable debug logging for more detailed output:
+```python
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## Next Steps
+
+After running these examples, you can:
+- Integrate the client into your own robotics applications
+- Modify the examples for your specific robot hardware
+- Build custom visualizers or control interfaces
+- Implement safety monitoring systems
+- Create automated testing scenarios 

client/python/examples/basic_consumer.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Basic Consumer Example - LeRobot Arena
+
+This example demonstrates:
+- Connecting to an existing room as a consumer
+- Receiving joint updates and state sync
+- Setting up callbacks
+- Getting current state
+"""
+
+import asyncio
+import logging
+
+from lerobot_arena_client import RoboticsConsumer
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def main():
+    """Basic consumer example."""
+    # You need to provide an existing room ID
+    # You can get this from running basic_producer.py first
+    room_id = input("Enter room ID to connect to: ").strip()
+
+    if not room_id:
+        logger.error("Room ID is required!")
+        return
+
+    # Create consumer client
+    consumer = RoboticsConsumer("http://localhost:8000")
+
+    # Track received updates
+    received_updates = []
+    received_states = []
+
+    # Set up callbacks
+    def on_joint_update(joints):
+        logger.info(f"Received joint update: {joints}")
+        received_updates.append(joints)
+
+    def on_state_sync(state):
+        logger.info(f"Received state sync: {state}")
+        received_states.append(state)
+
+    def on_error(error_msg):
+        logger.error(f"Consumer error: {error_msg}")
+
+    def on_connected():
+        logger.info("Consumer connected!")
+
+    def on_disconnected():
+        logger.info("Consumer disconnected!")
+
+    # Register all callbacks
+    consumer.on_joint_update(on_joint_update)
+    consumer.on_state_sync(on_state_sync)
+    consumer.on_error(on_error)
+    consumer.on_connected(on_connected)
+    consumer.on_disconnected(on_disconnected)
+
+    try:
+        # Connect to the room
+        success = await consumer.connect(room_id)
+        if not success:
+            logger.error("Failed to connect to room!")
+            return
+
+        # Get initial state
+        initial_state = await consumer.get_state_sync()
+        logger.info(f"Initial state: {initial_state}")
+
+        # Listen for updates for 30 seconds
+        logger.info("Listening for updates for 30 seconds...")
+        await asyncio.sleep(30)
+
+        # Show summary
+        logger.info(f"Received {len(received_updates)} joint updates")
+        logger.info(f"Received {len(received_states)} state syncs")
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+    finally:
+        # Always disconnect
+        if consumer.is_connected():
+            await consumer.disconnect()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/python/examples/basic_producer.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+Basic Producer Example - LeRobot Arena
+
+This example demonstrates:
+- Creating a room
+- Connecting as a producer
+- Sending joint updates
+- Basic error handling
+"""
+
+import asyncio
+import logging
+
+from lerobot_arena_client import RoboticsProducer
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def main():
+    """Basic producer example."""
+    # Create producer client
+    producer = RoboticsProducer("http://localhost:8000")
+
+    # Set up error callback
+    def on_error(error_msg):
+        logger.error(f"Producer error: {error_msg}")
+
+    producer.on_error(on_error)
+
+    try:
+        # Create a room and connect
+        room_id = await producer.create_room()
+        logger.info(f"Created room: {room_id}")
+
+        # Connect as producer
+        success = await producer.connect(room_id)
+        if not success:
+            logger.error("Failed to connect!")
+            return
+
+        logger.info("Connected as producer!")
+
+        # Send some joint updates
+        joints = [
+            {"name": "shoulder", "value": 45.0},
+            {"name": "elbow", "value": -20.0},
+            {"name": "wrist", "value": 10.0},
+        ]
+
+        logger.info("Sending joint updates...")
+        await producer.send_joint_update(joints)
+
+        # Send state sync (converted to joint updates)
+        state = {"shoulder": 90.0, "elbow": -45.0, "wrist": 0.0}
+
+        logger.info("Sending state sync...")
+        await producer.send_state_sync(state)
+
+        # Keep alive for a bit
+        await asyncio.sleep(2)
+
+        logger.info("Example completed successfully!")
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+    finally:
+        # Always disconnect
+        if producer.is_connected():
+            await producer.disconnect()
+            logger.info("Disconnected")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/python/examples/consumer_first_recorder.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""
+Consumer-First Video Recorder Example
+
+This example demonstrates the "consumer-first" scenario where:
+1. Consumer creates a room and waits
+2. Producer joins later and starts streaming
+3. Consumer records exactly 10 seconds of video when frames arrive
+4. Saves the recorded video to disk
+
+This tests the case where consumers are already waiting when producers start streaming.
+"""
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+from lerobot_arena_client.video import VideoConsumer
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+class VideoRecorder:
+    """Records video frames for a specific duration"""
+
+    def __init__(
+        self,
+        duration_seconds: float = 10.0,
+        output_dir: str = "./recordings",
+        fps: int = 30,
+    ):
+        self.duration_seconds = duration_seconds
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.fps = fps
+
+        # Recording state
+        self.recording = False
+        self.start_time: float | None = None
+        self.frames: list[np.ndarray] = []
+        self.frame_count = 0
+        self.recording_complete = False
+
+        # Video writer for MP4 output
+        self.video_writer: cv2.VideoWriter | None = None
+        self.video_path: Path | None = None
+
+    def start_recording(self, width: int, height: int) -> None:
+        """Start recording with the given frame dimensions"""
+        if self.recording:
+            logger.warning("Recording already in progress")
+            return
+
+        self.recording = True
+        self.start_time = time.time()
+        self.frames = []
+        self.frame_count = 0
+        self.recording_complete = False
+
+        # Create video writer for MP4 output
+        timestamp = int(time.time())
+        self.video_path = self.output_dir / f"recording_{timestamp}.mp4"
+
+        # Define codec and create VideoWriter
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        self.video_writer = cv2.VideoWriter(
+            str(self.video_path), fourcc, self.fps, (width, height)
+        )
+
+        logger.info(f"🎬 Started recording to {self.video_path}")
+        logger.info(f"   Duration: {self.duration_seconds}s")
+        logger.info(f"   Resolution: {width}x{height}")
+        logger.info(f"   Target FPS: {self.fps}")
+
+    def add_frame(self, frame_data) -> bool:
+        """Add a frame to the recording. Returns True if recording is complete."""
+        if not self.recording or self.recording_complete:
+            return self.recording_complete
+
+        # Check if recording duration exceeded
+        if self.start_time and time.time() - self.start_time > self.duration_seconds:
+            self.stop_recording()
+            return True
+
+        try:
+            # Extract frame information
+            metadata = frame_data.metadata
+            width = metadata.get("width", 0)
+            height = metadata.get("height", 0)
+
+            # Convert bytes to numpy array (server sends RGB format)
+            frame_bytes = frame_data.data
+            img_rgb = np.frombuffer(frame_bytes, dtype=np.uint8).reshape((
+                height,
+                width,
+                3,
+            ))
+
+            # Convert RGB to BGR for OpenCV
+            img_bgr = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR)
+
+            # Write frame to video
+            if self.video_writer:
+                self.video_writer.write(img_bgr)
+
+            # Store frame in memory for backup
+            self.frames.append(img_bgr.copy())
+            self.frame_count += 1
+
+            # Progress logging
+            if self.frame_count % 30 == 0:  # Every ~1 second at 30fps
+                elapsed = time.time() - self.start_time if self.start_time else 0
+                remaining = max(0, self.duration_seconds - elapsed)
+                logger.info(
+                    f"🎬 Recording: {elapsed:.1f}s / {self.duration_seconds}s ({remaining:.1f}s remaining)"
+                )
+
+        except Exception as e:
+            logger.error(f"❌ Error adding frame to recording: {e}")
+
+        return False
+
+    def stop_recording(self) -> dict:
+        """Stop recording and save the video"""
+        if not self.recording:
+            logger.warning("No recording in progress")
+            return {}
+
+        self.recording = False
+        self.recording_complete = True
+
+        # Release video writer
+        if self.video_writer:
+            self.video_writer.release()
+            self.video_writer = None
+
+        # Calculate stats
+        end_time = time.time()
+        actual_duration = end_time - self.start_time if self.start_time else 0
+        actual_fps = self.frame_count / actual_duration if actual_duration > 0 else 0
+
+        stats = {
+            "duration": actual_duration,
+            "frame_count": self.frame_count,
+            "target_fps": self.fps,
+            "actual_fps": actual_fps,
+            "video_path": str(self.video_path) if self.video_path else None,
+            "frame_backup_count": len(self.frames),
+        }
+
+        logger.info("🎬 Recording completed!")
+        logger.info(f"   Actual duration: {actual_duration:.1f}s")
+        logger.info(f"   Frames recorded: {self.frame_count}")
+        logger.info(f"   Actual FPS: {actual_fps:.1f}")
+        logger.info(f"   Video saved to: {self.video_path}")
+
+        # Also save frame sequence as backup
+        if self.frames:
+            self._save_frame_sequence()
+
+        return stats
+
+    def _save_frame_sequence(self) -> None:
+        """Save individual frames as image sequence backup"""
+        frame_dir = self.output_dir / f"frames_{int(time.time())}"
+        frame_dir.mkdir(exist_ok=True)
+
+        for i, frame in enumerate(self.frames):
+            frame_path = frame_dir / f"frame_{i:04d}.jpg"
+            cv2.imwrite(str(frame_path), frame)
+
+        logger.info(f"📸 Saved {len(self.frames)} frames to {frame_dir}")
+
+
+async def main():
+    """Main consumer-first recorder example"""
+    # Configuration
+    base_url = "http://localhost:8000"
+    recording_duration = 10.0  # Record for 10 seconds
+
+    logger.info("🎬 Consumer-First Video Recorder")
+    logger.info("=" * 50)
+    logger.info(f"Server: {base_url}")
+    logger.info(f"Recording duration: {recording_duration}s")
+    logger.info("")
+
+    # Create consumer
+    consumer = VideoConsumer(base_url)
+    recorder = VideoRecorder(duration_seconds=recording_duration)
+
+    # Track recording state
+    recording_started = False
+    recording_stats = {}
+
+    def handle_frame(frame_data):
+        """Handle received frame data"""
+        nonlocal recording_started, recording_stats
+
+        if not recording_started:
+            # Start recording on first frame
+            metadata = frame_data.metadata
+            width = metadata.get("width", 640)
+            height = metadata.get("height", 480)
+
+            recorder.start_recording(width, height)
+            recording_started = True
+
+        # Add frame to recording
+        is_complete = recorder.add_frame(frame_data)
+
+        if is_complete and not recording_stats:
+            recording_stats = recorder.stop_recording()
+
+    # Set up event handlers
+    consumer.on_frame_update(handle_frame)
+
+    def on_stream_started(config, producer_id):
+        logger.info(f"🚀 Producer {producer_id} started streaming!")
+        logger.info("🎬 Ready to record when frames arrive...")
+
+    def on_stream_stopped(producer_id, reason):
+        logger.info(f"⏹️ Producer {producer_id} stopped streaming")
+        if reason:
+            logger.info(f"   Reason: {reason}")
+
+    consumer.on_stream_started(on_stream_started)
+    consumer.on_stream_stopped(on_stream_stopped)
+
+    try:
+        # Step 1: Create our own room
+        logger.info("🏗️ Creating video room...")
+        room_id = await consumer.create_room("consumer-first-test")
+        logger.info(f"✅ Created room: {room_id}")
+
+        # Step 2: Connect as consumer
+        logger.info("🔌 Connecting to room as consumer...")
+        connected = await consumer.connect(room_id)
+
+        if not connected:
+            logger.error("❌ Failed to connect to room")
+            return
+
+        logger.info("✅ Connected as consumer successfully")
+
+        # Step 3: Start receiving (prepare for video)
+        logger.info("📺 Starting video reception...")
+        await consumer.start_receiving()
+
+        # Step 4: Wait for producer and record
+        logger.info("⏳ Waiting for producer to join and start streaming...")
+        logger.info(f"   Room ID: {room_id}")
+        logger.info("   (Start a producer with this room ID to begin recording)")
+
+        # Wait for recording to complete or timeout
+        timeout = 300  # 5 minutes timeout
+        start_wait = time.time()
+
+        while time.time() - start_wait < timeout:
+            await asyncio.sleep(1)
+
+            # Check if recording is complete
+            if recording_stats:
+                logger.info("🎉 Recording completed successfully!")
+                break
+
+            # Show waiting status every 30 seconds
+            elapsed_wait = time.time() - start_wait
+            if int(elapsed_wait) % 30 == 0 and elapsed_wait > 0:
+                remaining_timeout = timeout - elapsed_wait
+                logger.info(
+                    f"⏳ Still waiting for producer... ({remaining_timeout:.0f}s timeout remaining)"
+                )
+
+        # Final results
+        if recording_stats:
+            logger.info("📊 Final Recording Results:")
+            logger.info(f"   Duration: {recording_stats['duration']:.1f}s")
+            logger.info(f"   Frames: {recording_stats['frame_count']}")
+            logger.info(f"   FPS: {recording_stats['actual_fps']:.1f}")
+            logger.info(f"   Video file: {recording_stats['video_path']}")
+            logger.info("🎉 SUCCESS: Consumer-first recording completed!")
+        else:
+            logger.warning("⚠️ No recording was made - producer may not have joined")
+
+    except Exception as e:
+        logger.error(f"❌ Consumer-first recorder failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+    finally:
+        # Cleanup
+        logger.info("🧹 Cleaning up...")
+        try:
+            await consumer.stop_receiving()
+            await consumer.disconnect()
+            logger.info("👋 Consumer disconnected successfully")
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("🛑 Stopped by user")
+        logger.info("👋 Goodbye!")
+    except Exception as e:
+        logger.error(f"💥 Fatal error: {e}")
+        import traceback
+
+        traceback.print_exc()

client/python/examples/context_manager_example.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Context Manager Example - LeRobot Arena
+
+This example demonstrates:
+- Using clients as context managers for automatic cleanup
+- Exception handling with proper resource cleanup
+- Factory functions for quick client creation
+- Graceful error recovery
+"""
+
+import asyncio
+import logging
+
+from lerobot_arena_client import (
+    RoboticsConsumer,
+    RoboticsProducer,
+    create_consumer_client,
+    create_producer_client,
+)
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def basic_context_manager_example():
+    """Basic example using context managers."""
+    logger.info("=== Basic Context Manager Example ===")
+
+    # Using producer as context manager
+    async with RoboticsProducer("http://localhost:8000") as producer:
+        room_id = await producer.create_room()
+        logger.info(f"Created room: {room_id}")
+
+        await producer.connect(room_id)
+        logger.info("Producer connected")
+
+        # Send some data
+        await producer.send_state_sync({"joint1": 45.0, "joint2": -30.0})
+        logger.info("State sent")
+
+        # Exception handling within context
+        try:
+            # This might fail if room doesn't exist
+            await producer.send_joint_update([{"name": "invalid", "value": 999.0}])
+        except Exception as e:
+            logger.warning(f"Handled exception: {e}")
+
+    # Producer is automatically disconnected here
+    logger.info("Producer automatically disconnected")
+
+
+async def factory_function_example():
+    """Example using factory functions for quick setup."""
+    logger.info("\n=== Factory Function Example ===")
+
+    # Create and auto-connect producer with factory function
+    producer = await create_producer_client("http://localhost:8000")
+    room_id = producer.room_id
+    logger.info(f"Producer auto-connected to room: {room_id}")
+
+    try:
+        # Create and auto-connect consumer
+        consumer = await create_consumer_client(room_id, "http://localhost:8000")
+        logger.info("Consumer auto-connected")
+
+        # Set up callback
+        received_updates = []
+        consumer.on_joint_update(lambda joints: received_updates.append(joints))
+
+        # Send some updates
+        await producer.send_joint_update([
+            {"name": "shoulder", "value": 90.0},
+            {"name": "elbow", "value": -45.0},
+        ])
+
+        await asyncio.sleep(0.5)  # Wait for message propagation
+
+        logger.info(f"Consumer received {len(received_updates)} updates")
+
+    finally:
+        # Manual cleanup for factory-created clients
+        await producer.disconnect()
+        await consumer.disconnect()
+        logger.info("Manual cleanup completed")
+
+
+async def exception_handling_example():
+    """Example showing exception handling with context managers."""
+    logger.info("\n=== Exception Handling Example ===")
+
+    try:
+        async with RoboticsProducer("http://localhost:8000") as producer:
+            room_id = await producer.create_room()
+            await producer.connect(room_id)
+
+            # Simulate some work that might fail
+            for i in range(5):
+                if i == 3:
+                    # Simulate an error
+                    raise ValueError("Simulated error during operation")
+
+                await producer.send_state_sync({f"joint_{i}": float(i * 10)})
+                logger.info(f"Sent update {i}")
+                await asyncio.sleep(0.1)
+
+    except ValueError as e:
+        logger.error(f"Caught expected error: {e}")
+        logger.info("Context manager still ensures cleanup")
+
+    logger.info("Exception handling example completed")
+
+
+async def multiple_clients_example():
+    """Example with multiple clients using context managers."""
+    logger.info("\n=== Multiple Clients Example ===")
+
+    # Create room first
+    async with RoboticsProducer("http://localhost:8000") as setup_producer:
+        room_id = await setup_producer.create_room()
+        logger.info(f"Setup room: {room_id}")
+
+    # Now use multiple clients in the same room
+    async with RoboticsProducer("http://localhost:8000") as producer:
+        await producer.connect(room_id)
+
+        # Use multiple consumers
+        consumers = []
+        try:
+            # Create multiple consumers with context managers
+            for i in range(3):
+                consumer = RoboticsConsumer("http://localhost:8000")
+                consumers.append(consumer)
+                # Note: We're not using context manager here to show manual management
+                await consumer.connect(room_id, f"consumer-{i}")
+
+            logger.info(f"Connected {len(consumers)} consumers")
+
+            # Send data to all consumers
+            await producer.send_state_sync({
+                "base": 0.0,
+                "shoulder": 45.0,
+                "elbow": -30.0,
+                "wrist": 15.0,
+            })
+
+            await asyncio.sleep(0.5)  # Wait for propagation
+            logger.info("Data sent to all consumers")
+
+        finally:
+            # Manual cleanup for consumers
+            for i, consumer in enumerate(consumers):
+                await consumer.disconnect()
+                logger.info(f"Disconnected consumer-{i}")
+
+    logger.info("Multiple clients example completed")
+
+
+async def main():
+    """Run all context manager examples."""
+    logger.info("🤖 LeRobot Arena Context Manager Examples 🤖")
+
+    try:
+        await basic_context_manager_example()
+        await factory_function_example()
+        await exception_handling_example()
+        await multiple_clients_example()
+
+        logger.info("\n✅ All context manager examples completed successfully!")
+
+    except Exception as e:
+        logger.error(f"❌ Example failed: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/python/examples/producer_consumer_demo.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Producer-Consumer Demo - LeRobot Arena
+
+This example demonstrates:
+- Producer and multiple consumers working together
+- Real-time joint updates
+- Emergency stop functionality
+- State synchronization
+- Connection management
+"""
+
+import asyncio
+import logging
+import random
+
+from lerobot_arena_client import RoboticsConsumer, RoboticsProducer
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class DemoConsumer:
+    """Demo consumer that logs all received messages."""
+
+    def __init__(self, name: str, room_id: str):
+        self.name = name
+        self.room_id = room_id
+        self.consumer = RoboticsConsumer("http://localhost:8000")
+        self.update_count = 0
+        self.state_count = 0
+
+    async def setup(self):
+        """Setup consumer with callbacks."""
+
+        def on_joint_update(joints):
+            self.update_count += 1
+            logger.info(
+                f"[{self.name}] Joint update #{self.update_count}: {len(joints)} joints"
+            )
+
+        def on_state_sync(state):
+            self.state_count += 1
+            logger.info(
+                f"[{self.name}] State sync #{self.state_count}: {len(state)} joints"
+            )
+
+        def on_error(error_msg):
+            logger.error(f"[{self.name}] ERROR: {error_msg}")
+
+        def on_connected():
+            logger.info(f"[{self.name}] Connected!")
+
+        def on_disconnected():
+            logger.info(f"[{self.name}] Disconnected!")
+
+        self.consumer.on_joint_update(on_joint_update)
+        self.consumer.on_state_sync(on_state_sync)
+        self.consumer.on_error(on_error)
+        self.consumer.on_connected(on_connected)
+        self.consumer.on_disconnected(on_disconnected)
+
+    async def connect(self):
+        """Connect to room."""
+        success = await self.consumer.connect(self.room_id, f"demo-{self.name}")
+        if success:
+            logger.info(f"[{self.name}] Successfully connected to room {self.room_id}")
+        else:
+            logger.error(f"[{self.name}] Failed to connect to room {self.room_id}")
+        return success
+
+    async def disconnect(self):
+        """Disconnect from room."""
+        if self.consumer.is_connected():
+            await self.consumer.disconnect()
+        logger.info(
+            f"[{self.name}] Final stats: {self.update_count} updates, {self.state_count} states"
+        )
+
+
+async def simulate_robot_movement(producer: RoboticsProducer):
+    """Simulate realistic robot movement."""
+    # Define some realistic joint ranges for a robotic arm
+    joints = {
+        "base": {"current": 0.0, "target": 0.0, "min": -180, "max": 180},
+        "shoulder": {"current": 0.0, "target": 0.0, "min": -90, "max": 90},
+        "elbow": {"current": 0.0, "target": 0.0, "min": -135, "max": 135},
+        "wrist": {"current": 0.0, "target": 0.0, "min": -180, "max": 180},
+    }
+
+    logger.info("[Producer] Starting robot movement simulation...")
+
+    for step in range(20):  # 20 movement steps
+        # Occasionally set new random targets
+        if step % 5 == 0:
+            for joint_name, joint_data in joints.items():
+                joint_data["target"] = random.uniform(
+                    joint_data["min"], joint_data["max"]
+                )
+            logger.info(f"[Producer] Step {step + 1}: New targets set")
+
+        # Move each joint towards its target
+        joint_updates = []
+        for joint_name, joint_data in joints.items():
+            current = joint_data["current"]
+            target = joint_data["target"]
+
+            # Simple movement: move 10% towards target each step
+            diff = target - current
+            move = diff * 0.1
+            new_value = current + move
+
+            joint_data["current"] = new_value
+            joint_updates.append({"name": joint_name, "value": new_value})
+
+        # Send the joint updates
+        await producer.send_joint_update(joint_updates)
+
+        # Add some delay for realistic movement
+        await asyncio.sleep(0.5)
+
+    logger.info("[Producer] Movement simulation completed")
+
+
+async def main():
+    """Main demo function."""
+    logger.info("=== LeRobot Arena Producer-Consumer Demo ===")
+
+    # Create producer
+    producer = RoboticsProducer("http://localhost:8000")
+
+    # Setup producer callbacks
+    def on_producer_error(error_msg):
+        logger.error(f"[Producer] ERROR: {error_msg}")
+
+    def on_producer_connected():
+        logger.info("[Producer] Connected!")
+
+    def on_producer_disconnected():
+        logger.info("[Producer] Disconnected!")
+
+    producer.on_error(on_producer_error)
+    producer.on_connected(on_producer_connected)
+    producer.on_disconnected(on_producer_disconnected)
+
+    try:
+        # Create room and connect producer
+        room_id = await producer.create_room()
+        logger.info(f"Created room: {room_id}")
+
+        success = await producer.connect(room_id, "robot-controller")
+        if not success:
+            logger.error("Failed to connect producer!")
+            return
+
+        # Create multiple consumers
+        consumers = []
+        consumer_names = ["visualizer", "logger", "safety-monitor"]
+
+        for name in consumer_names:
+            consumer = DemoConsumer(name, room_id)
+            await consumer.setup()
+            consumers.append(consumer)
+
+        # Connect all consumers
+        logger.info("Connecting consumers...")
+        for consumer in consumers:
+            await consumer.connect()
+            await asyncio.sleep(0.1)  # Small delay between connections
+
+        # Send initial state
+        logger.info("[Producer] Sending initial state...")
+        initial_state = {"base": 0.0, "shoulder": 0.0, "elbow": 0.0, "wrist": 0.0}
+        await producer.send_state_sync(initial_state)
+        await asyncio.sleep(1)
+
+        # Start robot movement simulation
+        movement_task = asyncio.create_task(simulate_robot_movement(producer))
+
+        # Let it run for a bit
+        await asyncio.sleep(5)
+
+        # Demonstrate emergency stop
+        logger.info("🚨 [Producer] Sending emergency stop!")
+        await producer.send_emergency_stop(
+            "Demo emergency stop - testing safety systems"
+        )
+
+        # Wait for movement to complete
+        await movement_task
+
+        # Final state check
+        logger.info("=== Final Demo Summary ===")
+        for consumer in consumers:
+            logger.info(
+                f"[{consumer.name}] Received {consumer.update_count} updates, {consumer.state_count} states"
+            )
+
+        logger.info("Demo completed successfully!")
+
+    except Exception as e:
+        logger.error(f"Demo error: {e}")
+    finally:
+        # Cleanup
+        logger.info("Cleaning up...")
+
+        # Disconnect all consumers
+        for consumer in consumers:
+            await consumer.disconnect()
+
+        # Disconnect producer
+        if producer.is_connected():
+            await producer.disconnect()
+
+        logger.info("Demo cleanup completed")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/python/examples/room_management.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Room Management Example - LeRobot Arena
+
+This example demonstrates:
+- Listing rooms
+- Creating rooms (with and without custom IDs)
+- Getting room information
+- Getting room state
+- Deleting rooms
+"""
+
+import asyncio
+import logging
+
+from lerobot_arena_client import RoboticsClientCore
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def main():
+    """Room management example."""
+    # Create a basic client for API operations
+    client = RoboticsClientCore("http://localhost:8000")
+
+    try:
+        # List existing rooms
+        logger.info("=== Listing existing rooms ===")
+        rooms = await client.list_rooms()
+        logger.info(f"Found {len(rooms)} rooms:")
+        for room in rooms:
+            logger.info(
+                f"  - {room['id']}: {room['participants']['total']} participants"
+            )
+
+        # Create a room with auto-generated ID
+        logger.info("\n=== Creating room with auto-generated ID ===")
+        room_id_1 = await client.create_room()
+        logger.info(f"Created room: {room_id_1}")
+
+        # Create a room with custom ID
+        logger.info("\n=== Creating room with custom ID ===")
+        custom_room_id = "my-custom-room-123"
+        room_id_2 = await client.create_room(custom_room_id)
+        logger.info(f"Created custom room: {room_id_2}")
+
+        # Get room info
+        logger.info(f"\n=== Getting info for room {room_id_1} ===")
+        room_info = await client.get_room_info(room_id_1)
+        logger.info(f"Room info: {room_info}")
+
+        # Get room state
+        logger.info(f"\n=== Getting state for room {room_id_1} ===")
+        room_state = await client.get_room_state(room_id_1)
+        logger.info(f"Room state: {room_state}")
+
+        # List rooms again to see our new ones
+        logger.info("\n=== Listing rooms after creation ===")
+        rooms = await client.list_rooms()
+        logger.info(f"Now have {len(rooms)} rooms:")
+        for room in rooms:
+            logger.info(
+                f"  - {room['id']}: {room['participants']['total']} participants"
+            )
+
+        # Clean up - delete the rooms we created
+        logger.info("\n=== Cleaning up ===")
+
+        success_1 = await client.delete_room(room_id_1)
+        logger.info(f"Deleted room {room_id_1}: {success_1}")
+
+        success_2 = await client.delete_room(room_id_2)
+        logger.info(f"Deleted room {room_id_2}: {success_2}")
+
+        # Try to delete non-existent room
+        success_3 = await client.delete_room("non-existent-room")
+        logger.info(f"Tried to delete non-existent room: {success_3}")
+
+        # List final rooms
+        logger.info("\n=== Final room list ===")
+        rooms = await client.list_rooms()
+        logger.info(f"Final count: {len(rooms)} rooms")
+
+        logger.info("\nRoom management example completed!")
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

client/python/examples/test_consumer_fix.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+Test Consumer Fix
+
+This script tests the fixed Python video consumer to ensure it can properly
+receive and decode video frames from the server.
+"""
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+from lerobot_arena_client.video import VideoConsumer
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+class FrameProcessor:
+    """Processes received video frames and saves them for verification"""
+
+    def __init__(self, output_dir: str = "./test_frames"):
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(exist_ok=True)
+        self.frame_count = 0
+        self.total_bytes = 0
+        self.start_time = time.time()
+        self.last_frame_time = time.time()
+
+    def process_frame(self, frame_data):
+        """Process received frame data"""
+        try:
+            self.frame_count += 1
+            current_time = time.time()
+
+            # Extract metadata
+            metadata = frame_data.metadata
+            width = metadata.get("width", 0)
+            height = metadata.get("height", 0)
+            format_type = metadata.get("format", "unknown")
+
+            # Convert bytes back to numpy array
+            frame_bytes = frame_data.data
+            self.total_bytes += len(frame_bytes)
+
+            # Reconstruct numpy array from bytes
+            img = np.frombuffer(frame_bytes, dtype=np.uint8).reshape((height, width, 3))
+
+            # Save every 10th frame for verification
+            if self.frame_count % 10 == 0:
+                # Convert RGB to BGR for OpenCV saving
+                img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+                frame_path = self.output_dir / f"frame_{self.frame_count:06d}.jpg"
+                cv2.imwrite(str(frame_path), img_bgr)
+                logger.info(f"💾 Saved frame {self.frame_count} to {frame_path}")
+
+            # Calculate FPS
+            fps = (
+                1.0 / (current_time - self.last_frame_time)
+                if self.frame_count > 1
+                else 0
+            )
+            self.last_frame_time = current_time
+
+            # Log progress every 30 frames
+            if self.frame_count % 30 == 0:
+                elapsed = current_time - self.start_time
+                avg_fps = self.frame_count / elapsed if elapsed > 0 else 0
+                mb_received = self.total_bytes / (1024 * 1024)
+
+                logger.info("📊 Frame Stats:")
+                logger.info(f"   Frames: {self.frame_count}")
+                logger.info(f"   Resolution: {width}x{height}")
+                logger.info(f"   Format: {format_type}")
+                logger.info(f"   Current FPS: {fps:.1f}")
+                logger.info(f"   Average FPS: {avg_fps:.1f}")
+                logger.info(f"   Data received: {mb_received:.2f} MB")
+
+        except Exception as e:
+            logger.error(f"❌ Error processing frame {self.frame_count}: {e}")
+
+
+async def test_consumer_fix():
+    """Test the fixed consumer implementation"""
+    # Connect to the "webcam" room mentioned in the conversation
+    room_id = "webcam"
+    base_url = "http://localhost:8000"
+
+    logger.info("🎬 Testing Fixed Video Consumer")
+    logger.info("=" * 50)
+    logger.info(f"Room ID: {room_id}")
+    logger.info(f"Server: {base_url}")
+
+    # Create frame processor
+    processor = FrameProcessor()
+
+    # Create consumer
+    consumer = VideoConsumer(base_url)
+
+    # Set up frame callback
+    consumer.on_frame_update(processor.process_frame)
+
+    # Track connection states
+    connection_established = False
+    frames_received = False
+
+    def on_track_received(track):
+        nonlocal connection_established
+        connection_established = True
+        logger.info(f"✅ Video track received: {track.kind}")
+
+    try:
+        logger.info("🔌 Connecting to room...")
+        connected = await consumer.connect(room_id)
+
+        if not connected:
+            logger.error("❌ Failed to connect to room")
+            return False
+
+        logger.info("✅ Connected to room successfully")
+
+        # Start receiving
+        logger.info("📺 Starting video reception...")
+        await consumer.start_receiving()
+
+        # Wait for frames with timeout
+        test_duration = 30  # 30 seconds
+        logger.info(f"⏱️ Testing for {test_duration} seconds...")
+
+        start_time = time.time()
+        while time.time() - start_time < test_duration:
+            await asyncio.sleep(1)
+
+            # Check if we're receiving frames
+            if processor.frame_count > 0 and not frames_received:
+                frames_received = True
+                logger.info("🎉 First frame received successfully!")
+
+            # Show periodic status
+            if int(time.time() - start_time) % 5 == 0:
+                elapsed = time.time() - start_time
+                logger.info(
+                    f"⏱️ Test progress: {elapsed:.0f}s - Frames: {processor.frame_count}"
+                )
+
+        # Final results
+        logger.info("📊 Test Results:")
+        logger.info(f"   Connection established: {connection_established}")
+        logger.info(f"   Frames received: {frames_received}")
+        logger.info(f"   Total frames: {processor.frame_count}")
+
+        if processor.frame_count > 0:
+            elapsed = time.time() - processor.start_time
+            avg_fps = processor.frame_count / elapsed
+            mb_total = processor.total_bytes / (1024 * 1024)
+
+            logger.info(f"   Average FPS: {avg_fps:.1f}")
+            logger.info(f"   Total data: {mb_total:.2f} MB")
+            logger.info(
+                f"   Saved frames: {len(list(processor.output_dir.glob('*.jpg')))}"
+            )
+
+            # Verify saved frames
+            saved_frames = list(processor.output_dir.glob("*.jpg"))
+            if saved_frames:
+                logger.info(f"✅ SUCCESS: Frames saved to {processor.output_dir}")
+                logger.info(f"   Example frame: {saved_frames[0]}")
+
+            return True
+        logger.error("❌ FAILED: No frames received")
+        return False
+
+    except Exception as e:
+        logger.error(f"❌ Test failed with error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    finally:
+        # Cleanup
+        logger.info("🧹 Cleaning up...")
+        await consumer.stop_receiving()
+        logger.info("👋 Test completed")
+
+
+async def main():
+    """Main test function"""
+    try:
+        success = await test_consumer_fix()
+        if success:
+            logger.info("🎉 Consumer fix test PASSED!")
+            return 0
+        logger.error("💥 Consumer fix test FAILED!")
+        return 1
+    except KeyboardInterrupt:
+        logger.info("🛑 Test interrupted by user")
+        return 1
+    except Exception as e:
+        logger.error(f"💥 Unexpected error: {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    import sys
+
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)

client/python/examples/video_consumer_example.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Video Consumer Example - Fixed Version
+
+This example demonstrates how to connect as a video consumer and receive
+video frames from a producer in the LeRobot Arena.
+"""
+
+import asyncio
+import logging
+import time
+from pathlib import Path
+
+import cv2
+import numpy as np
+from lerobot_arena_client.video import VideoConsumer
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+
+class VideoFrameHandler:
+    """Handles received video frames with optional saving and display"""
+
+    def __init__(
+        self, save_frames: bool = False, output_dir: str = "./received_frames"
+    ):
+        self.save_frames = save_frames
+        self.output_dir = Path(output_dir) if save_frames else None
+        if self.output_dir:
+            self.output_dir.mkdir(exist_ok=True)
+
+        self.frame_count = 0
+        self.total_bytes = 0
+        self.start_time = time.time()
+        self.last_log_time = time.time()
+
+    def handle_frame(self, frame_data):
+        """Process received frame data"""
+        try:
+            self.frame_count += 1
+            current_time = time.time()
+
+            # Extract frame information
+            metadata = frame_data.metadata
+            width = metadata.get("width", 0)
+            height = metadata.get("height", 0)
+            format_type = metadata.get("format", "unknown")
+
+            # Convert bytes to numpy array
+            frame_bytes = frame_data.data
+            self.total_bytes += len(frame_bytes)
+
+            # Reconstruct image from bytes (server sends RGB format)
+            img = np.frombuffer(frame_bytes, dtype=np.uint8).reshape((height, width, 3))
+
+            # Save frames if requested
+            if self.save_frames and self.frame_count % 30 == 0:  # Save every 30th frame
+                # Convert RGB to BGR for OpenCV
+                img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+                frame_path = self.output_dir / f"frame_{self.frame_count:06d}.jpg"
+                cv2.imwrite(str(frame_path), img_bgr)
+                logger.info(f"💾 Saved frame {self.frame_count} to {frame_path}")
+
+            # Log statistics periodically
+            if current_time - self.last_log_time >= 5.0:  # Every 5 seconds
+                elapsed = current_time - self.start_time
+                fps = self.frame_count / elapsed if elapsed > 0 else 0
+                mb_received = self.total_bytes / (1024 * 1024)
+
+                logger.info("📊 Video Stats:")
+                logger.info(f"   Frames received: {self.frame_count}")
+                logger.info(f"   Resolution: {width}x{height}")
+                logger.info(f"   Format: {format_type}")
+                logger.info(f"   Average FPS: {fps:.1f}")
+                logger.info(f"   Data received: {mb_received:.2f} MB")
+
+                self.last_log_time = current_time
+
+        except Exception as e:
+            logger.error(f"❌ Error handling frame {self.frame_count}: {e}")
+
+
+async def main():
+    """Main consumer example"""
+    # Configuration
+    room_id = "webcam"  # Use the test webcam room
+    base_url = "http://localhost:8000"
+    duration = 60  # Run for 60 seconds
+    save_frames = True  # Save some frames as proof
+
+    logger.info("🎬 Video Consumer Example - Fixed Version")
+    logger.info("=" * 50)
+    logger.info(f"Room ID: {room_id}")
+    logger.info(f"Server: {base_url}")
+    logger.info(f"Duration: {duration} seconds")
+    logger.info(f"Save frames: {save_frames}")
+
+    # Create frame handler
+    frame_handler = VideoFrameHandler(save_frames=save_frames)
+
+    # Create consumer
+    consumer = VideoConsumer(base_url)
+
+    # Set up event handlers
+    consumer.on_frame_update(frame_handler.handle_frame)
+
+    # Track connection progress
+    connection_events = []
+
+    try:
+        logger.info("🔌 Connecting to room...")
+        connected = await consumer.connect(room_id)
+
+        if not connected:
+            logger.error("❌ Failed to connect to room")
+            return
+
+        logger.info("✅ Connected to room successfully")
+        connection_events.append("connected")
+
+        # Start receiving video
+        logger.info("📺 Starting video reception...")
+        await consumer.start_receiving()
+        connection_events.append("receiving_started")
+
+        # Run for specified duration
+        logger.info(f"⏱️ Running for {duration} seconds...")
+        logger.info("📺 Waiting for video frames... (Press Ctrl+C to stop early)")
+
+        start_time = time.time()
+        try:
+            while time.time() - start_time < duration:
+                await asyncio.sleep(1)
+
+                # Show progress
+                elapsed = time.time() - start_time
+                if int(elapsed) % 10 == 0 and elapsed > 0:  # Every 10 seconds
+                    logger.info(
+                        f"⏱️ Progress: {elapsed:.0f}s - Frames: {frame_handler.frame_count}"
+                    )
+
+        except KeyboardInterrupt:
+            logger.info("🛑 Stopped by user")
+
+        # Final statistics
+        elapsed = time.time() - start_time
+        logger.info("📊 Final Results:")
+        logger.info(f"   Test duration: {elapsed:.1f} seconds")
+        logger.info(f"   Total frames: {frame_handler.frame_count}")
+        logger.info(f"   Connection events: {connection_events}")
+
+        if frame_handler.frame_count > 0:
+            avg_fps = frame_handler.frame_count / elapsed
+            mb_total = frame_handler.total_bytes / (1024 * 1024)
+
+            logger.info(f"   Average FPS: {avg_fps:.1f}")
+            logger.info(f"   Total data: {mb_total:.2f} MB")
+
+            if save_frames and frame_handler.output_dir:
+                saved_files = list(frame_handler.output_dir.glob("*.jpg"))
+                logger.info(f"   Saved frames: {len(saved_files)}")
+                if saved_files:
+                    logger.info(f"   Output directory: {frame_handler.output_dir}")
+
+            logger.info("🎉 SUCCESS: Video consumer is working correctly!")
+        else:
+            logger.warning("⚠️ No frames received - check if producer is active")
+
+    except Exception as e:
+        logger.error(f"❌ Consumer example failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+    finally:
+        # Cleanup
+        logger.info("🧹 Cleaning up...")
+        try:
+            await consumer.stop_receiving()
+            logger.info("👋 Consumer stopped successfully")
+        except Exception as e:
+            logger.error(f"Error during cleanup: {e}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("👋 Goodbye!")
+    except Exception as e:
+        logger.error(f"💥 Fatal error: {e}")
+        import traceback
+
+        traceback.print_exc()

client/python/examples/video_producer_example.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Basic Video Producer Example
+
+Demonstrates how to use the LeRobot Arena Python video client for streaming.
+This example creates animated video content and streams it to the arena server.
+"""
+
+import asyncio
+import logging
+import time
+
+import numpy as np
+
+# Import the video client
+from lerobot_arena_client.video import (
+    VideoProducer,
+    create_producer_client,
+)
+
+
+async def animated_frame_source() -> np.ndarray | None:
+    """Create animated frames with colorful patterns"""
+    # Create a colorful animated frame
+    height, width = 480, 640
+    frame_count = int(time.time() * 30) % 1000  # 30 fps simulation
+
+    # Generate animated RGB channels using vectorized operations
+    time_factor = frame_count * 0.1
+
+    # Create colorful animated patterns
+    y_coords, x_coords = np.meshgrid(np.arange(width), np.arange(height), indexing="xy")
+
+    r = (128 + 127 * np.sin(time_factor + x_coords * 0.01)).astype(np.uint8)
+    g = (128 + 127 * np.sin(time_factor + y_coords * 0.01)).astype(np.uint8)
+    b = (128 + 127 * np.sin(time_factor) * np.ones((height, width))).astype(np.uint8)
+
+    # Stack into RGB frame
+    frame = np.stack([r, g, b], axis=2)
+
+    # Add a moving circle for visual feedback
+    center_x = int(320 + 200 * np.sin(frame_count * 0.05))
+    center_y = int(240 + 100 * np.cos(frame_count * 0.05))
+
+    # Create circle mask
+    circle_mask = (x_coords - center_x) ** 2 + (y_coords - center_y) ** 2 < 50**2
+    frame[circle_mask] = [255, 255, 0]  # Yellow circle
+
+    # Add frame counter text overlay
+    import cv2
+
+    cv2.putText(
+        frame,
+        f"Frame {frame_count}",
+        (20, 50),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        1.5,
+        (0, 0, 0),
+        3,
+    )  # Black outline
+    cv2.putText(
+        frame,
+        f"Frame {frame_count}",
+        (20, 50),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        1.5,
+        (255, 255, 255),
+        2,
+    )  # White text
+
+    return frame
+
+
+async def main():
+    """Main function demonstrating video producer functionality"""
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+    logger = logging.getLogger(__name__)
+
+    logger.info("🚀 Starting LeRobot Arena Video Producer Example")
+
+    try:
+        # Create video producer with configuration
+        producer = VideoProducer(base_url="http://localhost:8000")
+
+        # Set up event handlers
+        producer.on_connected(lambda: logger.info("✅ Connected to video server"))
+        producer.on_disconnected(
+            lambda: logger.info("👋 Disconnected from video server")
+        )
+        producer.on_error(lambda error: logger.error(f"❌ Error: {error}"))
+
+        producer.on_status_update(
+            lambda status, data: logger.info(f"📊 Status: {status}")
+        )
+        producer.on_stream_stats(
+            lambda stats: logger.debug(f"📈 Stats: {stats.average_fps:.1f}fps")
+        )
+
+        # Create a room and connect
+        room_id = await producer.create_room()
+        logger.info(f"🏠 Created room: {room_id}")
+
+        connected = await producer.connect(room_id)
+        if not connected:
+            logger.error("❌ Failed to connect to room")
+            return
+
+        logger.info(f"✅ Connected as producer to room: {room_id}")
+
+        # Start custom video stream with animated content
+        logger.info("🎬 Starting animated video stream...")
+        await producer.start_custom_stream(animated_frame_source)
+
+        logger.info("📺 Video streaming started!")
+        logger.info(f"🔗 Consumers can connect to room: {room_id}")
+        logger.info(
+            f"📱 Use JS consumer: http://localhost:5173/consumer?room={room_id}"
+        )
+
+        # Stream for demo duration
+        duration = 30  # Stream for 30 seconds
+        logger.info(f"⏱️  Streaming for {duration} seconds...")
+
+        for i in range(duration):
+            await asyncio.sleep(1)
+            if i % 5 == 0:
+                logger.info(f"📡 Streaming... {duration - i} seconds remaining")
+
+        logger.info("🛑 Stopping video stream...")
+        await producer.stop_streaming()
+
+    except Exception as e:
+        logger.error(f"❌ Unexpected error: {e}")
+        import traceback
+
+        traceback.print_exc()
+    finally:
+        # Clean up
+        logger.info("🧹 Cleaning up...")
+        if "producer" in locals():
+            await producer.disconnect()
+        logger.info("✅ Video producer example completed")
+
+
+async def camera_example():
+    """Example using actual camera (if available)"""
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+    logger.info("📷 Starting Camera Video Producer Example")
+
+    try:
+        # Create producer using factory function
+        producer = await create_producer_client(base_url="http://localhost:8000")
+
+        room_id = producer.current_room_id
+        logger.info(f"🏠 Connected to room: {room_id}")
+
+        # Get available cameras
+        cameras = await producer.get_camera_devices()
+        if cameras:
+            logger.info("📹 Available cameras:")
+            for camera in cameras:
+                logger.info(
+                    f"  Device {camera['device_id']}: {camera['name']} "
+                    f"({camera['resolution']['width']}x{camera['resolution']['height']})"
+                )
+
+            # Start camera stream
+            logger.info("📷 Starting camera stream...")
+            await producer.start_camera(device_id=0)
+
+            logger.info("📺 Camera streaming started!")
+            logger.info(f"🔗 Consumers can connect to room: {room_id}")
+
+            # Stream for demo duration
+            await asyncio.sleep(30)
+
+        else:
+            logger.warning("⚠️  No cameras found")
+
+    except Exception as e:
+        logger.error(f"❌ Camera error: {e}")
+        logger.info("💡 Make sure your camera is available and not used by other apps")
+    finally:
+        if "producer" in locals():
+            await producer.disconnect()
+
+
+async def screen_share_example():
+    """Example using screen sharing (animated pattern for demo)"""
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(__name__)
+
+    logger.info("🖥️  Starting Screen Share Example")
+
+    try:
+        producer = await create_producer_client()
+        room_id = producer.current_room_id
+
+        logger.info("🖥️  Starting screen share...")
+        await producer.start_screen_share()
+
+        logger.info(f"📺 Screen sharing started! Room: {room_id}")
+
+        # Share for demo duration
+        await asyncio.sleep(20)
+
+    except Exception as e:
+        logger.error(f"❌ Screen share error: {e}")
+    finally:
+        if "producer" in locals():
+            await producer.disconnect()
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        mode = sys.argv[1]
+
+        if mode == "camera":
+            asyncio.run(camera_example())
+        elif mode == "screen":
+            asyncio.run(screen_share_example())
+        elif mode == "animated":
+            asyncio.run(main())
+        else:
+            print("Usage:")
+            print("  python video_producer_example.py animated   # Animated content")
+            print("  python video_producer_example.py camera     # Camera stream")
+            print("  python video_producer_example.py screen     # Screen share")
+    else:
+        # Default: run animated example
+        asyncio.run(main())

client/python/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "lerobot_arena_client"
+version = "0.1.0"
+description = "Python client for LeRobot Arena robotics and video streaming API"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "aiohttp>=3.9.0",
+    "websockets>=15.0.1",
+    # Video client dependencies
+    "aiortc>=1.9.0",
+    "opencv-python>=4.10.0",
+    "numpy>=1.26.0",
+    "av>=13.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.0",
+    "pytest-asyncio>=1.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

client/python/src/lerobot_arena_client/__init__.py

@@ -0,0 +1,22 @@
+# Import video module
+from lerobot_arena_client import video
+from lerobot_arena_client.client import (
+    RoboticsClientCore,
+    RoboticsConsumer,
+    RoboticsProducer,
+    create_client,
+    create_consumer_client,
+    create_producer_client,
+)
+
+__all__ = [
+    # Robotics exports
+    "RoboticsClientCore",
+    "RoboticsConsumer",
+    "RoboticsProducer",
+    "create_client",
+    "create_consumer_client",
+    "create_producer_client",
+    # Video module
+    "video",
+]

client/python/src/lerobot_arena_client/client.py

@@ -0,0 +1,513 @@
+import asyncio
+import json
+import logging
+from collections.abc import Callable
+from urllib.parse import urlparse
+
+import aiohttp
+import websockets
+
+logger = logging.getLogger(__name__)
+
+
+class RoboticsClientCore:
+    """Base client for LeRobot Arena robotics API"""
+
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        self.base_url = base_url.rstrip("/")
+        self.api_base = f"{self.base_url}/robotics"
+
+        # WebSocket connection
+        self.websocket: websockets.WebSocketServerProtocol | None = None
+        self.workspace_id: str | None = None
+        self.room_id: str | None = None
+        self.role: str | None = None
+        self.participant_id: str | None = None
+        self.connected = False
+
+        # Background task for message handling
+        self._message_task: asyncio.Task | None = None
+
+    # ============= REST API METHODS =============
+
+    async def list_rooms(self, workspace_id: str) -> list[dict]:
+        """List all available rooms in a workspace"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.api_base}/workspaces/{workspace_id}/rooms"
+            ) as response:
+                response.raise_for_status()
+                result = await response.json()
+                # Extract the rooms list from the response
+                return result.get("rooms", [])
+
+    async def create_room(
+        self, workspace_id: str | None = None, room_id: str | None = None
+    ) -> tuple[str, str]:
+        """Create a new room and return (workspace_id, room_id)"""
+        # Generate workspace ID if not provided
+        final_workspace_id = workspace_id or self._generate_workspace_id()
+
+        payload = {}
+        if room_id:
+            payload["room_id"] = room_id
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.api_base}/workspaces/{final_workspace_id}/rooms", json=payload
+            ) as response:
+                response.raise_for_status()
+                result = await response.json()
+                return result["workspace_id"], result["room_id"]
+
+    async def delete_room(self, workspace_id: str, room_id: str) -> bool:
+        """Delete a room"""
+        async with aiohttp.ClientSession() as session:
+            async with session.delete(
+                f"{self.api_base}/workspaces/{workspace_id}/rooms/{room_id}"
+            ) as response:
+                if response.status == 404:
+                    return False
+                response.raise_for_status()
+                result = await response.json()
+                return result["success"]
+
+    async def get_room_state(self, workspace_id: str, room_id: str) -> dict:
+        """Get current room state"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.api_base}/workspaces/{workspace_id}/rooms/{room_id}/state"
+            ) as response:
+                response.raise_for_status()
+                result = await response.json()
+                # Extract the state from the response
+                return result.get("state", {})
+
+    async def get_room_info(self, workspace_id: str, room_id: str) -> dict:
+        """Get basic room information"""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                f"{self.api_base}/workspaces/{workspace_id}/rooms/{room_id}"
+            ) as response:
+                response.raise_for_status()
+                result = await response.json()
+                # Extract the room data from the response
+                return result.get("room", {})
+
+    # ============= WEBSOCKET CONNECTION =============
+
+    async def connect_to_room(
+        self,
+        workspace_id: str,
+        room_id: str,
+        role: str,
+        participant_id: str | None = None,
+    ) -> bool:
+        """Connect to a room as producer or consumer"""
+        if self.connected:
+            await self.disconnect()
+
+        self.workspace_id = workspace_id
+        self.room_id = room_id
+        self.role = role
+        self.participant_id = participant_id or f"{role}_{id(self)}"
+
+        # Convert HTTP URL to WebSocket URL
+        parsed = urlparse(self.base_url)
+        ws_scheme = "wss" if parsed.scheme == "https" else "ws"
+        ws_url = f"{ws_scheme}://{parsed.netloc}/robotics/workspaces/{workspace_id}/rooms/{room_id}/ws"
+
+        initial_state_sync = None
+
+        try:
+            self.websocket = await websockets.connect(ws_url)
+
+            # Send join message
+            join_message = {"participant_id": self.participant_id, "role": role}
+            await self.websocket.send(json.dumps(join_message))
+
+            # Wait for server response to join message
+            try:
+                response_text = await asyncio.wait_for(
+                    self.websocket.recv(), timeout=5.0
+                )
+                response = json.loads(response_text)
+
+                if response.get("type") == "error":
+                    logger.error(
+                        f"Server rejected connection: {response.get('message')}"
+                    )
+                    await self.websocket.close()
+                    return False
+                if response.get("type") == "state_sync":
+                    # Consumer receives initial state sync, store it and wait for joined message
+                    logger.debug("Received initial state sync")
+                    initial_state_sync = response
+                    # Wait for the joined message
+                    response_text = await asyncio.wait_for(
+                        self.websocket.recv(), timeout=5.0
+                    )
+                    response = json.loads(response_text)
+                    if response.get("type") == "joined":
+                        logger.info(f"Successfully joined room {room_id} as {role}")
+                    elif response.get("type") == "error":
+                        logger.error(
+                            f"Server rejected connection: {response.get('message')}"
+                        )
+                        await self.websocket.close()
+                        return False
+                    else:
+                        logger.warning(f"Unexpected response from server: {response}")
+                elif response.get("type") == "joined":
+                    logger.info(f"Successfully joined room {room_id} as {role}")
+                    # Connection successful, continue with setup
+                else:
+                    logger.warning(f"Unexpected response from server: {response}")
+
+            except TimeoutError:
+                logger.error("Timeout waiting for server response")
+                await self.websocket.close()
+                return False
+            except json.JSONDecodeError:
+                logger.error("Invalid JSON response from server")
+                await self.websocket.close()
+                return False
+
+            # Start message handling task
+            self._message_task = asyncio.create_task(self._handle_messages())
+
+            self.connected = True
+            logger.info(f"Connected to room {room_id} as {role}")
+
+            await self._on_connected()
+
+            # Process initial state sync if we received one
+            if initial_state_sync:
+                await self._process_message(initial_state_sync)
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to connect to room {room_id}: {e}")
+            return False
+
+    async def disconnect(self):
+        """Disconnect from current room"""
+        if self._message_task:
+            self._message_task.cancel()
+            try:
+                await self._message_task
+            except asyncio.CancelledError:
+                pass
+            self._message_task = None
+
+        if self.websocket:
+            await self.websocket.close()
+            self.websocket = None
+
+        self.connected = False
+        self.workspace_id = None
+        self.room_id = None
+        self.role = None
+        self.participant_id = None
+
+        await self._on_disconnected()
+
+        logger.info("Disconnected from room")
+
+    # ============= MESSAGE HANDLING =============
+
+    async def _handle_messages(self):
+        """Handle incoming WebSocket messages"""
+        try:
+            async for message in self.websocket:
+                try:
+                    data = json.loads(message)
+                    await self._process_message(data)
+                except json.JSONDecodeError:
+                    logger.error(f"Invalid JSON received: {message}")
+                except Exception as e:
+                    logger.error(f"Error processing message: {e}")
+
+        except websockets.exceptions.ConnectionClosed:
+            logger.info("WebSocket connection closed")
+        except Exception as e:
+            logger.error(f"WebSocket error: {e}")
+        finally:
+            self.connected = False
+            await self._on_disconnected()
+
+    async def _process_message(self, data: dict):
+        """Process incoming message based on type - to be overridden by subclasses"""
+        msg_type = data.get("type")
+
+        if msg_type == "joined":
+            logger.info(
+                f"Successfully joined room {data.get('room_id')} as {data.get('role')}"
+            )
+        elif msg_type == "heartbeat_ack":
+            logger.debug("Heartbeat acknowledged")
+        else:
+            # Let subclasses handle specific message types
+            await self._handle_role_specific_message(data)
+
+    async def _handle_role_specific_message(self, data: dict):
+        """Handle role-specific messages - to be overridden by subclasses"""
+
+    # ============= UTILITY METHODS =============
+
+    async def send_heartbeat(self):
+        """Send heartbeat to server"""
+        if not self.connected:
+            return
+
+        message = {"type": "heartbeat"}
+        await self.websocket.send(json.dumps(message))
+
+    def is_connected(self) -> bool:
+        """Check if client is connected"""
+        return self.connected
+
+    def get_connection_info(self) -> dict:
+        """Get current connection information"""
+        return {
+            "connected": self.connected,
+            "workspace_id": self.workspace_id,
+            "room_id": self.room_id,
+            "role": self.role,
+            "participant_id": self.participant_id,
+            "base_url": self.base_url,
+        }
+
+    # ============= HOOKS FOR SUBCLASSES =============
+
+    async def _on_connected(self):
+        """Called when connection is established - to be overridden by subclasses"""
+
+    async def _on_disconnected(self):
+        """Called when connection is lost - to be overridden by subclasses"""
+
+    # ============= CONTEXT MANAGER SUPPORT =============
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    # ============= WORKSPACE HELPERS =============
+
+    def _generate_workspace_id(self) -> str:
+        """Generate a UUID-like workspace ID"""
+        import uuid
+
+        return str(uuid.uuid4())
+
+
+class RoboticsProducer(RoboticsClientCore):
+    """Producer client for controlling robots"""
+
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        super().__init__(base_url)
+        self._on_error_callback: Callable[[str], None] | None = None
+        self._on_connected_callback: Callable[[], None] | None = None
+        self._on_disconnected_callback: Callable[[], None] | None = None
+
+    async def connect(
+        self, workspace_id: str, room_id: str, participant_id: str | None = None
+    ) -> bool:
+        """Connect as producer to a room"""
+        return await self.connect_to_room(
+            workspace_id, room_id, "producer", participant_id
+        )
+
+    # ============= PRODUCER METHODS =============
+
+    async def send_joint_update(self, joints: list[dict]):
+        """Send joint updates"""
+        if not self.connected:
+            raise ValueError("Must be connected to send joint updates")
+
+        message = {"type": "joint_update", "data": joints}
+        await self.websocket.send(json.dumps(message))
+
+    async def send_state_sync(self, state: dict):
+        """Send state synchronization (convert dict to list format)"""
+        joints = [{"name": name, "value": value} for name, value in state.items()]
+        await self.send_joint_update(joints)
+
+    async def send_emergency_stop(self, reason: str = "Emergency stop"):
+        """Send emergency stop signal"""
+        if not self.connected:
+            raise ValueError("Must be connected to send emergency stop")
+
+        message = {"type": "emergency_stop", "reason": reason}
+        await self.websocket.send(json.dumps(message))
+
+    # ============= EVENT CALLBACKS =============
+
+    def on_error(self, callback: Callable[[str], None]):
+        """Set callback for error events"""
+        self._on_error_callback = callback
+
+    def on_connected(self, callback: Callable[[], None]):
+        """Set callback for connection events"""
+        self._on_connected_callback = callback
+
+    def on_disconnected(self, callback: Callable[[], None]):
+        """Set callback for disconnection events"""
+        self._on_disconnected_callback = callback
+
+    # ============= OVERRIDDEN HOOKS =============
+
+    async def _on_connected(self):
+        if self._on_connected_callback:
+            self._on_connected_callback()
+
+    async def _on_disconnected(self):
+        if self._on_disconnected_callback:
+            self._on_disconnected_callback()
+
+    async def _handle_role_specific_message(self, data: dict):
+        """Handle producer-specific messages"""
+        msg_type = data.get("type")
+
+        if msg_type == "emergency_stop":
+            logger.warning(f"🚨 Emergency stop: {data.get('reason', 'Unknown reason')}")
+            if self._on_error_callback:
+                self._on_error_callback(
+                    f"Emergency stop: {data.get('reason', 'Unknown reason')}"
+                )
+
+        elif msg_type == "error":
+            error_msg = data.get("message", "Unknown error")
+            logger.error(f"Server error: {error_msg}")
+            if self._on_error_callback:
+                self._on_error_callback(error_msg)
+
+        else:
+            logger.warning(f"Unknown message type for producer: {msg_type}")
+
+
+class RoboticsConsumer(RoboticsClientCore):
+    """Consumer client for receiving robot commands"""
+
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        super().__init__(base_url)
+        self._on_state_sync_callback: Callable[[dict], None] | None = None
+        self._on_joint_update_callback: Callable[[list], None] | None = None
+        self._on_error_callback: Callable[[str], None] | None = None
+        self._on_connected_callback: Callable[[], None] | None = None
+        self._on_disconnected_callback: Callable[[], None] | None = None
+
+    async def connect(
+        self, workspace_id: str, room_id: str, participant_id: str | None = None
+    ) -> bool:
+        """Connect as consumer to a room"""
+        return await self.connect_to_room(
+            workspace_id, room_id, "consumer", participant_id
+        )
+
+    # ============= CONSUMER METHODS =============
+
+    async def get_state_sync(self) -> dict:
+        """Get current state synchronously"""
+        if not self.workspace_id or not self.room_id:
+            raise ValueError("Must be connected to a room")
+
+        state = await self.get_room_state(self.workspace_id, self.room_id)
+        return state.get("joints", {})
+
+    # ============= EVENT CALLBACKS =============
+
+    def on_state_sync(self, callback: Callable[[dict], None]):
+        """Set callback for state synchronization events"""
+        self._on_state_sync_callback = callback
+
+    def on_joint_update(self, callback: Callable[[list], None]):
+        """Set callback for joint update events"""
+        self._on_joint_update_callback = callback
+
+    def on_error(self, callback: Callable[[str], None]):
+        """Set callback for error events"""
+        self._on_error_callback = callback
+
+    def on_connected(self, callback: Callable[[], None]):
+        """Set callback for connection events"""
+        self._on_connected_callback = callback
+
+    def on_disconnected(self, callback: Callable[[], None]):
+        """Set callback for disconnection events"""
+        self._on_disconnected_callback = callback
+
+    # ============= OVERRIDDEN HOOKS =============
+
+    async def _on_connected(self):
+        if self._on_connected_callback:
+            self._on_connected_callback()
+
+    async def _on_disconnected(self):
+        if self._on_disconnected_callback:
+            self._on_disconnected_callback()
+
+    async def _handle_role_specific_message(self, data: dict):
+        """Handle consumer-specific messages"""
+        msg_type = data.get("type")
+
+        if msg_type == "state_sync":
+            if self._on_state_sync_callback:
+                self._on_state_sync_callback(data.get("data", {}))
+
+        elif msg_type == "joint_update":
+            if self._on_joint_update_callback:
+                self._on_joint_update_callback(data.get("data", []))
+
+        elif msg_type == "emergency_stop":
+            logger.warning(f"🚨 Emergency stop: {data.get('reason', 'Unknown reason')}")
+            if self._on_error_callback:
+                self._on_error_callback(
+                    f"Emergency stop: {data.get('reason', 'Unknown reason')}"
+                )
+
+        elif msg_type == "error":
+            error_msg = data.get("message", "Unknown error")
+            logger.error(f"Server error: {error_msg}")
+            if self._on_error_callback:
+                self._on_error_callback(error_msg)
+
+        else:
+            logger.warning(f"Unknown message type for consumer: {msg_type}")
+
+
+# ============= FACTORY FUNCTIONS =============
+
+
+def create_client(role: str, base_url: str = "http://localhost:8000"):
+    """Factory function to create the appropriate client based on role"""
+    if role == "producer":
+        return RoboticsProducer(base_url)
+    if role == "consumer":
+        return RoboticsConsumer(base_url)
+    raise ValueError(f"Invalid role: {role}. Must be 'producer' or 'consumer'")
+
+
+async def create_producer_client(
+    base_url: str = "http://localhost:8000",
+    workspace_id: str | None = None,
+    room_id: str | None = None,
+) -> RoboticsProducer:
+    """Create and connect a producer client"""
+    client = RoboticsProducer(base_url)
+
+    workspace_id, room_id = await client.create_room(workspace_id, room_id)
+    await client.connect(workspace_id, room_id)
+    return client
+
+
+async def create_consumer_client(
+    workspace_id: str, room_id: str, base_url: str = "http://localhost:8000"
+) -> RoboticsConsumer:
+    """Create and connect a consumer client"""
+    client = RoboticsConsumer(base_url)
+    await client.connect(workspace_id, room_id)
+    return client

client/python/src/lerobot_arena_client/video/__init__.py

@@ -0,0 +1,160 @@
+"""
+LeRobot Arena Video Client - Main Module
+
+TypeScript/JavaScript client for video streaming and monitoring
+"""
+
+# Export core classes
+from .consumer import VideoConsumer
+from .core import VideoClientCore
+
+# Export factory functions for convenience
+from .factory import create_client, create_consumer_client, create_producer_client
+from .producer import CameraVideoTrack, CustomVideoTrack, VideoProducer
+
+# Export all types
+from .types import (
+    DEFAULT_CLIENT_OPTIONS,
+    # Defaults
+    DEFAULT_RESOLUTION,
+    DEFAULT_VIDEO_CONFIG,
+    # API response types
+    ApiResponse,
+    # Message types
+    BaseMessage,
+    # Client options
+    ClientOptions,
+    ConnectedCallback,
+    ConnectionInfo,
+    # Request types
+    CreateRoomRequest,
+    CreateRoomResponse,
+    DeleteRoomResponse,
+    DisconnectedCallback,
+    EmergencyStopMessage,
+    ErrorCallback,
+    ErrorMessage,
+    # Data structures
+    FrameData,
+    # Event callback types
+    FrameUpdateCallback,
+    FrameUpdateMessage,
+    GetRoomResponse,
+    GetRoomStateResponse,
+    JoinedMessage,
+    JoinMessage,
+    ListRoomsResponse,
+    MessageType,
+    ParticipantInfo,
+    ParticipantJoinedMessage,
+    ParticipantLeftMessage,
+    # Core types
+    ParticipantRole,
+    RecoveryConfig,
+    RecoveryPolicy,
+    RecoveryTriggeredCallback,
+    RecoveryTriggeredMessage,
+    # Configuration types
+    Resolution,
+    RoomInfo,
+    RoomState,
+    StatusUpdateCallback,
+    StatusUpdateMessage,
+    StreamStartedCallback,
+    StreamStartedMessage,
+    StreamStats,
+    StreamStatsCallback,
+    StreamStatsMessage,
+    StreamStoppedCallback,
+    StreamStoppedMessage,
+    VideoConfig,
+    VideoConfigUpdateCallback,
+    VideoConfigUpdateMessage,
+    VideoEncoding,
+    WebRTCAnswerMessage,
+    # WebRTC types
+    WebRTCConfig,
+    WebRTCIceMessage,
+    WebRTCOfferMessage,
+    WebRTCSignalRequest,
+    WebRTCSignalResponse,
+    WebRTCStats,
+)
+
+__all__ = [
+    "DEFAULT_CLIENT_OPTIONS",
+    # Defaults
+    "DEFAULT_RESOLUTION",
+    "DEFAULT_VIDEO_CONFIG",
+    # API response types
+    "ApiResponse",
+    # Message types
+    "BaseMessage",
+    "CameraVideoTrack",
+    # Client options
+    "ClientOptions",
+    "ConnectedCallback",
+    "ConnectionInfo",
+    # Request types
+    "CreateRoomRequest",
+    "CreateRoomResponse",
+    "CustomVideoTrack",
+    "DeleteRoomResponse",
+    "DisconnectedCallback",
+    "EmergencyStopMessage",
+    "ErrorCallback",
+    "ErrorMessage",
+    # Data structures
+    "FrameData",
+    # Event callback types
+    "FrameUpdateCallback",
+    "FrameUpdateMessage",
+    "GetRoomResponse",
+    "GetRoomStateResponse",
+    "JoinMessage",
+    "JoinedMessage",
+    "ListRoomsResponse",
+    "MessageType",
+    "ParticipantInfo",
+    "ParticipantJoinedMessage",
+    "ParticipantLeftMessage",
+    # Core types
+    "ParticipantRole",
+    "RecoveryConfig",
+    "RecoveryPolicy",
+    "RecoveryTriggeredCallback",
+    "RecoveryTriggeredMessage",
+    # Configuration types
+    "Resolution",
+    "RoomInfo",
+    "RoomState",
+    "StatusUpdateCallback",
+    "StatusUpdateMessage",
+    "StreamStartedCallback",
+    "StreamStartedMessage",
+    "StreamStats",
+    "StreamStatsCallback",
+    "StreamStatsMessage",
+    "StreamStoppedCallback",
+    "StreamStoppedMessage",
+    # Core classes
+    "VideoClientCore",
+    "VideoConfig",
+    "VideoConfigUpdateCallback",
+    "VideoConfigUpdateMessage",
+    "VideoConsumer",
+    "VideoEncoding",
+    "VideoProducer",
+    "WebRTCAnswerMessage",
+    # WebRTC types
+    "WebRTCConfig",
+    "WebRTCIceMessage",
+    "WebRTCOfferMessage",
+    "WebRTCSignalRequest",
+    "WebRTCSignalResponse",
+    "WebRTCStats",
+    "create_client",
+    "create_consumer_client",
+    # Factory functions
+    "create_producer_client",
+]