Add type-safe EventBus with generic event mapping

Implemented EventBus class with full TypeScript type inference:
- Generic type parameter TEvents for event name to payload mapping
- Type-safe on/once/off/emit methods with inferred data types
- Utility methods: clear, listenerCount, eventNames
- Complete JSDoc documentation with usage examples

Added core connection types:
- ConnectionIdentity, ConnectionState, ConnectionInterface
- QueueMessageOptions for message queuing
- Connection composite type

All types and classes exported from main index.

Example usage:
```typescript
interface MyEvents {
  'user:connected': { userId: string; timestamp: number };
  'message:received': string;
}

const bus = new EventBus<MyEvents>();

// TypeScript knows data is { userId: string; timestamp: number }
bus.on('user:connected', (data) => {
  console.log(data.userId, data.timestamp);
});
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

EVENTBUS_EXAMPLE.md

@@ -0,0 +1,120 @@
+# EventBus Usage Examples
+
+## Type-Safe Event Bus
+
+The `EventBus` class provides fully type-safe event handling with TypeScript type inference.
+
+### Basic Usage
+
+```typescript
+import { EventBus } from '@xtr-dev/rondevu-client';
+
+// Define your event mapping
+interface AppEvents {
+  'user:connected': { userId: string; timestamp: number };
+  'user:disconnected': { userId: string };
+  'message:received': string;
+  'connection:error': Error;
+}
+
+// Create the event bus
+const events = new EventBus<AppEvents>();
+
+// Subscribe to events - TypeScript knows the exact data type!
+events.on('user:connected', (data) => {
+  // data is { userId: string; timestamp: number }
+  console.log(`User ${data.userId} connected at ${data.timestamp}`);
+});
+
+events.on('message:received', (data) => {
+  // data is string
+  console.log(data.toUpperCase());
+});
+
+// Emit events - TypeScript validates the data type
+events.emit('user:connected', {
+  userId: '123',
+  timestamp: Date.now()
+});
+
+events.emit('message:received', 'Hello World');
+
+// Type errors caught at compile time:
+// events.emit('user:connected', 'wrong type'); // ❌ Error!
+// events.emit('message:received', { wrong: 'type' }); // ❌ Error!
+```
+
+### One-Time Listeners
+
+```typescript
+// Subscribe once - handler auto-unsubscribes after first call
+events.once('connection:error', (error) => {
+  console.error('Connection failed:', error.message);
+});
+```
+
+### Unsubscribing
+
+```typescript
+const handler = (data: string) => {
+  console.log('Message:', data);
+};
+
+events.on('message:received', handler);
+
+// Later, unsubscribe
+events.off('message:received', handler);
+```
+
+### Utility Methods
+
+```typescript
+// Clear all handlers for a specific event
+events.clear('message:received');
+
+// Clear all handlers for all events
+events.clear();
+
+// Get listener count
+const count = events.listenerCount('user:connected');
+
+// Get all event names with handlers
+const eventNames = events.eventNames();
+```
+
+## Connection Events Example
+
+```typescript
+interface ConnectionEvents {
+  'connection:state': { state: 'connected' | 'disconnected' | 'connecting' };
+  'connection:message': { from: string; data: string | ArrayBuffer };
+  'connection:error': { code: string; message: string };
+}
+
+class ConnectionManager {
+  private events = new EventBus<ConnectionEvents>();
+
+  on<K extends keyof ConnectionEvents>(
+    event: K,
+    handler: (data: ConnectionEvents[K]) => void
+  ) {
+    this.events.on(event, handler);
+  }
+
+  private handleStateChange(state: 'connected' | 'disconnected' | 'connecting') {
+    this.events.emit('connection:state', { state });
+  }
+
+  private handleMessage(from: string, data: string | ArrayBuffer) {
+    this.events.emit('connection:message', { from, data });
+  }
+}
+```
+
+## Benefits
+
+- ✅ **Full type safety** - TypeScript validates event names and data types
+- ✅ **IntelliSense support** - Auto-completion for event names and data properties
+- ✅ **Compile-time errors** - Catch type mismatches before runtime
+- ✅ **Self-documenting** - Event interface serves as documentation
+- ✅ **Refactoring-friendly** - Rename events or change types with confidence

MIGRATION.md

@@ -0,0 +1,547 @@
+# Migration Guide: v0.8.x → v0.9.0
+
+This guide helps you migrate from Rondevu Client v0.8.x to v0.9.0.
+
+## Overview
+
+v0.9.0 is a **breaking change** that completely replaces low-level APIs with high-level durable connections featuring automatic reconnection and message queuing.
+
+### What's New
+
+✅ **Durable Connections**: Automatic reconnection on network drops
+✅ **Message Queuing**: Messages sent during disconnections are queued and flushed on reconnect
+✅ **Durable Channels**: RTCDataChannel wrappers that survive connection drops
+✅ **TTL Auto-Refresh**: Services automatically republish before expiration
+✅ **Simplified API**: Direct methods on main client instead of nested APIs
+
+### What's Removed
+
+❌ **Low-level APIs**: `client.services.*`, `client.discovery.*`, `client.createPeer()` no longer exported
+❌ **Manual Connection Management**: No need to handle WebRTC peer lifecycle manually
+❌ **Service Handles**: Replaced with DurableService instances
+
+## Breaking Changes
+
+### 1. Service Exposure
+
+#### v0.8.x (Old)
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client';
+
+const client = new Rondevu();
+await client.register();
+
+const handle = await client.services.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  isPublic: true,
+  handler: (channel, peer) => {
+    channel.onmessage = (e) => {
+      console.log('Received:', e.data);
+      channel.send(`Echo: ${e.data}`);
+    };
+  }
+});
+
+// Unpublish
+await handle.unpublish();
+```
+
+#### v0.9.0 (New)
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client';
+
+const client = new Rondevu();
+await client.register();
+
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  isPublic: true,
+  poolSize: 10,  // NEW: Handle multiple concurrent connections
+  handler: (channel, connectionId) => {
+    // NEW: DurableChannel with event emitters
+    channel.on('message', (data) => {
+      console.log('Received:', data);
+      channel.send(`Echo: ${data}`);
+    });
+  }
+});
+
+// NEW: Start the service
+await service.start();
+
+// NEW: Stop the service
+await service.stop();
+```
+
+**Key Differences:**
+- `client.services.exposeService()` → `client.exposeService()`
+- Returns `DurableService` instead of `ServiceHandle`
+- Handler receives `DurableChannel` instead of `RTCDataChannel`
+- Handler receives `connectionId` string instead of `RondevuPeer`
+- DurableChannel uses `.on('message', ...)` instead of `.onmessage = ...`
+- Must call `service.start()` to begin accepting connections
+- Use `service.stop()` instead of `handle.unpublish()`
+
+### 2. Connecting to Services
+
+#### v0.8.x (Old)
+```typescript
+// Connect by username + FQN
+const { peer, channel } = await client.discovery.connect(
+  'alice',
+  'chat@1.0.0'
+);
+
+channel.onmessage = (e) => {
+  console.log('Received:', e.data);
+};
+
+channel.onopen = () => {
+  channel.send('Hello!');
+};
+
+peer.on('connected', () => {
+  console.log('Connected');
+});
+
+peer.on('failed', (error) => {
+  console.error('Failed:', error);
+});
+```
+
+#### v0.9.0 (New)
+```typescript
+// Connect by username + FQN
+const connection = await client.connect('alice', 'chat@1.0.0', {
+  maxReconnectAttempts: 10  // NEW: Configurable reconnection
+});
+
+// NEW: Create durable channel
+const channel = connection.createChannel('main');
+
+channel.on('message', (data) => {
+  console.log('Received:', data);
+});
+
+channel.on('open', () => {
+  channel.send('Hello!');
+});
+
+// NEW: Connection lifecycle events
+connection.on('connected', () => {
+  console.log('Connected');
+});
+
+connection.on('reconnecting', (attempt, max, delay) => {
+  console.log(`Reconnecting (${attempt}/${max})...`);
+});
+
+connection.on('failed', (error) => {
+  console.error('Failed permanently:', error);
+});
+
+// NEW: Must explicitly connect
+await connection.connect();
+```
+
+**Key Differences:**
+- `client.discovery.connect()` → `client.connect()`
+- Returns `DurableConnection` instead of `{ peer, channel }`
+- Must create channels with `connection.createChannel()`
+- Must call `connection.connect()` to establish connection
+- Automatic reconnection with configurable retry limits
+- Messages sent during disconnection are automatically queued
+
+### 3. Connecting by UUID
+
+#### v0.8.x (Old)
+```typescript
+const { peer, channel } = await client.discovery.connectByUuid('service-uuid');
+
+channel.onmessage = (e) => {
+  console.log('Received:', e.data);
+};
+```
+
+#### v0.9.0 (New)
+```typescript
+const connection = await client.connectByUuid('service-uuid', {
+  maxReconnectAttempts: 5
+});
+
+const channel = connection.createChannel('main');
+
+channel.on('message', (data) => {
+  console.log('Received:', data);
+});
+
+await connection.connect();
+```
+
+**Key Differences:**
+- `client.discovery.connectByUuid()` → `client.connectByUuid()`
+- Returns `DurableConnection` instead of `{ peer, channel }`
+- Must create channels and connect explicitly
+
+### 4. Multi-Connection Services (Offer Pooling)
+
+#### v0.8.x (Old)
+```typescript
+const handle = await client.services.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  poolSize: 5,
+  pollingInterval: 2000,
+  handler: (channel, peer, connectionId) => {
+    console.log(`Connection: ${connectionId}`);
+  },
+  onPoolStatus: (status) => {
+    console.log('Pool status:', status);
+  }
+});
+
+const status = handle.getStatus();
+await handle.addOffers(3);
+```
+
+#### v0.9.0 (New)
+```typescript
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  poolSize: 5,          // SAME: Pool size
+  pollingInterval: 2000, // SAME: Polling interval
+  handler: (channel, connectionId) => {
+    console.log(`Connection: ${connectionId}`);
+  }
+});
+
+await service.start();
+
+// Get active connections
+const connections = service.getActiveConnections();
+
+// Listen for connection events
+service.on('connection', (connectionId) => {
+  console.log('New connection:', connectionId);
+});
+```
+
+**Key Differences:**
+- `onPoolStatus` callback removed (use `service.on('connection')` instead)
+- `handle.getStatus()` replaced with `service.getActiveConnections()`
+- `handle.addOffers()` removed (pool auto-manages offers)
+- Handler receives `DurableChannel` instead of `RTCDataChannel`
+
+## Feature Comparison
+
+| Feature | v0.8.x | v0.9.0 |
+|---------|--------|--------|
+| Service exposure | `client.services.exposeService()` | `client.exposeService()` |
+| Connection | `client.discovery.connect()` | `client.connect()` |
+| Connection by UUID | `client.discovery.connectByUuid()` | `client.connectByUuid()` |
+| Channel type | `RTCDataChannel` | `DurableChannel` |
+| Event handling | `.onmessage`, `.onopen`, etc. | `.on('message')`, `.on('open')`, etc. |
+| Automatic reconnection | ❌ No | ✅ Yes (configurable) |
+| Message queuing | ❌ No | ✅ Yes (during disconnections) |
+| TTL auto-refresh | ❌ No | ✅ Yes (configurable) |
+| Peer lifecycle | Manual | Automatic |
+| Connection pooling | ✅ Yes | ✅ Yes (same API) |
+
+## API Mapping
+
+### Removed Exports
+
+These are no longer exported in v0.9.0:
+
+```typescript
+// ❌ Removed
+import {
+  RondevuServices,
+  RondevuDiscovery,
+  RondevuPeer,
+  ServiceHandle,
+  PooledServiceHandle,
+  ConnectResult
+} from '@xtr-dev/rondevu-client';
+```
+
+### New Exports
+
+These are new in v0.9.0:
+
+```typescript
+// ✅ New
+import {
+  DurableConnection,
+  DurableChannel,
+  DurableService,
+  DurableConnectionState,
+  DurableChannelState,
+  DurableConnectionConfig,
+  DurableChannelConfig,
+  DurableServiceConfig,
+  DurableConnectionEvents,
+  DurableChannelEvents,
+  DurableServiceEvents,
+  ConnectionInfo,
+  ServiceInfo,
+  QueuedMessage
+} from '@xtr-dev/rondevu-client';
+```
+
+### Unchanged Exports
+
+These work the same in both versions:
+
+```typescript
+// ✅ Unchanged
+import {
+  Rondevu,
+  RondevuAuth,
+  RondevuUsername,
+  Credentials,
+  UsernameClaimResult,
+  UsernameCheckResult
+} from '@xtr-dev/rondevu-client';
+```
+
+## Configuration Options
+
+### New Connection Options
+
+v0.9.0 adds extensive configuration for automatic reconnection and message queuing:
+
+```typescript
+const connection = await client.connect('alice', 'chat@1.0.0', {
+  // Reconnection
+  maxReconnectAttempts: 10,      // default: 10
+  reconnectBackoffBase: 1000,    // default: 1000ms
+  reconnectBackoffMax: 30000,    // default: 30000ms (30 seconds)
+  reconnectJitter: 0.2,          // default: 0.2 (±20%)
+  connectionTimeout: 30000,      // default: 30000ms
+
+  // Message queuing
+  maxQueueSize: 1000,            // default: 1000 messages
+  maxMessageAge: 60000,          // default: 60000ms (1 minute)
+
+  // WebRTC
+  rtcConfig: {
+    iceServers: [...]
+  }
+});
+```
+
+### New Service Options
+
+Services can now auto-refresh TTL:
+
+```typescript
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+
+  // TTL auto-refresh (NEW)
+  ttl: 300000,              // default: 300000ms (5 minutes)
+  ttlRefreshMargin: 0.2,    // default: 0.2 (refresh at 80% of TTL)
+
+  // All connection options also apply to incoming connections
+  maxReconnectAttempts: 10,
+  maxQueueSize: 1000,
+  // ...
+});
+```
+
+## Migration Checklist
+
+- [ ] Replace `client.services.exposeService()` with `client.exposeService()`
+- [ ] Add `await service.start()` after creating service
+- [ ] Replace `handle.unpublish()` with `service.stop()`
+- [ ] Replace `client.discovery.connect()` with `client.connect()`
+- [ ] Replace `client.discovery.connectByUuid()` with `client.connectByUuid()`
+- [ ] Create channels with `connection.createChannel()` instead of receiving them directly
+- [ ] Add `await connection.connect()` to establish connection
+- [ ] Update handlers from `(channel, peer, connectionId?)` to `(channel, connectionId)`
+- [ ] Replace `.onmessage` with `.on('message', ...)`
+- [ ] Replace `.onopen` with `.on('open', ...)`
+- [ ] Replace `.onclose` with `.on('close', ...)`
+- [ ] Replace `.onerror` with `.on('error', ...)`
+- [ ] Add reconnection event handlers (`connection.on('reconnecting', ...)`)
+- [ ] Review and configure reconnection options if needed
+- [ ] Review and configure message queue limits if needed
+- [ ] Update TypeScript imports to use new types
+- [ ] Test automatic reconnection behavior
+- [ ] Test message queuing during disconnections
+
+## Common Migration Patterns
+
+### Pattern 1: Simple Echo Service
+
+#### Before (v0.8.x)
+```typescript
+await client.services.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'echo@1.0.0',
+  handler: (channel) => {
+    channel.onmessage = (e) => {
+      channel.send(`Echo: ${e.data}`);
+    };
+  }
+});
+```
+
+#### After (v0.9.0)
+```typescript
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'echo@1.0.0',
+  handler: (channel) => {
+    channel.on('message', (data) => {
+      channel.send(`Echo: ${data}`);
+    });
+  }
+});
+
+await service.start();
+```
+
+### Pattern 2: Connection with Error Handling
+
+#### Before (v0.8.x)
+```typescript
+try {
+  const { peer, channel } = await client.discovery.connect('alice', 'chat@1.0.0');
+
+  channel.onopen = () => {
+    channel.send('Hello!');
+  };
+
+  peer.on('failed', (error) => {
+    console.error('Connection failed:', error);
+    // Manual reconnection logic here
+  });
+} catch (error) {
+  console.error('Failed to connect:', error);
+}
+```
+
+#### After (v0.9.0)
+```typescript
+const connection = await client.connect('alice', 'chat@1.0.0', {
+  maxReconnectAttempts: 5
+});
+
+const channel = connection.createChannel('main');
+
+channel.on('open', () => {
+  channel.send('Hello!');
+});
+
+connection.on('reconnecting', (attempt, max, delay) => {
+  console.log(`Reconnecting (${attempt}/${max}) in ${delay}ms`);
+});
+
+connection.on('failed', (error) => {
+  console.error('Connection failed permanently:', error);
+});
+
+try {
+  await connection.connect();
+} catch (error) {
+  console.error('Initial connection failed:', error);
+}
+```
+
+### Pattern 3: Multi-User Chat Server
+
+#### Before (v0.8.x)
+```typescript
+const connections = new Map();
+
+await client.services.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  poolSize: 10,
+  handler: (channel, peer, connectionId) => {
+    connections.set(connectionId, channel);
+
+    channel.onmessage = (e) => {
+      // Broadcast to all
+      for (const [id, ch] of connections) {
+        if (id !== connectionId) {
+          ch.send(e.data);
+        }
+      }
+    };
+
+    channel.onclose = () => {
+      connections.delete(connectionId);
+    };
+  }
+});
+```
+
+#### After (v0.9.0)
+```typescript
+const channels = new Map();
+
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  poolSize: 10,
+  handler: (channel, connectionId) => {
+    channels.set(connectionId, channel);
+
+    channel.on('message', (data) => {
+      // Broadcast to all
+      for (const [id, ch] of channels) {
+        if (id !== connectionId) {
+          ch.send(data);
+        }
+      }
+    });
+
+    channel.on('close', () => {
+      channels.delete(connectionId);
+    });
+  }
+});
+
+await service.start();
+
+// Optional: Track connections
+service.on('connection', (connectionId) => {
+  console.log(`User ${connectionId} joined`);
+});
+
+service.on('disconnection', (connectionId) => {
+  console.log(`User ${connectionId} left`);
+});
+```
+
+## Benefits of Migration
+
+1. **Reliability**: Automatic reconnection handles network hiccups transparently
+2. **Simplicity**: No need to manage WebRTC peer lifecycle manually
+3. **Durability**: Messages sent during disconnections are queued and delivered when connection restores
+4. **Uptime**: Services automatically refresh TTL before expiration
+5. **Type Safety**: Better TypeScript types with DurableChannel event emitters
+6. **Debugging**: Queue size monitoring, connection state tracking, and detailed events
+
+## Getting Help
+
+If you encounter issues during migration:
+1. Check the [README](./README.md) for complete API documentation
+2. Review the examples for common patterns
+3. Open an issue on [GitHub](https://github.com/xtr-dev/rondevu-client/issues)

README.md

@@ -1,82 +1,659 @@
-# Rondevu
-
-🎯 **Simple WebRTC peer signaling and discovery**
-
-Meet peers by topic, by peer ID, or by connection ID.
-
-**Related repositories:**
-- [rondevu-server](https://github.com/xtr-dev/rondevu-server) - HTTP signaling server
-- [rondevu-demo](https://github.com/xtr-dev/rondevu-demo) - Interactive demo
-
----
-
-## @xtr-dev/rondevu-client
+# Rondevu Client
 
 [![npm version](https://img.shields.io/npm/v/@xtr-dev/rondevu-client)](https://www.npmjs.com/package/@xtr-dev/rondevu-client)
 
-TypeScript client library for Rondevu peer signaling and WebRTC connection management. Handles automatic signaling, ICE candidate exchange, and connection establishment.
+🌐 **WebRTC with durable connections and automatic reconnection**
 
-### Install
+TypeScript/JavaScript client for Rondevu, providing durable WebRTC connections that survive network interruptions with automatic reconnection and message queuing.
+
+**Related repositories:**
+- [@xtr-dev/rondevu-client](https://github.com/xtr-dev/rondevu-client) - TypeScript client library ([npm](https://www.npmjs.com/package/@xtr-dev/rondevu-client))
+- [@xtr-dev/rondevu-server](https://github.com/xtr-dev/rondevu-server) - HTTP signaling server ([npm](https://www.npmjs.com/package/@xtr-dev/rondevu-server), [live](https://api.ronde.vu))
+- [@xtr-dev/rondevu-demo](https://github.com/xtr-dev/rondevu-demo) - Interactive demo ([live](https://ronde.vu))
+
+---
+
+## Features
+
+- **Durable Connections**: Automatic reconnection on network drops
+- **Message Queuing**: Messages sent during disconnections are queued and flushed on reconnect
+- **Durable Channels**: RTCDataChannel wrappers that survive connection drops
+- **TTL Auto-Refresh**: Services automatically republish before expiration
+- **Username Claiming**: Cryptographic ownership with Ed25519 signatures
+- **Service Publishing**: Package-style naming (com.example.chat@1.0.0)
+- **TypeScript**: Full type safety and autocomplete
+- **Configurable**: All timeouts, retry limits, and queue sizes are configurable
+
+## Install
 
 ```bash
 npm install @xtr-dev/rondevu-client
 ```
 
-### Usage
+## Quick Start
+
+### Publishing a Service (Alice)
 
 ```typescript
 import { Rondevu } from '@xtr-dev/rondevu-client';
 
