@xtr-dev/rondevu-client 0.18.10 → 0.20.1

package/dist/utils/async-lock.js

@@ -0,0 +1,75 @@
+/**
+ * AsyncLock provides a mutual exclusion primitive for asynchronous operations.
+ * Ensures only one async operation can proceed at a time while queuing others.
+ */
+export class AsyncLock {
+    constructor() {
+        this.locked = false;
+        this.queue = [];
+    }
+    /**
+     * Acquire the lock. If already locked, waits until released.
+     * @returns Promise that resolves when lock is acquired
+     */
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return;
+        }
+        // Lock is held, wait in queue
+        return new Promise(resolve => {
+            this.queue.push(resolve);
+        });
+    }
+    /**
+     * Release the lock. If others are waiting, grants lock to next in queue.
+     */
+    release() {
+        const next = this.queue.shift();
+        if (next) {
+            // Grant lock to next waiter
+            next();
+        }
+        else {
+            // No waiters, mark as unlocked
+            this.locked = false;
+        }
+    }
+    /**
+     * Run a function with the lock acquired, automatically releasing after.
+     * This is the recommended way to use AsyncLock to prevent forgetting to release.
+     *
+     * @param fn - Async function to run with lock held
+     * @returns Promise resolving to the function's return value
+     *
+     * @example
+     * ```typescript
+     * const lock = new AsyncLock()
+     * const result = await lock.run(async () => {
+     *     // Critical section - only one caller at a time
+     *     return await doSomething()
+     * })
+     * ```
+     */
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    /**
+     * Check if lock is currently held
+     */
+    isLocked() {
+        return this.locked;
+    }
+    /**
+     * Get number of operations waiting for the lock
+     */
+    getQueueLength() {
+        return this.queue.length;
+    }
+}

