Implement RPC request batching and throttling

Adds automatic request batching to reduce HTTP overhead by combining
multiple RPC calls into a single request.

Features:
- RpcBatcher class for intelligent request batching
- Configurable batch size (default: 10 requests)
- Configurable wait time (default: 50ms)
- Throttling to prevent overwhelming the server (default: 10ms)
- Automatic flushing when batch is full
- Enabled by default, can be disabled via options

Changes:
- Created rpc-batcher.ts with RpcBatcher class
- Updated RondevuAPI to use batcher by default
- Added batching option to RondevuOptions
- Updated README with batching documentation
- Bumped version to 0.16.0

Example usage:
  // Default (batching enabled with defaults)
  const rondevu = new Rondevu({ apiUrl: 'https://api.ronde.vu' })

  // Custom batching settings
  const rondevu = new Rondevu({
    apiUrl: 'https://api.ronde.vu',
    batching: { maxBatchSize: 20, maxWaitTime: 100 }
  })

  // Disable batching
  const rondevu = new Rondevu({
    apiUrl: 'https://api.ronde.vu',
    batching: false
  })

This can reduce HTTP requests by up to 90% during intensive operations
like ICE candidate exchange.

🤖 Generated with Claude Code
https://claude.com/claude-code

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

.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)

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.7.11",
+  "version": "0.16.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,13 +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": {
-    "@xtr-dev/rondevu-client": "^0.5.1"
+    "@noble/ed25519": "^3.0.0"
   }
 }

src/api.ts

@@ -0,0 +1,423 @@
+/**
+ * Rondevu API Client - RPC interface
+ */
+
+import { CryptoAdapter, Keypair } from './crypto-adapter.js'
+import { WebCryptoAdapter } from './web-crypto-adapter.js'
+import { RpcBatcher, BatcherOptions } from './rpc-batcher.js'
+
+export type { Keypair } from './crypto-adapter.js'
+export type { BatcherOptions } from './rpc-batcher.js'
+
+export interface OfferRequest {
+    sdp: string
+}
+
+export interface ServiceRequest {
+    serviceFqn: string // Must include username: service:version@username
+    offers: OfferRequest[]
+    ttl?: number
+    signature: string
+    message: string
+}
+
+export interface ServiceOffer {
+    offerId: string
+    sdp: string
+    createdAt: number
+    expiresAt: number
+}
+
+export interface Service {
+    serviceId: string
+    offers: ServiceOffer[]
+    username: string
+    serviceFqn: string
+    createdAt: number
+    expiresAt: number
+}
+
+export interface IceCandidate {
+    candidate: RTCIceCandidateInit
+    createdAt: number
+}
+
+/**
+ * RPC request format
+ */
+interface RpcRequest {
+    method: string
+    message: string
+    signature: string
+    publicKey?: string
+    params?: any
+}
+
+/**
+ * RPC response format
+ */
+interface RpcResponse {
+    success: boolean
+    result?: any
+    error?: string
+}
+
+/**
+ * RondevuAPI - RPC-based API client for Rondevu signaling server
+ */
+export class RondevuAPI {
+    private crypto: CryptoAdapter
+    private batcher: RpcBatcher | null = null
+
+    constructor(
+        private baseUrl: string,
+        private username: string,
+        private keypair: Keypair,
+        cryptoAdapter?: CryptoAdapter,
+        batcherOptions?: BatcherOptions | false
+    ) {
+        // Use WebCryptoAdapter by default (browser environment)
+        this.crypto = cryptoAdapter || new WebCryptoAdapter()
+
+        // Create batcher if not explicitly disabled
+        if (batcherOptions !== false) {
+            this.batcher = new RpcBatcher(
+                (requests) => this.rpcBatchDirect(requests),
+                batcherOptions
+            )
+        }
+    }
+
+    /**
+     * Generate authentication parameters for RPC calls
+     */
+    private async generateAuth(method: string, params: string = ''): Promise<{
+        message: string
+        signature: string
+    }> {
+        const timestamp = Date.now()
+        const message = params
+            ? `${method}:${this.username}:${params}:${timestamp}`
+            : `${method}:${this.username}:${timestamp}`
+
+        const signature = await this.crypto.signMessage(message, this.keypair.privateKey)
+
+        return { message, signature }
+    }
+
+    /**
+     * Execute RPC call with optional batching
+     */
+    private async rpc(request: RpcRequest): Promise<any> {
+        // Use batcher if enabled
+        if (this.batcher) {
+            return await this.batcher.add(request)
+        }
+
+        // Direct call without batching
+        return await this.rpcDirect(request)
+    }
+
+    /**
+     * Execute single RPC call directly (bypasses batcher)
+     */
+    private async rpcDirect(request: RpcRequest): Promise<any> {
+        const response = await fetch(`${this.baseUrl}/rpc`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+        })
+
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        }
+
+        const result: RpcResponse = await response.json()
+
+        if (!result.success) {
+            throw new Error(result.error || 'RPC call failed')
+        }
+
+        return result.result
+    }
+
+    /**
+     * Execute batch RPC calls directly (bypasses batcher)
+     */
+    private async rpcBatchDirect(requests: RpcRequest[]): Promise<any[]> {
+        const response = await fetch(`${this.baseUrl}/rpc`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requests),
+        })
+
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        }
+
+        const results: RpcResponse[] = await response.json()
+
+        return results.map((result, i) => {
+            if (!result.success) {
+                throw new Error(result.error || `RPC call ${i} failed`)
+            }
+            return result.result
+        })
+    }
+
+    // ============================================
+    // Ed25519 Cryptography Helpers
+    // ============================================
+
+    /**
+     * Generate an Ed25519 keypair for username claiming and service publishing
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
+     */
+    static async generateKeypair(cryptoAdapter?: CryptoAdapter): Promise<Keypair> {
+        const adapter = cryptoAdapter || new WebCryptoAdapter()
+        return await adapter.generateKeypair()
+    }
+
+    /**
+     * Sign a message with an Ed25519 private key
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
+     */
+    static async signMessage(
+        message: string,
+        privateKeyBase64: string,
+        cryptoAdapter?: CryptoAdapter
+    ): Promise<string> {
+        const adapter = cryptoAdapter || new WebCryptoAdapter()
+        return await adapter.signMessage(message, privateKeyBase64)
+    }
+
+    /**
+     * Verify an Ed25519 signature
+     * @param cryptoAdapter - Optional crypto adapter (defaults to WebCryptoAdapter)
+     */
+    static async verifySignature(
+        message: string,
+        signatureBase64: string,
+        publicKeyBase64: string,
+        cryptoAdapter?: CryptoAdapter
+    ): Promise<boolean> {
+        const adapter = cryptoAdapter || new WebCryptoAdapter()
+        return await adapter.verifySignature(message, signatureBase64, publicKeyBase64)
+    }
+
+    // ============================================
+    // Username Management
+    // ============================================
+
+    /**
+     * Check if a username is available
+     */
+    async isUsernameAvailable(username: string): Promise<boolean> {
+        const auth = await this.generateAuth('getUser', username)
+        const result = await this.rpc({
+            method: 'getUser',
+            message: auth.message,
+            signature: auth.signature,
+            params: { username },
+        })
+        return result.available
+    }
+
+    /**
+     * Claim a username
+     */
+    async claimUsername(username: string, publicKey: string): Promise<void> {
+        const auth = await this.generateAuth('claim', username)
+        await this.rpc({
+            method: 'claimUsername',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { username, publicKey },
+        })
+    }
+
+    /**
+     * Check if current username is claimed
+     */
+    async isUsernameClaimed(): Promise<boolean> {
+        const auth = await this.generateAuth('getUser', this.username)
+        const result = await this.rpc({
+            method: 'getUser',
+            message: auth.message,
+            signature: auth.signature,
+            params: { username: this.username },
+        })
+        return !result.available
+    }
+
+    // ============================================
+    // Service Management
+    // ============================================
+
+    /**
+     * Publish a service
+     */
+    async publishService(service: ServiceRequest): Promise<Service> {
+        const auth = await this.generateAuth('publishService', service.serviceFqn)
+        return await this.rpc({
+            method: 'publishService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: {
+                serviceFqn: service.serviceFqn,
+                offers: service.offers,
+                ttl: service.ttl,
+            },
+        })
+    }
+
+    /**
+     * Get service by FQN (direct lookup, random, or paginated)
+     */
+    async getService(
+        serviceFqn: string,
+        options?: { limit?: number; offset?: number }
+    ): Promise<any> {
+        const auth = await this.generateAuth('getService', serviceFqn)
+        return await this.rpc({
+            method: 'getService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: {
+                serviceFqn,
+                ...options,
+            },
+        })
+    }
+
+    /**
+     * Delete a service
+     */
+    async deleteService(serviceFqn: string): Promise<void> {
+        const auth = await this.generateAuth('deleteService', serviceFqn)
+        await this.rpc({
+            method: 'deleteService',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn },
+        })
+    }
+
+    // ============================================
+    // WebRTC Signaling
+    // ============================================
+
+    /**
+     * Answer an offer
+     */
+    async answerOffer(serviceFqn: string, offerId: string, sdp: string): Promise<void> {
+        const auth = await this.generateAuth('answerOffer', offerId)
+        await this.rpc({
+            method: 'answerOffer',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, sdp },
+        })
+    }
+
+    /**
+     * Get answer for a specific offer (offerer polls this)
+     */
+    async getOfferAnswer(
+        serviceFqn: string,
+        offerId: string
+    ): Promise<{ sdp: string; offerId: string; answererId: string; answeredAt: number } | null> {
+        try {
+            const auth = await this.generateAuth('getOfferAnswer', offerId)
+            return await this.rpc({
+                method: 'getOfferAnswer',
+                message: auth.message,
+                signature: auth.signature,
+                publicKey: this.keypair.publicKey,
+                params: { serviceFqn, offerId },
+            })
+        } catch (err) {
+            if ((err as Error).message.includes('not yet answered')) {
+                return null
+            }
+            throw err
+        }
+    }
+
+    /**
+     * Combined polling for answers and ICE candidates
+     */
+    async poll(since?: number): Promise<{
+        answers: Array<{
+            offerId: string
+            serviceId?: string
+            answererId: string
+            sdp: string
+            answeredAt: number
+        }>
+        iceCandidates: Record<
+            string,
+            Array<{
+                candidate: any
+                role: 'offerer' | 'answerer'
+                peerId: string
+                createdAt: number
+            }>
+        >
+    }> {
+        const auth = await this.generateAuth('poll')
+        return await this.rpc({
+            method: 'poll',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { since },
+        })
+    }
+
+    /**
+     * Add ICE candidates to a specific offer
+     */
+    async addOfferIceCandidates(
+        serviceFqn: string,
+        offerId: string,
+        candidates: RTCIceCandidateInit[]
+    ): Promise<{ count: number; offerId: string }> {
+        const auth = await this.generateAuth('addIceCandidates', offerId)
+        return await this.rpc({
+            method: 'addIceCandidates',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, candidates },
+        })
+    }
+
+    /**
+     * Get ICE candidates for a specific offer
+     */
+    async getOfferIceCandidates(
+        serviceFqn: string,
+        offerId: string,
+        since: number = 0
+    ): Promise<{ candidates: IceCandidate[]; offerId: string }> {
+        const auth = await this.generateAuth('getIceCandidates', `${offerId}:${since}`)
+        const result = await this.rpc({
+            method: 'getIceCandidates',
+            message: auth.message,
+            signature: auth.signature,
+            publicKey: this.keypair.publicKey,
+            params: { serviceFqn, offerId, since },
+        })
+
+        return {
+            candidates: result.candidates || [],
+            offerId: result.offerId,
+        }
+    }
+}

