Release v0.17.0: Phase 1 & 2 improvements, documentation restructuring

Remove Node.js Host Guide references
Remove all references to NODE_HOST_GUIDE.md and test-connect.js: - README.md: Removed Node.js Host Guide section and links - ADVANCED.md: Simplified Node.js example, removed guide references Keep inline Node.js example code for reference. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2025-12-14 04:43:24 +00:00 · 2025-12-13 13:18:43 +01:00 · 2025-12-12 23:24:56 +01:00 · 2025-12-12 23:18:50 +01:00 · 2025-12-12 23:14:54 +01:00 · 2025-12-12 23:10:57 +01:00
17 changed files with 5347 additions and 857 deletions
--- a/.prettierrc.json
+++ b/.prettierrc.json
@@ -0,0 +1,9 @@
+{
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 4,
+    "useTabs": false,
+    "trailingComma": "es5",
+    "printWidth": 100,
+    "arrowParens": "avoid"
+}
--- a/ADVANCED.md
+++ b/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()
+```
--- a/EVENTBUS_EXAMPLE.md
+++ b/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
--- a/README.md
+++ b/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
- **Message Queuing**: Messages sent during disconnections are queued and flushed on reconnect
- **Durable Channels**: RTCDataChannel wrappers that survive connection drops
- **TTL Auto-Refresh**: Services automatically republish before expiration
- **Username Claiming**: Cryptographic ownership with Ed25519 signatures
- **Service Publishing**: Package-style naming (com.example.chat@1.0.0)
+- **Username Claiming**: Secure ownership with Ed25519 signatures
+- **Anonymous Users**: Auto-generated anonymous usernames for quick testing
+- **Service Publishing**: Publish services with multiple offers for connection pooling
+- **Service Discovery**: Direct lookup, random discovery, or paginated search
+- **Efficient Batch Polling**: Single endpoint for answers and ICE candidates (50% fewer requests)
+- **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
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
-await client.register();
+// 1. Connect to Rondevu
+const rondevu = await Rondevu.connect({
+  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)
-const claim = await client.usernames.claimUsername('alice');
-client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
+// 2. Publish service with automatic offer management
+await rondevu.publishService({
+  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
-const keypair = client.usernames.loadKeypairFromStorage('alice');
+    dc.addEventListener('open', () => {
+      console.log('Connection opened!')
+      dc.send('Hello from Alice!')
+    })

-const service = await client.exposeService({
-  username: 'alice',
-  privateKey: keypair.privateKey,
-  serviceFqn: 'chat@1.0.0',
-  isPublic: true,
-  poolSize: 10,  // Handle 10 concurrent connections
-  handler: (channel, connectionId) => {
-    console.log(`📡 New connection: ${connectionId}`);
+    dc.addEventListener('message', (e) => {
+      console.log('Received:', e.data)
+    })

-    channel.on('message', (data) => {
-      console.log('📥 Received:', data);
-      channel.send(`Echo: ${data}`);
-    });
-
-    channel.on('close', () => {
-      console.log(`👋 Connection ${connectionId} closed`);
-    });
+    const offer = await pc.createOffer()
+    await pc.setLocalDescription(offer)
+    return { pc, dc, offer }
  }
-});
+})

-// Start the service
-const info = await service.start();
-console.log(`Service published with UUID: ${info.uuid}`);
-console.log('Waiting for connections...');
-
-// Later: stop the service
-await service.stop();
+// 3. Start accepting connections
+await rondevu.startFilling()
 ```

-### 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
-const client = new Rondevu({ baseUrl: 'https://api.ronde.vu' });
-await client.register();
+// 1. Connect to Rondevu
+const rondevu = await Rondevu.connect({
+  apiUrl: 'https://api.ronde.vu',
+  username: 'bob',
+  iceServers: 'ipv4-turn'
+})

