@xtr-dev/rondevu-client 0.21.9 → 0.21.11

package/dist/api/client.d.ts

@@ -18,6 +18,13 @@ export interface DiscoverRequest {
     limit?: number;
     offset?: number;
 }
+export interface CountOffersByTagsRequest {
+    tags: string[];
+    unique?: boolean;
+}
+export interface CountOffersByTagsResponse {
+    counts: Record<string, number>;
+}
 export interface TaggedOffer {
     offerId: string;
     publicKey: string;
@@ -127,6 +134,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 and optional unique flag
+     * @returns Object mapping each tag to its count
+     */
+    countOffersByTags(request: CountOffersByTagsRequest): Promise<CountOffersByTagsResponse>;
     /**
      * Delete an offer by ID
      */

package/dist/api/client.js

@@ -211,6 +211,23 @@ 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 and optional unique flag
+     * @returns Object mapping each tag to its count
+     */
+    async countOffersByTags(request) {
+        const rpcRequest = {
+            method: 'countOffersByTags',
+            params: {
+                tags: request.tags,
+                ...(request.unique !== undefined && { unique: request.unique }),
+            },
+        };
+        const authHeaders = await this.generateAuthHeaders(rpcRequest);
+        return await this.rpc(rpcRequest, authHeaders);
+    }
     /**
      * Delete an offer by ID
      */

package/dist/connections/base.js

@@ -123,6 +123,9 @@ export class RondevuConnection extends EventEmitter {
                 if (this.state === ConnectionState.SIGNALING) {
                     this.transitionTo(ConnectionState.CHECKING, 'ICE checking started');
                 }
+                // ICE is progressing - clear the connection timeout to give ICE time to complete
+                // The timeout was for signaling, ICE checking shows progress is being made
+                this.clearConnectionTimeout();
                 // Note: ICE candidate polling is handled by PollingManager
                 // Candidates are received via handleRemoteIceCandidates()
                 break;

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: 10000 */
+    /** Maximum time to wait for connection (ms). Default: 30000 */
     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: 10000, // 10 seconds
+    connectionTimeout: 30000, // 30 seconds (should be less than server offer TTL)
     iceGatheringTimeout: 10000, // 10 seconds
     // Reconnection
     reconnectEnabled: true,

package/dist/core/offer-pool.js

@@ -233,11 +233,15 @@ 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);
@@ -247,8 +251,19 @@ export class OfferPool extends EventEmitter {
                 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

package/dist/core/polling-manager.js

@@ -30,6 +30,7 @@ export class PollingManager extends EventEmitter {
             this.debug('Already running');
             return;
         }
+        console.log('[PollingManager] Starting polling manager');
         this.debug('Starting polling manager');
         this.running = true;
         // Poll immediately
@@ -74,6 +75,11 @@ export class PollingManager extends EventEmitter {
             return;
         try {
             const result = await this.api.poll(this.lastPollTimestamp);
+            // Log poll results for debugging (only when there are results)
+            const iceCount = Object.values(result.iceCandidates).reduce((sum, candidates) => sum + candidates.length, 0);
+            if (result.answers.length > 0 || iceCount > 0) {
+                console.log(`[PollingManager] Poll: ${result.answers.length} answers, ${iceCount} ICE (since: ${this.lastPollTimestamp})`);
+            }
             // Emit answer events
             for (const answer of result.answers) {
                 this.debug(`Poll: answer for ${answer.offerId}`);

package/dist/core/rondevu.d.ts

@@ -255,6 +255,26 @@ 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
+     * @param unique - If true, count unique public keys instead of total offers
+     * @returns Object mapping each tag to its count
+     *
+     * @example
+     * ```typescript
+     * const counts = await rondevu.countOffersByTags(['chat', 'video'])
+     * console.log(counts.counts)  // { chat: 5, video: 3 }
+     *
+     * // Count unique peers instead of total offers
+     * const uniquePeers = await rondevu.countOffersByTags(['chat'], true)
+     * ```
+     */
+    countOffersByTags(tags: string[], unique?: boolean): Promise<{
+        counts: Record<string, number>;
+    }>;
     /**
      * Post answer SDP to specific offer
      */

package/dist/core/rondevu.js

@@ -446,6 +446,26 @@ 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
+     * @param unique - If true, count unique public keys instead of total offers
+     * @returns Object mapping each tag to its count
+     *
+     * @example
+     * ```typescript
+     * const counts = await rondevu.countOffersByTags(['chat', 'video'])
+     * console.log(counts.counts)  // { chat: 5, video: 3 }
+     *
+     * // Count unique peers instead of total offers
+     * const uniquePeers = await rondevu.countOffersByTags(['chat'], true)
+     * ```
+     */
+    async countOffersByTags(tags, unique) {
+        return await this.api.countOffersByTags({ tags, unique });
+    }
     // ============================================
     // WebRTC Signaling
     // ============================================

package/package.json

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