src/auth.ts

@@ -1,67 +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
-   * @param customPeerId - Optional custom peer ID (1-128 characters). If not provided, a random ID will be generated.
-   * @throws Error if registration fails (e.g., peer ID already in use)
-   */
-  async register(customPeerId?: string): Promise<Credentials> {
-    const body: { peerId?: string } = {};
-    if (customPeerId !== undefined) {
-      body.peerId = customPeerId;
-    }
-
-    const response = await this.fetchFn(`${this.baseUrl}/register`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify(body),
-    });
-
-    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/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/crypto-adapter.ts

@@ -0,0 +1,48 @@
+/**
+ * Crypto adapter interface for platform-independent cryptographic operations
+ */
+
+export interface Keypair {
+    publicKey: string
+    privateKey: string
+}
+
+/**
+ * Platform-independent crypto adapter interface
+ * Implementations provide platform-specific crypto operations
+ */
+export interface CryptoAdapter {
+    /**
+     * Generate an Ed25519 keypair
+     */
+    generateKeypair(): Promise<Keypair>
+
+    /**
+     * Sign a message with an Ed25519 private key
+     */
+    signMessage(message: string, privateKeyBase64: string): Promise<string>
+
+    /**
+     * Verify an Ed25519 signature
+     */
+    verifySignature(
+        message: string,
+        signatureBase64: string,
+        publicKeyBase64: string
+    ): Promise<boolean>
+
+    /**
+     * Convert Uint8Array to base64 string
+     */
+    bytesToBase64(bytes: Uint8Array): string
+
+    /**
+     * Convert base64 string to Uint8Array
+     */
+    base64ToBytes(base64: string): Uint8Array
+
+    /**
+     * Generate random bytes
+     */
+    randomBytes(length: number): Uint8Array
+}

src/event-emitter.ts

@@ -1,109 +0,0 @@
-/**
- * Type-safe EventEmitter implementation for browser and Node.js compatibility
- *
- * @template EventMap - A type mapping event names to their handler signatures
- *
- * @example
- * ```typescript
- * interface MyEvents {
- *   'data': (value: string) => void;
- *   'error': (error: Error) => void;
- *   'ready': () => void;
- * }
- *
- * class MyClass extends EventEmitter<MyEvents> {
- *   doSomething() {
- *     this.emit('data', 'hello'); // Type-safe!
- *     this.emit('error', new Error('oops')); // Type-safe!
- *     this.emit('ready'); // Type-safe!
- *   }
- * }
- *
- * const instance = new MyClass();
- * instance.on('data', (value) => {
- *   console.log(value.toUpperCase()); // 'value' is typed as string
- * });
- * ```
- */
-export class EventEmitter<EventMap extends Record<string, (...args: any[]) => void>> {
-  private events: Map<keyof EventMap, Set<Function>> = new Map();
-
-  /**
-   * Register an event listener
-   */
-  on<K extends keyof EventMap>(event: K, listener: EventMap[K]): 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<K extends keyof EventMap>(event: K, listener: EventMap[K]): this {
-    const onceWrapper = (...args: Parameters<EventMap[K]>) => {
-      this.off(event, onceWrapper as EventMap[K]);
-      listener(...args);
-    };
-    return this.on(event, onceWrapper as EventMap[K]);
-  }
-
-  /**
-   * Remove an event listener
-   */
-  off<K extends keyof EventMap>(event: K, listener: EventMap[K]): 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
-   */
-  protected emit<K extends keyof EventMap>(
-    event: K,
-    ...args: Parameters<EventMap[K]>
-  ): boolean {
-    const listeners = this.events.get(event);
-    if (!listeners || listeners.size === 0) {
-      return false;
-    }
-
-    listeners.forEach(listener => {
-      try {
-        (listener as EventMap[K])(...args);
-      } catch (err) {
-        console.error(`Error in ${String(event)} event listener:`, err);
-      }
-    });
-
-    return true;
-  }
-
-  /**
-   * Remove all listeners for an event (or all events if not specified)
-   */
-  removeAllListeners<K extends keyof EventMap>(event?: K): this {
-    if (event !== undefined) {
-      this.events.delete(event);
-    } else {
-      this.events.clear();
-    }
-    return this;
-  }
-
-  /**
-   * Get listener count for an event
-   */
-  listenerCount<K extends keyof EventMap>(event: K): number {
-    const listeners = this.events.get(event);
-    return listeners ? listeners.size : 0;
-  }
-}

src/index.ts

@@ -1,32 +1,35 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with topic-based discovery
+ * WebRTC peer signaling client
  */
 
-// Export main client class
+export { Rondevu } from './rondevu.js'
-export { Rondevu } from './rondevu.js';
+export { RondevuAPI } from './api.js'
-export type { RondevuOptions } from './rondevu.js';
+export { RondevuSignaler } from './rondevu-signaler.js'
+export { RpcBatcher } from './rpc-batcher.js'
 
-// Export authentication
+// Export crypto adapters
-export { RondevuAuth } from './auth.js';
+export { WebCryptoAdapter } from './web-crypto-adapter.js'
-export type { Credentials, FetchFunction } from './auth.js';
+export { NodeCryptoAdapter } from './node-crypto-adapter.js'
 
-// Export offers API
+// Export types
-export { RondevuOffers } from './offers.js';
 export type {
-  CreateOfferRequest,
+    Signaler,
-  Offer,
+    Binnable,
+} from './types.js'
+
+export type {
+    Keypair,
+    OfferRequest,
+    ServiceRequest,
+    Service,
+    ServiceOffer,
     IceCandidate,
-  TopicInfo
+} from './api.js'
-} from './offers.js';
 
-// Export bloom filter
+export type { RondevuOptions, PublishServiceOptions } from './rondevu.js'
-export { BloomFilter } from './bloom.js';
+
+export type { PollingConfig } from './rondevu-signaler.js'
+
+export type { CryptoAdapter } from './crypto-adapter.js'
 
-// Export peer manager
-export { default as RondevuPeer } from './peer/index.js';
-export type {
-  PeerOptions,
-  PeerEvents,
-  PeerTimeouts
-} from './peer/index.js';

src/node-crypto-adapter.ts

