@xtr-dev/rondevu-client 0.18.10 → 0.20.1

package/dist/{offerer-connection.js → connections/offerer.js}

@@ -1,14 +1,23 @@
 /**
  * Offerer-side WebRTC connection with offer creation and answer processing
  */
-import { RondevuConnection } from './connection.js';
-import { ConnectionState } from './connection-events.js';
+import { RondevuConnection } from './base.js';
+import { ConnectionState } from './events.js';
+import { AsyncLock } from '../utils/async-lock.js';
 /**
  * Offerer connection - manages already-created offers and waits for answers
  */
 export class OffererConnection extends RondevuConnection {
     constructor(options) {
-        super(undefined, options.config); // rtcConfig not needed, PC already created
+        // Force reconnectEnabled: false for offerer connections (offers are ephemeral)
+        super(undefined, {
+            ...options.config,
+            reconnectEnabled: false
+        });
+        // Rotation tracking
+        this.rotationLock = new AsyncLock();
+        this.rotating = false;
+        this.rotationAttempts = 0;
         this.api = options.api;
         this.serviceFqn = options.serviceFqn;
         this.offerId = options.offerId;
@@ -82,6 +91,71 @@ export class OffererConnection extends RondevuConnection {
             throw error;
         }
     }
+    /**
+     * Rebind this connection to a new offer (when previous offer failed)
+     * Keeps the same connection object alive but with new underlying WebRTC
+     */
+    async rebindToOffer(newOfferId, newPc, newDc) {
+        return this.rotationLock.run(async () => {
+            if (this.rotating) {
+                throw new Error('Rotation already in progress');
+            }
+            this.rotating = true;
+            try {
+                this.rotationAttempts++;
+                if (this.rotationAttempts > OffererConnection.MAX_ROTATION_ATTEMPTS) {
+                    throw new Error('Max rotation attempts exceeded');
+                }
+                this.debug(`Rebinding connection from ${this.offerId} to ${newOfferId}`);
+                // 1. Clean up old peer connection
+                if (this.pc) {
+                    this.pc.close();
+                }
+                if (this.dc && this.dc !== newDc) {
+                    this.dc.close();
+                }
+                // 2. Update to new offer
+                this.offerId = newOfferId;
+                this.pc = newPc;
+                this.dc = newDc || null;
+                // 3. Reset answer processing flags
+                this.answerProcessed = false;
+                this.answerSdpFingerprint = null;
+                // 4. Setup event handlers for new peer connection
+                this.pc.onicecandidate = (event) => this.handleIceCandidate(event);
+                this.pc.oniceconnectionstatechange = () => this.handleIceConnectionStateChange();
+                this.pc.onconnectionstatechange = () => this.handleConnectionStateChange();
+                this.pc.onicegatheringstatechange = () => this.handleIceGatheringStateChange();
+                // 5. Setup data channel handlers if we have one
+                if (this.dc) {
+                    this.setupDataChannelHandlers(this.dc);
+                }
+                // 6. Restart connection timeout
+                this.startConnectionTimeout();
+                // 7. Transition to SIGNALING state (waiting for answer)
+                this.transitionTo(ConnectionState.SIGNALING, 'Offer rotated, waiting for answer');
+                // Note: Message buffer is NOT cleared - it persists!
+                this.debug(`Rebind complete. Buffer has ${this.messageBuffer?.size() ?? 0} messages`);
+            }
+            finally {
+                this.rotating = false;
+            }
+        });
+    }
+    /**
+     * Check if connection is currently rotating
+     */
+    isRotating() {
+        return this.rotating;
+    }
+    /**
+     * Override onConnected to reset rotation attempts
+     */
+    onConnected() {
+        super.onConnected();
+        this.rotationAttempts = 0;
+        this.debug('Connection established, rotation attempts reset');
+    }
     /**
      * Generate a hash fingerprint of SDP for deduplication
      */
@@ -124,36 +198,22 @@ export class OffererConnection extends RondevuConnection {
         });
     }
     /**
-     * Poll for remote ICE candidates
+     * Get the API instance
      */
