v0.18.0 - Add WebRTC polyfill support for Node.js

Allow users to pass WebRTC polyfills (RTCPeerConnection, RTCIceCandidate) through RondevuOptions instead of manually setting global variables. The client now automatically applies these to globalThis when provided.

This simplifies Node.js integration:
- Before: Users had to manually set globalThis.RTCPeerConnection
- After: Pass rtcPeerConnection and rtcIceCandidate options

Example:
  const rondevu = await Rondevu.connect({
    apiUrl: 'https://api.example.com',
    username: 'alice',
    cryptoAdapter: new NodeCryptoAdapter(),
    rtcPeerConnection: wrtc.RTCPeerConnection,
    rtcIceCandidate: wrtc.RTCIceCandidate
  })

.prettierrc.json

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

ADVANCED.md

@@ -0,0 +1,486 @@
+# Rondevu Client - Advanced Usage
+
+Comprehensive guide for advanced features, platform support, and detailed API reference.
+
+## Table of Contents
+
+- [API Reference](#api-reference)
+- [Types](#types)
+- [Advanced Usage](#advanced-usage)
+- [Platform Support](#platform-support)
+- [Username Rules](#username-rules)
+- [Service FQN Format](#service-fqn-format)
+- [Examples](#examples)
+- [Migration Guide](#migration-guide)
+
+---
+
+## API Reference
+
+### Rondevu Class
+
+Main class for all Rondevu operations.
+
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client'
+
+// Create and connect to Rondevu
+const rondevu = await Rondevu.connect({
+  apiUrl: string,          // Signaling server URL
+  username?: string,       // Optional: your username (auto-generates anonymous if omitted)
+  keypair?: Keypair,       // Optional: reuse existing keypair
+  cryptoAdapter?: CryptoAdapter  // Optional: platform-specific crypto (defaults to WebCryptoAdapter)
+  batching?: BatcherOptions | false  // Optional: RPC batching configuration
+  iceServers?: IceServerPreset | RTCIceServer[]  // Optional: preset name or custom STUN/TURN servers
+  debug?: boolean  // Optional: enable debug logging (default: false)
+})
+```
+
+#### Platform Support (Browser & Node.js)
+
+The client supports both browser and Node.js environments using crypto adapters:
+
+**Browser (default):**
+```typescript
+import { Rondevu } from '@xtr-dev/rondevu-client'
+
+// WebCryptoAdapter is used by default - no configuration needed
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'alice'
+})
+```
+
+**Node.js (19+ or 18 with --experimental-global-webcrypto):**
+```typescript
+import { Rondevu, NodeCryptoAdapter } from '@xtr-dev/rondevu-client'
+
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'alice',
+  cryptoAdapter: new NodeCryptoAdapter()
+})
+```
+
+**Note:** Node.js support requires:
+- Node.js 19+ (crypto.subtle available globally), OR
+- Node.js 18 with `--experimental-global-webcrypto` flag
+- WebRTC implementation like `wrtc` or `node-webrtc` for RTCPeerConnection
+
+**Custom Crypto Adapter:**
+```typescript
+import { CryptoAdapter, Keypair } from '@xtr-dev/rondevu-client'
+
+class CustomCryptoAdapter implements CryptoAdapter {
+  async generateKeypair(): Promise<Keypair> { /* ... */ }
+  async signMessage(message: string, privateKey: string): Promise<string> { /* ... */ }
+  async verifySignature(message: string, signature: string, publicKey: string): Promise<boolean> { /* ... */ }
+  bytesToBase64(bytes: Uint8Array): string { /* ... */ }
+  base64ToBytes(base64: string): Uint8Array { /* ... */ }
+  randomBytes(length: number): Uint8Array { /* ... */ }
+}
+
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  cryptoAdapter: new CustomCryptoAdapter()
+})
+```
+
+#### Username Management
+
+Usernames are **automatically claimed** on the first authenticated request (like `publishService()`).
+
+```typescript
+// Check if username is claimed (checks server)
+await rondevu.isUsernameClaimed(): Promise<boolean>
+
+// Get username
+rondevu.getUsername(): string
+
+// Get public key
+rondevu.getPublicKey(): string
+
+// Get keypair (for backup/storage)
+rondevu.getKeypair(): Keypair
+```
+
+#### Service Publishing
+
+```typescript
+// Publish service with offers
+await rondevu.publishService({
+  service: string,  // e.g., 'chat:1.0.0' (username auto-appended)
+  maxOffers: number,  // Maximum number of concurrent offers to maintain
+  offerFactory?: OfferFactory,  // Optional: custom offer creation (defaults to simple data channel)
+  ttl?: number      // Optional: milliseconds (default: 300000)
+}): Promise<void>
+```
+
+#### Service Discovery
+
+```typescript
+// Direct lookup by FQN (with username)
+await rondevu.getService('chat:1.0.0@alice'): Promise<ServiceOffer>
+
+// Random discovery (without username)
+await rondevu.discoverService('chat:1.0.0'): Promise<ServiceOffer>
+
+// Paginated discovery (returns multiple offers)
+await rondevu.discoverServices(
+  'chat:1.0.0',  // serviceVersion
+  10,            // limit
+  0              // offset
+): Promise<{ services: ServiceOffer[], count: number, limit: number, offset: number }>
+```
+
+#### WebRTC Signaling
+
+```typescript
+// Post answer SDP
+await rondevu.postOfferAnswer(
+  serviceFqn: string,
+  offerId: string,
+  sdp: string
+): Promise<{ success: boolean, offerId: string }>
+
+// Get answer SDP (offerer polls this - deprecated, use pollOffers instead)
+await rondevu.getOfferAnswer(
+  serviceFqn: string,
+  offerId: string
+): Promise<{ sdp: string, offerId: string, answererId: string, answeredAt: number } | null>
+
+// Combined polling for answers and ICE candidates (RECOMMENDED for offerers)
+await rondevu.pollOffers(since?: number): Promise<{
+  answers: Array<{
+    offerId: string
+    serviceId?: string
+    answererId: string
+    sdp: string
+    answeredAt: number
+  }>
+  iceCandidates: Record<string, Array<{
+    candidate: RTCIceCandidateInit | null
+    role: 'offerer' | 'answerer'
+    peerId: string
+    createdAt: number
+  }>>
+}>
+
+// Add ICE candidates
+await rondevu.addOfferIceCandidates(
+  serviceFqn: string,
+  offerId: string,
+  candidates: RTCIceCandidateInit[]
+): Promise<{ count: number, offerId: string }>
+
+// Get ICE candidates (with polling support)
+await rondevu.getOfferIceCandidates(
+  serviceFqn: string,
+  offerId: string,
+  since: number = 0
+): Promise<{ candidates: IceCandidate[], offerId: string }>
+```
+
+### RondevuAPI Class
+
+Low-level HTTP API client (used internally by Rondevu class).
+
+```typescript
+import { RondevuAPI } from '@xtr-dev/rondevu-client'
+
+const api = new RondevuAPI(
+  baseUrl: string,
+  username: string,
+  keypair: Keypair
+)
+
+// Check username
+await api.checkUsername(username: string): Promise<{
+  available: boolean
+  publicKey?: string
+  claimedAt?: number
+  expiresAt?: number
+}>
+
+// Note: Username claiming is now implicit - usernames are auto-claimed
+// on first authenticated request to the server
+
+// ... (all other HTTP endpoints)
+```
+
+#### Cryptographic Helpers
+
+```typescript
+// Generate Ed25519 keypair
+const keypair = await RondevuAPI.generateKeypair(): Promise<Keypair>
+
+// Sign message
+const signature = await RondevuAPI.signMessage(
+  message: string,
+  privateKey: string
+): Promise<string>
+
+// Verify signature
+const valid = await RondevuAPI.verifySignature(
+  message: string,
+  signature: string,
+  publicKey: string
+): Promise<boolean>
+```
+
+---
+
+## Types
+
+```typescript
+interface Keypair {
+  publicKey: string   // Base64-encoded Ed25519 public key
+  privateKey: string  // Base64-encoded Ed25519 private key
+}
+
+interface Service {
+  serviceId: string
+  offers: ServiceOffer[]
+  username: string
+  serviceFqn: string
+  createdAt: number
+  expiresAt: number
+}
+
+interface ServiceOffer {
+  offerId: string
+  sdp: string
+  createdAt: number
+  expiresAt: number
+}
+
+interface IceCandidate {
+  candidate: RTCIceCandidateInit | null
+  createdAt: number
+}
+```
+
+---
+
+## Advanced Usage
+
+### Anonymous Username
+
+```typescript
+// Auto-generate anonymous username (format: anon-{timestamp}-{random})
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu'
+  // No username provided - will generate anonymous username
+})
+
+console.log(rondevu.getUsername())  // e.g., "anon-lx2w34-a3f501"
+
+// Anonymous users behave exactly like regular users
+await rondevu.publishService({
+  service: 'chat:1.0.0',
+  maxOffers: 5
+})
+
+await rondevu.startFilling()
+```
+
+### Persistent Keypair
+
+```typescript
+// Save keypair and username to localStorage
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'alice'
+})
+
+// Save for later (username will be auto-claimed on first authenticated request)
+localStorage.setItem('rondevu-username', rondevu.getUsername())
+localStorage.setItem('rondevu-keypair', JSON.stringify(rondevu.getKeypair()))
+
+// Load on next session
+const savedUsername = localStorage.getItem('rondevu-username')
+const savedKeypair = JSON.parse(localStorage.getItem('rondevu-keypair'))
+
+const rondevu2 = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: savedUsername,
+  keypair: savedKeypair
+})
+```
+
+### Service Discovery
+
+```typescript
+// Get a random available service
+const service = await rondevu.discoverService('chat:1.0.0')
+console.log('Discovered:', service.username)
+
+// Get multiple services (paginated)
+const result = await rondevu.discoverServices('chat:1.0.0', 10, 0)
+console.log(`Found ${result.count} services:`)
+result.services.forEach(s => console.log(`  - ${s.username}`))
+```
+
+### Multiple Concurrent Offers
+
+```typescript
+// Publish service with multiple offers for connection pooling
+const offers = []
+const connections = []
+
+for (let i = 0; i < 5; i++) {
+  const pc = new RTCPeerConnection(rtcConfig)
+  const dc = pc.createDataChannel('chat')
+  const offer = await pc.createOffer()
+  await pc.setLocalDescription(offer)
+
+  offers.push({ sdp: offer.sdp })
+  connections.push({ pc, dc })
+}
+
+const service = await rondevu.publishService({
+  service: 'chat:1.0.0',
+  offers,
+  ttl: 300000
+})
+
+// Each offer can be answered independently
+console.log(`Published ${service.offers.length} offers`)
+```
+
+### Debug Logging
+
+```typescript
+// Enable debug logging to see internal operations
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'alice',
+  debug: true  // All internal logs will be displayed with [Rondevu] prefix
+})
+
+// Debug logs include:
+// - Connection establishment
+// - Keypair generation
+// - Service publishing
+// - Offer creation
+// - ICE candidate exchange
+// - Connection state changes
+```
+
+---
+
+## Platform Support
+
+### Modern Browsers
+Works out of the box - no additional setup needed.
+
+### Node.js 18+
+Native fetch is available, but WebRTC requires polyfills:
+
+```bash
+npm install wrtc
+```
+
+```typescript
+import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc'
+
+// Use wrtc implementations
+const pc = new RTCPeerConnection()
+```
+
+---
+
+## Username Rules
+
+- **Format**: Lowercase alphanumeric + dash (`a-z`, `0-9`, `-`)
+- **Length**: 3-32 characters
+- **Pattern**: `^[a-z0-9][a-z0-9-]*[a-z0-9]$`
+- **Validity**: 365 days from claim/last use
+- **Ownership**: Secured by Ed25519 public key signature
+
+---
+
+## Service FQN Format
+
+- **Format**: `service:version@username`
+- **Service**: Lowercase alphanumeric + dash (e.g., `chat`, `video-call`)
+- **Version**: Semantic versioning (e.g., `1.0.0`, `2.1.3`)
+- **Username**: Claimed username
+- **Example**: `chat:1.0.0@alice`
+
+---
+
+## Examples
+
+### Node.js Service Host Example
+
+You can host WebRTC services in Node.js that browser clients can connect to:
+
+```typescript
+import { Rondevu, NodeCryptoAdapter } from '@xtr-dev/rondevu-client'
+import wrtc from 'wrtc'
+
+const { RTCPeerConnection } = wrtc
+
+// Initialize with Node crypto adapter
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'mybot',
+  cryptoAdapter: new NodeCryptoAdapter()
+})
+
+// Create peer connection (offerer creates data channel)
+const pc = new RTCPeerConnection(rtcConfig)
+const dc = pc.createDataChannel('chat')
+
+// Publish service (username auto-claimed on first publish)
+await rondevu.publishService({
+  service: 'chat:1.0.0',
+  maxOffers: 5
+})
+
+await rondevu.startFilling()
+
+// Browser clients can now discover and connect to chat:1.0.0@mybot
+```
+
+**See also:**
+- [React Demo](https://github.com/xtr-dev/rondevu-demo) - Complete browser UI ([live](https://ronde.vu))
+
+---
+
+## Migration Guide
+
+### Migration from v0.3.x
+
+v0.4.0 removes high-level abstractions and uses manual WebRTC setup:
+
+**Removed:**
+- `ServiceHost` class (use manual WebRTC + `publishService()`)
+- `ServiceClient` class (use manual WebRTC + `getService()`)
+- `RTCDurableConnection` class (use native WebRTC APIs)
+- `RondevuService` class (merged into `Rondevu`)
+
+**Added:**
+- `pollOffers()` - Combined polling for answers and ICE candidates
+- `publishService()` - Automatic offer pool management
+- `connectToService()` - Automatic answering side setup
+
+**Migration Example:**
+
+```typescript
+// Before (v0.3.x) - ServiceHost
+const host = new ServiceHost({
+  service: 'chat@1.0.0',
+  rondevuService: service
+})
+await host.start()
+
+// After (v0.4.0+) - Automatic setup
+await rondevu.publishService({
+  service: 'chat:1.0.0',
+  maxOffers: 5
+})
+
+await rondevu.startFilling()
+```

EVENTBUS_EXAMPLE.md

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

README.md

@@ -2,9 +2,9 @@
 
 [![npm version](https://img.shields.io/npm/v/@xtr-dev/rondevu-client)](https://www.npmjs.com/package/@xtr-dev/rondevu-client)
 
-🌐 **WebRTC with durable connections and automatic reconnection**
+🌐 **Simple WebRTC signaling client with username-based discovery**
 
-TypeScript/JavaScript client for Rondevu, providing durable WebRTC connections that survive network interruptions with automatic reconnection and message queuing.
+TypeScript/JavaScript client for Rondevu, providing WebRTC signaling with username claiming, service publishing/discovery, and efficient batch polling.
 
 **Related repositories:**
 - [@xtr-dev/rondevu-client](https://github.com/xtr-dev/rondevu-client) - TypeScript client library ([npm](https://www.npmjs.com/package/@xtr-dev/rondevu-client))
@@ -15,16 +15,17 @@ TypeScript/JavaScript client for Rondevu, providing durable WebRTC connections t
 
 ## Features
 
-- **Durable Connections**: Automatic reconnection on network drops
+- **Username Claiming**: Secure ownership with Ed25519 signatures
-- **Message Queuing**: Messages sent during disconnections are queued and flushed on reconnect
+- **Anonymous Users**: Auto-generated anonymous usernames for quick testing
-- **Durable Channels**: RTCDataChannel wrappers that survive connection drops
+- **Service Publishing**: Publish services with multiple offers for connection pooling
-- **TTL Auto-Refresh**: Services automatically republish before expiration
+- **Service Discovery**: Direct lookup, random discovery, or paginated search
-- **Username Claiming**: Cryptographic ownership with Ed25519 signatures
+- **Efficient Batch Polling**: Single endpoint for answers and ICE candidates (50% fewer requests)
-- **Service Publishing**: Package-style naming (com.example.chat@1.0.0)
+- **Semantic Version Matching**: Compatible version resolution (chat:1.0.0 matches any 1.x.x)
 - **TypeScript**: Full type safety and autocomplete
-- **Configurable**: All timeouts, retry limits, and queue sizes are configurable
+- **Keypair Management**: Generate or reuse Ed25519 keypairs
+- **Automatic Signatures**: All authenticated requests signed automatically
 
-## Install
+## Installation
 
 ```bash
 npm install @xtr-dev/rondevu-client