@@ -0,0 +1,98 @@
+/**
+ * Node.js Crypto adapter for Node.js environments
+ * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
+ */
+
+import * as ed25519 from '@noble/ed25519'
+import { CryptoAdapter, Keypair } from './crypto-adapter.js'
+
+/**
+ * Node.js Crypto implementation using Node.js built-in APIs
+ * Uses Buffer for base64 encoding and crypto.randomBytes for random generation
+ *
+ * Requirements:
+ * - Node.js 19+ (crypto.subtle available globally)
+ * - OR Node.js 18 with --experimental-global-webcrypto flag
+ *
+ * @example
+ * ```typescript
+ * import { RondevuAPI } from '@xtr-dev/rondevu-client'
+ * import { NodeCryptoAdapter } from '@xtr-dev/rondevu-client/node'
+ *
+ * const api = new RondevuAPI(
+ *   'https://signal.example.com',
+ *   'alice',
+ *   keypair,
+ *   new NodeCryptoAdapter()
+ * )
+ * ```
+ */
+export class NodeCryptoAdapter implements CryptoAdapter {
+    constructor() {
+        // Set SHA-512 hash function for ed25519 using Node's crypto.subtle
+        if (typeof crypto === 'undefined' || !crypto.subtle) {
+            throw new Error(
+                'crypto.subtle is not available. ' +
+                'Node.js 19+ is required, or Node.js 18 with --experimental-global-webcrypto flag'
+            )
+        }
+
+        ed25519.hashes.sha512Async = async (message: Uint8Array) => {
+            const hash = await crypto.subtle.digest('SHA-512', message as BufferSource)
+            return new Uint8Array(hash)
+        }
+    }
+
+    async generateKeypair(): Promise<Keypair> {
+        const privateKey = ed25519.utils.randomSecretKey()
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey)
+
+        return {
+            publicKey: this.bytesToBase64(publicKey),
+            privateKey: this.bytesToBase64(privateKey),
+        }
+    }
+
+    async signMessage(message: string, privateKeyBase64: string): Promise<string> {
+        const privateKey = this.base64ToBytes(privateKeyBase64)
+        const encoder = new TextEncoder()
+        const messageBytes = encoder.encode(message)
+        const signature = await ed25519.signAsync(messageBytes, privateKey)
+
+        return this.bytesToBase64(signature)
+    }
+
+    async verifySignature(
+        message: string,
+        signatureBase64: string,
+        publicKeyBase64: string
+    ): Promise<boolean> {
+        try {
+            const signature = this.base64ToBytes(signatureBase64)
+            const publicKey = this.base64ToBytes(publicKeyBase64)
+            const encoder = new TextEncoder()
+            const messageBytes = encoder.encode(message)
+
+            return await ed25519.verifyAsync(signature, messageBytes, publicKey)
+        } catch {
+            return false
+        }
+    }
+
+    bytesToBase64(bytes: Uint8Array): string {
+        // Node.js Buffer provides native base64 encoding
+        // @ts-expect-error - Buffer is available in Node.js but not in browser TypeScript definitions
+        return Buffer.from(bytes).toString('base64')
+    }
+
+    base64ToBytes(base64: string): Uint8Array {
+        // Node.js Buffer provides native base64 decoding
+        // @ts-expect-error - Buffer is available in Node.js but not in browser TypeScript definitions
+        return new Uint8Array(Buffer.from(base64, 'base64'))
+    }
+
+    randomBytes(length: number): Uint8Array {
+        // Use Web Crypto API's getRandomValues (available in Node 19+)
+        return crypto.getRandomValues(new Uint8Array(length))
+    }
+}

src/offers.ts

@@ -1,321 +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 {
-  sdp: string;
-  topics: string[];
-  ttl?: number;
-  secret?: string;
-  info?: string;
-}
-
-export interface Offer {
-  id: string;
-  peerId: string;
-  sdp: string;
-  topics: string[];
-  createdAt?: number;
-  expiresAt: number;
-  lastSeen: number;
-  secret?: string;
-  hasSecret?: boolean;
-  info?: string;
-  answererPeerId?: string;
-  answerSdp?: string;
-  answeredAt?: number;
-}
-
-export interface IceCandidate {
-  candidate: any; // Full candidate object as plain JSON - don't enforce structure
-  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;
-    startsWith?: string;
-  }): Promise<{
-    topics: TopicInfo[];
-    total: number;
-    limit: number;
-    offset: number;
-    startsWith?: string;
-  }> {
-    const params = new URLSearchParams();
-
-    if (options?.limit) {
-      params.set('limit', options.limit.toString());
-    }
-
-    if (options?.offset) {
-      params.set('offset', options.offset.toString());
-    }
-
-    if (options?.startsWith) {
-      params.set('startsWith', options.startsWith);
-    }
-
-    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;
-  }
-
-  /**
-   * 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, secret?: 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, secret }),
-    });
-
-    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: any[]
-  ): 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/peer/answering-state.ts

@@ -1,49 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-
-/**
- * Answering an offer and sending to server
- */
-export class AnsweringState extends PeerState {
-  constructor(peer: RondevuPeer) {
-    super(peer);
-  }
-
-  get name() { return 'answering'; }
-
-  async answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void> {
-    try {
-      this.peer.role = 'answerer';
-      this.peer.offerId = offerId;
-
-      // Set remote description
-      await this.peer.pc.setRemoteDescription({
-        type: 'offer',
-        sdp: offerSdp
-      });
-
-      // Create answer
-      const answer = await this.peer.pc.createAnswer();
-
-      // Send answer to server BEFORE setLocalDescription
-      // This registers us as the answerer so ICE candidates will be accepted
-      await this.peer.offersApi.answer(offerId, answer.sdp!, options.secret);
-
-      // Enable trickle ICE - set up handler before ICE gathering starts
-      this.setupIceCandidateHandler();
-
-      // Set local description - ICE gathering starts here
-      // Server already knows we're the answerer, so candidates will be accepted
-      await this.peer.pc.setLocalDescription(answer);
-
-      // Transition to exchanging ICE
-      const { ExchangingIceState } = await import('./exchanging-ice-state.js');
-      this.peer.setState(new ExchangingIceState(this.peer, offerId, options));
-    } catch (error) {
-      const { FailedState } = await import('./failed-state.js');
-      this.peer.setState(new FailedState(this.peer, error as Error));
-      throw error;
-    }
-  }
-}

src/peer/closed-state.ts

@@ -1,12 +0,0 @@
-import { PeerState } from './state.js';
-
-/**
- * Closed state - connection has been terminated
- */
-export class ClosedState extends PeerState {
-  get name() { return 'closed'; }
-
-  cleanup(): void {
-    this.peer.pc.close();
-  }
-}

src/peer/connected-state.ts

@@ -1,13 +0,0 @@
-import { PeerState } from './state.js';
-
-/**
- * Connected state - peer connection is established
- */
-export class ConnectedState extends PeerState {
-  get name() { return 'connected'; }
-
-  cleanup(): void {
-    // Keep connection alive, but stop any polling
-    // The peer connection will handle disconnects via onconnectionstatechange
-  }
-}

src/peer/creating-offer-state.ts

@@ -1,57 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-
-/**
- * Creating offer and sending to server
- */
-export class CreatingOfferState extends PeerState {
-  constructor(peer: RondevuPeer, private options: PeerOptions) {
-    super(peer);
-  }
-
-  get name() { return 'creating-offer'; }
-
-  async createOffer(options: PeerOptions): Promise<string> {
-    try {
-      this.peer.role = 'offerer';
-
-      // Create data channel if requested
-      if (options.createDataChannel !== false) {
-        const channel = this.peer.pc.createDataChannel(
-          options.dataChannelLabel || 'data'
-        );
-        this.peer.emitEvent('datachannel', channel);
-      }
-
-      // Enable trickle ICE - set up handler before ICE gathering starts
-      // Handler will check this.peer.offerId before sending
-      this.setupIceCandidateHandler();
-
-      // Create WebRTC offer
-      const offer = await this.peer.pc.createOffer();
-      await this.peer.pc.setLocalDescription(offer); // ICE gathering starts here
-
-      // Send offer to server immediately (don't wait for ICE)
-      const offers = await this.peer.offersApi.create([{
-        sdp: offer.sdp!,
-        topics: options.topics,
-        ttl: options.ttl || 300000,
-        secret: options.secret
-      }]);
-
-      const offerId = offers[0].id;
-      this.peer.offerId = offerId; // Now handler can send candidates
-
-      // Transition to waiting for answer
-      const { WaitingForAnswerState } = await import('./waiting-for-answer-state.js');
-      this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));
-
-      return offerId;
-    } catch (error) {
-      const { FailedState } = await import('./failed-state.js');
-      this.peer.setState(new FailedState(this.peer, error as Error));
-      throw error;
-    }
-  }
-}

src/peer/exchanging-ice-state.ts

