feat: update client to use service-based signaling endpoints

BREAKING CHANGE: Client API now uses service UUIDs for WebRTC signaling

- Replace answerOffer() with answerService()
- Replace getAnswer() with getServiceAnswer()
- Replace addIceCandidates() with addServiceIceCandidates()
- Replace getIceCandidates() with getServiceIceCandidates()
- Update RondevuSignaler to use service UUID instead of offer ID for signaling
- Automatically track offerId returned from service endpoints
- Bump version to 0.12.0

Matches server v0.4.0 service-based API refactor.

.prettierrc.json

@@ -0,0 +1,9 @@
+{
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 4,
+    "useTabs": false,
+    "trailingComma": "es5",
+    "printWidth": 100,
+    "arrowParens": "avoid"
+}

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,25 +1,30 @@
-# @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)
 
-🌐 **Topic-based peer discovery and WebRTC signaling client**
+🌐 **Simple, high-level WebRTC peer-to-peer connections**
 
-TypeScript/JavaScript client for Rondevu, providing topic-based peer discovery, stateless authentication, and complete WebRTC signaling.
+TypeScript/JavaScript client for Rondevu, providing easy-to-use WebRTC connections with automatic signaling, username-based discovery, and built-in reconnection support.
 
 **Related repositories:**
-- [rondevu-server](https://github.com/xtr-dev/rondevu) - HTTP signaling server
+- [@xtr-dev/rondevu-client](https://github.com/xtr-dev/rondevu-client) - TypeScript client library ([npm](https://www.npmjs.com/package/@xtr-dev/rondevu-client))
-- [rondevu-demo](https://rondevu-demo.pages.dev) - Interactive demo
+- [@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
 
-- **Topic-Based Discovery**: Find peers by topics (e.g., torrent infohashes)
+- **High-Level Wrappers**: ServiceHost and ServiceClient eliminate WebRTC boilerplate
-- **Stateless Authentication**: No server-side sessions, portable credentials
+- **Username-Based Discovery**: Connect to peers by username, not complex offer/answer exchange
-- **Bloom Filters**: Efficient peer exclusion for repeated discoveries
+- **Semver-Compatible Matching**: Requesting chat@1.0.0 matches any compatible 1.x.x version
-- **Multi-Offer Management**: Create and manage multiple offers per peer
+- **Privacy-First Design**: Services are hidden by default - no enumeration possible
-- **Complete WebRTC Signaling**: Full offer/answer and ICE candidate exchange
+- **Automatic Reconnection**: Built-in retry logic with exponential backoff
+- **Message Queuing**: Messages sent while disconnected are queued and flushed on reconnect
+- **Cryptographic Username Claiming**: Secure ownership with Ed25519 signatures
+- **Service Publishing**: Package-style naming (chat.app@1.0.0) with multiple simultaneous offers
 - **TypeScript**: Full type safety and autocomplete
+- **Configurable Polling**: Exponential backoff with jitter to reduce server load
 
 ## Install
 
@@ -29,376 +34,400 @@ npm install @xtr-dev/rondevu-client
 
 ## Quick Start
 
-The easiest way to use Rondevu is with the high-level `RondevuConnection` class, which handles all WebRTC connection complexity including offer/answer exchange, ICE candidates, and connection lifecycle.
+### Hosting a Service (Alice)
-
-### Creating an Offer (Peer A)
 
 ```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
+import { RondevuService, ServiceHost } from '@xtr-dev/rondevu-client'
 
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+// Step 1: Create and initialize service
-await client.register();
+const service = new RondevuService({
+    apiUrl: 'https://api.ronde.vu',
+    username: 'alice'
+})
 
-// Create a connection
+await service.initialize()  // Generates keypair
-const conn = client.createConnection();
+await service.claimUsername()  // Claims username with signature
 
-// Set up event listeners
+// Step 2: Create ServiceHost
-conn.on('connected', () => {
+const host = new ServiceHost({
-  console.log('Connected to peer!');
+    service: 'chat.app@1.0.0',
-});
+    rondevuService: service,
+    maxPeers: 5,  // Accept up to 5 connections
+    ttl: 300000   // 5 minutes
+})
 
-conn.on('datachannel', (channel) => {
+// Step 3: Listen for incoming connections
-  console.log('Data channel ready');
+host.events.on('connection', (connection) => {
+    console.log('✅ New connection!')
 
-  channel.onmessage = (event) => {
+    connection.events.on('message', (msg) => {
-    console.log('Received:', event.data);
+        console.log('📨 Received:', msg)
-  };
+        connection.sendMessage('Hello from Alice!')
+    })
 
-  channel.send('Hello from peer A!');
+    connection.events.on('state-change', (state) => {
-});
+        console.log('Connection state:', state)
+    })
+})
 
-// Create offer and advertise on topics
+host.events.on('error', (error) => {
-const offerId = await conn.createOffer({
+    console.error('Host error:', error)
-  topics: ['my-app', 'room-123'],
+})
-  ttl: 300000  // 5 minutes
-});
 
-console.log('Offer created:', offerId);
+// Step 4: Start hosting
-console.log('Share these topics with peers:', ['my-app', 'room-123']);
+await host.start()
+console.log('Service is now live! Others can connect to @alice')
+
+// Later: stop hosting
+host.dispose()
 ```
 
-### Answering an Offer (Peer B)
+### Connecting to a Service (Bob)
 
 ```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
+import { RondevuService, ServiceClient } from '@xtr-dev/rondevu-client'
 
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+// Step 1: Create and initialize service
-await client.register();
+const service = new RondevuService({
+    apiUrl: 'https://api.ronde.vu',
+    username: 'bob'
+})
 
-// Discover offers by topic
+await service.initialize()
-const offers = await client.offers.findByTopic('my-app', { limit: 10 });
+await service.claimUsername()
 
-if (offers.length > 0) {
+// Step 2: Create ServiceClient
-  const offer = offers[0];
+const client = new ServiceClient({
+    username: 'alice',  // Connect to Alice
+    serviceFqn: 'chat.app@1.0.0',
+    rondevuService: service,
+    autoReconnect: true,
+    maxReconnectAttempts: 5
+})
 
-  // Create connection
+// Step 3: Listen for connection events
-  const conn = client.createConnection();
+client.events.on('connected', (connection) => {
+    console.log('✅ Connected to Alice!')
 
-  // Set up event listeners
+    connection.events.on('message', (msg) => {
-  conn.on('connecting', () => {
+        console.log('📨 Received:', msg)
-    console.log('Connecting...');
+    })
-  });
 
-  conn.on('connected', () => {
+    // Send a message
-    console.log('Connected!');
+    connection.sendMessage('Hello from Bob!')
-  });
+})
 
-  conn.on('datachannel', (channel) => {
+client.events.on('disconnected', () => {
-    console.log('Data channel ready');
+    console.log('🔌 Disconnected')
+})
 
-    channel.onmessage = (event) => {
+client.events.on('reconnecting', ({ attempt, maxAttempts }) => {
-      console.log('Received:', event.data);
+    console.log(`🔄 Reconnecting (${attempt}/${maxAttempts})...`)
-    };
+})
 
-    channel.send('Hello from peer B!');
+client.events.on('error', (error) => {
-  });
+    console.error('❌ Error:', error)
+})
 
-  // Answer the offer
+// Step 4: Connect
-  await conn.answer(offer.id, offer.sdp);
+await client.connect()
-}
+
+// Later: disconnect
+client.dispose()
 ```
 
-### Connection Events
+## Core Concepts
 
-```typescript
+### RondevuService
-conn.on('connecting', () => {
-  // Connection is being established
-});
 
-conn.on('connected', () => {
+Handles authentication and username management:
-  // Connection established successfully
+- Generates Ed25519 keypair for signing
-});
+- Claims usernames with cryptographic proof
+- Provides API client for signaling server
 
-conn.on('disconnected', () => {
+### ServiceHost
-  // Connection lost or closed
-});
 
-conn.on('error', (error) => {
+High-level wrapper for hosting a WebRTC service:
-  // An error occurred
+- Automatically creates and publishes offers
-  console.error('Connection error:', error);
+- Handles incoming connections
-});
+- Manages ICE candidate exchange
+- Supports multiple simultaneous peers
 
-conn.on('datachannel', (channel) => {
+### ServiceClient
-  // Data channel is ready to use
-});
 
-conn.on('track', (event) => {
+High-level wrapper for connecting to services:
-  // Media track received (for audio/video streaming)
+- Discovers services by username
-  const stream = event.streams[0];
+- Handles offer/answer exchange automatically
-  videoElement.srcObject = stream;
+- Built-in auto-reconnection with exponential backoff
-});
+- Event-driven API
-```
 
-### Adding Media Tracks
+### RTCDurableConnection
 
-```typescript
+Low-level connection wrapper (used internally):
-// Get user's camera/microphone
+- Manages WebRTC PeerConnection lifecycle
-const stream = await navigator.mediaDevices.getUserMedia({
+- Handles ICE candidate polling
-  video: true,
+- Provides message queue for reliability
-  audio: true
+- State management and events
-});
-
-// Add tracks to connection
-stream.getTracks().forEach(track => {
-  conn.addTrack(track, stream);
-});
-```
-
-### Connection Properties
-
-```typescript
-// Get connection state
-console.log(conn.connectionState); // 'connecting', 'connected', 'disconnected', etc.
-
-// Get offer ID
-console.log(conn.id);
-
-// Get data channel
-console.log(conn.channel);
-```
-
-### Closing a Connection
-
-```typescript
-conn.close();
-```
-
-## Platform-Specific Setup
-
-### Node.js 18+ (with native fetch)
-
-Works out of the box - no additional setup needed.
-
-### Node.js < 18 (without native fetch)
-
-Install node-fetch and provide it to the client:
-
-```bash
-npm install node-fetch
-```
-
-```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
-import fetch from 'node-fetch';
-
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu',
-  fetch: fetch as any
-});
-```
-
-### Deno
-
-```typescript
-import { Rondevu } from 'npm:@xtr-dev/rondevu-client';
-
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu'
-});
-```
-
-### Bun
-
-Works out of the box - no additional setup needed.
-
-### Cloudflare Workers
-
-```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
-
-export default {
-  async fetch(request: Request, env: Env) {
-    const client = new Rondevu({
-      baseUrl: 'https://api.ronde.vu'
-    });
-
-    const creds = await client.register();
-    return new Response(JSON.stringify(creds));
-  }
-};
-```
-
-## Low-Level API Usage
-
-For advanced use cases where you need direct control over the signaling process, you can use the low-level API:
-
-```typescript
-import { Rondevu, BloomFilter } from '@xtr-dev/rondevu-client';
-
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
-
-// Register and get credentials
-const creds = await client.register();
-console.log('Peer ID:', creds.peerId);
-
-// Save credentials for later use
-localStorage.setItem('rondevu-creds', JSON.stringify(creds));
-
-// Create offer with topics
-const offers = await client.offers.create([{
-  sdp: 'v=0...',  // Your WebRTC offer SDP
-  topics: ['movie-xyz', 'hd-content'],
-  ttl: 300000  // 5 minutes
-}]);
-
-// Discover peers by topic
-const discovered = await client.offers.findByTopic('movie-xyz', {
-  limit: 50
-});
-
-console.log(`Found ${discovered.length} peers`);
-
-// Use bloom filter to exclude known peers
-const knownPeers = new Set(['peer-id-1', 'peer-id-2']);
-const bloom = new BloomFilter(1024, 3);
-knownPeers.forEach(id => bloom.add(id));
-
-const newPeers = await client.offers.findByTopic('movie-xyz', {
-  bloomFilter: bloom.toBytes(),
-  limit: 50
-});
-```
 
 ## API Reference
 
-### Authentication
+### RondevuService
-
-#### `client.register()`
-Register a new peer and receive credentials.
 
 ```typescript
-const creds = await client.register();
+const service = new RondevuService({
-// { peerId: '...', secret: '...' }
+    apiUrl: string,           // Signaling server URL
+    username: string,         // Your username
+    keypair?: Keypair         // Optional: reuse existing keypair
+})
+
+// Initialize service (generates keypair if not provided)
+await service.initialize(): Promise<void>
+
+// Claim username with cryptographic signature
+await service.claimUsername(): Promise<void>
+
+// Check if username is claimed
+service.isUsernameClaimed(): boolean
+
+// Get current username
+service.getUsername(): string
+
+// Get keypair
+service.getKeypair(): Keypair
+
+// Get API client
+service.getAPI(): RondevuAPI
 ```
 
-### Topics
+### ServiceHost
-
-#### `client.offers.getTopics(options?)`
-List all topics with active peer counts (paginated).
 
 ```typescript
-const result = await client.offers.getTopics({
+const host = new ServiceHost({
-  limit: 50,
+    service: string,              // Service FQN (e.g., 'chat.app@1.0.0')
-  offset: 0
+    rondevuService: RondevuService,
-});
+    maxPeers?: number,            // Default: 5
+    ttl?: number,                 // Default: 300000 (5 minutes)
+    isPublic?: boolean,           // Default: true
+    rtcConfiguration?: RTCConfiguration
+})
 
-// {
+// Start hosting
-//   topics: [
+await host.start(): Promise<void>
-//     { topic: 'movie-xyz', activePeers: 42 },
+
-//     { topic: 'torrent-abc', activePeers: 15 }
+// Stop hosting and cleanup
-//   ],
+host.dispose(): void
-//   total: 123,
+
-//   limit: 50,
+// Get all active connections
-//   offset: 0
+host.getConnections(): RTCDurableConnection[]
-// }
+
+// Events
+host.events.on('connection', (conn: RTCDurableConnection) => {})
+host.events.on('error', (error: Error) => {})
 ```
 
-### Offers
+### ServiceClient
-
-#### `client.offers.create(offers)`
-Create one or more offers with topics.
 
 ```typescript
-const offers = await client.offers.create([
+const client = new ServiceClient({
-  {
+    username: string,             // Host username to connect to
-    sdp: 'v=0...',
+    serviceFqn: string,          // Service FQN (e.g., 'chat.app@1.0.0')
-    topics: ['topic-1', 'topic-2'],
+    rondevuService: RondevuService,
-    ttl: 300000  // optional, default 5 minutes
+    autoReconnect?: boolean,     // Default: true
-  }
+    maxReconnectAttempts?: number, // Default: 5
-]);
+    rtcConfiguration?: RTCConfiguration
+})
+
+// Connect to service
+await client.connect(): Promise<RTCDurableConnection>
+
+// Disconnect and cleanup
+client.dispose(): void
+
+// Get current connection
+client.getConnection(): RTCDurableConnection | null
+
+// Events
+client.events.on('connected', (conn: RTCDurableConnection) => {})
+client.events.on('disconnected', () => {})
+client.events.on('reconnecting', (info: { attempt: number, maxAttempts: number }) => {})
+client.events.on('error', (error: Error) => {})
 ```
 
-#### `client.offers.findByTopic(topic, options?)`
+### RTCDurableConnection
-Find offers by topic with optional bloom filter.
 
 ```typescript
-const offers = await client.offers.findByTopic('movie-xyz', {
+// Connection state
-  limit: 50,
+connection.state: 'connected' | 'connecting' | 'disconnected'
-  bloomFilter: bloomBytes  // optional
+
-});
+// Send message (returns true if sent, false if queued)
+await connection.sendMessage(message: string): Promise<boolean>
+
+// Queue message for sending when connected
+await connection.queueMessage(message: string, options?: QueueMessageOptions): Promise<void>
+
+// Disconnect
+connection.disconnect(): void
+
+// Events
+connection.events.on('message', (msg: string) => {})
+connection.events.on('state-change', (state: ConnectionStates) => {})
 ```
 
-#### `client.offers.getMine()`
+## Configuration
-Get all offers owned by the authenticated peer.
+
+### Polling Configuration
+
+The signaling uses configurable polling with exponential backoff:
 
 ```typescript
-const myOffers = await client.offers.getMine();
+// Default polling config
+{
+    initialInterval: 500,      // Start at 500ms
+    maxInterval: 5000,         // Max 5 seconds
+    backoffMultiplier: 1.5,    // Increase by 1.5x each time
+    maxRetries: 50,            // Max 50 attempts
+    jitter: true               // Add random 0-100ms to prevent thundering herd
+}
 ```
 
-#### `client.offers.heartbeat(offerId)`
+This is handled automatically - no configuration needed.
-Update last_seen timestamp for an offer.
+
+### WebRTC Configuration
+
+Provide custom STUN/TURN servers:
 
 ```typescript
-await client.offers.heartbeat(offerId);
+const host = new ServiceHost({
+    service: 'chat.app@1.0.0',
+    rondevuService: service,
+    rtcConfiguration: {
+        iceServers: [
+            { urls: 'stun:stun.l.google.com:19302' },
+            {
+                urls: 'turn:turn.example.com:3478',
+                username: 'user',
+                credential: 'pass'
+            }
+        ]
+    }
+})
 ```
 
-#### `client.offers.delete(offerId)`
+## Username Rules
-Delete a specific offer.
+
+- **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 signature
+
+## Examples
+
+### Chat Application
+
+See [demo/demo.js](./demo/demo.js) for a complete working example.
+
+### Persistent Keypair
 
 ```typescript
-await client.offers.delete(offerId);
+// Save keypair to localStorage
+const service = new RondevuService({
+    apiUrl: 'https://api.ronde.vu',
+    username: 'alice'
+})
+
+await service.initialize()
+await service.claimUsername()
+
+// Save for later
+localStorage.setItem('rondevu-keypair', JSON.stringify(service.getKeypair()))
+localStorage.setItem('rondevu-username', service.getUsername())
+
+// Load on next session
+const savedKeypair = JSON.parse(localStorage.getItem('rondevu-keypair'))
+const savedUsername = localStorage.getItem('rondevu-username')
+
+const service2 = new RondevuService({
+    apiUrl: 'https://api.ronde.vu',
+    username: savedUsername,
+    keypair: savedKeypair
+})
+
+await service2.initialize()  // Reuses keypair
 ```
 
-#### `client.offers.answer(offerId, sdp)`
+### Message Queue Example
-Answer an offer (locks it to answerer).
 
 ```typescript
-await client.offers.answer(offerId, answerSdp);
+// Messages are automatically queued if not connected yet
+client.events.on('connected', (connection) => {
+    // Send immediately
+    connection.sendMessage('Hello!')
+})
+
+// Or queue for later
+await client.connect()
+const conn = client.getConnection()
+await conn.queueMessage('This will be sent when connected', {
+    expiresAt: Date.now() + 60000  // Expire after 1 minute
+})
 ```
 
-#### `client.offers.getAnswers()`
+## Migration from v0.9.x
-Poll for answers to your offers.
+
+v0.11.0+ introduces high-level wrappers, RESTful API changes, and semver-compatible discovery:
+
+**API Changes:**
+- Server endpoints restructured (`/usernames/*` → `/users/*`)
+- Added `ServiceHost` and `ServiceClient` wrappers
+- Message queue fully implemented
+- Configurable polling with exponential backoff
+- Removed deprecated `cleanup()` methods (use `dispose()`)
+- **v0.11.0+**: Services use `offers` array instead of single `sdp`
+- **v0.11.0+**: Semver-compatible service discovery (chat@1.0.0 matches 1.x.x)
+- **v0.11.0+**: All services are hidden - no listing endpoint
+- **v0.11.0+**: Services support multiple simultaneous offers for connection pooling
+
+**Migration Guide:**
 
 ```typescript
-const answers = await client.offers.getAnswers();
+// Before (v0.9.x) - Manual WebRTC setup
+const signaler = new RondevuSignaler(service, 'chat@1.0.0')
+const context = new WebRTCContext()
+const pc = context.createPeerConnection()
+// ... 50+ lines of boilerplate
+
+// After (v0.11.0) - ServiceHost wrapper
+const host = new ServiceHost({
+    service: 'chat@1.0.0',
+    rondevuService: service
+})
+await host.start()
+// Done!
 ```
 
-### ICE Candidates
+## Platform Support
 
-#### `client.offers.addIceCandidates(offerId, candidates)`
+### Modern Browsers
-Post ICE candidates for an offer.
+Works out of the box - no additional setup needed.
 
-```typescript
+### Node.js 18+
-await client.offers.addIceCandidates(offerId, [
+Native fetch is available, but WebRTC requires polyfills:
-  'candidate:1 1 UDP...'
+
-]);
+```bash
+npm install wrtc
 ```
 
-#### `client.offers.getIceCandidates(offerId, since?)`
-Get ICE candidates from the other peer.
-
 ```typescript
-const candidates = await client.offers.getIceCandidates(offerId);
+import { WebRTCContext } from '@xtr-dev/rondevu-client'
-```
+import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc'
 
-### Bloom Filter
+// Configure WebRTC context
-
+const context = new WebRTCContext({
-```typescript
+    RTCPeerConnection,
-import { BloomFilter } from '@xtr-dev/rondevu-client';
+    RTCSessionDescription,
-
+    RTCIceCandidate
-// Create filter: size=1024 bits, hash=3 functions
+} as any)
-const bloom = new BloomFilter(1024, 3);
-
-// Add items
-bloom.add('peer-id-1');
-bloom.add('peer-id-2');
-
-// Test membership
-bloom.test('peer-id-1');  // true (probably)
-bloom.test('unknown');    // false (definitely)
-
-// Export for API
-const bytes = bloom.toBytes();
 ```
 
 ## TypeScript
@@ -407,45 +436,21 @@ All types are exported:
 
 ```typescript
 import type {
-  Credentials,
+    RondevuServiceOptions,
-  Offer,
+    ServiceHostOptions,
-  CreateOfferRequest,
+    ServiceHostEvents,
-  TopicInfo,
+    ServiceClientOptions,
-  IceCandidate,
+    ServiceClientEvents,
-  FetchFunction,
+    ConnectionInterface,
-  RondevuOptions,
+    ConnectionEvents,
-  ConnectionOptions,
+    ConnectionStates,
-  RondevuConnectionEvents
+    Message,
-} from '@xtr-dev/rondevu-client';
+    QueueMessageOptions,
-```
+    Signaler,
-
+    PollingConfig,
-## Environment Compatibility
+    Credentials,
-
+    Keypair
-The client library is designed to work across different JavaScript runtimes:
+} from '@xtr-dev/rondevu-client'
-
-| Environment | Native Fetch | Custom Fetch Needed |
-|-------------|--------------|---------------------|
-| Modern Browsers | ✅ Yes | ❌ No |
-| Node.js 18+ | ✅ Yes | ❌ No |
-| Node.js < 18 | ❌ No | ✅ Yes (node-fetch) |
-| Deno | ✅ Yes | ❌ No |
-| Bun | ✅ Yes | ❌ No |
-| Cloudflare Workers | ✅ Yes | ❌ No |
-
-**If your environment doesn't have native fetch:**
-
-```bash
-npm install node-fetch
-```
-
-```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
-import fetch from 'node-fetch';
-
-const client = new Rondevu({
-  baseUrl: 'https://rondevu.xtrdev.workers.dev',
-  fetch: fetch as any
-});
 ```
 
 ## License

USAGE.md

@@ -0,0 +1,281 @@
+# Rondevu Client Usage Guide
+
+## Installation
+
+```bash
+npm install @xtr-dev/rondevu-client
+```
+
+## Quick Start
+
+### 1. Register and Create Connection
+
+```typescript
+import { RondevuAPI, RondevuSignaler, WebRTCRondevuConnection } from '@xtr-dev/rondevu-client';
+
+const API_URL = 'https://api.ronde.vu';
+
+// Register to get credentials
+const api = new RondevuAPI(API_URL);
+const credentials = await api.register();
+
+// Create authenticated API client
+const authenticatedApi = new RondevuAPI(API_URL, credentials);
+```
+
+### 2. Create an Offer (Offerer Side)
+
+```typescript
+// Create a connection
+const connection = new WebRTCRondevuConnection(
+  'connection-id',
+  'host-username',
+  'service-name'
+);
+
+// Wait for local description
+await connection.ready;
+
+// Create offer on server
+const offers = await authenticatedApi.createOffers([{
+  sdp: connection.connection.localDescription!.sdp!,
+  ttl: 300000 // 5 minutes
+}]);
+
+const offerId = offers[0].id;
+
+// Set up signaler for ICE candidate exchange
+const signaler = new RondevuSignaler(authenticatedApi, offerId);
+connection.setSignaler(signaler);
+
+// Poll for answer
+const checkAnswer = setInterval(async () => {
+  const answer = await authenticatedApi.getAnswer(offerId);
+  if (answer) {
+    clearInterval(checkAnswer);
+    await connection.connection.setRemoteDescription({
+      type: 'answer',
+      sdp: answer.sdp
+    });
+    console.log('Connection established!');
+  }
+}, 1000);
+```
+
+### 3. Answer an Offer (Answerer Side)
+
+```typescript
+// Get the offer
+const offer = await authenticatedApi.getOffer(offerId);
+
+// Create connection with remote offer
+const connection = new WebRTCRondevuConnection(
+  'connection-id',
+  'peer-username',
+  'service-name',
+  {
+    type: 'offer',
+    sdp: offer.sdp
+  }
+);
+
+// Wait for local description (answer)
+await connection.ready;
+
+// Send answer to server
+await authenticatedApi.answerOffer(
+  offerId,
+  connection.connection.localDescription!.sdp!
+);
+
+// Set up signaler for ICE candidate exchange
+const signaler = new RondevuSignaler(authenticatedApi, offerId);
+connection.setSignaler(signaler);
+
+console.log('Connection established!');
+```
+
+## Using Services
+
+### Publish a Service
+
+```typescript
+import { RondevuAPI } from '@xtr-dev/rondevu-client';
+
+const api = new RondevuAPI(API_URL, credentials);
+
+const service = await api.publishService({
+  username: 'my-username',
+  serviceFqn: 'chat.app@1.0.0',
+  sdp: localDescription.sdp,
+  ttl: 300000,
+  isPublic: true,
+  metadata: { description: 'My chat service' },
+  signature: '...', // Ed25519 signature
+  message: '...'    // Signed message
+});
+
+console.log('Service UUID:', service.uuid);
+```
+
+### Connect to a Service
+
+```typescript
+// Search for services
+const services = await api.searchServices('username', 'chat.app@1.0.0');
+
+if (services.length > 0) {
+  // Get service details with offer
+  const service = await api.getService(services[0].uuid);
+
+  // Create connection with service offer
+  const connection = new WebRTCRondevuConnection(
+    service.serviceId,
+    service.username,
+    service.serviceFqn,
+    {
+      type: 'offer',
+      sdp: service.sdp
+    }
+  );
+
+  await connection.ready;
+
+  // Answer the service offer
+  await api.answerOffer(
+    service.offerId,
+    connection.connection.localDescription!.sdp!
+  );
+
+  // Set up signaler
+  const signaler = new RondevuSignaler(api, service.offerId);
+  connection.setSignaler(signaler);
+}
+```
+
+## Event Handling
+
+```typescript
+import { EventBus } from '@xtr-dev/rondevu-client';
+
+// Connection events
+connection.events.on('state-change', (state) => {
+  console.log('Connection state:', state);
+});
+
+connection.events.on('message', (message) => {
+  console.log('Received message:', message);
+});
+
+// Custom events with EventBus
+interface MyEvents {
+  'user:connected': { userId: string; timestamp: number };
+  'message:sent': string;
+}
+
+const events = new EventBus<MyEvents>();
+
+events.on('user:connected', (data) => {
+  console.log(`User ${data.userId} connected at ${data.timestamp}`);
+});
+
+events.emit('user:connected', {
+  userId: '123',
+  timestamp: Date.now()
+});
+```
+
+## Cleanup
+
+```typescript
+import { createBin } from '@xtr-dev/rondevu-client';
+
+const bin = createBin();
+
+// Add cleanup functions
+bin(
+  () => console.log('Cleanup 1'),
+  () => console.log('Cleanup 2')
+);
+
+// Clean all
+bin.clean();
+```
+
+## API Reference
+
+### RondevuAPI
+
+Complete API client for Rondevu signaling server.
+
+**Methods:**
+- `register()` - Register new peer
+- `createOffers(offers)` - Create offers
+- `getOffer(offerId)` - Get offer by ID
+- `answerOffer(offerId, sdp)` - Answer an offer
+- `getAnswer(offerId)` - Poll for answer
+- `searchOffers(topic)` - Search by topic
+- `addIceCandidates(offerId, candidates)` - Add ICE candidates
+- `getIceCandidates(offerId, since)` - Get ICE candidates (polling)
+- `publishService(service)` - Publish service
+- `getService(uuid)` - Get service by UUID
+- `searchServices(username, serviceFqn)` - Search services
+- `checkUsername(username)` - Check availability
+- `claimUsername(username, publicKey, signature, message)` - Claim username
+
+### RondevuSignaler
+
+Handles ICE candidate exchange via polling.
+
+**Constructor:**
+```typescript
+new RondevuSignaler(api: RondevuAPI, offerId: string)
+```
+
+**Methods:**
+- `addIceCandidate(candidate)` - Send local candidate
+- `addListener(callback)` - Poll for remote candidates (returns cleanup function)
+
+### WebRTCRondevuConnection
+
+WebRTC connection wrapper with type-safe events.
+
+**Constructor:**
+```typescript
+new WebRTCRondevuConnection(
+  id: string,
+  host: string,
+  service: string,
+  offer?: RTCSessionDescriptionInit
+)
+```
+
+**Properties:**
+- `id` - Connection ID
+- `host` - Host username
+- `service` - Service FQN
+- `state` - Connection state
+- `events` - EventBus for state changes and messages
+- `ready` - Promise that resolves when local description is set
+
+**Methods:**
+- `setSignaler(signaler)` - Set signaler for ICE exchange
+- `queueMessage(message, options)` - Queue message for sending
+- `sendMessage(message)` - Send message immediately
+
+### EventBus<TEvents>
+
+Type-safe event emitter with inferred types.
+
+**Methods:**
+- `on(event, handler)` - Subscribe
+- `once(event, handler)` - Subscribe once
+- `off(event, handler)` - Unsubscribe
+- `emit(event, data)` - Emit event
+- `clear(event?)` - Clear handlers
+- `listenerCount(event)` - Get listener count
+- `eventNames()` - Get event names
+
+## Examples
+
+See the demo application at https://github.com/xtr-dev/rondevu-demo for a complete working example.

eslint.config.js

@@ -0,0 +1,52 @@
+import js from '@eslint/js'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
+import tsParser from '@typescript-eslint/parser'
+import prettierConfig from 'eslint-config-prettier'
+import prettierPlugin from 'eslint-plugin-prettier'
+import unicorn from 'eslint-plugin-unicorn'
+import globals from 'globals'
+
+export default [
+    js.configs.recommended,
+    {
+        files: ['**/*.ts', '**/*.tsx', '**/*.js'],
+        languageOptions: {
+            parser: tsParser,
+            parserOptions: {
+                ecmaVersion: 'latest',
+                sourceType: 'module',
+            },
+            globals: {
+                ...globals.browser,
+                ...globals.node,
+                RTCPeerConnection: 'readonly',
+                RTCIceCandidate: 'readonly',
+                RTCSessionDescriptionInit: 'readonly',
+                RTCIceCandidateInit: 'readonly',
+                BufferSource: 'readonly',
+            },
+        },
+        plugins: {
+            '@typescript-eslint': tsPlugin,
+            prettier: prettierPlugin,
+            unicorn: unicorn,
+        },
+        rules: {
+            ...tsPlugin.configs.recommended.rules,
+            ...prettierConfig.rules,
+            'prettier/prettier': 'error',
+            '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+            'unicorn/filename-case': [
+                'error',
+                {
+                    case: 'kebabCase',
+                    ignore: ['^README\\.md$'],
+                },
+            ],
+        },
+    },
+    {
+        ignores: ['dist/**', 'node_modules/**', '*.config.js'],
+    },
+]

package.json

@@ -1,13 +1,17 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.4.1",
+  "version": "0.12.0",
-  "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
+  "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",
+    "dev": "vite",
+    "lint": "eslint src demo --ext .ts,.tsx,.js",
+    "lint:fix": "eslint src demo --ext .ts,.tsx,.js --fix",
+    "format": "prettier --write \"src/**/*.{ts,tsx,js}\" \"demo/**/*.{ts,tsx,js,html}\"",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -20,10 +24,23 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.9.3"
+    "@eslint/js": "^9.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.6"
   },
   "files": [
     "dist",
     "README.md"
-  ]
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^3.0.0"
+  }
 }

src/api.ts

@@ -0,0 +1,466 @@
+/**
+ * Rondevu API Client - Single class for all API endpoints
+ */
+
+import * as ed25519 from '@noble/ed25519'
+
+// Set SHA-512 hash function for ed25519 (required in @noble/ed25519 v3+)
+ed25519.hashes.sha512Async = async (message: Uint8Array) => {
+    return new Uint8Array(await crypto.subtle.digest('SHA-512', message as BufferSource))
+}
+
+export interface Credentials {
+    peerId: string
+    secret: string
+}
+
+export interface Keypair {
+    publicKey: string
+    privateKey: string
+}
+
+export interface OfferRequest {
+    sdp: string
+    topics?: string[]
+    ttl?: number
+    secret?: string
+}
+
+export interface Offer {
+    id: string
+    peerId: string
+    sdp: string
+    topics: string[]
+    ttl: number
+    createdAt: number
+    expiresAt: number
+    answererPeerId?: string
+}
+
+export interface OfferRequest {
+    sdp: string
+}
+
+export interface ServiceRequest {
+    username: string
+    serviceFqn: string
+    offers: OfferRequest[]
+    ttl?: number
+    isPublic?: boolean
+    metadata?: Record<string, any>
+    signature: string
+    message: string
+}
+
+export interface ServiceOffer {
+    offerId: string
+    sdp: string
+    createdAt: number
+    expiresAt: number
+}
+
+export interface Service {
+    serviceId: string
+    uuid: string
+    offers: ServiceOffer[]
+    username: string
+    serviceFqn: string
+    isPublic: boolean
+    metadata?: Record<string, any>
+    createdAt: number
+    expiresAt: number
+}
+
+export interface IceCandidate {
+    candidate: RTCIceCandidateInit
+    createdAt: number
+}
+
+/**
+ * Helper: Convert Uint8Array to base64 string
+ */
+function bytesToBase64(bytes: Uint8Array): string {
+    const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('')
+    return btoa(binString)
+}
+
+/**
+ * Helper: Convert base64 string to Uint8Array
+ */
+function base64ToBytes(base64: string): Uint8Array {
+    const binString = atob(base64)
+    return Uint8Array.from(binString, char => char.codePointAt(0)!)
+}
+
+/**
+ * RondevuAPI - Complete API client for Rondevu signaling server
+ */
+export class RondevuAPI {
+    constructor(
+        private baseUrl: string,
+        private credentials?: Credentials
+    ) {}
+
+    /**
+     * Set credentials for authentication
+     */
+    setCredentials(credentials: Credentials): void {
+        this.credentials = credentials
+    }
+
+    /**
+     * Authentication header
+     */
+    private getAuthHeader(): Record<string, string> {
+        if (!this.credentials) {
+            return {}
+        }
+        return {
+            Authorization: `Bearer ${this.credentials.peerId}:${this.credentials.secret}`,
+        }
+    }
+
+    // ============================================
+    // Ed25519 Cryptography Helpers
+    // ============================================
+
+    /**
+     * Generate an Ed25519 keypair for username claiming and service publishing
+     */
+    static async generateKeypair(): Promise<Keypair> {
+        const privateKey = ed25519.utils.randomSecretKey()
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey)
+
+        return {
+            publicKey: bytesToBase64(publicKey),
+            privateKey: bytesToBase64(privateKey),
+        }
+    }
+
+    /**
+     * Sign a message with an Ed25519 private key
+     */
+    static async signMessage(message: string, privateKeyBase64: string): Promise<string> {
+        const privateKey = base64ToBytes(privateKeyBase64)
+        const encoder = new TextEncoder()
+        const messageBytes = encoder.encode(message)
+
+        const signature = await ed25519.signAsync(messageBytes, privateKey)
+        return bytesToBase64(signature)
+    }
+
+    /**
+     * Verify a signature
+     */
+    static async verifySignature(
+        message: string,
+        signatureBase64: string,
+        publicKeyBase64: string
+    ): Promise<boolean> {
+        const publicKey = base64ToBytes(publicKeyBase64)
+        const signature = base64ToBytes(signatureBase64)
+        const encoder = new TextEncoder()
+        const messageBytes = encoder.encode(message)
+
+        return await ed25519.verifyAsync(signature, messageBytes, publicKey)
+    }
+
+    // ============================================
+    // Authentication
+    // ============================================
+
+    /**
+     * Register a new peer and get credentials
+     */
+    async register(): Promise<Credentials> {
+        const response = await fetch(`${this.baseUrl}/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Registration failed: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    // ============================================
+    // Offers
+    // ============================================
+
+    /**
+     * Create one or more offers
+     */
+    async createOffers(offers: OfferRequest[]): Promise<Offer[]> {
+        const response = await fetch(`${this.baseUrl}/offers`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeader(),
+            },
+            body: JSON.stringify({ offers }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to create offers: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Get offer by ID
+     */
+    async getOffer(offerId: string): Promise<Offer> {
+        const response = await fetch(`${this.baseUrl}/offers/${offerId}`, {
+            headers: this.getAuthHeader(),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to get offer: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Answer a service
+     */
+    async answerService(serviceUuid: string, sdp: string): Promise<{ offerId: string }> {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeader(),
+            },
+            body: JSON.stringify({ sdp }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to answer service: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Get answer for a service (offerer polls this)
+     */
+    async getServiceAnswer(serviceUuid: string): Promise<{ sdp: string; offerId: string } | null> {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
+            headers: this.getAuthHeader(),
+        })
+
+        if (!response.ok) {
+            // 404 means not yet answered
+            if (response.status === 404) {
+                return null
+            }
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to get answer: ${error.error || response.statusText}`)
+        }
+
+        const data = await response.json()
+        return { sdp: data.sdp, offerId: data.offerId }
+    }
+
+    /**
+     * Search offers by topic
+     */
+    async searchOffers(topic: string): Promise<Offer[]> {
+        const response = await fetch(`${this.baseUrl}/offers?topic=${encodeURIComponent(topic)}`, {
+            headers: this.getAuthHeader(),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to search offers: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    // ============================================
+    // ICE Candidates
+    // ============================================
+
+    /**
+     * Add ICE candidates to a service
+     */
+    async addServiceIceCandidates(serviceUuid: string, candidates: RTCIceCandidateInit[], offerId?: string): Promise<{ offerId: string }> {
+        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeader(),
+            },
+            body: JSON.stringify({ candidates, offerId }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Get ICE candidates for a service (with polling support)
+     */
+    async getServiceIceCandidates(serviceUuid: string, since: number = 0, offerId?: string): Promise<{ candidates: IceCandidate[]; offerId: string }> {
+        const url = new URL(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`)
+        url.searchParams.set('since', since.toString())
+        if (offerId) {
+            url.searchParams.set('offerId', offerId)
+        }
+
+        const response = await fetch(url.toString(), { headers: this.getAuthHeader() })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`)
+        }
+
+        const data = await response.json()
+        return {
+            candidates: data.candidates || [],
+            offerId: data.offerId
+        }
+    }
+
+    // ============================================
+    // Services
+    // ============================================
+
+    /**
+     * Publish a service
+     */
+    async publishService(service: ServiceRequest): Promise<Service> {
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(service.username)}/services`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeader(),
+            },
+            body: JSON.stringify(service),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to publish service: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Get service by UUID
+     */
+    async getService(uuid: string): Promise<Service & { offerId: string; sdp: string }> {
+        const response = await fetch(`${this.baseUrl}/services/${uuid}`, {
+            headers: this.getAuthHeader(),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to get service: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Search services by username - lists all services for a username
+     */
+    async searchServicesByUsername(username: string): Promise<Service[]> {
+        const response = await fetch(
+            `${this.baseUrl}/users/${encodeURIComponent(username)}/services`,
+            { headers: this.getAuthHeader() }
+        )
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to search services: ${error.error || response.statusText}`)
+        }
+
+        const data = await response.json()
+        return data.services || []
+    }
+
+    /**
+     * Search services by username AND FQN - returns full service details
+     */
+    async searchServices(username: string, serviceFqn: string): Promise<Service[]> {
+        const response = await fetch(
+            `${this.baseUrl}/users/${encodeURIComponent(username)}/services/${encodeURIComponent(serviceFqn)}`,
+            { headers: this.getAuthHeader() }
+        )
+
+        if (!response.ok) {
+            if (response.status === 404) {
+                return []
+            }
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to search services: ${error.error || response.statusText}`)
+        }
+
+        const service = await response.json()
+        return [service]
+    }
+
+    // ============================================
+    // Usernames
+    // ============================================
+
+    /**
+     * Check if username is available
+     */
+    async checkUsername(username: string): Promise<{ available: boolean; owner?: string }> {
+        const response = await fetch(
+            `${this.baseUrl}/users/${encodeURIComponent(username)}`
+        )
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to check username: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+
+    /**
+     * Claim a username (requires Ed25519 signature)
+     */
+    async claimUsername(
+        username: string,
+        publicKey: string,
+        signature: string,
+        message: string
+    ): Promise<{ success: boolean; username: string }> {
+        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.getAuthHeader(),
+            },
+            body: JSON.stringify({
+                publicKey,
+                signature,
+                message,
+            }),
+        })
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }))
+            throw new Error(`Failed to claim username: ${error.error || response.statusText}`)
+        }
+
+        return await response.json()
+    }
+}