@@ -32,627 +33,144 @@ npm install @xtr-dev/rondevu-client
 
 ## Quick Start
 
-### Publishing a Service (Alice)
+### Publishing a Service (Offerer)
 
 ```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
+import { Rondevu } from '@xtr-dev/rondevu-client'
 
-// Initialize client and register
+// 1. Connect to Rondevu
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+const rondevu = await Rondevu.connect({
-await client.register();
+  apiUrl: 'https://api.ronde.vu',
+  username: 'alice',  // Or omit for anonymous username
+  iceServers: 'ipv4-turn'  // Preset: 'ipv4-turn', 'hostname-turns', 'google-stun', 'relay-only'
+})
 
-// Step 1: Claim username (one-time)
+// 2. Publish service with automatic offer management
-const claim = await client.usernames.claimUsername('alice');
+await rondevu.publishService({
-client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
+  service: 'chat:1.0.0',
+  maxOffers: 5,  // Maintain up to 5 concurrent offers
+  offerFactory: async (rtcConfig) => {
+    const pc = new RTCPeerConnection(rtcConfig)
+    const dc = pc.createDataChannel('chat')
 
-// Step 2: Expose service with handler
+    dc.addEventListener('open', () => {
-const keypair = client.usernames.loadKeypairFromStorage('alice');
+      console.log('Connection opened!')
+      dc.send('Hello from Alice!')
+    })
 
-const service = await client.exposeService({
+    dc.addEventListener('message', (e) => {
-  username: 'alice',
+      console.log('Received:', e.data)
-  privateKey: keypair.privateKey,
+    })
-  serviceFqn: 'chat@1.0.0',
-  isPublic: true,
-  poolSize: 10,  // Handle 10 concurrent connections
-  handler: (channel, connectionId) => {
-    console.log(`📡 New connection: ${connectionId}`);
 
-    channel.on('message', (data) => {
+    const offer = await pc.createOffer()
-      console.log('📥 Received:', data);
+    await pc.setLocalDescription(offer)
-      channel.send(`Echo: ${data}`);
+    return { pc, dc, offer }
-    });
-
-    channel.on('close', () => {
-      console.log(`👋 Connection ${connectionId} closed`);
-    });
   }
-});
+})
 
-// Start the service
+// 3. Start accepting connections
-const info = await service.start();
+await rondevu.startFilling()
-console.log(`Service published with UUID: ${info.uuid}`);
-console.log('Waiting for connections...');
-
-// Later: stop the service
-await service.stop();
 ```
 