@@ -1,74 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-
-/**
- * Exchanging ICE candidates and waiting for connection
- */
-export class ExchangingIceState extends PeerState {
-  private pollingInterval?: ReturnType<typeof setInterval>;
-  private timeout?: ReturnType<typeof setTimeout>;
-  private lastIceTimestamp = 0;
-
-  constructor(
-    peer: RondevuPeer,
-    private offerId: string,
-    private options: PeerOptions
-  ) {
-    super(peer);
-    this.startPolling();
-  }
-
-  get name() { return 'exchanging-ice'; }
-
-  private startPolling(): void {
-    const connectionTimeout = this.options.timeouts?.iceConnection || 30000;
-
-    this.timeout = setTimeout(async () => {
-      this.cleanup();
-      const { FailedState } = await import('./failed-state.js');
-      this.peer.setState(new FailedState(
-        this.peer,
-        new Error('ICE connection timeout')
-      ));
-    }, connectionTimeout);
-
-    this.pollingInterval = setInterval(async () => {
-      try {
-        const candidates = await this.peer.offersApi.getIceCandidates(
-          this.offerId,
-          this.lastIceTimestamp
-        );
-
-        for (const cand of candidates) {
-          if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
-            try {
-              await this.peer.pc.addIceCandidate(new this.peer.RTCIceCandidate(cand.candidate));
-              this.lastIceTimestamp = cand.createdAt;
-            } catch (err) {
-              console.warn('Failed to add ICE candidate:', err);
-              this.lastIceTimestamp = cand.createdAt;
-            }
-          } else {
-            this.lastIceTimestamp = cand.createdAt;
-          }
-        }
-      } catch (err) {
-        console.error('Error polling for ICE candidates:', err);
-        if (err instanceof Error && err.message.includes('not found')) {
-          this.cleanup();
-          const { FailedState } = await import('./failed-state.js');
-          this.peer.setState(new FailedState(
-            this.peer,
-            new Error('Offer expired or not found')
-          ));
-        }
-      }
-    }, 1000);
-  }
-
-  cleanup(): void {
-    if (this.pollingInterval) clearInterval(this.pollingInterval);
-    if (this.timeout) clearTimeout(this.timeout);
-  }
-}

src/peer/failed-state.ts

@@ -1,18 +0,0 @@
-import { PeerState } from './state.js';
-
-/**
- * Failed state - connection attempt failed
- */
-export class FailedState extends PeerState {
-  constructor(peer: any, private error: Error) {
-    super(peer);
-    peer.emitEvent('failed', error);
-  }
-
-  get name() { return 'failed'; }
-
-  cleanup(): void {
-    // Connection is failed, clean up resources
-    this.peer.pc.close();
-  }
-}

src/peer/idle-state.ts

@@ -1,18 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-
-export class IdleState extends PeerState {
-  get name() { return 'idle'; }
-
-  async createOffer(options: PeerOptions): Promise<string> {
-    const { CreatingOfferState } = await import('./creating-offer-state.js');
-    this.peer.setState(new CreatingOfferState(this.peer, options));
-    return this.peer.state.createOffer(options);
-  }
-
-  async answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void> {
-    const { AnsweringState } = await import('./answering-state.js');
-    this.peer.setState(new AnsweringState(this.peer));
-    return this.peer.state.answer(offerId, offerSdp, options);
-  }
-}

src/peer/index.ts

