@xtr-dev/rondevu-client 0.18.9 → 0.20.1

package/dist/{rondevu.js → core/rondevu.js}

@@ -1,7 +1,7 @@
-import { RondevuAPI } from './api.js';
+import { RondevuAPI } from '../api/client.js';
 import { EventEmitter } from 'eventemitter3';
-import { OffererConnection } from './offerer-connection.js';
-import { AnswererConnection } from './answerer-connection.js';
+import { AnswererConnection } from '../connections/answerer.js';
+import { OfferPool } from './offer-pool.js';
 // ICE server presets
 export const ICE_SERVER_PRESETS = {
     'ipv4-turn': [
@@ -146,15 +146,7 @@ export class Rondevu extends EventEmitter {
         this.usernameClaimed = false;
         // Service management
         this.currentService = null;
-        this.maxOffers = 0;
-        this.offerFactory = null;
-        this.ttl = Rondevu.DEFAULT_TTL_MS;
-        this.activeConnections = new Map();
-        // Polling
-        this.filling = false;
-        this.fillingSemaphore = false; // Semaphore to prevent concurrent fillOffers calls
-        this.pollingInterval = null;
-        this.lastPollTimestamp = 0;
+        this.offerPool = null;
         this.apiUrl = apiUrl;
         this.username = username;
         this.keypair = keypair;
@@ -297,160 +289,43 @@ export class Rondevu extends EventEmitter {
     async publishService(options) {
         const { service, maxOffers, offerFactory, ttl, connectionConfig } = 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
-     */
-    async createOffer() {
-        if (!this.currentService || !this.offerFactory) {
-            throw new Error('Service not published. Call publishService() first.');
-        }
-        const rtcConfig = {
-            iceServers: this.iceServers
-        };
         // 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)
-        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,
-            offers: [{ sdp: offer.sdp }],
-            ttl: this.ttl,
-            signature: '',
-            message: '',
-        });
-        const offerId = result.offers[0].offerId;
-        // 4. Create OffererConnection instance with already-created PC and DC
-        const connection = new OffererConnection({
+        const serviceFqn = `${service}@${this.username}`;
+        this.debug(`Publishing service: ${service} with maxOffers: ${maxOffers}`);
+        // Create OfferPool (but don't start it yet - call startFilling() to begin)
+        this.offerPool = new OfferPool({
             api: this.api,
             serviceFqn,
-            offerId,
-            pc, // Pass the peer connection from factory
-            dc, // Pass the data channel from factory
-            config: {
-                ...this.connectionConfig,
-                debug: this.debugEnabled,
-            },
+            maxOffers,
+            offerFactory: offerFactory || this.defaultOfferFactory.bind(this),
+            ttl: ttl || Rondevu.DEFAULT_TTL_MS,
+            iceServers: this.iceServers,
+            connectionConfig,
+            debugEnabled: this.debugEnabled,
         });
-        // Setup connection event handlers
-        connection.on('connected', () => {
-            this.debug(`Connection established for offer ${offerId}`);
+        // Forward events from OfferPool
+        this.offerPool.on('connection:opened', (offerId, connection) => {
             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
+        this.offerPool.on('offer:created', (offerId, serviceFqn) => {
+            this.emit('offer:created', offerId, serviceFqn);
         });
-        connection.on('closed', () => {
-            this.debug(`Connection closed for offer ${offerId}`);
-            this.activeConnections.delete(offerId);
-            this.fillOffers(); // Replace closed offer
+        this.offerPool.on('connection:rotated', (oldOfferId, newOfferId, connection) => {
+            this.emit('connection:rotated', oldOfferId, newOfferId, connection);
         });
-        // 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);
-    }
-    /**
-     * Fill offers to reach maxOffers count with semaphore protection
-     */
-    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);
-                }
-            }
-        }
-        finally {
-            this.fillingSemaphore = false;
-        }
-    }
-    /**
-     * Poll for answers and ICE candidates (internal use for automatic offer management)
-     */
-    async pollInternal() {
-        if (!this.filling)
-            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('[Rondevu] Polling error:', err);
-        }
+        this.usernameClaimed = true;
     }
     /**
      * Start filling offers and polling for answers/ICE
      * Call this after publishService() to begin accepting connections
      */
     async startFilling() {
-        if (this.filling) {
-            this.debug('Already filling');
-            return;
-        }
-        if (!this.currentService) {
+        if (!this.offerPool) {
             throw new Error('No service published. Call publishService() first.');
         }
         this.debug('Starting offer filling and polling');
-        this.filling = true;
-        // Fill initial offers
-        await this.fillOffers();
-        // Start polling
-        this.pollingInterval = setInterval(() => {
-            this.pollInternal();
-        }, Rondevu.POLLING_INTERVAL_MS);
+        await this.offerPool.start();
     }
     /**
      * Stop filling offers and polling
@@ -458,26 +333,14 @@ export class Rondevu extends EventEmitter {
      */
     stopFilling() {
         this.debug('Stopping offer filling and polling');
-        this.filling = false;
-        this.fillingSemaphore = false;
-        // 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();
-        }
-        this.activeConnections.clear();
+        this.offerPool?.stop();
     }
     /**
      * Get the count of active offers
      * @returns Number of active offers
      */
     getOfferCount() {
-        return this.activeConnections.size;
+        return this.offerPool?.getOfferCount() ?? 0;
     }
     /**
      * Check if an offer is currently connected
@@ -485,20 +348,15 @@ export class Rondevu extends EventEmitter {
      * @returns True if the offer exists and is connected
      */
     isConnected(offerId) {
-        const connection = this.activeConnections.get(offerId);
-        return connection ? connection.getState() === 'connected' : false;
+        return this.offerPool?.isConnected(offerId) ?? false;
     }
     /**
      * Disconnect all active offers
      * Similar to stopFilling() but doesn't stop the polling/filling process
      */
-    async disconnectAll() {
+    disconnectAll() {
         this.debug('Disconnecting all offers');
-        for (const [offerId, connection] of this.activeConnections.entries()) {
-            this.debug(`Closing connection ${offerId}`);
-            connection.close();
-        }
-        this.activeConnections.clear();
+        this.offerPool?.disconnectAll();
     }
     /**
      * Get the current service status
@@ -507,9 +365,7 @@ export class Rondevu extends EventEmitter {
     getServiceStatus() {
         return {
             active: this.currentService !== null,
-            offerCount: this.activeConnections.size,
-            maxOffers: this.maxOffers,
-            filling: this.filling
+            offerCount: this.offerPool?.getOfferCount() ?? 0
         };
     }
     /**
@@ -706,7 +562,7 @@ export class Rondevu extends EventEmitter {
      * Get active connections (for offerer side)
      */
     getActiveConnections() {
-        return this.activeConnections;
+        return this.offerPool?.getActiveConnections() ?? new Map();
     }
     /**
      * Get all active offers (legacy compatibility)
@@ -714,7 +570,8 @@ export class Rondevu extends EventEmitter {
      */
     getActiveOffers() {
         const offers = [];
-        for (const [offerId, connection] of this.activeConnections.entries()) {
+        const connections = this.offerPool?.getActiveConnections() ?? new Map();
+        for (const [offerId, connection] of connections.entries()) {
             const pc = connection.getPeerConnection();
             const dc = connection.getDataChannel();
             if (pc) {

package/dist/{node-crypto-adapter.d.ts → crypto/node.d.ts}

@@ -2,7 +2,7 @@
  * Node.js Crypto adapter for Node.js environments
  * Requires Node.js 19+ or Node.js 18 with --experimental-global-webcrypto flag
  */
-import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+import { CryptoAdapter, Keypair } from './adapter.js';
 /**
  * Node.js Crypto implementation using Node.js built-in APIs
  * Uses Buffer for base64 encoding and crypto.randomBytes for random generation

package/dist/{web-crypto-adapter.d.ts → crypto/web.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Web Crypto adapter for browser environments
  */
-import { CryptoAdapter, Keypair } from './crypto-adapter.js';
+import { CryptoAdapter, Keypair } from './adapter.js';
 /**
  * Web Crypto implementation using browser APIs
  * Uses btoa/atob for base64 encoding and crypto.getRandomValues for random bytes

package/dist/utils/async-lock.d.ts

@@ -0,0 +1,42 @@
+/**
+ * AsyncLock provides a mutual exclusion primitive for asynchronous operations.
+ * Ensures only one async operation can proceed at a time while queuing others.
+ */
+export declare class AsyncLock {
+    private locked;
+    private queue;
+    /**
+     * Acquire the lock. If already locked, waits until released.
+     * @returns Promise that resolves when lock is acquired
+     */
+    acquire(): Promise<void>;
+    /**
+     * Release the lock. If others are waiting, grants lock to next in queue.
+     */
+    release(): void;
+    /**
+     * 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()
+     * })
+     * ```
+     */
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Check if lock is currently held
+     */
+    isLocked(): boolean;
+    /**
+     * Get number of operations waiting for the lock
+     */
+    getQueueLength(): number;
+}

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.9",
+  "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,22 +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 { 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

@@ -1,17 +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 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-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;
-}