-const rdv = new Rondevu({ 
-  baseUrl: 'https://server.com',
+// Initialize client and register
+const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+await client.register();
+
+// Step 1: Claim username (one-time)
+const claim = await client.usernames.claimUsername('alice');
+client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
+
+// Step 2: Expose service with handler
+const keypair = client.usernames.loadKeypairFromStorage('alice');
+
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  isPublic: true,
+  poolSize: 10,  // Handle 10 concurrent connections
+  handler: (channel, connectionId) => {
+    console.log(`📡 New connection: ${connectionId}`);
+
+    channel.on('message', (data) => {
+      console.log('📥 Received:', data);
+      channel.send(`Echo: ${data}`);
+    });
+
+    channel.on('close', () => {
+      console.log(`👋 Connection ${connectionId} closed`);
+    });
+  }
+});
+
+// Start the service
+const info = await service.start();
+console.log(`Service published with UUID: ${info.uuid}`);
+console.log('Waiting for connections...');
+
+// Later: stop the service
+await service.stop();
+```
+
+### Connecting to a Service (Bob)
+
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client';
+
+// Initialize client and register
+const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+await client.register();
+
+// Connect to Alice's service
+const connection = await client.connect('alice', 'chat@1.0.0', {
+  maxReconnectAttempts: 5
+});
+
+// Create a durable channel
+const channel = connection.createChannel('main');
+
+channel.on('message', (data) => {
+  console.log('📥 Received:', data);
+});
+
+channel.on('open', () => {
+  console.log('✅ Channel open');
+  channel.send('Hello Alice!');
+});
+
+// Listen for connection events
+connection.on('connected', () => {
+  console.log('🎉 Connected to Alice');
+});
+
+connection.on('reconnecting', (attempt, max, delay) => {
+  console.log(`🔄 Reconnecting... (${attempt}/${max}, retry in ${delay}ms)`);
+});
+
+connection.on('disconnected', () => {
+  console.log('🔌 Disconnected');
+});
+
+connection.on('failed', (error) => {
+  console.error('❌ Connection failed permanently:', error);
+});
+
+// Establish the connection
+await connection.connect();
+
+// Messages sent during disconnection are automatically queued
+channel.send('This will be queued if disconnected');
+
+// Later: close the connection
+await connection.close();
+```
+
+## Core Concepts
+
+### DurableConnection
+
+Manages WebRTC peer lifecycle with automatic reconnection:
+- Automatically reconnects when connection drops
+- Exponential backoff with jitter (1s → 2s → 4s → 8s → ... max 30s)
+- Configurable max retry attempts (default: 10)
+- Manages multiple DurableChannel instances
+
+### DurableChannel
+
+Wraps RTCDataChannel with message queuing:
+- Queues messages during disconnection
+- Flushes queue on reconnection
+- Configurable queue size and message age limits
+- RTCDataChannel-compatible API with event emitters
+
+### DurableService
+
+Server-side service with TTL auto-refresh:
+- Automatically republishes service before TTL expires
+- Creates DurableConnection for each incoming peer
+- Manages connection pool for multiple simultaneous connections
+
+## API Reference
+
+### Main Client
+
+```typescript
+const client = new Rondevu({
+  baseUrl: 'https://api.ronde.vu',  // optional, default shown
+  credentials?: { peerId, secret },  // optional, skip registration
+  fetch?: customFetch,               // optional, for Node.js < 18
+  RTCPeerConnection?: RTCPeerConnection,  // optional, for Node.js
+  RTCSessionDescription?: RTCSessionDescription,
+  RTCIceCandidate?: RTCIceCandidate
+});
+
+// Register and get credentials
+const creds = await client.register();
+// { peerId: '...', secret: '...' }
+
+// Check if authenticated
+client.isAuthenticated(); // boolean
+
+// Get current credentials
+client.getCredentials(); // { peerId, secret } | undefined
+```
+
+### Username API
+
+```typescript
+// Check username availability
+const check = await client.usernames.checkUsername('alice');
+// { available: true } or { available: false, expiresAt: number, publicKey: string }
+
+// Claim username with new keypair
+const claim = await client.usernames.claimUsername('alice');
+// { username, publicKey, privateKey, claimedAt, expiresAt }
+
+// Save keypair to localStorage
+client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
+
+// Load keypair from localStorage
+const keypair = client.usernames.loadKeypairFromStorage('alice');
+// { publicKey, privateKey } | null
+```
+
+**Username Rules:**
+- Format: Lowercase alphanumeric + dash (`a-z`, `0-9`, `-`)
+- Length: 3-32 characters
+- Pattern: `^[a-z0-9][a-z0-9-]*[a-z0-9]$`
+- Validity: 365 days from claim/last use
+- Ownership: Secured by Ed25519 public key
+
+### Durable Service API
+
+```typescript
+// Expose a durable service
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+
+  // Service options
+  isPublic: true,               // optional, default: false
+  metadata: { version: '1.0' }, // optional
+  ttl: 300000,                  // optional, default: 5 minutes
+  ttlRefreshMargin: 0.2,        // optional, refresh at 80% of TTL
+
+  // Connection pooling
+  poolSize: 10,                 // optional, default: 1
+  pollingInterval: 2000,        // optional, default: 2000ms
+
+  // Connection options (applied to incoming connections)
+  maxReconnectAttempts: 10,     // optional, default: 10
+  reconnectBackoffBase: 1000,   // optional, default: 1000ms
+  reconnectBackoffMax: 30000,   // optional, default: 30000ms
+  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
+  connectionTimeout: 30000,     // optional, default: 30000ms
+
+  // Message queuing
+  maxQueueSize: 1000,           // optional, default: 1000
+  maxMessageAge: 60000,         // optional, default: 60000ms (1 minute)
+
+  // WebRTC configuration
   rtcConfig: {
     iceServers: [
-      // your ICE servers here
-      { urls: 'stun:stun.l.google.com:19302' },
-      { urls: 'stun:stun1.l.google.com:19302' },
-      {
-        urls: 'turn:relay1.example.com:3480',
-        username: 'example',
-        credential: 'example'
-      }
+      { urls: 'stun:stun.l.google.com:19302' }
+    ]
+  },
+
+  // Connection handler
+  handler: (channel, connectionId) => {
+    // Handle incoming connection
+    channel.on('message', (data) => {
+      console.log('Received:', data);
+      channel.send(`Echo: ${data}`);
+    });
+  }
+});
+
+// Start the service
+const info = await service.start();
+// { serviceId: '...', uuid: '...', expiresAt: 1234567890 }
+
+// Get active connections
+const connections = service.getActiveConnections();
+// ['conn-123', 'conn-456']
+
+// Get service info
+const serviceInfo = service.getServiceInfo();
+// { serviceId: '...', uuid: '...', expiresAt: 1234567890 } | null
+
+// Stop the service
+await service.stop();
+```
+
+**Service Events:**
+```typescript
+service.on('published', (serviceId, uuid) => {
+  console.log(`Service published: ${uuid}`);
+});
+
+service.on('connection', (connectionId) => {
+  console.log(`New connection: ${connectionId}`);
+});
+
+service.on('disconnection', (connectionId) => {
+  console.log(`Connection closed: ${connectionId}`);
+});
+
+service.on('ttl-refreshed', (expiresAt) => {
+  console.log(`TTL refreshed, expires at: ${new Date(expiresAt)}`);
+});
+
+service.on('error', (error, context) => {
+  console.error(`Service error (${context}):`, error);
+});
+
+service.on('closed', () => {
+  console.log('Service stopped');
+});
+```
+
+### Durable Connection API
+
+```typescript
+// Connect by username and service FQN
+const connection = await client.connect('alice', 'chat@1.0.0', {
+  // Connection options
+  maxReconnectAttempts: 10,     // optional, default: 10
+  reconnectBackoffBase: 1000,   // optional, default: 1000ms
+  reconnectBackoffMax: 30000,   // optional, default: 30000ms
+  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
+  connectionTimeout: 30000,     // optional, default: 30000ms
+
+  // Message queuing
+  maxQueueSize: 1000,           // optional, default: 1000
+  maxMessageAge: 60000,         // optional, default: 60000ms
+
+  // WebRTC configuration
+  rtcConfig: {
+    iceServers: [
+      { urls: 'stun:stun.l.google.com:19302' }
     ]
   }
 });
 
-// Connect by topic
-const conn = await rdv.join('room');
+// Connect by UUID
+const connection2 = await client.connectByUuid('service-uuid-here', {
+  maxReconnectAttempts: 5
+});
 
-// Or connect by ID
-const conn = await rdv.connect('meeting-123');
+// Create channels before connecting
+const channel = connection.createChannel('main');
+const fileChannel = connection.createChannel('files', {
+  ordered: false,
+  maxRetransmits: 3
+});
 
-// Use the connection
-conn.on('connect', () => {
-  const channel = conn.dataChannel('chat');
-  channel.send('Hello!');
+// Get existing channel
+const existingChannel = connection.getChannel('main');
+
+// Check connection state
+const state = connection.getState();
+// 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'failed' | 'closed'
+
+const isConnected = connection.isConnected();
+
+// Connect
+await connection.connect();
+
+// Close connection
+await connection.close();
+```
+
+**Connection Events:**
+```typescript
+connection.on('state', (newState, previousState) => {
+  console.log(`State: ${previousState} → ${newState}`);
+});
+
+connection.on('connected', () => {
+  console.log('Connected');
+});
+
+connection.on('reconnecting', (attempt, maxAttempts, delay) => {
+  console.log(`Reconnecting (${attempt}/${maxAttempts}) in ${delay}ms`);
+});
+
+connection.on('disconnected', () => {
+  console.log('Disconnected');
+});
+
+connection.on('failed', (error, permanent) => {
+  console.error('Connection failed:', error, 'Permanent:', permanent);
+});
+
+connection.on('closed', () => {
+  console.log('Connection closed');
 });
 ```
 