package/dist/{message-buffer.d.ts → utils/message-buffer.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Message buffering system for storing messages during disconnections
  */
-import { BufferedMessage } from './connection-events.js';
+import { BufferedMessage } from '../connections/events.js';
 export interface MessageBufferConfig {
     maxSize: number;
     maxAge: number;

package/package.json

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

package/dist/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * @xtr-dev/rondevu-client
- * WebRTC peer signaling client
- */
-export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } from './rondevu.js';
-export { RondevuAPI } from './api.js';
-export { RpcBatcher } from './rpc-batcher.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';

package/dist/index.js

@@ -1,10 +0,0 @@
-/**
- * @xtr-dev/rondevu-client
- * WebRTC peer signaling client
- */
-export { Rondevu, RondevuError, NetworkError, ValidationError, ConnectionError } 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';

package/dist/rondevu-signaler.d.ts

@@ -1,112 +0,0 @@
-import { Signaler, Binnable } from './types.js';
-import { Rondevu } from './rondevu.js';
-export interface PollingConfig {
-    initialInterval?: number;
-    maxInterval?: number;
-    backoffMultiplier?: number;
-    maxRetries?: number;
-    jitter?: boolean;
-}
-/**
- * RondevuSignaler - Handles WebRTC signaling via Rondevu service
- *
- * Manages offer/answer exchange and ICE candidate polling for establishing
- * WebRTC connections through the Rondevu signaling server.
- *
- * Supports configurable polling with exponential backoff and jitter to reduce
- * server load and prevent thundering herd issues.
- *
- * @example
- * ```typescript
- * const signaler = new RondevuSignaler(
- *   rondevuService,
- *   'chat.app@1.0.0',
- *   'peer-username',
- *   { initialInterval: 500, maxInterval: 5000, jitter: true }
- * )
- *
- * // For offerer:
- * await signaler.setOffer(offer)
- * signaler.addAnswerListener(answer => {
- *   // Handle remote answer
- * })
- *
- * // For answerer:
- * signaler.addOfferListener(offer => {
- *   // Handle remote offer
- * })
- * await signaler.setAnswer(answer)
- * ```
- */
-export declare class RondevuSignaler implements Signaler {
-    private readonly rondevu;
-    private readonly service;
-    private readonly host?;
-    private offerId;
-    private serviceFqn;
-    private offerListeners;
-    private answerListeners;
-    private iceListeners;
-    private pollingTimeout;
-    private icePollingTimeout;
-    private lastPollTimestamp;
-    private isPolling;
-    private isOfferer;
-    private pollingConfig;
-    constructor(rondevu: Rondevu, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
-    /**
-     * Publish an offer as a service
-     * Used by the offerer to make their offer available
-     */
-    setOffer(offer: RTCSessionDescriptionInit): Promise<void>;
-    /**
-     * Send an answer to the offerer
-     * Used by the answerer to respond to an offer
-     */
-    setAnswer(answer: RTCSessionDescriptionInit): Promise<void>;
-    /**
-     * Listen for incoming offers
-     * Used by the answerer to receive offers from the offerer
-     */
-    addOfferListener(callback: (offer: RTCSessionDescriptionInit) => void): Binnable;
-    /**
-     * Listen for incoming answers
-     * Used by the offerer to receive the answer from the answerer
-     */
-    addAnswerListener(callback: (answer: RTCSessionDescriptionInit) => void): Binnable;
-    /**
-     * Send an ICE candidate to the remote peer
-     */
-    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
-    /**
-     * Listen for ICE candidates from the remote peer
-     */
-    addListener(callback: (candidate: RTCIceCandidate) => void): Binnable;
-    /**
-     * Search for an offer from the host
-     * Used by the answerer to find the offerer's service
-     */
-    private searchForOffer;
-    /**
-     * Start combined polling for answers and ICE candidates (offerer side)
-     * Uses poll() for efficient batch polling
-     */
-    private startPolling;
-    /**
-     * Stop combined polling
-     */
-    private stopPolling;
-    /**
-     * Start polling for ICE candidates (answerer side only)
-     * Answerers use the separate endpoint since they don't have offers to poll
-     */
-    private startIcePolling;
-    /**
-     * Stop polling for ICE candidates
-     */
-    private stopIcePolling;
-    /**
-     * Stop all polling and cleanup
-     */
-    dispose(): void;
-}

package/dist/rondevu-signaler.js

@@ -1,401 +0,0 @@
-/**
- * RondevuSignaler - Handles WebRTC signaling via Rondevu service
- *
- * Manages offer/answer exchange and ICE candidate polling for establishing
- * WebRTC connections through the Rondevu signaling server.
- *
- * Supports configurable polling with exponential backoff and jitter to reduce
- * server load and prevent thundering herd issues.
- *
- * @example
- * ```typescript
- * const signaler = new RondevuSignaler(
- *   rondevuService,
- *   'chat.app@1.0.0',
- *   'peer-username',
- *   { initialInterval: 500, maxInterval: 5000, jitter: true }
- * )
- *
- * // For offerer:
- * await signaler.setOffer(offer)
- * signaler.addAnswerListener(answer => {
- *   // Handle remote answer
- * })
- *
- * // For answerer:
- * signaler.addOfferListener(offer => {
- *   // Handle remote offer
- * })
- * await signaler.setAnswer(answer)
- * ```
- */
-export class RondevuSignaler {
-    constructor(rondevu, service, host, pollingConfig) {
-        this.rondevu = rondevu;
-        this.service = service;
-        this.host = host;
-        this.offerId = null;
-        this.serviceFqn = null;
-        this.offerListeners = [];
-        this.answerListeners = [];
-        this.iceListeners = [];
-        this.pollingTimeout = null;
-        this.icePollingTimeout = null;
-        this.lastPollTimestamp = 0;
-        this.isPolling = false;
-        this.isOfferer = false;
-        this.pollingConfig = {
-            initialInterval: pollingConfig?.initialInterval ?? 500,
-            maxInterval: pollingConfig?.maxInterval ?? 5000,
-            backoffMultiplier: pollingConfig?.backoffMultiplier ?? 1.5,
-            maxRetries: pollingConfig?.maxRetries ?? 50,
-            jitter: pollingConfig?.jitter ?? true
-        };
-    }
-    /**
-     * Publish an offer as a service
-     * Used by the offerer to make their offer available
-     */
-    async setOffer(offer) {
-        if (!offer.sdp) {
-            throw new Error('Offer SDP is required');
-        }
-        // Publish service with the offer SDP
-        const publishedService = await this.rondevu.publishService({
-            serviceFqn: this.service,
-            offers: [{ sdp: offer.sdp }],
-            ttl: 300000, // 5 minutes
-        });
-        // Get the first offer from the published service
-        if (!publishedService.offers || publishedService.offers.length === 0) {
-            throw new Error('No offers returned from service publication');
-        }
-        this.offerId = publishedService.offers[0].offerId;
-        this.serviceFqn = publishedService.serviceFqn;
-        this.isOfferer = true;
-        // Start combined polling for answers and ICE candidates
-        this.startPolling();
-    }
-    /**
-     * Send an answer to the offerer
-     * Used by the answerer to respond to an offer
-     */
-    async setAnswer(answer) {
-        if (!answer.sdp) {
-            throw new Error('Answer SDP is required');
-        }
-        if (!this.serviceFqn || !this.offerId) {
-            throw new Error('No service FQN or offer ID available. Must receive offer first.');
-        }
-        // Send answer to the service
-        await this.rondevu.getAPIPublic().answerOffer(this.serviceFqn, this.offerId, answer.sdp);
-        this.isOfferer = false;
-        // Start polling for ICE candidates (answerer uses separate endpoint)
-        this.startIcePolling();
-    }
-    /**
-     * Listen for incoming offers
-     * Used by the answerer to receive offers from the offerer
-     */
-    addOfferListener(callback) {
-        this.offerListeners.push(callback);
-        // If we have a host, start searching for their service
-        if (this.host && !this.isPolling) {
-            this.searchForOffer();
-        }
-        // Return cleanup function
-        return () => {
-            const index = this.offerListeners.indexOf(callback);
-            if (index > -1) {
-                this.offerListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Listen for incoming answers
-     * Used by the offerer to receive the answer from the answerer
-     */
-    addAnswerListener(callback) {
-        this.answerListeners.push(callback);
-        // Return cleanup function
-        return () => {
-            const index = this.answerListeners.indexOf(callback);
-            if (index > -1) {
-                this.answerListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Send an ICE candidate to the remote peer
-     */
-    async addIceCandidate(candidate) {
-        if (!this.serviceFqn || !this.offerId) {
-            console.warn('Cannot send ICE candidate: no service FQN or offer ID');
-            return;
-        }
-        const candidateData = candidate.toJSON();
-        // Skip empty candidates
-        if (!candidateData.candidate || candidateData.candidate === '') {
-            return;
-        }
-        try {
-            await this.rondevu.getAPIPublic().addOfferIceCandidates(this.serviceFqn, this.offerId, [candidateData]);
-        }
-        catch (err) {
-            console.error('Failed to send ICE candidate:', err);
-        }
-    }
-    /**
-     * Listen for ICE candidates from the remote peer
-     */
-    addListener(callback) {
-        this.iceListeners.push(callback);
-        // Return cleanup function
-        return () => {
-            const index = this.iceListeners.indexOf(callback);
-            if (index > -1) {
-                this.iceListeners.splice(index, 1);
-            }
-        };
-    }
-    /**
-     * Search for an offer from the host
-     * Used by the answerer to find the offerer's service
-     */
-    async searchForOffer() {
-        if (!this.host) {
-            throw new Error('No host specified for offer search');
-        }
-        this.isPolling = true;
-        try {
-            // Get service by FQN (service should include @username)
-            const serviceFqn = `${this.service}@${this.host}`;
-            const serviceData = await this.rondevu.getAPIPublic().getService(serviceFqn);
-            if (!serviceData) {
-                console.warn(`No service found for ${serviceFqn}`);
-                this.isPolling = false;
-                return;
-            }
-            // Store service details
-            this.offerId = serviceData.offerId;
-            this.serviceFqn = serviceData.serviceFqn;
-            // Notify offer listeners
-            const offer = {
-                type: 'offer',
-                sdp: serviceData.sdp,
-            };
-            this.offerListeners.forEach(listener => {
-                try {
-                    listener(offer);
-                }
-                catch (err) {
-                    console.error('Offer listener error:', err);
-                }
-            });
-        }
-        catch (err) {
-            console.error('Failed to search for offer:', err);
-            this.isPolling = false;
-        }
-    }
-    /**
-     * Start combined polling for answers and ICE candidates (offerer side)
-     * Uses poll() for efficient batch polling
-     */
-    startPolling() {
-        if (this.pollingTimeout || !this.isOfferer) {
-            return;
-        }
-        let interval = this.pollingConfig.initialInterval;
-        let retries = 0;
-        let answerReceived = false;
-        const poll = async () => {
-            try {
-                const result = await this.rondevu.poll(this.lastPollTimestamp);
-                let foundActivity = false;
-                // Process answers
-                if (result.answers.length > 0 && !answerReceived) {
-                    foundActivity = true;
-                    // Find answer for our offerId
-                    const answer = result.answers.find(a => a.offerId === this.offerId);
-                    if (answer && answer.sdp) {
-                        answerReceived = true;
-                        const answerDesc = {
-                            type: 'answer',
-                            sdp: answer.sdp,
-                        };
-                        this.answerListeners.forEach(listener => {
-                            try {
-                                listener(answerDesc);
-                            }
-                            catch (err) {
-                                console.error('Answer listener error:', err);
-                            }
-                        });
-                        this.lastPollTimestamp = Math.max(this.lastPollTimestamp, answer.answeredAt);
-                    }
-                }
-                // Process ICE candidates for our offer
-                if (this.offerId && result.iceCandidates[this.offerId]) {
-                    const candidates = result.iceCandidates[this.offerId];
-                    // Filter for answerer candidates (offerer receives answerer's candidates)
-                    const answererCandidates = candidates.filter(c => c.role === 'answerer');
-                    if (answererCandidates.length > 0) {
-                        foundActivity = true;
-                        for (const item of answererCandidates) {
-                            if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
-                                try {
-                                    const rtcCandidate = new RTCIceCandidate(item.candidate);
-                                    this.iceListeners.forEach(listener => {
-                                        try {
-                                            listener(rtcCandidate);
-                                        }
-                                        catch (err) {
-                                            console.error('ICE listener error:', err);
-                                        }
-                                    });
-                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
-                                }
-                                catch (err) {
-                                    console.warn('Failed to process ICE candidate:', err);
-                                    this.lastPollTimestamp = Math.max(this.lastPollTimestamp, item.createdAt);
-                                }
-                            }
-                        }
-                    }
-                }
-                // Adjust interval based on activity
-                if (foundActivity) {
-                    interval = this.pollingConfig.initialInterval;
-                    retries = 0;
-                }
-                else {
-                    retries++;
-                    if (retries > this.pollingConfig.maxRetries) {
-                        console.warn('Max retries reached for polling');
-                        this.stopPolling();
-                        return;
-                    }
-                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
-                }
-                // Add jitter to prevent thundering herd
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.pollingTimeout = setTimeout(poll, finalInterval);
-            }
-            catch (err) {
-                console.error('Error polling offers:', err);
-                // Retry with backoff
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.pollingTimeout = setTimeout(poll, finalInterval);
-            }
-        };
-        poll(); // Start immediately
-    }
-    /**
-     * Stop combined polling
-     */
-    stopPolling() {
-        if (this.pollingTimeout) {
-            clearTimeout(this.pollingTimeout);
-            this.pollingTimeout = null;
-        }
-    }
-    /**
-     * Start polling for ICE candidates (answerer side only)
-     * Answerers use the separate endpoint since they don't have offers to poll
-     */
-    startIcePolling() {
-        if (this.icePollingTimeout || !this.serviceFqn || !this.offerId || this.isOfferer) {
-            return;
-        }
-        let interval = this.pollingConfig.initialInterval;
-        const poll = async () => {
-            if (!this.serviceFqn || !this.offerId) {
-                this.stopIcePolling();
-                return;
-            }
-            try {
-                const result = await this.rondevu
-                    .getAPIPublic()
-                    .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastPollTimestamp);
-                let foundCandidates = false;
-                for (const item of result.candidates) {
-                    if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {
-                        foundCandidates = true;
-                        try {
-                            const rtcCandidate = new RTCIceCandidate(item.candidate);
-                            this.iceListeners.forEach(listener => {
-                                try {
-                                    listener(rtcCandidate);
-                                }
-                                catch (err) {
-                                    console.error('ICE listener error:', err);
-                                }
-                            });
-                            this.lastPollTimestamp = item.createdAt;
-                        }
-                        catch (err) {
-                            console.warn('Failed to process ICE candidate:', err);
-                            this.lastPollTimestamp = item.createdAt;
-                        }
-                    }
-                    else {
-                        this.lastPollTimestamp = item.createdAt;
-                    }
-                }
-                // If candidates found, reset interval to initial value
-                // Otherwise, increase interval with backoff
-                if (foundCandidates) {
-                    interval = this.pollingConfig.initialInterval;
-                }
-                else {
-                    interval = Math.min(interval * this.pollingConfig.backoffMultiplier, this.pollingConfig.maxInterval);
-                }
-                // Add jitter
-                const finalInterval = this.pollingConfig.jitter
-                    ? interval + Math.random() * 100
-                    : interval;
-                this.icePollingTimeout = setTimeout(poll, finalInterval);
-            }
-            catch (err) {
-                // 404/410 means offer expired, stop polling
-                if (err instanceof Error && (err.message?.includes('404') || err.message?.includes('410'))) {
-                    console.warn('Offer not found or expired, stopping ICE polling');
-                    this.stopIcePolling();
-                }
-                else if (err instanceof Error && !err.message?.includes('404')) {
-                    console.error('Error polling for ICE candidates:', err);
-                    // Continue polling despite errors
-                    const finalInterval = this.pollingConfig.jitter
-                        ? interval + Math.random() * 100
-                        : interval;
-                    this.icePollingTimeout = setTimeout(poll, finalInterval);
-                }
-            }
-        };
-        poll(); // Start immediately
-    }
-    /**
-     * Stop polling for ICE candidates
-     */
-    stopIcePolling() {
-        if (this.icePollingTimeout) {
-            clearTimeout(this.icePollingTimeout);
-            this.icePollingTimeout = null;
-        }
-    }
-    /**
-     * Stop all polling and cleanup
-     */
-    dispose() {
-        this.stopPolling();
-        this.stopIcePolling();
-        this.offerListeners = [];
-        this.answerListeners = [];
-        this.iceListeners = [];
-    }
-}