@xtr-dev/rondevu-client 0.21.8 → 0.21.10

package/dist/api/client.d.ts

@@ -18,6 +18,12 @@ export interface DiscoverRequest {
     limit?: number;
     offset?: number;
 }
+export interface CountOffersByTagsRequest {
+    tags: string[];
+}
+export interface CountOffersByTagsResponse {
+    counts: Record<string, number>;
+}
 export interface TaggedOffer {
     offerId: string;
     publicKey: string;
@@ -127,6 +133,13 @@ export declare class RondevuAPI {
      * @returns Paginated response if limit provided, single offer if not
      */
     discover(request: DiscoverRequest): Promise<DiscoverResponse | TaggedOffer>;
+    /**
+     * Count available offers by tags
+     * Returns the count of available (unanswered, non-expired) offers for each tag
+     * @param request - Request with tags to count
+     * @returns Object mapping each tag to its offer count
+     */
+    countOffersByTags(request: CountOffersByTagsRequest): Promise<CountOffersByTagsResponse>;
     /**
      * Delete an offer by ID
      */

package/dist/api/client.js

@@ -211,6 +211,22 @@ export class RondevuAPI {
         const authHeaders = await this.generateAuthHeaders(rpcRequest);
         return await this.rpc(rpcRequest, authHeaders);
     }
+    /**
+     * Count available offers by tags
+     * Returns the count of available (unanswered, non-expired) offers for each tag
+     * @param request - Request with tags to count
+     * @returns Object mapping each tag to its offer count
+     */
+    async countOffersByTags(request) {
+        const rpcRequest = {
+            method: 'countOffersByTags',
+            params: {
+                tags: request.tags,
+            },
+        };
+        const authHeaders = await this.generateAuthHeaders(rpcRequest);
+        return await this.rpc(rpcRequest, authHeaders);
+    }
     /**
      * Delete an offer by ID
      */

package/dist/connections/config.d.ts

@@ -6,7 +6,7 @@
  * Advanced options use sensible defaults.
  */
 export interface ConnectionOptions {
-    /** Maximum time to wait for connection (ms). Default: 30000 */
+    /** Maximum time to wait for connection (ms). Default: 10000 */
     timeout?: number;
     /** Enable automatic reconnection on failures. Default: true */
     reconnect?: boolean;

package/dist/connections/config.js

@@ -3,7 +3,7 @@
  */
 export const DEFAULT_CONNECTION_CONFIG = {
     // Timeouts
-    connectionTimeout: 30000, // 30 seconds
+    connectionTimeout: 10000, // 10 seconds
     iceGatheringTimeout: 10000, // 10 seconds
     // Reconnection
     reconnectEnabled: true,

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

@@ -52,6 +52,7 @@ export declare class OfferPool extends EventEmitter<OfferPoolEvents> {
     private readonly debugEnabled;
     private readonly offerCreationThrottleMs;
     private readonly activeConnections;
+    private readonly rotatedOfferIds;
     private readonly matchedTagsByOffer;
     private readonly fillLock;
     private running;
@@ -123,6 +124,11 @@ export declare class OfferPool extends EventEmitter<OfferPoolEvents> {
      * Called by Rondevu when a poll:ice event is received
      */
     handlePollIce(data: PollIceEvent): void;
+    /**
+     * Resolve an offerId through the rotation chain to find the current offerId
+     * Returns the final offerId or undefined if not found
+     */
+    private resolveRotatedOfferId;
     /**
      * Debug logging (only if debug enabled)
      */

package/dist/core/offer-pool.js

@@ -11,6 +11,7 @@ export class OfferPool extends EventEmitter {
         super();
         // State
         this.activeConnections = new Map();
+        this.rotatedOfferIds = new Map(); // Maps old offerId -> new offerId for late-arriving answers
         this.matchedTagsByOffer = new Map(); // Track matchedTags from answers
         this.fillLock = new AsyncLock();
         this.running = false;
@@ -57,6 +58,8 @@ export class OfferPool extends EventEmitter {
             connection.close();
         }
         this.activeConnections.clear();
+        this.rotatedOfferIds.clear();
+        this.matchedTagsByOffer.clear();
     }
     /**
      * Get count of active offers
@@ -230,20 +233,37 @@ export class OfferPool extends EventEmitter {
                 return;
             }
             this.debug(`Proceeding with rotation for offer ${currentOfferId}`);
+            // Track new RTCPeerConnection for cleanup if rotation fails
+            let newPcForCleanup = null;
             try {
                 // Create new offer and rebind existing connection
                 const { newOfferId, pc, dc } = await this.createNewOfferForRotation();
-                // Rebind the connection to new offer
+                newPcForCleanup = pc; // Track for cleanup if rebind fails
+                // Rebind the connection to new offer (this closes the old pc)
                 await connection.rebindToOffer(newOfferId, pc, dc);
+                newPcForCleanup = null; // Rebind succeeded, pc is now managed by connection
                 // Update map: remove old offerId, add new offerId with same connection
                 this.activeConnections.delete(currentOfferId);
                 this.activeConnections.set(newOfferId, connection);
+                // Track rotation so late-arriving answers for old offerId can be forwarded
+                this.rotatedOfferIds.set(currentOfferId, newOfferId);
                 this.emit('connection:rotated', currentOfferId, newOfferId, connection);
                 this.debug(`Connection rotated: ${currentOfferId} → ${newOfferId}`);
             }
             catch (rotationError) {
-                // If rotation fails, fall back to destroying connection
+                // If rotation fails, clean up all RTCPeerConnections to prevent resource leak
                 this.debug(`Rotation failed for ${currentOfferId}:`, rotationError);
+                // Close the new pc if it was created but rebind failed
+                if (newPcForCleanup) {
+                    try {
+                        newPcForCleanup.close();
+                    }
+                    catch {
+                        // Ignore close errors
+                    }
+                }
+                // Close the old connection (closes its RTCPeerConnection)
+                connection.close();
                 this.activeConnections.delete(currentOfferId);
                 this.emit('offer:failed', currentOfferId, error);
                 this.fillOffers(); // Create replacement
@@ -268,12 +288,25 @@ export class OfferPool extends EventEmitter {
     async handlePollAnswer(data) {
         if (!this.running)
             return;
-        const connection = this.activeConnections.get(data.offerId);
+        // Find connection - check direct mapping first, then rotated offers
+        let connection = this.activeConnections.get(data.offerId);
+        let effectiveOfferId = data.offerId;
+        if (!connection) {
+            // Check if this is a late-arriving answer for a rotated offer
+            const newOfferId = this.resolveRotatedOfferId(data.offerId);
+            if (newOfferId && newOfferId !== data.offerId) {
+                connection = this.activeConnections.get(newOfferId);
+                effectiveOfferId = newOfferId;
+                if (connection) {
+                    this.debug(`Late answer for rotated offer ${data.offerId} → forwarding to ${newOfferId}`);
+                }
+            }
+        }
         if (connection) {
-            this.debug(`Processing answer for offer ${data.offerId}`);
+            this.debug(`Processing answer for offer ${effectiveOfferId}`);
             // Store matchedTags for when connection opens
             if (data.matchedTags) {
-                this.matchedTagsByOffer.set(data.offerId, data.matchedTags);
+                this.matchedTagsByOffer.set(effectiveOfferId, data.matchedTags);
             }
             try {
                 await connection.processAnswer(data.sdp, data.answererPublicKey);
@@ -281,7 +314,7 @@ export class OfferPool extends EventEmitter {
                 this.fillOffers();
             }
             catch (err) {
-                this.debug(`Failed to process answer for offer ${data.offerId}:`, err);
+                this.debug(`Failed to process answer for offer ${effectiveOfferId}:`, err);
             }
         }
         // Silently ignore answers for offers we don't have - they may be for other connections
@@ -293,13 +326,42 @@ export class OfferPool extends EventEmitter {
     handlePollIce(data) {
         if (!this.running)
             return;
-        const connection = this.activeConnections.get(data.offerId);
+        // Find connection - check direct mapping first, then rotated offers
+        let connection = this.activeConnections.get(data.offerId);
+        if (!connection) {
+            // Check if this is late-arriving ICE for a rotated offer
+            const newOfferId = this.resolveRotatedOfferId(data.offerId);
+            if (newOfferId && newOfferId !== data.offerId) {
+                connection = this.activeConnections.get(newOfferId);
+                if (connection) {
+                    this.debug(`Late ICE for rotated offer ${data.offerId} → forwarding to ${newOfferId}`);
+                }
+            }
+        }
         if (connection) {
             this.debug(`Processing ${data.candidates.length} ICE candidates for offer ${data.offerId}`);
             connection.handleRemoteIceCandidates(data.candidates);
         }
         // Silently ignore ICE candidates for offers we don't have
     }
+    /**
+     * Resolve an offerId through the rotation chain to find the current offerId
+     * Returns the final offerId or undefined if not found
+     */
+    resolveRotatedOfferId(offerId) {
+        let currentId = offerId;
+        const visited = new Set();
+        while (this.rotatedOfferIds.has(currentId)) {
+            if (visited.has(currentId)) {
+                // Circular reference - shouldn't happen but protect against it
+                this.debug(`Circular rotation detected for ${offerId}`);
+                return undefined;
+            }
+            visited.add(currentId);
+            currentId = this.rotatedOfferIds.get(currentId);
+        }
+        return currentId !== offerId ? currentId : undefined;
+    }
     /**
      * Debug logging (only if debug enabled)
      */

package/dist/core/rondevu.d.ts

@@ -255,6 +255,22 @@ export declare class Rondevu extends EventEmitter {
      * ```
      */
     discover(tags: string[], options?: DiscoverOptions): Promise<DiscoverResult>;
+    /**
+     * Count available offers by tags
+     * Returns the count of available (unanswered, non-expired) offers for each tag
+     *
+     * @param tags - Tags to count offers for
+     * @returns Object mapping each tag to its offer count
+     *
+     * @example
+     * ```typescript
+     * const counts = await rondevu.countOffersByTags(['chat', 'video'])
+     * console.log(counts.counts)  // { chat: 5, video: 3 }
+     * ```
+     */
+    countOffersByTags(tags: string[]): Promise<{
+        counts: Record<string, number>;
+    }>;
     /**
      * Post answer SDP to specific offer
      */

package/dist/core/rondevu.js

@@ -446,6 +446,22 @@ export class Rondevu extends EventEmitter {
         // Always pass limit to ensure we get DiscoverResponse (paginated mode)
         return (await this.api.discover({ tags, limit, offset }));
     }
+    /**
+     * Count available offers by tags
+     * Returns the count of available (unanswered, non-expired) offers for each tag
+     *
+     * @param tags - Tags to count offers for
+     * @returns Object mapping each tag to its offer count
+     *
+     * @example
+     * ```typescript
+     * const counts = await rondevu.countOffersByTags(['chat', 'video'])
+     * console.log(counts.counts)  // { chat: 5, video: 3 }
+     * ```
+     */
+    async countOffersByTags(tags) {
+        return await this.api.countOffersByTags({ tags });
+    }
     // ============================================
     // WebRTC Signaling
     // ============================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.21.8",
+  "version": "0.21.10",
   "description": "TypeScript client for Rondevu with durable WebRTC connections, automatic reconnection, and message queuing",
   "type": "module",
   "main": "dist/core/index.js",