squash: initial commit

.dockerignore

@@ -0,0 +1,22 @@
+node_modules
+.git
+.gitignore
+README.md
+Dockerfile
+docker-compose.yml
+.dockerignore
+.env
+.env.local
+.svelte-kit
+dist
+build
+.vscode
+*.log
+.DS_Store
+src-python/.venv
+src-python/.git
+src-python/target
+src-python/dist
+src-python/build
+*.pyc
+__pycache__ 

.gitattributes

@@ -0,0 +1 @@
+*.stl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,28 @@
+node_modules
+
+# Output
+.output
+.vercel
+.netlify
+.wrangler
+/.svelte-kit
+/build
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Env
+.env
+.env.*
+!.env.example
+!.env.test
+
+# Vite
+vite.config.js.timestamp-*
+vite.config.ts.timestamp-*
+
+# Box-packager / PyApp build artifacts
+src-python/target/
+src-python/dist/
+src-python/build/

.npmrc

@@ -0,0 +1 @@
+engine-strict=true

.prettierignore

@@ -0,0 +1,6 @@
+# Package Managers
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+bun.lock
+bun.lockb

.prettierrc

@@ -0,0 +1,15 @@
+{
+	"useTabs": true,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"printWidth": 100,
+	"plugins": ["prettier-plugin-svelte", "prettier-plugin-tailwindcss"],
+	"overrides": [
+		{
+			"files": "*.svelte",
+			"options": {
+				"parser": "svelte"
+			}
+		}
+	]
+}

DOCKER_README.md

@@ -0,0 +1,287 @@
+# 🐳 LeRobot Arena Docker Setup
+
+This Docker setup provides a containerized environment that runs both the Python backend and Svelte frontend for LeRobot Arena using modern tools like Bun, uv, and box-packager.
+
+## 🚀 Quick Start
+
+### Using Docker Compose (Recommended)
+
+```bash
+# Build and start both services
+docker-compose up --build
+
+# Or run in detached mode
+docker-compose up -d --build
+```
+
+### Using Docker directly
+
+```bash
+# Build the image
+docker build -t lerobot-arena .
+
+# Run the container
+docker run -p 8080:8080 -p 7860:7860 lerobot-arena
+```
+
+## 🌐 Access the Application
+
+After starting the container, you can access:
+
+- **Frontend (Svelte)**: http://localhost:7860
+- **Backend (Python/FastAPI)**: http://localhost:8080
+- **Backend API Docs**: http://localhost:8080/docs
+
+## 📋 What's Included
+
+The Docker container includes:
+
+1. **Frontend**: 
+   - Svelte application built as static files using **Bun**
+   - Served on port 7860 using Python's built-in HTTP server
+   - Production-ready build with all optimizations
+
+2. **Backend**:
+   - FastAPI Python server with dependencies managed by **uv**
+   - **Standalone executable** created with **box-packager** for faster startup
+   - WebSocket support for real-time robot communication
+   - Runs on port 8080
+   - Auto-configured for container environment
+
+## 🛠️ Development vs Production
+
+### Production (Default)
+The Dockerfile builds the Svelte app as static files using Bun and packages the Python backend as a standalone executable using box-packager.
+
+### Development
+For development with hot-reload, you can use local tools:
+
+```bash
+# Terminal 1: Frontend development
+bun run dev
+
+# Terminal 2: Backend development
+cd src-python && python start_server.py
+```
+
+## 📁 Container Structure
+
+```
+/home/user/app/
+├── src-python/          # Python backend source
+│   └── target/release/  # Box-packager standalone executable
+├── static-frontend/     # Built Svelte app (static files)
+└── start_services.sh    # Startup script for both services
+```
+
+## 🔧 Build Process
+
+The Docker build process includes these key steps:
+
+1. **Frontend Build Stage (Bun)**:
+   - Uses `oven/bun:1-alpine` for fast package management
+   - Builds Svelte app with `bun run build`
+   - Produces optimized static files
+
+2. **Backend Build Stage (Python + Rust)**:
+   - Installs Rust/Cargo for box-packager
+   - Uses `uv` for fast Python dependency management  
+   - Packages backend with `box package` into standalone executable
+   - Configures proper user permissions for HF Spaces
+
+3. **Runtime**:
+   - Runs standalone executable (faster startup)
+   - Serves frontend static files
+   - Both services managed by startup script
+
+## 🚀 Performance Benefits
+
+### Box-packager Advantages:
+- **Faster startup**: No Python interpreter overhead
+- **Self-contained**: All dependencies bundled
+- **Smaller runtime**: No need for full Python environment
+- **Cross-platform**: Single executable works anywhere
+
+### Build Optimization:
+- **Bun**: Faster JavaScript package manager and bundler
+- **uv**: Ultra-fast Python package manager
+- **Multi-stage build**: Minimal final image size
+- **Alpine base**: Lightweight frontend build stage
+
+## 🔧 Customization
+
+### Environment Variables
+
+You can customize the container behavior using environment variables:
+
+```bash
+docker run -p 8080:8080 -p 7860:7860 \
+  -e PYTHONUNBUFFERED=1 \
+  -e NODE_ENV=production \
+  lerobot-arena
+```
+
+### Port Configuration
+
+To use different ports:
+
+```bash
+# Map to different host ports
+docker run -p 9000:8080 -p 3000:7860 lerobot-arena
+```
+
+Then access:
+- Frontend: http://localhost:3000
+- Backend: http://localhost:9000
+
+### Volume Mounts for Persistence
+
+```bash
+# Mount data directory for persistence
+docker run -p 8080:8080 -p 7860:7860 \
+  -v $(pwd)/data:/home/user/app/data \
+  lerobot-arena
+```
+
+## 🐛 Troubleshooting
+
+### Container won't start
+```bash
+# Check logs
+docker-compose logs lerobot-arena
+
+# Or for direct docker run
+docker logs <container-id>
+```
+
+### Port conflicts
+```bash
+# Check what's using the ports
+lsof -i :8080
+lsof -i :7860
+
+# Kill processes or use different ports
+docker run -p 8081:8080 -p 7861:7860 lerobot-arena
+```
+
+### Frontend not loading
+```bash
+# Verify the frontend was built correctly
+docker exec -it <container-id> ls -la /home/user/app/static-frontend
+
+# Check if frontend server is running
+docker exec -it <container-id> ps aux | grep python
+```
+
+### Backend API errors
+```bash
+# Check if standalone executable is running
+docker exec -it <container-id> ps aux | grep lerobot-arena-server
+
+# Test backend directly
+curl http://localhost:8080/
+```
+
+### Box-packager Build Issues
+```bash
+# Force rebuild without cache to fix cargo/box issues
+docker-compose build --no-cache
+docker-compose up
+
+# Check if Rust/Cargo is properly installed
+docker exec -it <container-id> cargo --version
+```
+
+## 🔄 Updates and Rebuilding
+
+```bash
+# Pull latest code and rebuild
+git pull
+docker-compose down
+docker-compose up --build
+
+# Force rebuild without cache
+docker-compose build --no-cache
+docker-compose up
+```
+
+## 🚀 Hugging Face Spaces Deployment
+
+This Docker setup is optimized for Hugging Face Spaces:
+
+### Key Features for HF Spaces:
+- **Port 7860**: Uses the default HF Spaces port
+- **User permissions**: Runs as user ID 1000 as required
+- **Proper ownership**: All files owned by the user
+- **Git support**: Includes git for dependency resolution
+- **Standalone executable**: Faster cold starts on HF infrastructure
+
+### Deployment Steps:
+1. Push your code to a GitHub repository
+2. Create a new Space on Hugging Face Spaces
+3. Connect your GitHub repository
+4. The YAML frontmatter in README.md will auto-configure the Space
+5. HF will build and deploy your Docker container automatically
+
+### Accessing on HF Spaces:
+- Your Space URL will serve the frontend directly
+- Backend API will be available at your-space-url/api/ (if using a reverse proxy)
+
+## 🔧 Advanced Configuration
+
+### Using with nginx (Production)
+```nginx
+server {
+    listen 80;
+    
+    # Serve frontend
+    location / {
+        proxy_pass http://localhost:7860;
+    }
+    
+    # Proxy API calls
+    location /api/ {
+        proxy_pass http://localhost:8080;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_cache_bypass $http_upgrade;
+    }
+    
+    # WebSocket support
+    location /ws/ {
+        proxy_pass http://localhost:8080;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+```
+
+## 📊 Container Stats
+
+```bash
+# Monitor resource usage
+docker stats lerobot-arena
+
+# View container info
+docker inspect lerobot-arena
+```
+
+## 🧹 Cleanup
+
+```bash
+# Stop and remove containers
+docker-compose down
+
+# Remove images
+docker rmi lerobot-arena
+
+# Clean up unused images and containers
+docker system prune -a
+```
+
+---
+
+**Happy containerized robotics! 🤖🐳** 

Dockerfile

@@ -0,0 +1,71 @@
+# Multi-stage Dockerfile for LeRobot Arena
+# Stage 1: Build Svelte frontend with Bun
+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 package files
+COPY package.json bun.lockb* ./
+
+# Install dependencies with bun
+RUN bun install
+
+# Copy source code
+COPY . .
+
+# Build the Svelte app
+RUN bun run build
+
+# Stage 2: Python backend with official uv image
+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 src-python/pyproject.toml src-python/uv.lock ./src-python/
+
+# Install dependencies first (better caching)
+WORKDIR $HOME/app/src-python
+RUN uv sync --no-install-project
+
+# Copy the rest of the Python backend
+COPY --chown=user src-python/ ./
+
+# Install the project itself
+RUN uv sync
+
+# Copy built frontend from previous stage with proper ownership
+COPY --chown=user --from=frontend-builder /app/build $HOME/app/static-frontend
+
+# Create a startup script that runs both services
+WORKDIR $HOME/app
+RUN echo '#!/bin/bash\n\
+echo "Starting LeRobot Arena services..."\n\
+echo "🚀 Starting Python backend on port 8080..."\n\
+cd $HOME/app/src-python && uv run python start_server.py &\n\
+echo "🌐 Starting static file server on port 7860..."\n\
+cd $HOME/app/static-frontend && python -m http.server 7860 --bind 0.0.0.0 &\n\
+echo "✅ Both services started!"\n\
+echo "Backend: http://localhost:8080"\n\
+echo "Frontend: http://localhost:7860"\n\
+wait' > start_services.sh && chmod +x start_services.sh
+
+# Expose both ports (7860 is default for HF Spaces)
+EXPOSE 7860 8080
+
+# Start both services
+CMD ["./start_services.sh"] 

README.md

@@ -0,0 +1,265 @@
+---
+title: LeRobot Arena
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+suggested_hardware: cpu-upgrade
+suggested_storage: small
+short_description: A web-based robotics control and simulation platform that bridges digital twins and physical robots
+tags:
+  - robotics
+  - control
+  - simulation
+  - websocket
+  - fastapi
+  - svelte
+  - urdf
+  - 3d-visualization
+pinned: false
+fullWidth: true
+---
+
+# 🤖 LeRobot Arena
+
+A web-based robotics control and simulation platform that bridges digital twins and physical robots. Built with Svelte for the frontend and FastAPI for the backend.
+
+## 🚀 Quick Start with Docker
+
+The easiest way to run LeRobot Arena 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. **Clone the repository**
+   ```bash
+   git clone <your-repo-url>
+   cd lerobot-arena
+   ```
+
+2. **Build and start the services**
+   ```bash
+   docker-compose up --build
+   ```
+
+3. **Access the application**
+   - **Frontend**: http://localhost:7860
+   - **Backend API**: http://localhost:8080
+   - **API Documentation**: http://localhost:8080/docs
+
+4. **Stop the services**
+   ```bash
+   # Press Ctrl+C to stop, or in another terminal:
+   docker-compose down
+   ```
+
+### Alternative Docker Commands
+
+If you prefer using Docker directly:
+
+```bash
+# Build the image
+docker build -t lerobot-arena .
+
+# Run the container
+docker run -p 8080:8080 -p 7860:7860 lerobot-arena
+```
+
+## 🛠️ Development Setup
+
+For local development with hot-reload capabilities:
+
+### Frontend Development
+
+```bash
+# Install dependencies
+bun install
+
+# Start the development server
+bun run dev
+
+# Or open in browser automatically
+bun run dev -- --open
+```
+
+### Backend Development
+
+```bash
+# Navigate to Python backend
+cd src-python
+
+# Install Python dependencies (using uv)
+uv sync
+
+# Or using pip
+pip install -e .
+
+# Start the backend server
+python start_server.py
+```
+
+### Building Standalone Executable
+
+The backend can be packaged as a standalone executable using box-packager:
+
+```bash
+# Navigate to Python backend
+cd src-python
+
+# Install box-packager (if not already installed)
+uv pip install box-packager
+
+# Package the application
+box package
+
+# The executable will be in target/release/lerobot-arena-server
+./target/release/lerobot-arena-server
+```
+
+Note: Requires [Rust/Cargo](https://rustup.rs/) to be installed for box-packager to work.
+
+## 📋 Project Structure
+
+```
+lerobot-arena/
+├── src/                    # Svelte frontend source
+│   ├── lib/               # Reusable components and utilities
+│   ├── routes/            # SvelteKit routes
+│   └── app.html           # App template
+├── src-python/            # Python backend
+│   ├── src/               # Python source code
+│   ├── start_server.py    # Server entry point
+│   ├── target/            # Box-packager build output (excluded from git)
+│   └── pyproject.toml     # Python dependencies
+├── static/                # Static assets
+├── Dockerfile             # Docker configuration
+├── docker-compose.yml     # Docker Compose setup
+└── package.json           # Node.js dependencies
+```
+
+## 🐳 Docker Information
+
+The Docker setup includes:
+
+- **Multi-stage build**: Optimized for production using Bun and uv
+- **Automatic startup**: Both services start together
+- **Port mapping**: Backend on 8080, Frontend on 7860 (HF Spaces compatible)
+- **Static file serving**: Compiled Svelte app served efficiently
+- **User permissions**: Properly configured for Hugging Face Spaces
+- **Standalone executable**: Backend packaged with box-packager for faster startup
+
+For detailed Docker documentation, see [DOCKER_README.md](./DOCKER_README.md).
+
+## 🔧 Building for Production
+
+### Frontend Only
+```bash
+bun run build
+```
+
+### Backend Standalone Executable
+```bash
+cd src-python
+box package
+```
+
+### Complete Docker Build
+```bash
+docker-compose up --build
+```
+
+## 🌐 What's Included
+
+- **Real-time Robot Control**: WebSocket-based communication
+- **3D Visualization**: Three.js integration for robot visualization
+- **URDF Support**: Load and display robot models
+- **Multi-robot Management**: Control multiple robots simultaneously
+- **WebSocket API**: Real-time bidirectional communication
+- **Standalone Distribution**: Self-contained executable with box-packager
+
+## 🚨 Troubleshooting
+
+### Port Conflicts
+If ports 8080 or 7860 are already in use:
+
+```bash
+# Check what's using the ports
+lsof -i :8080
+lsof -i :7860
+
+# Use different ports
+docker run -p 8081:8080 -p 7861:7860 lerobot-arena
+```
+
+### Container Issues
+```bash
+# View logs
+docker-compose logs lerobot-arena
+
+# Rebuild without cache
+docker-compose build --no-cache
+docker-compose up
+```
+
+### Development Issues
+```bash
+# Clear node modules and reinstall
+rm -rf node_modules
+bun install
+
+# Clear Svelte kit cache
+rm -rf .svelte-kit
+bun run dev
+```
+
+### Box-packager Issues
+```bash
+# Clean build artifacts
+cd src-python
+box clean
+
+# Rebuild executable
+box package
+
+# Install cargo if missing
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+## 🚀 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 from the frontmatter)
+5. **Deploy** - The Space will automatically build and run
+
+The frontend will be available at your Space URL, and the backend API will be accessible at `/api/` endpoints.
+
+## 📚 Additional Documentation
+
+- [Docker Setup Guide](./DOCKER_README.md) - Detailed Docker instructions
+- [Robot Architecture](./ROBOT_ARCHITECTURE.md) - System architecture overview
+- [Robot Instancing Guide](./ROBOT_INSTANCING_README.md) - Multi-robot setup
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test with Docker: `docker-compose up --build`
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License.
+
+---
+
+**Built with ❤️ for the robotics community** 🤖

ROBOT_ARCHITECTURE.md

@@ -0,0 +1,416 @@
+# Robot Control Architecture v2.0 - Master/Slave Pattern
+
+This document describes the revolutionary new **Master-Slave Architecture** that enables sophisticated robot control with clear separation between command sources (Masters) and execution targets (Slaves).
+
+## 🏗️ Architecture Overview
+
+The new architecture follows a **Master-Slave Pattern** with complete separation of concerns:
+
+```
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│   UI Panel      │    │  Robot Manager   │    │    Masters      │
+│                 │◄──►│                  │◄──►│                 │
+│ • Manual Control│    │ • Master/Slave   │    │ • Remote Server │
+│ • Monitoring    │    │ • Command Router │    │ • Mock Sequence │
+│ (disabled if    │    │ • State Sync     │    │ • Script Player │
+│  master active) │    └──────────────────┘    └─────────────────┘
+└─────────────────┘             │
+                                ▼
+                       ┌──────────────────┐    ┌─────────────────┐
+                       │   Robot Model    │◄──►│     Slaves      │
+                       │                  │    │                 │
+                       │ • URDF State     │    │ • USB Robots    │
+                       │ • Joint States   │    │ • Mock Hardware │
+                       │ • Command Queue  │    │ • Simulations   │
+                       └──────────────────┘    └─────────────────┘
+```
+
+## 🎯 Key Concepts
+
+### Masters (Command Sources)
+- **Purpose**: Generate commands and control sequences
+- **Examples**: Remote servers, predefined sequences, scripts
+- **Limitation**: Only 1 master per robot (exclusive control)
+- **Effect**: When active, disables manual panel control
+
+### Slaves (Execution Targets)  
+- **Purpose**: Execute commands on physical/virtual robots
+- **Examples**: USB robots, mock robots, simulations
+- **Limitation**: Multiple slaves per robot (parallel execution)
+- **Effect**: All connected slaves execute the same commands
+
+### Control Flow
+1. **No Master**: Manual panel control → All slaves
+2. **With Master**: Master commands → All slaves (panel disabled)
+3. **Bidirectional**: Slaves provide real-time feedback
+
+## 📁 File Structure
+
+```
+src/lib/
+├── robot/
+│   ├── Robot.svelte.ts              # Master-slave robot management
+│   ├── RobotManager.svelte.ts       # Global orchestration
+│   └── drivers/
+│       ├── masters/
+│       │   ├── MockSequenceMaster.ts    # Demo sequences
+│       │   ├── RemoteServerMaster.ts    # HTTP/WebSocket commands
+│       │   └── ScriptPlayerMaster.ts    # Script execution
+│       └── slaves/
+│           ├── MockSlave.ts             # Development/testing
+│           ├── USBSlave.ts              # Physical USB robots
+│           └── SimulationSlave.ts       # Physics simulation
+├── types/
+│   └── robotDriver.ts               # Master/Slave interfaces
+└── components/
+    ├── scene/
+    │   └── Robot.svelte             # 3D visualization
+    └── panel/
+        └── RobotControlPanel.svelte # Master/Slave connection UI
+```
+
+## 🔧 Core Components
+
+### RobotManager
+**Central orchestrator with master-slave management**
+
+```typescript
+import { robotManager } from '$lib/robot/RobotManager.svelte';
+
+// Create robot
+const robot = await robotManager.createRobot('my-robot', urdfConfig);
+
+// Connect demo sequence master (disables manual control)
+await robotManager.connectDemoSequences('my-robot', true);
+
+// Connect mock slave (executes commands)  
+await robotManager.connectMockSlave('my-robot', 50);
+
+// Connect USB slave (real hardware)
+await robotManager.connectUSBSlave('my-robot');
+
+// Disconnect master (restores manual control)
+await robotManager.disconnectMaster('my-robot');
+```
+
+### Robot Class
+**Individual robot with master-slave coordination**
+
+```typescript
+// Master management
+await robot.setMaster(sequenceMaster);
+await robot.removeMaster();
+
+// Slave management
+await robot.addSlave(usbSlave);
+await robot.addSlave(mockSlave);
+await robot.removeSlave(slaveId);
+
+// Control state
+robot.controlState.hasActiveMaster    // true when master connected
+robot.controlState.manualControlEnabled  // false when master active
+robot.controlState.lastCommandSource     // "master" | "manual" | "none"
+
+// Manual control (only when no master)
+await robot.updateJointValue('joint_1', 45);
+```
+
+## 🔌 Master Drivers
+
+### Mock Sequence Master
+**Predefined movement sequences for testing**
+
+```typescript
+const config: MasterDriverConfig = {
+  type: "mock-sequence",
+  sequences: DEMO_SEQUENCES,  // Wave, Scan, Pick-Place patterns
+  autoStart: true,
+  loopMode: true
+};
+
+await robotManager.connectMaster('robot-1', config);
+```
+
+**Demo Sequences:**
+- **Wave Pattern**: Greeting gesture with wrist roll
+- **Scanning Pattern**: Horizontal sweep with pitch variation  
+- **Pick and Place**: Complete manipulation sequence
+
+### Remote Server Master *(Planned)*
+**HTTP/WebSocket command reception**
+
+```typescript
+const config: MasterDriverConfig = {
+  type: "remote-server",
+  url: "ws://robot-server:8080/ws",
+  apiKey: "your-api-key",
+  pollInterval: 100
+};
+```
+
+### Script Player Master *(Planned)*
+**JavaScript/Python script execution**
+
+```typescript
+const config: MasterDriverConfig = {
+  type: "script-player", 
+  scriptUrl: "/scripts/robot-dance.js",
+  variables: { speed: 1.5, amplitude: 45 }
+};
+```
+
+## 🤖 Slave Drivers
+
+### Mock Slave
+**Perfect simulation for development**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "mock-slave",
+  simulateLatency: 50,      // ms response delay
+  simulateErrors: false,    // random failures
+  responseDelay: 20         // command execution time
+};
+
+await robotManager.connectSlave('robot-1', config);
+```
+
+**Features:**
+- ✅ Perfect command execution (real = virtual)
+- ✅ Configurable latency and errors
+- ✅ Real-time state feedback
+- ✅ Instant connection
+
+### USB Slave *(Planned)*
+**Physical robot via feetech.js**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "usb-slave",
+  port: "/dev/ttyUSB0",     // auto-detect if undefined
+  baudRate: 115200
+};
+```
+
+**Features:**
+- ✅ Direct hardware control
+- ✅ Position/speed commands
+- ✅ Real servo feedback  
+- ✅ Calibration support
+
+### Simulation Slave *(Planned)*
+**Physics-based simulation**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "simulation-slave",
+  physics: true,
+  collisionDetection: true
+};
+```
+
+## 🔄 Command Flow Architecture
+
+### Command Structure
+```typescript
+interface RobotCommand {
+  timestamp: number;
+  joints: {
+    name: string;
+    value: number;      // degrees for revolute, speed for continuous
+    speed?: number;     // optional movement speed
+  }[];
+  duration?: number;    // optional execution time
+  metadata?: Record<string, unknown>;
+}
+```
+
+### Command Sources
+
+#### Master Commands
+```typescript
+// Continuous sequence from master
+master.onCommand((commands) => {
+  // Route to all connected slaves
+  robot.slaves.forEach(slave => slave.executeCommands(commands));
+});
+```
+
+#### Manual Commands  
+```typescript
+// Only when no master active
+if (robot.manualControlEnabled) {
+  await robot.updateJointValue('shoulder', 45);
+}
+```
+
+### Command Execution
+```typescript
+// All slaves execute in parallel
+const executePromises = robot.connectedSlaves.map(slave => 
+  slave.executeCommand(command)
+);
+await Promise.allSettled(executePromises);
+```
+
+## 🎮 Usage Examples
+
+### Basic Master-Slave Setup
+```typescript
+// 1. Create robot
+const robot = await robotManager.createRobot('arm-1', urdfConfig);
+
+// 2. Add slaves for execution
+await robotManager.connectMockSlave('arm-1');      // Development
+await robotManager.connectUSBSlave('arm-1');       // Real hardware
+
+// 3. Connect master for control
+await robotManager.connectDemoSequences('arm-1');  // Automated sequences
+
+// 4. Monitor status
+const status = robotManager.getRobotStatus('arm-1');
+console.log(`Master: ${status.masterName}, Slaves: ${status.connectedSlaves}`);
+```
+
+### Multiple Robots with Different Masters
+```typescript
+// Robot 1: Demo sequences
+await robotManager.createRobot('demo-1', armConfig);
+await robotManager.connectDemoSequences('demo-1', true);
+await robotManager.connectMockSlave('demo-1');
+
+// Robot 2: Remote control
+await robotManager.createRobot('remote-1', armConfig);
+await robotManager.connectMaster('remote-1', remoteServerConfig);
+await robotManager.connectUSBSlave('remote-1');
+
+// Robot 3: Manual control only
+await robotManager.createRobot('manual-1', armConfig);
+await robotManager.connectMockSlave('manual-1');
+// No master = manual control enabled
+```
+
+### Master Switching
+```typescript
+// Switch from manual to automated control
+await robotManager.connectDemoSequences('robot-1');
+// Panel inputs now disabled, sequences control robot
+
+// Switch back to manual control  
+await robotManager.disconnectMaster('robot-1');
+// Panel inputs re-enabled, manual control restored
+```
+
+## 🚀 Benefits
+
+### 1. **Clear Control Hierarchy**
+- Masters provide commands exclusively
+- Slaves execute commands in parallel
+- No ambiguity about command source
+
+### 2. **Flexible Command Sources**
+- Remote servers for network control
+- Predefined sequences for automation
+- Manual control for testing/setup
+- Easy to add new master types
+
+### 3. **Multiple Execution Targets**
+- Physical robots via USB
+- Simulated robots for testing
+- Mock robots for development
+- All execute same commands simultaneously
+
+### 4. **Automatic Panel Management**
+- Panel disabled when master active
+- Panel re-enabled when master disconnected
+- Clear visual feedback about control state
+
+### 5. **Safe Operation**
+- Masters cannot conflict (only 1 allowed)
+- Graceful disconnection with rest positioning
+- Error isolation between slaves
+
+### 6. **Development Workflow**
+- Test with mock slaves during development
+- Add real slaves for deployment
+- Switch masters for different scenarios
+
+## 🔮 Implementation Roadmap
+
+### Phase 1: Core Architecture ✅
+- [x] Master-Slave interfaces
+- [x] Robot class with dual management
+- [x] RobotManager orchestration
+- [x] MockSequenceMaster with demo patterns
+- [x] MockSlave for testing
+
+### Phase 2: Real Hardware
+- [ ] USBSlave implementation (feetech.js integration)
+- [ ] Calibration system for hardware slaves
+- [ ] Error handling and recovery
+
+### Phase 3: Remote Control
+- [ ] RemoteServerMaster (HTTP/WebSocket)
+- [ ] Authentication and security
+- [ ] Real-time command streaming
+
+### Phase 4: Advanced Features
+- [ ] ScriptPlayerMaster (JS/Python execution)
+- [ ] SimulationSlave (physics integration)
+- [ ] Command recording and playback
+- [ ] Multi-robot coordination
+
+## 🛡️ Safety Features
+
+### Master Safety
+- Only 1 master per robot prevents conflicts
+- Master disconnect automatically restores manual control
+- Command validation before execution
+
+### Slave Safety  
+- Rest positioning before disconnect
+- Smooth movement transitions
+- Individual slave error isolation
+- Calibration offset compensation
+
+### System Safety
+- Graceful degradation on slave failures
+- Command queuing prevents overwhelming
+- Real-time state monitoring
+- Emergency stop capabilities *(planned)*
+
+## 🔧 Migration from v1.0
+
+The new architecture is **completely different** from the old driver pattern:
+
+### Old Architecture (v1.0)
+```typescript
+// Single driver per robot
+const driver = new USBRobotDriver(config);
+await robot.setDriver(driver);
+await robot.updateJointValue('joint', 45);
+```
+
+### New Architecture (v2.0)
+```typescript
+// Separate masters and slaves
+await robotManager.connectMaster(robotId, masterConfig);   // Command source
+await robotManager.connectSlave(robotId, slaveConfig);     // Execution target
+
+// Manual control only when no master
+if (robot.manualControlEnabled) {
+  await robot.updateJointValue('joint', 45);
+}
+```
+
+### Key Changes
+1. **Drivers → Masters + Slaves**: Split command/execution concerns
+2. **Single Connection → Multiple**: 1 master + N slaves per robot  
+3. **Always Manual → Conditional**: Panel disabled when master active
+4. **Direct Control → Command Routing**: Masters route to all slaves
+
+The new architecture provides **dramatically more flexibility** while maintaining complete backward compatibility for URDF visualization and joint control.
+
+---
+
+*This architecture enables sophisticated robot control scenarios from simple manual operation to complex multi-robot coordination, all with a clean, extensible design.* 