-### Connecting to a Service (Bob)
+### Connecting to a Service (Answerer)
 
 ```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
+import { Rondevu } from '@xtr-dev/rondevu-client'
 
-// Initialize client and register
+// 1. Connect to Rondevu
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
+const rondevu = await Rondevu.connect({
-await client.register();
+  apiUrl: 'https://api.ronde.vu',
+  username: 'bob',
+  iceServers: 'ipv4-turn'
+})
 
-// Connect to Alice's service
+// 2. Connect to service (automatic WebRTC setup)
-const connection = await client.connect('alice', 'chat@1.0.0', {
+const connection = await rondevu.connectToService({
-  maxReconnectAttempts: 5
+  serviceFqn: 'chat:1.0.0@alice',
-});
+  onConnection: ({ dc, peerUsername }) => {
+    console.log('Connected to', peerUsername)
 
-// Create a durable channel
+    dc.addEventListener('message', (e) => {
-const channel = connection.createChannel('main');
+      console.log('Received:', e.data)
+    })
 
-channel.on('message', (data) => {
+    dc.addEventListener('open', () => {
-  console.log('📥 Received:', data);
+      dc.send('Hello from Bob!')
-});
+    })
-
-channel.on('open', () => {
-  console.log('✅ Channel open');
-  channel.send('Hello Alice!');
-});
-
-// Listen for connection events
-connection.on('connected', () => {
-  console.log('🎉 Connected to Alice');
-});
-
-connection.on('reconnecting', (attempt, max, delay) => {
-  console.log(`🔄 Reconnecting... (${attempt}/${max}, retry in ${delay}ms)`);
-});
-
-connection.on('disconnected', () => {
-  console.log('🔌 Disconnected');
-});
-
-connection.on('failed', (error) => {
-  console.error('❌ Connection failed permanently:', error);
-});
-
-// Establish the connection
-await connection.connect();
-
-// Messages sent during disconnection are automatically queued
-channel.send('This will be queued if disconnected');
-
-// Later: close the connection
-await connection.close();
-```
-
-## Core Concepts
-
-### DurableConnection
-
-Manages WebRTC peer lifecycle with automatic reconnection:
-- Automatically reconnects when connection drops
-- Exponential backoff with jitter (1s → 2s → 4s → 8s → ... max 30s)
-- Configurable max retry attempts (default: 10)
-- Manages multiple DurableChannel instances
-
-### DurableChannel
-
-Wraps RTCDataChannel with message queuing:
-- Queues messages during disconnection
-- Flushes queue on reconnection
-- Configurable queue size and message age limits
-- RTCDataChannel-compatible API with event emitters
-
-### DurableService
-
-Server-side service with TTL auto-refresh:
-- Automatically republishes service before TTL expires
-- Creates DurableConnection for each incoming peer
-- Manages connection pool for multiple simultaneous connections
-
-## API Reference
-
-### Main Client
-
-```typescript
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu',  // optional, default shown
-  credentials?: { peerId, secret },  // optional, skip registration
-  fetch?: customFetch,               // optional, for Node.js < 18
-  RTCPeerConnection?: RTCPeerConnection,  // optional, for Node.js
-  RTCSessionDescription?: RTCSessionDescription,
-  RTCIceCandidate?: RTCIceCandidate
-});
-
-// Register and get credentials
-const creds = await client.register();
-// { peerId: '...', secret: '...' }
-
-// Check if authenticated
-client.isAuthenticated(); // boolean
-
-// Get current credentials
-client.getCredentials(); // { peerId, secret } | undefined
-```
-
-### Username API
-
-```typescript
-// Check username availability
-const check = await client.usernames.checkUsername('alice');
-// { available: true } or { available: false, expiresAt: number, publicKey: string }
-
-// Claim username with new keypair
-const claim = await client.usernames.claimUsername('alice');
-// { username, publicKey, privateKey, claimedAt, expiresAt }
-
-// Save keypair to localStorage
-client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
-
-// Load keypair from localStorage
-const keypair = client.usernames.loadKeypairFromStorage('alice');
-// { publicKey, privateKey } | null
-```
-
-**Username Rules:**
-- Format: Lowercase alphanumeric + dash (`a-z`, `0-9`, `-`)
-- Length: 3-32 characters
-- Pattern: `^[a-z0-9][a-z0-9-]*[a-z0-9]$`
-- Validity: 365 days from claim/last use
-- Ownership: Secured by Ed25519 public key
-
-### Durable Service API
-
-```typescript
-// Expose a durable service
-const service = await client.exposeService({
-  username: 'alice',
-  privateKey: keypair.privateKey,
-  serviceFqn: 'chat@1.0.0',
-
-  // Service options
-  isPublic: true,               // optional, default: false
-  metadata: { version: '1.0' }, // optional
-  ttl: 300000,                  // optional, default: 5 minutes
-  ttlRefreshMargin: 0.2,        // optional, refresh at 80% of TTL
-
-  // Connection pooling
-  poolSize: 10,                 // optional, default: 1
-  pollingInterval: 2000,        // optional, default: 2000ms
-
-  // Connection options (applied to incoming connections)
-  maxReconnectAttempts: 10,     // optional, default: 10
-  reconnectBackoffBase: 1000,   // optional, default: 1000ms
-  reconnectBackoffMax: 30000,   // optional, default: 30000ms
-  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
-  connectionTimeout: 30000,     // optional, default: 30000ms
-
-  // Message queuing
-  maxQueueSize: 1000,           // optional, default: 1000
-  maxMessageAge: 60000,         // optional, default: 60000ms (1 minute)
-
-  // WebRTC configuration
-  rtcConfig: {
-    iceServers: [
-      { urls: 'stun:stun.l.google.com:19302' }
-    ]
-  },
-
-  // Connection handler
-  handler: (channel, connectionId) => {
-    // Handle incoming connection
-    channel.on('message', (data) => {
-      console.log('Received:', data);
-      channel.send(`Echo: ${data}`);
-    });
   }
-});
+})
 
-// Start the service
+// Access connection
-const info = await service.start();
+connection.dc.send('Another message')
-// { serviceId: '...', uuid: '...', expiresAt: 1234567890 }
+connection.pc.close()  // Close when done
-
-// Get active connections
-const connections = service.getActiveConnections();
-// ['conn-123', 'conn-456']
-
-// Get service info
-const serviceInfo = service.getServiceInfo();
-// { serviceId: '...', uuid: '...', expiresAt: 1234567890 } | null
-
-// Stop the service
-await service.stop();
 ```
 