@@ -1,212 +0,0 @@
-import { RondevuOffers } from '../offers.js';
-import { EventEmitter } from '../event-emitter.js';
-import type { PeerOptions, PeerEvents } from './types.js';
-import { PeerState } from './state.js';
-import { IdleState } from './idle-state.js';
-import { CreatingOfferState } from './creating-offer-state.js';
-import { WaitingForAnswerState } from './waiting-for-answer-state.js';
-import { AnsweringState } from './answering-state.js';
-import { ExchangingIceState } from './exchanging-ice-state.js';
-import { ConnectedState } from './connected-state.js';
-import { FailedState } from './failed-state.js';
-import { ClosedState } from './closed-state.js';
-
-// Re-export types for external consumers
-export type { PeerTimeouts, PeerOptions, PeerEvents } from './types.js';
-
-/**
- * High-level WebRTC peer connection manager with state-based lifecycle
- * Handles offer/answer exchange, ICE candidates, timeouts, and error recovery
- */
-export default class RondevuPeer extends EventEmitter<PeerEvents> {
-  pc: RTCPeerConnection;
-  offersApi: RondevuOffers;
-  offerId?: string;
-  role?: 'offerer' | 'answerer';
-
-  // WebRTC polyfills for Node.js compatibility
-  RTCPeerConnection: typeof RTCPeerConnection;
-  RTCSessionDescription: typeof RTCSessionDescription;
-  RTCIceCandidate: typeof RTCIceCandidate;
-
-  private _state: PeerState;
-
-  // Event handler references for cleanup
-  private connectionStateChangeHandler?: () => void;
-  private dataChannelHandler?: (event: RTCDataChannelEvent) => void;
-  private trackHandler?: (event: RTCTrackEvent) => void;
-  private iceCandidateErrorHandler?: (event: Event) => void;
-
-  /**
-   * Current connection state name
-   */
-  get stateName(): string {
-    return this._state.name;
-  }
-
-  /**
-   * Current state object (internal use)
-   */
-  get state(): PeerState {
-    return this._state;
-  }
-
-  /**
-   * RTCPeerConnection state
-   */
-  get connectionState(): RTCPeerConnectionState {
-    return this.pc.connectionState;
-  }
-
-  constructor(
-    offersApi: RondevuOffers,
-    rtcConfig: RTCConfiguration = {
-      iceServers: [
-        { urls: 'stun:stun.l.google.com:19302' },
-        { urls: 'stun:stun1.l.google.com:19302' }
-      ]
-    },
-    rtcPeerConnection?: typeof RTCPeerConnection,
-    rtcSessionDescription?: typeof RTCSessionDescription,
-    rtcIceCandidate?: typeof RTCIceCandidate
-  ) {
-    super();
-    this.offersApi = offersApi;
-
-    // Use provided polyfills or fall back to globals
-    this.RTCPeerConnection = rtcPeerConnection || (typeof globalThis.RTCPeerConnection !== 'undefined'
-      ? globalThis.RTCPeerConnection
-      : (() => {
-          throw new Error('RTCPeerConnection is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-        }) as any);
-
-    this.RTCSessionDescription = rtcSessionDescription || (typeof globalThis.RTCSessionDescription !== 'undefined'
-      ? globalThis.RTCSessionDescription
-      : (() => {
-          throw new Error('RTCSessionDescription is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-        }) as any);
-
-    this.RTCIceCandidate = rtcIceCandidate || (typeof globalThis.RTCIceCandidate !== 'undefined'
-      ? globalThis.RTCIceCandidate
-      : (() => {
-          throw new Error('RTCIceCandidate is not available. Please provide it in the Rondevu constructor options for Node.js environments.');
-        }) as any);
-
-    this.pc = new this.RTCPeerConnection(rtcConfig);
-    this._state = new IdleState(this);
-
-    this.setupPeerConnection();
-  }
-
-  /**
-   * Set up peer connection event handlers
-   */
-  private setupPeerConnection(): void {
-    this.connectionStateChangeHandler = () => {
-      switch (this.pc.connectionState) {
-        case 'connected':
-          this.setState(new ConnectedState(this));
-          this.emitEvent('connected');
-          break;
-        case 'disconnected':
-          this.emitEvent('disconnected');
-          break;
-        case 'failed':
-          this.setState(new FailedState(this, new Error('Connection failed')));
-          break;
-        case 'closed':
-          this.setState(new ClosedState(this));
-          this.emitEvent('disconnected');
-          break;
-      }
-    };
-    this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
-
-    this.dataChannelHandler = (event: RTCDataChannelEvent) => {
-      this.emitEvent('datachannel', event.channel);
-    };
-    this.pc.addEventListener('datachannel', this.dataChannelHandler);
-
-    this.trackHandler = (event: RTCTrackEvent) => {
-      this.emitEvent('track', event);
-    };
-    this.pc.addEventListener('track', this.trackHandler);
-
-    this.iceCandidateErrorHandler = (event: Event) => {
-      console.error('ICE candidate error:', event);
-    };
-    this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
-  }
-
-  /**
-   * Set new state and emit state change event
-   */
-  setState(newState: PeerState): void {
-    this._state.cleanup();
-    this._state = newState;
-    this.emitEvent('state', newState.name);
-  }
-
-  /**
-   * Emit event (exposed for PeerState classes)
-   * @internal
-   */
-  emitEvent<K extends keyof PeerEvents>(
-    event: K,
-    ...args: Parameters<PeerEvents[K]>
-  ): void {
-    this.emit(event, ...args);
-  }
-
-  /**
-   * Create an offer and advertise on topics
-   */
-  async createOffer(options: PeerOptions): Promise<string> {
-    return this._state.createOffer(options);
-  }
-
-  /**
-   * Answer an existing offer
-   */
-  async answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void> {
-    return this._state.answer(offerId, offerSdp, options);
-  }
-
-  /**
-   * Add a media track to the connection
-   */
-  addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): RTCRtpSender {
-    return this.pc.addTrack(track, ...streams);
-  }
-
-  /**
-   * Create a data channel for sending and receiving arbitrary data
-   * This should typically be called by the offerer before creating the offer
-   * The answerer will receive the channel via the 'datachannel' event
-   */
-  createDataChannel(label: string, options?: RTCDataChannelInit): RTCDataChannel {
-    return this.pc.createDataChannel(label, options);
-  }
-
-  /**
-   * Close the connection and clean up
-   */
-  async close(): Promise<void> {
-    // Remove RTCPeerConnection event listeners
-    if (this.connectionStateChangeHandler) {
-      this.pc.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
-    }
-    if (this.dataChannelHandler) {
-      this.pc.removeEventListener('datachannel', this.dataChannelHandler);
-    }
-    if (this.trackHandler) {
-      this.pc.removeEventListener('track', this.trackHandler);
-    }
-    if (this.iceCandidateErrorHandler) {
-      this.pc.removeEventListener('icecandidateerror', this.iceCandidateErrorHandler);
-    }
-
-    await this._state.close();
-    this.removeAllListeners();
-  }
-}

src/peer/state.ts

@@ -1,66 +0,0 @@
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-
-/**
- * Base class for peer connection states
- * Implements the State pattern for managing WebRTC connection lifecycle
- */
-export abstract class PeerState {
-  protected iceCandidateHandler?: (event: RTCPeerConnectionIceEvent) => void;
-
-  constructor(protected peer: RondevuPeer) {}
-
-  abstract get name(): string;
-
-  async createOffer(options: PeerOptions): Promise<string> {
-    throw new Error(`Cannot create offer in ${this.name} state`);
-  }
-
-  async answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void> {
-    throw new Error(`Cannot answer in ${this.name} state`);
-  }
-
-  async handleAnswer(sdp: string): Promise<void> {
-    throw new Error(`Cannot handle answer in ${this.name} state`);
-  }
-
-  async handleIceCandidate(candidate: any): Promise<void> {
-    // ICE candidates can arrive in multiple states, so default is to add them
-    if (this.peer.pc.remoteDescription) {
-      await this.peer.pc.addIceCandidate(new this.peer.RTCIceCandidate(candidate));
-    }
-  }
-
-  /**
-   * Setup trickle ICE candidate handler
-   * Sends local ICE candidates to server as they are discovered
-   */
-  protected setupIceCandidateHandler(): void {
-    this.iceCandidateHandler = async (event: RTCPeerConnectionIceEvent) => {
-      if (event.candidate && this.peer.offerId) {
-        const candidateData = event.candidate.toJSON();
-        if (candidateData.candidate && candidateData.candidate !== '') {
-          try {
-            await this.peer.offersApi.addIceCandidates(this.peer.offerId, [candidateData]);
-          } catch (err) {
-            console.error('Error sending ICE candidate:', err);
-          }
-        }
-      }
-    };
-    this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
-  }
-
-  cleanup(): void {
-    // Clean up ICE candidate handler if it exists
-    if (this.iceCandidateHandler) {
-      this.peer.pc.removeEventListener('icecandidate', this.iceCandidateHandler);
-    }
-  }
-
-  async close(): Promise<void> {
-    this.cleanup();
-    const { ClosedState } = await import('./closed-state.js');
-    this.peer.setState(new ClosedState(this.peer));
-  }
-}

src/peer/types.ts

@@ -1,45 +0,0 @@
-/**
- * Timeout configurations for different connection phases
- */
-export interface PeerTimeouts {
-  /** Timeout for ICE gathering (default: 10000ms) */
-  iceGathering?: number;
-  /** Timeout for waiting for answer (default: 30000ms) */
-  waitingForAnswer?: number;
-  /** Timeout for creating answer (default: 10000ms) */
-  creatingAnswer?: number;
-  /** Timeout for ICE connection (default: 30000ms) */
-  iceConnection?: number;
-}
-
-/**
- * Options for creating a peer connection
- */
-export interface PeerOptions {
-  /** RTCConfiguration for the peer connection */
-  rtcConfig?: RTCConfiguration;
-  /** Topics to advertise this connection under */
-  topics: string[];
-  /** How long the offer should live (milliseconds) */
-  ttl?: number;
-  /** Optional secret to protect the offer (max 128 characters) */
-  secret?: string;
-  /** Whether to create a data channel automatically (for offerer) */
-  createDataChannel?: boolean;
-  /** Label for the automatically created data channel */
-  dataChannelLabel?: string;
-  /** Timeout configurations */
-  timeouts?: PeerTimeouts;
-}
-
-/**
- * Events emitted by RondevuPeer
- */
-export interface PeerEvents extends Record<string, (...args: any[]) => void> {
-  'state': (state: string) => void;
-  'connected': () => void;
-  'disconnected': () => void;
-  'failed': (error: Error) => void;
-  'datachannel': (channel: RTCDataChannel) => void;
-  'track': (event: RTCTrackEvent) => void;
-}

src/peer/waiting-for-answer-state.ts

@@ -1,78 +0,0 @@
-import { PeerState } from './state.js';
-import type { PeerOptions } from './types.js';
-import type RondevuPeer from './index.js';
-
-/**
- * Waiting for answer from another peer
- */
-export class WaitingForAnswerState extends PeerState {
-  private pollingInterval?: ReturnType<typeof setInterval>;
-  private timeout?: ReturnType<typeof setTimeout>;
-
-  constructor(
-    peer: RondevuPeer,
-    private offerId: string,
-    private options: PeerOptions
-  ) {
-    super(peer);
-    this.startPolling();
-  }
-
-  get name() { return 'waiting-for-answer'; }
-
-  private startPolling(): void {
-    const answerTimeout = this.options.timeouts?.waitingForAnswer || 30000;
-
-    this.timeout = setTimeout(async () => {
-      this.cleanup();
-      const { FailedState } = await import('./failed-state.js');
-      this.peer.setState(new FailedState(
-        this.peer,
-        new Error('Timeout waiting for answer')
-      ));
-    }, answerTimeout);
-
-    this.pollingInterval = setInterval(async () => {
-      try {
-        const answers = await this.peer.offersApi.getAnswers();
-        const myAnswer = answers.find((a: any) => a.offerId === this.offerId);
-
-        if (myAnswer) {
-          this.cleanup();
-          await this.handleAnswer(myAnswer.sdp);
-        }
-      } catch (err) {
-        console.error('Error polling for answers:', err);
-        if (err instanceof Error && err.message.includes('not found')) {
-          this.cleanup();
-          const { FailedState } = await import('./failed-state.js');
-          this.peer.setState(new FailedState(
-            this.peer,
-            new Error('Offer expired or not found')
-          ));
-        }
-      }
-    }, 2000);
-  }
-
-  async handleAnswer(sdp: string): Promise<void> {
-    try {
-      await this.peer.pc.setRemoteDescription({
-        type: 'answer',
-        sdp
-      });
-
-      // Transition to exchanging ICE
-      const { ExchangingIceState } = await import('./exchanging-ice-state.js');
-      this.peer.setState(new ExchangingIceState(this.peer, this.offerId, this.options));
-    } catch (error) {
-      const { FailedState } = await import('./failed-state.js');
-      this.peer.setState(new FailedState(this.peer, error as Error));
-    }
-  }
-
-  cleanup(): void {
-    if (this.pollingInterval) clearInterval(this.pollingInterval);
-    if (this.timeout) clearTimeout(this.timeout);
-  }
-}

src/rondevu-signaler.ts

@@ -0,0 +1,478 @@
+import { Signaler, Binnable } from './types.js'
+import { Rondevu } from './rondevu.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 serviceFqn: string | null = null
+    private offerListeners: Array<(offer: RTCSessionDescriptionInit) => void> = []
+    private answerListeners: Array<(answer: RTCSessionDescriptionInit) => void> = []
+    private iceListeners: Array<(candidate: RTCIceCandidate) => void> = []
+    private pollingTimeout: ReturnType<typeof setTimeout> | null = null
+    private icePollingTimeout: ReturnType<typeof setTimeout> | null = null
+    private lastPollTimestamp = 0
+    private isPolling = false
+    private isOfferer = false
+    private pollingConfig: Required<PollingConfig>
+
+    constructor(
+        private readonly rondevu: Rondevu,
+        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
+        })
+
+        // 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.serviceFqn = publishedService.serviceFqn
+        this.isOfferer = true
+
+        // Start combined polling for answers and ICE candidates
+        this.startPolling()
+    }
+
+    /**
+     * 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.serviceFqn || !this.offerId) {
+            throw new Error('No service FQN or offer ID available. Must receive offer first.')
+        }
+
+        // Send answer to the service
+        await this.rondevu.getAPIPublic().answerOffer(this.serviceFqn, this.offerId, answer.sdp)
+        this.isOfferer = false
+
+        // Start polling for ICE candidates (answerer uses separate endpoint)
+        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.serviceFqn || !this.offerId) {
+            console.warn('Cannot send ICE candidate: no service FQN or offer ID')
+            return
+        }
+
+        const candidateData = candidate.toJSON()
+
+        // Skip empty candidates
+        if (!candidateData.candidate || candidateData.candidate === '') {
+            return
+        }
+
+        try {
+            await this.rondevu.getAPIPublic().addOfferIceCandidates(
+                this.serviceFqn,
+                this.offerId,
+                [candidateData]
+            )
+        } 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 {
+            // Get service by FQN (service should include @username)
+            const serviceFqn = `${this.service}@${this.host}`
+            const serviceData = await this.rondevu.getAPIPublic().getService(serviceFqn)
+
+            if (!serviceData) {
+                console.warn(`No service found for ${serviceFqn}`)
+                this.isPolling = false
+                return
+            }
+
+            // Store service details
+            this.offerId = serviceData.offerId
+            this.serviceFqn = serviceData.serviceFqn
+
+            // Notify offer listeners
+            const offer: RTCSessionDescriptionInit = {
+                type: 'offer',
+                sdp: serviceData.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 combined polling for answers and ICE candidates (offerer side)
+     * Uses poll() for efficient batch polling
+     */
+    private startPolling(): void {
+        if (this.pollingTimeout || !this.isOfferer) {
+            return
+        }
+
+        let interval = this.pollingConfig.initialInterval
+        let retries = 0
+        let answerReceived = false
+
+        const poll = async () => {
+            try {
+                const result = await this.rondevu.poll(this.lastPollTimestamp)
+
+                let foundActivity = false
+
+                // Process answers
+                if (result.answers.length > 0 && !answerReceived) {
+                    foundActivity = true
+
+                    // Find answer for our offerId
+                    const answer = result.answers.find(a => a.offerId === this.offerId)
+
+                    if (answer && answer.sdp) {
+                        answerReceived = true
+
+                        const answerDesc: RTCSessionDescriptionInit = {
+                            type: 'answer',
+                            sdp: answer.sdp,
+                        }
+
+                        this.answerListeners.forEach(listener => {
+                            try {
+                                listener(answerDesc)
+                            } catch (err) {
+                                console.error('Answer listener error:', err)
+                            }
+                        })
+
+                        this.lastPollTimestamp = Math.max(this.lastPollTimestamp, answer.answeredAt)
+                    }
+                }
+
+                // Process ICE candidates for our offer
+                if (this.offerId && result.iceCandidates[this.offerId]) {
+                    const candidates = result.iceCandidates[this.offerId]
+
+                    // Filter for answerer candidates (offerer receives answerer's candidates)
+                    const answererCandidates = candidates.filter(c => c.role === 'answerer')
+
+                    if (answererCandidates.length > 0) {
+                        foundActivity = true
+
+                        for (const item of answererCandidates) {
+                            if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
+                                try {
+                                    const rtcCandidate = new RTCIceCandidate(item.candidate)
+
+                                    this.iceListeners.forEach(listener => {
+                                        try {
+                                            listener(rtcCandidate)
+                                        } catch (err) {
+                                            console.error('ICE listener error:', err)
+                                        }
+                                    })
+
+                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt)
+                                } catch (err) {
+                                    console.warn('Failed to process ICE candidate:', err)
+                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt)
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Adjust interval based on activity
+                if (foundActivity) {
+                    interval = this.pollingConfig.initialInterval
+                    retries = 0
+                } else {
+                    retries++
+                    if (retries > this.pollingConfig.maxRetries) {
+                        console.warn('Max retries reached for polling')
+                        this.stopPolling()
+                        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.pollingTimeout = setTimeout(poll, finalInterval)
+
+            } catch (err) {
+                console.error('Error polling offers:', err)
+
+                // Retry with backoff
+                const finalInterval = this.pollingConfig.jitter
+                    ? interval + Math.random() * 100
+                    : interval
+                this.pollingTimeout = setTimeout(poll, finalInterval)
+            }
+        }
+
+        poll() // Start immediately
+    }
+
+    /**
+     * Stop combined polling
+     */
+    private stopPolling(): void {
+        if (this.pollingTimeout) {
+            clearTimeout(this.pollingTimeout)
+            this.pollingTimeout = null
+        }
+    }
+
+    /**
+     * Start polling for ICE candidates (answerer side only)
+     * Answerers use the separate endpoint since they don't have offers to poll
+     */
+    private startIcePolling(): void {
+        if (this.icePollingTimeout || !this.serviceFqn || !this.offerId || this.isOfferer) {
+            return
+        }
+
+        let interval = this.pollingConfig.initialInterval
+
+        const poll = async () => {
+            if (!this.serviceFqn || !this.offerId) {
+                this.stopIcePolling()
+                return
+            }
+
+            try {
+                const result = await this.rondevu
+                    .getAPIPublic()
+                    .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastPollTimestamp)
+
+                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.lastPollTimestamp = item.createdAt
+                        } catch (err) {
+                            console.warn('Failed to process ICE candidate:', err)
+                            this.lastPollTimestamp = item.createdAt
+                        }
+                    } else {
+                        this.lastPollTimestamp = 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.stopPolling()
+        this.stopIcePolling()
+        this.offerListeners = []
+        this.answerListeners = []
+        this.iceListeners = []
+    }
+}

src/rondevu.ts

@@ -1,152 +1,370 @@
-import { RondevuAuth, Credentials, FetchFunction } from './auth.js';
+import { RondevuAPI, Keypair, Service, ServiceRequest, IceCandidate, BatcherOptions } from './api.js'
-import { RondevuOffers } from './offers.js';
+import { CryptoAdapter } from './crypto-adapter.js'
-import RondevuPeer from './peer/index.js';
 
 export interface RondevuOptions {
-  /**
+    apiUrl: string
-   * Base URL of the Rondevu server
+    username?: string  // Optional, will generate anonymous if not provided
-   * @default 'https://api.ronde.vu'
+    keypair?: Keypair  // Optional, will generate if not provided
-   */
+    cryptoAdapter?: CryptoAdapter  // Optional, defaults to WebCryptoAdapter
-  baseUrl?: string;
+    batching?: BatcherOptions | false  // Optional, defaults to enabled with default options
-
-  /**
-   * 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;
-
-  /**
-   * Custom RTCPeerConnection implementation for Node.js environments
-   * Required when using in Node.js with wrtc or similar polyfills
-   *
-   * @example Node.js with wrtc
-   * ```typescript
-   * import { RTCPeerConnection } from 'wrtc';
-   * const client = new Rondevu({ RTCPeerConnection });
-   * ```
-   */
-  RTCPeerConnection?: typeof RTCPeerConnection;
-
-  /**
-   * Custom RTCSessionDescription implementation for Node.js environments
-   * Required when using in Node.js with wrtc or similar polyfills
-   *
-   * @example Node.js with wrtc
-   * ```typescript
-   * import { RTCSessionDescription } from 'wrtc';
-   * const client = new Rondevu({ RTCSessionDescription });
-   * ```
-   */
-  RTCSessionDescription?: typeof RTCSessionDescription;
-
-  /**
-   * Custom RTCIceCandidate implementation for Node.js environments
-   * Required when using in Node.js with wrtc or similar polyfills
-   *
-   * @example Node.js with wrtc
-   * ```typescript
-   * import { RTCIceCandidate } from 'wrtc';
-   * const client = new Rondevu({ RTCIceCandidate });
-   * ```
-   */
-  RTCIceCandidate?: typeof RTCIceCandidate;
 }
 
+export interface PublishServiceOptions {
+    serviceFqn: string // Must include @username (e.g., "chat:1.0.0@alice")
+    offers: Array<{ sdp: string }>
+    ttl?: number
+}
+
+/**
+ * Rondevu - Complete WebRTC signaling client
+ *
+ * Provides a unified API for:
+ * - Username claiming with Ed25519 signatures
+ * - Service publishing with automatic signature generation
+ * - Service discovery (direct, random, paginated)
+ * - WebRTC signaling (offer/answer exchange, ICE relay)
+ * - Keypair management
+ *
+ * @example
+ * ```typescript
+ * // Create Rondevu instance with username
+ * const rondevu = new Rondevu({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'alice',
+ * })
+ * await rondevu.initialize()
+ * await rondevu.claimUsername()  // Claim username before publishing
+ *
+ * // Publish a service
+ * const publishedService = await rondevu.publishService({
+ *   serviceFqn: 'chat:1.0.0@alice',
+ *   offers: [{ sdp: offerSdp }],
+ *   ttl: 300000,
+ * })
+ *
+ * // Discover a service
+ * const service = await rondevu.getService('chat:1.0.0@bob')
+ *
+ * // Post answer
+ * await rondevu.postOfferAnswer(service.serviceFqn, service.offerId, answerSdp)
+ * ```
+ */
 export class Rondevu {
-  readonly auth: RondevuAuth;
+    private api: RondevuAPI | null = null
-  private _offers?: RondevuOffers;
+    private readonly apiUrl: string
-  private credentials?: Credentials;
+    private username: string
-  private baseUrl: string;
+    private keypair: Keypair | null = null
-  private fetchFn?: FetchFunction;
+    private usernameClaimed = false
-  private rtcPeerConnection?: typeof RTCPeerConnection;
+    private cryptoAdapter?: CryptoAdapter
-  private rtcSessionDescription?: typeof RTCSessionDescription;
+    private batchingOptions?: BatcherOptions | false
-  private rtcIceCandidate?: typeof RTCIceCandidate;
 
-  constructor(options: RondevuOptions = {}) {
+    constructor(options: RondevuOptions) {
-    this.baseUrl = options.baseUrl || 'https://api.ronde.vu';
+        this.apiUrl = options.apiUrl
-    this.fetchFn = options.fetch;
+        this.username = options.username || this.generateAnonymousUsername()
-    this.rtcPeerConnection = options.RTCPeerConnection;
+        this.keypair = options.keypair || null
-    this.rtcSessionDescription = options.RTCSessionDescription;
+        this.cryptoAdapter = options.cryptoAdapter
-    this.rtcIceCandidate = options.RTCIceCandidate;
+        this.batchingOptions = options.batching
 
-    this.auth = new RondevuAuth(this.baseUrl, this.fetchFn);
+        console.log('[Rondevu] Constructor called:', {
-
+            username: this.username,
-    if (options.credentials) {
+            hasKeypair: !!this.keypair,
-      this.credentials = options.credentials;
+            publicKey: this.keypair?.publicKey,
-      this._offers = new RondevuOffers(this.baseUrl, this.credentials, this.fetchFn);
+            batchingEnabled: options.batching !== false
-    }
+        })
     }
 
     /**
-   * Get offers API (requires authentication)
+     * Generate an anonymous username with timestamp and random component
      */
-  get offers(): RondevuOffers {
+    private generateAnonymousUsername(): string {
-    if (!this._offers) {
+        const timestamp = Date.now().toString(36)
-      throw new Error('Not authenticated. Call register() first or provide credentials.');
+        const random = Array.from(crypto.getRandomValues(new Uint8Array(3)))
+            .map(b => b.toString(16).padStart(2, '0')).join('')
+        return `anon-${timestamp}-${random}`
     }
-    return this._offers;
+
+    // ============================================
+    // Initialization
+    // ============================================
+
+    /**
+     * Initialize the service - generates keypair if not provided and creates API instance
+     * Call this before using other methods
+     */
+    async initialize(): Promise<void> {
+        console.log('[Rondevu] Initialize called, hasKeypair:', !!this.keypair)
+
+        // Generate keypair if not provided
+        if (!this.keypair) {
+            console.log('[Rondevu] Generating new keypair...')
+            this.keypair = await RondevuAPI.generateKeypair(this.cryptoAdapter)
+            console.log('[Rondevu] Generated keypair, publicKey:', this.keypair.publicKey)
+        } else {
+            console.log('[Rondevu] Using existing keypair, publicKey:', this.keypair.publicKey)
+        }
+
+        // Create API instance with username, keypair, crypto adapter, and batching options
+        this.api = new RondevuAPI(
+            this.apiUrl,
+            this.username,
+            this.keypair,
+            this.cryptoAdapter,
+            this.batchingOptions
+        )
+        console.log('[Rondevu] Created API instance with username:', this.username)
+    }
+
+    // ============================================
+    // Username Management
+    // ============================================
+
+    /**
+     * Claim the username with Ed25519 signature
+     * Should be called once before publishing services
+     */
+    async claimUsername(): Promise<void> {
+        if (!this.keypair) {
+            throw new Error('Not initialized. Call initialize() first.')
+        }
+
+        // Check if username is already claimed
+        const available = await this.getAPI().isUsernameAvailable(this.username)
+        if (!available) {
+            // Check if it's claimed by us
+            const claimed = await this.getAPI().isUsernameClaimed()
+            if (claimed) {
+                this.usernameClaimed = true
+                return
+            }
+            throw new Error(`Username "${this.username}" is already claimed by another user`)
+        }
+
+        // Claim the username
+        await this.getAPI().claimUsername(this.username, this.keypair.publicKey)
+        this.usernameClaimed = true
     }
 
     /**
-   * Register and initialize authenticated client
+     * Get API instance (creates lazily if needed)
-   * @param customPeerId - Optional custom peer ID (1-128 characters). If not provided, a random ID will be generated.
      */
-  async register(customPeerId?: string): Promise<Credentials> {
+    private getAPI(): RondevuAPI {
-    this.credentials = await this.auth.register(customPeerId);
+        if (!this.api) {
-
+            throw new Error('Not initialized. Call initialize() first.')
-    // Create offers API instance
+        }
-    this._offers = new RondevuOffers(
+        return this.api
-      this.baseUrl,
-      this.credentials,
-      this.fetchFn
-    );
-
-    return this.credentials;
     }
 
     /**
-   * Check if client is authenticated
+     * Check if username has been claimed (checks with server)
      */
-  isAuthenticated(): boolean {
+    async isUsernameClaimed(): Promise<boolean> {
-    return !!this.credentials;
+        if (!this.keypair) {
+            return false
+        }
+
+        try {
+            const claimed = await this.getAPI().isUsernameClaimed()
+
+            // Update internal flag to match server state
+            this.usernameClaimed = claimed
+
+            return claimed
+        } catch (err) {
+            console.error('Failed to check username claim status:', err)
+            return false
+        }
+    }
+
+    // ============================================
+    // Service Publishing
+    // ============================================
+
+    /**
+     * Publish a service with automatic signature generation
+     * Username will be automatically claimed on first publish if not already claimed
+     */
+    async publishService(options: PublishServiceOptions): Promise<Service> {
+        if (!this.keypair) {
+            throw new Error('Not initialized. Call initialize() first.')
+        }
+
+        const { serviceFqn, offers, ttl } = options
+
+        // Publish to server (server will auto-claim username if needed)
+        // Note: signature and message are generated by the API layer
+        const result = await this.getAPI().publishService({
+            serviceFqn,
+            offers,
+            ttl,
+            signature: '', // Not used, generated by API layer
+            message: '',   // Not used, generated by API layer
+        })
+
+        // Mark username as claimed after successful publish
+        this.usernameClaimed = true
+
+        return result
+    }
+
+    // ============================================
+    // Service Discovery
+    // ============================================
+
+    /**
+     * Get service by FQN (with username) - Direct lookup
+     * Example: chat:1.0.0@alice
+     */
+    async getService(serviceFqn: string): Promise<{
+        serviceId: string
+        username: string
+        serviceFqn: string
+        offerId: string
+        sdp: string
+        createdAt: number
+        expiresAt: number
+    }> {
+        return await this.getAPI().getService(serviceFqn)
     }
 
     /**
-   * Get current credentials
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
      */
-  getCredentials(): Credentials | undefined {
+    async discoverService(serviceVersion: string): Promise<{
-    return this.credentials;
+        serviceId: string
+        username: string
+        serviceFqn: string
+        offerId: string
+        sdp: string
+        createdAt: number
+        expiresAt: number
+    }> {
+        return await this.getAPI().getService(serviceVersion)
     }
 
     /**
-   * Create a new WebRTC peer connection (requires authentication)
+     * Discover multiple available services with pagination
-   * This is a high-level helper that creates and manages WebRTC connections with state management
+     * Example: chat:1.0.0 (without @username)
-   *
-   * @param rtcConfig Optional RTCConfiguration for the peer connection
-   * @returns RondevuPeer instance
      */
-  createPeer(rtcConfig?: RTCConfiguration): RondevuPeer {
+    async discoverServices(serviceVersion: string, limit: number = 10, offset: number = 0): Promise<{
-    if (!this._offers) {
+        services: Array<{
-      throw new Error('Not authenticated. Call register() first or provide credentials.');
+            serviceId: string
+            username: string
+            serviceFqn: string
+            offerId: string
+            sdp: string
+            createdAt: number
+            expiresAt: number
+        }>
+        count: number
+        limit: number
+        offset: number
+    }> {
+        return await this.getAPI().getService(serviceVersion, { limit, offset })
     }
 
-    return new RondevuPeer(
+    // ============================================
-      this._offers,
+    // WebRTC Signaling
-      rtcConfig,
+    // ============================================
-      this.rtcPeerConnection,
+
-      this.rtcSessionDescription,
+    /**
-      this.rtcIceCandidate
+     * Post answer SDP to specific offer
-    );
+     */
+    async postOfferAnswer(serviceFqn: string, offerId: string, sdp: string): Promise<{
+        success: boolean
+        offerId: string
+    }> {
+        await this.getAPI().answerOffer(serviceFqn, offerId, sdp)
+        return { success: true, offerId }
+    }
+
+    /**
+     * Get answer SDP (offerer polls this)
+     */
+    async getOfferAnswer(serviceFqn: string, offerId: string): Promise<{
+        sdp: string
+        offerId: string
+        answererId: string
+        answeredAt: number
+    } | null> {
+        return await this.getAPI().getOfferAnswer(serviceFqn, offerId)
+    }
+
+    /**
+     * Combined polling for answers and ICE candidates
+     * Returns all answered offers and ICE candidates for all peer's offers since timestamp
+     */
+    async poll(since?: number): Promise<{
+        answers: Array<{
+            offerId: string
+            serviceId?: string
+            answererId: string
+            sdp: string
+            answeredAt: number
+        }>
+        iceCandidates: Record<string, Array<{
+            candidate: any
+            role: 'offerer' | 'answerer'
+            peerId: string
+            createdAt: number
+        }>>
+    }> {
+        return await this.getAPI().poll(since)
+    }
+
+    /**
+     * Add ICE candidates to specific offer
+     */
+    async addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
+        count: number
+        offerId: string
+    }> {
+        return await this.getAPI().addOfferIceCandidates(serviceFqn, offerId, candidates)
+    }
+
+    /**
+     * Get ICE candidates for specific offer (with polling support)
+     */
+    async getOfferIceCandidates(serviceFqn: string, offerId: string, since: number = 0): Promise<{
+        candidates: IceCandidate[]
+        offerId: string
+    }> {
+        return await this.getAPI().getOfferIceCandidates(serviceFqn, offerId, since)
+    }
+
+    // ============================================
+    // Utility Methods
+    // ============================================
+
+    /**
+     * 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
+    }
+
+    /**
+     * Access to underlying API for advanced operations
+     * @deprecated Use direct methods on Rondevu instance instead
+     */
+    getAPIPublic(): RondevuAPI {
+        if (!this.api) {
+            throw new Error('Not initialized. Call initialize() first.')
+        }
+        return this.api
     }
 }

src/rpc-batcher.ts

@@ -0,0 +1,157 @@
+/**
+ * RPC Batcher - Throttles and batches RPC requests to reduce HTTP overhead
+ */
+
+export interface BatcherOptions {
+    /**
+     * Maximum number of requests to batch together
+     * Default: 10
+     */
+    maxBatchSize?: number
+
+    /**
+     * Maximum time to wait before sending a batch (ms)
+     * Default: 50ms
+     */
+    maxWaitTime?: number
+
+    /**
+     * Minimum time between batches (ms)
+     * Default: 10ms
+     */
+    throttleInterval?: number
+}
+
+interface QueuedRequest {
+    request: any
+    resolve: (value: any) => void
+    reject: (error: Error) => void
+}
+
+/**
+ * Batches and throttles RPC requests to optimize network usage
+ *
+ * @example
+ * ```typescript
+ * const batcher = new RpcBatcher(
+ *   (requests) => api.rpcBatch(requests),
+ *   { maxBatchSize: 10, maxWaitTime: 50 }
+ * )
+ *
+ * // These will be batched together if called within maxWaitTime
+ * const result1 = await batcher.add(request1)
+ * const result2 = await batcher.add(request2)
+ * const result3 = await batcher.add(request3)
+ * ```
+ */
+export class RpcBatcher {
+    private queue: QueuedRequest[] = []
+    private batchTimeout: ReturnType<typeof setTimeout> | null = null
+    private lastBatchTime: number = 0
+    private options: Required<BatcherOptions>
+    private sendBatch: (requests: any[]) => Promise<any[]>
+
+    constructor(
+        sendBatch: (requests: any[]) => Promise<any[]>,
+        options?: BatcherOptions
+    ) {
+        this.sendBatch = sendBatch
+        this.options = {
+            maxBatchSize: options?.maxBatchSize ?? 10,
+            maxWaitTime: options?.maxWaitTime ?? 50,
+            throttleInterval: options?.throttleInterval ?? 10,
+        }
+    }
+
+    /**
+     * Add an RPC request to the batch queue
+     * Returns a promise that resolves when the request completes
+     */
+    async add(request: any): Promise<any> {
+        return new Promise((resolve, reject) => {
+            this.queue.push({ request, resolve, reject })
+
+            // Send immediately if batch is full
+            if (this.queue.length >= this.options.maxBatchSize) {
+                this.flush()
+                return
+            }
+
+            // Schedule batch if not already scheduled
+            if (!this.batchTimeout) {
+                this.batchTimeout = setTimeout(() => {
+                    this.flush()
+                }, this.options.maxWaitTime)
+            }
+        })
+    }
+
+    /**
+     * Flush the queue immediately
+     */
+    async flush(): Promise<void> {
+        // Clear timeout if set
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout)
+            this.batchTimeout = null
+        }
+
+        // Nothing to flush
+        if (this.queue.length === 0) {
+            return
+        }
+
+        // Throttle: wait if we sent a batch too recently
+        const now = Date.now()
+        const timeSinceLastBatch = now - this.lastBatchTime
+        if (timeSinceLastBatch < this.options.throttleInterval) {
+            const waitTime = this.options.throttleInterval - timeSinceLastBatch
+            await new Promise(resolve => setTimeout(resolve, waitTime))
+        }
+
+        // Extract requests from queue
+        const batch = this.queue.splice(0, this.options.maxBatchSize)
+        const requests = batch.map(item => item.request)
+
+        this.lastBatchTime = Date.now()
+
+        try {
+            // Send batch request
+            const results = await this.sendBatch(requests)
+
+            // Resolve individual promises
+            for (let i = 0; i < batch.length; i++) {
+                batch[i].resolve(results[i])
+            }
+        } catch (error) {
+            // Reject all promises in batch
+            for (const item of batch) {
+                item.reject(error as Error)
+            }
+        }
+    }
+
+    /**
+     * Get current queue size
+     */
+    getQueueSize(): number {
+        return this.queue.length
+    }
+
+    /**
+     * Clear the queue without sending
+     */
+    clear(): void {
+        if (this.batchTimeout) {
+            clearTimeout(this.batchTimeout)
+            this.batchTimeout = null
+        }
+
+        // Reject all pending requests
+        for (const item of this.queue) {
+            item.reject(new Error('Batch queue cleared'))
+        }
+
+        this.queue = []
+    }
+}

src/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Core signaling types
+ */
+
+/**
+ * Cleanup function returned by listener methods
+ */
+export type Binnable = () => void
+
+/**
+ * Signaler interface for WebRTC offer/answer/ICE exchange
+ */
+export interface Signaler {
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>
+    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable
+    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable
+    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable
+    setOffer(offer: RTCSessionDescriptionInit): Promise<void>
+    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>
+}

src/web-crypto-adapter.ts

@@ -0,0 +1,67 @@
+/**
+ * Web Crypto adapter for browser environments
+ */
+
+import * as ed25519 from '@noble/ed25519'
+import { CryptoAdapter, Keypair } from './crypto-adapter.js'
+
+// 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))
+}
+
+/**
+ * Web Crypto implementation using browser APIs
+ * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes
+ */
+export class WebCryptoAdapter implements CryptoAdapter {
+    async generateKeypair(): Promise<Keypair> {
+        const privateKey = ed25519.utils.randomSecretKey()
+        const publicKey = await ed25519.getPublicKeyAsync(privateKey)
+
+        return {
+            publicKey: this.bytesToBase64(publicKey),
+            privateKey: this.bytesToBase64(privateKey),
+        }
+    }
+
+    async signMessage(message: string, privateKeyBase64: string): Promise<string> {
+        const privateKey = this.base64ToBytes(privateKeyBase64)
+        const encoder = new TextEncoder()
+        const messageBytes = encoder.encode(message)
+        const signature = await ed25519.signAsync(messageBytes, privateKey)
+
+        return this.bytesToBase64(signature)
+    }
+
+    async verifySignature(
+        message: string,
+        signatureBase64: string,
+        publicKeyBase64: string
+    ): Promise<boolean> {
+        try {
+            const signature = this.base64ToBytes(signatureBase64)
+            const publicKey = this.base64ToBytes(publicKeyBase64)
+            const encoder = new TextEncoder()
+            const messageBytes = encoder.encode(message)
+
+            return await ed25519.verifyAsync(signature, messageBytes, publicKey)
+        } catch {
+            return false
+        }
+    }
+
+    bytesToBase64(bytes: Uint8Array): string {
+        const binString = Array.from(bytes, byte => String.fromCodePoint(byte)).join('')
+        return btoa(binString)
+    }
+
+    base64ToBytes(base64: string): Uint8Array {
+        const binString = atob(base64)
+        return Uint8Array.from(binString, char => char.codePointAt(0)!)
+    }
+
+    randomBytes(length: number): Uint8Array {
+        return crypto.getRandomValues(new Uint8Array(length))
+    }
+}