ROBOT_INSTANCING_README.md

@@ -0,0 +1,73 @@
+# Robot Instancing Optimization
+
+This implementation optimizes the rendering of multiple robots using Threlte's instancing capabilities for improved performance.
+
+## Key Features
+
+### 1. **Smart Instancing by Robot Type**
+- Robots are grouped by their URDF type (URL) for optimal instancing
+- Single robots render with full detail
+- Multiple robots of the same type use instanced rendering
+
+### 2. **Geometry-Specific Instancing**
+- **Box Geometries**: Instanced with `T.boxGeometry`
+- **Cylinder Geometries**: Instanced with `T.cylinderGeometry`  
+- **Mesh Geometries**: Instanced with simplified `T.sphereGeometry` for performance
+
+### 3. **Hybrid Rendering Strategy**
+- First robot of each type: Full detailed rendering with all URDF components
+- Additional robots: Simplified instanced representation
+- Maintains visual quality while optimizing performance
+
+### 4. **Performance Benefits**
+- Reduces draw calls when rendering multiple robots
+- Optimizes GPU memory usage through instancing
+- Scales better with increasing robot count
+- Maintains interactivity for detailed robots
+
+## Implementation Details
+
+### State Management
+```typescript
+// Robots grouped by URDF type for optimal batching
+let robotsByType: Record<string, Array<{ 
+  id: string; 
+  position: [number, number, number]; 
+  robotState: RobotState 
+}>> = $state({});
+```
+
+### Instancing Logic
+1. **Single Robot**: Full `UrdfLink` rendering with all details
+2. **Multiple Robots**: 
+   - Geometry analysis and grouping
+   - Instanced rendering for primitive shapes
+   - Simplified representations for complex meshes
+
+### Automatic Demonstration
+- Spawns additional robots after 2 seconds to showcase instancing
+- Shows performance difference between single and multiple robot rendering
+
+## Usage
+
+Simply use the `Robot.svelte` component with a `urdfConfig`. The component automatically:
+- Detects when multiple robots of the same type exist
+- Switches to instanced rendering for optimal performance
+- Maintains full detail for single robots
+
+```svelte
+<Robot {urdfConfig} />
+```
+
+## Performance Impact
+
+- **Before**: O(n) draw calls for n robots
+- **After**: O(1) draw calls per geometry type regardless of robot count
+- **Memory**: Shared geometry instances reduce GPU memory usage
+- **Scalability**: Linear performance improvement with robot count
+
+This optimization is particularly beneficial for:
+- Robot swarms
+- Multi-robot simulations  
+- Arena scenarios with many similar robots
+- Performance-critical real-time applications 

bun.lock

