@xtr-dev/rondevu-client 0.18.9 → 0.18.10

package/dist/index.d.ts

@@ -5,18 +5,9 @@
 export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
 export { RondevuAPI } from './api.js';
 export { RpcBatcher } from './rpc-batcher.js';
-export { RondevuConnection } from './connection.js';
-export { OffererConnection } from './offerer-connection.js';
-export { AnswererConnection } from './answerer-connection.js';
-export { ExponentialBackoff } from './exponential-backoff.js';
-export { MessageBuffer } from './message-buffer.js';
 export { WebCryptoAdapter } from './web-crypto-adapter.js';
 export { NodeCryptoAdapter } from './node-crypto-adapter.js';
 export type { Signaler, Binnable, } from './types.js';
 export type { Keypair, OfferRequest, ServiceRequest, Service, ServiceOffer, IceCandidate, } from './api.js';
 export type { RondevuOptions, PublishServiceOptions, ConnectToServiceOptions, ConnectionContext, OfferContext, OfferFactory, ActiveOffer, FindServiceOptions, ServiceResult, PaginatedServiceResult } from './rondevu.js';
 export type { CryptoAdapter } from './crypto-adapter.js';
-export type { ConnectionConfig, } from './connection-config.js';
-export type { ConnectionState, BufferedMessage, ReconnectInfo, StateChangeInfo, ConnectionEventMap, ConnectionEventName, ConnectionEventArgs, } from './connection-events.js';
-export type { OffererOptions, } from './offerer-connection.js';
-export type { AnswererOptions, } from './answerer-connection.js';

package/dist/index.js

@@ -5,13 +5,6 @@
 export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
 export { RondevuAPI } from './api.js';
 export { RpcBatcher } from './rpc-batcher.js';
-// Export connection classes
-export { RondevuConnection } from './connection.js';
-export { OffererConnection } from './offerer-connection.js';
-export { AnswererConnection } from './answerer-connection.js';
-// Export utilities
-export { ExponentialBackoff } from './exponential-backoff.js';
-export { MessageBuffer } from './message-buffer.js';
 // Export crypto adapters
 export { WebCryptoAdapter } from './web-crypto-adapter.js';
 export { NodeCryptoAdapter } from './node-crypto-adapter.js';

package/dist/rondevu.d.ts

@@ -1,9 +1,6 @@
 import { RondevuAPI, Keypair, IceCandidate, BatcherOptions } from './api.js';
 import { CryptoAdapter } from './crypto-adapter.js';
 import { EventEmitter } from 'eventemitter3';