-**Service Events:**
+## Core API
-```typescript
-service.on('published', (serviceId, uuid) => {
-  console.log(`Service published: ${uuid}`);
-});
 
-service.on('connection', (connectionId) => {
+### Rondevu.connect()
-  console.log(`New connection: ${connectionId}`);
-});
-
-service.on('disconnection', (connectionId) => {
-  console.log(`Connection closed: ${connectionId}`);
-});
-
-service.on('ttl-refreshed', (expiresAt) => {
-  console.log(`TTL refreshed, expires at: ${new Date(expiresAt)}`);
-});
-
-service.on('error', (error, context) => {
-  console.error(`Service error (${context}):`, error);
-});
-
-service.on('closed', () => {
-  console.log('Service stopped');
-});
-```
-
-### Durable Connection API
 
 ```typescript
-// Connect by username and service FQN
+const rondevu = await Rondevu.connect({
-const connection = await client.connect('alice', 'chat@1.0.0', {
+  apiUrl: string,          // Required: Signaling server URL
-  // Connection options
+  username?: string,       // Optional: your username (auto-generates anonymous if omitted)
-  maxReconnectAttempts: 10,     // optional, default: 10
+  keypair?: Keypair,       // Optional: reuse existing keypair
-  reconnectBackoffBase: 1000,   // optional, default: 1000ms
+  iceServers?: IceServerPreset | RTCIceServer[],  // Optional: preset or custom config
-  reconnectBackoffMax: 30000,   // optional, default: 30000ms
+  debug?: boolean          // Optional: enable debug logging (default: false)
-  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
+})
-  connectionTimeout: 30000,     // optional, default: 30000ms
-
-  // Message queuing
-  maxQueueSize: 1000,           // optional, default: 1000
-  maxMessageAge: 60000,         // optional, default: 60000ms
-
-  // WebRTC configuration
-  rtcConfig: {
-    iceServers: [
-      { urls: 'stun:stun.l.google.com:19302' }
-    ]
-  }
-});
-
-// Connect by UUID
-const connection2 = await client.connectByUuid('service-uuid-here', {
-  maxReconnectAttempts: 5
-});
-
-// Create channels before connecting
-const channel = connection.createChannel('main');
-const fileChannel = connection.createChannel('files', {
-  ordered: false,
-  maxRetransmits: 3
-});
-
-// Get existing channel
-const existingChannel = connection.getChannel('main');
-
-// Check connection state
-const state = connection.getState();
-// 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'failed' | 'closed'
-
-const isConnected = connection.isConnected();
-
-// Connect
-await connection.connect();
-
-// Close connection
-await connection.close();
 ```
 
-**Connection Events:**
+### Service Publishing
-```typescript
-connection.on('state', (newState, previousState) => {
-  console.log(`State: ${previousState} → ${newState}`);
-});
-
-connection.on('connected', () => {
-  console.log('Connected');
-});
-
-connection.on('reconnecting', (attempt, maxAttempts, delay) => {
-  console.log(`Reconnecting (${attempt}/${maxAttempts}) in ${delay}ms`);
-});
-
-connection.on('disconnected', () => {
-  console.log('Disconnected');
-});
-
-connection.on('failed', (error, permanent) => {
-  console.error('Connection failed:', error, 'Permanent:', permanent);
-});
-
-connection.on('closed', () => {
-  console.log('Connection closed');
-});
-```
-
-### Durable Channel API
 
 ```typescript
-const channel = connection.createChannel('chat', {
+await rondevu.publishService({
-  ordered: true,          // optional, default: true
+  service: string,        // e.g., 'chat:1.0.0' (username auto-appended)
-  maxRetransmits: undefined  // optional, for unordered channels
+  maxOffers: number,      // Maximum concurrent offers to maintain
-});
+  offerFactory?: OfferFactory,  // Optional: custom offer creation
+  ttl?: number           // Optional: offer lifetime in ms (default: 300000)
+})
 
-// Send data (queued if disconnected)
+await rondevu.startFilling()  // Start accepting connections
-channel.send('Hello!');
+rondevu.stopFilling()         // Stop and close all connections
-channel.send(new ArrayBuffer(1024));
-channel.send(new Blob(['data']));
-
-// Check state
-const state = channel.readyState;
-// 'connecting' | 'open' | 'closing' | 'closed'
-
-// Get buffered amount
-const buffered = channel.bufferedAmount;
-
-// Set buffered amount low threshold
-channel.bufferedAmountLowThreshold = 16 * 1024; // 16KB
-
-// Get queue size (for debugging)
-const queueSize = channel.getQueueSize();
-
-// Close channel
-channel.close();
 ```
 
-**Channel Events:**
+### Service Discovery
-```typescript
-channel.on('open', () => {
-  console.log('Channel open');
-});
-
-channel.on('message', (data) => {
-  console.log('Received:', data);
-});
-
-channel.on('error', (error) => {
-  console.error('Channel error:', error);
-});
-
-channel.on('close', () => {
-  console.log('Channel closed');
-});
-
-channel.on('bufferedAmountLow', () => {
-  console.log('Buffer drained, safe to send more');
-});
-
-channel.on('queueOverflow', (droppedCount) => {
-  console.warn(`Queue overflow: ${droppedCount} messages dropped`);
-});
-```
-
-## Configuration Options
-
-### Connection Configuration
 
 ```typescript
-interface DurableConnectionConfig {
+// Direct lookup (with username)
-  maxReconnectAttempts?: number;      // default: 10
+await rondevu.getService('chat:1.0.0@alice')
-  reconnectBackoffBase?: number;      // default: 1000 (1 second)
+
-  reconnectBackoffMax?: number;       // default: 30000 (30 seconds)
+// Random discovery (without username)
-  reconnectJitter?: number;           // default: 0.2 (±20%)
+await rondevu.discoverService('chat:1.0.0')
-  connectionTimeout?: number;         // default: 30000 (30 seconds)
+
-  maxQueueSize?: number;              // default: 1000 messages
+// Paginated discovery
-  maxMessageAge?: number;             // default: 60000 (1 minute)
+await rondevu.discoverServices('chat:1.0.0', limit, offset)
-  rtcConfig?: RTCConfiguration;
-}
 ```
 
-### Service Configuration
+### Connecting to Services
 
 ```typescript
-interface DurableServiceConfig extends DurableConnectionConfig {
+const connection = await rondevu.connectToService({
-  username: string;
+  serviceFqn?: string,     // Full FQN like 'chat:1.0.0@alice'
-  privateKey: string;
+  service?: string,        // Service without username (for discovery)
-  serviceFqn: string;
+  username?: string,       // Target username (combined with service)
-  isPublic?: boolean;                 // default: false
+  onConnection?: (context) => void,  // Called when data channel opens
-  metadata?: Record<string, any>;
+  rtcConfig?: RTCConfiguration  // Optional: override ICE servers
-  ttl?: number;                       // default: 300000 (5 minutes)
+})
-  ttlRefreshMargin?: number;          // default: 0.2 (refresh at 80%)
-  poolSize?: number;                  // default: 1
-  pollingInterval?: number;           // default: 2000 (2 seconds)
-}
 ```
 
+## Documentation
+
+📚 **[ADVANCED.md](./ADVANCED.md)** - Comprehensive guide including:
+- Detailed API reference for all methods
+- Type definitions and interfaces
+- Platform support (Browser & Node.js)
+- Advanced usage patterns
+- Username rules and service FQN format
+- Examples and migration guides
+
 ## Examples
 