@@ -0,0 +1,652 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "my-app",
+      "dependencies": {
+        "@threlte/core": "^8.0.4",
+        "@threlte/extras": "^9.2.1",
+        "@types/three": "^0.176.0",
+        "clsx": "^2.1.1",
+        "tailwind-merge": "^3.3.0",
+        "three": "^0.177.0",
+        "zod": "^3.25.42",
+      },
+      "devDependencies": {
+        "@eslint/compat": "^1.2.5",
+        "@eslint/js": "^9.18.0",
+        "@sveltejs/adapter-auto": "^6.0.0",
+        "@sveltejs/adapter-static": "^3.0.8",
+        "@sveltejs/kit": "^2.16.0",
+        "@sveltejs/vite-plugin-svelte": "^5.0.0",
+        "@tailwindcss/vite": "^4.0.0",
+        "eslint": "^9.18.0",
+        "eslint-config-prettier": "^10.0.1",
+        "eslint-plugin-svelte": "^3.0.0",
+        "globals": "^16.0.0",
+        "prettier": "^3.4.2",
+        "prettier-plugin-svelte": "^3.3.3",
+        "prettier-plugin-tailwindcss": "^0.6.11",
+        "svelte": "^5.0.0",
+        "svelte-check": "^4.0.0",
+        "tailwindcss": "^4.0.0",
+        "typescript": "^5.0.0",
+        "typescript-eslint": "^8.20.0",
+        "vite": "^6.2.6",
+      },
+    },
+  },
+  "packages": {
+    "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="],
+
+    "@dimforge/rapier3d-compat": ["@dimforge/rapier3d-compat@0.12.0", "", {}, "sha512-uekIGetywIgopfD97oDL5PfeezkFpNhwlzlaEYNOA0N6ghdsOvh/HYjSMek5Q2O1PYvRSDFcqFVJl4r4ZBwOow=="],
+
+    "@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=="],
+
+    "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.7.0", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw=="],
+
+    "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.1", "", {}, "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ=="],
+
+    "@eslint/compat": ["@eslint/compat@1.2.9", "", { "peerDependencies": { "eslint": "^9.10.0" }, "optionalPeers": ["eslint"] }, "sha512-gCdSY54n7k+driCadyMNv8JSPzYLeDVM/ikZRtvtROBpRdFSkS8W9A82MqsaY7lZuwL0wiapgD0NT1xT0hyJsA=="],
+
+    "@eslint/config-array": ["@eslint/config-array@0.20.0", "", { "dependencies": { "@eslint/object-schema": "^2.1.6", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ=="],
+
+    "@eslint/config-helpers": ["@eslint/config-helpers@0.2.2", "", {}, "sha512-+GPzk8PlG0sPpzdU5ZvIRMPidzAnZDl/s9L+y13iodqvb8leL53bTannOrQ/Im7UkpsmFU5Ily5U60LWixnmLg=="],
+
+    "@eslint/core": ["@eslint/core@0.14.0", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg=="],
+
+    "@eslint/eslintrc": ["@eslint/eslintrc@3.3.1", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ=="],
+
+    "@eslint/js": ["@eslint/js@9.28.0", "", {}, "sha512-fnqSjGWd/CoIp4EXIxWVK/sHA6DOHN4+8Ix2cX5ycOY7LG0UY8nHCU5pIp2eaE1Mc7Qd8kHspYNzYXT2ojPLzg=="],
+
+    "@eslint/object-schema": ["@eslint/object-schema@2.1.6", "", {}, "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA=="],
+
+    "@eslint/plugin-kit": ["@eslint/plugin-kit@0.3.1", "", { "dependencies": { "@eslint/core": "^0.14.0", "levn": "^0.4.1" } }, "sha512-0J+zgWxHN+xXONWIyPWKFMgVuJoZuGiIFu8yxk7RJjxkzpGmyja5wRFqZIVtjDVOQpV+Rw0iOAjYPE2eQyjr0w=="],
+
+    "@humanfs/core": ["@humanfs/core@0.19.1", "", {}, "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA=="],
+
+    "@humanfs/node": ["@humanfs/node@0.16.6", "", { "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.3.0" } }, "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw=="],
+
+    "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="],
+
+    "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="],
+
+    "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
+
+    "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.8", "", { "dependencies": { "@jridgewell/set-array": "^1.2.1", "@jridgewell/sourcemap-codec": "^1.4.10", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA=="],
+
+    "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="],
+
+    "@jridgewell/set-array": ["@jridgewell/set-array@1.2.1", "", {}, "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A=="],
+
+    "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.0", "", {}, "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="],
+
+    "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.25", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ=="],
+
+    "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
+
+    "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="],
+
+    "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="],
+
+    "@polka/url": ["@polka/url@1.0.0-next.29", "", {}, "sha512-wwQAWhWSuHaag8c4q/KN/vCoeOJYshAIvMQwD4GpSb3OiZklFfvAgmj0VCBBImRpuF/aFgIRzllXlVX93Jevww=="],
+
+    "@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=="],
+
+    "@sveltejs/acorn-typescript": ["@sveltejs/acorn-typescript@1.0.5", "", { "peerDependencies": { "acorn": "^8.9.0" } }, "sha512-IwQk4yfwLdibDlrXVE04jTZYlLnwsTT2PIOQQGNLWfjavGifnk1JD1LcZjZaBTRcxZu2FfPfNLOE04DSu9lqtQ=="],
+
+    "@sveltejs/adapter-auto": ["@sveltejs/adapter-auto@6.0.1", "", { "peerDependencies": { "@sveltejs/kit": "^2.0.0" } }, "sha512-mcWud3pYGPWM2Pphdj8G9Qiq24nZ8L4LB7coCUckUEy5Y7wOWGJ/enaZ4AtJTcSm5dNK1rIkBRoqt+ae4zlxcQ=="],
+
+    "@sveltejs/adapter-static": ["@sveltejs/adapter-static@3.0.8", "", { "peerDependencies": { "@sveltejs/kit": "^2.0.0" } }, "sha512-YaDrquRpZwfcXbnlDsSrBQNCChVOT9MGuSg+dMAyfsAa1SmiAhrA5jUYUiIMC59G92kIbY/AaQOWcBdq+lh+zg=="],
+
+    "@sveltejs/kit": ["@sveltejs/kit@2.21.1", "", { "dependencies": { "@sveltejs/acorn-typescript": "^1.0.5", "@types/cookie": "^0.6.0", "acorn": "^8.14.1", "cookie": "^0.6.0", "devalue": "^5.1.0", "esm-env": "^1.2.2", "kleur": "^4.1.5", "magic-string": "^0.30.5", "mrmime": "^2.0.0", "sade": "^1.8.1", "set-cookie-parser": "^2.6.0", "sirv": "^3.0.0" }, "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^3.0.0 || ^4.0.0-next.1 || ^5.0.0", "svelte": "^4.0.0 || ^5.0.0-next.0", "vite": "^5.0.3 || ^6.0.0" }, "bin": { "svelte-kit": "svelte-kit.js" } }, "sha512-vLbtVwtDcK8LhJKnFkFYwM0uCdFmzioQnif0bjEYH1I24Arz22JPr/hLUiXGVYAwhu8INKx5qrdvr4tHgPwX6w=="],
+
+    "@sveltejs/vite-plugin-svelte": ["@sveltejs/vite-plugin-svelte@5.0.3", "", { "dependencies": { "@sveltejs/vite-plugin-svelte-inspector": "^4.0.1", "debug": "^4.4.0", "deepmerge": "^4.3.1", "kleur": "^4.1.5", "magic-string": "^0.30.15", "vitefu": "^1.0.4" }, "peerDependencies": { "svelte": "^5.0.0", "vite": "^6.0.0" } }, "sha512-MCFS6CrQDu1yGwspm4qtli0e63vaPCehf6V7pIMP15AsWgMKrqDGCPFF/0kn4SP0ii4aySu4Pa62+fIRGFMjgw=="],
+
+    "@sveltejs/vite-plugin-svelte-inspector": ["@sveltejs/vite-plugin-svelte-inspector@4.0.1", "", { "dependencies": { "debug": "^4.3.7" }, "peerDependencies": { "@sveltejs/vite-plugin-svelte": "^5.0.0", "svelte": "^5.0.0", "vite": "^6.0.0" } }, "sha512-J/Nmb2Q2y7mck2hyCX4ckVHcR5tu2J+MtBEQqpDrrgELZ2uvraQcK/ioCV61AqkdXFgriksOKIceDcQmqnGhVw=="],
+
+    "@tailwindcss/node": ["@tailwindcss/node@4.1.8", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "enhanced-resolve": "^5.18.1", "jiti": "^2.4.2", "lightningcss": "1.30.1", "magic-string": "^0.30.17", "source-map-js": "^1.2.1", "tailwindcss": "4.1.8" } }, "sha512-OWwBsbC9BFAJelmnNcrKuf+bka2ZxCE2A4Ft53Tkg4uoiE67r/PMEYwCsourC26E+kmxfwE0hVzMdxqeW+xu7Q=="],
+
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.1.8", "", { "dependencies": { "detect-libc": "^2.0.4", "tar": "^7.4.3" }, "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.1.8", "@tailwindcss/oxide-darwin-arm64": "4.1.8", "@tailwindcss/oxide-darwin-x64": "4.1.8", "@tailwindcss/oxide-freebsd-x64": "4.1.8", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.8", "@tailwindcss/oxide-linux-arm64-gnu": "4.1.8", "@tailwindcss/oxide-linux-arm64-musl": "4.1.8", "@tailwindcss/oxide-linux-x64-gnu": "4.1.8", "@tailwindcss/oxide-linux-x64-musl": "4.1.8", "@tailwindcss/oxide-wasm32-wasi": "4.1.8", "@tailwindcss/oxide-win32-arm64-msvc": "4.1.8", "@tailwindcss/oxide-win32-x64-msvc": "4.1.8" } }, "sha512-d7qvv9PsM5N3VNKhwVUhpK6r4h9wtLkJ6lz9ZY9aeZgrUWk1Z8VPyqyDT9MZlem7GTGseRQHkeB1j3tC7W1P+A=="],
+
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.1.8", "", { "os": "android", "cpu": "arm64" }, "sha512-Fbz7qni62uKYceWYvUjRqhGfZKwhZDQhlrJKGtnZfuNtHFqa8wmr+Wn74CTWERiW2hn3mN5gTpOoxWKk0jRxjg=="],
+
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.1.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RdRvedGsT0vwVVDztvyXhKpsU2ark/BjgG0huo4+2BluxdXo8NDgzl77qh0T1nUxmM11eXwR8jA39ibvSTbi7A=="],
+
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.1.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-t6PgxjEMLp5Ovf7uMb2OFmb3kqzVTPPakWpBIFzppk4JE4ix0yEtbtSjPbU8+PZETpaYMtXvss2Sdkx8Vs4XRw=="],
+
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.1.8", "", { "os": "freebsd", "cpu": "x64" }, "sha512-g8C8eGEyhHTqwPStSwZNSrOlyx0bhK/V/+zX0Y+n7DoRUzyS8eMbVshVOLJTDDC+Qn9IJnilYbIKzpB9n4aBsg=="],
+
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.1.8", "", { "os": "linux", "cpu": "arm" }, "sha512-Jmzr3FA4S2tHhaC6yCjac3rGf7hG9R6Gf2z9i9JFcuyy0u79HfQsh/thifbYTF2ic82KJovKKkIB6Z9TdNhCXQ=="],
+
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-qq7jXtO1+UEtCmCeBBIRDrPFIVI4ilEQ97qgBGdwXAARrUqSn/L9fUrkb1XP/mvVtoVeR2bt/0L77xx53bPZ/Q=="],
+
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-O6b8QesPbJCRshsNApsOIpzKt3ztG35gfX9tEf4arD7mwNinsoCKxkj8TgEE0YRjmjtO3r9FlJnT/ENd9EVefQ=="],
+
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-32iEXX/pXwikshNOGnERAFwFSfiltmijMIAbUhnNyjFr3tmWmMJWQKU2vNcFX0DACSXJ3ZWcSkzNbaKTdngH6g=="],
+
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-s+VSSD+TfZeMEsCaFaHTaY5YNj3Dri8rST09gMvYQKwPphacRG7wbuQ5ZJMIJXN/puxPcg/nU+ucvWguPpvBDg=="],
+
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.1.8", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@emnapi/wasi-threads": "^1.0.2", "@napi-rs/wasm-runtime": "^0.2.10", "@tybys/wasm-util": "^0.9.0", "tslib": "^2.8.0" }, "cpu": "none" }, "sha512-CXBPVFkpDjM67sS1psWohZ6g/2/cd+cq56vPxK4JeawelxwK4YECgl9Y9TjkE2qfF+9/s1tHHJqrC4SS6cVvSg=="],
+
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.1.8", "", { "os": "win32", "cpu": "arm64" }, "sha512-7GmYk1n28teDHUjPlIx4Z6Z4hHEgvP5ZW2QS9ygnDAdI/myh3HTHjDqtSqgu1BpRoI4OiLx+fThAyA1JePoENA=="],
+
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.1.8", "", { "os": "win32", "cpu": "x64" }, "sha512-fou+U20j+Jl0EHwK92spoWISON2OBnCazIc038Xj2TdweYV33ZRkS9nwqiUi2d/Wba5xg5UoHfvynnb/UB49cQ=="],
+
+    "@tailwindcss/vite": ["@tailwindcss/vite@4.1.8", "", { "dependencies": { "@tailwindcss/node": "4.1.8", "@tailwindcss/oxide": "4.1.8", "tailwindcss": "4.1.8" }, "peerDependencies": { "vite": "^5.2.0 || ^6" } }, "sha512-CQ+I8yxNV5/6uGaJjiuymgw0kEQiNKRinYbZXPdx1fk5WgiyReG0VaUx/Xq6aVNSUNJFzxm6o8FNKS5aMaim5A=="],
+
+    "@threejs-kit/instanced-sprite-mesh": ["@threejs-kit/instanced-sprite-mesh@2.5.1", "", { "dependencies": { "diet-sprite": "^0.0.1", "earcut": "^2.2.4", "maath": "^0.10.7", "three-instanced-uniforms-mesh": "^0.52.4", "troika-three-utils": "^0.52.4" }, "peerDependencies": { "three": ">=0.170.0" } }, "sha512-pmt1ALRhbHhCJQTj2FuthH6PeLIeaM4hOuS2JO3kWSwlnvx/9xuUkjFR3JOi/myMqsH7pSsLIROSaBxDfttjeA=="],
+
+    "@threlte/core": ["@threlte/core@8.0.4", "", { "dependencies": { "mitt": "^3.0.1" }, "peerDependencies": { "svelte": ">=5", "three": ">=0.155" } }, "sha512-kg0nTq00RqgTExIEKkyO/yCupCt73lybuFZObKHCRaY7dPcCvRD4tHkyKIFeYLYV4R6u1nqIuzfgDzYJqHbLlQ=="],
+
+    "@threlte/extras": ["@threlte/extras@9.2.1", "", { "dependencies": { "@threejs-kit/instanced-sprite-mesh": "^2.5.1", "camera-controls": "^2.10.1", "three-mesh-bvh": "^0.9.0", "three-perf": "github:jerzakm/three-perf#three-kit-threlte-fork", "three-viewport-gizmo": "^2.2.0", "troika-three-text": "^0.52.4" }, "peerDependencies": { "svelte": ">=5", "three": ">=0.155" } }, "sha512-FzHGZadxtOIlD2ZAaH6m/vAiBVJWl/MWrW7O3DMl42ixYrGBR3FQwUbdxdHQR0akVqPESm6bwvwvRZlWqiOhAQ=="],
+
+    "@tweenjs/tween.js": ["@tweenjs/tween.js@23.1.3", "", {}, "sha512-vJmvvwFxYuGnF2axRtPYocag6Clbb5YS7kLL+SO/TeVFzHqDIWrNKYtcsPMibjDx9O+bu+psAy9NKfWklassUA=="],
+
+    "@types/cookie": ["@types/cookie@0.6.0", "", {}, "sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA=="],
+
+    "@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/stats.js": ["@types/stats.js@0.17.4", "", {}, "sha512-jIBvWWShCvlBqBNIZt0KAshWpvSjhkwkEu4ZUcASoAvhmrgAUI2t1dXrjSL4xXVLB4FznPrIsX3nKXFl/Dt4vA=="],
+
+    "@types/three": ["@types/three@0.176.0", "", { "dependencies": { "@dimforge/rapier3d-compat": "^0.12.0", "@tweenjs/tween.js": "~23.1.3", "@types/stats.js": "*", "@types/webxr": "*", "@webgpu/types": "*", "fflate": "~0.8.2", "meshoptimizer": "~0.18.1" } }, "sha512-FwfPXxCqOtP7EdYMagCFePNKoG1AGBDUEVKtluv2BTVRpSt7b+X27xNsirPCTCqY1pGYsPUzaM3jgWP7dXSxlw=="],
+
+    "@types/webxr": ["@types/webxr@0.5.22", "", {}, "sha512-Vr6Stjv5jPRqH690f5I5GLjVk8GSsoQSYJ2FVd/3jJF7KaqfwPi3ehfBS96mlQ2kPCwZaX6U0rG2+NGHBKkA/A=="],
+
+    "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@8.33.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.10.0", "@typescript-eslint/scope-manager": "8.33.0", "@typescript-eslint/type-utils": "8.33.0", "@typescript-eslint/utils": "8.33.0", "@typescript-eslint/visitor-keys": "8.33.0", "graphemer": "^1.4.0", "ignore": "^7.0.0", "natural-compare": "^1.4.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "@typescript-eslint/parser": "^8.33.0", "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <5.9.0" } }, "sha512-CACyQuqSHt7ma3Ns601xykeBK/rDeZa3w6IS6UtMQbixO5DWy+8TilKkviGDH6jtWCo8FGRKEK5cLLkPvEammQ=="],
+
+    "@typescript-eslint/parser": ["@typescript-eslint/parser@8.33.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "8.33.0", "@typescript-eslint/types": "8.33.0", "@typescript-eslint/typescript-estree": "8.33.0", "@typescript-eslint/visitor-keys": "8.33.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <5.9.0" } }, "sha512-JaehZvf6m0yqYp34+RVnihBAChkqeH+tqqhS0GuX1qgPpwLvmTPheKEs6OeCK6hVJgXZHJ2vbjnC9j119auStQ=="],
+
+    "@typescript-eslint/project-service": ["@typescript-eslint/project-service@8.33.0", "", { "dependencies": { "@typescript-eslint/tsconfig-utils": "^8.33.0", "@typescript-eslint/types": "^8.33.0", "debug": "^4.3.4" } }, "sha512-d1hz0u9l6N+u/gcrk6s6gYdl7/+pp8yHheRTqP6X5hVDKALEaTn8WfGiit7G511yueBEL3OpOEpD+3/MBdoN+A=="],
+
+    "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@8.33.0", "", { "dependencies": { "@typescript-eslint/types": "8.33.0", "@typescript-eslint/visitor-keys": "8.33.0" } }, "sha512-LMi/oqrzpqxyO72ltP+dBSP6V0xiUb4saY7WLtxSfiNEBI8m321LLVFU9/QDJxjDQG9/tjSqKz/E3380TEqSTw=="],
+
+    "@typescript-eslint/tsconfig-utils": ["@typescript-eslint/tsconfig-utils@8.33.0", "", { "peerDependencies": { "typescript": ">=4.8.4 <5.9.0" } }, "sha512-sTkETlbqhEoiFmGr1gsdq5HyVbSOF0145SYDJ/EQmXHtKViCaGvnyLqWFFHtEXoS0J1yU8Wyou2UGmgW88fEug=="],
+
+    "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@8.33.0", "", { "dependencies": { "@typescript-eslint/typescript-estree": "8.33.0", "@typescript-eslint/utils": "8.33.0", "debug": "^4.3.4", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <5.9.0" } }, "sha512-lScnHNCBqL1QayuSrWeqAL5GmqNdVUQAAMTaCwdYEdWfIrSrOGzyLGRCHXcCixa5NK6i5l0AfSO2oBSjCjf4XQ=="],
+
+    "@typescript-eslint/types": ["@typescript-eslint/types@8.33.0", "", {}, "sha512-DKuXOKpM5IDT1FA2g9x9x1Ug81YuKrzf4mYX8FAVSNu5Wo/LELHWQyM1pQaDkI42bX15PWl0vNPt1uGiIFUOpg=="],
+
+    "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@8.33.0", "", { "dependencies": { "@typescript-eslint/project-service": "8.33.0", "@typescript-eslint/tsconfig-utils": "8.33.0", "@typescript-eslint/types": "8.33.0", "@typescript-eslint/visitor-keys": "8.33.0", "debug": "^4.3.4", "fast-glob": "^3.3.2", "is-glob": "^4.0.3", "minimatch": "^9.0.4", "semver": "^7.6.0", "ts-api-utils": "^2.1.0" }, "peerDependencies": { "typescript": ">=4.8.4 <5.9.0" } }, "sha512-vegY4FQoB6jL97Tu/lWRsAiUUp8qJTqzAmENH2k59SJhw0Th1oszb9Idq/FyyONLuNqT1OADJPXfyUNOR8SzAQ=="],
+
+    "@typescript-eslint/utils": ["@typescript-eslint/utils@8.33.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.7.0", "@typescript-eslint/scope-manager": "8.33.0", "@typescript-eslint/types": "8.33.0", "@typescript-eslint/typescript-estree": "8.33.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <5.9.0" } }, "sha512-lPFuQaLA9aSNa7D5u2EpRiqdAUhzShwGg/nhpBlc4GR6kcTABttCuyjFs8BcEZ8VWrjCBof/bePhP3Q3fS+Yrw=="],
+
+    "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.33.0", "", { "dependencies": { "@typescript-eslint/types": "8.33.0", "eslint-visitor-keys": "^4.2.0" } }, "sha512-7RW7CMYoskiz5OOGAWjJFxgb7c5UNjTG292gYhWeOAcFmYCtVCSqjqSBj5zMhxbXo2JOW95YYrUWJfU0zrpaGQ=="],
+
+    "@webgpu/types": ["@webgpu/types@0.1.61", "", {}, "sha512-w2HbBvH+qO19SB5pJOJFKs533CdZqxl3fcGonqL321VHkW7W/iBo6H8bjDy6pr/+pbMwIu5dnuaAxH7NxBqUrQ=="],
+
+    "acorn": ["acorn@8.14.1", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg=="],
+
+    "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="],
+
+    "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
+
+    "aria-query": ["aria-query@5.3.2", "", {}, "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw=="],
+
+    "axobject-query": ["axobject-query@4.1.0", "", {}, "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ=="],
+
+    "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
+
+    "bidi-js": ["bidi-js@1.0.3", "", { "dependencies": { "require-from-string": "^2.0.2" } }, "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw=="],
+
+    "brace-expansion": ["brace-expansion@1.1.11", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA=="],
+
+    "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
+
+    "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="],
+
+    "camera-controls": ["camera-controls@2.10.1", "", { "peerDependencies": { "three": ">=0.126.1" } }, "sha512-KnaKdcvkBJ1Irbrzl8XD6WtZltkRjp869Jx8c0ujs9K+9WD+1D7ryBsCiVqJYUqt6i/HR5FxT7RLASieUD+Q5w=="],
+
+    "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
+
+    "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="],
+
+    "clsx": ["clsx@2.1.1", "", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="],
+
+    "cookie": ["cookie@0.6.0", "", {}, "sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw=="],
+
+    "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
+
+    "cssesc": ["cssesc@3.0.0", "", { "bin": { "cssesc": "bin/cssesc" } }, "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="],
+
+    "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
+
+    "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
+
+    "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
+
+    "detect-libc": ["detect-libc@2.0.4", "", {}, "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA=="],
+
+    "devalue": ["devalue@5.1.1", "", {}, "sha512-maua5KUiapvEwiEAe+XnlZ3Rh0GD+qI1J/nb9vrJc3muPXvcF/8gXYTWF76+5DAqHyDUtOIImEuo0YKE9mshVw=="],
+
+    "diet-sprite": ["diet-sprite@0.0.1", "", {}, "sha512-zSHI2WDAn1wJqJYxcmjWfJv3Iw8oL9reQIbEyx2x2/EZ4/qmUTIo8/5qOCurnAcq61EwtJJaZ0XTy2NRYqpB5A=="],
+
+    "earcut": ["earcut@2.2.4", "", {}, "sha512-/pjZsA1b4RPHbeWZQn66SWS8nZZWLQQ23oE3Eam7aroEFGEvwKAsJfZ9ytiEMycfzXWpca4FA9QIOehf7PocBQ=="],
+
+    "enhanced-resolve": ["enhanced-resolve@5.18.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" } }, "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg=="],
+
+    "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=="],
+
+    "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="],
+
+    "eslint": ["eslint@9.28.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.20.0", "@eslint/config-helpers": "^0.2.1", "@eslint/core": "^0.14.0", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.28.0", "@eslint/plugin-kit": "^0.3.1", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.3.0", "eslint-visitor-keys": "^4.2.0", "espree": "^10.3.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "optionalPeers": ["jiti"], "bin": { "eslint": "bin/eslint.js" } }, "sha512-ocgh41VhRlf9+fVpe7QKzwLj9c92fDiqOj8Y3Sd4/ZmVA4Btx4PlUYPq4pp9JDyupkf1upbEXecxL2mwNV7jPQ=="],
+
+    "eslint-config-prettier": ["eslint-config-prettier@10.1.5", "", { "peerDependencies": { "eslint": ">=7.0.0" }, "bin": { "eslint-config-prettier": "bin/cli.js" } }, "sha512-zc1UmCpNltmVY34vuLRV61r1K27sWuX39E+uyUnY8xS2Bex88VV9cugG+UZbRSRGtGyFboj+D8JODyme1plMpw=="],
+
+    "eslint-plugin-svelte": ["eslint-plugin-svelte@3.9.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.6.1", "@jridgewell/sourcemap-codec": "^1.5.0", "esutils": "^2.0.3", "globals": "^16.0.0", "known-css-properties": "^0.36.0", "postcss": "^8.4.49", "postcss-load-config": "^3.1.4", "postcss-safe-parser": "^7.0.0", "semver": "^7.6.3", "svelte-eslint-parser": "^1.2.0" }, "peerDependencies": { "eslint": "^8.57.1 || ^9.0.0", "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" }, "optionalPeers": ["svelte"] }, "sha512-nvIUNyyPGbr5922Kd1p/jXe+FfNdVPXsxLyrrXpwfSbZZEFdAYva9O/gm2lObC/wXkQo/AUmQkAihfmNJYeCjA=="],
+
+    "eslint-scope": ["eslint-scope@8.3.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ=="],
+
+    "eslint-visitor-keys": ["eslint-visitor-keys@4.2.0", "", {}, "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw=="],
+
+    "esm-env": ["esm-env@1.2.2", "", {}, "sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA=="],
+
+    "espree": ["espree@10.3.0", "", { "dependencies": { "acorn": "^8.14.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.0" } }, "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg=="],
+
+    "esquery": ["esquery@1.6.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg=="],
+
+    "esrap": ["esrap@1.4.6", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.4.15" } }, "sha512-F/D2mADJ9SHY3IwksD4DAXjTt7qt7GWUf3/8RhCNWmC/67tyb55dpimHmy7EplakFaflV0R/PC+fdSPqrRHAQw=="],
+
+    "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="],
+
+    "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
+
+    "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="],
+
+    "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
+
+    "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="],
+
+    "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="],
+
+    "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="],
+
+    "fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="],
+
+    "fdir": ["fdir@6.4.5", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-4BG7puHpVsIYxZUbiUE3RqGloLaSSwzYie5jvasC4LWuBWzZawynvYouhjbQKw2JuIGYdm0DzIxl8iVidKlUEw=="],
+
+    "fflate": ["fflate@0.8.2", "", {}, "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="],
+
+    "file-entry-cache": ["file-entry-cache@8.0.0", "", { "dependencies": { "flat-cache": "^4.0.0" } }, "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ=="],
+
+    "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="],
+
+    "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="],
+
+    "flat-cache": ["flat-cache@4.0.1", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw=="],
+
+    "flatted": ["flatted@3.3.3", "", {}, "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg=="],
+
+    "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
+
+    "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
+
+    "globals": ["globals@16.2.0", "", {}, "sha512-O+7l9tPdHCU320IigZZPj5zmRCFG9xHmx9cU8FqU2Rp+JN714seHV+2S9+JslCpY4gJwU2vOGox0wzgae/MCEg=="],
+
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
+    "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="],
+
+    "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
+
+    "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="],
+
+    "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
+
+    "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="],
+
+    "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
+
+    "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
+
+    "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
+
+    "is-reference": ["is-reference@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.6" } }, "sha512-ixkJoqQvAP88E6wLydLGGqCJsrFUnqoH6HnaczB8XmDH1oaWU+xxdptvikTgaEhtZ53Ky6YXiBuUI2WXLMCwjw=="],
+
+    "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="],
+
+    "jiti": ["jiti@2.4.2", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A=="],
+
+    "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="],
+
+    "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="],
+
+    "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="],
+
+    "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="],
+
+    "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="],
+
+    "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="],
+
+    "known-css-properties": ["known-css-properties@0.36.0", "", {}, "sha512-A+9jP+IUmuQsNdsLdcg6Yt7voiMF/D4K83ew0OpJtpu+l34ef7LaohWV0Rc6KNvzw6ZDizkqfyB5JznZnzuKQA=="],
+
+    "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="],
+
+    "lightningcss": ["lightningcss@1.30.1", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-darwin-arm64": "1.30.1", "lightningcss-darwin-x64": "1.30.1", "lightningcss-freebsd-x64": "1.30.1", "lightningcss-linux-arm-gnueabihf": "1.30.1", "lightningcss-linux-arm64-gnu": "1.30.1", "lightningcss-linux-arm64-musl": "1.30.1", "lightningcss-linux-x64-gnu": "1.30.1", "lightningcss-linux-x64-musl": "1.30.1", "lightningcss-win32-arm64-msvc": "1.30.1", "lightningcss-win32-x64-msvc": "1.30.1" } }, "sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg=="],
+
+    "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.30.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-c8JK7hyE65X1MHMN+Viq9n11RRC7hgin3HhYKhrMyaXflk5GVplZ60IxyoVtzILeKr+xAJwg6zK6sjTBJ0FKYQ=="],
+
+    "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.30.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-k1EvjakfumAQoTfcXUcHQZhSpLlkAuEkdMBsI/ivWw9hL+7FtilQc0Cy3hrx0AAQrVtQAbMI7YjCgYgvn37PzA=="],
+
+    "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.30.1", "", { "os": "freebsd", "cpu": "x64" }, "sha512-kmW6UGCGg2PcyUE59K5r0kWfKPAVy4SltVeut+umLCFoJ53RdCUWxcRDzO1eTaxf/7Q2H7LTquFHPL5R+Gjyig=="],
+
+    "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.30.1", "", { "os": "linux", "cpu": "arm" }, "sha512-MjxUShl1v8pit+6D/zSPq9S9dQ2NPFSQwGvxBCYaBYLPlCWuPh9/t1MRS8iUaR8i+a6w7aps+B4N0S1TYP/R+Q=="],
+
+    "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.30.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-gB72maP8rmrKsnKYy8XUuXi/4OctJiuQjcuqWNlJQ6jZiWqtPvqFziskH3hnajfvKB27ynbVCucKSm2rkQp4Bw=="],
+
+    "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.30.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-jmUQVx4331m6LIX+0wUhBbmMX7TCfjF5FoOH6SD1CttzuYlGNVpA7QnrmLxrsub43ClTINfGSYyHe2HWeLl5CQ=="],
+
+    "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.30.1", "", { "os": "linux", "cpu": "x64" }, "sha512-piWx3z4wN8J8z3+O5kO74+yr6ze/dKmPnI7vLqfSqI8bccaTGY5xiSGVIJBDd5K5BHlvVLpUB3S2YCfelyJ1bw=="],
+
+    "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.30.1", "", { "os": "linux", "cpu": "x64" }, "sha512-rRomAK7eIkL+tHY0YPxbc5Dra2gXlI63HL+v1Pdi1a3sC+tJTcFrHX+E86sulgAXeI7rSzDYhPSeHHjqFhqfeQ=="],
+
+    "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.30.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-mSL4rqPi4iXq5YVqzSsJgMVFENoa4nGTT/GjO2c0Yl9OuQfPsIfncvLrEW6RbbB24WtZ3xP/2CCmI3tNkNV4oA=="],
+
+    "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.30.1", "", { "os": "win32", "cpu": "x64" }, "sha512-PVqXh48wh4T53F/1CCu8PIPCxLzWyCnn/9T5W1Jpmdy5h9Cwd+0YQS6/LwhHXSafuc61/xg9Lv5OrCby6a++jg=="],
+
+    "lilconfig": ["lilconfig@2.1.0", "", {}, "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ=="],
+
+    "locate-character": ["locate-character@3.0.0", "", {}, "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA=="],
+
+    "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="],
+
+    "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="],
+
+    "maath": ["maath@0.10.8", "", { "peerDependencies": { "@types/three": ">=0.134.0", "three": ">=0.134.0" } }, "sha512-tRvbDF0Pgqz+9XUa4jjfgAQ8/aPKmQdWXilFu2tMy4GWj4NOsx99HlULO4IeREfbO3a0sA145DZYyvXPkybm0g=="],
+
+    "magic-string": ["magic-string@0.30.17", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0" } }, "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA=="],
+
+    "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="],
+
+    "meshoptimizer": ["meshoptimizer@0.18.1", "", {}, "sha512-ZhoIoL7TNV4s5B6+rx5mC//fw8/POGyNxS/DZyCJeiZ12ScLfVwRE/GfsxwiTkMYYD5DmK2/JXnEVXqL4rF+Sw=="],
+
+    "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="],
+
+    "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="],
+
+    "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="],
+
+    "minizlib": ["minizlib@3.0.2", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-oG62iEk+CYt5Xj2YqI5Xi9xWUeZhDI8jjQmC5oThVH5JGCTgIjr7ciJDzC7MBzYd//WvR1OTmP5Q38Q8ShQtVA=="],
+
+    "mitt": ["mitt@3.0.1", "", {}, "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw=="],
+
+    "mkdirp": ["mkdirp@3.0.1", "", { "bin": { "mkdirp": "dist/cjs/src/bin.js" } }, "sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg=="],
+
+    "mri": ["mri@1.2.0", "", {}, "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA=="],
+
+    "mrmime": ["mrmime@2.0.1", "", {}, "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "nanoid": ["nanoid@3.3.11", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="],
+
+    "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="],
+
+    "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="],
+
+    "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="],
+
+    "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
+
+    "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="],
+
+    "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
+
+    "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="],
+
+    "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],
+
+    "picomatch": ["picomatch@4.0.2", "", {}, "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg=="],
+
+    "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=="],
+
+    "postcss-load-config": ["postcss-load-config@3.1.4", "", { "dependencies": { "lilconfig": "^2.0.5", "yaml": "^1.10.2" }, "peerDependencies": { "postcss": ">=8.0.9", "ts-node": ">=9.0.0" }, "optionalPeers": ["postcss", "ts-node"] }, "sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg=="],
+
+    "postcss-safe-parser": ["postcss-safe-parser@7.0.1", "", { "peerDependencies": { "postcss": "^8.4.31" } }, "sha512-0AioNCJZ2DPYz5ABT6bddIqlhgwhpHZ/l65YAYo0BCIn0xiDpsnTHz0gnoTGk0OXZW0JRs+cDwL8u/teRdz+8A=="],
+
+    "postcss-scss": ["postcss-scss@4.0.9", "", { "peerDependencies": { "postcss": "^8.4.29" } }, "sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A=="],
+
+    "postcss-selector-parser": ["postcss-selector-parser@7.1.0", "", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA=="],
+
+    "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="],
+
+    "prettier": ["prettier@3.5.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="],
+
+    "prettier-plugin-svelte": ["prettier-plugin-svelte@3.4.0", "", { "peerDependencies": { "prettier": "^3.0.0", "svelte": "^3.2.0 || ^4.0.0-next.0 || ^5.0.0-next.0" } }, "sha512-pn1ra/0mPObzqoIQn/vUTR3ZZI6UuZ0sHqMK5x2jMLGrs53h0sXhkVuDcrlssHwIMk7FYrMjHBPoUSyyEEDlBQ=="],
+
+    "prettier-plugin-tailwindcss": ["prettier-plugin-tailwindcss@0.6.12", "", { "peerDependencies": { "@ianvs/prettier-plugin-sort-imports": "*", "@prettier/plugin-pug": "*", "@shopify/prettier-plugin-liquid": "*", "@trivago/prettier-plugin-sort-imports": "*", "@zackad/prettier-plugin-twig": "*", "prettier": "^3.0", "prettier-plugin-astro": "*", "prettier-plugin-css-order": "*", "prettier-plugin-import-sort": "*", "prettier-plugin-jsdoc": "*", "prettier-plugin-marko": "*", "prettier-plugin-multiline-arrays": "*", "prettier-plugin-organize-attributes": "*", "prettier-plugin-organize-imports": "*", "prettier-plugin-sort-imports": "*", "prettier-plugin-style-order": "*", "prettier-plugin-svelte": "*" }, "optionalPeers": ["@ianvs/prettier-plugin-sort-imports", "@prettier/plugin-pug", "@shopify/prettier-plugin-liquid", "@trivago/prettier-plugin-sort-imports", "@zackad/prettier-plugin-twig", "prettier-plugin-astro", "prettier-plugin-css-order", "prettier-plugin-import-sort", "prettier-plugin-jsdoc", "prettier-plugin-marko", "prettier-plugin-multiline-arrays", "prettier-plugin-organize-attributes", "prettier-plugin-organize-imports", "prettier-plugin-sort-imports", "prettier-plugin-style-order", "prettier-plugin-svelte"] }, "sha512-OuTQKoqNwV7RnxTPwXWzOFXy6Jc4z8oeRZYGuMpRyG3WbuR3jjXdQFK8qFBMBx8UHWdHrddARz2fgUenild6aw=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
+
+    "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-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="],
+
+    "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
+
+    "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=="],
+
+    "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="],
+
+    "sade": ["sade@1.8.1", "", { "dependencies": { "mri": "^1.1.0" } }, "sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A=="],
+
+    "semver": ["semver@7.7.2", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="],
+
+    "set-cookie-parser": ["set-cookie-parser@2.7.1", "", {}, "sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ=="],
+
+    "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
+
+    "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
+
+    "sirv": ["sirv@3.0.1", "", { "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", "totalist": "^3.0.0" } }, "sha512-FoqMu0NCGBLCcAkS1qA+XJIQTR6/JHfQXl+uGteNCQ76T91DMUjPa9xfmeqMY3z80nLSg9yQmNjK0Px6RWsH/A=="],
+
+    "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="],
+
+    "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
+
+    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
+    "svelte": ["svelte@5.33.10", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@jridgewell/sourcemap-codec": "^1.5.0", "@sveltejs/acorn-typescript": "^1.0.5", "@types/estree": "^1.0.5", "acorn": "^8.12.1", "aria-query": "^5.3.1", "axobject-query": "^4.1.0", "clsx": "^2.1.1", "esm-env": "^1.2.1", "esrap": "^1.4.6", "is-reference": "^3.0.3", "locate-character": "^3.0.0", "magic-string": "^0.30.11", "zimmerframe": "^1.1.2" } }, "sha512-/yArPQIBoQS2p86LKnvJywOXkVHeEXnFgrDPSxkEfIAEkykopYuy2bF6UUqHG4IbZlJD6OurLxJT8Kn7kTk9WA=="],
+
+    "svelte-check": ["svelte-check@4.2.1", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "chokidar": "^4.0.1", "fdir": "^6.2.0", "picocolors": "^1.0.0", "sade": "^1.7.4" }, "peerDependencies": { "svelte": "^4.0.0 || ^5.0.0-next.0", "typescript": ">=5.0.0" }, "bin": { "svelte-check": "bin/svelte-check" } }, "sha512-e49SU1RStvQhoipkQ/aonDhHnG3qxHSBtNfBRb9pxVXoa+N7qybAo32KgA9wEb2PCYFNaDg7bZCdhLD1vHpdYA=="],
+
+    "svelte-eslint-parser": ["svelte-eslint-parser@1.2.0", "", { "dependencies": { "eslint-scope": "^8.2.0", "eslint-visitor-keys": "^4.0.0", "espree": "^10.0.0", "postcss": "^8.4.49", "postcss-scss": "^4.0.9", "postcss-selector-parser": "^7.0.0" }, "peerDependencies": { "svelte": "^3.37.0 || ^4.0.0 || ^5.0.0" }, "optionalPeers": ["svelte"] }, "sha512-mbPtajIeuiyU80BEyGvwAktBeTX7KCr5/0l+uRGLq1dafwRNrjfM5kHGJScEBlPG3ipu6dJqfW/k0/fujvIEVw=="],
+
+    "tailwind-merge": ["tailwind-merge@3.3.0", "", {}, "sha512-fyW/pEfcQSiigd5SNn0nApUOxx0zB/dm6UDU/rEwc2c3sX2smWUNbapHv+QRqLGVp9GWX3THIa7MUGPo+YkDzQ=="],
+
+    "tailwindcss": ["tailwindcss@4.1.8", "", {}, "sha512-kjeW8gjdxasbmFKpVGrGd5T4i40mV5J2Rasw48QARfYeQ8YS9x02ON9SFWax3Qf616rt4Cp3nVNIj6Hd1mP3og=="],
+
+    "tapable": ["tapable@2.2.2", "", {}, "sha512-Re10+NauLTMCudc7T5WLFLAwDhQ0JWdrMK+9B2M8zR5hRExKmsRDCBA7/aV/pNJFltmBFO5BAMlQFi/vq3nKOg=="],
+
+    "tar": ["tar@7.4.3", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.0.1", "mkdirp": "^3.0.1", "yallist": "^5.0.0" } }, "sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw=="],
+
+    "three": ["three@0.177.0", "", {}, "sha512-EiXv5/qWAaGI+Vz2A+JfavwYCMdGjxVsrn3oBwllUoqYeaBO75J63ZfyaQKoiLrqNHoTlUc6PFgMXnS0kI45zg=="],
+
+    "three-instanced-uniforms-mesh": ["three-instanced-uniforms-mesh@0.52.4", "", { "dependencies": { "troika-three-utils": "^0.52.4" }, "peerDependencies": { "three": ">=0.125.0" } }, "sha512-YwDBy05hfKZQtU+Rp0KyDf9yH4GxfhxMbVt9OYruxdgLfPwmDG5oAbGoW0DrKtKZSM3BfFcCiejiOHCjFBTeng=="],
+
+    "three-mesh-bvh": ["three-mesh-bvh@0.9.0", "", { "peerDependencies": { "three": ">= 0.159.0" } }, "sha512-xAwZj0hZknpwVsdK5BBJTIAZDjDPZCRzURY1o+z/JHBON/jc2UetK1CzPeQZiiOVSfI4jV2z7sXnnGtgsgnjaA=="],
+
+    "three-perf": ["three-perf@github:jerzakm/three-perf#322d7d3", { "dependencies": { "troika-three-text": "^0.52.0", "tweakpane": "^3.1.10" }, "peerDependencies": { "three": ">=0.170" } }, "jerzakm-three-perf-322d7d3"],
+
+    "three-viewport-gizmo": ["three-viewport-gizmo@2.2.0", "", { "peerDependencies": { "three": ">=0.162.0 <1.0.0" } }, "sha512-Jo9Liur1rUmdKk75FZumLU/+hbF+RtJHi1qsKZpntjKlCYScK6tjbYoqvJ9M+IJphrlQJF5oReFW7Sambh0N4Q=="],
+
+    "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
+
+    "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="],
+
+    "totalist": ["totalist@3.0.1", "", {}, "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ=="],
+
+    "troika-three-text": ["troika-three-text@0.52.4", "", { "dependencies": { "bidi-js": "^1.0.2", "troika-three-utils": "^0.52.4", "troika-worker-utils": "^0.52.0", "webgl-sdf-generator": "1.1.1" }, "peerDependencies": { "three": ">=0.125.0" } }, "sha512-V50EwcYGruV5rUZ9F4aNsrytGdKcXKALjEtQXIOBfhVoZU9VAqZNIoGQ3TMiooVqFAbR1w15T+f+8gkzoFzawg=="],
+
+    "troika-three-utils": ["troika-three-utils@0.52.4", "", { "peerDependencies": { "three": ">=0.125.0" } }, "sha512-NORAStSVa/BDiG52Mfudk4j1FG4jC4ILutB3foPnfGbOeIs9+G5vZLa0pnmnaftZUGm4UwSoqEpWdqvC7zms3A=="],
+
+    "troika-worker-utils": ["troika-worker-utils@0.52.0", "", {}, "sha512-W1CpvTHykaPH5brv5VHLfQo9D1OYuo0cSBEUQFFT/nBUzM8iD6Lq2/tgG/f1OelbAS1WtaTPQzE5uM49egnngw=="],
+
+    "ts-api-utils": ["ts-api-utils@2.1.0", "", { "peerDependencies": { "typescript": ">=4.8.4" } }, "sha512-CUgTZL1irw8u29bzrOD/nH85jqyc74D6SshFgujOIA7osm2Rz7dYH77agkx7H4FBNxDq7Cjf+IjaX/8zwFW+ZQ=="],
+
+    "tweakpane": ["tweakpane@3.1.10", "", {}, "sha512-rqwnl/pUa7+inhI2E9ayGTqqP0EPOOn/wVvSWjZsRbZUItzNShny7pzwL3hVlaN4m9t/aZhsP0aFQ9U5VVR2VQ=="],
+
+    "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="],
+
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
+
+    "typescript-eslint": ["typescript-eslint@8.33.0", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "8.33.0", "@typescript-eslint/parser": "8.33.0", "@typescript-eslint/utils": "8.33.0" }, "peerDependencies": { "eslint": "^8.57.0 || ^9.0.0", "typescript": ">=4.8.4 <5.9.0" } }, "sha512-5YmNhF24ylCsvdNW2oJwMzTbaeO4bg90KeGtMjUw0AGtHksgEPLRTUil+coHwCfiu4QjVJFnjp94DmU6zV7DhQ=="],
+
+    "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="],
+
+    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
+    "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=="],
+
+    "vitefu": ["vitefu@1.0.6", "", { "peerDependencies": { "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0" }, "optionalPeers": ["vite"] }, "sha512-+Rex1GlappUyNN6UfwbVZne/9cYC4+R2XDk9xkNXBKMw6HQagdX9PgZ8V2v1WUSK1wfBLp7qbI1+XSNIlB1xmA=="],
+
+    "webgl-sdf-generator": ["webgl-sdf-generator@1.1.1", "", {}, "sha512-9Z0JcMTFxeE+b2x1LJTdnaT8rT8aEp7MVxkNwoycNmJWwPdzoXzMh0BjJSh/AEFP+KPYZUli814h8bJZFIZ2jA=="],
+
+    "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
+
+    "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
+
+    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+
+    "yaml": ["yaml@1.10.2", "", {}, "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg=="],
+
+    "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
+
+    "zimmerframe": ["zimmerframe@1.1.2", "", {}, "sha512-rAbqEGa8ovJy4pyBxZM70hg4pE6gDgaQ0Sl9M3enG3I0d6H4XSAM3GeNGLKnsBpuijUow064sf7ww1nutC5/3w=="],
+
+    "zod": ["zod@3.25.42", "", {}, "sha512-PcALTLskaucbeHc41tU/xfjfhcz8z0GdhhDcSgrCTmSazUuqnYqiXO63M0QUBVwpBlsLsNVn5qHSC5Dw3KZvaQ=="],
+
+    "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
+
+    "@eslint/eslintrc/globals": ["globals@14.0.0", "", {}, "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ=="],
+
+    "@humanfs/node/@humanwhocodes/retry": ["@humanwhocodes/retry@0.3.1", "", {}, "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/core": ["@emnapi/core@1.4.3", "", { "dependencies": { "@emnapi/wasi-threads": "1.0.2", "tslib": "^2.4.0" }, "bundled": true }, "sha512-4m62DuCE07lw01soJwPiBGC0nAww0Q+RY70VZ+n49yDIO13yyinhbWCeNnaob0lakDtWQzSdtNWzJeOJt2ma+g=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/runtime": ["@emnapi/runtime@1.4.3", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-pBPWdu6MLKROBX05wSNKcNb++m5Er+KQ9QkB+WVM+pW2Kx9hoSrVTnu3BdkI5eBLZoKu/J6mW/B6i6bJB2ytXQ=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.0.2", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-5n3nTJblwRi8LlXkJ9eBzu+kZR8Yxcc7ubakyQTFzPMtIhFpUBRbsnc2Dv88IZDIbCDlBiWrknhB4Lsz7mg6BA=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@0.2.10", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@tybys/wasm-util": "^0.9.0" }, "bundled": true }, "sha512-bCsCyeZEwVErsGmyPNSzwfwFn4OdxBj0mmv6hOFucB/k81Ojdu68RbZdxYsRQUPc9l6SU5F/cG+bXgWs3oUgsQ=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.9.0", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-6+7nlbMVX/PVDCwaIQ8nTOPveOcFLSt8GcXdx8hD0bt39uWxYT88uXzqTd4fTvqta7oeUJqudepapKNt2DYJFw=="],
+
+    "@tailwindcss/oxide-wasm32-wasi/tslib": ["tslib@2.8.1", "", { "bundled": true }, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
+    "@typescript-eslint/eslint-plugin/ignore": ["ignore@7.0.5", "", {}, "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg=="],
+
+    "@typescript-eslint/typescript-estree/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="],
+
+    "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
+
+    "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
+
+    "@typescript-eslint/typescript-estree/minimatch/brace-expansion": ["brace-expansion@2.0.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="],
+  }
+}

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  lerobot-arena:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8080:8080"  # Python backend
+      - "7860:7860"  # Svelte frontend (HF Spaces default)
+    environment:
+      - NODE_ENV=production
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped 