-    pollIceCandidates() {
-        this.api
-            .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastIcePollTime)
-            .then((result) => {
-            if (result.candidates.length > 0) {
-                this.debug(`Received ${result.candidates.length} remote ICE candidates`);
-                for (const iceCandidate of result.candidates) {
-                    if (iceCandidate.candidate && this.pc) {
-                        const candidate = iceCandidate.candidate;
-                        this.pc
-                            .addIceCandidate(new RTCIceCandidate(candidate))
-                            .then(() => {
-                            this.emit('ice:candidate:remote', new RTCIceCandidate(candidate));
-                        })
-                            .catch((error) => {
-                            this.debug('Failed to add ICE candidate:', error);
-                        });
-                    }
-                    // Update last poll time
-                    if (iceCandidate.createdAt > this.lastIcePollTime) {
-                        this.lastIcePollTime = iceCandidate.createdAt;
-                    }
-                }
-            }
-        })
-            .catch((error) => {
-            this.debug('Failed to poll ICE candidates:', error);
-        });
+    getApi() {
+        return this.api;
+    }
+    /**
+     * Get the service FQN
+     */
+    getServiceFqn() {
+        return this.serviceFqn;
+    }
+    /**
+     * Offerers accept all ICE candidates (no filtering)
+     */
+    getIceCandidateRole() {
+        return null;
     }
     /**
      * Attempt to reconnect
@@ -175,3 +235,4 @@ export class OffererConnection extends RondevuConnection {
         return this.offerId;
     }
 }
+OffererConnection.MAX_ROTATION_ATTEMPTS = 5;

package/dist/core/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @xtr-dev/rondevu-client
+ * WebRTC peer signaling client
+ */
+export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
+export { RondevuAPI } from '../api/client.js';
+export { RpcBatcher } from '../api/batcher.js';
+export { RondevuConnection } from '../connections/base.js';
+export { OffererConnection } from '../connections/offerer.js';
+export { AnswererConnection } from '../connections/answerer.js';
+export { ExponentialBackoff } from '../utils/exponential-backoff.js';
+export { MessageBuffer } from '../utils/message-buffer.js';
+export { WebCryptoAdapter } from '../crypto/web.js';
+export { NodeCryptoAdapter } from '../crypto/node.js';
+export type { Signaler, Binnable, } from './types.js';
+export type { Keypair, OfferRequest, ServiceRequest, Service, ServiceOffer, IceCandidate, } from '../api/client.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 '../connections/config.js';
+export type { ConnectionState, BufferedMessage, ReconnectInfo, StateChangeInfo, ConnectionEventMap, ConnectionEventName, ConnectionEventArgs, } from '../connections/events.js';
+export type { OffererOptions, } from '../connections/offerer.js';
+export type { AnswererOptions, } from '../connections/answerer.js';

package/dist/core/index.js

@@ -0,0 +1,17 @@
+/**
+ * @xtr-dev/rondevu-client
+ * WebRTC peer signaling client
+ */
+export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
+export { RondevuAPI } from '../api/client.js';
+export { RpcBatcher } from '../api/batcher.js';
+// Export connection classes
+export { RondevuConnection } from '../connections/base.js';
+export { OffererConnection } from '../connections/offerer.js';
+export { AnswererConnection } from '../connections/answerer.js';
+// Export utilities
+export { ExponentialBackoff } from '../utils/exponential-backoff.js';
+export { MessageBuffer } from '../utils/message-buffer.js';
+// Export crypto adapters
+export { WebCryptoAdapter } from '../crypto/web.js';
+export { NodeCryptoAdapter } from '../crypto/node.js';

package/dist/core/offer-pool.d.ts