-### API
+### Durable Channel API
 
-**Main Methods:**
-- `rdv.join(topic)` - Auto-connect to first peer in topic
-- `rdv.join(topic, {filter})` - Connect to specific peer by ID
-- `rdv.create(id, topic)` - Create connection for others to join
-- `rdv.connect(id)` - Join connection by ID
+```typescript
+const channel = connection.createChannel('chat', {
+  ordered: true,          // optional, default: true
+  maxRetransmits: undefined  // optional, for unordered channels
+});
 
-**Connection Events:**
-- `connect` - Connection established
-- `disconnect` - Connection closed
-- `datachannel` - Remote peer created data channel
-- `stream` - Remote media stream received
-- `error` - Error occurred
+// Send data (queued if disconnected)
+channel.send('Hello!');
+channel.send(new ArrayBuffer(1024));
+channel.send(new Blob(['data']));
 
-**Connection Methods:**
-- `conn.dataChannel(label)` - Get or create data channel
-- `conn.addStream(stream)` - Add media stream
-- `conn.getPeerConnection()` - Get underlying RTCPeerConnection
-- `conn.close()` - Close connection
+// Check state
+const state = channel.readyState;
+// 'connecting' | 'open' | 'closing' | 'closed'
 
-### License
+// Get buffered amount
+const buffered = channel.bufferedAmount;
+
+// Set buffered amount low threshold
+channel.bufferedAmountLowThreshold = 16 * 1024; // 16KB
+
+// Get queue size (for debugging)
+const queueSize = channel.getQueueSize();
+
+// Close channel
+channel.close();
+```
+
+**Channel Events:**
+```typescript
+channel.on('open', () => {
+  console.log('Channel open');
+});
+
+channel.on('message', (data) => {
+  console.log('Received:', data);
+});
+
+channel.on('error', (error) => {
+  console.error('Channel error:', error);
+});
+
+channel.on('close', () => {
+  console.log('Channel closed');
+});
+
+channel.on('bufferedAmountLow', () => {
+  console.log('Buffer drained, safe to send more');
+});
+
+channel.on('queueOverflow', (droppedCount) => {
+  console.warn(`Queue overflow: ${droppedCount} messages dropped`);
+});
+```
+
+## Configuration Options
+
+### Connection Configuration
+
+```typescript
+interface DurableConnectionConfig {
+  maxReconnectAttempts?: number;      // default: 10
+  reconnectBackoffBase?: number;      // default: 1000 (1 second)
+  reconnectBackoffMax?: number;       // default: 30000 (30 seconds)
+  reconnectJitter?: number;           // default: 0.2 (±20%)
+  connectionTimeout?: number;         // default: 30000 (30 seconds)
+  maxQueueSize?: number;              // default: 1000 messages
+  maxMessageAge?: number;             // default: 60000 (1 minute)
+  rtcConfig?: RTCConfiguration;
+}
+```
+
+### Service Configuration
+
+```typescript
+interface DurableServiceConfig extends DurableConnectionConfig {
+  username: string;
+  privateKey: string;
+  serviceFqn: string;
+  isPublic?: boolean;                 // default: false
+  metadata?: Record<string, any>;
+  ttl?: number;                       // default: 300000 (5 minutes)
+  ttlRefreshMargin?: number;          // default: 0.2 (refresh at 80%)
+  poolSize?: number;                  // default: 1
+  pollingInterval?: number;           // default: 2000 (2 seconds)
+}
+```
+
+## Examples
+
+### Chat Application
+
+```typescript
+// Server
+const client = new Rondevu();
+await client.register();
+
+const claim = await client.usernames.claimUsername('alice');
+client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
+const keypair = client.usernames.loadKeypairFromStorage('alice');
+
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'chat@1.0.0',
+  isPublic: true,
+  poolSize: 50,  // Handle 50 concurrent users
+  handler: (channel, connectionId) => {
+    console.log(`User ${connectionId} joined`);
+
+    channel.on('message', (data) => {
+      console.log(`[${connectionId}]: ${data}`);
+      // Broadcast to all users (implement your broadcast logic)
+    });
+
+    channel.on('close', () => {
+      console.log(`User ${connectionId} left`);
+    });
+  }
+});
+
+await service.start();
+
+// Client
+const client2 = new Rondevu();
+await client2.register();
+
+const connection = await client2.connect('alice', 'chat@1.0.0');
+const channel = connection.createChannel('chat');
+
+channel.on('message', (data) => {
+  console.log('Message:', data);
+});
+
+await connection.connect();
+channel.send('Hello everyone!');
+```
+
+### File Transfer with Progress
+
+```typescript
+// Server
+const service = await client.exposeService({
+  username: 'alice',
+  privateKey: keypair.privateKey,
+  serviceFqn: 'files@1.0.0',
+  handler: (channel, connectionId) => {
+    channel.on('message', async (data) => {
+      const request = JSON.parse(data);
+
+      if (request.action === 'download') {
+        const file = await fs.readFile(request.path);
+        const chunkSize = 16 * 1024; // 16KB chunks
+
+        for (let i = 0; i < file.byteLength; i += chunkSize) {
+          const chunk = file.slice(i, i + chunkSize);
+          channel.send(chunk);
+
+          // Wait for buffer to drain if needed
+          while (channel.bufferedAmount > 16 * 1024 * 1024) { // 16MB
+            await new Promise(resolve => setTimeout(resolve, 100));
+          }
+        }
+
+        channel.send(JSON.stringify({ done: true }));
+      }
+    });
+  }
+});
+
+await service.start();
+
+// Client
+const connection = await client.connect('alice', 'files@1.0.0');
+const channel = connection.createChannel('files');
+
+const chunks = [];
+channel.on('message', (data) => {
+  if (typeof data === 'string') {
+    const msg = JSON.parse(data);
+    if (msg.done) {
+      const blob = new Blob(chunks);
+      console.log('Download complete:', blob.size, 'bytes');
+    }
+  } else {
+    chunks.push(data);
+    console.log('Progress:', chunks.length * 16 * 1024, 'bytes');
+  }
+});
+
+await connection.connect();
+channel.send(JSON.stringify({ action: 'download', path: '/file.zip' }));
+```
+
+## Platform-Specific Setup
+
+### Modern Browsers
+Works out of the box - no additional setup needed.
+
+### Node.js 18+
+Native fetch is available, but you need WebRTC polyfills:
+
+```bash
+npm install wrtc
+```
+
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client';
+import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc';
+
+const client = new Rondevu({
+  baseUrl: 'https://api.ronde.vu',
+  RTCPeerConnection,
+  RTCSessionDescription,
+  RTCIceCandidate
+});
+```
+
+### Node.js < 18
+Install both fetch and WebRTC polyfills:
+
+```bash
+npm install node-fetch wrtc
+```
+
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client';
+import fetch from 'node-fetch';
+import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc';
+
+const client = new Rondevu({
+  baseUrl: 'https://api.ronde.vu',
+  fetch: fetch as any,
+  RTCPeerConnection,
+  RTCSessionDescription,
+  RTCIceCandidate
+});
+```
+
+## TypeScript
+
+All types are exported:
+
+```typescript
+import type {
+  // Client types
+  Credentials,
+  RondevuOptions,
+
+  // Username types
+  UsernameCheckResult,
+  UsernameClaimResult,
+
+  // Durable connection types
+  DurableConnectionState,
+  DurableChannelState,
+  DurableConnectionConfig,
+  DurableChannelConfig,
+  DurableServiceConfig,
+  QueuedMessage,
+  DurableConnectionEvents,
+  DurableChannelEvents,
+  DurableServiceEvents,
+  ConnectionInfo,
+  ServiceInfo
+} from '@xtr-dev/rondevu-client';
+```
+
+## Migration from v0.8.x
+
+v0.9.0 is a **breaking change** that replaces the low-level APIs with high-level durable connections. See [MIGRATION.md](./MIGRATION.md) for detailed migration guide.
+
+**Key Changes:**
+- ❌ Removed: `client.services.*`, `client.discovery.*`, `client.createPeer()` (low-level APIs)
+- ✅ Added: `client.exposeService()`, `client.connect()`, `client.connectByUuid()` (durable APIs)
+- ✅ Changed: Focus on durable connections with automatic reconnection and message queuing
+
+## License
 
 MIT