eslint.config.js

@@ -0,0 +1,36 @@
+import prettier from 'eslint-config-prettier';
+import js from '@eslint/js';
+import { includeIgnoreFile } from '@eslint/compat';
+import svelte from 'eslint-plugin-svelte';
+import globals from 'globals';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript-eslint';
+import svelteConfig from './svelte.config.js';
+
+const gitignorePath = fileURLToPath(new URL('./.gitignore', import.meta.url));
+
+export default ts.config(
+	includeIgnoreFile(gitignorePath),
+	js.configs.recommended,
+	...ts.configs.recommended,
+	...svelte.configs.recommended,
+	prettier,
+	...svelte.configs.prettier,
+	{
+		languageOptions: {
+			globals: { ...globals.browser, ...globals.node }
+		},
+		rules: { 'no-undef': 'off' }
+	},
+	{
+		files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+		languageOptions: {
+			parserOptions: {
+				projectService: true,
+				extraFileExtensions: ['.svelte'],
+				parser: ts.parser,
+				svelteConfig
+			}
+		}
+	}
+);

package.json

@@ -0,0 +1,47 @@
+{
+	"name": "my-app",
+	"private": true,
+	"version": "0.0.1",
+	"type": "module",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build",
+		"preview": "vite preview",
+		"prepare": "svelte-kit sync || echo ''",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"format": "prettier --write .",
+		"lint": "prettier --check . && eslint ."
+	},
+	"devDependencies": {
+		"@eslint/compat": "^1.2.5",
+		"@eslint/js": "^9.18.0",
+		"@sveltejs/adapter-auto": "^6.0.0",
+		"@sveltejs/adapter-static": "^3.0.8",
+		"@sveltejs/kit": "^2.16.0",
+		"@sveltejs/vite-plugin-svelte": "^5.0.0",
+		"@tailwindcss/vite": "^4.0.0",
+		"eslint": "^9.18.0",
+		"eslint-config-prettier": "^10.0.1",
+		"eslint-plugin-svelte": "^3.0.0",
+		"globals": "^16.0.0",
+		"prettier": "^3.4.2",
+		"prettier-plugin-svelte": "^3.3.3",
+		"prettier-plugin-tailwindcss": "^0.6.11",
+		"svelte": "^5.0.0",
+		"svelte-check": "^4.0.0",
+		"tailwindcss": "^4.0.0",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.20.0",
+		"vite": "^6.2.6"
+	},
+	"dependencies": {
+		"@threlte/core": "^8.0.4",
+		"@threlte/extras": "^9.2.1",
+		"@types/three": "^0.176.0",
+		"clsx": "^2.1.1",
+		"tailwind-merge": "^3.3.0",
+		"three": "^0.177.0",
+		"zod": "^3.25.42"
+	}
+}

src-python/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

src-python/.python-version

@@ -0,0 +1 @@
+3.12

src-python/README.md

@@ -0,0 +1,656 @@
+# 🤖 LeRobot Arena - Complete Robot Control System
+
+A comprehensive WebSocket-based robot control platform featuring **master-slave architecture**, real-time 3D visualization, and seamless integration between physical robots and digital twins.
+
+## 🏛️ Core Architecture
+
+### Master-Slave Pattern
+```
+┌─────────────────┐    Commands     ┌─────────────────┐    Execution    ┌─────────────────┐
+│    🎮 MASTERS   │ ───────────────►│  🤖 ROBOT CORE  │ ───────────────►│   🔧 SLAVES     │
+│                 │                 │                 │                 │                 │
+│ • Remote Server │    WebSocket    │ • Robot Manager │   USB/Mock/WS   │ • Physical Bot  │
+│ • Demo Scripts  │    HTTP API     │ • State Sync    │   Direct I/O    │ • 3D Simulation │
+│ • Manual UI     │    Sequences    │ • Safety Logic  │   Commands      │ • Mock Testing  │
+│ • AI Agents     │                 │ • Multi-Robot   │                 │ • Remote Proxy  │
+└─────────────────┘                 └─────────────────┘                 └─────────────────┘
+```
+
+**Key Principles:**
+- 🎯 **Single Source of Truth**: Only one master per robot at a time
+- 🔒 **Safety First**: Manual control disabled when master active  
+- 🌐 **Multi-Modal**: Same commands work across all slave types
+- 🔄 **Real-Time Sync**: Virtual and physical states synchronized
+- 📡 **Network Native**: Built for remote operation from day one
+
+## 🚀 Quick Start Guide
+
+### 1. Server Setup
+```bash
+# Install dependencies
+cd src-python
+uv sync
+
+# Start the WebSocket server
+python start_server.py
+# Server runs on http://localhost:8080
+```
+
+### 2. Frontend Integration
+```bash
+# In your Svelte app
+npm run dev
+# Visit http://localhost:5173
+```
+
+### 3. Create & Control Robot
+```javascript
+// Create robot in UI or via API
+const robot = await robotManager.createRobot('my-robot', robotUrdfConfig);
+
+// Option 1: Manual control (sliders in UI)
+await robot.updateJointValue('Rotation', 45);
+
+// Option 2: Demo sequences
+await robotManager.connectDemoSequences('my-robot');
+
+// Option 3: Remote server control
+await robotManager.connectMaster('my-robot', {
+  type: "remote-server",
+  url: "ws://localhost:8080"
+});
+
+// Option 4: Direct API sequence trigger
+curl -X POST http://localhost:8080/api/robots/my-robot/play-sequence/gentle-wave
+```
+
+## 🎮 Master Drivers (Command Sources)
+
+### MockSequenceMaster
+**Pre-programmed movement patterns for testing and demos**
+
+```typescript
+const config: MasterDriverConfig = {
+  type: "mock-sequence",
+  sequences: DEMO_SEQUENCES,
+  autoStart: true,
+  loopMode: true
+};
+
+await robotManager.connectMaster('robot-1', config);
+```
+
+**Available Sequences:**
+- **🌊 Gentle Wave Pattern** (6s): Smooth greeting gesture with wrist movements
+- **🔍 Small Scanning Pattern** (8s): Horizontal sweep for environment scanning  
+- **💪 Tiny Flex Pattern** (8s): Articulation demonstration with elbow/jaw coordination
+
+**Features:**
+- ✅ Safe movement ranges (±25° max)
+- ✅ Smooth interpolation between keyframes
+- ✅ Loop mode for continuous operation
+- ✅ Automatic master takeover
+
+### RemoteServerMaster
+**WebSocket connection to external control systems**
+
+```typescript
+const config: MasterDriverConfig = {
+  type: "remote-server", 
+  url: "ws://localhost:8080",
+  apiKey: "optional-auth-token"
+};
+
+await robotManager.connectMaster('robot-1', config);
+```
+
+**Features:**
+- ✅ Real-time bidirectional communication
+- ✅ Automatic reconnection with exponential backoff
+- ✅ Heartbeat monitoring (30s intervals)
+- ✅ Command acknowledgment
+- ✅ Status and error reporting
+
+**Message Format:**
+```json
+{
+  "type": "command",
+  "timestamp": "2024-01-01T12:00:00Z", 
+  "data": {
+    "timestamp": 1704110400000,
+    "joints": [
+      {"name": "Rotation", "value": 45, "speed": 100}
+    ]
+  }
+}
+```
+
+## 🔧 Slave Drivers (Execution Targets)
+
+### MockSlave
+**Perfect simulation for development and testing**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "mock-slave",
+  simulateLatency: 50,      // Realistic response delay
+  simulateErrors: false,    // Random connection issues
+  responseDelay: 20         // Command execution time
+};
+
+await robotManager.connectSlave('robot-1', config);
+```
+
+**Features:**
+- ✅ Perfect command execution (real_value = virtual_value)
+- ✅ Configurable network latency simulation
+- ✅ Error injection for robustness testing
+- ✅ Instant connection without hardware
+- ✅ Real-time state feedback
+
+### USBSlave
+**Direct serial communication with physical robots**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "usb-slave",
+  port: "/dev/ttyUSB0",     // Auto-detect if undefined
+  baudRate: 115200
+};
+
+await robotManager.connectSlave('robot-1', config);
+```
+
+**Features:**
+- ✅ Feetech servo protocol support
+- ✅ Position and speed control
+- ✅ Real servo position feedback
+- ✅ Calibration workflow for sync
+- ✅ Error handling and recovery
+
+**Calibration Process:**
+1. Manually position robot to match digital twin
+2. Click "Calibrate" to sync virtual/real coordinates
+3. System calculates offset: `real_pos = raw_pos + offset`
+4. All future commands automatically compensated
+
+### WebSocketSlave
+**Remote robot control via WebSocket relay**
+
+```typescript
+const config: SlaveDriverConfig = {
+  type: "websocket-slave",
+  url: "ws://robot-proxy:8080",
+  robotId: "remote-arm-1"
+};
+
+await robotManager.connectSlave('robot-1', config);
+```
+
+**Use Cases:**
+- 🌐 Control robots across internet
+- 🏢 Enterprise robot fleet management
+- 🔒 Firewall-friendly robot access
+- 📡 Proxy through edge devices
+
+## 📡 WebSocket Protocol Specification
+
+### Master → Server Communication
+
+#### Send Joint Command
+```json
+{
+  "type": "command",
+  "timestamp": "2024-01-01T12:00:00Z",
+  "data": {
+    "timestamp": 1704110400000,
+    "joints": [
+      {"name": "Rotation", "value": 45, "speed": 100},
+      {"name": "Pitch", "value": -30, "speed": 150}
+    ],
+    "duration": 2000,
+    "metadata": {"source": "manual_control"}
+  }
+}
+```
+
+#### Send Movement Sequence
+```json
+{
+  "type": "sequence",
+  "timestamp": "2024-01-01T12:00:00Z", 
+  "data": {
+    "id": "custom-dance",
+    "name": "Custom Dance Sequence",
+    "commands": [
+      {
+        "timestamp": 0,
+        "joints": [{"name": "Rotation", "value": -30}],
+        "duration": 1000
+      },
+      {
+        "timestamp": 1000, 
+        "joints": [{"name": "Rotation", "value": 30}],
+        "duration": 1000
+      }
+    ],
+    "total_duration": 2000,
+    "loop": false
+  }
+}
+```
+
+#### Heartbeat
+```json
+{
+  "type": "heartbeat",
+  "timestamp": "2024-01-01T12:00:00Z"
+}
+```
+
+### Slave → Server Communication
+
+#### Status Update
+```json
+{
+  "type": "status_update",
+  "timestamp": "2024-01-01T12:00:00Z",
+  "data": {
+    "isConnected": true,
+    "lastConnected": "2024-01-01T11:58:00Z",
+    "error": null
+  }
+}
+```
+
+#### Joint State Feedback
+```json
+{
+  "type": "joint_states", 
+  "timestamp": "2024-01-01T12:00:00Z",
+  "data": [
+    {
+      "name": "Rotation",
+      "servo_id": 1,
+      "type": "revolute",
+      "virtual_value": 45.0,
+      "real_value": 44.8,
+      "limits": {
+        "lower": -180,
+        "upper": 180,
+        "velocity": 200
+      }
+    }
+  ]
+}
+```
+
+#### Error Reporting
+```json
+{
+  "type": "error",
+  "timestamp": "2024-01-01T12:00:00Z", 
+  "data": {
+    "code": "SERVO_TIMEOUT",
+    "message": "Servo 3 not responding",
+    "joint": "Elbow", 
+    "severity": "warning"
+  }
+}
+```
+
+## 🛠️ REST API Reference
+
+### Robot Management
+
+| Method | Endpoint | Description | Example |
+|--------|----------|-------------|---------|
+| GET | `/` | Server status & metrics | `curl http://localhost:8080/` |
+| GET | `/api/robots` | List all robots | `curl http://localhost:8080/api/robots` |
+| POST | `/api/robots` | Create new robot | `curl -X POST -H "Content-Type: application/json" -d '{"robot_type":"so-arm100","name":"My Robot"}' http://localhost:8080/api/robots` |
+| GET | `/api/robots/{id}` | Get robot details | `curl http://localhost:8080/api/robots/robot-123` |
+| GET | `/api/robots/{id}/status` | Get connection status | `curl http://localhost:8080/api/robots/robot-123/status` |
+| DELETE | `/api/robots/{id}` | Delete robot | `curl -X DELETE http://localhost:8080/api/robots/robot-123` |
+
+### Sequence Control
+
+| Method | Endpoint | Description | Example |
+|--------|----------|-------------|---------|
+| GET | `/api/sequences` | List demo sequences | `curl http://localhost:8080/api/sequences` |
+| POST | `/api/robots/{id}/play-sequence/{seq_id}` | Play sequence | `curl -X POST http://localhost:8080/api/robots/robot-123/play-sequence/gentle-wave` |
+| POST | `/api/robots/{id}/stop-sequence` | Stop sequences | `curl -X POST http://localhost:8080/api/robots/robot-123/stop-sequence` |
+
+### WebSocket Endpoints
+
+| Endpoint | Purpose | Client Type | Example |
+|----------|---------|-------------|---------|
+| `/ws/master/{robot_id}` | Send commands | Control sources | `ws://localhost:8080/ws/master/robot-123` |
+| `/ws/slave/{robot_id}` | Receive commands | Execution targets | `ws://localhost:8080/ws/slave/robot-123` |
+
+## 🎯 Usage Scenarios
+
+### 1. 🧪 Development & Testing
+```bash
+# Create robot with mock slave for safe testing
+robot = await robotManager.createRobot('test-bot', urdfConfig);
+await robotManager.connectMockSlave('test-bot', 50);
+await robotManager.connectDemoSequences('test-bot');
+```
+
+**Perfect for:**
+- Algorithm development without hardware risk
+- UI/UX testing with realistic feedback
+- Automated testing pipelines
+- Demo presentations
+
+### 2. 🦾 Physical Robot Control
+```bash
+# Connect real hardware
+robot = await robotManager.createRobot('real-bot', urdfConfig);
+await robotManager.connectUSBSlave('real-bot', '/dev/ttyUSB0');
+
+# Manual control via UI sliders
+# OR automated via demo sequences
+await robotManager.connectDemoSequences('real-bot');
+```
+
+**Calibration Workflow:**
+1. Connect USB slave to robot
+2. Manually position to match 3D model rest pose
+3. Click "Calibrate" to sync coordinate systems
+4. Robot now mirrors 3D model movements precisely
+
+### 3. 🌐 Remote Operation
+```bash
+# Master controls slave over internet
+# Master side:
+await robotManager.connectMaster('local-avatar', {
+  type: "remote-server", 
+  url: "wss://robot-farm.com:8080"
+});
+
+# Slave side (at robot location):
+await robotManager.connectSlave('physical-robot', {
+  type: "websocket-slave",
+  url: "wss://robot-farm.com:8080", 
+  robotId: "local-avatar"
+});
+```
+
+**Use Cases:**
+- Telepresence robotics
+- Remote maintenance and inspection
+- Distributed manufacturing
+- Educational robot sharing
+
+### 4. 🤖 Multi-Robot Coordination
+```bash
+# One master controlling multiple robots
+await robotManager.connectMaster('fleet-commander', masterConfig);
+
+// Multiple slaves executing same commands
+for (const robot of robotFleet) {
+  await robotManager.connectSlave(robot.id, slaveConfig);
+}
+```
+
+**Applications:**
+- Synchronized dance performances
+- Assembly line coordination
+- Swarm robotics research
+- Entertainment shows
+
+### 5. 🧠 AI Agent Integration
+```javascript
+// AI agent as master driver
+class AIAgentMaster implements MasterDriver {
+  async generateNextCommand(): Promise<RobotCommand> {
+    const sensorData = await this.readEnvironment();
+    const decision = await this.aiModel.predict(sensorData);
+    return this.convertToRobotCommand(decision);
+  }
+}
+
+await robot.setMaster(new AIAgentMaster(config));
+```
+
+## 🔧 Integration Guide
+
+### Frontend Integration (Svelte)
+```typescript
+import { robotManager } from '$lib/robot/RobotManager.svelte';
+import { robotUrdfConfigMap } from '$lib/configs/robotUrdfConfig';
+
+// Create robot
+const robot = await robotManager.createRobot('my-robot', robotUrdfConfigMap['so-arm100']);
+
+// Add visualization 
+await robotManager.connectMockSlave('my-robot');
+
+// Add control
+await robotManager.connectDemoSequences('my-robot', true);
+
+// Monitor state
+robot.joints.forEach(joint => {
+  console.log(`${joint.name}: virtual=${joint.virtualValue}° real=${joint.realValue}°`);
+});
+```
+
+### Backend Integration (Python)
+```python
+import asyncio
+import websockets
+import json
+
+async def robot_controller():
+    uri = "ws://localhost:8080/ws/master/my-robot"
+    async with websockets.connect(uri) as websocket:
+        # Send command
+        command = {
+            "type": "command",
+            "timestamp": "2024-01-01T12:00:00Z",
+            "data": {
+                "timestamp": 1704110400000,
+                "joints": [{"name": "Rotation", "value": 45}]
+            }
+        }
+        await websocket.send(json.dumps(command))
+        
+        # Listen for responses
+        async for message in websocket:
+            data = json.loads(message)
+            if data["type"] == "joint_states":
+                print(f"Robot position: {data['data']}")
+
+asyncio.run(robot_controller())
+```
+
+### Hardware Integration (Arduino/C++)
+```cpp
+#include <WiFi.h>
+#include <WebSocketsClient.h>
+#include <ArduinoJson.h>
+
+WebSocketsClient webSocket;
+
+void onWebSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
+    if (type == WStype_TEXT) {
+        DynamicJsonDocument doc(1024);
+        deserializeJson(doc, payload);
+        
+        if (doc["type"] == "execute_command") {
+            JsonArray joints = doc["data"]["joints"];
+            for (JsonObject joint : joints) {
+                String name = joint["name"];
+                float value = joint["value"];
+                moveServo(name, value);
+            }
+        }
+    }
+}
+
+void setup() {
+    webSocket.begin("192.168.1.100", 8080, "/ws/slave/arduino-bot");
+    webSocket.onEvent(onWebSocketEvent);
+}
+```
+
+## 🛡️ Security & Production
+
+### Authentication
+```typescript
+// API key authentication (planned)
+const master = new RemoteServerMaster({
+  type: "remote-server",
+  url: "wss://secure-robot-farm.com:8080",
+  apiKey: "your-secret-api-key"
+}, robotId);
+```
+
+### TLS/SSL
+```bash
+# Production deployment with SSL
+uvicorn main:app --host 0.0.0.0 --port 443 --ssl-keyfile key.pem --ssl-certfile cert.pem
+```
+
+### Rate Limiting & Safety
+```python
+# Built-in protections
+- Command rate limiting (100 commands/second max)
+- Joint velocity limits from URDF
+- Emergency stop on connection loss
+- Position bounds checking
+- Servo temperature monitoring
+```
+
+## 🚀 Deployment Options
+
+### Development
+```bash
+cd src-python && python start_server.py
+```
+
+### Docker
+```dockerfile
+FROM python:3.12-slim
+COPY src-python/ /app/
+WORKDIR /app
+RUN pip install -r requirements.txt
+EXPOSE 8080
+CMD ["python", "start_server.py"]
+```
+
+### Cloud (Railway/Heroku)
+```bash
+# Procfile
+web: cd src-python && python start_server.py
+```
+
+### Raspberry Pi (Edge)
+```bash
+# systemd service for autostart
+sudo systemctl enable lerobot-arena
+sudo systemctl start lerobot-arena
+```
+
+## 🧪 Testing & Debugging
+
+### Unit Tests
+```bash
+cd src-python
+pytest tests/ -v
+```
+
+### Integration Tests
+```javascript
+// Frontend testing
+import { expect, test } from '@playwright/test';
+
+test('robot creation and control', async ({ page }) => {
+  await page.goto('/');
+  await page.click('[data-testid="create-robot"]');
+  await page.click('[data-testid="connect-demo-sequences"]');
+  await expect(page.locator('[data-testid="robot-status"]')).toContainText('Master + Slaves');
+});
+```
+
+### Debug Mode
+```bash
+# Enable verbose logging
+export LOG_LEVEL=DEBUG
+python start_server.py
+
+# Frontend debug
+export VITE_DEBUG=true
+npm run dev
+```
+
+### Health Monitoring
+```bash
+# Check server health
+curl http://localhost:8080/
+
+# Monitor WebSocket connections
+curl http://localhost:8080/api/robots
+```
+
+## 🔮 Roadmap
+
+### v2.0 - Enhanced Control
+- [ ] **Script Player Master**: Execute Python/JS scripts
+- [ ] **Simulation Slave**: Physics-based simulation
+- [ ] **Force Control**: Torque and compliance modes
+- [ ] **Vision Integration**: Camera feeds and computer vision
+
+### v2.1 - Enterprise Features
+- [ ] **Authentication**: JWT tokens and user management
+- [ ] **Multi-tenancy**: Isolated robot fleets per organization
+- [ ] **Monitoring**: Prometheus metrics and Grafana dashboards
+- [ ] **Recording**: Command sequences and replay
+
+### v2.2 - Advanced Robotics
+- [ ] **Path Planning**: Trajectory optimization
+- [ ] **Collision Detection**: Safety in shared workspaces
+- [ ] **AI Integration**: Reinforcement learning environments
+- [ ] **ROS Bridge**: Integration with ROS2 ecosystem
+
+## 🤝 Contributing
+
+### Development Setup
+```bash
+# Frontend
+npm install
+npm run dev
+
+# Backend  
+cd src-python
+uv sync
+python start_server.py
+
+# Tests
+npm run test
+cd src-python && pytest
+```
+
+### Code Style
+- **TypeScript**: ESLint + Prettier
+- **Python**: Black + isort + mypy
+- **Commits**: Conventional commits format
+
+### Pull Request Process
+1. Fork repository
+2. Create feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Update documentation
+6. Submit PR with clear description
+
+## 📄 License
+
+MIT License - Feel free to use in commercial and personal projects.
+
+---
+
+**Built with ❤️ for the robotics community**
+
+*LeRobot Arena bridges the gap between digital twins and physical robots, making robotics accessible to developers, researchers, and enthusiasts worldwide.*

src-python/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "lerobot-arena-server"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.115.12",
+    "uvicorn>=0.34.3",
+    "websockets>=15.0.1",
+]
+
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[project.scripts]
+lerobot-arena-server = "start_server:main"
+
+[project.optional-dependencies]
+packaging = [
+    "box-packager>=0.4.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "box-packager>=0.4.0",
+]
+
+[tool.box]
+builder = "hatch"
+is_gui = false
+app_entry = "start_server:main"
+entry_type = "spec"
+python_version = "3.12"
+
+[tool.box.env-vars]
+PYAPP_UV_ENABLED = "true"
+PYAPP_EXPOSE_METADATA = "false"