-import { OffererConnection } from './offerer-connection.js';
-import { AnswererConnection } from './answerer-connection.js';
-import { ConnectionConfig } from './connection-config.js';
 export type IceServerPreset = 'ipv4-turn' | 'hostname-turns' | 'google-stun' | 'relay-only';
 export declare const ICE_SERVER_PRESETS: Record<IceServerPreset, RTCIceServer[]>;
 export interface RondevuOptions {
@@ -35,7 +32,6 @@ export interface PublishServiceOptions {
     maxOffers: number;
     offerFactory?: OfferFactory;
     ttl?: number;
-    connectionConfig?: Partial<ConnectionConfig>;
 }
 export interface ConnectionContext {
     pc: RTCPeerConnection;
@@ -48,8 +44,8 @@ export interface ConnectToServiceOptions {
     serviceFqn?: string;
     service?: string;
     username?: string;
+    onConnection?: (context: ConnectionContext) => void | Promise<void>;
     rtcConfig?: RTCConfiguration;
-    connectionConfig?: Partial<ConnectionConfig>;
 }
 export interface ActiveOffer {
     offerId: string;
@@ -105,13 +101,14 @@ export declare class ConnectionError extends RondevuError {
     constructor(message: string, context?: Record<string, any>);
 }
 /**
- * Rondevu - Complete WebRTC signaling client with durable connections
+ * Rondevu - Complete WebRTC signaling client
  *
- * v1.0.0 introduces breaking changes:
- * - connectToService() now returns AnswererConnection instead of ConnectionContext
- * - Automatic reconnection and message buffering built-in
- * - Connection objects expose .send() method instead of raw DataChannel
- * - Rich event system for connection lifecycle (connected, disconnected, reconnecting, etc.)
+ * 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
@@ -122,39 +119,39 @@ export declare class ConnectionError extends RondevuError {
  *   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
+ *   maxOffers: 5,  // Maintain up to 5 concurrent offers
+ *   offerFactory: async (pc) => {
+ *     // pc is created by Rondevu with ICE handlers already attached
+ *     const dc = pc.createDataChannel('chat')
+ *     const offer = await pc.createOffer()
+ *     await pc.setLocalDescription(offer)
+ *     return { dc, offer }
+ *   }
  * })
  *
  * // Start accepting connections (auto-fills offers and polls)
  * await rondevu.startFilling()
  *
- * // Listen for connections (v1.0.0 API)
- * rondevu.on('connection:opened', (offerId, connection) => {
- *   connection.on('connected', () => console.log('Connected!'))
- *   connection.on('message', (data) => console.log('Received:', data))
- *   connection.send('Hello!')
- * })
- *
- * // Connect to a service (v1.0.0 - returns AnswererConnection)
- * const connection = await rondevu.connectToService({
- *   serviceFqn: 'chat:2.0.0@bob'
- * })
- *
- * connection.on('connected', () => {
- *   console.log('Connected!')
- *   connection.send('Hello!')
- * })
- *
- * connection.on('message', (data) => {
- *   console.log('Received:', data)
- * })
+ * // Access active connections
+ * for (const offer of rondevu.getActiveOffers()) {
+ *   offer.dc?.addEventListener('message', (e) => console.log(e.data))
+ * }
  *
- * connection.on('reconnecting', (attempt) => {
- *   console.log(`Reconnecting, attempt ${attempt}`)
- * })
+ * // Stop when done
+ * rondevu.stopFilling()
  * ```
  */
 export declare class Rondevu extends EventEmitter {
@@ -175,12 +172,11 @@ export declare class Rondevu extends EventEmitter {
     private maxOffers;
     private offerFactory;
     private ttl;
-    private activeConnections;
-    private connectionConfig?;
+    private activeOffers;
     private filling;
-    private fillingSemaphore;
     private pollingInterval;
     private lastPollTimestamp;
+    private isPolling;
     private constructor();
     /**
      * Internal debug logging - only logs if debug mode is enabled
@@ -219,22 +215,26 @@ export declare class Rondevu extends EventEmitter {
      * ```typescript
      * await rondevu.publishService({
      *   service: 'chat:2.0.0',
-     *   maxOffers: 5,
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
-     *   }
+     *   maxOffers: 5
      * })
      * await rondevu.startFilling()
      * ```
      */
     publishService(options: PublishServiceOptions): Promise<void>;
     /**
-     * Create a single offer and publish it to the server using OffererConnection
+     * Set up ICE candidate handler to send candidates to the server
+     *
+     * Note: This is used by connectToService() where the offerId is already known.
+     * For createOffer(), we use inline ICE handling with early candidate queuing
+     * since the offerId isn't available until after the factory completes.
+     */
+    private setupIceCandidateHandler;
+    /**
+     * Create a single offer and publish it to the server
      */
     private createOffer;
     /**
-     * Fill offers to reach maxOffers count with semaphore protection
+     * Fill offers to reach maxOffers count
      */
     private fillOffers;
     /**
@@ -259,7 +259,7 @@ export declare class Rondevu extends EventEmitter {
     /**
      * Check if an offer is currently connected
      * @param offerId - The offer ID to check
-     * @returns True if the offer exists and is connected
+     * @returns True if the offer exists and has been answered
      */
     isConnected(offerId: string): boolean;
     /**
@@ -283,45 +283,41 @@ export declare class Rondevu extends EventEmitter {
      */
     private resolveServiceFqn;
     /**
-     * Connect to a service (answerer side) - v1.0.0 API
-     * Returns an AnswererConnection with automatic reconnection and buffering
-     *
-     * BREAKING CHANGE: This now returns AnswererConnection instead of ConnectionContext
+     * Start polling for remote ICE candidates
+     * Returns the polling interval ID
+     */
+    private startIcePolling;
+    /**
+     * 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',
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *     dc.addEventListener('message', (e) => console.log(e.data))
+     *     dc.addEventListener('open', () => dc.send('Hello!'))
      *   }
      * })
      *
-     * connection.on('connected', () => {
-     *   console.log('Connected!')
-     *   connection.send('Hello!')
-     * })
-     *
-     * connection.on('message', (data) => {
-     *   console.log('Received:', data)
-     * })
-     *
-     * connection.on('reconnecting', (attempt) => {
-     *   console.log(`Reconnecting, attempt ${attempt}`)
-     * })
-     *
      * // Discover random service
      * const connection = await rondevu.connectToService({
-     *   service: 'chat:2.0.0'
+     *   service: 'chat:2.0.0',
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *   }
      * })
      * ```
      */
-    connectToService(options: ConnectToServiceOptions): Promise<AnswererConnection>;
+    connectToService(options: ConnectToServiceOptions): Promise<ConnectionContext>;
     /**
      * Find a service - unified discovery method
      *
+     * Replaces getService(), discoverService(), and discoverServices() with a single method.
+     *
      * @param serviceFqn - Service identifier (e.g., 'chat:1.0.0' or 'chat:1.0.0@alice')
      * @param options - Discovery options
      *
@@ -403,15 +399,6 @@ export declare class Rondevu extends EventEmitter {
      * Get the public key
      */
     getPublicKey(): string;
-    /**
-     * Get active connections (for offerer side)
-     */
-    getActiveConnections(): Map<string, OffererConnection>;
-    /**
-     * Get all active offers (legacy compatibility)
-     * @deprecated Use getActiveConnections() instead
-     */
-    getActiveOffers(): ActiveOffer[];
     /**
      * Access to underlying API for advanced operations
      * @deprecated Use direct methods on Rondevu instance instead

package/dist/rondevu.js

@@ -1,7 +1,5 @@
 import { RondevuAPI } from './api.js';
 import { EventEmitter } from 'eventemitter3';
-import { OffererConnection } from './offerer-connection.js';
-import { AnswererConnection } from './answerer-connection.js';
 // ICE server presets
 export const ICE_SERVER_PRESETS = {
     'ipv4-turn': [
@@ -88,13 +86,14 @@ export class ConnectionError extends RondevuError {
     }
 }
 /**
- * Rondevu - Complete WebRTC signaling client with durable connections
+ * Rondevu - Complete WebRTC signaling client
  *
- * v1.0.0 introduces breaking changes:
- * - connectToService() now returns AnswererConnection instead of ConnectionContext
- * - Automatic reconnection and message buffering built-in
- * - Connection objects expose .send() method instead of raw DataChannel
- * - Rich event system for connection lifecycle (connected, disconnected, reconnecting, etc.)
+ * 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
@@ -105,39 +104,39 @@ export class ConnectionError extends RondevuError {
  *   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
+ *   maxOffers: 5,  // Maintain up to 5 concurrent offers
+ *   offerFactory: async (pc) => {
+ *     // pc is created by Rondevu with ICE handlers already attached
+ *     const dc = pc.createDataChannel('chat')
+ *     const offer = await pc.createOffer()
+ *     await pc.setLocalDescription(offer)
+ *     return { dc, offer }
+ *   }
  * })
  *
  * // Start accepting connections (auto-fills offers and polls)
  * await rondevu.startFilling()
  *
- * // Listen for connections (v1.0.0 API)
- * rondevu.on('connection:opened', (offerId, connection) => {
- *   connection.on('connected', () => console.log('Connected!'))
- *   connection.on('message', (data) => console.log('Received:', data))
- *   connection.send('Hello!')
- * })
+ * // Access active connections
+ * for (const offer of rondevu.getActiveOffers()) {
+ *   offer.dc?.addEventListener('message', (e) => console.log(e.data))
+ * }
  *
- * // Connect to a service (v1.0.0 - returns AnswererConnection)
- * const connection = await rondevu.connectToService({
- *   serviceFqn: 'chat:2.0.0@bob'
- * })
- *
- * connection.on('connected', () => {
- *   console.log('Connected!')
- *   connection.send('Hello!')
- * })
- *
- * connection.on('message', (data) => {
- *   console.log('Received:', data)
- * })
- *
- * connection.on('reconnecting', (attempt) => {
- *   console.log(`Reconnecting, attempt ${attempt}`)
- * })
+ * // Stop when done
+ * rondevu.stopFilling()
  * ```
  */
 export class Rondevu extends EventEmitter {
@@ -149,12 +148,12 @@ export class Rondevu extends EventEmitter {
         this.maxOffers = 0;
         this.offerFactory = null;
         this.ttl = Rondevu.DEFAULT_TTL_MS;
-        this.activeConnections = new Map();
+        this.activeOffers = new Map();
         // Polling
         this.filling = false;
-        this.fillingSemaphore = false; // Semaphore to prevent concurrent fillOffers calls
         this.pollingInterval = null;
         this.lastPollTimestamp = 0;
+        this.isPolling = false; // Guard against concurrent poll execution
         this.apiUrl = apiUrl;
         this.username = username;
         this.keypair = keypair;
@@ -285,27 +284,49 @@ export class Rondevu extends EventEmitter {
      * ```typescript
      * await rondevu.publishService({
      *   service: 'chat:2.0.0',
-     *   maxOffers: 5,
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
-     *   }
+     *   maxOffers: 5
      * })
      * await rondevu.startFilling()
      * ```
      */
     async publishService(options) {
-        const { service, maxOffers, offerFactory, ttl, connectionConfig } = options;
+        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.connectionConfig = connectionConfig;
         this.debug(`Publishing service: ${service} with maxOffers: ${maxOffers}`);
         this.usernameClaimed = true;
     }
     /**
-     * Create a single offer and publish it to the server using OffererConnection
+     * Set up ICE candidate handler to send candidates to the server
+     *
+     * Note: This is used by connectToService() where the offerId is already known.
+     * For createOffer(), we use inline ICE handling with early candidate queuing
+     * since the offerId isn't available until after the factory completes.
+     */
+    setupIceCandidateHandler(pc, serviceFqn, offerId) {
+        pc.onicecandidate = async (event) => {
+            if (event.candidate) {
+                try {
+                    // Handle both browser and Node.js (wrtc) environments
+                    // Browser: candidate.toJSON() exists
+                    // Node.js wrtc: candidate is already a plain object
+                    const candidateData = typeof event.candidate.toJSON === 'function'
+                        ? event.candidate.toJSON()
+                        : event.candidate;
+                    // Emit local ICE candidate event
+                    this.emit('ice:candidate:local', offerId, candidateData);
+                    await this.api.addOfferIceCandidates(serviceFqn, offerId, [candidateData]);
+                }
+                catch (err) {
+                    console.error('[Rondevu] Failed to send ICE candidate:', err);
+                }
+            }
+        };
+    }
+    /**
+     * Create a single offer and publish it to the server
      */
     async createOffer() {
         if (!this.currentService || !this.offerFactory) {
@@ -317,9 +338,42 @@ export class Rondevu extends EventEmitter {
         // Auto-append username to service
         const serviceFqn = `${this.currentService}@${this.username}`;
         this.debug('Creating new offer...');
-        // 1. Create RTCPeerConnection using factory (for now, keep compatibility)
+        // 1. Create the RTCPeerConnection - Rondevu controls this to set up handlers early
         const pc = new RTCPeerConnection(rtcConfig);
-        // 2. Call the factory to create offer
+        // 2. Set up ICE candidate handler with queuing BEFORE the factory runs
+        // This ensures we capture all candidates, even those generated immediately
+        // when setLocalDescription() is called in the factory
+        const earlyIceCandidates = [];
+        let offerId;
+        pc.onicecandidate = async (event) => {
+            if (event.candidate) {
+                // Handle both browser and Node.js (wrtc) environments
+                const candidateData = typeof event.candidate.toJSON === 'function'
+                    ? event.candidate.toJSON()
+                    : event.candidate;
+                // Emit local ICE candidate event
+                if (offerId) {
+                    this.emit('ice:candidate:local', offerId, candidateData);
+                }
+                if (offerId) {
+                    // We have the offerId, send directly
+                    try {
+                        await this.api.addOfferIceCandidates(serviceFqn, offerId, [candidateData]);
+                    }
+                    catch (err) {
+                        console.error('[Rondevu] Failed to send ICE candidate:', err);
+                    }
+                }
+                else {
+                    // Queue for later - we don't have the offerId yet
+                    this.debug('Queuing early ICE candidate');
+                    earlyIceCandidates.push(candidateData);
+                }
+            }
+        };
+        // 3. Call the factory with the pc - factory creates data channel and offer
+        // When factory calls setLocalDescription(), ICE gathering starts and
+        // candidates are captured by the handler we set up above
         let dc;
         let offer;
         try {
@@ -328,10 +382,11 @@ export class Rondevu extends EventEmitter {
             offer = factoryResult.offer;
         }
         catch (err) {
+            // Clean up the connection if factory fails
             pc.close();
             throw err;
         }
-        // 3. Publish to server to get offerId
+        // 4. Publish to server to get offerId
         const result = await this.api.publishService({
             serviceFqn,
             offers: [{ sdp: offer.sdp }],
@@ -339,68 +394,61 @@ export class Rondevu extends EventEmitter {
             signature: '',
             message: '',
         });
-        const offerId = result.offers[0].offerId;
-        // 4. Create OffererConnection instance with already-created PC and DC
-        const connection = new OffererConnection({
-            api: this.api,
-            serviceFqn,
+        offerId = result.offers[0].offerId;
+        // 5. Store active offer
+        this.activeOffers.set(offerId, {
             offerId,
-            pc, // Pass the peer connection from factory
-            dc, // Pass the data channel from factory
-            config: {
-                ...this.connectionConfig,
-                debug: this.debugEnabled,
-            },
-        });
-        // Setup connection event handlers
-        connection.on('connected', () => {
-            this.debug(`Connection established for offer ${offerId}`);
-            this.emit('connection:opened', offerId, connection);
-        });
-        connection.on('failed', (error) => {
-            this.debug(`Connection failed for offer ${offerId}:`, error);
-            this.activeConnections.delete(offerId);
-            this.fillOffers(); // Replace failed offer
-        });
-        connection.on('closed', () => {
-            this.debug(`Connection closed for offer ${offerId}`);
-            this.activeConnections.delete(offerId);
-            this.fillOffers(); // Replace closed offer
+            serviceFqn,
+            pc,
+            dc,
+            answered: false,
+            createdAt: Date.now()
         });
-        // Store active connection
-        this.activeConnections.set(offerId, connection);
-        // Initialize the connection
-        await connection.initialize();
         this.debug(`Offer created: ${offerId}`);
         this.emit('offer:created', offerId, serviceFqn);
+        // Set up data channel open handler (offerer side)
+        if (dc) {
+            dc.onopen = () => {
+                this.debug(`Data channel opened for offer ${offerId}`);
+                this.emit('connection:opened', offerId, dc);
+            };
+        }
+        // 6. Send any queued early ICE candidates
+        if (earlyIceCandidates.length > 0) {
+            this.debug(`Sending ${earlyIceCandidates.length} early ICE candidates`);
+            try {
+                await this.api.addOfferIceCandidates(serviceFqn, offerId, earlyIceCandidates);
+            }
+            catch (err) {
+                console.error('[Rondevu] Failed to send early ICE candidates:', err);
+            }
+        }
+        // 7. Monitor connection state
+        pc.onconnectionstatechange = () => {
+            this.debug(`Offer ${offerId} connection state: ${pc.connectionState}`);
+            if (pc.connectionState === 'failed' || pc.connectionState === 'closed') {
+                this.emit('connection:closed', offerId);
+                this.activeOffers.delete(offerId);
+                this.fillOffers(); // Try to replace failed offer
+            }
+        };
     }
     /**
-     * Fill offers to reach maxOffers count with semaphore protection
+     * Fill offers to reach maxOffers count
      */
     async fillOffers() {
         if (!this.filling || !this.currentService)
             return;
-        // Semaphore to prevent concurrent fills
-        if (this.fillingSemaphore) {
-            this.debug('fillOffers already in progress, skipping');
-            return;
-        }
-        this.fillingSemaphore = true;
-        try {
-            const currentCount = this.activeConnections.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);
-                }
+        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);
             }
-        }
-        finally {
-            this.fillingSemaphore = false;
         }
     }
     /**
@@ -409,20 +457,41 @@ export class Rondevu extends EventEmitter {
     async pollInternal() {
         if (!this.filling)
             return;
+        // Prevent concurrent poll execution to avoid duplicate answer processing
+        if (this.isPolling) {
+            this.debug('Poll already in progress, skipping');
+            return;
+        }
+        this.isPolling = true;
         try {
             const result = await this.api.poll(this.lastPollTimestamp);
-            // Process answers - delegate to OffererConnections
+            // Process answers
             for (const answer of result.answers) {
-                const connection = this.activeConnections.get(answer.offerId);
-                if (connection) {
-                    try {
-                        await connection.processAnswer(answer.sdp, answer.answererId);
-                        this.lastPollTimestamp = Math.max(this.lastPollTimestamp, answer.answeredAt);
-                        // Create replacement offer
-                        this.fillOffers();
-                    }
-                    catch (err) {
-                        this.debug(`Failed to process answer for offer ${answer.offerId}:`, err);
+                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;
+                    this.emit('offer:answered', answer.offerId, answer.answererId);
+                    // 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) {
+                            this.emit('ice:candidate:remote', offerId, item.candidate, item.role);
+                            await activeOffer.pc.addIceCandidate(new RTCIceCandidate(item.candidate));
+                            this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
+                        }
                     }
                 }
             }
@@ -430,6 +499,9 @@ export class Rondevu extends EventEmitter {
         catch (err) {
             console.error('[Rondevu] Polling error:', err);
         }
+        finally {
+            this.isPolling = false;
+        }
     }
     /**
      * Start filling offers and polling for answers/ICE
@@ -459,34 +531,35 @@ export class Rondevu extends EventEmitter {
     stopFilling() {
         this.debug('Stopping offer filling and polling');
         this.filling = false;
-        this.fillingSemaphore = false;
+        this.isPolling = false; // Reset polling guard
         // Stop polling
         if (this.pollingInterval) {
             clearInterval(this.pollingInterval);
             this.pollingInterval = null;
         }
         // Close all active connections
-        for (const [offerId, connection] of this.activeConnections.entries()) {
-            this.debug(`Closing connection ${offerId}`);
-            connection.close();
+        for (const [offerId, offer] of this.activeOffers.entries()) {
+            this.debug(`Closing offer ${offerId}`);
+            offer.dc?.close();
+            offer.pc.close();
         }
-        this.activeConnections.clear();
+        this.activeOffers.clear();
     }
     /**
      * Get the count of active offers
      * @returns Number of active offers
      */
     getOfferCount() {
-        return this.activeConnections.size;
+        return this.activeOffers.size;
     }
     /**
      * Check if an offer is currently connected
      * @param offerId - The offer ID to check
-     * @returns True if the offer exists and is connected
+     * @returns True if the offer exists and has been answered
      */
     isConnected(offerId) {
-        const connection = this.activeConnections.get(offerId);
-        return connection ? connection.getState() === 'connected' : false;
+        const offer = this.activeOffers.get(offerId);
+        return offer ? offer.answered : false;
     }
     /**
      * Disconnect all active offers
@@ -494,11 +567,12 @@ export class Rondevu extends EventEmitter {
      */
     async disconnectAll() {
         this.debug('Disconnecting all offers');
-        for (const [offerId, connection] of this.activeConnections.entries()) {
-            this.debug(`Closing connection ${offerId}`);
-            connection.close();
+        for (const [offerId, offer] of this.activeOffers.entries()) {
+            this.debug(`Closing offer ${offerId}`);
+            offer.dc?.close();
+            offer.pc.close();
         }
-        this.activeConnections.clear();
+        this.activeOffers.clear();
     }
     /**
      * Get the current service status
@@ -507,7 +581,7 @@ export class Rondevu extends EventEmitter {
     getServiceStatus() {
         return {
             active: this.currentService !== null,
-            offerCount: this.activeConnections.size,
+            offerCount: this.activeOffers.size,
             maxOffers: this.maxOffers,
             filling: this.filling
         };
@@ -535,43 +609,54 @@ export class Rondevu extends EventEmitter {
         }
     }
     /**
-     * Connect to a service (answerer side) - v1.0.0 API
-     * Returns an AnswererConnection with automatic reconnection and buffering
-     *
-     * BREAKING CHANGE: This now returns AnswererConnection instead of ConnectionContext
+     * Start polling for remote ICE candidates
+     * Returns the polling interval ID
+     */
+    startIcePolling(pc, serviceFqn, offerId) {
+        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) {
+                        this.emit('ice:candidate:remote', offerId, item.candidate, item.role);
+                        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',
-     *   connectionConfig: {
-     *     reconnectEnabled: true,
-     *     bufferEnabled: true
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *     dc.addEventListener('message', (e) => console.log(e.data))
+     *     dc.addEventListener('open', () => dc.send('Hello!'))
      *   }
      * })
      *
-     * connection.on('connected', () => {
-     *   console.log('Connected!')
-     *   connection.send('Hello!')
-     * })
-     *
-     * connection.on('message', (data) => {
-     *   console.log('Received:', data)
-     * })
-     *
-     * connection.on('reconnecting', (attempt) => {
-     *   console.log(`Reconnecting, attempt ${attempt}`)
-     * })
-     *
      * // Discover random service
      * const connection = await rondevu.connectToService({
-     *   service: 'chat:2.0.0'
+     *   service: 'chat:2.0.0',
+     *   onConnection: ({ dc, peerUsername }) => {
+     *     console.log('Connected to', peerUsername)
+     *   }
      * })
      * ```
      */
     async connectToService(options) {
-        const { rtcConfig, connectionConfig } = options;
+        const { onConnection, rtcConfig } = options;
         // Validate inputs
         if (options.serviceFqn !== undefined && typeof options.serviceFqn === 'string' && !options.serviceFqn.trim()) {
             throw new Error('serviceFqn cannot be empty');
@@ -585,28 +670,73 @@ export class Rondevu extends EventEmitter {
         // Determine the full service FQN
         const fqn = await this.resolveServiceFqn(options);
         this.debug(`Connecting to service: ${fqn}`);
-        // Get service offer
+        // 1. Get service offer
         const serviceData = await this.api.getService(fqn);
         this.debug(`Found service from @${serviceData.username}`);
-        // Create RTCConfiguration
+        // 2. Create RTCPeerConnection
         const rtcConfiguration = rtcConfig || {
             iceServers: this.iceServers
         };
-        // Create AnswererConnection
-        const connection = new AnswererConnection({
-            api: this.api,
+        const pc = new RTCPeerConnection(rtcConfiguration);
+        // 3. Set up data channel handler (answerer receives it from offerer)
+        let dc = null;
+        const dataChannelPromise = new Promise((resolve) => {
+            pc.ondatachannel = (event) => {
+                this.debug('Data channel received from offerer');
+                dc = event.channel;
+                this.emit('connection:opened', serviceData.offerId, dc);
+                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 = {
+            pc,
+            dc,
             serviceFqn: serviceData.serviceFqn,
             offerId: serviceData.offerId,
-            offerSdp: serviceData.sdp,
-            rtcConfig: rtcConfiguration,
-            config: {
-                ...connectionConfig,
-                debug: this.debugEnabled,
-            },
-        });
-        // Initialize the connection
-        await connection.initialize();
-        return connection;
+            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((resolve) => {
+                dc.addEventListener('open', async () => {
+                    this.debug('Data channel opened');
+                    if (onConnection) {
+                        await onConnection(context);
+                    }
+                    resolve();
+                });
+            });
+        }
+        return context;
     }
     // ============================================
     // Service Discovery
@@ -614,6 +744,8 @@ export class Rondevu extends EventEmitter {
     /**
      * Find a service - unified discovery method
      *
+     * Replaces getService(), discoverService(), and discoverServices() with a single method.
+     *
      * @param serviceFqn - Service identifier (e.g., 'chat:1.0.0' or 'chat:1.0.0@alice')
      * @param options - Discovery options
      *
@@ -702,34 +834,6 @@ export class Rondevu extends EventEmitter {
     getPublicKey() {
         return this.keypair.publicKey;
     }
-    /**
-     * Get active connections (for offerer side)
-     */
-    getActiveConnections() {
-        return this.activeConnections;
-    }
-    /**
-     * Get all active offers (legacy compatibility)
-     * @deprecated Use getActiveConnections() instead
-     */
-    getActiveOffers() {
-        const offers = [];
-        for (const [offerId, connection] of this.activeConnections.entries()) {
-            const pc = connection.getPeerConnection();
-            const dc = connection.getDataChannel();
-            if (pc) {
-                offers.push({
-                    offerId,
-                    serviceFqn: this.currentService ? `${this.currentService}@${this.username}` : '',
-                    pc,
-                    dc: dc || undefined,
-                    answered: connection.getState() === 'connected',
-                    createdAt: Date.now(),
-                });
-            }
-        }
-        return offers;
-    }
     /**
      * Access to underlying API for advanced operations
      * @deprecated Use direct methods on Rondevu instance instead

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.18.9",
-  "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
+  "version": "0.18.10",
+  "description": "TypeScript client for Rondevu WebRTC signaling with username-based discovery",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",