@@ -0,0 +1,94 @@
+import { EventEmitter } from 'eventemitter3';
+import { RondevuAPI } from '../api/client.js';
+import { OffererConnection } from '../connections/offerer.js';
+import { ConnectionConfig } from '../connections/config.js';
+export type OfferFactory = (pc: RTCPeerConnection) => Promise<{
+    dc?: RTCDataChannel;
+    offer: RTCSessionDescriptionInit;
+}>;
+export interface OfferPoolOptions {
+    api: RondevuAPI;
+    serviceFqn: string;
+    maxOffers: number;
+    offerFactory: OfferFactory;
+    ttl: number;
+    iceServers: RTCIceServer[];
+    connectionConfig?: Partial<ConnectionConfig>;
+    debugEnabled?: boolean;
+}
+interface OfferPoolEvents {
+    'connection:opened': (offerId: string, connection: OffererConnection) => void;
+    'offer:created': (offerId: string, serviceFqn: string) => void;
+    'offer:failed': (offerId: string, error: Error) => void;
+    'connection:rotated': (oldOfferId: string, newOfferId: string, connection: OffererConnection) => void;
+}
+/**
+ * OfferPool manages a pool of WebRTC offers for a published service.
+ * Maintains a target number of active offers and automatically replaces
+ * offers that fail or get answered.
+ */
+export declare class OfferPool extends EventEmitter<OfferPoolEvents> {
+    private readonly api;
+    private readonly serviceFqn;
+    private readonly maxOffers;
+    private readonly offerFactory;
+    private readonly ttl;
+    private readonly iceServers;
+    private readonly connectionConfig?;
+    private readonly debugEnabled;
+    private readonly activeConnections;
+    private readonly fillLock;
+    private running;
+    private pollingInterval;
+    private lastPollTimestamp;
+    private static readonly POLLING_INTERVAL_MS;
+    constructor(options: OfferPoolOptions);
+    /**
+     * Start filling offers and polling for answers
+     */
+    start(): Promise<void>;
+    /**
+     * Stop filling offers and polling
+     * Closes all active connections
+     */
+    stop(): void;
+    /**
+     * Get count of active offers
+     */
+    getOfferCount(): number;
+    /**
+     * Get all active connections
+     */
+    getActiveConnections(): Map<string, OffererConnection>;
+    /**
+     * Check if a specific offer is connected
+     */
+    isConnected(offerId: string): boolean;
+    /**
+     * Disconnect all active offers
+     */
+    disconnectAll(): void;
+    /**
+     * Fill offers to reach maxOffers count
+     * Uses AsyncLock to prevent concurrent fills
+     */
+    private fillOffers;
+    /**
+     * Create a new offer for rotation (reuses existing creation logic)
+     * Similar to createOffer() but only creates the offer, doesn't create connection
+     */
+    private createNewOfferForRotation;
+    /**
+     * Create a single offer and publish it to the server
+     */
+    private createOffer;
+    /**
+     * Poll for answers and delegate to OffererConnections
+     */
+    private pollInternal;
+    /**
+     * Debug logging (only if debug enabled)
+     */
+    private debug;
+}
+export {};

package/dist/core/offer-pool.js