src-python/src/__init__.py

@@ -0,0 +1 @@
+# LeRobot Arena Server Package 

src-python/src/connection_manager.py

@@ -0,0 +1,147 @@
+from fastapi import WebSocket
+from typing import Dict, List, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ConnectionManager:
+    """Manages WebSocket connections for masters and slaves"""
+    
+    def __init__(self):
+        # robot_id -> websocket
+        self.master_connections: Dict[str, WebSocket] = {}
+        
+        # robot_id -> list of websockets
+        self.slave_connections: Dict[str, List[WebSocket]] = {}
+        
+        # connection_id -> (robot_id, websocket)
+        self.connection_registry: Dict[str, tuple] = {}
+
+    async def connect_master(self, connection_id: str, robot_id: str, websocket: WebSocket):
+        """Connect a master to a robot"""
+        # Only one master per robot
+        if robot_id in self.master_connections:
+            logger.warning(f"Disconnecting existing master for robot {robot_id}")
+            await self.disconnect_master_by_robot(robot_id)
+        
+        self.master_connections[robot_id] = websocket
+        self.connection_registry[connection_id] = (robot_id, websocket)
+        logger.info(f"Master {connection_id} connected to robot {robot_id}")
+
+    async def connect_slave(self, connection_id: str, robot_id: str, websocket: WebSocket):
+        """Connect a slave to a robot"""
+        if robot_id not in self.slave_connections:
+            self.slave_connections[robot_id] = []
+        
+        self.slave_connections[robot_id].append(websocket)
+        self.connection_registry[connection_id] = (robot_id, websocket)
+        logger.info(f"Slave {connection_id} connected to robot {robot_id} ({len(self.slave_connections[robot_id])} total slaves)")
+
+    async def disconnect_master(self, connection_id: str):
+        """Disconnect a master connection"""
+        if connection_id in self.connection_registry:
+            robot_id, websocket = self.connection_registry[connection_id]
+            
+            if robot_id in self.master_connections:
+                del self.master_connections[robot_id]
+            
+            del self.connection_registry[connection_id]
+            logger.info(f"Master {connection_id} disconnected from robot {robot_id}")
+
+    async def disconnect_master_by_robot(self, robot_id: str):
+        """Disconnect master by robot ID"""
+        if robot_id in self.master_connections:
+            websocket = self.master_connections[robot_id]
+            
+            # Find and remove from connection registry
+            for conn_id, (r_id, ws) in list(self.connection_registry.items()):
+                if r_id == robot_id and ws == websocket:
+                    del self.connection_registry[conn_id]
+                    break
+            
+            del self.master_connections[robot_id]
+            
+            try:
+                await websocket.close()
+            except Exception as e:
+                logger.error(f"Error closing master websocket for robot {robot_id}: {e}")
+
+    async def disconnect_slave(self, connection_id: str):
+        """Disconnect a slave connection"""
+        if connection_id in self.connection_registry:
+            robot_id, websocket = self.connection_registry[connection_id]
+            
+            if robot_id in self.slave_connections:
+                try:
+                    self.slave_connections[robot_id].remove(websocket)
+                    if not self.slave_connections[robot_id]:  # Remove empty list
+                        del self.slave_connections[robot_id]
+                except ValueError:
+                    logger.warning(f"Slave websocket not found in connections for robot {robot_id}")
+            
+            del self.connection_registry[connection_id]
+            logger.info(f"Slave {connection_id} disconnected from robot {robot_id}")
+
+    def get_master_connection(self, robot_id: str) -> Optional[WebSocket]:
+        """Get master connection for a robot"""
+        return self.master_connections.get(robot_id)
+
+    def get_slave_connections(self, robot_id: str) -> List[WebSocket]:
+        """Get all slave connections for a robot"""
+        return self.slave_connections.get(robot_id, [])
+
+    def get_connection_count(self) -> int:
+        """Get total number of active connections"""
+        master_count = len(self.master_connections)
+        slave_count = sum(len(slaves) for slaves in self.slave_connections.values())
+        return master_count + slave_count
+
+    def get_robot_connection_info(self, robot_id: str) -> dict:
+        """Get connection information for a robot"""
+        has_master = robot_id in self.master_connections
+        slave_count = len(self.slave_connections.get(robot_id, []))
+        
+        return {
+            "robot_id": robot_id,
+            "has_master": has_master,
+            "slave_count": slave_count,
+            "total_connections": (1 if has_master else 0) + slave_count
+        }
+
+    async def cleanup_robot_connections(self, robot_id: str):
+        """Clean up all connections for a robot"""
+        # Close master connection
+        if robot_id in self.master_connections:
+            try:
+                await self.master_connections[robot_id].close()
+            except Exception as e:
+                logger.error(f"Error closing master connection for robot {robot_id}: {e}")
+            del self.master_connections[robot_id]
+        
+        # Close slave connections
+        if robot_id in self.slave_connections:
+            for websocket in self.slave_connections[robot_id]:
+                try:
+                    await websocket.close()
+                except Exception as e:
+                    logger.error(f"Error closing slave connection for robot {robot_id}: {e}")
+            del self.slave_connections[robot_id]
+        
+        # Clean up connection registry
+        to_remove = []
+        for conn_id, (r_id, _) in self.connection_registry.items():
+            if r_id == robot_id:
+                to_remove.append(conn_id)
+        
+        for conn_id in to_remove:
+            del self.connection_registry[conn_id]
+        
+        logger.info(f"Cleaned up all connections for robot {robot_id}")
+
+    def list_all_connections(self) -> dict:
+        """List all active connections for debugging"""
+        return {
+            "masters": {robot_id: "connected" for robot_id in self.master_connections.keys()},
+            "slaves": {robot_id: len(slaves) for robot_id, slaves in self.slave_connections.items()},
+            "total_connections": self.get_connection_count()
+        } 

src-python/src/main.py