src/auth.ts

@@ -1,60 +0,0 @@
-export interface Credentials {
-  peerId: string;
-  secret: string;
-}
-
-// Fetch-compatible function type
-export type FetchFunction = (
-  input: RequestInfo | URL,
-  init?: RequestInit
-) => Promise<Response>;
-
-export class RondevuAuth {
-  private fetchFn: FetchFunction;
-
-  constructor(
-    private baseUrl: string,
-    fetchFn?: FetchFunction
-  ) {
-    // Use provided fetch or fall back to global fetch
-    this.fetchFn = fetchFn || ((...args) => {
-      if (typeof globalThis.fetch === 'function') {
-        return globalThis.fetch(...args);
-      }
-      throw new Error(
-        'fetch is not available. Please provide a fetch implementation in the constructor options.'
-      );
-    });
-  }
-
-  /**
-   * Register a new peer and receive credentials
-   */
-  async register(): Promise<Credentials> {
-    const response = await this.fetchFn(`${this.baseUrl}/register`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({}),
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Registration failed: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return {
-      peerId: data.peerId,
-      secret: data.secret,
-    };
-  }
-
-  /**
-   * Create Authorization header value
-   */
-  static createAuthHeader(credentials: Credentials): string {
-    return `Bearer ${credentials.peerId}:${credentials.secret}`;
-  }
-}

src/bin.ts

@@ -0,0 +1,42 @@
+/**
+ * Binnable - A cleanup function that can be synchronous or asynchronous
+ *
+ * Used to unsubscribe from events, close connections, or perform other cleanup operations.
+ */
+export type Binnable = () => void | Promise<void>
+
+/**
+ * Create a cleanup function collector (garbage bin)
+ *
+ * Collects cleanup functions and provides a single `clean()` method to execute all of them.
+ * Useful for managing multiple cleanup operations in a single place.
+ *
+ * @returns A function that accepts cleanup functions and has a `clean()` method
+ *
+ * @example
+ * ```typescript
+ * const bin = createBin();
+ *
+ * // Add cleanup functions
+ * bin(
+ *   () => console.log('Cleanup 1'),
+ *   () => connection.close(),
+ *   () => clearInterval(timer)
+ * );
+ *
+ * // Later, clean everything
+ * bin.clean(); // Executes all cleanup functions
+ * ```
+ */
+export const createBin = () => {
+    const bin: Binnable[] = []
+    return Object.assign((...rubbish: Binnable[]) => bin.push(...rubbish), {
+        /**
+         * Execute all cleanup functions and clear the bin
+         */
+        clean: (): void => {
+            bin.forEach(binnable => binnable())
+            bin.length = 0
+        },
+    })
+}

src/bloom.ts

@@ -1,83 +0,0 @@
-// Declare Buffer for Node.js compatibility
-declare const Buffer: any;
-
-/**
- * Simple bloom filter implementation for peer ID exclusion
- * Uses multiple hash functions for better distribution
- */
-export class BloomFilter {
-  private bits: Uint8Array;
-  private size: number;
-  private numHashes: number;
-
-  constructor(size: number = 1024, numHashes: number = 3) {
-    this.size = size;
-    this.numHashes = numHashes;
-    this.bits = new Uint8Array(Math.ceil(size / 8));
-  }
-
-  /**
-   * Add a peer ID to the filter
-   */
-  add(peerId: string): void {
-    for (let i = 0; i < this.numHashes; i++) {
-      const hash = this.hash(peerId, i);
-      const index = hash % this.size;
-      const byteIndex = Math.floor(index / 8);
-      const bitIndex = index % 8;
-      this.bits[byteIndex] |= 1 << bitIndex;
-    }
-  }
-
-  /**
-   * Test if peer ID might be in the filter
-   */
-  test(peerId: string): boolean {
-    for (let i = 0; i < this.numHashes; i++) {
-      const hash = this.hash(peerId, i);
-      const index = hash % this.size;
-      const byteIndex = Math.floor(index / 8);
-      const bitIndex = index % 8;
-      if (!(this.bits[byteIndex] & (1 << bitIndex))) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Get raw bits for transmission
-   */
-  toBytes(): Uint8Array {
-    return this.bits;
-  }
-
-  /**
-   * Convert to base64 for URL parameters
-   */
-  toBase64(): string {
-    // Convert Uint8Array to regular array then to string
-    const binaryString = String.fromCharCode(...Array.from(this.bits));
-    // Use btoa for browser, or Buffer for Node.js
-    if (typeof btoa !== 'undefined') {
-      return btoa(binaryString);
-    } else if (typeof Buffer !== 'undefined') {
-      return Buffer.from(this.bits).toString('base64');
-    } else {
-      // Fallback: manual base64 encoding
-      throw new Error('No base64 encoding available');
-    }
-  }
-
-  /**
-   * Simple hash function (FNV-1a variant)
-   */
-  private hash(str: string, seed: number): number {
-    let hash = 2166136261 ^ seed;
-    for (let i = 0; i < str.length; i++) {
-      hash ^= str.charCodeAt(i);
-      hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-    }
-    return hash >>> 0;
-  }
-}

src/client.ts

@@ -1,208 +0,0 @@
-import {
-  RondevuClientOptions,
-  CreateOfferRequest,
-  CreateOfferResponse,
-  AnswerRequest,
-  AnswerResponse,
-  PollRequest,
-  PollOffererResponse,
-  PollAnswererResponse,
-  VersionResponse,
-  HealthResponse,
-  ErrorResponse,
-  Side,
-} from './types.js';
-
-/**
- * HTTP API client for Rondevu peer signaling server
- */
-export class RondevuAPI {
-  private readonly baseUrl: string;
-  private readonly fetchImpl: typeof fetch;
-
-  /**
-   * Creates a new Rondevu API 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
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   * const { version } = await api.getVersion();
-   * console.log('Server version:', version);
-   * ```
-   */
-  async getVersion(): Promise<VersionResponse> {
-    return this.request<VersionResponse>('/', {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Creates a new offer
-   *
-   * @param request - Offer details including peer ID, signaling data, and optional custom code
-   * @returns Unique offer code (UUID or custom code)
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   * const { code } = await api.createOffer({
-   *   peerId: 'peer-123',
-   *   offer: signalingData,
-   *   code: 'my-custom-code' // optional
-   * });
-   * console.log('Offer code:', code);
-   * ```
-   */
-  async createOffer(request: CreateOfferRequest): Promise<CreateOfferResponse> {
-    return this.request<CreateOfferResponse>('/offer', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
-  }
-
-  /**
-   * Sends an answer or candidate to an existing offer
-   *
-   * @param request - Answer details including offer code and signaling data
-   * @returns Success confirmation
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   *
-   * // Send answer
-   * await api.sendAnswer({
-   *   code: offerCode,
-   *   answer: answerData,
-   *   side: 'answerer'
-   * });
-   *
-   * // Send candidate
-   * await api.sendAnswer({
-   *   code: offerCode,
-   *   candidate: candidateData,
-   *   side: 'offerer'
-   * });
-   * ```
-   */
-  async sendAnswer(request: AnswerRequest): Promise<AnswerResponse> {
-    return this.request<AnswerResponse>('/answer', {
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
-  }
-
-  /**
-   * Polls for offer data from the other peer
-   *
-   * @param code - Offer code
-   * @param side - Which side is polling ('offerer' or 'answerer')
-   * @returns Offer data including offers, answers, and candidates
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   *
-   * // Offerer polls for answer
-   * const offererData = await api.poll(offerCode, 'offerer');
-   * if (offererData.answer) {
-   *   console.log('Received answer:', offererData.answer);
-   * }
-   *
-   * // Answerer polls for offer
-   * const answererData = await api.poll(offerCode, '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 and version
-   *
-   * @returns Health status, timestamp, and version
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   * const health = await api.health();
-   * console.log('Server status:', health.status);
-   * console.log('Server version:', health.version);
-   * ```
-   */
-  async health(): Promise<HealthResponse> {
-    return this.request<HealthResponse>('/health', {
-      method: 'GET',
-    });
-  }
-
-  /**
-   * Ends a session by deleting the offer from the server
-   *
-   * @param code - The offer code
-   * @returns Success confirmation
-   *
-   * @example
-   * ```typescript
-   * const api = new RondevuAPI({ baseUrl: 'https://example.com' });
-   * await api.leave('my-offer-code');
-   * ```
-   */
-  async leave(code: string): Promise<{ success: boolean }> {
-    return this.request<{ success: boolean }>('/leave', {
-      method: 'POST',
-      body: JSON.stringify({ code }),
-    });
-  }
-}

src/connection.ts

@@ -1,388 +0,0 @@
-import { RondevuOffers, RTCIceCandidateInit } from './offers.js';
-
-/**
- * Events emitted by RondevuConnection
- */
-export interface RondevuConnectionEvents {
-  'connecting': () => void;
-  'connected': () => void;
-  'disconnected': () => void;
-  'error': (error: Error) => void;
-  'datachannel': (channel: RTCDataChannel) => void;
-  'track': (event: RTCTrackEvent) => void;
-}
-
-/**
- * Options for creating a WebRTC connection
- */
-export interface ConnectionOptions {
-  /**
-   * RTCConfiguration for the peer connection
-   * @default { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] }
-   */
-  rtcConfig?: RTCConfiguration;
-
-  /**
-   * Topics to advertise this connection under
-   */
-  topics: string[];
-
-  /**
-   * How long the offer should live (milliseconds)
-   * @default 300000 (5 minutes)
-   */
-  ttl?: number;
-
-  /**
-   * Whether to create a data channel automatically (for offerer)
-   * @default true
-   */
-  createDataChannel?: boolean;
-
-  /**
-   * Label for the automatically created data channel
-   * @default 'data'
-   */
-  dataChannelLabel?: string;
-}
-
-/**
- * High-level WebRTC connection manager for Rondevu
- * Handles offer/answer exchange, ICE candidates, and connection lifecycle
- */
-export class RondevuConnection {
-  private pc: RTCPeerConnection;
-  private offersApi: RondevuOffers;
-  private offerId?: string;
-  private role?: 'offerer' | 'answerer';
-  private icePollingInterval?: ReturnType<typeof setInterval>;
-  private answerPollingInterval?: ReturnType<typeof setInterval>;
-  private lastIceTimestamp: number = 0;  // Start at 0 to get all candidates on first poll
-  private eventListeners: Map<keyof RondevuConnectionEvents, Set<Function>> = new Map();
-  private dataChannel?: RTCDataChannel;
-  private pendingIceCandidates: RTCIceCandidateInit[] = [];
-
-  /**
-   * Current connection state
-   */
-  get connectionState(): RTCPeerConnectionState {
-    return this.pc.connectionState;
-  }
-
-  /**
-   * The offer ID for this connection
-   */
-  get id(): string | undefined {
-    return this.offerId;
-  }
-
-  /**
-   * Get the primary data channel (if created)
-   */
-  get channel(): RTCDataChannel | undefined {
-    return this.dataChannel;
-  }
-
-  constructor(
-    offersApi: RondevuOffers,
-    private rtcConfig: RTCConfiguration = {
-      iceServers: [
-        { urls: 'stun:stun.l.google.com:19302' },
-        { urls: 'stun:stun1.l.google.com:19302' }
-      ]
-    }
-  ) {
-    this.offersApi = offersApi;
-    this.pc = new RTCPeerConnection(rtcConfig);
-    this.setupPeerConnection();
-  }
-
-  /**
-   * Set up peer connection event handlers
-   */
-  private setupPeerConnection(): void {
-    this.pc.onicecandidate = async (event) => {
-      if (event.candidate) {
-        // Convert RTCIceCandidate to RTCIceCandidateInit (plain object)
-        const candidateData: RTCIceCandidateInit = {
-          candidate: event.candidate.candidate,
-          sdpMid: event.candidate.sdpMid,
-          sdpMLineIndex: event.candidate.sdpMLineIndex,
-          usernameFragment: event.candidate.usernameFragment,
-        };
-
-        if (this.offerId) {
-          // offerId is set, send immediately (trickle ICE)
-          try {
-            await this.offersApi.addIceCandidates(this.offerId, [candidateData]);
-          } catch (err) {
-            console.error('Error sending ICE candidate:', err);
-          }
-        } else {
-          // offerId not set yet, buffer the candidate
-          this.pendingIceCandidates.push(candidateData);
-        }
-      }
-    };
-
-    this.pc.onconnectionstatechange = () => {
-      switch (this.pc.connectionState) {
-        case 'connecting':
-          this.emit('connecting');
-          break;
-        case 'connected':
-          this.emit('connected');
-          // Stop polling once connected - we have all the ICE candidates we need
-          this.stopPolling();
-          break;
-        case 'disconnected':
-        case 'failed':
-        case 'closed':
-          this.emit('disconnected');
-          this.stopPolling();
-          break;
-      }
-    };
-
-    this.pc.ondatachannel = (event) => {
-      this.dataChannel = event.channel;
-      this.emit('datachannel', event.channel);
-    };
-
-    this.pc.ontrack = (event) => {
-      this.emit('track', event);
-    };
-
-    this.pc.onicecandidateerror = (event) => {
-      console.error('ICE candidate error:', event);
-    };
-  }
-
-  /**
-   * Flush buffered ICE candidates (trickle ICE support)
-   */
-  private async flushPendingIceCandidates(): Promise<void> {
-    if (this.pendingIceCandidates.length > 0 && this.offerId) {
-      try {
-        await this.offersApi.addIceCandidates(this.offerId, this.pendingIceCandidates);
-        this.pendingIceCandidates = [];
-      } catch (err) {
-        console.error('Error flushing pending ICE candidates:', err);
-      }
-    }
-  }
-
-  /**
-   * Create an offer and advertise on topics
-   */
-  async createOffer(options: ConnectionOptions): Promise<string> {
-    this.role = 'offerer';
-
-    // Create data channel if requested
-    if (options.createDataChannel !== false) {
-      this.dataChannel = this.pc.createDataChannel(
-        options.dataChannelLabel || 'data'
-      );
-      this.emit('datachannel', this.dataChannel);
-    }
-
-    // Create WebRTC offer
-    const offer = await this.pc.createOffer();
-    await this.pc.setLocalDescription(offer);
-
-    // Create offer on Rondevu server
-    const offers = await this.offersApi.create([{
-      sdp: offer.sdp!,
-      topics: options.topics,
-      ttl: options.ttl || 300000
-    }]);
-
-    this.offerId = offers[0].id;
-
-    // Flush any ICE candidates that were generated during offer creation
-    await this.flushPendingIceCandidates();
-
-    // Start polling for answers
-    this.startAnswerPolling();
-
-    return this.offerId;
-  }
-
-  /**
-   * Answer an existing offer
-   */
-  async answer(offerId: string, offerSdp: string): Promise<void> {
-    this.role = 'answerer';
-
-    // Set remote description
-    await this.pc.setRemoteDescription({
-      type: 'offer',
-      sdp: offerSdp
-    });
-
-    // Create answer
-    const answer = await this.pc.createAnswer();
-    await this.pc.setLocalDescription(answer);
-
-    // Send answer to server FIRST
-    // This registers us as the answerer before ICE candidates arrive
-    await this.offersApi.answer(offerId, answer.sdp!);
-
-    // Now set offerId to enable ICE candidate sending
-    // This prevents a race condition where ICE candidates arrive before answer is registered
-    this.offerId = offerId;
-
-    // Flush any ICE candidates that were generated during answer creation
-    await this.flushPendingIceCandidates();
-
-    // Start polling for ICE candidates
-    this.startIcePolling();
-  }
-
-  /**
-   * Start polling for answers (offerer only)
-   */
-  private startAnswerPolling(): void {
-    if (this.role !== 'offerer' || !this.offerId) return;
-
-    this.answerPollingInterval = setInterval(async () => {
-      try {
-        const answers = await this.offersApi.getAnswers();
-        const myAnswer = answers.find(a => a.offerId === this.offerId);
-
-        if (myAnswer) {
-          // Set remote description
-          await this.pc.setRemoteDescription({
-            type: 'answer',
-            sdp: myAnswer.sdp
-          });
-
-          // Stop answer polling, start ICE polling
-          this.stopAnswerPolling();
-          this.startIcePolling();
-        }
-      } catch (err) {
-        console.error('Error polling for answers:', err);
-        // Stop polling if offer expired/not found
-        if (err instanceof Error && err.message.includes('not found')) {
-          this.stopPolling();
-        }
-      }
-    }, 2000);
-  }
-
-  /**
-   * Start polling for ICE candidates
-   */
-  private startIcePolling(): void {
-    if (!this.offerId) return;
-
-    this.icePollingInterval = setInterval(async () => {
-      if (!this.offerId) return;
-
-      try {
-        const candidates = await this.offersApi.getIceCandidates(
-          this.offerId,
-          this.lastIceTimestamp
-        );
-
-        for (const cand of candidates) {
-          // Use the candidate object directly - it's already RTCIceCandidateInit
-          await this.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
-          this.lastIceTimestamp = cand.createdAt;
-        }
-      } catch (err) {
-        console.error('Error polling for ICE candidates:', err);
-        // Stop polling if offer expired/not found
-        if (err instanceof Error && err.message.includes('not found')) {
-          this.stopPolling();
-        }
-      }
-    }, 1000);
-  }
-
-  /**
-   * Stop answer polling
-   */
-  private stopAnswerPolling(): void {
-    if (this.answerPollingInterval) {
-      clearInterval(this.answerPollingInterval);
-      this.answerPollingInterval = undefined;
-    }
-  }
-
-  /**
-   * Stop ICE polling
-   */
-  private stopIcePolling(): void {
-    if (this.icePollingInterval) {
-      clearInterval(this.icePollingInterval);
-      this.icePollingInterval = undefined;
-    }
-  }
-
-  /**
-   * Stop all polling
-   */
-  private stopPolling(): void {
-    this.stopAnswerPolling();
-    this.stopIcePolling();
-  }
-
-  /**
-   * Add event listener
-   */
-  on<K extends keyof RondevuConnectionEvents>(
-    event: K,
-    listener: RondevuConnectionEvents[K]
-  ): void {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set());
-    }
-    this.eventListeners.get(event)!.add(listener);
-  }
-
-  /**
-   * Remove event listener
-   */
-  off<K extends keyof RondevuConnectionEvents>(
-    event: K,
-    listener: RondevuConnectionEvents[K]
-  ): void {
-    const listeners = this.eventListeners.get(event);
-    if (listeners) {
-      listeners.delete(listener);
-    }
-  }
-
-  /**
-   * Emit event
-   */
-  private emit<K extends keyof RondevuConnectionEvents>(
-    event: K,
-    ...args: Parameters<RondevuConnectionEvents[K]>
-  ): void {
-    const listeners = this.eventListeners.get(event);
-    if (listeners) {
-      listeners.forEach(listener => {
-        (listener as any)(...args);
-      });
-    }
-  }
-
-  /**
-   * Add a media track to the connection
-   */
-  addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender {
-    return this.pc.addTrack(track, ...streams);
-  }
-
-  /**
-   * Close the connection and clean up
-   */
-  close(): void {
-    this.stopPolling();
-    this.pc.close();
-    this.eventListeners.clear();
-  }
-}

src/durable-connection.ts

@@ -0,0 +1,290 @@
+import {
+    ConnectionEvents,
+    ConnectionInterface,
+    ConnectionStates,
+    isConnectionState,
+    Message,
+    QueueMessageOptions,
+    Signaler,
+} from './types.js'
+import { EventBus } from './event-bus.js'
+import { createBin } from './bin.js'
+import { WebRTCContext } from './webrtc-context'
+
+export type WebRTCRondevuConnectionOptions = {
+    offer?: RTCSessionDescriptionInit | null
+    context: WebRTCContext
+    signaler: Signaler
+}
+
+/**
+ * WebRTCRondevuConnection - WebRTC peer connection wrapper with Rondevu signaling
+ *
+ * Manages a WebRTC peer connection lifecycle including:
+ * - Automatic offer/answer creation based on role
+ * - ICE candidate exchange via Rondevu signaling server
+ * - Connection state management with type-safe events
+ * - Data channel creation and message handling
+ *
+ * The connection automatically determines its role (offerer or answerer) based on whether
+ * an offer is provided in the constructor. The offerer creates the data channel, while
+ * the answerer receives it via the 'datachannel' event.
+ *
+ * @example
+ * ```typescript
+ * // Offerer side (creates offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0'
+ * );
+ *
+ * await connection.ready; // Wait for local offer
+ * const sdp = connection.connection.localDescription!.sdp!;
+ * // Send sdp to signaling server...
+ *
+ * // Answerer side (receives offer)
+ * const connection = new WebRTCRondevuConnection(
+ *   'conn-123',
+ *   'peer-username',
+ *   'chat.service@1.0.0',
+ *   { type: 'offer', sdp: remoteOfferSdp }
+ * );
+ *
+ * await connection.ready; // Wait for local answer
+ * const answerSdp = connection.connection.localDescription!.sdp!;
+ * // Send answer to signaling server...
+ *
+ * // Both sides: Set up signaler and listen for state changes
+ * connection.setSignaler(signaler);
+ * connection.events.on('state-change', (state) => {
+ *   console.log('Connection state:', state);
+ * });
+ * ```
+ */
+export class RTCDurableConnection implements ConnectionInterface {
+    private readonly side: 'offer' | 'answer'
+    public readonly expiresAt: number = 0
+    public readonly lastActive: number = 0
+    public readonly events: EventBus<ConnectionEvents> = new EventBus()
+    public readonly ready: Promise<void>
+    private iceBin = createBin()
+    private context: WebRTCContext
+    private readonly signaler: Signaler
+    private _conn: RTCPeerConnection | null = null
+    private _state: ConnectionInterface['state'] = 'disconnected'
+    private _dataChannel: RTCDataChannel | null = null
+    private messageQueue: Array<{
+        message: Message
+        options: QueueMessageOptions
+        timestamp: number
+    }> = []
+
+    constructor({ context, offer, signaler }: WebRTCRondevuConnectionOptions) {
+        this.context = context
+        this.signaler = signaler
+        this._conn = context.createPeerConnection()
+        this.side = offer ? 'answer' : 'offer'
+
+        // setup data channel
+        if (offer) {
+            this._conn.addEventListener('datachannel', e => {
+                this._dataChannel = e.channel
+                this.setupDataChannelListeners(this._dataChannel)
+            })
+        } else {
+            this._dataChannel = this._conn.createDataChannel('vu.ronde.protocol')
+            this.setupDataChannelListeners(this._dataChannel)
+        }
+
+        // setup description exchange
+        this.ready = offer
+            ? this._conn
+                  .setRemoteDescription(offer)
+                  .then(() => this._conn?.createAnswer())
+                  .then(async answer => {
+                      if (!answer || !this._conn) throw new Error('Connection disappeared')
+                      await this._conn.setLocalDescription(answer)
+                      return await signaler.setAnswer(answer)
+                  })
+            : this._conn.createOffer().then(async offer => {
+                  if (!this._conn) throw new Error('Connection disappeared')
+                  await this._conn.setLocalDescription(offer)
+                  return await signaler.setOffer(offer)
+              })
+
+        // propagate connection state changes
+        this._conn.addEventListener('connectionstatechange', () => {
+            console.log(this.side, 'connection state changed: ', this._conn!.connectionState)
+            const state = isConnectionState(this._conn!.connectionState)
+                ? this._conn!.connectionState
+                : 'disconnected'
+            this.setState(state)
+        })
+
+        this._conn.addEventListener('iceconnectionstatechange', () => {
+            console.log(this.side, 'ice connection state changed: ', this._conn!.iceConnectionState)
+        })
+
+        // start ICE candidate exchange when gathering begins
+        this._conn.addEventListener('icegatheringstatechange', () => {
+            if (this._conn!.iceGatheringState === 'gathering') {
+                this.startIce()
+            } else if (this._conn!.iceGatheringState === 'complete') {
+                this.stopIce()
+            }
+        })
+    }
+
+    /**
+     * Getter method for retrieving the current connection.
+     *
+     * @return {RTCPeerConnection|null} The current connection instance.
+     */
+    public get connection(): RTCPeerConnection | null {
+        return this._conn
+    }
+
+    /**
+     * Update connection state and emit state-change event
+     */
+    private setState(state: ConnectionInterface['state']) {
+        this._state = state
+        this.events.emit('state-change', state)
+    }
+
+    /**
+     * Start ICE candidate exchange when gathering begins
+     */
+    private startIce() {
+        const listener = ({ candidate }: { candidate: RTCIceCandidate | null }) => {
+            if (candidate) this.signaler.addIceCandidate(candidate)
+        }
+        if (!this._conn) throw new Error('Connection disappeared')
+        this._conn.addEventListener('icecandidate', listener)
+        this.iceBin(
+            this.signaler.addListener((candidate: RTCIceCandidate) =>
+                this._conn?.addIceCandidate(candidate)
+            ),
+            () => this._conn?.removeEventListener('icecandidate', listener)
+        )
+    }
+
+    /**
+     * Stop ICE candidate exchange when gathering completes
+     */
+    private stopIce() {
+        this.iceBin.clean()
+    }
+
+    /**
+     * Disconnects the current connection and cleans up resources.
+     * Closes the active connection if it exists, resets the connection instance to null,
+     * stops the ICE process, and updates the state to 'disconnected'.
+     *
+     * @return {void} No return value.
+     */
+    disconnect(): void {
+        this._conn?.close()
+        this._conn = null
+        this.stopIce()
+        this.setState('disconnected')
+    }
+
+    /**
+     * Current connection state
+     */
+    get state() {
+        return this._state
+    }
+
+    /**
+     * Setup data channel event listeners
+     */
+    private setupDataChannelListeners(channel: RTCDataChannel): void {
+        channel.addEventListener('message', e => {
+            this.events.emit('message', e.data)
+        })
+
+        channel.addEventListener('open', () => {
+            // Channel opened - flush queued messages
+            this.flushQueue().catch(err => {
+                console.error('Failed to flush message queue:', err)
+            })
+        })
+
+        channel.addEventListener('error', err => {
+            console.error('Data channel error:', err)
+        })
+
+        channel.addEventListener('close', () => {
+            console.log('Data channel closed')
+        })
+    }
+
+    /**
+     * Flush the message queue
+     */
+    private async flushQueue(): Promise<void> {
+        while (this.messageQueue.length > 0 && this._state === 'connected') {
+            const item = this.messageQueue.shift()!
+
+            // Check expiration
+            if (item.options.expiresAt && Date.now() > item.options.expiresAt) {
+                continue
+            }
+
+            const success = await this.sendMessage(item.message)
+            if (!success) {
+                // Re-queue on failure
+                this.messageQueue.unshift(item)
+                break
+            }
+        }
+    }
+
+    /**
+     * Queue a message for sending when connection is established
+     *
+     * @param message - Message to queue (string or ArrayBuffer)
+     * @param options - Queue options (e.g., expiration time)
+     */
+    async queueMessage(message: Message, options: QueueMessageOptions = {}): Promise<void> {
+        this.messageQueue.push({
+            message,
+            options,
+            timestamp: Date.now()
+        })
+
+        // Try immediate send if connected
+        if (this._state === 'connected') {
+            await this.flushQueue()
+        }
+    }
+
+    /**
+     * Send a message immediately
+     *
+     * @param message - Message to send (string or ArrayBuffer)
+     * @returns Promise resolving to true if sent successfully
+     */
+    async sendMessage(message: Message): Promise<boolean> {
+        if (this._state !== 'connected' || !this._dataChannel) {
+            return false
+        }
+
+        if (this._dataChannel.readyState !== 'open') {
+            return false
+        }
+
+        try {
+            // TypeScript has trouble with the union type, so we cast to any
+            // Both string and ArrayBuffer are valid for RTCDataChannel.send()
+            this._dataChannel.send(message as any)
+            return true
+        } catch (err) {
+            console.error('Send failed:', err)
+            return false
+        }
+    }
+}

src/event-bus.ts

@@ -0,0 +1,94 @@
+/**
+ * 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
+     * Returns a cleanup function to unsubscribe
+     */
+    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)
+
+        // Return cleanup function
+        return () => this.off(event, 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()
+        }
+    }
+}

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,31 +1,44 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with topic-based discovery
+ * WebRTC peer signaling client
  */
 
-// Export main client class
+export { EventBus } from './event-bus.js'
-export { Rondevu } from './rondevu.js';
+export { RondevuAPI } from './api.js'
-export type { RondevuOptions } from './rondevu.js';
+export { RondevuService } from './rondevu-service.js'
+export { RondevuSignaler } from './rondevu-signaler.js'
+export { WebRTCContext } from './webrtc-context.js'
+export { RTCDurableConnection } from './durable-connection'
+export { ServiceHost } from './service-host.js'
+export { ServiceClient } from './service-client.js'
+export { createBin } from './bin.js'
 
-// Export authentication
+// Export types
-export { RondevuAuth } from './auth.js';
-export type { Credentials, FetchFunction } from './auth.js';
-
-// Export offers API
-export { RondevuOffers } from './offers.js';
 export type {
-  CreateOfferRequest,
+    ConnectionInterface,
-  Offer,
+    QueueMessageOptions,
-  IceCandidate,
+    Message,
-  TopicInfo
+    ConnectionEvents,
-} from './offers.js';
+    Signaler,
+} from './types.js'
 
-// Export bloom filter
-export { BloomFilter } from './bloom.js';
-
-// Export connection manager
-export { RondevuConnection } from './connection.js';
 export type {
-  ConnectionOptions,
+    Credentials,
-  RondevuConnectionEvents
+    Keypair,
-} from './connection.js';
+    OfferRequest,
+    Offer,
+    ServiceRequest,
+    Service,
+    IceCandidate,
+} from './api.js'
+
+export type { Binnable } from './bin.js'
+
+export type { RondevuServiceOptions, PublishServiceOptions } from './rondevu-service.js'
+
+export type { ServiceHostOptions, ServiceHostEvents } from './service-host.js'
+
+export type { ServiceClientOptions, ServiceClientEvents } from './service-client.js'
+
+export type { PollingConfig } from './rondevu-signaler.js'
+

src/offers.ts

@@ -1,338 +0,0 @@
-import { Credentials, FetchFunction } from './auth.js';
-import { RondevuAuth } from './auth.js';
-
-// Declare Buffer for Node.js compatibility
-declare const Buffer: any;
-
-export interface CreateOfferRequest {
-  id?: string;
-  sdp: string;
-  topics: string[];
-  ttl?: number;
-}
-
-export interface Offer {
-  id: string;
-  peerId: string;
-  sdp: string;
-  topics: string[];
-  createdAt?: number;
-  expiresAt: number;
-  lastSeen: number;
-  answererPeerId?: string;
-  answerSdp?: string;
-  answeredAt?: number;
-}
-
-/**
- * RTCIceCandidateInit interface for environments without native WebRTC types
- */
-export interface RTCIceCandidateInit {
-  candidate?: string;
-  sdpMid?: string | null;
-  sdpMLineIndex?: number | null;
-  usernameFragment?: string | null;
-}
-
-export interface IceCandidate {
-  candidate: RTCIceCandidateInit; // Full candidate object
-  peerId: string;
-  role: 'offerer' | 'answerer';
-  createdAt: number;
-}
-
-export interface TopicInfo {
-  topic: string;
-  activePeers: number;
-}
-
-export class RondevuOffers {
-  private fetchFn: FetchFunction;
-
-  constructor(
-    private baseUrl: string,
-    private credentials: Credentials,
-    fetchFn?: FetchFunction
-  ) {
-    // Use provided fetch or fall back to global fetch
-    this.fetchFn = fetchFn || ((...args) => {
-      if (typeof globalThis.fetch === 'function') {
-        return globalThis.fetch(...args);
-      }
-      throw new Error(
-        'fetch is not available. Please provide a fetch implementation in the constructor options.'
-      );
-    });
-  }
-
-  /**
-   * Create one or more offers
-   */
-  async create(offers: CreateOfferRequest[]): Promise<Offer[]> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-      body: JSON.stringify({ offers }),
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to create offers: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data.offers;
-  }
-
-  /**
-   * Find offers by topic with optional bloom filter
-   */
-  async findByTopic(
-    topic: string,
-    options?: {
-      bloomFilter?: Uint8Array;
-      limit?: number;
-    }
-  ): Promise<Offer[]> {
-    const params = new URLSearchParams();
-
-    if (options?.bloomFilter) {
-      // Convert to base64
-      const binaryString = String.fromCharCode(...Array.from(options.bloomFilter));
-      const base64 = typeof btoa !== 'undefined'
-        ? btoa(binaryString)
-        : (typeof Buffer !== 'undefined' ? Buffer.from(options.bloomFilter).toString('base64') : '');
-      params.set('bloom', base64);
-    }
-
-    if (options?.limit) {
-      params.set('limit', options.limit.toString());
-    }
-
-    const url = `${this.baseUrl}/offers/by-topic/${encodeURIComponent(topic)}${
-      params.toString() ? '?' + params.toString() : ''
-    }`;
-
-    const response = await this.fetchFn(url, {
-      method: 'GET',
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to find offers: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data.offers;
-  }
-
-  /**
-   * Get all offers from a specific peer
-   */
-  async getByPeerId(peerId: string): Promise<{
-    offers: Offer[];
-    topics: string[];
-  }> {
-    const response = await this.fetchFn(`${this.baseUrl}/peers/${encodeURIComponent(peerId)}/offers`, {
-      method: 'GET',
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to get peer offers: ${error.error || response.statusText}`);
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Get topics with active peer counts (paginated)
-   */
-  async getTopics(options?: {
-    limit?: number;
-    offset?: number;
-  }): Promise<{
-    topics: TopicInfo[];
-    total: number;
-    limit: number;
-    offset: number;
-  }> {
-    const params = new URLSearchParams();
-
-    if (options?.limit) {
-      params.set('limit', options.limit.toString());
-    }
-
-    if (options?.offset) {
-      params.set('offset', options.offset.toString());
-    }
-
-    const url = `${this.baseUrl}/topics${
-      params.toString() ? '?' + params.toString() : ''
-    }`;
-
-    const response = await this.fetchFn(url, {
-      method: 'GET',
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to get topics: ${error.error || response.statusText}`);
-    }
-
-    return await response.json();
-  }
-
-  /**
-   * Get own offers
-   */
-  async getMine(): Promise<Offer[]> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/mine`, {
-      method: 'GET',
-      headers: {
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to get own offers: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data.offers;
-  }
-
-  /**
-   * Update offer heartbeat
-   */
-  async heartbeat(offerId: string): Promise<void> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/heartbeat`, {
-      method: 'PUT',
-      headers: {
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to update heartbeat: ${error.error || response.statusText}`);
-    }
-  }
-
-  /**
-   * Delete an offer
-   */
-  async delete(offerId: string): Promise<void> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}`, {
-      method: 'DELETE',
-      headers: {
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to delete offer: ${error.error || response.statusText}`);
-    }
-  }
-
-  /**
-   * Answer an offer
-   */
-  async answer(offerId: string, sdp: string): Promise<void> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/answer`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-      body: JSON.stringify({ sdp }),
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
-    }
-  }
-
-  /**
-   * Get answers to your offers
-   */
-  async getAnswers(): Promise<Array<{
-    offerId: string;
-    answererId: string;
-    sdp: string;
-    answeredAt: number;
-    topics: string[];
-  }>> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/answers`, {
-      method: 'GET',
-      headers: {
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to get answers: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data.answers;
-  }
-
-  /**
-   * Post ICE candidates for an offer
-   */
-  async addIceCandidates(
-    offerId: string,
-    candidates: RTCIceCandidateInit[]
-  ): Promise<void> {
-    const response = await this.fetchFn(`${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-      body: JSON.stringify({ candidates }),
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to add ICE candidates: ${error.error || response.statusText}`);
-    }
-  }
-
-  /**
-   * Get ICE candidates for an offer
-   */
-  async getIceCandidates(offerId: string, since?: number): Promise<IceCandidate[]> {
-    const params = new URLSearchParams();
-    if (since !== undefined) {
-      params.set('since', since.toString());
-    }
-
-    const url = `${this.baseUrl}/offers/${encodeURIComponent(offerId)}/ice-candidates${
-      params.toString() ? '?' + params.toString() : ''
-    }`;
-
-    const response = await this.fetchFn(url, {
-      method: 'GET',
-      headers: {
-        Authorization: RondevuAuth.createAuthHeader(this.credentials),
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-      throw new Error(`Failed to get ICE candidates: ${error.error || response.statusText}`);
-    }
-
-    const data = await response.json();
-    return data.candidates;
-  }
-}

src/rondevu-service.ts

@@ -0,0 +1,175 @@
+import { RondevuAPI, Credentials, Keypair, Service, ServiceRequest } from './api.js'
+
+export interface RondevuServiceOptions {
+    apiUrl: string
+    username: string
+    keypair?: Keypair
+    credentials?: Credentials
+}
+
+export interface PublishServiceOptions {
+    serviceFqn: string
+    offers: Array<{ sdp: string }>
+    ttl?: number
+    isPublic?: boolean
+    metadata?: Record<string, any>
+}
+
+/**
+ * RondevuService - High-level service management with automatic signature handling
+ *
+ * Provides a simplified API for:
+ * - Username claiming with Ed25519 signatures
+ * - Service publishing with automatic signature generation
+ * - Keypair management
+ *
+ * @example
+ * ```typescript
+ * // Initialize service (generates keypair automatically)
+ * const service = new RondevuService({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'myusername',
+ * })
+ *
+ * await service.initialize()
+ *
+ * // Claim username (one time)
+ * await service.claimUsername()
+ *
+ * // Publish a service
+ * const publishedService = await service.publishService({
+ *   serviceFqn: 'chat.app@1.0.0',
+ *   offers: [{ sdp: offerSdp }],
+ *   ttl: 300000,
+ *   isPublic: true,
+ * })
+ * ```
+ */
+export class RondevuService {
+    private readonly api: RondevuAPI
+    private readonly username: string
+    private keypair: Keypair | null = null
+    private usernameClaimed = false
+
+    constructor(options: RondevuServiceOptions) {
+        this.username = options.username
+        this.keypair = options.keypair || null
+        this.api = new RondevuAPI(options.apiUrl, options.credentials)
+    }
+
+    /**
+     * Initialize the service - generates keypair if not provided
+     * Call this before using other methods
+     */
+    async initialize(): Promise<void> {
+        if (!this.keypair) {
+            this.keypair = await RondevuAPI.generateKeypair()
+        }
+
+        // Register with API if no credentials provided
+        if (!this.api['credentials']) {
+            const credentials = await this.api.register()
+            this.api.setCredentials(credentials)
+        }
+    }
+
+    /**
+     * Claim the username with Ed25519 signature
+     * Should be called once before publishing services
+     */
+    async claimUsername(): Promise<void> {
+        if (!this.keypair) {
+            throw new Error('Service not initialized. Call initialize() first.')
+        }
+
+        // Check if username is already claimed
+        const check = await this.api.checkUsername(this.username)
+        if (!check.available) {
+            // Verify it's claimed by us
+            if (check.owner === this.keypair.publicKey) {
+                this.usernameClaimed = true
+                return
+            }
+            throw new Error(`Username "${this.username}" is already claimed by another user`)
+        }
+
+        // Generate signature for username claim
+        const message = `claim:${this.username}:${Date.now()}`
+        const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey)
+
+        // Claim the username
+        await this.api.claimUsername(this.username, this.keypair.publicKey, signature, message)
+        this.usernameClaimed = true
+    }
+
+    /**
+     * Publish a service with automatic signature generation
+     */
+    async publishService(options: PublishServiceOptions): Promise<Service> {
+        if (!this.keypair) {
+            throw new Error('Service not initialized. Call initialize() first.')
+        }
+
+        if (!this.usernameClaimed) {
+            throw new Error(
+                'Username not claimed. Call claimUsername() first or the server will reject the service.'
+            )
+        }
+
+        const { serviceFqn, offers, ttl, isPublic, metadata } = options
+
+        // Generate signature for service publication
+        const message = `publish:${this.username}:${serviceFqn}:${Date.now()}`
+        const signature = await RondevuAPI.signMessage(message, this.keypair.privateKey)
+
+        // Create service request
+        const serviceRequest: ServiceRequest = {
+            username: this.username,
+            serviceFqn,
+            offers,
+            signature,
+            message,
+            ttl,
+            isPublic,
+            metadata,
+        }
+
+        // Publish to server
+        return await this.api.publishService(serviceRequest)
+    }
+
+    /**
+     * Get the current keypair (for backup/storage)
+     */
+    getKeypair(): Keypair | null {
+        return this.keypair
+    }
+
+    /**
+     * Get the username
+     */
+    getUsername(): string {
+        return this.username
+    }
+
+    /**
+     * Get the public key
+     */
+    getPublicKey(): string | null {
+        return this.keypair?.publicKey || null
+    }
+
+    /**
+     * Check if username has been claimed
+     */
+    isUsernameClaimed(): boolean {
+        return this.usernameClaimed
+    }
+
+    /**
+     * Access to underlying API for advanced operations
+     */
+    getAPI(): RondevuAPI {
+        return this.api
+    }
+}

src/rondevu-signaler.ts

@@ -0,0 +1,462 @@
+import { Signaler } from './types.js'
+import { RondevuService } from './rondevu-service.js'
+import { Binnable } from './bin.js'
+
+export interface PollingConfig {
+    initialInterval?: number     // Default: 500ms
+    maxInterval?: number          // Default: 5000ms
+    backoffMultiplier?: number    // Default: 1.5
+    maxRetries?: number           // Default: 50 (50 seconds max)
+    jitter?: boolean              // Default: true
+}
+
+/**
+ * RondevuSignaler - Handles WebRTC signaling via Rondevu service
+ *
+ * Manages offer/answer exchange and ICE candidate polling for establishing
+ * WebRTC connections through the Rondevu signaling server.
+ *
+ * Supports configurable polling with exponential backoff and jitter to reduce
+ * server load and prevent thundering herd issues.
+ *
+ * @example
+ * ```typescript
+ * const signaler = new RondevuSignaler(
+ *   rondevuService,
+ *   'chat.app@1.0.0',
+ *   'peer-username',
+ *   { initialInterval: 500, maxInterval: 5000, jitter: true }
+ * )
+ *
+ * // For offerer:
+ * await signaler.setOffer(offer)
+ * signaler.addAnswerListener(answer => {
+ *   // Handle remote answer
+ * })
+ *
+ * // For answerer:
+ * signaler.addOfferListener(offer => {
+ *   // Handle remote offer
+ * })
+ * await signaler.setAnswer(answer)
+ * ```
+ */
+export class RondevuSignaler implements Signaler {
+    private offerId: string | null = null
+    private serviceUuid: string | null = null
+    private offerListeners: Array<(offer: RTCSessionDescriptionInit) => void> = []
+    private answerListeners: Array<(answer: RTCSessionDescriptionInit) => void> = []
+    private iceListeners: Array<(candidate: RTCIceCandidate) => void> = []
+    private answerPollingTimeout: ReturnType<typeof setTimeout> | null = null
+    private icePollingTimeout: ReturnType<typeof setTimeout> | null = null
+    private lastIceTimestamp = 0
+    private isPolling = false
+    private pollingConfig: Required<PollingConfig>
+
+    constructor(
+        private readonly rondevu: RondevuService,
+        private readonly service: string,
+        private readonly host?: string,
+        pollingConfig?: PollingConfig
+    ) {
+        this.pollingConfig = {
+            initialInterval: pollingConfig?.initialInterval ?? 500,
+            maxInterval: pollingConfig?.maxInterval ?? 5000,
+            backoffMultiplier: pollingConfig?.backoffMultiplier ?? 1.5,
+            maxRetries: pollingConfig?.maxRetries ?? 50,
+            jitter: pollingConfig?.jitter ?? true
+        }
+    }
+
+    /**
+     * Publish an offer as a service
+     * Used by the offerer to make their offer available
+     */
+    async setOffer(offer: RTCSessionDescriptionInit): Promise<void> {
+        if (!offer.sdp) {
+            throw new Error('Offer SDP is required')
+        }
+
+        // Publish service with the offer SDP
+        const publishedService = await this.rondevu.publishService({
+            serviceFqn: this.service,
+            offers: [{ sdp: offer.sdp }],
+            ttl: 300000, // 5 minutes
+            isPublic: true,
+        })
+
+        // Get the first offer from the published service
+        if (!publishedService.offers || publishedService.offers.length === 0) {
+            throw new Error('No offers returned from service publication')
+        }
+
+        this.offerId = publishedService.offers[0].offerId
+        this.serviceUuid = publishedService.uuid
+
+        // Start polling for answer
+        this.startAnswerPolling()
+
+        // Start polling for ICE candidates
+        this.startIcePolling()
+    }
+
+    /**
+     * Send an answer to the offerer
+     * Used by the answerer to respond to an offer
+     */
+    async setAnswer(answer: RTCSessionDescriptionInit): Promise<void> {
+        if (!answer.sdp) {
+            throw new Error('Answer SDP is required')
+        }
+
+        if (!this.serviceUuid) {
+            throw new Error('No service UUID available. Must receive offer first.')
+        }
+
+        // Send answer to the service
+        const result = await this.rondevu.getAPI().answerService(this.serviceUuid, answer.sdp)
+        this.offerId = result.offerId
+
+        // Start polling for ICE candidates
+        this.startIcePolling()
+    }
+
+    /**
+     * Listen for incoming offers
+     * Used by the answerer to receive offers from the offerer
+     */
+    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable {
+        this.offerListeners.push(callback)
+
+        // If we have a host, start searching for their service
+        if (this.host && !this.isPolling) {
+            this.searchForOffer()
+        }
+
+        // Return cleanup function
+        return () => {
+            const index = this.offerListeners.indexOf(callback)
+            if (index > -1) {
+                this.offerListeners.splice(index, 1)
+            }
+        }
+    }
+
+    /**
+     * Listen for incoming answers
+     * Used by the offerer to receive the answer from the answerer
+     */
+    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable {
+        this.answerListeners.push(callback)
+
+        // Return cleanup function
+        return () => {
+            const index = this.answerListeners.indexOf(callback)
+            if (index > -1) {
+                this.answerListeners.splice(index, 1)
+            }
+        }
+    }
+
+    /**
+     * Send an ICE candidate to the remote peer
+     */
+    async addIceCandidate(candidate: RTCIceCandidate): Promise<void> {
+        if (!this.serviceUuid) {
+            console.warn('Cannot send ICE candidate: no service UUID')
+            return
+        }
+
+        const candidateData = candidate.toJSON()
+
+        // Skip empty candidates
+        if (!candidateData.candidate || candidateData.candidate === '') {
+            return
+        }
+
+        try {
+            const result = await this.rondevu.getAPI().addServiceIceCandidates(
+                this.serviceUuid,
+                [candidateData],
+                this.offerId || undefined
+            )
+            // Store offerId if we didn't have it yet
+            if (!this.offerId) {
+                this.offerId = result.offerId
+            }
+        } catch (err) {
+            console.error('Failed to send ICE candidate:', err)
+        }
+    }
+
+    /**
+     * Listen for ICE candidates from the remote peer
+     */
+    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable {
+        this.iceListeners.push(callback)
+
+        // Return cleanup function
+        return () => {
+            const index = this.iceListeners.indexOf(callback)
+            if (index > -1) {
+                this.iceListeners.splice(index, 1)
+            }
+        }
+    }
+
+    /**
+     * Search for an offer from the host
+     * Used by the answerer to find the offerer's service
+     */
+    private async searchForOffer(): Promise<void> {
+        if (!this.host) {
+            throw new Error('No host specified for offer search')
+        }
+
+        this.isPolling = true
+
+        try {
+            // Search for services by username and service FQN
+            const services = await this.rondevu.getAPI().searchServices(this.host, this.service)
+
+            if (services.length === 0) {
+                console.warn(`No services found for ${this.host}/${this.service}`)
+                this.isPolling = false
+                return
+            }
+
+            // Get the first available service (already has full details from searchServices)
+            const service = services[0] as any
+
+            // Get the first available offer from the service
+            if (!service.offers || service.offers.length === 0) {
+                console.warn(`No offers available for service ${this.host}/${this.service}`)
+                this.isPolling = false
+                return
+            }
+
+            const firstOffer = service.offers[0]
+            this.offerId = firstOffer.offerId
+            this.serviceUuid = service.uuid
+
+            // Notify offer listeners
+            const offer: RTCSessionDescriptionInit = {
+                type: 'offer',
+                sdp: firstOffer.sdp,
+            }
+
+            this.offerListeners.forEach(listener => {
+                try {
+                    listener(offer)
+                } catch (err) {
+                    console.error('Offer listener error:', err)
+                }
+            })
+        } catch (err) {
+            console.error('Failed to search for offer:', err)
+            this.isPolling = false
+        }
+    }
+
+    /**
+     * Start polling for answer (offerer side) with exponential backoff
+     */
+    private startAnswerPolling(): void {
+        if (this.answerPollingTimeout || !this.serviceUuid) {
+            return
+        }
+
+        let interval = this.pollingConfig.initialInterval
+        let retries = 0
+
+        const poll = async () => {
+            if (!this.serviceUuid) {
+                this.stopAnswerPolling()
+                return
+            }
+
+            try {
+                const answer = await this.rondevu.getAPI().getServiceAnswer(this.serviceUuid)
+
+                if (answer && answer.sdp) {
+                    // Store offerId if we didn't have it yet
+                    if (!this.offerId) {
+                        this.offerId = answer.offerId
+                    }
+
+                    // Got answer - notify listeners and stop polling
+                    const answerDesc: RTCSessionDescriptionInit = {
+                        type: 'answer',
+                        sdp: answer.sdp,
+                    }
+
+                    this.answerListeners.forEach(listener => {
+                        try {
+                            listener(answerDesc)
+                        } catch (err) {
+                            console.error('Answer listener error:', err)
+                        }
+                    })
+
+                    // Stop polling once we get the answer
+                    this.stopAnswerPolling()
+                    return
+                }
+
+                // No answer yet - exponential backoff
+                retries++
+                if (retries > this.pollingConfig.maxRetries) {
+                    console.warn('Max retries reached for answer polling')
+                    this.stopAnswerPolling()
+                    return
+                }
+
+                interval = Math.min(
+                    interval * this.pollingConfig.backoffMultiplier,
+                    this.pollingConfig.maxInterval
+                )
+
+                // Add jitter to prevent thundering herd
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval
+
+                this.answerPollingTimeout = setTimeout(poll, finalInterval)
+
+            } catch (err) {
+                // 404 is expected when answer isn't available yet
+                if (err instanceof Error && !err.message?.includes('404')) {
+                    console.error('Error polling for answer:', err)
+                }
+
+                // Retry with backoff
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval
+                this.answerPollingTimeout = setTimeout(poll, finalInterval)
+            }
+        }
+
+        poll() // Start immediately
+    }
+
+    /**
+     * Stop polling for answer
+     */
+    private stopAnswerPolling(): void {
+        if (this.answerPollingTimeout) {
+            clearTimeout(this.answerPollingTimeout)
+            this.answerPollingTimeout = null
+        }
+    }
+
+    /**
+     * Start polling for ICE candidates with adaptive backoff
+     */
+    private startIcePolling(): void {
+        if (this.icePollingTimeout || !this.serviceUuid) {
+            return
+        }
+
+        let interval = this.pollingConfig.initialInterval
+
+        const poll = async () => {
+            if (!this.serviceUuid) {
+                this.stopIcePolling()
+                return
+            }
+
+            try {
+                const result = await this.rondevu
+                    .getAPI()
+                    .getServiceIceCandidates(this.serviceUuid, this.lastIceTimestamp, this.offerId || undefined)
+
+                // Store offerId if we didn't have it yet
+                if (!this.offerId) {
+                    this.offerId = result.offerId
+                }
+
+                let foundCandidates = false
+
+                for (const item of result.candidates) {
+                    if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
+                        foundCandidates = true
+                        try {
+                            const rtcCandidate = new RTCIceCandidate(item.candidate)
+
+                            this.iceListeners.forEach(listener => {
+                                try {
+                                    listener(rtcCandidate)
+                                } catch (err) {
+                                    console.error('ICE listener error:', err)
+                                }
+                            })
+
+                            this.lastIceTimestamp = item.createdAt
+                        } catch (err) {
+                            console.warn('Failed to process ICE candidate:', err)
+                            this.lastIceTimestamp = item.createdAt
+                        }
+                    } else {
+                        this.lastIceTimestamp = item.createdAt
+                    }
+                }
+
+                // If candidates found, reset interval to initial value
+                // Otherwise, increase interval with backoff
+                if (foundCandidates) {
+                    interval = this.pollingConfig.initialInterval
+                } else {
+                    interval = Math.min(
+                        interval * this.pollingConfig.backoffMultiplier,
+                        this.pollingConfig.maxInterval
+                    )
+                }
+
+                // Add jitter
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval
+
+                this.icePollingTimeout = setTimeout(poll, finalInterval)
+
+            } catch (err) {
+                // 404/410 means offer expired, stop polling
+                if (err instanceof Error && (err.message?.includes('404') || err.message?.includes('410'))) {
+                    console.warn('Offer not found or expired, stopping ICE polling')
+                    this.stopIcePolling()
+                } else if (err instanceof Error && !err.message?.includes('404')) {
+                    console.error('Error polling for ICE candidates:', err)
+                    // Continue polling despite errors
+                    const finalInterval = this.pollingConfig.jitter
+                        ? interval + Math.random() * 100
+                        : interval
+                    this.icePollingTimeout = setTimeout(poll, finalInterval)
+                }
+            }
+        }
+
+        poll() // Start immediately
+    }
+
+    /**
+     * Stop polling for ICE candidates
+     */
+    private stopIcePolling(): void {
+        if (this.icePollingTimeout) {
+            clearTimeout(this.icePollingTimeout)
+            this.icePollingTimeout = null
+        }
+    }
+
+    /**
+     * Stop all polling and cleanup
+     */
+    dispose(): void {
+        this.stopAnswerPolling()
+        this.stopIcePolling()
+        this.offerListeners = []
+        this.answerListeners = []
+        this.iceListeners = []
+    }
+}

src/rondevu.ts

@@ -1,103 +0,0 @@
-import { RondevuAuth, Credentials, FetchFunction } from './auth.js';
-import { RondevuOffers } from './offers.js';
-import { RondevuConnection, ConnectionOptions } from './connection.js';
-
-export interface RondevuOptions {
-  /**
-   * Base URL of the Rondevu server
-   * @default 'https://api.ronde.vu'
-   */
-  baseUrl?: string;
-
-  /**
-   * Existing credentials (peerId + secret) to skip registration
-   */
-  credentials?: Credentials;
-
-  /**
-   * Custom fetch implementation for environments without native fetch
-   * (Node.js < 18, some Workers environments, etc.)
-   *
-   * @example Node.js
-   * ```typescript
-   * import fetch from 'node-fetch';
-   * const client = new Rondevu({ fetch });
-   * ```
-   */
-  fetch?: FetchFunction;
-}
-
-export class Rondevu {
-  readonly auth: RondevuAuth;
-  private _offers?: RondevuOffers;
-  private credentials?: Credentials;
-  private baseUrl: string;
-  private fetchFn?: FetchFunction;
-
-  constructor(options: RondevuOptions = {}) {
-    this.baseUrl = options.baseUrl || 'https://api.ronde.vu';
-    this.fetchFn = options.fetch;
-
-    this.auth = new RondevuAuth(this.baseUrl, this.fetchFn);
-
-    if (options.credentials) {
-      this.credentials = options.credentials;
-      this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
-    }
-  }
-
-  /**
-   * Get offers API (requires authentication)
-   */
-  get offers(): RondevuOffers {
-    if (!this._offers) {
-      throw new Error('Not authenticated. Call register() first or provide credentials.');
-    }
-    return this._offers;
-  }
-
-  /**
-   * Register and initialize authenticated client
-   */
-  async register(): Promise<Credentials> {
-    this.credentials = await this.auth.register();
-
-    // Create offers API instance
-    this._offers = new RondevuOffers(
-      this.baseUrl,
-      this.credentials,
-      this.fetchFn
-    );
-
-    return this.credentials;
-  }
-
-  /**
-   * Check if client is authenticated
-   */
-  isAuthenticated(): boolean {
-    return !!this.credentials;
-  }
-
-  /**
-   * Get current credentials
-   */
-  getCredentials(): Credentials | undefined {
-    return this.credentials;
-  }
-
-  /**
-   * Create a new WebRTC connection (requires authentication)
-   * This is a high-level helper that creates and manages WebRTC connections
-   *
-   * @param rtcConfig Optional RTCConfiguration for the peer connection
-   * @returns RondevuConnection instance
-   */
-  createConnection(rtcConfig?: RTCConfiguration): RondevuConnection {
-    if (!this._offers) {
-      throw new Error('Not authenticated. Call register() first or provide credentials.');
-    }
-
-    return new RondevuConnection(this._offers, rtcConfig);
-  }
-}

src/service-client.ts

@@ -0,0 +1,203 @@
+import { RondevuService } from './rondevu-service.js'
+import { RondevuSignaler } from './rondevu-signaler.js'
+import { WebRTCContext } from './webrtc-context.js'
+import { RTCDurableConnection } from './durable-connection.js'
+import { EventBus } from './event-bus.js'
+
+export interface ServiceClientOptions {
+    username: string                     // Host username
+    serviceFqn: string                  // e.g., 'chat.app@1.0.0'
+    rondevuService: RondevuService
+    autoReconnect?: boolean             // Default: true
+    maxReconnectAttempts?: number       // Default: 5
+    rtcConfiguration?: RTCConfiguration
+}
+
+export interface ServiceClientEvents {
+    connected: RTCDurableConnection
+    disconnected: void
+    reconnecting: { attempt: number; maxAttempts: number }
+    error: Error
+}
+
+/**
+ * ServiceClient - High-level wrapper for connecting to a WebRTC service
+ *
+ * Simplifies client connection by handling:
+ * - Service discovery
+ * - Offer/answer exchange
+ * - ICE candidate polling
+ * - Automatic reconnection
+ *
+ * @example
+ * ```typescript
+ * const client = new ServiceClient({
+ *     username: 'host-user',
+ *     serviceFqn: 'chat.app@1.0.0',
+ *     rondevuService: myService
+ * })
+ *
+ * client.events.on('connected', conn => {
+ *     conn.events.on('message', msg => console.log('Received:', msg))
+ *     conn.sendMessage('Hello from client!')
+ * })
+ *
+ * await client.connect()
+ * ```
+ */
+export class ServiceClient {
+    events: EventBus<ServiceClientEvents>
+
+    private signaler: RondevuSignaler | null = null
+    private webrtcContext: WebRTCContext
+    private connection: RTCDurableConnection | null = null
+    private autoReconnect: boolean
+    private maxReconnectAttempts: number
+    private reconnectAttempts = 0
+    private isConnecting = false
+
+    constructor(private options: ServiceClientOptions) {
+        this.events = new EventBus<ServiceClientEvents>()
+        this.webrtcContext = new WebRTCContext(options.rtcConfiguration)
+        this.autoReconnect = options.autoReconnect !== undefined ? options.autoReconnect : true
+        this.maxReconnectAttempts = options.maxReconnectAttempts || 5
+    }
+
+    /**
+     * Connect to the service
+     */
+    async connect(): Promise<RTCDurableConnection> {
+        if (this.isConnecting) {
+            throw new Error('Connection already in progress')
+        }
+
+        if (this.connection) {
+            throw new Error('Already connected. Disconnect first.')
+        }
+
+        this.isConnecting = true
+
+        try {
+            // Create signaler
+            this.signaler = new RondevuSignaler(
+                this.options.rondevuService,
+                this.options.serviceFqn,
+                this.options.username
+            )
+
+            // Wait for remote offer from signaler
+            const remoteOffer = await new Promise<RTCSessionDescriptionInit>((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Service discovery timeout'))
+                }, 30000)
+
+                this.signaler!.addOfferListener((offer) => {
+                    clearTimeout(timeout)
+                    resolve(offer)
+                })
+            })
+
+            // Create connection with remote offer (makes us the answerer)
+            const connection = new RTCDurableConnection({
+                context: this.webrtcContext,
+                signaler: this.signaler,
+                offer: remoteOffer
+            })
+
+            // Wait for connection to be ready
+            await connection.ready
+
+            // Set up connection event listeners
+            connection.events.on('state-change', (state) => {
+                if (state === 'connected') {
+                    this.reconnectAttempts = 0
+                    this.events.emit('connected', connection)
+                } else if (state === 'disconnected') {
+                    this.events.emit('disconnected', undefined)
+                    if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+                        this.attemptReconnect()
+                    }
+                }
+            })
+
+            this.connection = connection
+            this.isConnecting = false
+
+            return connection
+
+        } catch (err) {
+            this.isConnecting = false
+            const error = err instanceof Error ? err : new Error(String(err))
+            this.events.emit('error', error)
+            throw error
+        }
+    }
+
+    /**
+     * Disconnect from the service
+     */
+    dispose(): void {
+        if (this.signaler) {
+            this.signaler.dispose()
+            this.signaler = null
+        }
+
+        if (this.connection) {
+            this.connection.disconnect()
+            this.connection = null
+        }
+
+        this.isConnecting = false
+        this.reconnectAttempts = 0
+    }
+
+    /**
+     * @deprecated Use dispose() instead
+     */
+    disconnect(): void {
+        this.dispose()
+    }
+
+    /**
+     * Attempt to reconnect
+     */
+    private async attemptReconnect(): Promise<void> {
+        this.reconnectAttempts++
+        this.events.emit('reconnecting', {
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts
+        })
+
+        // Cleanup old connection
+        if (this.signaler) {
+            this.signaler.dispose()
+            this.signaler = null
+        }
+
+        if (this.connection) {
+            this.connection = null
+        }
+
+        // Wait a bit before reconnecting
+        await new Promise(resolve => setTimeout(resolve, 1000 * this.reconnectAttempts))
+
+        try {
+            await this.connect()
+        } catch (err) {
+            console.error('Reconnection attempt failed:', err)
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.attemptReconnect()
+            } else {
+                const error = new Error('Max reconnection attempts reached')
+                this.events.emit('error', error)
+            }
+        }
+    }
+
+    /**
+     * Get the current connection
+     */
+    getConnection(): RTCDurableConnection | null {
+        return this.connection
+    }
+}

src/service-host.ts

@@ -0,0 +1,158 @@
+import { RondevuService } from './rondevu-service.js'
+import { RondevuSignaler } from './rondevu-signaler.js'
+import { WebRTCContext } from './webrtc-context.js'
+import { RTCDurableConnection } from './durable-connection.js'
+import { EventBus } from './event-bus.js'
+
+export interface ServiceHostOptions {
+    service: string                      // e.g., 'chat.app@1.0.0'
+    rondevuService: RondevuService
+    maxPeers?: number                    // Default: 5
+    ttl?: number                         // Default: 300000 (5 min)
+    isPublic?: boolean                   // Default: true
+    rtcConfiguration?: RTCConfiguration
+    metadata?: Record<string, any>
+}
+
+export interface ServiceHostEvents {
+    connection: RTCDurableConnection
+    error: Error
+}
+
+/**
+ * ServiceHost - High-level wrapper for hosting a WebRTC service
+ *
+ * Simplifies hosting by handling:
+ * - Offer/answer exchange
+ * - ICE candidate polling
+ * - Connection pool management
+ * - Automatic reconnection
+ *
+ * @example
+ * ```typescript
+ * const host = new ServiceHost({
+ *     service: 'chat.app@1.0.0',
+ *     rondevuService: myService,
+ *     maxPeers: 5
+ * })
+ *
+ * host.events.on('connection', conn => {
+ *     conn.events.on('message', msg => console.log('Received:', msg))
+ *     conn.sendMessage('Hello!')
+ * })
+ *
+ * await host.start()
+ * ```
+ */
+export class ServiceHost {
+    events: EventBus<ServiceHostEvents>
+
+    private signaler: RondevuSignaler | null = null
+    private webrtcContext: WebRTCContext
+    private connections: RTCDurableConnection[] = []
+    private maxPeers: number
+    private running = false
+
+    constructor(private options: ServiceHostOptions) {
+        this.events = new EventBus<ServiceHostEvents>()
+        this.webrtcContext = new WebRTCContext(options.rtcConfiguration)
+        this.maxPeers = options.maxPeers || 5
+    }
+
+    /**
+     * Start hosting the service
+     */
+    async start(): Promise<void> {
+        if (this.running) {
+            throw new Error('ServiceHost already running')
+        }
+
+        this.running = true
+
+        // Create signaler
+        this.signaler = new RondevuSignaler(
+            this.options.rondevuService,
+            this.options.service
+        )
+
+        // Create first connection (offerer)
+        const connection = new RTCDurableConnection({
+            context: this.webrtcContext,
+            signaler: this.signaler,
+            offer: null  // null means we're the offerer
+        })
+
+        // Wait for connection to be ready
+        await connection.ready
+
+        // Set up connection event listeners
+        connection.events.on('state-change', (state) => {
+            if (state === 'connected') {
+                this.connections.push(connection)
+                this.events.emit('connection', connection)
+
+                // Create next connection if under maxPeers
+                if (this.connections.length < this.maxPeers) {
+                    this.createNextConnection().catch(err => {
+                        console.error('Failed to create next connection:', err)
+                        this.events.emit('error', err)
+                    })
+                }
+            } else if (state === 'disconnected') {
+                // Remove from connections list
+                const index = this.connections.indexOf(connection)
+                if (index > -1) {
+                    this.connections.splice(index, 1)
+                }
+            }
+        })
+
+        // Publish service with the offer
+        const offer = connection.connection?.localDescription
+        if (!offer?.sdp) {
+            throw new Error('Offer SDP is empty')
+        }
+
+        await this.signaler.setOffer(offer)
+    }
+
+    /**
+     * Create the next connection for incoming peers
+     */
+    private async createNextConnection(): Promise<void> {
+        if (!this.signaler || !this.running) {
+            return
+        }
+
+        // For now, we'll use the same offer for all connections
+        // In a production scenario, you'd create multiple offers
+        // This is a limitation of the current service model
+        // which publishes one offer per service
+    }
+
+    /**
+     * Stop hosting the service
+     */
+    dispose(): void {
+        this.running = false
+
+        // Cleanup signaler
+        if (this.signaler) {
+            this.signaler.dispose()
+            this.signaler = null
+        }
+
+        // Disconnect all connections
+        for (const conn of this.connections) {
+            conn.disconnect()
+        }
+        this.connections = []
+    }
+
+    /**
+     * Get all active connections
+     */
+    getConnections(): RTCDurableConnection[] {
+        return [...this.connections]
+    }
+}

src/types.ts

@@ -1,182 +1,44 @@
-// ============================================================================
-// Signaling Types
-// ============================================================================
-
 /**
- * Session side - identifies which peer in a connection
+ * Core connection types
  */
-export type Side = 'offerer' | 'answerer';
+import { EventBus } from './event-bus.js'
+import { Binnable } from './bin.js'
 
-/**
+export type Message = string | ArrayBuffer
- * Request body for POST /offer
+
- */
+export interface QueueMessageOptions {
-export interface CreateOfferRequest {
+    expiresAt?: number
-  /** 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;
 }
 
-/**
+export interface ConnectionEvents {
- * Response from POST /offer
+    'state-change': ConnectionInterface['state']
- */
+    message: Message
-export interface CreateOfferResponse {
-  /** Unique session identifier (UUID) */
-  code: string;
 }
 
-/**
+export const ConnectionStates = [
- * Request body for POST /answer
+    'connected',
- */
+    'disconnected',
-export interface AnswerRequest {
+    'connecting'
-  /** Session UUID from the offer */
+] as const
-  code: string;
+
-  /** Response signaling data (required if candidate not provided) */
+export const isConnectionState = (state: string): state is (typeof ConnectionStates)[number] =>
-  answer?: string;
+    ConnectionStates.includes(state as any)
-  /** Additional signaling data (required if answer not provided) */
+
-  candidate?: string;
+export interface ConnectionInterface {
-  /** Which peer is sending the data */
+    state: (typeof ConnectionStates)[number]
-  side: Side;
+    lastActive: number
+    expiresAt?: number
+    events: EventBus<ConnectionEvents>
+
+    queueMessage(message: Message, options?: QueueMessageOptions): Promise<void>
+    sendMessage(message: Message): Promise<boolean>
 }
 
-/**
+export interface Signaler {
- * Response from POST /answer
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>
- */
+    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable
-export interface AnswerResponse {
+    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable
-  success: boolean;
+    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable
-}
+    setOffer(offer: RTCSessionDescriptionInit): Promise<void>
-
+    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>
-/**
- * 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;
-  version: string;
-}
-
-/**
- * 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
-// ============================================================================
-
-/**
- * WebRTC polyfill for Node.js and other non-browser platforms
- */
-export interface WebRTCPolyfill {
-  RTCPeerConnection: typeof RTCPeerConnection;
-  RTCSessionDescription: typeof RTCSessionDescription;
-  RTCIceCandidate: typeof RTCIceCandidate;
-}
-
-/**
- * Configuration options for Rondevu WebRTC client
- */
-export interface RondevuOptions {
-  /** Base URL of the Rondevu server (defaults to 'https://api.ronde.vu') */
-  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;
-  /** WebRTC polyfill for Node.js (e.g., wrtc or @roamhq/wrtc) */
-  wrtc?: WebRTCPolyfill;
-}
-
-/**
- * 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;
-  wrtc?: WebRTCPolyfill;
-}
-
-/**
- * Event map for RondevuConnection events
- */
-export interface RondevuConnectionEvents {
-  connect: () => void;
-  disconnect: () => void;
-  error: (error: Error) => void;
-  datachannel: (channel: RTCDataChannel) => void;
-  stream: (stream: MediaStream) => void;
 }

src/webrtc-context.ts

@@ -0,0 +1,39 @@
+import { Signaler } from './types'
+
+const DEFAULT_RTC_CONFIGURATION: RTCConfiguration = {
+    iceServers: [
+        {
+            urls: 'stun:stun.relay.metered.ca:80',
+        },
+        {
+            urls: 'turn:standard.relay.metered.ca:80',
+            username: 'c53a9c971da5e6f3bc959d8d',
+            credential: 'QaccPqtPPaxyokXp',
+        },
+        {
+            urls: 'turn:standard.relay.metered.ca:80?transport=tcp',
+            username: 'c53a9c971da5e6f3bc959d8d',
+            credential: 'QaccPqtPPaxyokXp',
+        },
+        {
+            urls: 'turn:standard.relay.metered.ca:443',
+            username: 'c53a9c971da5e6f3bc959d8d',
+            credential: 'QaccPqtPPaxyokXp',
+        },
+        {
+            urls: 'turns:standard.relay.metered.ca:443?transport=tcp',
+            username: 'c53a9c971da5e6f3bc959d8d',
+            credential: 'QaccPqtPPaxyokXp',
+        },
+    ],
+}
+
+export class WebRTCContext {
+    constructor(
+        private readonly config?: RTCConfiguration
+    ) {}
+
+    createPeerConnection(): RTCPeerConnection {
+        return new RTCPeerConnection(this.config || DEFAULT_RTC_CONFIGURATION)
+    }
+}