package-lock.json

@@ -0,0 +1,52 @@
+{
+  "name": "@xtr-dev/rondevu-client",
+  "version": "0.9.2",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@xtr-dev/rondevu-client",
+      "version": "0.9.2",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/ed25519": "^3.0.0",
+        "@xtr-dev/rondevu-client": "^0.9.2"
+      },
+      "devDependencies": {
+        "typescript": "^5.9.3"
+      }
+    },
+    "node_modules/@noble/ed25519": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@noble/ed25519/-/ed25519-3.0.0.tgz",
+      "integrity": "sha512-QyteqMNm0GLqfa5SoYbSC3+Pvykwpn95Zgth4MFVSMKBB75ELl9tX1LAVsN4c3HXOrakHsF2gL4zWDAYCcsnzg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@xtr-dev/rondevu-client": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@xtr-dev/rondevu-client/-/rondevu-client-0.9.2.tgz",
+      "integrity": "sha512-DVow5AOPU40dqQtlfQK7J2GNX8dz2/4UzltMqublaPZubbkRYgocvp0b76NQu5F6v150IstMV2N49uxAYqogVw==",
+      "license": "MIT",
+      "dependencies": {
+        "@noble/ed25519": "^3.0.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    }
+  }
+}

package.json

@@ -1,15 +1,14 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.1.2",
-  "description": "TypeScript client for Rondevu peer signaling and discovery server",
+  "version": "0.9.2",
+  "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build",
-    "publish": "npm publish"
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "webrtc",
@@ -26,5 +25,9 @@
   "files": [
     "dist",
     "README.md"
-  ]
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^3.0.0",
+    "@xtr-dev/rondevu-client": "^0.9.2"
+  }
 }