-// Connect to Alice's service
-const connection = await client.connect('alice', 'chat@1.0.0', {
-  maxReconnectAttempts: 5
-});
+// 2. Connect to service (automatic WebRTC setup)
+const connection = await rondevu.connectToService({
+  serviceFqn: 'chat:1.0.0@alice',
+  onConnection: ({ dc, peerUsername }) => {
+    console.log('Connected to', peerUsername)

-// Create a durable channel
-const channel = connection.createChannel('main');
+    dc.addEventListener('message', (e) => {
+      console.log('Received:', e.data)
+    })

-channel.on('message', (data) => {
-  console.log('📥 Received:', data);
-});
-
-channel.on('open', () => {
-  console.log('✅ Channel open');
-  channel.send('Hello Alice!');
-});
-
-// Listen for connection events
-connection.on('connected', () => {
-  console.log('🎉 Connected to Alice');
-});
-
-connection.on('reconnecting', (attempt, max, delay) => {
-  console.log(`🔄 Reconnecting... (${attempt}/${max}, retry in ${delay}ms)`);
-});
-
-connection.on('disconnected', () => {
-  console.log('🔌 Disconnected');
-});
-
-connection.on('failed', (error) => {
-  console.error('❌ Connection failed permanently:', error);
-});
-
-// Establish the connection
-await connection.connect();
-
-// Messages sent during disconnection are automatically queued
-channel.send('This will be queued if disconnected');
-
-// Later: close the connection
-await connection.close();
-```
-
-## Core Concepts
-
-### DurableConnection
-
-Manages WebRTC peer lifecycle with automatic reconnection:
- Automatically reconnects when connection drops
- Exponential backoff with jitter (1s → 2s → 4s → 8s → ... max 30s)
- Configurable max retry attempts (default: 10)
- Manages multiple DurableChannel instances
-
-### DurableChannel
-
-Wraps RTCDataChannel with message queuing:
- Queues messages during disconnection
- Flushes queue on reconnection
- Configurable queue size and message age limits
- RTCDataChannel-compatible API with event emitters
-
-### DurableService
-
-Server-side service with TTL auto-refresh:
- Automatically republishes service before TTL expires
- Creates DurableConnection for each incoming peer
- Manages connection pool for multiple simultaneous connections
-
-## API Reference
-
-### Main Client
-
-```typescript
-const client = new Rondevu({
-  baseUrl: 'https://api.ronde.vu',  // optional, default shown
-  credentials?: { peerId, secret },  // optional, skip registration
-  fetch?: customFetch,               // optional, for Node.js < 18
-  RTCPeerConnection?: RTCPeerConnection,  // optional, for Node.js
-  RTCSessionDescription?: RTCSessionDescription,
-  RTCIceCandidate?: RTCIceCandidate
-});
-
-// Register and get credentials
-const creds = await client.register();
-// { peerId: '...', secret: '...' }
-
-// Check if authenticated
-client.isAuthenticated(); // boolean
-
-// Get current credentials
-client.getCredentials(); // { peerId, secret } | undefined
-```
-
-### Username API
-
-```typescript
-// Check username availability
-const check = await client.usernames.checkUsername('alice');
-// { available: true } or { available: false, expiresAt: number, publicKey: string }
-
-// Claim username with new keypair
-const claim = await client.usernames.claimUsername('alice');
-// { username, publicKey, privateKey, claimedAt, expiresAt }
-
-// Save keypair to localStorage
-client.usernames.saveKeypairToStorage('alice', claim.publicKey, claim.privateKey);
-
-// Load keypair from localStorage
-const keypair = client.usernames.loadKeypairFromStorage('alice');
-// { publicKey, privateKey } | null
-```
-
-**Username Rules:**
- Format: Lowercase alphanumeric + dash (`a-z`, `0-9`, `-`)
- Length: 3-32 characters
- Pattern: `^[a-z0-9][a-z0-9-]*[a-z0-9]$`
- Validity: 365 days from claim/last use
- Ownership: Secured by Ed25519 public key
-
-### Durable Service API
-
-```typescript
-// Expose a durable service
-const service = await client.exposeService({
-  username: 'alice',
-  privateKey: keypair.privateKey,
-  serviceFqn: 'chat@1.0.0',
-
-  // Service options
-  isPublic: true,               // optional, default: false
-  metadata: { version: '1.0' }, // optional
-  ttl: 300000,                  // optional, default: 5 minutes
-  ttlRefreshMargin: 0.2,        // optional, refresh at 80% of TTL
-
-  // Connection pooling
-  poolSize: 10,                 // optional, default: 1
-  pollingInterval: 2000,        // optional, default: 2000ms
-
-  // Connection options (applied to incoming connections)
-  maxReconnectAttempts: 10,     // optional, default: 10
-  reconnectBackoffBase: 1000,   // optional, default: 1000ms
-  reconnectBackoffMax: 30000,   // optional, default: 30000ms
-  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
-  connectionTimeout: 30000,     // optional, default: 30000ms
-
-  // Message queuing
-  maxQueueSize: 1000,           // optional, default: 1000
-  maxMessageAge: 60000,         // optional, default: 60000ms (1 minute)
-
-  // WebRTC configuration
-  rtcConfig: {
-    iceServers: [
-      { 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}`);
-    });
+    dc.addEventListener('open', () => {
+      dc.send('Hello from Bob!')
+    })
  }
-});
+})

-// Start the service
-const info = await service.start();
-// { serviceId: '...', uuid: '...', expiresAt: 1234567890 }
-
-// Get active connections
-const connections = service.getActiveConnections();
-// ['conn-123', 'conn-456']
-
-// Get service info
-const serviceInfo = service.getServiceInfo();
-// { serviceId: '...', uuid: '...', expiresAt: 1234567890 } | null
-
-// Stop the service
-await service.stop();
+// Access connection
+connection.dc.send('Another message')
+connection.pc.close()  // Close when done
 ```

-**Service Events:**
-```typescript
-service.on('published', (serviceId, uuid) => {
-  console.log(`Service published: ${uuid}`);
-});
+## Core API

-service.on('connection', (connectionId) => {
-  console.log(`New connection: ${connectionId}`);
-});
-
-service.on('disconnection', (connectionId) => {
-  console.log(`Connection closed: ${connectionId}`);
-});
-
-service.on('ttl-refreshed', (expiresAt) => {
-  console.log(`TTL refreshed, expires at: ${new Date(expiresAt)}`);
-});
-
-service.on('error', (error, context) => {
-  console.error(`Service error (${context}):`, error);
-});
-
-service.on('closed', () => {
-  console.log('Service stopped');
-});
-```
-
-### Durable Connection API
+### Rondevu.connect()

 ```typescript
-// Connect by username and service FQN
-const connection = await client.connect('alice', 'chat@1.0.0', {
-  // Connection options
-  maxReconnectAttempts: 10,     // optional, default: 10
-  reconnectBackoffBase: 1000,   // optional, default: 1000ms
-  reconnectBackoffMax: 30000,   // optional, default: 30000ms
-  reconnectJitter: 0.2,         // optional, default: 0.2 (±20%)
-  connectionTimeout: 30000,     // optional, default: 30000ms
-
-  // Message queuing
-  maxQueueSize: 1000,           // optional, default: 1000
-  maxMessageAge: 60000,         // optional, default: 60000ms
-
-  // WebRTC configuration
-  rtcConfig: {
-    iceServers: [
-      { urls: 'stun:stun.l.google.com:19302' }
-    ]
-  }
-});
-
-// Connect by 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();
+const rondevu = await Rondevu.connect({
+  apiUrl: string,          // Required: Signaling server URL
+  username?: string,       // Optional: your username (auto-generates anonymous if omitted)
+  keypair?: Keypair,       // Optional: reuse existing keypair
+  iceServers?: IceServerPreset | RTCIceServer[],  // Optional: preset or custom config
+  debug?: boolean          // Optional: enable debug logging (default: false)
+})
 ```

-**Connection Events:**
-```typescript
-connection.on('state', (newState, previousState) => {
-  console.log(`State: ${previousState} → ${newState}`);
-});
-
-connection.on('connected', () => {
-  console.log('Connected');
-});
-
-connection.on('reconnecting', (attempt, maxAttempts, delay) => {
-  console.log(`Reconnecting (${attempt}/${maxAttempts}) in ${delay}ms`);
-});
-
-connection.on('disconnected', () => {
-  console.log('Disconnected');
-});
-
-connection.on('failed', (error, permanent) => {
-  console.error('Connection failed:', error, 'Permanent:', permanent);
-});
-
-connection.on('closed', () => {
-  console.log('Connection closed');
-});
-```
-
-### Durable Channel API
+### Service Publishing

 ```typescript
-const channel = connection.createChannel('chat', {
-  ordered: true,          // optional, default: true
-  maxRetransmits: undefined  // optional, for unordered channels
-});
+await rondevu.publishService({
+  service: string,        // e.g., 'chat:1.0.0' (username auto-appended)
+  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)
-channel.send('Hello!');
-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();
+await rondevu.startFilling()  // Start accepting connections
+rondevu.stopFilling()         // Stop and close all connections
 ```

-**Channel Events:**
-```typescript
-channel.on('open', () => {
-  console.log('Channel open');
-});
-
-channel.on('message', (data) => {
-  console.log('Received:', data);
-});
-
-channel.on('error', (error) => {
-  console.error('Channel error:', error);
-});
-
-channel.on('close', () => {
-  console.log('Channel closed');
-});
-
-channel.on('bufferedAmountLow', () => {
-  console.log('Buffer drained, safe to send more');
-});
-
-channel.on('queueOverflow', (droppedCount) => {
-  console.warn(`Queue overflow: ${droppedCount} messages dropped`);
-});
-```
-
-## Configuration Options
-
-### Connection Configuration
+### Service Discovery

 ```typescript
-interface DurableConnectionConfig {
-  maxReconnectAttempts?: number;      // default: 10
-  reconnectBackoffBase?: number;      // default: 1000 (1 second)
-  reconnectBackoffMax?: number;       // default: 30000 (30 seconds)
-  reconnectJitter?: number;           // default: 0.2 (±20%)
-  connectionTimeout?: number;         // default: 30000 (30 seconds)
-  maxQueueSize?: number;              // default: 1000 messages
-  maxMessageAge?: number;             // default: 60000 (1 minute)
-  rtcConfig?: RTCConfiguration;
-}
+// Direct lookup (with username)
+await rondevu.getService('chat:1.0.0@alice')
+
+// Random discovery (without username)
+await rondevu.discoverService('chat:1.0.0')
+
+// Paginated discovery
+await rondevu.discoverServices('chat:1.0.0', limit, offset)
 ```

-### Service Configuration
+### Connecting to Services

 ```typescript
-interface DurableServiceConfig extends DurableConnectionConfig {
-  username: string;
-  privateKey: string;
-  serviceFqn: string;
-  isPublic?: boolean;                 // default: false
-  metadata?: Record<string, any>;
-  ttl?: number;                       // default: 300000 (5 minutes)
-  ttlRefreshMargin?: number;          // default: 0.2 (refresh at 80%)
-  poolSize?: number;                  // default: 1
-  pollingInterval?: number;           // default: 2000 (2 seconds)
-}
+const connection = await rondevu.connectToService({
+  serviceFqn?: string,     // Full FQN like 'chat:1.0.0@alice'
+  service?: string,        // Service without username (for discovery)
+  username?: string,       // Target username (combined with service)
+  onConnection?: (context) => void,  // Called when data channel opens
+  rtcConfig?: RTCConfiguration  // Optional: override ICE servers
+})
 ```

+## 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
-
-```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
+- [React Demo](https://github.com/xtr-dev/rondevu-demo) - Full browser UI ([live](https://ronde.vu))

 ## License

--- a/eslint.config.js
+++ b/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'],
+    },
+]
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@xtr-dev/rondevu-client",
-  "version": "0.9.2",
+  "version": "0.17.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",
-    "@xtr-dev/rondevu-client": "^0.9.2"
+    "@noble/ed25519": "^3.0.0"
  }
 }
--- a/src/api.ts
+++ b/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,
+        }
+    }
+}
--- a/src/connection-manager.ts
+++ b/src/connection-manager.ts
@@ -1,9 +0,0 @@
-/**
- * ConnectionManager - Manages WebRTC peer connections
- */
-
-export class ConnectionManager {
-  constructor() {
-    // TODO: Initialize connection manager
-  }
-}
--- a/src/crypto-adapter.ts
+++ b/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
+}
--- a/src/event-bus.ts
+++ b/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());
-  }
-}
--- a/src/index.ts
+++ b/src/index.ts
@@ -3,14 +3,37 @@
 * WebRTC peer signaling client
 */

-export { ConnectionManager } from './connection-manager.js';
-export { EventBus } from './event-bus.js';
+export { Rondevu } from './rondevu.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,
-  ConnectionState,
-  ConnectionInterface,
-  Connection,
-  QueueMessageOptions
-} from './types.js';
+    Signaler,
+    Binnable,
+} from './types.js'
+
+export type {
+    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'
+
--- a/src/node-crypto-adapter.ts
+++ b/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))
+    }
+}
--- a/src/rondevu.ts
+++ b/src/rondevu.ts
@@ -0,0 +1,888 @@
+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)
+}
+
+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
+
+    // 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
+    ) {
+        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.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()
+
+        // 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
+        )
+    }
+
+    /**
+     * 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 {
+                    await this.api.addOfferIceCandidates(
+                        serviceFqn,
+                        offerId,
+                        [event.candidate.toJSON()]
+                    )
+                } 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
+    }
+}
--- a/src/rpc-batcher.ts
+++ b/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 = []
+    }
+}
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,24 +1,20 @@
 /**
- * Core connection types
+ * Core signaling types
 */

-export interface ConnectionIdentity {
-    id: string;
-    hostUsername: string;
-}
+/**
+ * Cleanup function returned by listener methods
+ */
+export type Binnable = () => void

-export interface ConnectionState {
-    state: 'connected' | 'disconnected' | 'connecting';
-    lastActive: number;
+/**
+ * Signaler interface for WebRTC offer/answer/ICE exchange
+ */
+export interface Signaler {
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>
+    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable
+    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable
+    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable
+    setOffer(offer: RTCSessionDescriptionInit): Promise<void>
+    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>
 }
-
-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;
--- a/src/web-crypto-adapter.ts
+++ b/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))
+    }
+}