@@ -0,0 +1,267 @@
+import { EventEmitter } from 'eventemitter3';
+import { OffererConnection } from '../connections/offerer.js';
+import { AsyncLock } from '../utils/async-lock.js';
+/**
+ * OfferPool manages a pool of WebRTC offers for a published service.
+ * Maintains a target number of active offers and automatically replaces
+ * offers that fail or get answered.
+ */
+export class OfferPool extends EventEmitter {
+    constructor(options) {
+        super();
+        // State
+        this.activeConnections = new Map();
+        this.fillLock = new AsyncLock();
+        this.running = false;
+        this.pollingInterval = null;
+        this.lastPollTimestamp = 0;
+        this.api = options.api;
+        this.serviceFqn = options.serviceFqn;
+        this.maxOffers = options.maxOffers;
+        this.offerFactory = options.offerFactory;
+        this.ttl = options.ttl;
+        this.iceServers = options.iceServers;
+        this.connectionConfig = options.connectionConfig;
+        this.debugEnabled = options.debugEnabled || false;
+    }
+    /**
+     * Start filling offers and polling for answers
+     */
+    async start() {
+        if (this.running) {
+            this.debug('Already running');
+            return;
+        }
+        this.debug('Starting offer pool');
+        this.running = true;
+        // Fill initial offers
+        await this.fillOffers();
+        // Start polling for answers
+        this.pollingInterval = setInterval(() => {
+            this.pollInternal();
+        }, OfferPool.POLLING_INTERVAL_MS);
+    }
+    /**
+     * Stop filling offers and polling
+     * Closes all active connections
+     */
+    stop() {
+        this.debug('Stopping offer pool');
+        this.running = false;
+        // Stop polling
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = null;
+        }
+        // Close all active connections
+        for (const [offerId, connection] of this.activeConnections.entries()) {
+            if (connection.isRotating()) {
+                this.debug(`Connection ${offerId} is rotating, will close anyway`);
+            }
+            this.debug(`Closing connection ${offerId}`);
+            connection.close();
+        }
+        this.activeConnections.clear();
+    }
+    /**
+     * Get count of active offers
+     */
+    getOfferCount() {
+        return this.activeConnections.size;
+    }
+    /**
+     * Get all active connections
+     */
+    getActiveConnections() {
+        return this.activeConnections;
+    }
+    /**
+     * Check if a specific offer is connected
+     */
+    isConnected(offerId) {
+        const connection = this.activeConnections.get(offerId);
+        return connection ? connection.getState() === 'connected' : false;
+    }
+    /**
+     * Disconnect all active offers
+     */
+    disconnectAll() {
+        this.debug('Disconnecting all offers');
+        for (const [offerId, connection] of this.activeConnections.entries()) {
+            this.debug(`Closing connection ${offerId}`);
+            connection.close();
+        }
+        this.activeConnections.clear();
+    }
+    /**
+     * Fill offers to reach maxOffers count
+     * Uses AsyncLock to prevent concurrent fills
+     */
+    async fillOffers() {
+        if (!this.running)
+            return;
+        return this.fillLock.run(async () => {
+            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('[OfferPool] Failed to create offer:', err);
+                }
+            }
+        });
+    }
+    /**
+     * Create a new offer for rotation (reuses existing creation logic)
+     * Similar to createOffer() but only creates the offer, doesn't create connection
+     */
+    async createNewOfferForRotation() {
+        const rtcConfig = {
+            iceServers: this.iceServers
+        };
+        this.debug('Creating new offer for rotation...');
+        // 1. Create RTCPeerConnection
+        const pc = new RTCPeerConnection(rtcConfig);
+        // 2. Call the factory to create offer
+        let dc;
+        let offer;
+        try {
+            const factoryResult = await this.offerFactory(pc);
+            dc = factoryResult.dc;
+            offer = factoryResult.offer;
+        }
+        catch (err) {
+            pc.close();
+            throw err;
+        }
+        // 3. Publish to server to get offerId
+        const result = await this.api.publishService({
+            serviceFqn: this.serviceFqn,
+            offers: [{ sdp: offer.sdp }],
+            ttl: this.ttl,
+        });
+        const newOfferId = result.offers[0].offerId;
+        this.debug(`New offer created for rotation: ${newOfferId}`);
+        return { newOfferId, pc, dc };
+    }
+    /**
+     * Create a single offer and publish it to the server
+     */
+    async createOffer() {
+        const rtcConfig = {
+            iceServers: this.iceServers
+        };
+        this.debug('Creating new offer...');
+        // 1. Create RTCPeerConnection
+        const pc = new RTCPeerConnection(rtcConfig);
+        // 2. Call the factory to create offer
+        let dc;
+        let offer;
+        try {
+            const factoryResult = await this.offerFactory(pc);
+            dc = factoryResult.dc;
+            offer = factoryResult.offer;
+        }
+        catch (err) {
+            pc.close();
+            throw err;
+        }
+        // 3. Publish to server to get offerId
+        const result = await this.api.publishService({
+            serviceFqn: this.serviceFqn,
+            offers: [{ sdp: offer.sdp }],
+            ttl: this.ttl,
+        });
+        const offerId = result.offers[0].offerId;
+        // 4. Create OffererConnection instance
+        const connection = new OffererConnection({
+            api: this.api,
+            serviceFqn: this.serviceFqn,
+            offerId,
+            pc,
+            dc,
+            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', async (error) => {
+            const currentOfferId = connection.getOfferId();
+            this.debug(`Connection failed for offer ${currentOfferId}, rotating...`);
+            try {
+                // Create new offer and rebind existing connection
+                const { newOfferId, pc, dc } = await this.createNewOfferForRotation();
+                // Rebind the connection to new offer
+                await connection.rebindToOffer(newOfferId, pc, dc);
+                // Update map: remove old offerId, add new offerId with same connection
+                this.activeConnections.delete(currentOfferId);
+                this.activeConnections.set(newOfferId, connection);
+                this.emit('connection:rotated', currentOfferId, newOfferId, connection);
+                this.debug(`Connection rotated: ${currentOfferId} → ${newOfferId}`);
+            }
+            catch (rotationError) {
+                // If rotation fails, fall back to destroying connection
+                this.debug(`Rotation failed for ${currentOfferId}:`, rotationError);
+                this.activeConnections.delete(currentOfferId);
+                this.emit('offer:failed', currentOfferId, error);
+                this.fillOffers(); // Create replacement
+            }
+        });
+        connection.on('closed', () => {
+            this.debug(`Connection closed for offer ${offerId}`);
+            this.activeConnections.delete(offerId);
+            this.fillOffers(); // Replace closed offer
+        });
+        // Store active connection
+        this.activeConnections.set(offerId, connection);
+        // Initialize the connection
+        await connection.initialize();
+        this.debug(`Offer created: ${offerId}`);
+        this.emit('offer:created', offerId, this.serviceFqn);
+    }
+    /**
+     * Poll for answers and delegate to OffererConnections
+     */
+    async pollInternal() {
+        if (!this.running)
+            return;
+        try {
+            const result = await this.api.poll(this.lastPollTimestamp);
+            // Process answers - delegate to OffererConnections
+            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);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[OfferPool] Polling error:', err);
+        }
+    }
+    /**
+     * Debug logging (only if debug enabled)
+     */
+    debug(...args) {
+        if (this.debugEnabled) {
+            console.log('[OfferPool]', ...args);
+        }
+    }
+}
+OfferPool.POLLING_INTERVAL_MS = 1000;