@@ -0,0 +1,554 @@
+import asyncio
+import logging
+import uuid
+from datetime import UTC, datetime
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+
+from .connection_manager import ConnectionManager
+from .models import (
+    CreateRobotRequest,
+    Robot,
+    RobotStatus,
+)
+from .robot_manager import RobotManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="LeRobot Arena Server",
+    description="WebSocket-based robot control server for master-slave architecture",
+    version="1.0.0",
+)
+
+# CORS middleware for web frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "http://localhost:5174",
+        "http://localhost:3000",
+    ],  # Add your frontend URLs
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global managers
+connection_manager = ConnectionManager()
+robot_manager = RobotManager()
+
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("🤖 LeRobot Arena Server starting up...")
+
+    # Create some demo robots for testing
+    await robot_manager.create_robot("demo-arm-1", "so-arm100", "Demo Arm Robot 1")
+    await robot_manager.create_robot("demo-arm-2", "so-arm100", "Demo Arm Robot 2")
+
+    logger.info("✅ Server ready for robot connections!")
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "LeRobot Arena Server",
+        "version": "1.0.0",
+        "robots_connected": len(robot_manager.robots),
+        "active_connections": connection_manager.get_connection_count(),
+    }
+
+
+# ============= ROBOT MANAGEMENT API =============
+
+
+@app.get("/api/robots", response_model=list[Robot])
+async def list_robots():
+    """Get list of all available robots"""
+    robots = list(robot_manager.robots.values())
+    print("🔍 DEBUG: /api/robots called")
+    print(f"🔍 DEBUG: Found {len(robots)} robots")
+    for robot in robots:
+        print(
+            f"🔍 DEBUG: Robot - ID: {robot.id}, Name: {robot.name}, Type: {robot.robot_type}"
+        )
+    return robots
+
+
+@app.post("/api/robots", response_model=Robot)
+async def create_robot(request: CreateRobotRequest):
+    """Create a new robot"""
+    robot_id = f"robot-{uuid.uuid4().hex[:8]}"
+    return await robot_manager.create_robot(
+        robot_id, request.robot_type, request.name or f"Robot {robot_id}"
+    )
+
+
+@app.get("/api/robots/{robot_id}", response_model=Robot)
+async def get_robot(robot_id: str):
+    """Get robot details"""
+    robot = robot_manager.get_robot(robot_id)
+    if not robot:
+        raise HTTPException(status_code=404, detail="Robot not found")
+    return robot
+
+
+@app.get("/api/robots/{robot_id}/status", response_model=RobotStatus)
+async def get_robot_status(robot_id: str):
+    """Get robot connection status"""
+    status = robot_manager.get_robot_status(robot_id)
+    if not status:
+        raise HTTPException(status_code=404, detail="Robot not found")
+    return status
+
+
+@app.delete("/api/robots/{robot_id}")
+async def delete_robot(robot_id: str):
+    """Delete a robot"""
+    if not robot_manager.get_robot(robot_id):
+        raise HTTPException(status_code=404, detail="Robot not found")
+
+    await robot_manager.delete_robot(robot_id)
+    return {"message": f"Robot {robot_id} deleted"}
+
+
+# ============= DEMO SEQUENCE API =============
+
+
+@app.get("/api/sequences")
+async def list_demo_sequences():
+    """Get list of available demo sequences"""
+    from .models import DEMO_SEQUENCES
+
+    return [
+        {
+            "id": seq.id,
+            "name": seq.name,
+            "total_duration": seq.total_duration,
+            "command_count": len(seq.commands),
+        }
+        for seq in DEMO_SEQUENCES
+    ]
+
+
+@app.post("/api/robots/{robot_id}/play-sequence/{sequence_id}")
+async def play_demo_sequence(robot_id: str, sequence_id: str):
+    """Play a demo sequence on a robot"""
+    # Check if robot exists
+    robot = robot_manager.get_robot(robot_id)
+    if not robot:
+        raise HTTPException(status_code=404, detail="Robot not found")
+
+    # Find the sequence
+    from .models import DEMO_SEQUENCES
+
+    sequence = next((seq for seq in DEMO_SEQUENCES if seq.id == sequence_id), None)
+    if not sequence:
+        raise HTTPException(status_code=404, detail="Sequence not found")
+
+    # Get available connections
+    slave_connections = connection_manager.get_slave_connections(robot_id)
+    master_connection = connection_manager.get_master_connection(robot_id)
+
+    if not slave_connections and not master_connection:
+        raise HTTPException(
+            status_code=400,
+            detail="No connections available. Connect a master (for 3D visualization) or slave (for robot execution) to play sequences.",
+        )
+
+    # Send sequence to slaves and/or master
+    notifications_sent = 0
+    try:
+        # Send to slaves if available (physical robots)
+        if slave_connections:
+            await broadcast_to_slaves(
+                robot_id,
+                {
+                    "type": "execute_sequence",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "data": sequence.model_dump(mode="json"),
+                },
+            )
+            notifications_sent += len(slave_connections)
+            logger.info(
+                f"🤖 Sent sequence '{sequence.name}' to {len(slave_connections)} slaves"
+            )
+
+        # Send to master if available (3D visualization)
+        if master_connection:
+            await broadcast_to_master(
+                robot_id,
+                {
+                    "type": "play_sequence",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "data": sequence.model_dump(mode="json"),
+                },
+            )
+            notifications_sent += 1
+            logger.info(
+                f"🎬 Sent sequence '{sequence.name}' to master for visualization"
+            )
+
+        logger.info(
+            f"🎬 Playing sequence '{sequence.name}' on robot {robot_id} ({notifications_sent} connections)"
+        )
+
+        return {
+            "message": f"Sequence '{sequence.name}' started on robot {robot_id}",
+            "sequence": {
+                "id": sequence.id,
+                "name": sequence.name,
+                "duration": sequence.total_duration,
+            },
+            "slaves_notified": len(slave_connections),
+            "master_notified": 1 if master_connection else 0,
+            "total_notifications": notifications_sent,
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to play sequence {sequence_id} on robot {robot_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to play sequence: {e}")
+
+
+@app.post("/api/robots/{robot_id}/stop-sequence")
+async def stop_sequence(robot_id: str):
+    """Stop any running sequence on a robot"""
+    # Check if robot exists
+    robot = robot_manager.get_robot(robot_id)
+    if not robot:
+        raise HTTPException(status_code=404, detail="Robot not found")
+
+    # Check if robot has slaves
+    slave_connections = connection_manager.get_slave_connections(robot_id)
+    if not slave_connections:
+        raise HTTPException(status_code=400, detail="No slave connections available")
+
+    try:
+        # Send stop command to all slaves
+        await broadcast_to_slaves(
+            robot_id,
+            {
+                "type": "stop_sequence",
+                "timestamp": datetime.now(UTC).isoformat(),
+                "data": {},
+            },
+        )
+
+        logger.info(f"⏹️ Stopped sequences on robot {robot_id}")
+
+        return {
+            "message": f"Sequences stopped on robot {robot_id}",
+            "slaves_notified": len(slave_connections),
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to stop sequences on robot {robot_id}: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to stop sequences: {e}")
+
+
+# ============= WEBSOCKET ENDPOINTS =============
+
+
+@app.websocket("/ws/master/{robot_id}")
+async def websocket_master_endpoint(websocket: WebSocket, robot_id: str):
+    """WebSocket endpoint for master connections (command sources)"""
+    await websocket.accept()
+
+    robot = robot_manager.get_robot(robot_id)
+    if not robot:
+        # Auto-create robot if it doesn't exist
+        logger.info(f"🤖 Auto-creating robot {robot_id} for master connection")
+        try:
+            robot = await robot_manager.create_robot(
+                robot_id, "so-arm100", f"Auto-created Robot {robot_id}"
+            )
+        except Exception as e:
+            logger.error(f"Failed to auto-create robot {robot_id}: {e}")
+            await websocket.close(code=4003, reason="Failed to create robot")
+            return
+
+    connection_id = f"master-{uuid.uuid4().hex[:8]}"
+    logger.info(f"🎮 Master connected: {connection_id} for robot {robot_id}")
+
+    try:
+        # Register master connection
+        await connection_manager.connect_master(connection_id, robot_id, websocket)
+        await robot_manager.set_master_connected(robot_id, connection_id)
+
+        # Send initial robot state
+        await websocket.send_json({
+            "type": "robot_state",
+            "timestamp": datetime.now(UTC).isoformat(),
+            "data": robot.model_dump(mode="json"),
+        })
+
+        # Handle incoming messages
+        async for message in websocket.iter_json():
+            await handle_master_message(connection_id, robot_id, message)
+
+    except WebSocketDisconnect:
+        logger.info(f"🔌 Master disconnected: {connection_id}")
+    except Exception as e:
+        logger.error(f"❌ Master connection error: {e}")
+    finally:
+        await connection_manager.disconnect_master(connection_id)
+        await robot_manager.set_master_disconnected(robot_id)
+
+
+@app.websocket("/ws/slave/{robot_id}")
+async def websocket_slave_endpoint(websocket: WebSocket, robot_id: str):
+    """WebSocket endpoint for slave connections (execution targets)"""
+    print(f"🔍 DEBUG: Slave WebSocket connection attempt for robot {robot_id}")
+    await websocket.accept()
+
+    robot = robot_manager.get_robot(robot_id)
+    if not robot:
+        # Auto-create robot if it doesn't exist
+        print(f"🔍 DEBUG: Robot {robot_id} not found, auto-creating...")
+        logger.info(f"🤖 Auto-creating robot {robot_id} for slave connection")
+        try:
+            robot = await robot_manager.create_robot(
+                robot_id, "so-arm100", f"Auto-created Robot {robot_id}"
+            )
+            print(f"🔍 DEBUG: Successfully auto-created robot {robot_id}")
+        except Exception as e:
+            print(f"🔍 DEBUG: Failed to auto-create robot {robot_id}: {e}")
+            logger.error(f"Failed to auto-create robot {robot_id}: {e}")
+            await websocket.close(code=4003, reason="Failed to create robot")
+            return
+    else:
+        print(f"🔍 DEBUG: Robot {robot_id} found, proceeding with connection")
+
+    connection_id = f"slave-{uuid.uuid4().hex[:8]}"
+    print(f"🔍 DEBUG: Generated slave connection ID: {connection_id}")
+    logger.info(f"🤖 Slave connected: {connection_id} for robot {robot_id}")
+
+    try:
+        # Register slave connection
+        await connection_manager.connect_slave(connection_id, robot_id, websocket)
+        await robot_manager.add_slave_connection(robot_id, connection_id)
+        print(f"🔍 DEBUG: Slave {connection_id} registered successfully")
+
+        # Send initial commands if any
+        await sync_slave_with_current_state(robot_id, websocket)
+        print(f"🔍 DEBUG: Initial state sync sent to slave {connection_id}")
+
+        # Handle incoming messages (mainly status updates)
+        async for message in websocket.iter_json():
+            print(f"🔍 DEBUG: Received message from slave {connection_id}: {message}")
+            await handle_slave_message(connection_id, robot_id, message)
+
+    except WebSocketDisconnect:
+        print(f"🔍 DEBUG: Slave {connection_id} disconnected normally")
+        logger.info(f"🔌 Slave disconnected: {connection_id}")
+    except Exception as e:
+        print(f"🔍 DEBUG: Slave {connection_id} connection error: {e}")
+        logger.error(f"❌ Slave connection error: {e}")
+    finally:
+        print(f"🔍 DEBUG: Cleaning up slave {connection_id}")
+        await connection_manager.disconnect_slave(connection_id)
+        await robot_manager.remove_slave_connection(robot_id, connection_id)
+
+
+# ============= MESSAGE HANDLERS =============
+
+
+async def handle_master_message(connection_id: str, robot_id: str, message: dict):
+    """Handle incoming messages from master connections"""
+    print(f"🔍 DEBUG: Received message from master {connection_id}: {message}")
+    try:
+        msg_type = message.get("type")
+        print(f"🔍 DEBUG: Message type: {msg_type}")
+
+        if msg_type == "command":
+            print("🔍 DEBUG: Processing command message")
+            # Forward command to all slaves
+            await broadcast_to_slaves(
+                robot_id,
+                {
+                    "type": "execute_command",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "data": message.get("data"),
+                },
+            )
+
+        elif msg_type == "sequence":
+            print("🔍 DEBUG: Processing sequence message")
+            # Forward sequence to all slaves
+            await broadcast_to_slaves(
+                robot_id,
+                {
+                    "type": "execute_sequence",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "data": message.get("data"),
+                },
+            )
+
+        elif msg_type == "start_control":
+            print("🔍 DEBUG: Processing start_control message")
+            # Handle start control message (acknowledge it)
+            master_ws = connection_manager.get_master_connection(robot_id)
+            if master_ws:
+                await master_ws.send_json({
+                    "type": "control_started",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "data": {"robot_id": robot_id},
+                })
+                print("🔍 DEBUG: Sent control_started acknowledgment")
+
+        elif msg_type == "stop_control":
+            print("🔍 DEBUG: Processing stop_control message")
+            # Handle stop control message
+
+        elif msg_type == "pause_control":
+            print("🔍 DEBUG: Processing pause_control message")
+            # Handle pause control message
+
+        elif msg_type == "resume_control":
+            print("🔍 DEBUG: Processing resume_control message")
+            # Handle resume control message
+
+        elif msg_type == "heartbeat":
+            print("🔍 DEBUG: Processing heartbeat message")
+            # Respond to heartbeat
+            master_ws = connection_manager.get_master_connection(robot_id)
+            if master_ws:
+                await master_ws.send_json({
+                    "type": "heartbeat_ack",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                })
+                print("🔍 DEBUG: Sent heartbeat_ack")
+
+        else:
+            print(f"🔍 DEBUG: Unknown message type: {msg_type}")
+            logger.warning(
+                f"Unknown message type from master {connection_id}: {msg_type}"
+            )
+
+    except Exception as e:
+        print(f"🔍 DEBUG: Error handling master message: {e}")
+        logger.error(f"Error handling master message: {e}")
+
+
+async def handle_slave_message(connection_id: str, robot_id: str, message: dict):
+    """Handle incoming messages from slave connections"""
+    print(f"🔍 DEBUG: Processing slave message from {connection_id}: {message}")
+    try:
+        msg_type = message.get("type")
+        print(f"🔍 DEBUG: Slave message type: {msg_type}")
+
+        if msg_type == "status_update":
+            print("🔍 DEBUG: Processing slave status_update")
+            # Forward status to master
+            await broadcast_to_master(
+                robot_id,
+                {
+                    "type": "slave_status",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "slave_id": connection_id,
+                    "data": message.get("data"),
+                },
+            )
+
+        elif msg_type == "joint_states":
+            print("🔍 DEBUG: Processing slave joint_states")
+            # Forward joint states to master
+            await broadcast_to_master(
+                robot_id,
+                {
+                    "type": "joint_states",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "slave_id": connection_id,
+                    "data": message.get("data"),
+                },
+            )
+
+        elif msg_type == "error":
+            print("🔍 DEBUG: Processing slave error")
+            # Forward error to master
+            await broadcast_to_master(
+                robot_id,
+                {
+                    "type": "slave_error",
+                    "timestamp": datetime.now(UTC).isoformat(),
+                    "slave_id": connection_id,
+                    "data": message.get("data"),
+                },
+            )
+
+        else:
+            print(f"🔍 DEBUG: Unknown slave message type: {msg_type}")
+            logger.warning(
+                f"Unknown message type from slave {connection_id}: {msg_type}"
+            )
+
+    except Exception as e:
+        print(f"🔍 DEBUG: Error handling slave message: {e}")
+        logger.error(f"Error handling slave message: {e}")
+
+
+# ============= UTILITY FUNCTIONS =============
+
+
+async def broadcast_to_slaves(robot_id: str, message: dict):
+    """Broadcast message to all slaves of a robot"""
+    slave_connections = connection_manager.get_slave_connections(robot_id)
+    print(f"🔍 DEBUG: Broadcasting to slaves for robot {robot_id}")
+    print(f"🔍 DEBUG: Found {len(slave_connections)} slave connections")
+    print(f"🔍 DEBUG: Message to broadcast: {message}")
+    if slave_connections:
+        logger.info(
+            f"📡 Broadcasting to {len(slave_connections)} slaves for robot {robot_id}"
+        )
+        results = await asyncio.gather(
+            *[ws.send_json(message) for ws in slave_connections], return_exceptions=True
+        )
+        print(f"🔍 DEBUG: Broadcast results: {results}")
+
+
+async def broadcast_to_master(robot_id: str, message: dict):
+    """Send message to master of a robot"""
+    master_ws = connection_manager.get_master_connection(robot_id)
+    print(f"🔍 DEBUG: Broadcasting to master for robot {robot_id}")
+    print(f"🔍 DEBUG: Master connection found: {master_ws is not None}")
+    print(f"🔍 DEBUG: Message to send: {message}")
+    if master_ws:
+        await master_ws.send_json(message)
+        print("🔍 DEBUG: Message sent to master successfully")
+
+
+async def sync_slave_with_current_state(robot_id: str, websocket: WebSocket):
+    """Send current robot state to newly connected slave"""
+    robot = robot_manager.get_robot(robot_id)
+    if robot:
+        await websocket.send_json({
+            "type": "sync_state",
+            "timestamp": datetime.now(UTC).isoformat(),
+            "data": robot.model_dump(mode="json"),
+        })
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    """Start the LeRobot Arena server"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+    logger = logging.getLogger("lerobot-arena")
+    logger.info("🚀 Starting LeRobot Arena WebSocket Server...")
+
+    # Start the server
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=8080,
+        log_level="info",
+        reload=False,  # Auto-reload on code changes
+    )

src-python/src/models.py

@@ -0,0 +1,191 @@
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Any, Literal
+from datetime import datetime
+from enum import Enum
+
+# ============= ROBOT COMMAND MODELS =============
+
+class JointUpdate(BaseModel):
+    name: str
+    value: float
+    speed: Optional[float] = None
+
+class RobotCommand(BaseModel):
+    timestamp: int
+    joints: List[JointUpdate]
+    duration: Optional[int] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+class CommandSequence(BaseModel):
+    id: str
+    name: str
+    commands: List[RobotCommand]
+    loop: Optional[bool] = False
+    total_duration: int
+
+# ============= COMMUNICATION MODELS =============
+
+class ControlMessage(BaseModel):
+    type: Literal["command", "sequence", "heartbeat", "status_request"]
+    timestamp: str
+    data: Optional[Dict[str, Any]] = None
+
+class StatusMessage(BaseModel):
+    type: Literal["status", "joint_states", "error", "heartbeat_ack", "slave_status"]
+    timestamp: str
+    slave_id: Optional[str] = None
+    data: Optional[Dict[str, Any]] = None
+
+# ============= ROBOT MODELS =============
+
+class JointLimits(BaseModel):
+    lower: Optional[float] = None
+    upper: Optional[float] = None
+    velocity: Optional[float] = None
+    effort: Optional[float] = None
+
+class DriverJointState(BaseModel):
+    name: str
+    servo_id: int
+    type: Literal["revolute", "continuous"]
+    virtual_value: float
+    real_value: Optional[float] = None
+    limits: Optional[JointLimits] = None
+
+class ConnectionStatus(BaseModel):
+    is_connected: bool
+    last_connected: Optional[datetime] = None
+    error: Optional[str] = None
+
+# ============= ROBOT MANAGEMENT =============
+
+class Robot(BaseModel):
+    id: str
+    name: str
+    robot_type: str
+    created_at: datetime
+    joints: List[DriverJointState] = []
+    
+    # Connection state
+    master_connected: bool = False
+    master_connection_id: Optional[str] = None
+    slave_connections: List[str] = []
+    
+    # Control state
+    last_command_source: Literal["master", "manual", "none"] = "none"
+    last_command_time: Optional[datetime] = None
+
+class RobotStatus(BaseModel):
+    robot_id: str
+    master_connected: bool
+    slave_count: int
+    last_command_source: str
+    last_command_time: Optional[datetime]
+    last_seen: datetime
+
+class CreateRobotRequest(BaseModel):
+    name: Optional[str] = None
+    robot_type: str = "so-arm100"
+
+# ============= DEMO SEQUENCES =============
+
+DEMO_SEQUENCES = [
+    CommandSequence(
+        id="gentle-wave",
+        name="Gentle Wave Pattern",
+        total_duration=6000,
+        commands=[
+            RobotCommand(
+                timestamp=0,
+                joints=[
+                    JointUpdate(name="Rotation", value=-10),
+                    JointUpdate(name="Pitch", value=8),
+                    JointUpdate(name="Elbow", value=-12)
+                ],
+                duration=2000
+            ),
+            RobotCommand(
+                timestamp=2000,
+                joints=[JointUpdate(name="Wrist_Roll", value=10)],
+                duration=1000
+            ),
+            RobotCommand(
+                timestamp=3000,
+                joints=[JointUpdate(name="Wrist_Roll", value=-10)],
+                duration=1000
+            ),
+            RobotCommand(
+                timestamp=4000,
+                joints=[
+                    JointUpdate(name="Wrist_Roll", value=0),
+                    JointUpdate(name="Rotation", value=0),
+                    JointUpdate(name="Pitch", value=0),
+                    JointUpdate(name="Elbow", value=0)
+                ],
+                duration=2000
+            )
+        ]
+    ),
+    CommandSequence(
+        id="small-scan",
+        name="Small Scanning Pattern",
+        total_duration=8000,
+        commands=[
+            RobotCommand(
+                timestamp=0,
+                joints=[
+                    JointUpdate(name="Rotation", value=-15),
+                    JointUpdate(name="Pitch", value=10)
+                ],
+                duration=2000
+            ),
+            RobotCommand(
+                timestamp=2000,
+                joints=[JointUpdate(name="Rotation", value=15)],
+                duration=3000
+            ),
+            RobotCommand(
+                timestamp=5000,
+                joints=[
+                    JointUpdate(name="Rotation", value=0),
+                    JointUpdate(name="Pitch", value=0)
+                ],
+                duration=3000
+            )
+        ]
+    ),
+    CommandSequence(
+        id="tiny-flex",
+        name="Tiny Flex Pattern",
+        total_duration=8000,
+        commands=[
+            RobotCommand(
+                timestamp=0,
+                joints=[
+                    JointUpdate(name="Elbow", value=-15),
+                    JointUpdate(name="Wrist_Pitch", value=8)
+                ],
+                duration=2000
+            ),
+            RobotCommand(
+                timestamp=2000,
+                joints=[JointUpdate(name="Jaw", value=8)],
+                duration=1000
+            ),
+            RobotCommand(
+                timestamp=3000,
+                joints=[JointUpdate(name="Elbow", value=-25)],
+                duration=2000
+            ),
+            RobotCommand(
+                timestamp=5000,
+                joints=[
+                    JointUpdate(name="Jaw", value=0),
+                    JointUpdate(name="Elbow", value=0),
+                    JointUpdate(name="Wrist_Pitch", value=0)
+                ],
+                duration=3000
+            )
+        ]
+    )
+] 

src-python/src/robot_manager.py

@@ -0,0 +1,168 @@
+from typing import Dict, Optional, List
+from datetime import datetime, timezone
+import logging
+
+from .models import Robot, RobotStatus, DriverJointState
+
+logger = logging.getLogger(__name__)
+
+class RobotManager:
+    """Manages robot lifecycle and state"""
+    
+    def __init__(self):
+        self.robots: Dict[str, Robot] = {}
+
+    async def create_robot(self, robot_id: str, robot_type: str, name: str) -> Robot:
+        """Create a new robot"""
+        if robot_id in self.robots:
+            raise ValueError(f"Robot {robot_id} already exists")
+        
+        # Create demo joint configuration for so-arm100
+        joints = self._create_demo_joints(robot_type)
+        
+        robot = Robot(
+            id=robot_id,
+            name=name,
+            robot_type=robot_type,
+            created_at=datetime.now(timezone.utc),
+            joints=joints
+        )
+        
+        self.robots[robot_id] = robot
+        logger.info(f"Created robot {robot_id} ({robot_type}) with {len(joints)} joints")
+        
+        return robot
+
+    def get_robot(self, robot_id: str) -> Optional[Robot]:
+        """Get robot by ID"""
+        return self.robots.get(robot_id)
+
+    async def delete_robot(self, robot_id: str):
+        """Delete a robot"""
+        if robot_id in self.robots:
+            del self.robots[robot_id]
+            logger.info(f"Deleted robot {robot_id}")
+
+    async def set_master_connected(self, robot_id: str, connection_id: str):
+        """Mark robot as having a master connection"""
+        robot = self.robots.get(robot_id)
+        if robot:
+            robot.master_connected = True
+            robot.master_connection_id = connection_id
+            robot.last_command_source = "master"
+            robot.last_command_time = datetime.now(timezone.utc)
+
+    async def set_master_disconnected(self, robot_id: str):
+        """Mark robot as having no master connection"""
+        robot = self.robots.get(robot_id)
+        if robot:
+            robot.master_connected = False
+            robot.master_connection_id = None
+            robot.last_command_source = "none"
+
+    async def add_slave_connection(self, robot_id: str, connection_id: str):
+        """Add a slave connection to robot"""
+        robot = self.robots.get(robot_id)
+        if robot:
+            if connection_id not in robot.slave_connections:
+                robot.slave_connections.append(connection_id)
+                logger.info(f"Added slave {connection_id} to robot {robot_id} ({len(robot.slave_connections)} total)")
+
+    async def remove_slave_connection(self, robot_id: str, connection_id: str):
+        """Remove a slave connection from robot"""
+        robot = self.robots.get(robot_id)
+        if robot:
+            try:
+                robot.slave_connections.remove(connection_id)
+                logger.info(f"Removed slave {connection_id} from robot {robot_id} ({len(robot.slave_connections)} remaining)")
+            except ValueError:
+                logger.warning(f"Slave {connection_id} not found in robot {robot_id} connections")
+
+    def get_robot_status(self, robot_id: str) -> Optional[RobotStatus]:
+        """Get robot connection status"""
+        robot = self.robots.get(robot_id)
+        if not robot:
+            return None
+        
+        return RobotStatus(
+            robot_id=robot_id,
+            master_connected=robot.master_connected,
+            slave_count=len(robot.slave_connections),
+            last_command_source=robot.last_command_source,
+            last_command_time=robot.last_command_time,
+            last_seen=datetime.now(timezone.utc)
+        )
+
+    def list_robots_with_masters(self) -> List[Robot]:
+        """Get all robots that have master connections"""
+        return [robot for robot in self.robots.values() if robot.master_connected]
+
+    def list_robots_with_slaves(self) -> List[Robot]:
+        """Get all robots that have slave connections"""
+        return [robot for robot in self.robots.values() if robot.slave_connections]
+
+    def _create_demo_joints(self, robot_type: str) -> List[DriverJointState]:
+        """Create demo joint configuration based on robot type"""
+        if robot_type == "so-arm100":
+            return [
+                DriverJointState(
+                    name="Rotation",
+                    servo_id=1,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="Pitch",
+                    servo_id=2,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="Elbow",
+                    servo_id=3,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="Wrist_Pitch",
+                    servo_id=4,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="Wrist_Roll",
+                    servo_id=5,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="Jaw",
+                    servo_id=6,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                )
+            ]
+        else:
+            # Default generic robot
+            return [
+                DriverJointState(
+                    name="joint_1",
+                    servo_id=1,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                ),
+                DriverJointState(
+                    name="joint_2",
+                    servo_id=2,
+                    type="revolute",
+                    virtual_value=0.0,
+                    real_value=0.0
+                )
+            ] 

src-python/start_server.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+LeRobot Arena WebSocket Server
+
+Run with: python start_server.py
+"""
+
+import uvicorn
+import logging
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+from src.main import app
+
+def main():
+    """Start the LeRobot Arena server"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    logger = logging.getLogger("lerobot-arena")
+    logger.info("🚀 Starting LeRobot Arena WebSocket Server...")
+    
+    # Start the server
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8080,
+        log_level="info",
+        reload=False  # Auto-reload on code changes
+    )
+
+if __name__ == "__main__":
+    main() 

src-python/uv.lock

@@ -0,0 +1,239 @@
+version = 1
+revision = 2
+requires-python = ">=3.12"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.115.12"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f4/55/ae499352d82338331ca1e28c7f4a63bfd09479b16395dce38cf50a39e2c2/fastapi-0.115.12.tar.gz", hash = "sha256:1e2c2a2646905f9e83d32f04a3f86aff4a286669c6c950ca95b5fd68c2602681", size = 295236, upload-time = "2025-03-23T22:55:43.822Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/50/b3/b51f09c2ba432a576fe63758bddc81f78f0c6309d9e5c10d194313bf021e/fastapi-0.115.12-py3-none-any.whl", hash = "sha256:e94613d6c05e27be7ffebdd6ea5f388112e5e430c8f7d6494a9d1d88d43e814d", size = 95164, upload-time = "2025-03-23T22:55:42.101Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },
+]
+
+[[package]]
+name = "lerobot-arena-server"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "uvicorn" },
+    { name = "websockets" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.115.12" },
+    { name = "uvicorn", specifier = ">=0.34.3" },
+    { name = "websockets", specifier = ">=15.0.1" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.11.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f0/86/8ce9040065e8f924d642c58e4a344e33163a07f6b57f836d0d734e0ad3fb/pydantic-2.11.5.tar.gz", hash = "sha256:7f853db3d0ce78ce8bbb148c401c2cdd6431b3473c0cdff2755c7690952a7b7a", size = 787102, upload-time = "2025-05-22T21:18:08.761Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/69/831ed22b38ff9b4b64b66569f0e5b7b97cf3638346eb95a2147fdb49ad5f/pydantic-2.11.5-py3-none-any.whl", hash = "sha256:f9c26ba06f9747749ca1e5c94d6a85cb84254577553c8785576fd38fa64dc0f7", size = 444229, upload-time = "2025-05-22T21:18:06.329Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.33.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },
+    { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },
+    { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },
+    { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" },
+    { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" },
+    { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" },
+    { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.46.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ce/20/08dfcd9c983f6a6f4a1000d934b9e6d626cff8d2eeb77a89a68eef20a2b7/starlette-0.46.2.tar.gz", hash = "sha256:7f7361f34eed179294600af672f565727419830b54b7b084efe44bb82d2fccd5", size = 2580846, upload-time = "2025-04-13T13:56:17.942Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/0c/9d30a4ebeb6db2b25a841afbb80f6ef9a854fc3b41be131d249a977b4959/starlette-0.46.2-py3-none-any.whl", hash = "sha256:595633ce89f8ffa71a015caed34a5b2dc1c0cdb3f0f1fbd1e69339cf2abeec35", size = 72037, upload-time = "2025-04-13T13:56:16.21Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.13.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967, upload-time = "2025-04-10T14:19:05.416Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806, upload-time = "2025-04-10T14:19:03.967Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.34.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/de/ad/713be230bcda622eaa35c28f0d328c3675c371238470abdea52417f17a8e/uvicorn-0.34.3.tar.gz", hash = "sha256:35919a9a979d7a59334b6b10e05d77c1d0d574c50e0fc98b8b1a0f165708b55a", size = 76631, upload-time = "2025-06-01T07:48:17.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/0d/8adfeaa62945f90d19ddc461c55f4a50c258af7662d34b6a3d5d1f8646f6/uvicorn-0.34.3-py3-none-any.whl", hash = "sha256:16246631db62bdfbf069b0645177d6e8a77ba950cfedbfd093acef9444e4d885", size = 62431, upload-time = "2025-06-01T07:48:15.664Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "15.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/21/e6/26d09fab466b7ca9c7737474c52be4f76a40301b08362eb2dbc19dcc16c1/websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee", size = 177016, upload-time = "2025-03-05T20:03:41.606Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/51/6b/4545a0d843594f5d0771e86463606a3988b5a09ca5123136f8a76580dd63/websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3", size = 175437, upload-time = "2025-03-05T20:02:16.706Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/71/809a0f5f6a06522af902e0f2ea2757f71ead94610010cf570ab5c98e99ed/websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665", size = 173096, upload-time = "2025-03-05T20:02:18.832Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/69/1a681dd6f02180916f116894181eab8b2e25b31e484c5d0eae637ec01f7c/websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2", size = 173332, upload-time = "2025-03-05T20:02:20.187Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/02/0073b3952f5bce97eafbb35757f8d0d54812b6174ed8dd952aa08429bcc3/websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215", size = 183152, upload-time = "2025-03-05T20:02:22.286Z" },
+    { url = "https://files.pythonhosted.org/packages/74/45/c205c8480eafd114b428284840da0b1be9ffd0e4f87338dc95dc6ff961a1/websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5", size = 182096, upload-time = "2025-03-05T20:02:24.368Z" },
+    { url = "https://files.pythonhosted.org/packages/14/8f/aa61f528fba38578ec553c145857a181384c72b98156f858ca5c8e82d9d3/websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65", size = 182523, upload-time = "2025-03-05T20:02:25.669Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/6d/0267396610add5bc0d0d3e77f546d4cd287200804fe02323797de77dbce9/websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe", size = 182790, upload-time = "2025-03-05T20:02:26.99Z" },
+    { url = "https://files.pythonhosted.org/packages/02/05/c68c5adbf679cf610ae2f74a9b871ae84564462955d991178f95a1ddb7dd/websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4", size = 182165, upload-time = "2025-03-05T20:02:30.291Z" },
+    { url = "https://files.pythonhosted.org/packages/29/93/bb672df7b2f5faac89761cb5fa34f5cec45a4026c383a4b5761c6cea5c16/websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597", size = 182160, upload-time = "2025-03-05T20:02:31.634Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/83/de1f7709376dc3ca9b7eeb4b9a07b4526b14876b6d372a4dc62312bebee0/websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9", size = 176395, upload-time = "2025-03-05T20:02:33.017Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/71/abf2ebc3bbfa40f391ce1428c7168fb20582d0ff57019b69ea20fa698043/websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7", size = 176841, upload-time = "2025-03-05T20:02:34.498Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/9f/51f0cf64471a9d2b4d0fc6c534f323b664e7095640c34562f5182e5a7195/websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931", size = 175440, upload-time = "2025-03-05T20:02:36.695Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/05/aa116ec9943c718905997412c5989f7ed671bc0188ee2ba89520e8765d7b/websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675", size = 173098, upload-time = "2025-03-05T20:02:37.985Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0b/33cef55ff24f2d92924923c99926dcce78e7bd922d649467f0eda8368923/websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151", size = 173329, upload-time = "2025-03-05T20:02:39.298Z" },
+    { url = "https://files.pythonhosted.org/packages/31/1d/063b25dcc01faa8fada1469bdf769de3768b7044eac9d41f734fd7b6ad6d/websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22", size = 183111, upload-time = "2025-03-05T20:02:40.595Z" },
+    { url = "https://files.pythonhosted.org/packages/93/53/9a87ee494a51bf63e4ec9241c1ccc4f7c2f45fff85d5bde2ff74fcb68b9e/websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f", size = 182054, upload-time = "2025-03-05T20:02:41.926Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b2/83a6ddf56cdcbad4e3d841fcc55d6ba7d19aeb89c50f24dd7e859ec0805f/websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8", size = 182496, upload-time = "2025-03-05T20:02:43.304Z" },
+    { url = "https://files.pythonhosted.org/packages/98/41/e7038944ed0abf34c45aa4635ba28136f06052e08fc2168520bb8b25149f/websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375", size = 182829, upload-time = "2025-03-05T20:02:48.812Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/17/de15b6158680c7623c6ef0db361da965ab25d813ae54fcfeae2e5b9ef910/websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d", size = 182217, upload-time = "2025-03-05T20:02:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/33/2b/1f168cb6041853eef0362fb9554c3824367c5560cbdaad89ac40f8c2edfc/websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4", size = 182195, upload-time = "2025-03-05T20:02:51.561Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/20b6cdf273913d0ad05a6a14aed4b9a85591c18a987a3d47f20fa13dcc47/websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa", size = 176393, upload-time = "2025-03-05T20:02:53.814Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6c/c65773d6cab416a64d191d6ee8a8b1c68a09970ea6909d16965d26bfed1e/websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561", size = 176837, upload-time = "2025-03-05T20:02:55.237Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
+]

src/app.css

@@ -0,0 +1 @@
+@import 'tailwindcss';

src/app.d.ts

@@ -0,0 +1,13 @@
+// See https://svelte.dev/docs/kit/types#app.d.ts
+// for information about these interfaces
+declare global {
+	namespace App {
+		// interface Error {}
+		// interface Locals {}
+		// interface PageData {}
+		// interface PageState {}
+		// interface Platform {}
+	}
+}
+
+export {};

src/app.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<link rel="icon" href="%sveltekit.assets%/favicon.png" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		%sveltekit.head%
+	</head>
+	<body data-sveltekit-preload-data="hover">
+		<div style="display: contents">%sveltekit.body%</div>
+	</body>
+</html>

src/lib/components/panel/ControlPanel.svelte

@@ -0,0 +1,60 @@
+<script lang="ts">
+    import { settings } from "$lib/configs/settings.svelte";
+    import RobotControlPanel from "./RobotControlPanel.svelte";
+
+    interface Props {}
+    
+    let {}: Props = $props();
+</script>
+
+<div class="space-y-6">
+    <!-- Robot Control Section -->
+    <RobotControlPanel />
+
+</div>
+
+<style>
+    .slider::-webkit-slider-thumb {
+        appearance: none;
+        height: 18px;
+        width: 18px;
+        border-radius: 50%;
+        background: #38bdf8; /* sky-400 */
+        cursor: pointer;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+        border: 2px solid #0f172a; /* slate-900 */
+    }
+    
+    .slider::-moz-range-thumb {
+        height: 18px;
+        width: 18px;
+        border-radius: 50%;
+        background: #38bdf8; /* sky-400 */
+        cursor: pointer;
+        border: 2px solid #0f172a; /* slate-900 */
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.3);
+    }
+    
+    .slider::-webkit-slider-track {
+        background: #475569; /* slate-600 */
+        border-radius: 4px;
+        height: 8px;
+    }
+    
+    .slider::-moz-range-track {
+        background: #475569; /* slate-600 */
+        border-radius: 4px;
+        height: 8px;
+        border: none;
+    }
+    
+    .slider:hover::-webkit-slider-thumb {
+        background: #0ea5e9; /* sky-500 */
+        transform: scale(1.1);
+    }
+    
+    .slider:hover::-moz-range-thumb {
+        background: #0ea5e9; /* sky-500 */
+        transform: scale(1.1);
+    }
+</style>

src/lib/components/panel/Panels.svelte

@@ -0,0 +1,78 @@
+<script lang="ts">
+	import ControlPanel from "./ControlPanel.svelte";
+	import SettingsPanel from "./SettingsPanel.svelte";
+
+	type Tab = 'controls' | 'settings';
+
+	interface Props {
+		activeTab?: Tab;
+		isOpen?: boolean;
+	}
+
+	let { activeTab = $bindable("controls"), isOpen = $bindable(false) }: Props = $props();
+</script>
+
+{#if isOpen}
+	<div class="absolute bottom-5 left-5 z-50">
+		<button
+			onclick={() => (isOpen = false)}
+			class="rounded bg-gray-700 px-3 py-1.5 text-sm text-white transition-colors hover:bg-gray-600"
+		>
+			Hide Controls
+		</button>
+	</div>
+{:else}
+	<div
+		class="absolute top-0 right-0 h-screen w-80 overflow-y-auto border-l border-slate-600 bg-gradient-to-b from-slate-700 to-slate-800 text-white shadow-2xl"
+	>
+		<div
+			class="flex flex-wrap items-center justify-between gap-2 border-b border-slate-600 bg-slate-700/80 p-6 backdrop-blur-sm"
+		>
+			<h2 class="m-0 text-xl font-semibold text-slate-100">Robot Controls</h2>
+			<div class="flex flex-wrap items-center gap-2">
+				<span class="rounded-xl bg-sky-400 px-3 py-1 text-sm font-medium text-slate-900"
+					>Robot</span
+				>
+			</div>
+			<button
+				onclick={() => (isOpen = true)}
+				class="ml-2 rounded-full px-2 text-xl transition-colors hover:bg-slate-800"
+				title="Collapse"
+			>
+				×
+			</button>
+		</div>
+
+		<!-- Tab Navigation (only show if custom URDF is enabled) -->
+		<div class="flex border-b border-slate-600">
+			<button
+				class="flex-1 cursor-pointer border-none bg-transparent px-4 py-3 text-sm text-slate-300 transition-all hover:bg-slate-700/50 {activeTab ===
+				'controls'
+					? 'border-b-2 border-sky-400 bg-sky-400/10 text-slate-100'
+					: ''}"
+				onclick={() => (activeTab = 'controls')}
+			>
+				Controls
+			</button>
+			<button
+				class="flex-1 cursor-pointer border-none bg-transparent px-4 py-3 text-sm text-slate-300 transition-all hover:bg-slate-700/50 {activeTab ===
+				'settings'
+					? 'border-b-2 border-sky-400 bg-sky-400/10 text-slate-100'
+					: ''}"
+				onclick={() => (activeTab = 'settings')}
+			>
+				Settings
+			</button>
+		</div>
+
+		<div class="p-4">
+			{#if activeTab === 'controls'}
+				<ControlPanel />
+			{:else if activeTab === 'settings'}
+				<SettingsPanel />
+			{/if}
+		</div>
+	</div>
+{/if}
+
+

src/lib/components/panel/RobotControlPanel.svelte

@@ -0,0 +1,649 @@
+<script lang="ts">
+    import { robotManager } from "$lib/robot/RobotManager.svelte";
+    import { robotUrdfConfigMap } from "$lib/configs/robotUrdfConfig";
+    import type { Robot } from "$lib/robot/Robot.svelte";
+
+    interface Props {}
+    
+    let {}: Props = $props();
+    
+    // Local state
+    let selectedRobotType = $state("so-arm100");
+    let isCreating = $state(false);
+    let error = $state<string | undefined>(undefined);
+
+    // Robot selection modal state
+    let showRobotSelectionModal = $state(false);
+    let availableServerRobots = $state<{ id: string; name: string; robot_type: string }[]>([]);
+    let selectedServerRobotId = $state<string>("");
+    let pendingLocalRobot: Robot | null = $state(null);
+
+    // Reactive values
+    const robots = $derived(robotManager.robots);
+    const robotsWithSlaves = $derived(robotManager.robotsWithSlaves.length);
+    const robotsWithMaster = $derived(robotManager.robotsWithMaster.length);
+
+    async function createRobot() {
+        if (isCreating) return;
+        
+        console.log('Creating robot...');
+        isCreating = true;
+        error = undefined;
+        
+        try {
+            const urdfConfig = robotUrdfConfigMap[selectedRobotType];
+            if (!urdfConfig) {
+                throw new Error(`Unknown robot type: ${selectedRobotType}`);
+            }
+            
+            const robotId = `robot-${Date.now()}`;
+            console.log('Creating robot with ID:', robotId, 'and config:', urdfConfig);
+            const robot = await robotManager.createRobot(robotId, urdfConfig);
+            console.log('Robot created successfully:', robot);
+            
+        } catch (err) {
+            error = `Failed to create robot: ${err}`;
+            console.error('Robot creation failed:', err);
+        } finally {
+            isCreating = false;
+        }
+    }
+
+    // Master connection functions
+    async function connectMockSequenceMaster(robot: Robot) {
+        try {
+            await robotManager.connectDemoSequences(robot.id, true);
+        } catch (err) {
+            error = `Failed to connect demo sequences: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function connectRemoteServerMaster(robot: Robot) {
+        try {
+            const config: import('$lib/types/robotDriver').MasterDriverConfig = {
+                type: "remote-server",
+                url: "ws://localhost:8080",
+                apiKey: undefined,
+                pollInterval: 100
+            };
+            await robotManager.connectMaster(robot.id, config);
+        } catch (err) {
+            error = `Failed to connect remote server: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function disconnectMaster(robot: Robot) {
+        try {
+            await robotManager.disconnectMaster(robot.id);
+        } catch (err) {
+            error = `Failed to disconnect master: ${err}`;
+            console.error(err);
+        }
+    }
+
+    // Slave connection functions
+    async function connectMockSlave(robot: Robot) {
+        try {
+            await robotManager.connectMockSlave(robot.id, 50);
+        } catch (err) {
+            error = `Failed to connect mock slave: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function connectUSBSlave(robot: Robot) {
+        try {
+            await robotManager.connectUSBSlave(robot.id);
+        } catch (err) {
+            error = `Failed to connect USB slave: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function connectRemoteServerSlave(robot: Robot) {
+        try {
+            // First, fetch available robots from the server
+            const serverUrl = "http://localhost:8080";
+            const response = await fetch(`${serverUrl}/api/robots`);
+            
+            if (!response.ok) {
+                throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
+            }
+            
+            const robots = await response.json();
+            
+            if (robots.length === 0) {
+                error = "No robots available on the server. Create a robot on the server first.";
+                return;
+            }
+            
+            // Show modal for robot selection
+            availableServerRobots = robots;
+            pendingLocalRobot = robot;
+            selectedServerRobotId = robots[0]?.id || "";
+            showRobotSelectionModal = true;
+            
+        } catch (err) {
+            error = `Failed to fetch server robots: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function confirmRobotSelection() {
+        if (!pendingLocalRobot || !selectedServerRobotId) return;
+        
+        try {
+            await robotManager.connectRemoteServerSlave(
+                pendingLocalRobot.id, 
+                "ws://localhost:8080", 
+                undefined, 
+                selectedServerRobotId
+            );
+            
+            // Close modal
+            showRobotSelectionModal = false;
+            pendingLocalRobot = null;
+            
+        } catch (err) {
+            error = `Failed to connect remote server slave: ${err}`;
+            console.error(err);
+        }
+    }
+
+    function cancelRobotSelection() {
+        showRobotSelectionModal = false;
+        pendingLocalRobot = null;
+        selectedServerRobotId = "";
+    }
+
+    async function disconnectSlave(robot: Robot, slaveId: string) {
+        try {
+            await robotManager.disconnectSlave(robot.id, slaveId);
+        } catch (err) {
+            error = `Failed to disconnect slave: ${err}`;
+            console.error(err);
+        }
+    }
+
+    // Robot management
+    async function calibrateRobot(robot: Robot) {
+        try {
+            await robot.calibrateRobot();
+        } catch (err) {
+            error = `Failed to calibrate: ${err}`;
+            console.error(err);
+        }
+    }
+
+    async function moveToRest(robot: Robot) {
+        try {
+            await robot.moveToRestPosition();
+        } catch (err) {
+            error = `Failed to move to rest: ${err}`;
+            console.error(err);
+        }
+    }
+
+    function clearCalibration(robot: Robot) {
+        robot.clearCalibration();
+    }
+
+    async function removeRobot(robot: Robot) {
+        try {
+            await robotManager.removeRobot(robot.id);
+        } catch (err) {
+            error = `Failed to remove robot: ${err}`;
+            console.error(err);
+        }
+    }
+
+    function clearError() {
+        error = undefined;
+    }
+
+    // Helper functions
+    function getConnectionStatusText(robot: Robot): string {
+        const hasActiveMaster = robot.controlState.hasActiveMaster;
+        const connectedSlaves = robot.connectedSlaves.length;
+        const totalSlaves = robot.slaves.length;
+        
+        if (hasActiveMaster && connectedSlaves > 0) {
+            return `Master + ${connectedSlaves}/${totalSlaves} Slaves`;
+        } else if (hasActiveMaster) {
+            return `Master Only`;
+        } else if (connectedSlaves > 0) {
+            return `${connectedSlaves}/${totalSlaves} Slaves`;
+        } else {
+            return "Manual Control";
+        }
+    }
+
+    function getConnectionStatusColor(robot: Robot): string {
+        const hasActiveMaster = robot.controlState.hasActiveMaster;
+        const connectedSlaves = robot.connectedSlaves.length;
+        
+        if (hasActiveMaster && connectedSlaves > 0) {
+            return "green";  // Full master-slave setup
+        } else if (hasActiveMaster || connectedSlaves > 0) {
+            return "yellow"; // Partial connection
+        } else {
+            return "red";    // No connections
+        }
+    }
+
+    async function connectUSBMaster(robot: Robot) {
+        try {
+            await robotManager.connectUSBMaster(robot.id, {
+                pollInterval: 200,
+                smoothing: true
+            });
+        } catch (err) {
+            error = `Failed to connect USB master: ${err}`;
+            console.error(err);
+        }
+    }
+</script>
+
+<div class="space-y-6 p-4">
+    <div class="flex items-center justify-between">
+        <h2 class="text-xl font-bold text-slate-100">Robot Control - Master/Slave Architecture</h2>
+        <div class="text-sm text-slate-400">
+            {robots.length} robots, {robotsWithMaster} with masters, {robotsWithSlaves} with slaves
+        </div>
+    </div>
+
+    <!-- Error Display -->
+    {#if error}
+        <div class="bg-red-500/20 border border-red-500 rounded-lg p-3 flex items-center justify-between">
+            <span class="text-red-200 text-sm">{error}</span>
+            <button 
+                onclick={clearError}
+                class="text-red-200 hover:text-white"
+            >×</button>
+        </div>
+    {/if}
+
+    <!-- Create Robot Section -->
+    <div class="bg-slate-800 rounded-lg p-4 space-y-4">
+        <h3 class="text-lg font-semibold text-slate-100">Create Robot</h3>
+        
+        <div class="flex gap-3">
+            <select 
+                bind:value={selectedRobotType}
+                class="flex-1 px-3 py-2 bg-slate-700 border border-slate-600 rounded-md text-slate-100"
+            >
+                {#each Object.keys(robotUrdfConfigMap) as robotType}
+                    <option value={robotType}>{robotType}</option>
+                {/each}
+            </select>
+            
+            <button 
+                onclick={createRobot}
+                disabled={isCreating}
+                class="px-4 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-slate-600 disabled:cursor-not-allowed text-white rounded-md transition-colors"
+            >
+                {isCreating ? "Creating..." : "Create Robot"}
+            </button>
+        </div>
+    </div>
+
+    <!-- Robots List -->
+    <div class="space-y-3">
+        {#each robots as robot (robot.id)}
+            <div class="bg-slate-800 rounded-lg p-4">
+                <div class="flex items-center justify-between mb-3">
+                    <div>
+                        <h4 class="font-semibold text-slate-100">{robot.id}</h4>
+                        <div class="text-sm text-slate-400">
+                            Status: 
+                            <span class="text-{getConnectionStatusColor(robot)}-400">
+                                {getConnectionStatusText(robot)}
+                            </span>
+                            {#if robot.controlState.lastCommandSource !== "none"}
+                                <span class="text-blue-400 ml-2">• Last: {robot.controlState.lastCommandSource}</span>
+                            {/if}
+                            {#if robot.isCalibrated}
+                                <span class="text-green-400 ml-2">• Calibrated</span>
+                            {/if}
+                        </div>
+                    </div>
+                    
+                    <button 
+                        onclick={() => removeRobot(robot)}
+                        class="px-3 py-1 bg-red-600 hover:bg-red-700 text-white text-sm rounded transition-colors"
+                    >
+                        Remove
+                    </button>
+                </div>
+
+                <!-- Master Controls -->
+                <div class="mb-4 p-3 bg-orange-500/10 border border-orange-500/30 rounded-lg">
+                    <div class="text-sm text-orange-200 mb-2">
+                        <strong>Masters (Control Sources)</strong>
+                        {#if robot.controlState.hasActiveMaster}
+                            - <span class="text-green-400">Connected: {robot.controlState.masterName}</span>
+                        {:else}
+                            - <span class="text-slate-400">None Connected</span>
+                        {/if}
+                    </div>
+                    
+                    <div class="flex flex-wrap gap-2">
+                        <button
+                            class="px-3 py-1.5 bg-orange-500 text-white rounded text-sm hover:bg-orange-600 transition-colors disabled:bg-slate-600 disabled:cursor-not-allowed"
+                            onclick={() => connectMockSequenceMaster(robot)}
+                            disabled={robot.controlState.hasActiveMaster}
+                        >
+                            Demo Sequences
+                        </button>
+                        
+                        <button
+                            class="px-3 py-1.5 bg-purple-500 text-white rounded text-sm hover:bg-purple-600 transition-colors disabled:bg-slate-600 disabled:cursor-not-allowed"
+                            onclick={() => connectRemoteServerMaster(robot)}
+                            disabled={robot.controlState.hasActiveMaster}
+                        >
+                            Connect Remote Server
+                        </button>
+
+                        <button
+                            class="px-3 py-1.5 bg-blue-500 text-white rounded text-sm hover:bg-blue-600 transition-colors disabled:bg-slate-600 disabled:cursor-not-allowed"
+                            onclick={() => connectUSBMaster(robot)}
+                            disabled={robot.controlState.hasActiveMaster}
+                        >
+                            Connect USB Master
+                        </button>
+                        
+                        {#if robot.controlState.hasActiveMaster}
+                            <button
+                                class="px-3 py-1.5 bg-red-500 text-white rounded text-sm hover:bg-red-600 transition-colors"
+                                onclick={() => disconnectMaster(robot)}
+                            >
+                                Disconnect Master
+                            </button>
+                        {/if}
+                    </div>
+                </div>
+
+                <!-- Slave Controls -->
+                <div class="mb-4 p-3 bg-blue-500/10 border border-blue-500/30 rounded-lg">
+                    <div class="text-sm text-blue-200 mb-2">
+                        <strong>Slaves (Execution Targets)</strong>
+                        - <span class="text-green-400">{robot.connectedSlaves.length} Connected</span>
+                        / <span class="text-slate-400">{robot.slaves.length} Total</span>
+                    </div>
+                    
+                    <div class="flex gap-2 mb-2">
+                        <button 
+                            onclick={() => connectMockSlave(robot)}
+                            class="px-3 py-1 bg-yellow-600 hover:bg-yellow-700 text-white text-sm rounded transition-colors"
+                        >
+                            Add Mock Slave
+                        </button>
+                        <button 
+                            onclick={() => connectUSBSlave(robot)}
+                            class="px-3 py-1 bg-green-600 hover:bg-green-700 text-white text-sm rounded transition-colors"
+                        >
+                            Add USB Slave
+                        </button>
+                        <button 
+                            onclick={() => connectRemoteServerSlave(robot)}
+                            class="px-3 py-1 bg-purple-600 hover:bg-purple-700 text-white text-sm rounded transition-colors"
+                        >
+                            Add Remote Server Slave
+                        </button>
+                    </div>
+                    
+                    {#if robot.slaves.length > 0}
+                        <div class="text-xs text-blue-300">
+                            <strong>Connected Slaves:</strong>
+                            {#each robot.slaves as slave}
+                                <div class="flex items-center justify-between mt-1">
+                                    <span>{slave.name} ({slave.id})</span>
+                                    <button 
+                                        onclick={() => disconnectSlave(robot, slave.id)}
+                                        class="px-2 py-1 bg-red-500 hover:bg-red-600 text-white text-xs rounded"
+                                    >
+                                        Remove
+                                    </button>
+                                </div>
+                            {/each}
+                        </div>
+                    {/if}
+                </div>
+
+                <!-- Calibration Section (for USB slaves) -->
+                {#if robot.connectedSlaves.some(slave => slave.name.includes("USB"))}
+                    <div class="mb-3 p-3 bg-orange-500/10 border border-orange-500/30 rounded-lg">
+                        <div class="text-sm text-orange-200 mb-2">
+                            <strong>USB Robot Calibration</strong>
+                        </div>
+                        {#if !robot.isCalibrated}
+                            <div class="text-xs text-orange-300 mb-2">
+                                1. Manually position your robot to match the digital twin's rest pose<br>
+                                2. Click "Calibrate" when positioned correctly
+                            </div>
+                            <div class="flex gap-2">
+                                <button 
+                                    onclick={() => moveToRest(robot)}
+                                    class="px-3 py-1 bg-blue-600 hover:bg-blue-700 text-white text-sm rounded transition-colors"
+                                >
+                                    Show Rest Pose
+                                </button>
+                                <button 
+                                    onclick={() => calibrateRobot(robot)}
+                                    class="px-3 py-1 bg-green-600 hover:bg-green-700 text-white text-sm rounded transition-colors"
+                                >
+                                    Calibrate
+                                </button>
+                            </div>
+                        {:else}
+                            <div class="text-xs text-green-300 mb-2">
+                                ✓ Robot calibrated at {robot.calibrationState.calibrationTime?.toLocaleTimeString()}
+                            </div>
+                            <button 
+                                onclick={() => clearCalibration(robot)}
+                                class="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white text-sm rounded transition-colors"
+                            >
+                                Clear Calibration
+                            </button>
+                        {/if}
+                    </div>
+                {/if}
+
+                <!-- Manual Joint Controls (only when no master) -->
+                {#if robot.manualControlEnabled}
+                    <div class="space-y-3">
+                        <h5 class="text-sm font-medium text-slate-300">Manual Control ({robot.activeJoints.length} active joints)</h5>
+                        {#each robot.activeJoints as joint}
+                            <div class="joint-control">
+                                <div class="joint-header">
+                                    <span class="joint-name">{joint.name}</span>
+                                    <div class="joint-values">
+                                        <span class="virtual-value">{joint.virtualValue.toFixed(0)}°</span>
+                                        {#if joint.realValue !== undefined}
+                                            <span class="real-value" title="Real robot position">
+                                                Real: {joint.realValue.toFixed(0)}°
+                                            </span>
+                                        {:else}
+                                            <span class="real-value disconnected">N/A</span>
+                                        {/if}
+                                    </div>
+                                </div>
+                                <input 
+                                    type="range"
+                                    min="-180"
+                                    max="180"
+                                    step="1"
+                                    value={joint.virtualValue}
+                                    oninput={(e) => {
+                                        const target = e.target as HTMLInputElement;
+                                        robot.updateJointValue(joint.name, parseFloat(target.value));
+                                    }}
+                                    class="joint-slider"
+                                />
+                            </div>
+                        {/each}
+                        
+                        {#if robot.activeJoints.length === 0}
+                            <div class="text-sm text-slate-500 italic">No active joints</div>
+                        {/if}
+                    </div>
+                {:else}
+                    <div class="p-3 bg-purple-500/10 border border-purple-500/30 rounded-lg">
+                        <div class="text-sm text-purple-200">
+                            🎮 <strong>Master Control Active</strong><br>
+                            <span class="text-xs text-purple-300">
+                                Robot is controlled by: {robot.controlState.masterName}<br>
+                                Manual controls are disabled. Disconnect master to regain manual control.
+                            </span>
+                        </div>
+                    </div>
+                {/if}
+            </div>
+        {/each}
+        
+        {#if robots.length === 0}
+            <div class="text-center text-slate-500 py-8">
+                No robots created yet. Create one above to get started with the master-slave architecture.
+            </div>
+        {/if}
+    </div>
+</div>
+
+<!-- Robot Selection Modal -->
+{#if showRobotSelectionModal}
+    <div class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+        <div class="bg-slate-800 rounded-lg p-6 w-96 max-w-full mx-4">
+            <h3 class="text-lg font-semibold text-slate-100 mb-4">Select Server Robot</h3>
+            
+            <div class="mb-4">
+                <label class="block text-sm font-medium text-slate-300 mb-2">
+                    Available robots on server:
+                </label>
+                <select 
+                    bind:value={selectedServerRobotId}
+                    class="w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded-md text-slate-100"
+                >
+                    {#each availableServerRobots as serverRobot}
+                        <option value={serverRobot.id}>
+                            {serverRobot.name} ({serverRobot.id}) - {serverRobot.robot_type}
+                        </option>
+                    {/each}
+                </select>
+            </div>
+            
+            <div class="text-sm text-slate-400 mb-4">
+                This will connect your local robot "{pendingLocalRobot?.id}" as a slave to 
+                receive commands from the selected server robot.
+            </div>
+            
+            <div class="flex gap-3 justify-end">
+                <button 
+                    onclick={cancelRobotSelection}
+                    class="px-4 py-2 bg-slate-600 hover:bg-slate-700 text-white rounded-md transition-colors"
+                >
+                    Cancel
+                </button>
+                <button 
+                    onclick={confirmRobotSelection}
+                    class="px-4 py-2 bg-purple-600 hover:bg-purple-700 text-white rounded-md transition-colors"
+                    disabled={!selectedServerRobotId}
+                >
+                    Connect Slave
+                </button>
+            </div>
+        </div>
+    </div>
+{/if}
+
+<style>
+    .joint-control {
+        background: rgba(71, 85, 105, 0.3);
+        border-radius: 8px;
+        padding: 12px;
+        border: 1px solid rgba(71, 85, 105, 0.5);
+    }
+
+    .joint-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 8px;
+    }
+
+    .joint-name {
+        font-weight: 500;
+        color: #e2e8f0;
+        font-size: 14px;
+    }
+
+    .joint-values {
+        display: flex;
+        gap: 12px;
+        font-size: 12px;
+    }
+
+    .virtual-value {
+        color: #60a5fa;
+        font-weight: 500;
+    }
+
+    .real-value {
+        color: #34d399;
+        font-weight: 500;
+    }
+
+    .real-value.disconnected {
+        color: #f87171;
+    }
+
+    .joint-slider {
+        width: 100%;
+        height: 6px;
+        background: #374151;
+        border-radius: 3px;
+        outline: none;
+        cursor: pointer;
+        appearance: none;
+    }
+
+    .joint-slider::-webkit-slider-thumb {
+        appearance: none;
+        width: 18px;
+        height: 18px;
+        border-radius: 50%;
+        background: #3b82f6;
+        cursor: pointer;
+        border: 2px solid #1e293b;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+        transition: all 0.15s ease;
+    }
+
+    .joint-slider::-webkit-slider-thumb:hover {
+        background: #2563eb;
+        transform: scale(1.1);
+    }
+
+    .joint-slider::-moz-range-thumb {
+        width: 18px;
+        height: 18px;
+        border-radius: 50%;
+        background: #3b82f6;
+        cursor: pointer;
+        border: 2px solid #1e293b;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+        transition: all 0.15s ease;
+    }
+
+    .joint-slider::-moz-range-track {
+        height: 6px;
+        background: #374151;
+        border-radius: 3px;
+        border: none;
+    }
+
+    .joint-slider:focus {
+        box-shadow: 0 0 0 2px rgba(59, 130, 246, 0.5);
+    }
+</style> 

src/lib/components/panel/SettingsPanel.svelte

@@ -0,0 +1,248 @@
+<script lang="ts">
+    import { environment } from '$lib/runes/env.svelte';
+	import type IUrdfJoint from '$lib/components/scene/robot/URDF/interfaces/IUrdfJoint';
+
+    interface Props {}
+    
+    let {}: Props = $props();
+    
+    // Helper function to get all robots
+    const robots = $derived(Object.entries(environment.robots));
+    
+    // Helper function to convert degrees to radians
+    function degreesToRadians(degrees: number): number {
+        return degrees * (Math.PI / 180);
+    }
+    
+    // Helper function to convert radians to degrees
+    function radiansToDegrees(radians: number): number {
+        return radians * (180 / Math.PI);
+    }
+    
+    // Helper function to get current joint rotation value in degrees
+    function getJointRotationValue(joint: any): number {
+        const axis = joint.axis_xyz || [0, 0, 1];
+        const rotation = joint.rotation || [0, 0, 0];
+        
+        // Find the primary axis and get the rotation value
+        for (let i = 0; i < 3; i++) {
+            if (Math.abs(axis[i]) > 0.001) {
+                return radiansToDegrees(rotation[i] / axis[i]);
+            }
+        }
+        return 0;
+    }
+    
+    // Helper function to update joint rotation using axis
+    function updateJointRotation(robotId: string, jointIndex: number, degrees: number): void {
+        const robot = environment.robots[robotId];
+        if (!robot?.robot.joints[jointIndex]) return;
+        
+        const joint = robot.robot.joints[jointIndex];
+        const radians = degreesToRadians(degrees);
+        const axis = joint.axis_xyz || [0, 0, 1];
+        
+        // Calculate rotation based on axis
+        joint.rotation = [
+            radians * axis[0],
+            radians * axis[1],
+            radians * axis[2]
+        ];
+    }
+    
+    // Helper function to get joint limits
+    function getJointLimits(joint: IUrdfJoint): { min: number; max: number } {
+        if (joint.limit) {
+            return {
+                min: joint.limit.lower ? radiansToDegrees(joint.limit.lower) : -180,
+                max: joint.limit.upper ? radiansToDegrees(joint.limit.upper) : 180
+            };
+        }
+        return joint.type === 'continuous' ? { min: -360, max: 360 } : { min: -180, max: 180 };
+    }
+</script>
+
+<div class="space-y-6">
+    <h3 class="text-lg font-semibold text-slate-100 mb-4">Robot Joint Settings</h3>
+    
+    {#if robots.length === 0}
+        <div class="text-slate-400 text-sm">
+            No robots in the environment. Create a robot first using the Control Panel.
+        </div>
+    {:else}
+        {#each robots as [robotId, robotState]}
+            <div class="space-y-4 p-4 bg-slate-700/50 rounded-lg border border-slate-600">
+                <h4 class="text-md font-medium text-slate-200 border-b border-slate-600 pb-2">
+                    Robot: <span class="text-sky-400">{robotId.slice(0, 8)}...</span>
+                </h4>
+                
+                {#if robotState.robot.joints.length === 0}
+                    <div class="text-slate-400 text-sm">No joints found for this robot.</div>
+                {:else}
+                    <div class="text-slate-400 text-sm">
+                        Joints:
+                    </div>
+                    <div class="space-y-4">
+                        {#each robotState.robot.joints as joint, jointIndex}
+                            {#if joint.type === 'revolute'}
+                                {@const currentValue = getJointRotationValue(joint)}
+                                {@const limits = getJointLimits(joint)}
+                                {@const axis = joint.axis_xyz || [0, 0, 1]}
+                                
+                                <div class="space-y-3 p-3 bg-slate-800/50 rounded border border-slate-600">
+                                    <div class="flex justify-between items-start">
+                                        <div>
+                                            <h5 class="text-sm font-medium text-slate-300">
+                                                <span class="text-yellow-400">{joint.name || `Joint ${jointIndex}`}</span>
+                                                <span class="text-xs text-slate-400 ml-2">({joint.type})</span>
+                                            </h5>
+                                            <div class="text-xs text-slate-500 mt-1">
+                                                Axis: [{axis[0].toFixed(1)}, {axis[1].toFixed(1)}, {axis[2].toFixed(1)}]
+                                            </div>
+                                        </div>
+                                        <div class="text-right">
+                                            <div class="text-sky-400 font-mono text-sm">{currentValue.toFixed(1)}°</div>
+                                            <div class="text-xs text-slate-500">
+                                                {limits.min.toFixed(0)}° to {limits.max.toFixed(0)}°
+                                            </div>
+                                        </div>
+                                    </div>
+                                    
+                                    <!-- Single Rotation Control -->
+                                    <div class="space-y-2">
+                                        <input 
+                                            type="range" 
+                                            min={limits.min} 
+                                            max={limits.max} 
+                                            step="1"
+                                            value={currentValue}
+                                            oninput={(e) => updateJointRotation(robotId, jointIndex, parseFloat(e.currentTarget.value))}
+                                            class="w-full h-2 bg-slate-600 rounded-lg appearance-none cursor-pointer slider"
+                                        />
+                                    </div>
+                                    
+                                    <!-- Reset Joint Button -->
+                                    <button 
+                                        onclick={() => updateJointRotation(robotId, jointIndex, 0)}
+                                        class="text-xs px-3 py-1 bg-slate-600 hover:bg-slate-500 text-slate-200 rounded transition-colors"
+                                    >
+                                        Reset to 0°
+                                    </button>
+                                </div>
+                            {:else if joint.type === 'continuous'}
+                                {@const currentValue = getJointRotationValue(joint)}
+                                {@const limits = getJointLimits(joint)}
+                                {@const axis = joint.axis_xyz || [0, 0, 1]}
+                                <div class="space-y-3 p-3 bg-slate-800/50 rounded border border-slate-600">
+                                    <div class="flex justify-between items-start">
+                                        <div>
+                                            <h5 class="text-sm font-medium text-slate-300">
+                                                <span class="text-yellow-400">{joint.name || `Joint ${jointIndex}`}</span>
+                                                <span class="text-xs text-slate-400 ml-2">({joint.type})</span>
+                                            </h5>
+                                            <div class="text-xs text-slate-500 mt-1">
+                                                Axis: [{axis[0].toFixed(1)}, {axis[1].toFixed(1)}, {axis[2].toFixed(1)}]
+                                            </div>
+                                        </div>
+                                        <div class="text-right">
+                                            <div class="text-sky-400 font-mono text-sm">{currentValue.toFixed(1)}°</div>
+                                            <div class="text-xs text-slate-500">
+                                                {limits.min.toFixed(0)}° to {limits.max.toFixed(0)}°
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            {:else if joint.type === 'fixed'}
+                                <div class="p-2 bg-slate-800/30 rounded border border-slate-700">
+                                    <div class="text-xs text-slate-500">
+                                        <span class="text-slate-400">{joint.name || `Joint ${jointIndex}`}</span>
+                                        <span class="ml-2">(fixed joint)</span>
+                                    </div>
+                                </div>
+                            {/if}
+                        {/each}
+                    </div>
+                    {#if robotState.urdfConfig.compoundMovements}
+                        <div class="text-slate-400 text-sm">
+                            Compound Movements:
+                        </div>
+                        <div class="space-y-4">
+                        {#each robotState.urdfConfig.compoundMovements as movement}
+                            <div class="text-slate-400 text-sm">
+                                {movement.name}
+                                {#each movement.dependents as dependent}
+                                    <div class="text-slate-400 text-sm">
+                                        {dependent.joint}
+                                    </div>
+                                {/each}
+                            </div>
+                        {/each}
+                        </div>
+                    {/if}
+                {/if}
+                
+                <!-- Reset All Joints Button -->
+                <button 
+                    onclick={() => {
+                        robotState.robot.joints.forEach((joint, index) => {
+                            if (joint.type === 'revolute') {
+                                updateJointRotation(robotId, index, 0);
+                            } else if (joint.type === 'continuous') {
+                                updateJointRotation(robotId, index, 0);
+                            }
+                        });
+                    }}
+                    class="w-full px-3 py-2 bg-sky-600 hover:bg-sky-500 text-white rounded transition-colors text-sm font-medium"
+                >
+                    Reset All Joints to 0°
+                </button>
+            </div>
+        {/each}
+    {/if}
+</div>
+
+<style>
+    .slider::-webkit-slider-thumb {
+        appearance: none;
+        height: 16px;
+        width: 16px;
+        border-radius: 50%;
+        background: #38bdf8; /* sky-400 */
+        cursor: pointer;
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+        border: 2px solid #0f172a; /* slate-900 */
+    }
+    
+    .slider::-moz-range-thumb {
+        height: 16px;
+        width: 16px;
+        border-radius: 50%;
+        background: #38bdf8; /* sky-400 */
+        cursor: pointer;
+        border: 2px solid #0f172a; /* slate-900 */
+        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.3);
+    }
+    
+    .slider::-webkit-slider-track {
+        background: #475569; /* slate-600 */
+        border-radius: 4px;
+        height: 8px;
+    }
+    
+    .slider::-moz-range-track {
+        background: #475569; /* slate-600 */
+        border-radius: 4px;
+        height: 8px;
+        border: none;
+    }
+    
+    .slider:hover::-webkit-slider-thumb {
+        background: #0ea5e9; /* sky-500 */
+        transform: scale(1.05);
+    }
+    
+    .slider:hover::-moz-range-thumb {
+        background: #0ea5e9; /* sky-500 */
+        transform: scale(1.05);
+    }
+</style>

src/lib/components/scene/Floor.svelte

@@ -0,0 +1,56 @@
+<script lang="ts">
+	import { T } from '@threlte/core';
+	import * as THREE from 'three';
+
+	/**
+	 * Creates a grid texture for the ground plane
+	 * Matches the original React implementation for visual consistency
+	 */
+	function createGridTexture(): THREE.CanvasTexture {
+		const size = 200;
+		const canvas = document.createElement('canvas');
+		canvas.width = canvas.height = size;
+		const ctx = canvas.getContext('2d');
+
+		if (ctx) {
+			// Base color
+			ctx.fillStyle = '#aaa';
+			ctx.fillRect(0, 0, size, size);
+
+			// Grid lines
+			ctx.strokeStyle = '#707070';
+			ctx.lineWidth = 8;
+			ctx.beginPath();
+			ctx.moveTo(0, 0);
+			ctx.lineTo(0, size);
+			ctx.lineTo(size, size);
+			ctx.lineTo(size, 0);
+			ctx.closePath();
+			ctx.stroke();
+		}
+
+		const texture = new THREE.CanvasTexture(canvas);
+		texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+		texture.repeat.set(100, 100);
+		return texture;
+	}
+
+	// Create texture reactively using Svelte 5 runes
+	const gridTexture = createGridTexture();
+</script>
+
+<!-- Ground plane with grid texture matching React version -->
+<T.Mesh rotation={[-Math.PI / 2, 0, 0]} receiveShadow>
+	<T.PlaneGeometry args={[30, 30]} />
+	<T.MeshPhysicalMaterial
+		color={0x808080}
+		metalness={0.7}
+		roughness={0.3}
+		reflectivity={0.1}
+		clearcoat={0.3}
+		side={THREE.DoubleSide}
+		transparent
+		opacity={0.7}
+		map={gridTexture}
+	/>
+</T.Mesh>

src/lib/components/scene/Robot.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+	import { T } from '@threlte/core';
+	import { getRootLinks } from '$lib/components/scene/robot/URDF/utils/UrdfParser';
+	import UrdfLink from '$lib/components/scene/robot/URDF/primitives/UrdfLink.svelte';
+	import { robotManager } from '$lib/robot/RobotManager.svelte';
+
+	interface Props {}
+
+	let {}: Props = $props();
+
+	// Get all robots from the manager
+	const robots = $derived(robotManager.robots);
+</script>
+
+{#each robots as robot, index (robot.id)}
+	{@const xPosition = index * 5} <!-- Space robots 5 units apart -->
+	<T.Group position.x={xPosition} position.y={0} position.z={0} quaternion={[0, 0, 0, 1]} scale={[10, 10, 10]} rotation={[-Math.PI / 2, 0, 0]}>
+		{#each getRootLinks(robot.robotState.robot) as link}
+			<UrdfLink
+				robot={robot.robotState.robot}
+				{link}
+				textScale={0.2}
+				showName={true}
+				showVisual={true}
+				showCollision={false}
+				visualColor="#333333"
+				visualOpacity={0.7}
+				collisionOpacity={0.7}
+				collisionColor="#813d9c"
+				jointNames={true}
+				joints={true}
+				jointColor="#62a0ea"
+				jointIndicatorColor="#f66151"
+				nameHeight={0.1}
+				selectedLink={robot.robotState.selection.selectedLink}
+				selectedJoint={robot.robotState.selection.selectedJoint}
+				highlightColor="#ffa348"
+				showLine={false}
+				opacity={1}
+				isInteractive={false}
+			/>
+		{/each}
+	</T.Group>
+{/each}

src/lib/components/scene/Selectable.svelte

@@ -0,0 +1,68 @@
+<script lang="ts">
+	import { T } from '@threlte/core';
+	import { TransformControls, interactivity } from '@threlte/extras';
+	import type { Object3D } from 'three';
+	import type { Snippet } from 'svelte';
+	import type IUrdfJoint from './robot/URDF/interfaces/IUrdfJoint';
+	import { updateOrigin } from './robot/URDF/utils/UrdfParser';
+	import type { IUrdfVisual } from './robot/URDF/interfaces/IUrdfVisual';
+	import type { TransformControlsMode } from 'three/examples/jsm/Addons.js';
+
+	interface Props {
+		origin: IUrdfJoint | IUrdfVisual;
+		children?: Snippet; // renderable
+		selected?: boolean;
+		translationSnap?: number;
+		scaleSnap?: number;
+		rotationSnap?: number;
+		tool?: TransformControlsMode;
+		enableEdit?: boolean;
+	}
+
+	let {
+		origin,
+		children,
+		selected = false,
+		translationSnap = 0.1,
+		scaleSnap = 0.1,
+		rotationSnap = 0.1,
+		tool = 'translate',
+		enableEdit = true
+	}: Props = $props();
+
+	const updateData = (obj: Object3D) => {
+		origin.origin_xyz = obj.position.toArray();
+		origin.origin_rpy = [obj.rotation.x, obj.rotation.y, obj.rotation.z];
+		updateOrigin(origin);
+	};
+
+	const onobjectChange = (event: any) => {
+		if (!event.target) {
+			return;
+		}
+		const obj = event.target.object;
+		updateData(obj);
+	};
+
+	interactivity();
+</script>
+
+{#if selected && enableEdit}
+	<TransformControls
+		{translationSnap}
+		{scaleSnap}
+		rotationSnap={Math.PI / rotationSnap}
+		position={origin.origin_xyz}
+		rotation={origin.origin_rpy}
+		mode={tool}
+		{onobjectChange}
+	>
+		{@render children?.()}
+	</TransformControls>
+{:else}
+	<T.Group position={origin.origin_xyz} rotation={origin.origin_rpy}>
+		{@render children?.()}
+	</T.Group>
+{/if}
+
+<!-- From https://github.com/brean/urdf-viewer -->

src/lib/components/scene/robot/URDF/createRobot.svelte.ts

@@ -0,0 +1,27 @@
+import type { RobotState } from "$lib/types/robot";
+import type { RobotUrdfConfig } from "$lib/types/urdf";
+import { UrdfParser } from "./utils/UrdfParser";
+
+export async function createRobot(urdfConfig: RobotUrdfConfig): Promise<RobotState> {
+    const customParser = new UrdfParser(urdfConfig.urdfUrl, "/robots/so-100/");
+    const urdfData = await customParser.load();
+    const robot = customParser.fromString(urdfData);
+
+    // Make the robot data reactive so mutations to joint.rotation trigger reactivity
+    const reactiveRobot = $state(robot);
+    
+    // Make the selection state reactive as well
+    const reactiveSelection = $state({
+        isSelected: false,
+        selectedLink: undefined,
+        selectedJoint: undefined
+    });
+
+    const robotState: RobotState = {
+        robot: reactiveRobot,
+        urdfConfig: urdfConfig,
+        selection: reactiveSelection
+    };
+
+    return robotState;
+} 

src/lib/components/scene/robot/URDF/interfaces/IUrdfBox.ts

@@ -0,0 +1,3 @@
+export default interface IUrdfBox {
+    size: [x: number, y: number, z: number]
+  }

src/lib/components/scene/robot/URDF/interfaces/IUrdfCylinder.ts

@@ -0,0 +1,4 @@
+export default interface IUrdfCylinder {
+    radius: number;
+    length: number
+  }

src/lib/components/scene/robot/URDF/interfaces/IUrdfJoint.ts

@@ -0,0 +1,42 @@
+import type IUrdfLink from "./IUrdfLink"
+
+export default interface IUrdfJoint {
+  name?: string
+  type?: 'revolute' | 'continuous' | 'prismatic' | 'fixed' | 'floating' | 'planar'
+  // rpy = roll, pitch, yaw (values between -pi and +pi)
+  origin_rpy: [roll: number, pitch: number, yaw: number]
+  origin_xyz: [x: number, y: number, z: number]
+  // calculated rotation for non-fixed joints based on origin_rpy and axis_xyz
+  rotation: [x: number, y: number, z: number]
+  parent: IUrdfLink
+  child: IUrdfLink
+  // axis for revolute and continuous joints defaults to (1,0,0)
+  axis_xyz?: [x: number, y: number, z: number]
+  calibration?: {
+    rising?: number,  // Calibration rising value in radians
+    falling?: number  // Calibration falling value in radians
+  }
+  dynamics?: {
+    damping?: number
+    friction?: number
+  }
+  // only for revolute joints
+  limit?: {
+    lower?: number
+    upper?: number
+    effort: number
+    velocity: number
+  }
+  mimic?: {
+    joint: string
+    multiplier?: number
+    offset?: number
+  }
+  safety_controller?: {
+    soft_lower_limit?: number
+    soft_upper_limit?: number
+    k_position?: number
+    k_velocity: number
+  }
+  elem: Element
+}

src/lib/components/scene/robot/URDF/interfaces/IUrdfLink.ts

@@ -0,0 +1,23 @@
+import type {IUrdfVisual} from "./IUrdfVisual"
+
+interface IUrdfInertia {
+  ixx: number;
+  ixy: number;
+  ixz: number;
+  iyy: number;
+  iyz: number;
+  izz: number;
+}
+
+export default interface IUrdfLink {
+  name: string
+  inertial?: {
+    origin_xyz?: [x: number, y: number, z: number]
+    origin_rpy?: [roll: number, pitch: number, yaw: number]
+    mass: number
+    inertia: IUrdfInertia
+  }
+  visual: IUrdfVisual[]
+  collision: IUrdfVisual[]
+  elem: Element
+}

src/lib/components/scene/robot/URDF/interfaces/IUrdfMesh.ts

@@ -0,0 +1,5 @@
+export default interface IUrdfMesh {
+    filename: string;
+    type: 'stl' | 'fbx' | 'obj' | 'dae';
+    scale: [x: number, y: number, z: number];
+  }

src/lib/components/scene/robot/URDF/interfaces/IUrdfRobot.ts

@@ -0,0 +1,10 @@
+import type IUrdfJoint from "./IUrdfJoint"
+import type IUrdfLink from "./IUrdfLink"
+
+export default interface IUrdfRobot {
+  name: string
+  links: {[name: string]: IUrdfLink}
+  joints: IUrdfJoint[]
+  // the DOM element holding the XML, so we can work non-destructive
+  elem?: Element
+}

src/lib/components/scene/robot/URDF/interfaces/IUrdfVisual.ts

@@ -0,0 +1,56 @@
+import type IUrdfBox from "./IUrdfBox";
+import type IUrdfCylinder from "./IUrdfCylinder";
+import type IUrdfMesh from "./IUrdfMesh";
+
+// 1) Box‐type visual
+interface IUrdfVisualBox {
+  name: string;
+  origin_xyz: [x: number, y: number, z: number];
+  origin_rpy: [roll: number, pitch: number, yaw: number];
+  geometry: IUrdfBox;
+  material?: {
+    name: string;
+    color?: string;
+    texture?: string;
+  },
+  type: 'box';
+  // optional RGBA color override
+  color_rgba?: [r: number, g: number, b: number, a: number];
+  // XML Element reference
+  elem: Element;
+}
+
+// 2) Cylinder‐type visual
+interface IUrdfVisualCylinder {
+  name: string;
+  origin_xyz: [x: number, y: number, z: number];
+  origin_rpy: [roll: number, pitch: number, yaw: number];
+  geometry: IUrdfCylinder;
+  material?: {
+    name: string;
+    color?: string;
+    texture?: string;
+  },
+  type: 'cylinder';
+  color_rgba?: [r: number, g: number, b: number, a: number];
+  elem: Element;
+}
+
+// 3) Mesh‐type visual
+interface IUrdfVisualMesh {
+  name: string;
+  origin_xyz: [x: number, y: number, z: number];
+  origin_rpy: [roll: number, pitch: number, yaw: number];
+  geometry: IUrdfMesh;
+  material?: {
+    name: string;
+    color?: string;
+    texture?: string;
+  },
+  type: 'mesh';
+  color_rgba?: [r: number, g: number, b: number, a: number];
+  elem: Element;
+}
+
+// Now make a union of the three:
+export type IUrdfVisual = IUrdfVisualBox | IUrdfVisualCylinder | IUrdfVisualMesh;

src/lib/components/scene/robot/URDF/interfaces/index.ts

@@ -0,0 +1,7 @@
+export * from './IUrdfBox';
+export * from './IUrdfCylinder';
+export * from './IUrdfJoint';
+export * from './IUrdfLink';
+export * from './IUrdfMesh';
+export * from './IUrdfRobot';
+export * from './IUrdfVisual';

src/lib/components/scene/robot/URDF/mesh/DAE.svelte

@@ -0,0 +1,70 @@
+<script lang="ts">
+	import { T, useLoader } from '@threlte/core';
+	import type { InteractivityProps } from '@threlte/extras';
+	import { DoubleSide, Mesh, type Side } from 'three';
+	import { ColladaLoader } from 'three/examples/jsm/loaders/ColladaLoader.js';
+
+	type Props = InteractivityProps & {
+		filename: string;
+		color?: string;
+		scale?: [number, number, number];
+		position?: [number, number, number];
+		rotation?: [number, number, number];
+		castShadow?: boolean;
+		receiveShadow?: boolean;
+		opacity?: number;
+		isInteractive?: boolean;
+		wireframe?: boolean;
+		side?: Side;
+	};
+	let {
+		filename,
+		color = '#ffffff',
+		scale = [1, 1, 1],
+		position = [0, 0, 0],
+		rotation = [0, 0, 0],
+		opacity = 1.0,
+		castShadow = true,
+		receiveShadow = true,
+		isInteractive = false,
+		wireframe = false,
+		side = DoubleSide,
+		...restProps
+	}: Props = $props();
+
+	const sceneUp: [x: number, y: number, z: number] = [Math.PI / 2, -Math.PI / 2, -Math.PI / 2];
+
+	const { load } = useLoader(ColladaLoader);
+</script>
+
+{#await load(filename) then dae}
+	{@html `<!-- include dae: ${filename} ${scale} -->`}
+	<T.Group {scale} {position} {rotation}>
+		<T.Group rotation={sceneUp}>
+			<T.Group
+				scale={dae.scene.scale.toArray()}
+				position={dae.scene.position.toArray()}
+				rotation={dae.scene.rotation ? dae.scene.rotation.toArray() : [0, 0, 0]}
+			>
+				{#each dae.scene.children as obj}
+					{#if obj.type === 'Mesh'}
+						{@const mesh = obj as Mesh}
+						<T.Mesh
+							{castShadow}
+							{receiveShadow}
+							geometry={mesh.geometry}
+							scale={mesh.scale ? mesh.scale.toArray() : [1, 1, 1]}
+							position={mesh.position ? mesh.position.toArray() : [0, 0, 0]}
+							material={mesh.material}
+							{...restProps}
+						>
+							<T.MeshLambertMaterial {color} {opacity} transparent={opacity < 1.0} />
+						</T.Mesh>
+					{/if}
+				{/each}
+			</T.Group>
+		</T.Group>
+	</T.Group>
+{/await}
+
+<!-- From https://github.com/brean/urdf-viewer -->

src/lib/components/scene/robot/URDF/mesh/OBJ.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+	import { T, useLoader } from '@threlte/core';
+	import type { InteractivityProps } from '@threlte/extras';
+	import { DoubleSide, type Side } from 'three';
+	import { OBJLoader } from 'three/examples/jsm/loaders/OBJLoader.js';
+
+	type Props = InteractivityProps & {
+		filename: string;
+		color?: string;
+		scale?: [number, number, number];
+		position?: [number, number, number];
+		rotation?: [number, number, number];
+		castShadow?: boolean;
+		receiveShadow?: boolean;
+		opacity?: number;
+		isInteractive?: boolean;
+		wireframe?: boolean;
+		side?: Side;
+	};
+	let {
+		filename,
+		color = '#ffffff',
+		scale = [1, 1, 1],
+		rotation = [0, 0, 0],
+		position = [0, 0, 0],
+		opacity = 1.0,
+		castShadow = true,
+		receiveShadow = true,
+		isInteractive = false,
+		wireframe = false,
+		side = DoubleSide,
+		...restProps
+	}: Props = $props();
+
+	const { load } = useLoader(OBJLoader);
+
+	// let obj = $state<undefined | Group>();
+
+	// const objLoader = new OBJLoader();
+	// objLoader.load(filename, (data: Group) => {
+	// 	obj = data;
+	// });
+</script>
+
+{#await load(filename) then obj}
+	{@html `<!-- include obj: ${filename} ${scale} -->`}
+	<T is={obj} {position} {rotation} {scale} {castShadow} {receiveShadow} {side} {...restProps}>
+		<T.MeshLambertMaterial {color} {opacity} transparent={opacity < 1.0} {wireframe} {side} />
+	</T>
+{/await}
+
+<!-- From https://github.com/brean/urdf-viewer -->

src/lib/components/scene/robot/URDF/mesh/STL.svelte

@@ -0,0 +1,51 @@
+<script lang="ts">
+	import { T, useLoader } from '@threlte/core';
+	import type { InteractivityProps } from '@threlte/extras';
+	import { STLLoader } from 'three/examples/jsm/loaders/STLLoader.js';
+	import { type Side, DoubleSide } from 'three';
+	import { interactivity } from '@threlte/extras';
+
+	type Props = InteractivityProps & {
+		filename: string;
+		color?: string;
+		scale?: [number, number, number];
+		position?: [number, number, number];
+		rotation?: [number, number, number];
+		castShadow?: boolean;
+		receiveShadow?: boolean;
+		opacity?: number;
+		isInteractive?: boolean;
+		wireframe?: boolean;
+		side?: Side;
+	};
+
+	let {
+		filename,
+		color = '#ffffff',
+		scale = [1, 1, 1],
+		position = [0, 0, 0],
+		rotation = [0, 0, 0],
+		opacity = 1.0,
+		castShadow = true,
+		receiveShadow = true,
+		isInteractive = false,
+		wireframe = false,
+		side = DoubleSide,
+		...restProps
+	}: Props = $props();
+
+	if (isInteractive) {
+		interactivity();
+	}
+
+	const { load } = useLoader(STLLoader);
+</script>
+
+{#await load(filename) then stl}
+	{@html `<!-- include stl: ${filename} ${scale} -->`}
+	<T.Mesh geometry={stl} {scale} {castShadow} {receiveShadow} {position} {rotation} {...restProps}>
+		<T.MeshLambertMaterial color={color} {opacity} transparent={opacity < 1.0} {wireframe} {side} />
+	</T.Mesh>
+{/await}
+
+<!-- From https://github.com/brean/urdf-viewer -->

src/lib/components/scene/robot/URDF/primitives/UrdfJoint.svelte

@@ -0,0 +1,148 @@
+<script lang="ts">
+	import type IUrdfJoint from '../interfaces/IUrdfJoint';
+	import { T } from '@threlte/core';
+	import UrdfLink from './UrdfLink.svelte';
+	import { Vector3 } from 'three';
+	import {
+		Billboard,
+		interactivity,
+		MeshLineGeometry,
+		Text,
+		type InteractivityProps
+	} from '@threlte/extras';
+	import Selectable from '../../../Selectable.svelte';
+
+	import type IUrdfLink from '../interfaces/IUrdfLink';
+	import type IUrdfRobot from '../interfaces/IUrdfRobot';
+
+	const defaultOnClick: InteractivityProps['onclick'] = (event) => {
+		event.stopPropagation();
+		selectedLink = undefined;
+		selectedJoint = joint;
+	};
+
+	type Props = InteractivityProps & {
+		robot: IUrdfRobot;
+		joint: IUrdfJoint;
+		selectedJoint?: IUrdfJoint;
+		selectedLink?: IUrdfLink;
+		showName?: boolean;
+		nameHeight?: number;
+		highlightColor?: string;
+		jointColor?: string;
+		jointIndicatorColor?: string;
+		showLine?: boolean;
+		opacity?: number;
+		isInteractive?: boolean;
+		showVisual?: boolean;
+		showCollision?: boolean;
+		visualOpacity?: number;
+		collisionOpacity?: number;
+		collisionColor?: string;
+		jointNames?: boolean;
+		joints?: boolean;
+	};
+
+	let {
+		robot,
+		joint,
+		selectedJoint = $bindable(),
+		selectedLink = $bindable(),
+		showLine = false,
+		nameHeight = 0.02,
+		highlightColor = '#ff0000',
+		jointColor = '#000000',
+		jointIndicatorColor = '#000000',
+		opacity = 0.7,
+		isInteractive = false,
+		showName = false,
+		showVisual = true,
+		showCollision = true,
+		visualOpacity = 1,
+		collisionOpacity = 1,
+		collisionColor = '#000000',
+		jointNames = true,
+		onclick = defaultOnClick,
+		...restProps
+	}: Props = $props();
+
+	if (isInteractive) {
+		interactivity();
+	}
+</script>
+
+{@html `<!-- Joint ${joint.name} (${joint.type}) -->`}
+{#if showName}
+	<Billboard
+		position.x={joint.origin_xyz[0]}
+		position.y={joint.origin_xyz[1]}
+		position.z={joint.origin_xyz[2]}
+	>
+		<Text
+			scale={nameHeight}
+			color={selectedJoint == joint ? highlightColor : jointColor}
+			text={joint.name}
+			characters="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		></Text>
+	</Billboard>
+{/if}
+
+<!-- draw line from parent-frame to joint origin -->
+{#if showLine}
+	<T.Line>
+		<MeshLineGeometry
+			points={[
+				new Vector3(0, 0, 0),
+				new Vector3(joint.origin_xyz[0], joint.origin_xyz[1], joint.origin_xyz[2])
+			]}
+		/>
+		<T.LineBasicMaterial color={jointColor} />
+	</T.Line>
+{/if}
+
+<Selectable origin={joint} selected={selectedJoint == joint}>
+	<T.Group rotation={joint.rotation || [0, 0, 0]}>
+		{#if joint.child}
+			<UrdfLink
+				{robot}
+				link={joint.child}
+				textScale={0.02}
+				{showName}
+				{showVisual}
+				{showCollision}
+				{visualOpacity}
+				{collisionOpacity}
+				{collisionColor}
+				jointNames={true}
+				joints={true}
+				{jointColor}
+				{jointIndicatorColor}
+				{nameHeight}
+				{selectedLink}
+				{selectedJoint}
+				{highlightColor}
+				showLine={true}
+				opacity={1}
+				isInteractive={true}
+			/>
+		{/if}
+
+		{#if showLine}
+			<T.Line>
+				<MeshLineGeometry points={[new Vector3(0, 0, 0), new Vector3(0, -0.02, 0)]} />
+				<T.LineBasicMaterial color={jointIndicatorColor} />
+			</T.Line>
+
+			<T.Mesh rotation={[Math.PI / 2, 0, 0]} {...restProps}>
+				<T.CylinderGeometry args={[0.004, 0.004, 0.03]} />
+				<T.MeshBasicMaterial
+					color={selectedJoint == joint ? highlightColor : jointColor}
+					{opacity}
+					transparent={opacity < 1.0}
+				/>
+			</T.Mesh>
+		{/if}
+	</T.Group>
+</Selectable>
+
+<!-- From https://github.com/brean/urdf-viewer -->

src/lib/components/scene/robot/URDF/primitives/UrdfLink.svelte

@@ -0,0 +1,112 @@
+<script lang="ts">
+	// The link element describes a rigid body with an inertia, visual features, and collision properties.
+	import type IUrdfLink from '../interfaces/IUrdfLink';
+	import UrdfVisual from './UrdfVisual.svelte';
+	import { getChildJoints } from '../utils/UrdfParser';
+	import UrdfJoint from './UrdfJoint.svelte';
+	import { Billboard, Text } from '@threlte/extras';
+	import type IUrdfRobot from '../interfaces/IUrdfRobot';
+	import type IUrdfJoint from '../interfaces/IUrdfJoint';
+
+	interface Props {
+		robot: IUrdfRobot;
+		link: IUrdfLink;
+		textScale?: number;
+		showName?: boolean;
+		showVisual?: boolean;
+		showCollision?: boolean;
+		visualColor?: string;
+		visualOpacity?: number;
+		collisionOpacity?: number;
+		collisionColor?: string;
+		jointNames?: boolean;
+		joints?: boolean;
+		jointColor?: string;
+		jointIndicatorColor?: string;
+		nameHeight?: number;
+		selectedLink?: IUrdfLink;
+		selectedJoint?: IUrdfJoint;
+		highlightColor?: string;
+		showLine?: boolean;
+		opacity?: number;
+		isInteractive?: boolean;
+	}
+
+	let {
+		robot,
+		link,
+		textScale = 1,
+		showName = true,
+		showVisual = true,
+		showCollision = true,
+		visualColor = '#000000',
+		visualOpacity = 1,
+		collisionOpacity = 1,
+		collisionColor = '#000000',
+		jointNames = true,
+		joints = true,
+		jointColor = '#000000',
+		jointIndicatorColor = '#000000',
+		nameHeight = 0.1,
+		selectedLink = undefined,
+		selectedJoint = undefined,
+		highlightColor = '#000000',
+		showLine = true,
+		opacity = 0.7,
+		isInteractive = false
+	}: Props = $props();
+</script>
+
+{@html `<!-- Link ${link.name} -->`}
+{#if showName}
+	<!-- <Billboard position.x={0} position.y={0} position.z={0}>
+		<Text anchorY={-0.2} scale={textScale} text={link.name} characters="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		></Text>
+	</Billboard> -->
+{/if}
+
+{#if showVisual}
+	{#each link.visual as visual}
+		<UrdfVisual
+			opacity={visualOpacity}
+			{visual}
+			defaultColor={visualColor}
+		/>
+	{/each}
+{/if}
+
+{#if showCollision}
+	{#each link.collision as visual}
+		<UrdfVisual
+			opacity={collisionOpacity}
+			visual={visual}
+			defaultColor={collisionColor}
+		/>
+	{/each}
+{/if}
+
+{#each getChildJoints(robot, link) as joint}
+	<UrdfJoint
+		{robot}
+		joint={joint}
+		{selectedJoint}
+		{selectedLink}
+		{showName}
+		{nameHeight}
+		{highlightColor}
+		{jointColor}
+		{jointIndicatorColor}
+		{showLine}
+		{opacity}
+		{isInteractive}
+		{showVisual}
+		{showCollision}
+		{visualOpacity}
+		{collisionOpacity}
+		{collisionColor}
+		{jointNames}
+		{joints}
+	/>
+{/each}
+
+<!-- From https://github.com/brean/urdf-viewer -->