src/client.ts

@@ -1,239 +0,0 @@
-import {
-  RondevuClientOptions,
-  ListTopicsResponse,
-  ListSessionsResponse,
-  CreateOfferRequest,
-  CreateOfferResponse,
-  AnswerRequest,
-  AnswerResponse,
-  PollRequest,
-  PollOffererResponse,
-  PollAnswererResponse,
-  VersionResponse,
-  HealthResponse,
-  ErrorResponse,
-  Side,
-} from './types';
-
-/**
- * HTTP client for Rondevu peer signaling and discovery server
- */
-export class RondevuClient {
-  private readonly baseUrl: string;
-  private readonly fetchImpl: typeof fetch;
-
-  /**
-   * Creates a new Rondevu client instance
-   * @param options - Client configuration options
-   */
-  constructor(options: RondevuClientOptions) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, ''); // Remove trailing slash
-    this.fetchImpl = options.fetch || globalThis.fetch.bind(globalThis);
-  }
-
-  /**
-   * Makes an HTTP request to the Rondevu server
-   */
-  private async request<T>(
-    endpoint: string,
-    options: RequestInit = {}
-  ): Promise<T> {
-    const url = `${this.baseUrl}${endpoint}`;
-
-    const headers: Record<string, string> = {
-      ...(options.headers as Record<string, string>),
-    };
-
-    if (options.body) {
-      headers['Content-Type'] = 'application/json';
-    }
-
-    const response = await this.fetchImpl(url, {
-      ...options,
-      headers,
-    });
-
-    const data = await response.json();
-
-    if (!response.ok) {
-      const error = data as ErrorResponse;
-      throw new Error(error.error || `HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    return data as T;
-  }
-
-  /**
-   * Gets server version information
-   *
-   * @returns Server version (git commit hash)
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   * const { version } = await client.getVersion();
-   * console.log('Server version:', version);
-   * ```
-   */
-  async getVersion(): Promise<VersionResponse> {
-    return this.request<VersionResponse>('/', {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Lists all topics with peer counts
-   *
-   * @param page - Page number (starting from 1)
-   * @param limit - Results per page (max 1000)
-   * @returns List of topics with pagination info
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   * const { topics, pagination } = await client.listTopics();
-   * console.log(`Found ${topics.length} topics`);
-   * ```
-   */
-  async listTopics(page = 1, limit = 100): Promise<ListTopicsResponse> {
-    const params = new URLSearchParams({
-      page: page.toString(),
-      limit: limit.toString(),
-    });
-    return this.request<ListTopicsResponse>(`/topics?${params}`, {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Discovers available peers for a given topic
-   *
-   * @param topic - Topic identifier
-   * @returns List of available sessions
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   * const { sessions } = await client.listSessions('my-room');
-   * const otherPeers = sessions.filter(s => s.peerId !== myPeerId);
-   * ```
-   */
-  async listSessions(topic: string): Promise<ListSessionsResponse> {
-    return this.request<ListSessionsResponse>(`/${encodeURIComponent(topic)}/sessions`, {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Announces peer availability and creates a new session
-   *
-   * @param topic - Topic identifier for grouping peers (max 1024 characters)
-   * @param request - Offer details including peer ID and signaling data
-   * @returns Unique session code (UUID)
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   * const { code } = await client.createOffer('my-room', {
-   *   peerId: 'peer-123',
-   *   offer: signalingData
-   * });
-   * console.log('Session code:', code);
-   * ```
-   */
-  async createOffer(
-    topic: string,
-    request: CreateOfferRequest
-  ): Promise<CreateOfferResponse> {
-    return this.request<CreateOfferResponse>(
-      `/${encodeURIComponent(topic)}/offer`,
-      {
-        method: 'POST',
-        body: JSON.stringify(request),
-      }
-    );
-  }
-
-  /**
-   * Sends an answer or candidate to an existing session
-   *
-   * @param request - Answer details including session code and signaling data
-   * @returns Success confirmation
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   *
-   * // Send answer
-   * await client.sendAnswer({
-   *   code: sessionCode,
-   *   answer: answerData,
-   *   side: 'answerer'
-   * });
-   *
-   * // Send candidate
-   * await client.sendAnswer({
-   *   code: sessionCode,
-   *   candidate: candidateData,
-   *   side: 'offerer'
-   * });
-   * ```
-   */
-  async sendAnswer(request: AnswerRequest): Promise<AnswerResponse> {
-    return this.request<AnswerResponse>('/answer', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
-  }
-
-  /**
-   * Polls for session data from the other peer
-   *
-   * @param code - Session UUID
-   * @param side - Which side is polling ('offerer' or 'answerer')
-   * @returns Session data including offers, answers, and candidates
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   *
-   * // Offerer polls for answer
-   * const offererData = await client.poll(sessionCode, 'offerer');
-   * if (offererData.answer) {
-   *   console.log('Received answer:', offererData.answer);
-   * }
-   *
-   * // Answerer polls for offer
-   * const answererData = await client.poll(sessionCode, 'answerer');
-   * console.log('Received offer:', answererData.offer);
-   * ```
-   */
-  async poll(
-    code: string,
-    side: Side
-  ): Promise<PollOffererResponse | PollAnswererResponse> {
-    const request: PollRequest = { code, side };
-    return this.request<PollOffererResponse | PollAnswererResponse>('/poll', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
-  }
-
-  /**
-   * Checks server health
-   *
-   * @returns Health status and timestamp
-   *
-   * @example
-   * ```typescript
-   * const client = new RondevuClient({ baseUrl: 'https://example.com' });
-   * const health = await client.health();
-   * console.log('Server status:', health.status);
-   * ```
-   */
-  async health(): Promise<HealthResponse> {
-    return this.request<HealthResponse>('/health', {
-      method: 'GET',
-    });
-  }
-}

src/connection-manager.ts

@@ -0,0 +1,9 @@
+/**
+ * ConnectionManager - Manages WebRTC peer connections
+ */
+
+export class ConnectionManager {
+  constructor() {
+    // TODO: Initialize connection manager
+  }
+}

src/connection.ts

@@ -1,310 +0,0 @@
-import { EventEmitter } from './event-emitter';
-import { RondevuClient } from './client';
-import { RondevuConnectionParams } from './types';
-
-/**
- * Represents a WebRTC connection with automatic signaling and ICE exchange
- */
-export class RondevuConnection extends EventEmitter {
-  readonly id: string;
-  readonly topic: string;
-  readonly role: 'offerer' | 'answerer';
-  readonly remotePeerId: string;
-
-  private pc: RTCPeerConnection;
-  private client: RondevuClient;
-  private localPeerId: string;
-  private dataChannels: Map<string, RTCDataChannel>;
-  private pollingInterval?: ReturnType<typeof setInterval>;
-  private pollingIntervalMs: number;
-  private connectionTimeoutMs: number;
-  private connectionTimer?: ReturnType<typeof setTimeout>;
-  private isPolling: boolean = false;
-  private isClosed: boolean = false;
-
-  constructor(params: RondevuConnectionParams, client: RondevuClient) {
-    super();
-    this.id = params.id;
-    this.topic = params.topic;
-    this.role = params.role;
-    this.pc = params.pc;
-    this.localPeerId = params.localPeerId;
-    this.remotePeerId = params.remotePeerId;
-    this.client = client;
-    this.dataChannels = new Map();
-    this.pollingIntervalMs = params.pollingInterval;
-    this.connectionTimeoutMs = params.connectionTimeout;
-
-    this.setupEventHandlers();
-    this.startConnectionTimeout();
-  }
-
-  /**
-   * Setup RTCPeerConnection event handlers
-   */
-  private setupEventHandlers(): void {
-    // ICE candidate gathering
-    this.pc.onicecandidate = (event) => {
-      if (event.candidate && !this.isClosed) {
-        this.sendIceCandidate(event.candidate).catch((err) => {
-          this.emit('error', new Error(`Failed to send ICE candidate: ${err.message}`));
-        });
-      }
-    };
-
-    // Connection state changes
-    this.pc.onconnectionstatechange = () => {
-      this.handleConnectionStateChange();
-    };
-
-    // Remote data channels
-    this.pc.ondatachannel = (event) => {
-      this.handleRemoteDataChannel(event.channel);
-    };
-
-    // Remote media streams
-    this.pc.ontrack = (event) => {
-      if (event.streams && event.streams[0]) {
-        this.emit('stream', event.streams[0]);
-      }
-    };
-
-    // ICE connection state changes
-    this.pc.oniceconnectionstatechange = () => {
-      const state = this.pc.iceConnectionState;
-
-      if (state === 'failed' || state === 'closed') {
-        this.emit('error', new Error(`ICE connection ${state}`));
-        if (state === 'failed') {
-          this.close();
-        }
-      }
-    };
-  }
-
-  /**
-   * Handle RTCPeerConnection state changes
-   */
-  private handleConnectionStateChange(): void {
-    const state = this.pc.connectionState;
-
-    switch (state) {
-      case 'connected':
-        this.clearConnectionTimeout();
-        this.stopPolling();
-        this.emit('connect');
-        break;
-
-      case 'disconnected':
-        this.emit('disconnect');
-        break;
-
-      case 'failed':
-        this.emit('error', new Error('Connection failed'));
-        this.close();
-        break;
-
-      case 'closed':
-        this.emit('disconnect');
-        break;
-    }
-  }
-
-  /**
-   * Send an ICE candidate to the remote peer via signaling server
-   */
-  private async sendIceCandidate(candidate: RTCIceCandidate): Promise<void> {
-    try {
-      await this.client.sendAnswer({
-        code: this.id,
-        candidate: JSON.stringify(candidate.toJSON()),
-        side: this.role,
-      });
-    } catch (err: any) {
-      throw new Error(`Failed to send ICE candidate: ${err.message}`);
-    }
-  }
-
-  /**
-   * Start polling for remote session data (answer/candidates)
-   */
-  startPolling(): void {
-    if (this.isPolling || this.isClosed) {
-      return;
-    }
-
-    this.isPolling = true;
-
-    // Poll immediately
-    this.poll().catch((err) => {
-      this.emit('error', new Error(`Poll error: ${err.message}`));
-    });
-
-    // Set up interval polling
-    this.pollingInterval = setInterval(() => {
-      this.poll().catch((err) => {
-        this.emit('error', new Error(`Poll error: ${err.message}`));
-      });
-    }, this.pollingIntervalMs);
-  }
-
-  /**
-   * Stop polling
-   */
-  private stopPolling(): void {
-    this.isPolling = false;
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = undefined;
-    }
-  }
-
-  /**
-   * Poll the signaling server for remote data
-   */
-  private async poll(): Promise<void> {
-    if (this.isClosed) {
-      this.stopPolling();
-      return;
-    }
-
-    try {
-      const response = await this.client.poll(this.id, this.role);
-
-      if (this.role === 'offerer') {
-        const offererResponse = response as { answer: string | null; answerCandidates: string[] };
-
-        // Apply answer if received and not yet applied
-        if (offererResponse.answer && !this.pc.currentRemoteDescription) {
-          await this.pc.setRemoteDescription({
-            type: 'answer',
-            sdp: offererResponse.answer,
-          });
-        }
-
-        // Apply ICE candidates
-        if (offererResponse.answerCandidates && offererResponse.answerCandidates.length > 0) {
-          for (const candidateStr of offererResponse.answerCandidates) {
-            try {
-              const candidate = JSON.parse(candidateStr);
-              await this.pc.addIceCandidate(new RTCIceCandidate(candidate));
-            } catch (err) {
-              console.warn('Failed to add ICE candidate:', err);
-            }
-          }
-        }
-      } else {
-        // Answerer role
-        const answererResponse = response as { offer: string; offerCandidates: string[] };
-
-        // Apply ICE candidates from offerer
-        if (answererResponse.offerCandidates && answererResponse.offerCandidates.length > 0) {
-          for (const candidateStr of answererResponse.offerCandidates) {
-            try {
-              const candidate = JSON.parse(candidateStr);
-              await this.pc.addIceCandidate(new RTCIceCandidate(candidate));
-            } catch (err) {
-              console.warn('Failed to add ICE candidate:', err);
-            }
-          }
-        }
-      }
-    } catch (err: any) {
-      // Session not found or expired
-      if (err.message.includes('404') || err.message.includes('not found')) {
-        this.emit('error', new Error('Session not found or expired'));
-        this.close();
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Handle remotely created data channel
-   */
-  private handleRemoteDataChannel(channel: RTCDataChannel): void {
-    this.dataChannels.set(channel.label, channel);
-    this.emit('datachannel', channel);
-  }
-
-  /**
-   * Get or create a data channel
-   */
-  dataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel {
-    let channel = this.dataChannels.get(label);
-
-    if (!channel) {
-      channel = this.pc.createDataChannel(label, options);
-      this.dataChannels.set(label, channel);
-    }
-
-    return channel;
-  }
-
-  /**
-   * Add a local media stream to the connection
-   */
-  addStream(stream: MediaStream): void {
-    stream.getTracks().forEach(track => {
-      this.pc.addTrack(track, stream);
-    });
-  }
-
-  /**
-   * Get the underlying RTCPeerConnection for advanced usage
-   */
-  getPeerConnection(): RTCPeerConnection {
-    return this.pc;
-  }
-
-  /**
-   * Start connection timeout
-   */
-  private startConnectionTimeout(): void {
-    this.connectionTimer = setTimeout(() => {
-      if (this.pc.connectionState !== 'connected') {
-        this.emit('error', new Error('Connection timeout'));
-        this.close();
-      }
-    }, this.connectionTimeoutMs);
-  }
-
-  /**
-   * Clear connection timeout
-   */
-  private clearConnectionTimeout(): void {
-    if (this.connectionTimer) {
-      clearTimeout(this.connectionTimer);
-      this.connectionTimer = undefined;
-    }
-  }
-
-  /**
-   * Close the connection and cleanup resources
-   */
-  close(): void {
-    if (this.isClosed) {
-      return;
-    }
-
-    this.isClosed = true;
-
-    this.stopPolling();
-    this.clearConnectionTimeout();
-
-    // Close all data channels
-    this.dataChannels.forEach(dc => {
-      if (dc.readyState === 'open' || dc.readyState === 'connecting') {
-        dc.close();
-      }
-    });
-    this.dataChannels.clear();
-
-    // Close peer connection
-    if (this.pc.connectionState !== 'closed') {
-      this.pc.close();
-    }
-
-    this.emit('disconnect');
-  }
-}

src/event-bus.ts

@@ -0,0 +1,104 @@
+/**
+ * Type-safe EventBus with event name to payload type mapping
+ */
+
+type EventHandler<T = any> = (data: T) => void;
+
+/**
+ * EventBus - Type-safe event emitter with inferred event data types
+ *
+ * @example
+ * interface MyEvents {
+ *   'user:connected': { userId: string; timestamp: number };
+ *   'user:disconnected': { userId: string };
+ *   'message:received': string;
+ * }
+ *
+ * const bus = new EventBus<MyEvents>();
+ *
+ * // TypeScript knows data is { userId: string; timestamp: number }
+ * bus.on('user:connected', (data) => {
+ *   console.log(data.userId, data.timestamp);
+ * });
+ *
+ * // TypeScript knows data is string
+ * bus.on('message:received', (data) => {
+ *   console.log(data.toUpperCase());
+ * });
+ */
+export class EventBus<TEvents extends Record<string, any>> {
+  private handlers: Map<keyof TEvents, Set<EventHandler>>;
+
+  constructor() {
+    this.handlers = new Map();
+  }
+
+  /**
+   * Subscribe to an event
+   */
+  on<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, new Set());
+    }
+    this.handlers.get(event)!.add(handler);
+  }
+
+  /**
+   * Subscribe to an event once (auto-unsubscribe after first call)
+   */
+  once<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void {
+    const wrappedHandler = (data: TEvents[K]) => {
+      handler(data);
+      this.off(event, wrappedHandler);
+    };
+    this.on(event, wrappedHandler);
+  }
+
+  /**
+   * Unsubscribe from an event
+   */
+  off<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.delete(handler);
+      if (eventHandlers.size === 0) {
+        this.handlers.delete(event);
+      }
+    }
+  }
+
+  /**
+   * Emit an event with data
+   */
+  emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void {
+    const eventHandlers = this.handlers.get(event);
+    if (eventHandlers) {
+      eventHandlers.forEach(handler => handler(data));
+    }
+  }
+
+  /**
+   * Remove all handlers for a specific event, or all handlers if no event specified
+   */
+  clear<K extends keyof TEvents>(event?: K): void {
+    if (event !== undefined) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+
+  /**
+   * Get count of handlers for an event
+   */
+  listenerCount<K extends keyof TEvents>(event: K): number {
+    return this.handlers.get(event)?.size ?? 0;
+  }
+
+  /**
+   * Get all event names that have handlers
+   */
+  eventNames(): Array<keyof TEvents> {
+    return Array.from(this.handlers.keys());
+  }
+}

src/event-emitter.ts

@@ -1,86 +0,0 @@
-/**
- * Simple EventEmitter implementation for browser and Node.js compatibility
- */
-export class EventEmitter {
-  private events: Map<string, Set<Function>>;
-
-  constructor() {
-    this.events = new Map();
-  }
-
-  /**
-   * Register an event listener
-   */
-  on(event: string, listener: Function): this {
-    if (!this.events.has(event)) {
-      this.events.set(event, new Set());
-    }
-    this.events.get(event)!.add(listener);
-    return this;
-  }
-
-  /**
-   * Register a one-time event listener
-   */
-  once(event: string, listener: Function): this {
-    const onceWrapper = (...args: any[]) => {
-      this.off(event, onceWrapper);
-      listener.apply(this, args);
-    };
-    return this.on(event, onceWrapper);
-  }
-
-  /**
-   * Remove an event listener
-   */
-  off(event: string, listener: Function): this {
-    const listeners = this.events.get(event);
-    if (listeners) {
-      listeners.delete(listener);
-      if (listeners.size === 0) {
-        this.events.delete(event);
-      }
-    }
-    return this;
-  }
-
-  /**
-   * Emit an event
-   */
-  emit(event: string, ...args: any[]): boolean {
-    const listeners = this.events.get(event);
-    if (!listeners || listeners.size === 0) {
-      return false;
-    }
-
-    listeners.forEach(listener => {
-      try {
-        listener.apply(this, args);
-      } catch (err) {
-        console.error(`Error in ${event} event listener:`, err);
-      }
-    });
-
-    return true;
-  }
-
-  /**
-   * Remove all listeners for an event (or all events if not specified)
-   */
-  removeAllListeners(event?: string): this {
-    if (event) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-
-  /**
-   * Get listener count for an event
-   */
-  listenerCount(event: string): number {
-    const listeners = this.events.get(event);
-    return listeners ? listeners.size : 0;
-  }
-}

src/index.ts

@@ -1,42 +1,16 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client
+ * WebRTC peer signaling client
  */
 
-// Export main WebRTC client class
-export { Rondevu } from './rondevu';
+export { ConnectionManager } from './connection-manager.js';
+export { EventBus } from './event-bus.js';
 
-// Export connection class
-export { RondevuConnection } from './connection';
-
-// Export low-level signaling client (for advanced usage)
-export { RondevuClient } from './client';
-
-// Export all types
+// Export types
 export type {
-  // WebRTC types
-  RondevuOptions,
-  JoinOptions,
-  ConnectionRole,
-  RondevuConnectionParams,
-  RondevuConnectionEvents,
-  // Signaling types
-  Side,
-  Session,
-  TopicInfo,
-  Pagination,
-  ListTopicsResponse,
-  ListSessionsResponse,
-  CreateOfferRequest,
-  CreateOfferResponse,
-  AnswerRequest,
-  AnswerResponse,
-  PollRequest,
-  PollOffererResponse,
-  PollAnswererResponse,
-  PollResponse,
-  VersionResponse,
-  HealthResponse,
-  ErrorResponse,
-  RondevuClientOptions,
-} from './types';
+  ConnectionIdentity,
+  ConnectionState,
+  ConnectionInterface,
+  Connection,
+  QueueMessageOptions
+} from './types.js';

src/rondevu.ts

@@ -1,273 +0,0 @@
-import { RondevuClient } from './client';
-import { RondevuConnection } from './connection';
-import { RondevuOptions, JoinOptions, RondevuConnectionParams } from './types';
-
-/**
- * Main Rondevu WebRTC client with automatic connection management
- */
-export class Rondevu {
-  readonly peerId: string;
-
-  private client: RondevuClient;
-  private baseUrl: string;
-  private fetchImpl?: typeof fetch;
-  private rtcConfig?: RTCConfiguration;
-  private pollingInterval: number;
-  private connectionTimeout: number;
-
-  /**
-   * Creates a new Rondevu client instance
-   * @param options - Client configuration options
-   */
-  constructor(options: RondevuOptions = {}) {
-    this.baseUrl = options.baseUrl || 'https://rondevu.xtrdev.workers.dev';
-    this.fetchImpl = options.fetch;
-
-    this.client = new RondevuClient({
-      baseUrl: this.baseUrl,
-      fetch: options.fetch,
-    });
-
-    // Auto-generate peer ID if not provided
-    this.peerId = options.peerId || this.generatePeerId();
-    this.rtcConfig = options.rtcConfig;
-    this.pollingInterval = options.pollingInterval || 1000;
-    this.connectionTimeout = options.connectionTimeout || 30000;
-  }
-
-  /**
-   * Generate a unique peer ID
-   */
-  private generatePeerId(): string {
-    return `rdv_${Math.random().toString(36).substring(2, 14)}`;
-  }
-
-  /**
-   * Update the peer ID (useful when user identity changes)
-   */
-  updatePeerId(newPeerId: string): void {
-    (this as any).peerId = newPeerId;
-  }
-
-  /**
-   * Create a new connection (offerer role)
-   * @param id - Connection identifier
-   * @param topic - Topic name for grouping connections
-   * @returns Promise that resolves to RondevuConnection
-   */
-  async create(id: string, topic: string): Promise<RondevuConnection> {
-    // Create peer connection
-    const pc = new RTCPeerConnection(this.rtcConfig);
-
-    // Create initial data channel for negotiation (required for offer creation)
-    pc.createDataChannel('_negotiation');
-
-    // Generate offer
-    const offer = await pc.createOffer();
-    await pc.setLocalDescription(offer);
-
-    // Wait for ICE gathering to complete
-    await this.waitForIceGathering(pc);
-
-    // Create session on server with custom code
-    await this.client.createOffer(topic, {
-      peerId: this.peerId,
-      offer: pc.localDescription!.sdp,
-      code: id,
-    });
-
-    // Create connection object
-    const connectionParams: RondevuConnectionParams = {
-      id,
-      topic,
-      role: 'offerer',
-      pc,
-      localPeerId: this.peerId,
-      remotePeerId: '', // Will be populated when answer is received
-      pollingInterval: this.pollingInterval,
-      connectionTimeout: this.connectionTimeout,
-    };
-
-    const connection = new RondevuConnection(connectionParams, this.client);
-
-    // Start polling for answer
-    connection.startPolling();
-
-    return connection;
-  }
-
-  /**
-   * Connect to an existing connection by ID (answerer role)
-   * @param id - Connection identifier
-   * @returns Promise that resolves to RondevuConnection
-   */
-  async connect(id: string): Promise<RondevuConnection> {
-    // Poll server to get session by ID
-    const sessionData = await this.findSessionByIdWithClient(id, this.client);
-
-    if (!sessionData) {
-      throw new Error(`Connection ${id} not found or expired`);
-    }
-
-    // Create peer connection
-    const pc = new RTCPeerConnection(this.rtcConfig);
-
-    // Set remote offer
-    await pc.setRemoteDescription({
-      type: 'offer',
-      sdp: sessionData.offer,
-    });
-
-    // Generate answer
-    const answer = await pc.createAnswer();
-    await pc.setLocalDescription(answer);
-
-    // Wait for ICE gathering
-    await this.waitForIceGathering(pc);
-
-    // Send answer to server
-    await this.client.sendAnswer({
-      code: id,
-      answer: pc.localDescription!.sdp,
-      side: 'answerer',
-    });
-
-    // Create connection object
-    const connectionParams: RondevuConnectionParams = {
-      id,
-      topic: sessionData.topic || 'unknown',
-      role: 'answerer',
-      pc,
-      localPeerId: this.peerId,
-      remotePeerId: sessionData.peerId,
-      pollingInterval: this.pollingInterval,
-      connectionTimeout: this.connectionTimeout,
-    };
-
-    const connection = new RondevuConnection(connectionParams, this.client);
-
-    // Start polling for ICE candidates
-    connection.startPolling();
-
-    return connection;
-  }
-
-  /**
-   * Join a topic and discover available peers (answerer role)
-   * @param topic - Topic name
-   * @param options - Optional join options for filtering and selection
-   * @returns Promise that resolves to RondevuConnection
-   */
-  async join(topic: string, options?: JoinOptions): Promise<RondevuConnection> {
-    // List sessions in topic
-    const { sessions } = await this.client.listSessions(topic);
-
-    // Filter out self (sessions with our peer ID)
-    let availableSessions = sessions.filter(
-      session => session.peerId !== this.peerId
-    );
-
-    // Apply custom filter if provided
-    if (options?.filter) {
-      availableSessions = availableSessions.filter(options.filter);
-    }
-
-    if (availableSessions.length === 0) {
-      throw new Error(`No available peers in topic: ${topic}`);
-    }
-
-    // Select session based on strategy
-    const selectedSession = this.selectSession(
-      availableSessions,
-      options?.select || 'first'
-    );
-
-    // Connect to selected session
-    return this.connect(selectedSession.code);
-  }
-
-  /**
-   * Select a session based on strategy
-   */
-  private selectSession(
-    sessions: Array<{ code: string; peerId: string; createdAt: number }>,
-    strategy: 'first' | 'newest' | 'oldest' | 'random'
-  ): { code: string; peerId: string; createdAt: number } {
-    switch (strategy) {
-      case 'first':
-        return sessions[0];
-      case 'newest':
-        return sessions.reduce((newest, session) =>
-          session.createdAt > newest.createdAt ? session : newest
-        );
-      case 'oldest':
-        return sessions.reduce((oldest, session) =>
-          session.createdAt < oldest.createdAt ? session : oldest
-        );
-      case 'random':
-        return sessions[Math.floor(Math.random() * sessions.length)];
-      default:
-        return sessions[0];
-    }
-  }
-
-  /**
-   * Wait for ICE gathering to complete
-   */
-  private async waitForIceGathering(pc: RTCPeerConnection): Promise<void> {
-    if (pc.iceGatheringState === 'complete') {
-      return;
-    }
-
-    return new Promise((resolve) => {
-      const checkState = () => {
-        if (pc.iceGatheringState === 'complete') {
-          pc.removeEventListener('icegatheringstatechange', checkState);
-          resolve();
-        }
-      };
-
-      pc.addEventListener('icegatheringstatechange', checkState);
-
-      // Also set a timeout in case gathering takes too long
-      setTimeout(() => {
-        pc.removeEventListener('icegatheringstatechange', checkState);
-        resolve();
-      }, 5000);
-    });
-  }
-
-  /**
-   * Find a session by connection ID
-   * This requires polling since we don't know which topic it's in
-   */
-  private async findSessionByIdWithClient(
-    id: string,
-    client: RondevuClient
-  ): Promise<{
-    code: string;
-    peerId: string;
-    offer: string;
-    topic?: string;
-  } | null> {
-    try {
-      // Try to poll for the session directly
-      // The poll endpoint should return the session data
-      const response = await client.poll(id, 'answerer');
-      const answererResponse = response as { offer: string; offerCandidates: string[] };
-
-      if (answererResponse.offer) {
-        return {
-          code: id,
-          peerId: '', // Will be populated from session data
-          offer: answererResponse.offer,
-          topic: undefined,
-        };
-      }
-
-      return null;
-    } catch (err) {
-      throw new Error(`Failed to find session ${id}: ${(err as Error).message}`);
-    }
-  }
-}

src/types.ts

@@ -1,236 +1,24 @@
-// ============================================================================
-// Signaling Types
-// ============================================================================
-
 /**
- * Session side - identifies which peer in a connection
+ * Core connection types
  */
-export type Side = 'offerer' | 'answerer';
 
-/**
- * Session information returned from discovery endpoints
- */
-export interface Session {
-  /** Unique session identifier (UUID) */
-  code: string;
-  /** Peer identifier/metadata */
-  peerId: string;
-  /** Signaling data for peer connection */
-  offer: string;
-  /** Additional signaling data from offerer */
-  offerCandidates: string[];
-  /** Unix timestamp when session was created */
-  createdAt: number;
-  /** Unix timestamp when session expires */
-  expiresAt: number;
+export interface ConnectionIdentity {
+    id: string;
+    hostUsername: string;
 }
 
-/**
- * Topic information with peer count
- */
-export interface TopicInfo {
-  /** Topic identifier */
-  topic: string;
-  /** Number of available peers in this topic */
-  count: number;
+export interface ConnectionState {
+    state: 'connected' | 'disconnected' | 'connecting';
+    lastActive: number;
 }
 
-/**
- * Pagination information
- */
-export interface Pagination {
-  /** Current page number */
-  page: number;
-  /** Results per page */
-  limit: number;
-  /** Total number of results */
-  total: number;
-  /** Whether there are more results available */
-  hasMore: boolean;
+export interface QueueMessageOptions {
+    expiresAt?: number;
 }
 
-/**
- * Response from GET / - list all topics
- */
-export interface ListTopicsResponse {
-  topics: TopicInfo[];
-  pagination: Pagination;
+export interface ConnectionInterface {
+    queueMessage(message: string | ArrayBuffer, options?: QueueMessageOptions): void;
+    sendMessage(message: string | ArrayBuffer): void;
 }
 
-/**
- * Response from GET /:topic/sessions - list sessions in a topic
- */
-export interface ListSessionsResponse {
-  sessions: Session[];
-}
-
-/**
- * Request body for POST /:topic/offer
- */
-export interface CreateOfferRequest {
-  /** Peer identifier/metadata (max 1024 characters) */
-  peerId: string;
-  /** Signaling data for peer connection */
-  offer: string;
-  /** Optional custom connection code (if not provided, server generates UUID) */
-  code?: string;
-}
-
-/**
- * Response from POST /:topic/offer
- */
-export interface CreateOfferResponse {
-  /** Unique session identifier (UUID) */
-  code: string;
-}
-
-/**
- * Request body for POST /answer
- */
-export interface AnswerRequest {
-  /** Session UUID from the offer */
-  code: string;
-  /** Response signaling data (required if candidate not provided) */
-  answer?: string;
-  /** Additional signaling data (required if answer not provided) */
-  candidate?: string;
-  /** Which peer is sending the data */
-  side: Side;
-}
-
-/**
- * Response from POST /answer
- */
-export interface AnswerResponse {
-  success: boolean;
-}
-
-/**
- * Request body for POST /poll
- */
-export interface PollRequest {
-  /** Session UUID */
-  code: string;
-  /** Which side is polling */
-  side: Side;
-}
-
-/**
- * Response from POST /poll when side=offerer
- */
-export interface PollOffererResponse {
-  /** Answer from answerer (null if not yet received) */
-  answer: string | null;
-  /** Additional signaling data from answerer */
-  answerCandidates: string[];
-}
-
-/**
- * Response from POST /poll when side=answerer
- */
-export interface PollAnswererResponse {
-  /** Offer from offerer */
-  offer: string;
-  /** Additional signaling data from offerer */
-  offerCandidates: string[];
-}
-
-/**
- * Response from POST /poll (union type)
- */
-export type PollResponse = PollOffererResponse | PollAnswererResponse;
-
-/**
- * Response from GET / - server version information
- */
-export interface VersionResponse {
-  /** Git commit hash or version identifier */
-  version: string;
-}
-
-/**
- * Response from GET /health
- */
-export interface HealthResponse {
-  status: 'ok';
-  timestamp: number;
-}
-
-/**
- * Error response structure
- */
-export interface ErrorResponse {
-  error: string;
-}
-
-/**
- * Client configuration options
- */
-export interface RondevuClientOptions {
-  /** Base URL of the Rondevu server (e.g., 'https://example.com') */
-  baseUrl: string;
-  /** Optional fetch implementation (for Node.js environments) */
-  fetch?: typeof fetch;
-}
-
-// ============================================================================
-// WebRTC Types
-// ============================================================================
-
-/**
- * Configuration options for Rondevu WebRTC client
- */
-export interface RondevuOptions {
-  /** Base URL of the Rondevu server (defaults to 'https://rondevu.xtrdev.workers.dev') */
-  baseUrl?: string;
-  /** Peer identifier (optional, auto-generated if not provided) */
-  peerId?: string;
-  /** Optional fetch implementation (for Node.js environments) */
-  fetch?: typeof fetch;
-  /** WebRTC configuration (ICE servers, etc.) */
-  rtcConfig?: RTCConfiguration;
-  /** Polling interval in milliseconds (default: 1000) */
-  pollingInterval?: number;
-  /** Connection timeout in milliseconds (default: 30000) */
-  connectionTimeout?: number;
-}
-
-/**
- * Options for joining a topic
- */
-export interface JoinOptions {
-  /** Filter function to select specific sessions */
-  filter?: (session: { code: string; peerId: string }) => boolean;
-  /** Selection strategy for choosing a session */
-  select?: 'first' | 'newest' | 'oldest' | 'random';
-}
-
-/**
- * Connection role - whether this peer is creating or answering
- */
-export type ConnectionRole = 'offerer' | 'answerer';
-
-/**
- * Parameters for creating a RondevuConnection
- */
-export interface RondevuConnectionParams {
-  id: string;
-  topic: string;
-  role: ConnectionRole;
-  pc: RTCPeerConnection;
-  localPeerId: string;
-  remotePeerId: string;
-  pollingInterval: number;
-  connectionTimeout: number;
-}
-
-/**
- * Event map for RondevuConnection events
- */
-export interface RondevuConnectionEvents {
-  connect: () => void;
-  disconnect: () => void;
-  error: (error: Error) => void;
-  datachannel: (channel: RTCDataChannel) => void;
-  stream: (stream: MediaStream) => void;
-}
+export type Connection = ConnectionIdentity & ConnectionState & ConnectionInterface;