-### Chat Application
+- [React Demo](https://github.com/xtr-dev/rondevu-demo) - Full browser UI ([live](https://ronde.vu))
-
-```typescript
-// Server
-const client = new Rondevu();
-await client.register();
-
-const claim = await client.usernames.claimUsername('alice');
-client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
-const keypair = client.usernames.loadKeypairFromStorage('alice');
-
-const service = await client.exposeService({
-  username: 'alice',
-  privateKey: keypair.privateKey,
-  serviceFqn: 'chat@1.0.0',
-  isPublic: true,
-  poolSize: 50,  // Handle 50 concurrent users
-  handler: (channel, connectionId) => {
-    console.log(`User ${connectionId} joined`);
-
-    channel.on('message', (data) => {
-      console.log(`[${connectionId}]: ${data}`);
-      // Broadcast to all users (implement your broadcast logic)
-    });
-
-    channel.on('close', () => {
-      console.log(`User ${connectionId} left`);
-    });
-  }
-});
-
-await service.start();
-
-// Client
-const client2 = new Rondevu();
-await client2.register();
-
-const connection = await client2.connect('alice', 'chat@1.0.0');
-const channel = connection.createChannel('chat');
-
-channel.on('message', (data) => {
-  console.log('Message:', data);
-});
-
-await connection.connect();
-channel.send('Hello everyone!');
-```
-
-### File Transfer with Progress
-
-```typescript
-// Server
-const service = await client.exposeService({
-  username: 'alice',
-  privateKey: keypair.privateKey,
-  serviceFqn: 'files@1.0.0',
-  handler: (channel, connectionId) => {
-    channel.on('message', async (data) => {
-      const request = JSON.parse(data);
-
-      if (request.action === 'download') {
-        const file = await fs.readFile(request.path);
-        const chunkSize = 16 * 1024; // 16KB chunks
-
-        for (let i = 0; i < file.byteLength; i += chunkSize) {
-          const chunk = file.slice(i, i + chunkSize);
-          channel.send(chunk);
-
-          // Wait for buffer to drain if needed
-          while (channel.bufferedAmount > 16 * 1024 * 1024) { // 16MB
-            await new Promise(resolve => setTimeout(resolve, 100));
-          }
-        }
-
-        channel.send(JSON.stringify({ done: true }));
-      }
-    });
-  }
-});
-
-await service.start();
-
-// Client
-const connection = await client.connect('alice', 'files@1.0.0');
-const channel = connection.createChannel('files');
-
-const chunks = [];
-channel.on('message', (data) => {
-  if (typeof data === 'string') {
-    const msg = JSON.parse(data);
-    if (msg.done) {
-      const blob = new Blob(chunks);
-      console.log('Download complete:', blob.size, 'bytes');
-    }
-  } else {
-    chunks.push(data);
-    console.log('Progress:', chunks.length * 16 * 1024, 'bytes');
-  }
-});
-
-await connection.connect();
-channel.send(JSON.stringify({ action: 'download', path: '/file.zip' }));
-```
-
-## Platform-Specific Setup
-
-### Modern Browsers
-Works out of the box - no additional setup needed.
-
-### Node.js 18+
-Native fetch is available, but you need WebRTC polyfills:
-
-```bash
-npm install wrtc
-```
-
-```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
-import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc';
-
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu',
-  RTCPeerConnection,
-  RTCSessionDescription,
-  RTCIceCandidate
-});
-```
-
-### Node.js < 18
-Install both fetch and WebRTC polyfills:
-
-```bash
-npm install node-fetch wrtc
-```
-
-```typescript
-import { Rondevu } from '@xtr-dev/rondevu-client';
-import fetch from 'node-fetch';
-import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate } from 'wrtc';
-
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu',
-  fetch: fetch as any,
-  RTCPeerConnection,
-  RTCSessionDescription,
-  RTCIceCandidate
-});
-```
-
-## TypeScript
-
-All types are exported:
-
-```typescript
-import type {
-  // Client types
-  Credentials,
-  RondevuOptions,
-
-  // Username types
-  UsernameCheckResult,
-  UsernameClaimResult,
-
-  // Durable connection types
-  DurableConnectionState,
-  DurableChannelState,
-  DurableConnectionConfig,
-  DurableChannelConfig,
-  DurableServiceConfig,
-  QueuedMessage,
-  DurableConnectionEvents,
-  DurableChannelEvents,
-  DurableServiceEvents,
-  ConnectionInfo,
-  ServiceInfo
-} from '@xtr-dev/rondevu-client';
-```
-
-## Migration from v0.8.x
-
-v0.9.0 is a **breaking change** that replaces the low-level APIs with high-level durable connections. See [MIGRATION.md](./MIGRATION.md) for detailed migration guide.
-
-**Key Changes:**
-- ❌ Removed: `client.services.*`, `client.discovery.*`, `client.createPeer()` (low-level APIs)
-- ✅ Added: `client.exposeService()`, `client.connect()`, `client.connectByUuid()` (durable APIs)
-- ✅ Changed: Focus on durable connections with automatic reconnection and message queuing
 
 ## License
 

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,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.9.2",
+  "version": "0.18.0",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,10 @@
   "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,14 +24,23 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.9.3"
+    "@eslint/js": "^9.39.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.6"
   },
   "files": [
     "dist",
     "README.md"
   ],
   "dependencies": {
-    "@noble/ed25519": "^3.0.0",
+    "@noble/ed25519": "^3.0.0"
-    "@xtr-dev/rondevu-client": "^0.9.2"
   }
 }

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 | null
+    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()
+
+        // Validate response is an array
+        if (!Array.isArray(results)) {
+            console.error('Invalid RPC batch response:', results)
+            throw new Error('Server returned invalid batch response (not an array)')
+        }
+
+        // Check response length matches request length
+        if (results.length !== requests.length) {
+            console.error(`Response length mismatch: expected ${requests.length}, got ${results.length}`)
+        }
+
+        return results.map((result, i) => {
+            if (!result || typeof result !== 'object') {
+                throw new Error(`Invalid response at index ${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
+    }
+
+    /**
+     * 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: RTCIceCandidateInit | null
+                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/connection-manager.ts

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

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-bus.ts

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

src/index.ts

@@ -3,14 +3,37 @@
  * WebRTC peer signaling client
  */
 
-export { ConnectionManager } from './connection-manager.js';
+export { Rondevu } from './rondevu.js'
-export { EventBus } from './event-bus.js';
+export { RondevuAPI } from './api.js'
+export { RpcBatcher } from './rpc-batcher.js'
+
+// Export crypto adapters
+export { WebCryptoAdapter } from './web-crypto-adapter.js'
+export { NodeCryptoAdapter } from './node-crypto-adapter.js'
 
 // Export types
 export type {
-  ConnectionIdentity,
+    Signaler,
-  ConnectionState,
+    Binnable,
-  ConnectionInterface,
+} from './types.js'
-  Connection,
+
-  QueueMessageOptions
+export type {
-} from './types.js';
+    Keypair,
+    OfferRequest,
+    ServiceRequest,
+    Service,
+    ServiceOffer,
+    IceCandidate,
+} from './api.js'
+
+export type {
+    RondevuOptions,
+    PublishServiceOptions,
+    ConnectToServiceOptions,
+    ConnectionContext,
+    OfferContext,
+    OfferFactory
+} from './rondevu.js'
+
+export type { CryptoAdapter } from './crypto-adapter.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/rondevu.ts

@@ -0,0 +1,914 @@
+import { RondevuAPI, Keypair, IceCandidate, BatcherOptions } from './api.js'
+import { CryptoAdapter } from './crypto-adapter.js'
+
+// ICE server preset names
+export type IceServerPreset = 'ipv4-turn' | 'hostname-turns' | 'google-stun' | 'relay-only'
+
+// ICE server presets
+export const ICE_SERVER_PRESETS: Record<IceServerPreset, RTCIceServer[]> = {
+    'ipv4-turn': [
+        { urls: 'stun:57.129.61.67:3478' },
+        {
+            urls: [
+                'turn:57.129.61.67:3478?transport=tcp',
+                'turn:57.129.61.67:3478?transport=udp',
+            ],
+            username: 'webrtcuser',
+            credential: 'supersecretpassword'
+        }
+    ],
+    'hostname-turns': [
+        { urls: 'stun:turn.share.fish:3478' },
+        {
+            urls: [
+                'turns:turn.share.fish:5349?transport=tcp',
+                'turns:turn.share.fish:5349?transport=udp',
+                'turn:turn.share.fish:3478?transport=tcp',
+                'turn:turn.share.fish:3478?transport=udp',
+            ],
+            username: 'webrtcuser',
+            credential: 'supersecretpassword'
+        }
+    ],
+    'google-stun': [
+        { urls: 'stun:stun.l.google.com:19302' },
+        { urls: 'stun:stun1.l.google.com:19302' }
+    ],
+    'relay-only': [
+        { urls: 'stun:57.129.61.67:3478' },
+        {
+            urls: [
+                'turn:57.129.61.67:3478?transport=tcp',
+                'turn:57.129.61.67:3478?transport=udp',
+            ],
+            username: 'webrtcuser',
+            credential: 'supersecretpassword',
+            // @ts-expect-error - iceTransportPolicy is valid but not in RTCIceServer type
+            iceTransportPolicy: 'relay'
+        }
+    ]
+}
+
+export interface RondevuOptions {
+    apiUrl: string
+    username?: string  // Optional, will generate anonymous if not provided
+    keypair?: Keypair  // Optional, will generate if not provided
+    cryptoAdapter?: CryptoAdapter  // Optional, defaults to WebCryptoAdapter
+    batching?: BatcherOptions | false  // Optional, defaults to enabled with default options
+    iceServers?: IceServerPreset | RTCIceServer[]  // Optional: preset name or custom STUN/TURN servers
+    debug?: boolean  // Optional: enable debug logging (default: false)
+    // WebRTC polyfills for Node.js environments (e.g., wrtc)
+    rtcPeerConnection?: typeof RTCPeerConnection
+    rtcIceCandidate?: typeof RTCIceCandidate
+}
+
+export interface OfferContext {
+    pc: RTCPeerConnection
+    dc?: RTCDataChannel
+    offer: RTCSessionDescriptionInit
+}
+
+export type OfferFactory = (rtcConfig: RTCConfiguration) => Promise<OfferContext>
+
+export interface PublishServiceOptions {
+    service: string // Service name and version (e.g., "chat:2.0.0") - username will be auto-appended
+    maxOffers: number  // Maximum number of concurrent offers to maintain
+    offerFactory?: OfferFactory  // Optional: custom offer creation (defaults to simple data channel)
+    ttl?: number  // Time-to-live for offers in milliseconds (default: 300000)
+}
+
+export interface ConnectionContext {
+    pc: RTCPeerConnection
+    dc: RTCDataChannel
+    serviceFqn: string
+    offerId: string
+    peerUsername: string
+}
+
+export interface ConnectToServiceOptions {
+    serviceFqn?: string  // Full FQN like 'chat:2.0.0@alice'
+    service?: string     // Service without username (for discovery)
+    username?: string    // Target username (combined with service)
+    onConnection?: (context: ConnectionContext) => void | Promise<void>  // Called when data channel opens
+    rtcConfig?: RTCConfiguration  // Optional: override default ICE servers
+}
+
+interface ActiveOffer {
+    offerId: string
+    serviceFqn: string
+    pc: RTCPeerConnection
+    dc?: RTCDataChannel
+    answered: boolean
+    createdAt: number
+}
+
+/**
+ * Rondevu - Complete WebRTC signaling client
+ *
+ * Provides a unified API for:
+ * - Implicit username claiming (auto-claimed on first authenticated request)
+ * - Service publishing with automatic signature generation
+ * - Service discovery (direct, random, paginated)
+ * - WebRTC signaling (offer/answer exchange, ICE relay)
+ * - Keypair management
+ *
+ * @example
+ * ```typescript
+ * // Create and initialize Rondevu instance with preset ICE servers
+ * const rondevu = await Rondevu.connect({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'alice',
+ *   iceServers: 'ipv4-turn'  // Use preset: 'ipv4-turn', 'hostname-turns', 'google-stun', or 'relay-only'
+ * })
+ *
+ * // Or use custom ICE servers
+ * const rondevu2 = await Rondevu.connect({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'bob',
+ *   iceServers: [
+ *     { urls: 'stun:stun.l.google.com:19302' },
+ *     { urls: 'turn:turn.example.com:3478', username: 'user', credential: 'pass' }
+ *   ]
+ * })
+ *
+ * // Publish a service with automatic offer management
+ * await rondevu.publishService({
+ *   service: 'chat:2.0.0',
+ *   maxOffers: 5,  // Maintain up to 5 concurrent offers
+ *   offerFactory: async (rtcConfig) => {
+ *     const pc = new RTCPeerConnection(rtcConfig)
+ *     const dc = pc.createDataChannel('chat')
+ *     const offer = await pc.createOffer()
+ *     await pc.setLocalDescription(offer)
+ *     return { pc, dc, offer }
+ *   }
+ * })
+ *
+ * // Start accepting connections (auto-fills offers and polls)
+ * await rondevu.startFilling()
+ *
+ * // Access active connections
+ * for (const offer of rondevu.getActiveOffers()) {
+ *   offer.dc?.addEventListener('message', (e) => console.log(e.data))
+ * }
+ *
+ * // Stop when done
+ * rondevu.stopFilling()
+ * ```
+ */
+export class Rondevu {
+    // Constants
+    private static readonly DEFAULT_TTL_MS = 300000  // 5 minutes
+    private static readonly POLLING_INTERVAL_MS = 1000  // 1 second
+
+    private api: RondevuAPI
+    private readonly apiUrl: string
+    private username: string
+    private keypair: Keypair
+    private usernameClaimed = false
+    private cryptoAdapter?: CryptoAdapter
+    private batchingOptions?: BatcherOptions | false
+    private iceServers: RTCIceServer[]
+    private debugEnabled: boolean
+    private rtcPeerConnection?: typeof RTCPeerConnection
+    private rtcIceCandidate?: typeof RTCIceCandidate
+
+    // Service management
+    private currentService: string | null = null
+    private maxOffers = 0
+    private offerFactory: OfferFactory | null = null
+    private ttl = Rondevu.DEFAULT_TTL_MS
+    private activeOffers = new Map<string, ActiveOffer>()
+
+    // Polling
+    private filling = false
+    private pollingInterval: ReturnType<typeof setInterval> | null = null
+    private lastPollTimestamp = 0
+
+    private constructor(
+        apiUrl: string,
+        username: string,
+        keypair: Keypair,
+        api: RondevuAPI,
+        iceServers: RTCIceServer[],
+        cryptoAdapter?: CryptoAdapter,
+        batchingOptions?: BatcherOptions | false,
+        debugEnabled = false,
+        rtcPeerConnection?: typeof RTCPeerConnection,
+        rtcIceCandidate?: typeof RTCIceCandidate
+    ) {
+        this.apiUrl = apiUrl
+        this.username = username
+        this.keypair = keypair
+        this.api = api
+        this.iceServers = iceServers
+        this.cryptoAdapter = cryptoAdapter
+        this.batchingOptions = batchingOptions
+        this.debugEnabled = debugEnabled
+        this.rtcPeerConnection = rtcPeerConnection
+        this.rtcIceCandidate = rtcIceCandidate
+
+        this.debug('Instance created:', {
+            username: this.username,
+            publicKey: this.keypair.publicKey,
+            hasIceServers: iceServers.length > 0,
+            batchingEnabled: batchingOptions !== false
+        })
+    }
+
+    /**
+     * Internal debug logging - only logs if debug mode is enabled
+     */
+    private debug(message: string, ...args: any[]): void {
+        if (this.debugEnabled) {
+            console.log(`[Rondevu] ${message}`, ...args)
+        }
+    }
+
+    /**
+     * Create and initialize a Rondevu client
+     *
+     * @example
+     * ```typescript
+     * const rondevu = await Rondevu.connect({
+     *   apiUrl: 'https://api.ronde.vu',
+     *   username: 'alice'
+     * })
+     * ```
+     */
+    static async connect(options: RondevuOptions): Promise<Rondevu> {
+        const username = options.username || Rondevu.generateAnonymousUsername()
+
+        // Apply WebRTC polyfills to global scope if provided (Node.js environments)
+        if (options.rtcPeerConnection) {
+            globalThis.RTCPeerConnection = options.rtcPeerConnection as any
+        }
+        if (options.rtcIceCandidate) {
+            globalThis.RTCIceCandidate = options.rtcIceCandidate as any
+        }
+
+        // Handle preset string or custom array
+        let iceServers: RTCIceServer[]
+        if (typeof options.iceServers === 'string') {
+            iceServers = ICE_SERVER_PRESETS[options.iceServers]
+        } else {
+            iceServers = options.iceServers || [
+                { urls: 'stun:stun.l.google.com:19302' }
+            ]
+        }
+
+        if (options.debug) {
+            console.log('[Rondevu] Connecting:', {
+                username,
+                hasKeypair: !!options.keypair,
+                iceServers: iceServers.length,
+                batchingEnabled: options.batching !== false
+            })
+        }
+
+        // Generate keypair if not provided
+        let keypair = options.keypair
+        if (!keypair) {
+            if (options.debug) console.log('[Rondevu] Generating new keypair...')
+            keypair = await RondevuAPI.generateKeypair(options.cryptoAdapter)
+            if (options.debug) console.log('[Rondevu] Generated keypair, publicKey:', keypair.publicKey)
+        } else {
+            if (options.debug) console.log('[Rondevu] Using existing keypair, publicKey:', keypair.publicKey)
+        }
+
+        // Create API instance
+        const api = new RondevuAPI(
+            options.apiUrl,
+            username,
+            keypair,
+            options.cryptoAdapter,
+            options.batching
+        )
+        if (options.debug) console.log('[Rondevu] Created API instance')
+
+        return new Rondevu(
+            options.apiUrl,
+            username,
+            keypair,
+            api,
+            iceServers,
+            options.cryptoAdapter,
+            options.batching,
+            options.debug || false,
+            options.rtcPeerConnection,
+            options.rtcIceCandidate
+        )
+    }
+
+    /**
+     * Generate an anonymous username with timestamp and random component
+     */
+    private static generateAnonymousUsername(): string {
+        const timestamp = Date.now().toString(36)
+        const random = Array.from(crypto.getRandomValues(new Uint8Array(3)))
+            .map(b => b.toString(16).padStart(2, '0')).join('')
+        return `anon-${timestamp}-${random}`
+    }
+
+    // ============================================
+    // Username Management
+    // ============================================
+
+    /**
+     * Check if username has been claimed (checks with server)
+     */
+    async isUsernameClaimed(): Promise<boolean> {
+        try {
+            const claimed = await this.api.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
+    // ============================================
+
+    /**
+     * Default offer factory - creates a simple data channel connection
+     */
+    private async defaultOfferFactory(rtcConfig: RTCConfiguration): Promise<OfferContext> {
+        const pc = new RTCPeerConnection(rtcConfig)
+        const dc = pc.createDataChannel('default')
+
+        const offer = await pc.createOffer()
+        await pc.setLocalDescription(offer)
+
+        return { pc, dc, offer }
+    }
+
+    /**
+     * Publish a service with automatic offer management
+     * Call startFilling() to begin accepting connections
+     *
+     * @example
+     * ```typescript
+     * await rondevu.publishService({
+     *   service: 'chat:2.0.0',
+     *   maxOffers: 5
+     * })
+     * await rondevu.startFilling()
+     * ```
+     */
+    async publishService(options: PublishServiceOptions): Promise<void> {
+        const { service, maxOffers, offerFactory, ttl } = options
+
+        this.currentService = service
+        this.maxOffers = maxOffers
+        this.offerFactory = offerFactory || this.defaultOfferFactory.bind(this)
+        this.ttl = ttl || Rondevu.DEFAULT_TTL_MS
+
+        this.debug(`Publishing service: ${service} with maxOffers: ${maxOffers}`)
+        this.usernameClaimed = true
+    }
+
+    /**
+     * Set up ICE candidate handler to send candidates to the server
+     */
+    private setupIceCandidateHandler(
+        pc: RTCPeerConnection,
+        serviceFqn: string,
+        offerId: string
+    ): void {
+        pc.onicecandidate = async (event) => {
+            if (event.candidate) {
+                try {
+                    // Handle both browser and Node.js (wrtc) environments
+                    // Browser: candidate.toJSON() exists
+                    // Node.js wrtc: candidate is already a plain object
+                    const candidateData = typeof event.candidate.toJSON === 'function'
+                        ? event.candidate.toJSON()
+                        : event.candidate
+
+                    await this.api.addOfferIceCandidates(
+                        serviceFqn,
+                        offerId,
+                        [candidateData]
+                    )
+                } catch (err) {
+                    console.error('[Rondevu] Failed to send ICE candidate:', err)
+                }
+            }
+        }
+    }
+
+    /**
+     * Create a single offer and publish it to the server
+     */
+    private async createOffer(): Promise<void> {
+        if (!this.currentService || !this.offerFactory) {
+            throw new Error('Service not published. Call publishService() first.')
+        }
+
+        const rtcConfig: RTCConfiguration = {
+            iceServers: this.iceServers
+        }
+
+        this.debug('Creating new offer...')
+
+        // Create the offer using the factory
+        const { pc, dc, offer } = await this.offerFactory(rtcConfig)
+
+        // Auto-append username to service
+        const serviceFqn = `${this.currentService}@${this.username}`
+
+        // Publish to server
+        const result = await this.api.publishService({
+            serviceFqn,
+            offers: [{ sdp: offer.sdp! }],
+            ttl: this.ttl,
+            signature: '',
+            message: '',
+        })
+
+        const offerId = result.offers[0].offerId
+
+        // Store active offer
+        this.activeOffers.set(offerId, {
+            offerId,
+            serviceFqn,
+            pc,
+            dc,
+            answered: false,
+            createdAt: Date.now()
+        })
+
+        this.debug(`Offer created: ${offerId}`)
+
+        // Set up ICE candidate handler
+        this.setupIceCandidateHandler(pc, serviceFqn, offerId)
+
+        // Monitor connection state
+        pc.onconnectionstatechange = () => {
+            this.debug(`Offer ${offerId} connection state: ${pc.connectionState}`)
+
+            if (pc.connectionState === 'failed' || pc.connectionState === 'closed') {
+                this.activeOffers.delete(offerId)
+                this.fillOffers()  // Try to replace failed offer
+            }
+        }
+    }
+
+    /**
+     * Fill offers to reach maxOffers count
+     */
+    private async fillOffers(): Promise<void> {
+        if (!this.filling || !this.currentService) return
+
+        const currentCount = this.activeOffers.size
+        const needed = this.maxOffers - currentCount
+
+        this.debug(`Filling offers: current=${currentCount}, needed=${needed}`)
+
+        for (let i = 0; i < needed; i++) {
+            try {
+                await this.createOffer()
+            } catch (err) {
+                console.error('[Rondevu] Failed to create offer:', err)
+            }
+        }
+    }
+
+    /**
+     * Poll for answers and ICE candidates (internal use for automatic offer management)
+     */
+    private async pollInternal(): Promise<void> {
+        if (!this.filling) return
+
+        try {
+            const result = await this.api.poll(this.lastPollTimestamp)
+
+            // Process answers
+            for (const answer of result.answers) {
+                const activeOffer = this.activeOffers.get(answer.offerId)
+                if (activeOffer && !activeOffer.answered) {
+                    this.debug(`Received answer for offer ${answer.offerId}`)
+
+                    await activeOffer.pc.setRemoteDescription({
+                        type: 'answer',
+                        sdp: answer.sdp
+                    })
+
+                    activeOffer.answered = true
+                    this.lastPollTimestamp = answer.answeredAt
+
+                    // Create replacement offer
+                    this.fillOffers()
+                }
+            }
+
+            // Process ICE candidates
+            for (const [offerId, candidates] of Object.entries(result.iceCandidates)) {
+                const activeOffer = this.activeOffers.get(offerId)
+                if (activeOffer) {
+                    const answererCandidates = candidates.filter(c => c.role === 'answerer')
+
+                    for (const item of answererCandidates) {
+                        if (item.candidate) {
+                            await activeOffer.pc.addIceCandidate(new RTCIceCandidate(item.candidate))
+                            this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt)
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            console.error('[Rondevu] Polling error:', err)
+        }
+    }
+
+    /**
+     * Start filling offers and polling for answers/ICE
+     * Call this after publishService() to begin accepting connections
+     */
+    async startFilling(): Promise<void> {
+        if (this.filling) {
+            this.debug('Already filling')
+            return
+        }
+
+        if (!this.currentService) {
+            throw new Error('No service published. Call publishService() first.')
+        }
+
+        this.debug('Starting offer filling and polling')
+        this.filling = true
+
+        // Fill initial offers
+        await this.fillOffers()
+
+        // Start polling
+        this.pollingInterval = setInterval(() => {
+            this.pollInternal()
+        }, Rondevu.POLLING_INTERVAL_MS)
+    }
+
+    /**
+     * Stop filling offers and polling
+     * Closes all active peer connections
+     */
+    stopFilling(): void {
+        this.debug('Stopping offer filling and polling')
+        this.filling = false
+
+        // Stop polling
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval)
+            this.pollingInterval = null
+        }
+
+        // Close all active connections
+        for (const [offerId, offer] of this.activeOffers.entries()) {
+            this.debug(`Closing offer ${offerId}`)
+            offer.dc?.close()
+            offer.pc.close()
+        }
+
+        this.activeOffers.clear()
+    }
+
+    /**
+     * Resolve the full service FQN from various input options
+     * Supports direct FQN, service+username, or service discovery
+     */
+    private async resolveServiceFqn(options: ConnectToServiceOptions): Promise<string> {
+        const { serviceFqn, service, username } = options
+
+        if (serviceFqn) {
+            return serviceFqn
+        } else if (service && username) {
+            return `${service}@${username}`
+        } else if (service) {
+            // Discovery mode - get random service
+            this.debug(`Discovering service: ${service}`)
+            const discovered = await this.discoverService(service)
+            return discovered.serviceFqn
+        } else {
+            throw new Error('Either serviceFqn or service must be provided')
+        }
+    }
+
+    /**
+     * Start polling for remote ICE candidates
+     * Returns the polling interval ID
+     */
+    private startIcePolling(
+        pc: RTCPeerConnection,
+        serviceFqn: string,
+        offerId: string
+    ): ReturnType<typeof setInterval> {
+        let lastIceTimestamp = 0
+
+        return setInterval(async () => {
+            try {
+                const result = await this.api.getOfferIceCandidates(
+                    serviceFqn,
+                    offerId,
+                    lastIceTimestamp
+                )
+                for (const item of result.candidates) {
+                    if (item.candidate) {
+                        await pc.addIceCandidate(new RTCIceCandidate(item.candidate))
+                        lastIceTimestamp = item.createdAt
+                    }
+                }
+            } catch (err) {
+                console.error('[Rondevu] Failed to poll ICE candidates:', err)
+            }
+        }, Rondevu.POLLING_INTERVAL_MS)
+    }
+
+    /**
+     * Automatically connect to a service (answerer side)
+     * Handles the entire connection flow: discovery, WebRTC setup, answer exchange, ICE candidates
+     *
+     * @example
+     * ```typescript
+     * // Connect to specific user
+     * const connection = await rondevu.connectToService({
+     *   serviceFqn: 'chat:2.0.0@alice',
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *     dc.addEventListener('message', (e) => console.log(e.data))
+     *     dc.addEventListener('open', () => dc.send('Hello!'))
+     *   }
+     * })
+     *
+     * // Discover random service
+     * const connection = await rondevu.connectToService({
+     *   service: 'chat:2.0.0',
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *   }
+     * })
+     * ```
+     */
+    async connectToService(options: ConnectToServiceOptions): Promise<ConnectionContext> {
+        const { onConnection, rtcConfig } = options
+
+        // Validate inputs
+        if (options.serviceFqn !== undefined && typeof options.serviceFqn === 'string' && !options.serviceFqn.trim()) {
+            throw new Error('serviceFqn cannot be empty')
+        }
+        if (options.service !== undefined && typeof options.service === 'string' && !options.service.trim()) {
+            throw new Error('service cannot be empty')
+        }
+        if (options.username !== undefined && typeof options.username === 'string' && !options.username.trim()) {
+            throw new Error('username cannot be empty')
+        }
+
+        // Determine the full service FQN
+        const fqn = await this.resolveServiceFqn(options)
+        this.debug(`Connecting to service: ${fqn}`)
+
+        // 1. Get service offer
+        const serviceData = await this.api.getService(fqn)
+        this.debug(`Found service from @${serviceData.username}`)
+
+        // 2. Create RTCPeerConnection
+        const rtcConfiguration = rtcConfig || {
+            iceServers: this.iceServers
+        }
+        const pc = new RTCPeerConnection(rtcConfiguration)
+
+        // 3. Set up data channel handler (answerer receives it from offerer)
+        let dc: RTCDataChannel | null = null
+        const dataChannelPromise = new Promise<RTCDataChannel>((resolve) => {
+            pc.ondatachannel = (event) => {
+                this.debug('Data channel received from offerer')
+                dc = event.channel
+                resolve(dc)
+            }
+        })
+
+        // 4. Set up ICE candidate exchange
+        this.setupIceCandidateHandler(pc, serviceData.serviceFqn, serviceData.offerId)
+
+        // 5. Poll for remote ICE candidates
+        const icePollInterval = this.startIcePolling(pc, serviceData.serviceFqn, serviceData.offerId)
+
+        // 6. Set remote description
+        await pc.setRemoteDescription({
+            type: 'offer',
+            sdp: serviceData.sdp
+        })
+
+        // 7. Create and send answer
+        const answer = await pc.createAnswer()
+        await pc.setLocalDescription(answer)
+        await this.api.answerOffer(
+            serviceData.serviceFqn,
+            serviceData.offerId,
+            answer.sdp!
+        )
+
+        // 8. Wait for data channel to be established
+        dc = await dataChannelPromise
+
+        // Create connection context
+        const context: ConnectionContext = {
+            pc,
+            dc,
+            serviceFqn: serviceData.serviceFqn,
+            offerId: serviceData.offerId,
+            peerUsername: serviceData.username
+        }
+
+        // 9. Set up connection state monitoring
+        pc.onconnectionstatechange = () => {
+            this.debug(`Connection state: ${pc.connectionState}`)
+            if (pc.connectionState === 'failed' || pc.connectionState === 'closed') {
+                clearInterval(icePollInterval)
+            }
+        }
+
+        // 10. Wait for data channel to open and call onConnection
+        if (dc.readyState === 'open') {
+            this.debug('Data channel already open')
+            if (onConnection) {
+                await onConnection(context)
+            }
+        } else {
+            await new Promise<void>((resolve) => {
+                dc!.addEventListener('open', async () => {
+                    this.debug('Data channel opened')
+                    if (onConnection) {
+                        await onConnection(context)
+                    }
+                    resolve()
+                })
+            })
+        }
+
+        return context
+    }
+
+    // ============================================
+    // 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.api.getService(serviceFqn)
+    }
+
+    /**
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
+     */
+    async discoverService(serviceVersion: string): Promise<{
+        serviceId: string
+        username: string
+        serviceFqn: string
+        offerId: string
+        sdp: string
+        createdAt: number
+        expiresAt: number
+    }> {
+        return await this.api.getService(serviceVersion)
+    }
+
+    /**
+     * Discover multiple available services with pagination
+     * Example: chat:1.0.0 (without @username)
+     */
+    async discoverServices(serviceVersion: string, limit: number = 10, offset: number = 0): Promise<{
+        services: Array<{
+            serviceId: string
+            username: string
+            serviceFqn: string
+            offerId: string
+            sdp: string
+            createdAt: number
+            expiresAt: number
+        }>
+        count: number
+        limit: number
+        offset: number
+    }> {
+        return await this.api.getService(serviceVersion, { limit, offset })
+    }
+
+    // ============================================
+    // WebRTC Signaling
+    // ============================================
+
+    /**
+     * Post answer SDP to specific offer
+     */
+    async postOfferAnswer(serviceFqn: string, offerId: string, sdp: string): Promise<{
+        success: boolean
+        offerId: string
+    }> {
+        await this.api.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.api.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: RTCIceCandidateInit | null
+            role: 'offerer' | 'answerer'
+            peerId: string
+            createdAt: number
+        }>>
+    }> {
+        return await this.api.poll(since)
+    }
+
+    /**
+     * Add ICE candidates to specific offer
+     */
+    async addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
+        count: number
+        offerId: string
+    }> {
+        return await this.api.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.api.getOfferIceCandidates(serviceFqn, offerId, since)
+    }
+
+    // ============================================
+    // Utility Methods
+    // ============================================
+
+    /**
+     * Get the current keypair (for backup/storage)
+     */
+    getKeypair(): Keypair {
+        return this.keypair
+    }
+
+    /**
+     * Get the username
+     */
+    getUsername(): string {
+        return this.username
+    }
+
+    /**
+     * Get the public key
+     */
+    getPublicKey(): string {
+        return this.keypair.publicKey
+    }
+
+    /**
+     * Access to underlying API for advanced operations
+     * @deprecated Use direct methods on Rondevu instance instead
+     */
+    getAPIPublic(): RondevuAPI {
+        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

@@ -1,24 +1,20 @@
 /**
- * Core connection types
+ * Core signaling types
  */
 
-export interface ConnectionIdentity {
+/**
-    id: string;
+ * Cleanup function returned by listener methods
-    hostUsername: string;
+ */
-}
+export type Binnable = () => void
 
-export interface ConnectionState {
+/**
-    state: 'connected' | 'disconnected' | 'connecting';
+ * Signaler interface for WebRTC offer/answer/ICE exchange
-    lastActive: number;
+ */
+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>
 }
-
-export interface QueueMessageOptions {
-    expiresAt?: number;
-}
-
-export interface ConnectionInterface {
-    queueMessage(message: string | ArrayBuffer, options?: QueueMessageOptions): void;
-    sendMessage(message: string | ArrayBuffer): void;
-}
-
-export type Connection = ConnectionIdentity & ConnectionState & ConnectionInterface;

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))
+    }
+}