@xtr-dev/rondevu-client 0.20.1 → 0.21.3

package/dist/connections/answerer.js

@@ -8,9 +8,10 @@ import { ConnectionState } from './events.js';
  */
 export class AnswererConnection extends RondevuConnection {
     constructor(options) {
-        super(options.rtcConfig, options.config);
+        super(options.rtcConfig, options.config, options.webrtcAdapter);
         this.api = options.api;
-        this.serviceFqn = options.serviceFqn;
+        this.ownerUsername = options.ownerUsername;
+        this.tags = options.tags;
         this.offerId = options.offerId;
         this.offerSdp = options.offerSdp;
     }
@@ -25,7 +26,7 @@ export class AnswererConnection extends RondevuConnection {
             throw new Error('Peer connection not created');
         // Setup ondatachannel handler BEFORE setting remote description
         // This is critical to avoid race conditions
-        this.pc.ondatachannel = (event) => {
+        this.pc.ondatachannel = event => {
             this.debug('Received data channel');
             this.dc = event.channel;
             this.setupDataChannelHandlers(this.dc);
@@ -43,7 +44,9 @@ export class AnswererConnection extends RondevuConnection {
         await this.pc.setLocalDescription(answer);
         this.debug('Answer created, sending to server');
         // Send answer to server
-        await this.api.answerOffer(this.serviceFqn, this.offerId, answer.sdp);
+        await this.api.answerOffer(this.offerId, answer.sdp);
+        // Note: ICE candidate polling is handled by PollingManager
+        // Candidates are received via handleRemoteIceCandidates()
         this.debug('Answer sent successfully');
     }
     /**
@@ -54,14 +57,14 @@ export class AnswererConnection extends RondevuConnection {
         // For answerer, we add ICE candidates to the offer
         // The server will make them available for the offerer to poll
         this.api
-            .addOfferIceCandidates(this.serviceFqn, this.offerId, [
+            .addOfferIceCandidates(this.offerId, [
             {
                 candidate: candidate.candidate,
                 sdpMLineIndex: candidate.sdpMLineIndex,
                 sdpMid: candidate.sdpMid,
             },
         ])
-            .catch((error) => {
+            .catch(error => {
             this.debug('Failed to send ICE candidate:', error);
         });
     }
@@ -72,10 +75,10 @@ export class AnswererConnection extends RondevuConnection {
         return this.api;
     }
     /**
-     * Get the service FQN
+     * Get the owner username
      */
-    getServiceFqn() {
-        return this.serviceFqn;
+    getOwnerUsername() {
+        return this.ownerUsername;
     }
     /**
      * Answerers accept ICE candidates from offerers only
@@ -84,11 +87,11 @@ export class AnswererConnection extends RondevuConnection {
         return 'offerer';
     }
     /**
-     * Attempt to reconnect
+     * Attempt to reconnect to the same user
      */
     attemptReconnect() {
-        this.debug('Attempting to reconnect');
-        // For answerer, we need to fetch a new offer and create a new answer
+        this.debug(`Attempting to reconnect to ${this.ownerUsername}`);
+        // For answerer, we need to fetch a new offer from the same user
         // Clean up old connection
         if (this.pc) {
             this.pc.close();
@@ -98,24 +101,31 @@ export class AnswererConnection extends RondevuConnection {
             this.dc.close();
             this.dc = null;
         }
-        // Fetch new offer from service
+        // Discover new offer using tags (use paginated mode to get array)
         this.api
-            .getService(this.serviceFqn)
-            .then((service) => {
-            if (!service || !service.offers || service.offers.length === 0) {
+            .discover({ tags: this.tags, limit: 100 })
+            .then(result => {
+            const response = result;
+            if (!response || !response.offers || response.offers.length === 0) {
                 throw new Error('No offers available for reconnection');
             }
-            // Pick a random offer
-            const offer = service.offers[Math.floor(Math.random() * service.offers.length)];
+            // Filter for offers from the same user
+            const userOffers = response.offers.filter(o => o.username === this.ownerUsername);
+            if (userOffers.length === 0) {
+                throw new Error(`No offers available from ${this.ownerUsername}`);
+            }
+            // Pick a random offer from the same user
+            const offer = userOffers[Math.floor(Math.random() * userOffers.length)];
             this.offerId = offer.offerId;
             this.offerSdp = offer.sdp;
+            this.debug(`Found new offer ${offer.offerId} from ${this.ownerUsername}`);
             // Reinitialize with new offer
             return this.initialize();
         })
             .then(() => {
             this.emit('reconnect:success');
         })
-            .catch((error) => {
+            .catch(error => {
             this.debug('Reconnection failed:', error);
             this.emit('reconnect:failed', error);
             this.scheduleReconnect();
@@ -127,4 +137,31 @@ export class AnswererConnection extends RondevuConnection {
     getOfferId() {
         return this.offerId;
     }
+    /**
+     * Handle remote ICE candidates received from polling
+     * Called by Rondevu when poll:ice event is received
+     */
+    handleRemoteIceCandidates(candidates) {
+        if (!this.pc) {
+            this.debug('Cannot add ICE candidates: peer connection not initialized');
+            return;
+        }
+        for (const iceCandidate of candidates) {
+            // Answerer only accepts offerer's candidates
+            if (iceCandidate.role !== 'offerer') {
+                continue;
+            }
+            if (iceCandidate.candidate) {
+                const rtcCandidate = this.webrtcAdapter.createIceCandidate(iceCandidate.candidate);
+                this.pc
+                    .addIceCandidate(rtcCandidate)
+                    .then(() => {
+                    this.emit('ice:candidate:remote', rtcCandidate);
+                })
+                    .catch(error => {
+                    this.debug('Failed to add ICE candidate:', error);
+                });
+            }
+        }
+    }
 }

package/dist/connections/base.d.ts

@@ -6,6 +6,7 @@ import { ConnectionConfig } from './config.js';
 import { ConnectionState, ConnectionEventMap } from './events.js';
 import { ExponentialBackoff } from '../utils/exponential-backoff.js';
 import { MessageBuffer } from '../utils/message-buffer.js';
+import { WebRTCAdapter } from '../webrtc/adapter.js';
 /**
  * Abstract base class for WebRTC connections with durability features
  */
@@ -15,6 +16,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     protected dc: RTCDataChannel | null;
     protected state: ConnectionState;
     protected config: ConnectionConfig;
+    protected webrtcAdapter: WebRTCAdapter;
     protected messageBuffer: MessageBuffer | null;
     protected backoff: ExponentialBackoff | null;
     protected reconnectTimeout: ReturnType<typeof setTimeout> | null;
@@ -25,7 +27,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     protected lastIcePollTime: number;
     protected answerProcessed: boolean;
     protected answerSdpFingerprint: string | null;
-    constructor(rtcConfig?: RTCConfiguration | undefined, userConfig?: Partial<ConnectionConfig>);
+    constructor(rtcConfig?: RTCConfiguration | undefined, userConfig?: Partial<ConnectionConfig>, webrtcAdapter?: WebRTCAdapter);
     /**
      * Transition to a new state and emit events
      */
@@ -87,9 +89,9 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
      */
     protected abstract getApi(): any;
     /**
-     * Get the service FQN - subclasses must provide
+     * Get the owner username - subclasses must provide
      */
-    protected abstract getServiceFqn(): string;
+    protected abstract getOwnerUsername(): string;
     /**
      * Get the offer ID - subclasses must provide
      */
@@ -163,7 +165,7 @@ export declare abstract class RondevuConnection extends EventEmitter<ConnectionE
     /**
      * Debug logging helper
      */
-    protected debug(...args: any[]): void;
+    protected debug(...args: unknown[]): void;
     protected abstract onLocalIceCandidate(candidate: RTCIceCandidate): void;
     protected abstract attemptReconnect(): void;
 }

package/dist/connections/base.js

@@ -6,11 +6,12 @@ import { mergeConnectionConfig } from './config.js';
 import { ConnectionState, } from './events.js';
 import { ExponentialBackoff } from '../utils/exponential-backoff.js';
 import { MessageBuffer } from '../utils/message-buffer.js';
+import { BrowserWebRTCAdapter } from '../webrtc/browser.js';
 /**
  * Abstract base class for WebRTC connections with durability features
  */
 export class RondevuConnection extends EventEmitter {
-    constructor(rtcConfig, userConfig) {
+    constructor(rtcConfig, userConfig, webrtcAdapter) {
         super();
         this.rtcConfig = rtcConfig;
         this.pc = null;
@@ -32,6 +33,7 @@ export class RondevuConnection extends EventEmitter {
         this.answerProcessed = false;
         this.answerSdpFingerprint = null;
         this.config = mergeConnectionConfig(userConfig);
+        this.webrtcAdapter = webrtcAdapter || new BrowserWebRTCAdapter();
         // Initialize message buffer if enabled
         if (this.config.bufferEnabled) {
             this.messageBuffer = new MessageBuffer({
@@ -81,9 +83,9 @@ export class RondevuConnection extends EventEmitter {
      * Create and configure RTCPeerConnection
      */
     createPeerConnection() {
-        this.pc = new RTCPeerConnection(this.rtcConfig);
+        this.pc = this.webrtcAdapter.createPeerConnection(this.rtcConfig);
         // Setup event handlers BEFORE any signaling
-        this.pc.onicecandidate = (event) => this.handleIceCandidate(event);
+        this.pc.onicecandidate = event => this.handleIceCandidate(event);
         this.pc.oniceconnectionstatechange = () => this.handleIceConnectionStateChange();
         this.pc.onconnectionstatechange = () => this.handleConnectionStateChange();
         this.pc.onicegatheringstatechange = () => this.handleIceGatheringStateChange();
@@ -95,8 +97,8 @@ export class RondevuConnection extends EventEmitter {
     setupDataChannelHandlers(dc) {
         dc.onopen = () => this.handleDataChannelOpen();
         dc.onclose = () => this.handleDataChannelClose();
-        dc.onerror = (error) => this.handleDataChannelError(error);
-        dc.onmessage = (event) => this.handleMessage(event);
+        dc.onerror = error => this.handleDataChannelError(error);
+        dc.onmessage = event => this.handleMessage(event);
     }
     /**
      * Handle local ICE candidate generation
@@ -121,7 +123,8 @@ export class RondevuConnection extends EventEmitter {
                 if (this.state === ConnectionState.SIGNALING) {
                     this.transitionTo(ConnectionState.CHECKING, 'ICE checking started');
                 }
-                this.startIcePolling();
+                // Note: ICE candidate polling is handled by PollingManager
+                // Candidates are received via handleRemoteIceCandidates()
                 break;
             case 'connected':
             case 'completed':
@@ -191,7 +194,9 @@ export class RondevuConnection extends EventEmitter {
         this.debug('Data channel opened');
         this.emit('datachannel:open');
         // Only transition to CONNECTED if ICE is also connected
-        if (this.pc && (this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed')) {
+        if (this.pc &&
+            (this.pc.iceConnectionState === 'connected' ||
+                this.pc.iceConnectionState === 'completed')) {
             this.transitionTo(ConnectionState.CONNECTED, 'Data channel opened and ICE connected');
             this.onConnected();
         }
@@ -256,9 +261,14 @@ export class RondevuConnection extends EventEmitter {
             return;
         this.debug('Starting ICE polling');
         this.emit('ice:polling:started');
-        this.lastIcePollTime = Date.now();
+        // Use 0 instead of Date.now() to get ALL existing candidates on first poll
+        // Remote candidates may have been created before this peer's ICE checking started
+        this.lastIcePollTime = 0;
+        const pollingStartTime = Date.now();
+        // Immediately poll for existing candidates
+        this.pollIceCandidates();
         this.icePollingInterval = setInterval(() => {
-            const elapsed = Date.now() - this.lastIcePollTime;
+            const elapsed = Date.now() - pollingStartTime;
             if (elapsed > this.config.icePollingTimeout) {
                 this.debug('ICE polling timeout');
                 this.stopIcePolling();
@@ -285,10 +295,8 @@ export class RondevuConnection extends EventEmitter {
     pollIceCandidates() {
         const acceptRole = this.getIceCandidateRole();
         const api = this.getApi();
-        const serviceFqn = this.getServiceFqn();
         const offerId = this.getOfferId();
-        api
-            .getOfferIceCandidates(serviceFqn, offerId, this.lastIcePollTime)
+        api.getOfferIceCandidates(offerId, this.lastIcePollTime)
             .then((result) => {
             if (result.candidates.length > 0) {
                 this.debug(`Received ${result.candidates.length} remote ICE candidates`);
@@ -299,12 +307,13 @@ export class RondevuConnection extends EventEmitter {
                     }
                     if (iceCandidate.candidate && this.pc) {
                         const candidate = iceCandidate.candidate;
+                        const rtcCandidate = this.webrtcAdapter.createIceCandidate(candidate);
                         this.pc
-                            .addIceCandidate(new RTCIceCandidate(candidate))
+                            .addIceCandidate(rtcCandidate)
                             .then(() => {
-                            this.emit('ice:candidate:remote', new RTCIceCandidate(candidate));
+                            this.emit('ice:candidate:remote', rtcCandidate);
                         })
-                            .catch((error) => {
+                            .catch(error => {
                             this.debug('Failed to add ICE candidate:', error);
                         });
                     }
@@ -370,7 +379,8 @@ export class RondevuConnection extends EventEmitter {
         if (!this.config.reconnectEnabled || !this.backoff)
             return;
         // Check if we've exceeded max attempts
-        if (this.config.maxReconnectAttempts > 0 && this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+        if (this.config.maxReconnectAttempts > 0 &&
+            this.reconnectAttempts >= this.config.maxReconnectAttempts) {
             this.debug('Max reconnection attempts reached');
             this.emit('reconnect:exhausted', this.reconnectAttempts);
             return;

package/dist/connections/config.d.ts

@@ -1,6 +1,27 @@
 /**
  * Connection configuration interfaces and defaults
  */
+/**
+ * Simplified connection options for public API.
+ * Advanced options use sensible defaults.
+ */
+export interface ConnectionOptions {
+    /** Maximum time to wait for connection (ms). Default: 30000 */
+    timeout?: number;
+    /** Enable automatic reconnection on failures. Default: true */
+    reconnect?: boolean;
+    /** Maximum reconnection attempts (0 = infinite). Default: 5 */
+    maxReconnects?: number;
+    /** Buffer messages during disconnections. Default: true */
+    bufferMessages?: boolean;
+    /** Enable debug logging. Default: false */
+    debug?: boolean;
+}
+/**
+ * Full internal configuration with all options.
+ * Use ConnectionOptions for public API.
+ * @internal
+ */
 export interface ConnectionConfig {
     connectionTimeout: number;
     iceGatheringTimeout: number;
@@ -18,4 +39,13 @@ export interface ConnectionConfig {
     debug: boolean;
 }
 export declare const DEFAULT_CONNECTION_CONFIG: ConnectionConfig;
+/**
+ * Merge user config with defaults.
+ * @internal
+ */
 export declare function mergeConnectionConfig(userConfig?: Partial<ConnectionConfig>): ConnectionConfig;
+/**
+ * Convert simplified ConnectionOptions to full ConnectionConfig.
+ * Maps user-friendly names to internal config.
+ */
+export declare function toConnectionConfig(options?: ConnectionOptions): ConnectionConfig;

package/dist/connections/config.js

@@ -22,9 +22,29 @@ export const DEFAULT_CONNECTION_CONFIG = {
     // Debug
     debug: false,
 };
+/**
+ * Merge user config with defaults.
+ * @internal
+ */
 export function mergeConnectionConfig(userConfig) {
     return {
         ...DEFAULT_CONNECTION_CONFIG,
         ...userConfig,
     };
 }
+/**
+ * Convert simplified ConnectionOptions to full ConnectionConfig.
+ * Maps user-friendly names to internal config.
+ */
+export function toConnectionConfig(options) {
+    if (!options)
+        return DEFAULT_CONNECTION_CONFIG;
+    return {
+        ...DEFAULT_CONNECTION_CONFIG,
+        ...(options.timeout !== undefined && { connectionTimeout: options.timeout }),
+        ...(options.reconnect !== undefined && { reconnectEnabled: options.reconnect }),
+        ...(options.maxReconnects !== undefined && { maxReconnectAttempts: options.maxReconnects }),
+        ...(options.bufferMessages !== undefined && { bufferEnabled: options.bufferMessages }),
+        ...(options.debug !== undefined && { debug: options.debug }),
+    };
+}

package/dist/connections/events.d.ts

@@ -35,17 +35,17 @@ export interface StateChangeInfo {
  */
 export interface ConnectionEventMap {
     'state:changed': [StateChangeInfo];
-    'connecting': [];
-    'connected': [];
-    'disconnected': [reason?: string];
-    'failed': [error: Error];
-    'closed': [reason?: string];
+    connecting: [];
+    connected: [];
+    disconnected: [reason?: string];
+    failed: [error: Error];
+    closed: [reason?: string];
     'reconnect:scheduled': [ReconnectInfo];
     'reconnect:attempting': [attempt: number];
     'reconnect:success': [];
     'reconnect:failed': [error: Error];
     'reconnect:exhausted': [attempts: number];
-    'message': [data: string | ArrayBuffer | Blob];
+    message: [data: string | ArrayBuffer | Blob];
     'message:sent': [data: string | ArrayBuffer | Blob, buffered: boolean];
     'message:buffered': [data: string | ArrayBuffer | Blob];
     'message:replayed': [message: BufferedMessage];

package/dist/connections/offerer.d.ts

@@ -2,14 +2,16 @@
  * Offerer-side WebRTC connection with offer creation and answer processing
  */
 import { RondevuConnection } from './base.js';
-import { RondevuAPI } from '../api/client.js';
+import { RondevuAPI, IceCandidate } from '../api/client.js';
 import { ConnectionConfig } from './config.js';
+import { WebRTCAdapter } from '../webrtc/adapter.js';
 export interface OffererOptions {
     api: RondevuAPI;
-    serviceFqn: string;
+    ownerUsername: string;
     offerId: string;
     pc: RTCPeerConnection;
     dc?: RTCDataChannel;
+    webrtcAdapter?: WebRTCAdapter;
     config?: Partial<ConnectionConfig>;
 }
 /**
@@ -17,12 +19,14 @@ export interface OffererOptions {
  */
 export declare class OffererConnection extends RondevuConnection {
     private api;
-    private serviceFqn;
+    private ownerUsername;
     private offerId;
+    private _peerUsername;
     private rotationLock;
     private rotating;
     private rotationAttempts;
     private static readonly MAX_ROTATION_ATTEMPTS;
+    private pendingIceCandidates;
     constructor(options: OffererOptions);
     /**
      * Initialize the connection - setup handlers for already-created offer
@@ -58,22 +62,47 @@ export declare class OffererConnection extends RondevuConnection {
      */
     protected getApi(): any;
     /**
-     * Get the service FQN
+     * Get the owner username
      */
-    protected getServiceFqn(): string;
+    protected getOwnerUsername(): string;
     /**
      * Offerers accept all ICE candidates (no filtering)
      */
     protected getIceCandidateRole(): 'offerer' | null;
     /**
-     * Attempt to reconnect
+     * Attempt to reconnect (required by abstract base class)
      *
-     * Note: For offerer connections, reconnection is handled by the Rondevu instance
-     * creating a new offer via fillOffers(). This method is a no-op.
+     * For OffererConnection, traditional reconnection is NOT used.
+     * Instead, the OfferPool handles failures via offer rotation:
+     *
+     * 1. When this connection fails, the 'failed' event is emitted
+     * 2. OfferPool detects the failure and calls createNewOfferForRotation()
+     * 3. The new offer is published to the server
+     * 4. This connection is rebound via rebindToOffer()
+     *
+     * This approach ensures the answerer always gets a fresh offer
+     * rather than trying to reconnect to a stale one.
+     *
+     * @see OfferPool.createNewOfferForRotation() - creates replacement offer
+     * @see OffererConnection.rebindToOffer() - rebinds connection to new offer
      */
     protected attemptReconnect(): void;
     /**
      * Get the offer ID
      */
     getOfferId(): string;
+    /**
+     * Get the peer username (who answered this offer)
+     * Returns null if no answer has been processed yet
+     */
+    get peerUsername(): string | null;
+    /**
+     * Handle remote ICE candidates received from polling
+     * Called by OfferPool when poll:ice event is received
+     */
+    handleRemoteIceCandidates(candidates: IceCandidate[]): void;
+    /**
+     * Apply ICE candidates to the peer connection
+     */
+    private applyIceCandidates;
 }