@xtr-dev/rondevu-client 0.8.2 → 0.9.1

package/dist/durable/service.js

@@ -0,0 +1,264 @@
+/**
+ * DurableService - Service with automatic TTL refresh
+ *
+ * Manages service publishing with automatic reconnection for incoming
+ * connections and TTL auto-refresh to prevent expiration.
+ */
+import { EventEmitter } from '../event-emitter.js';
+import { ServicePool } from '../service-pool.js';
+import { DurableChannel } from './channel.js';
+/**
+ * Default configuration for durable services
+ */
+const DEFAULT_CONFIG = {
+    isPublic: false,
+    ttlRefreshMargin: 0.2,
+    poolSize: 1,
+    pollingInterval: 2000,
+    maxReconnectAttempts: 10,
+    reconnectBackoffBase: 1000,
+    reconnectBackoffMax: 30000,
+    reconnectJitter: 0.2,
+    connectionTimeout: 30000,
+    maxQueueSize: 1000,
+    maxMessageAge: 60000,
+    rtcConfig: {
+        iceServers: [
+            { urls: 'stun:stun.l.google.com:19302' },
+            { urls: 'stun:stun1.l.google.com:19302' }
+        ]
+    }
+};
+/**
+ * Durable service that automatically refreshes TTL and handles reconnections
+ *
+ * The DurableService manages service publishing and provides:
+ * - Automatic TTL refresh before expiration
+ * - Durable connections for incoming peers
+ * - Connection pooling for multiple simultaneous connections
+ * - High-level connection lifecycle events
+ *
+ * @example
+ * ```typescript
+ * const service = new DurableService(
+ *   offersApi,
+ *   (channel, connectionId) => {
+ *     channel.on('message', (data) => {
+ *       console.log(`Message from ${connectionId}:`, data);
+ *       channel.send(`Echo: ${data}`);
+ *     });
+ *   },
+ *   {
+ *     username: 'alice',
+ *     privateKey: keypair.privateKey,
+ *     serviceFqn: 'chat@1.0.0',
+ *     poolSize: 10
+ *   }
+ * );
+ *
+ * service.on('published', (serviceId, uuid) => {
+ *   console.log(`Service published: ${uuid}`);
+ * });
+ *
+ * service.on('connection', (connectionId) => {
+ *   console.log(`New connection: ${connectionId}`);
+ * });
+ *
+ * await service.start();
+ * ```
+ */
+export class DurableService extends EventEmitter {
+    constructor(offersApi, baseUrl, credentials, handler, config) {
+        super();
+        this.offersApi = offersApi;
+        this.baseUrl = baseUrl;
+        this.credentials = credentials;
+        this.handler = handler;
+        this.activeChannels = new Map();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Start the service
+     *
+     * Publishes the service and begins accepting connections.
+     *
+     * @returns Service information
+     */
+    async start() {
+        if (this.servicePool) {
+            throw new Error('Service already started');
+        }
+        // Create and start service pool
+        this.servicePool = new ServicePool(this.baseUrl, this.credentials, {
+            username: this.config.username,
+            privateKey: this.config.privateKey,
+            serviceFqn: this.config.serviceFqn,
+            rtcConfig: this.config.rtcConfig,
+            isPublic: this.config.isPublic,
+            metadata: this.config.metadata,
+            ttl: this.config.ttl,
+            poolSize: this.config.poolSize,
+            pollingInterval: this.config.pollingInterval,
+            handler: (channel, peer, connectionId) => {
+                this.handleNewConnection(channel, connectionId);
+            },
+            onPoolStatus: (status) => {
+                // Could emit pool status event if needed
+            },
+            onError: (error, context) => {
+                this.emit('error', error, context);
+            }
+        });
+        const handle = await this.servicePool.start();
+        // Store service info
+        this.serviceId = handle.serviceId;
+        this.uuid = handle.uuid;
+        this.expiresAt = Date.now() + (this.config.ttl || 300000); // Default 5 minutes
+        this.emit('published', this.serviceId, this.uuid);
+        // Schedule TTL refresh
+        this.scheduleRefresh();
+        return {
+            serviceId: this.serviceId,
+            uuid: this.uuid,
+            expiresAt: this.expiresAt
+        };
+    }
+    /**
+     * Stop the service
+     *
+     * Unpublishes the service and closes all active connections.
+     */
+    async stop() {
+        // Cancel TTL refresh
+        if (this.ttlRefreshTimer) {
+            clearTimeout(this.ttlRefreshTimer);
+            this.ttlRefreshTimer = undefined;
+        }
+        // Close all active channels
+        for (const channel of this.activeChannels.values()) {
+            channel.close();
+        }
+        this.activeChannels.clear();
+        // Stop service pool
+        if (this.servicePool) {
+            await this.servicePool.stop();
+            this.servicePool = undefined;
+        }
+        this.emit('closed');
+    }
+    /**
+     * Get list of active connection IDs
+     */
+    getActiveConnections() {
+        return Array.from(this.activeChannels.keys());
+    }
+    /**
+     * Get service information
+     */
+    getServiceInfo() {
+        if (!this.serviceId || !this.uuid || !this.expiresAt) {
+            return null;
+        }
+        return {
+            serviceId: this.serviceId,
+            uuid: this.uuid,
+            expiresAt: this.expiresAt
+        };
+    }
+    /**
+     * Schedule TTL refresh
+     */
+    scheduleRefresh() {
+        if (!this.expiresAt || !this.config.ttl) {
+            return;
+        }
+        // Cancel existing timer
+        if (this.ttlRefreshTimer) {
+            clearTimeout(this.ttlRefreshTimer);
+        }
+        // Calculate refresh time (default: refresh at 80% of TTL)
+        const timeUntilExpiry = this.expiresAt - Date.now();
+        const refreshMargin = timeUntilExpiry * this.config.ttlRefreshMargin;
+        const refreshTime = Math.max(0, timeUntilExpiry - refreshMargin);
+        // Schedule refresh
+        this.ttlRefreshTimer = setTimeout(() => {
+            this.refreshServiceTTL().catch(error => {
+                this.emit('error', error, 'ttl-refresh');
+                // Retry after short delay
+                setTimeout(() => this.scheduleRefresh(), 5000);
+            });
+        }, refreshTime);
+    }
+    /**
+     * Refresh service TTL
+     */
+    async refreshServiceTTL() {
+        if (!this.serviceId || !this.uuid) {
+            return;
+        }
+        // Delete old service
+        await this.servicePool?.stop();
+        // Recreate service pool (this republishes the service)
+        this.servicePool = new ServicePool(this.baseUrl, this.credentials, {
+            username: this.config.username,
+            privateKey: this.config.privateKey,
+            serviceFqn: this.config.serviceFqn,
+            rtcConfig: this.config.rtcConfig,
+            isPublic: this.config.isPublic,
+            metadata: this.config.metadata,
+            ttl: this.config.ttl,
+            poolSize: this.config.poolSize,
+            pollingInterval: this.config.pollingInterval,
+            handler: (channel, peer, connectionId) => {
+                this.handleNewConnection(channel, connectionId);
+            },
+            onPoolStatus: (status) => {
+                // Could emit pool status event if needed
+            },
+            onError: (error, context) => {
+                this.emit('error', error, context);
+            }
+        });
+        const handle = await this.servicePool.start();
+        // Update service info
+        this.serviceId = handle.serviceId;
+        this.uuid = handle.uuid;
+        this.expiresAt = Date.now() + (this.config.ttl || 300000);
+        this.emit('ttl-refreshed', this.expiresAt);
+        // Schedule next refresh
+        this.scheduleRefresh();
+    }
+    /**
+     * Handle new incoming connection
+     */
+    handleNewConnection(channel, connectionId) {
+        // Create durable channel
+        const durableChannel = new DurableChannel(channel.label, {
+            maxQueueSize: this.config.maxQueueSize,
+            maxMessageAge: this.config.maxMessageAge
+        });
+        // Attach to underlying channel
+        durableChannel.attachToChannel(channel);
+        // Track channel
+        this.activeChannels.set(connectionId, durableChannel);
+        // Setup cleanup on close
+        durableChannel.on('close', () => {
+            this.activeChannels.delete(connectionId);
+            this.emit('disconnection', connectionId);
+        });
+        // Emit connection event
+        this.emit('connection', connectionId);
+        // Invoke user handler
+        try {
+            const result = this.handler(durableChannel, connectionId);
+            if (result && typeof result.then === 'function') {
+                result.catch(error => {
+                    this.emit('error', error, 'handler');
+                });
+            }
+        }
+        catch (error) {
+            this.emit('error', error, 'handler');
+        }
+    }
+}

package/dist/durable/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Type definitions for durable WebRTC connections
+ *
+ * This module defines all interfaces, enums, and types used by the durable
+ * connection system for automatic reconnection and message queuing.
+ */
+/**
+ * Connection state enum
+ */
+export declare enum DurableConnectionState {
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    DISCONNECTED = "disconnected",
+    FAILED = "failed",
+    CLOSED = "closed"
+}
+/**
+ * Channel state enum
+ */
+export declare enum DurableChannelState {
+    CONNECTING = "connecting",
+    OPEN = "open",
+    CLOSING = "closing",
+    CLOSED = "closed"
+}
+/**
+ * Configuration for durable connections
+ */
+export interface DurableConnectionConfig {
+    /** Maximum number of reconnection attempts (default: 10) */
+    maxReconnectAttempts?: number;
+    /** Base delay for exponential backoff in milliseconds (default: 1000) */
+    reconnectBackoffBase?: number;
+    /** Maximum delay between reconnection attempts in milliseconds (default: 30000) */
+    reconnectBackoffMax?: number;
+    /** Jitter factor for randomizing reconnection delays (default: 0.2 = ±20%) */
+    reconnectJitter?: number;
+    /** Timeout for initial connection attempt in milliseconds (default: 30000) */
+    connectionTimeout?: number;
+    /** Maximum number of messages to queue during disconnection (default: 1000) */
+    maxQueueSize?: number;
+    /** Maximum age of queued messages in milliseconds (default: 60000) */
+    maxMessageAge?: number;
+    /** WebRTC configuration */
+    rtcConfig?: RTCConfiguration;
+}
+/**
+ * Configuration for durable channels
+ */
+export interface DurableChannelConfig {
+    /** Maximum number of messages to queue (default: 1000) */
+    maxQueueSize?: number;
+    /** Maximum age of queued messages in milliseconds (default: 60000) */
+    maxMessageAge?: number;
+    /** Whether messages should be delivered in order (default: true) */
+    ordered?: boolean;
+    /** Maximum retransmits for unordered channels (default: undefined) */
+    maxRetransmits?: number;
+}
+/**
+ * Configuration for durable services
+ */
+export interface DurableServiceConfig extends DurableConnectionConfig {
+    /** Username that owns the service */
+    username: string;
+    /** Private key for signing service operations */
+    privateKey: string;
+    /** Fully qualified service name (e.g., com.example.chat@1.0.0) */
+    serviceFqn: string;
+    /** Whether the service is publicly discoverable (default: false) */
+    isPublic?: boolean;
+    /** Optional metadata for the service */
+    metadata?: Record<string, any>;
+    /** Time-to-live for service in milliseconds (default: server default) */
+    ttl?: number;
+    /** Margin before TTL expiry to trigger refresh (default: 0.2 = refresh at 80%) */
+    ttlRefreshMargin?: number;
+    /** Number of simultaneous open offers to maintain (default: 1) */
+    poolSize?: number;
+    /** Polling interval for checking answers in milliseconds (default: 2000) */
+    pollingInterval?: number;
+}
+/**
+ * Queued message structure
+ */
+export interface QueuedMessage {
+    /** Message data */
+    data: string | Blob | ArrayBuffer | ArrayBufferView;
+    /** Timestamp when message was enqueued */
+    enqueuedAt: number;
+    /** Unique message ID */
+    id: string;
+}
+/**
+ * Event type map for DurableConnection
+ */
+export interface DurableConnectionEvents extends Record<string, (...args: any[]) => void> {
+    'state': (state: DurableConnectionState, previousState: DurableConnectionState) => void;
+    'connected': () => void;
+    'reconnecting': (attempt: number, maxAttempts: number, nextRetryIn: number) => void;
+    'disconnected': () => void;
+    'failed': (error: Error, permanent: boolean) => void;
+    'closed': () => void;
+}
+/**
+ * Event type map for DurableChannel
+ */
+export interface DurableChannelEvents extends Record<string, (...args: any[]) => void> {
+    'open': () => void;
+    'message': (data: any) => void;
+    'error': (error: Error) => void;
+    'close': () => void;
+    'bufferedAmountLow': () => void;
+    'queueOverflow': (droppedCount: number) => void;
+}
+/**
+ * Event type map for DurableService
+ */
+export interface DurableServiceEvents extends Record<string, (...args: any[]) => void> {
+    'published': (serviceId: string, uuid: string) => void;
+    'connection': (connectionId: string) => void;
+    'disconnection': (connectionId: string) => void;
+    'ttl-refreshed': (expiresAt: number) => void;
+    'error': (error: Error, context: string) => void;
+    'closed': () => void;
+}
+/**
+ * Information about a durable connection
+ */
+export interface ConnectionInfo {
+    /** Username (for username-based connections) */
+    username?: string;
+    /** Service FQN (for service-based connections) */
+    serviceFqn?: string;
+    /** UUID (for UUID-based connections) */
+    uuid?: string;
+}
+/**
+ * Service information returned when service is published
+ */
+export interface ServiceInfo {
+    /** Service ID */
+    serviceId: string;
+    /** Service UUID for discovery */
+    uuid: string;
+    /** Expiration timestamp */
+    expiresAt: number;
+}

package/dist/durable/types.js

@@ -0,0 +1,28 @@
+/**
+ * Type definitions for durable WebRTC connections
+ *
+ * This module defines all interfaces, enums, and types used by the durable
+ * connection system for automatic reconnection and message queuing.
+ */
+/**
+ * Connection state enum
+ */
+export var DurableConnectionState;
+(function (DurableConnectionState) {
+    DurableConnectionState["CONNECTING"] = "connecting";
+    DurableConnectionState["CONNECTED"] = "connected";
+    DurableConnectionState["RECONNECTING"] = "reconnecting";
+    DurableConnectionState["DISCONNECTED"] = "disconnected";
+    DurableConnectionState["FAILED"] = "failed";
+    DurableConnectionState["CLOSED"] = "closed";
+})(DurableConnectionState || (DurableConnectionState = {}));
+/**
+ * Channel state enum
+ */
+export var DurableChannelState;
+(function (DurableChannelState) {
+    DurableChannelState["CONNECTING"] = "connecting";
+    DurableChannelState["OPEN"] = "open";
+    DurableChannelState["CLOSING"] = "closing";
+    DurableChannelState["CLOSED"] = "closed";
+})(DurableChannelState || (DurableChannelState = {}));

package/dist/index.d.ts

@@ -1,19 +1,14 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with topic-based discovery
+ * WebRTC peer signaling and discovery client with durable connections
  */
 export { Rondevu } from './rondevu.js';
 export type { RondevuOptions } from './rondevu.js';
 export { RondevuAuth } from './auth.js';
 export type { Credentials, FetchFunction } from './auth.js';
-export { RondevuOffers } from './offers.js';
-export type { CreateOfferRequest, Offer, IceCandidate, TopicInfo } from './offers.js';
-export { default as RondevuPeer } from './peer/index.js';
-export type { PeerOptions, PeerEvents, PeerTimeouts } from './peer/index.js';
 export { RondevuUsername } from './usernames.js';
 export type { UsernameClaimResult, UsernameCheckResult } from './usernames.js';
-export { RondevuServices } from './services.js';
-export type { ServicePublishResult, PublishServiceOptions, ServiceHandle } from './services.js';
-export { RondevuDiscovery } from './discovery.js';
-export type { ServiceInfo, ServiceListResult, ServiceQueryResult, ServiceDetails, ConnectResult } from './discovery.js';
-export type { PoolStatus, PooledServiceHandle } from './service-pool.js';
+export { DurableConnection } from './durable/connection.js';
+export { DurableChannel } from './durable/channel.js';
+export { DurableService } from './durable/service.js';
+export type { DurableConnectionState, DurableChannelState, DurableConnectionConfig, DurableChannelConfig, DurableServiceConfig, QueuedMessage, DurableConnectionEvents, DurableChannelEvents, DurableServiceEvents, ConnectionInfo, ServiceInfo } from './durable/types.js';

package/dist/index.js

@@ -1,18 +1,14 @@
 /**
  * @xtr-dev/rondevu-client
- * WebRTC peer signaling and discovery client with topic-based discovery
+ * WebRTC peer signaling and discovery client with durable connections
  */
 // Export main client class
 export { Rondevu } from './rondevu.js';
 // Export authentication
 export { RondevuAuth } from './auth.js';
-// Export offers API
-export { RondevuOffers } from './offers.js';
-// Export peer manager
-export { default as RondevuPeer } from './peer/index.js';
 // Export username API
 export { RondevuUsername } from './usernames.js';
-// Export services API
-export { RondevuServices } from './services.js';
-// Export discovery API
-export { RondevuDiscovery } from './discovery.js';
+// Export durable connection APIs
+export { DurableConnection } from './durable/connection.js';
+export { DurableChannel } from './durable/channel.js';
+export { DurableService } from './durable/service.js';

package/dist/offer-pool.d.ts

@@ -6,6 +6,8 @@ export interface AnsweredOffer {
     offerId: string;
     answererId: string;
     sdp: string;
+    peerConnection: RTCPeerConnection;
+    dataChannel?: RTCDataChannel;
     answeredAt: number;
 }
 /**
@@ -19,7 +21,11 @@ export interface OfferPoolOptions {
     /** Callback invoked when an offer is answered */
     onAnswered: (answer: AnsweredOffer) => Promise<void>;
     /** Callback to create new offers when refilling the pool */
-    onRefill: (count: number) => Promise<Offer[]>;
+    onRefill: (count: number) => Promise<{
+        offers: Offer[];
+        peerConnections: RTCPeerConnection[];
+        dataChannels: RTCDataChannel[];
+    }>;
     /** Error handler for pool operations */
     onError: (error: Error, context: string) => void;
 }
@@ -34,15 +40,17 @@ export declare class OfferPool {
     private offersApi;
     private options;
     private offers;
+    private peerConnections;
+    private dataChannels;
     private polling;
     private pollingTimer?;
     private lastPollTime;
     private readonly pollingInterval;
     constructor(offersApi: RondevuOffers, options: OfferPoolOptions);
     /**
-     * Add offers to the pool
+     * Add offers to the pool with their peer connections and data channels
      */
-    addOffers(offers: Offer[]): Promise<void>;
+    addOffers(offers: Offer[], peerConnections?: RTCPeerConnection[], dataChannels?: RTCDataChannel[]): Promise<void>;
     /**
      * Start polling for answers
      */
@@ -63,6 +71,10 @@ export declare class OfferPool {
      * Get all active offer IDs
      */
     getActiveOfferIds(): string[];
+    /**
+     * Get all active peer connections
+     */
+    getActivePeerConnections(): RTCPeerConnection[];
     /**
      * Get the last poll timestamp
      */

package/dist/offer-pool.js

@@ -10,16 +10,25 @@ export class OfferPool {
         this.offersApi = offersApi;
         this.options = options;
         this.offers = new Map();
+        this.peerConnections = new Map();
+        this.dataChannels = new Map();
         this.polling = false;
         this.lastPollTime = 0;
         this.pollingInterval = options.pollingInterval || 2000;
     }
     /**
-     * Add offers to the pool
+     * Add offers to the pool with their peer connections and data channels
      */
-    async addOffers(offers) {
-        for (const offer of offers) {
+    async addOffers(offers, peerConnections, dataChannels) {
+        for (let i = 0; i < offers.length; i++) {
+            const offer = offers[i];
             this.offers.set(offer.id, offer);
+            if (peerConnections && peerConnections[i]) {
+                this.peerConnections.set(offer.id, peerConnections[i]);
+            }
+            if (dataChannels && dataChannels[i]) {
+                this.dataChannels.set(offer.id, dataChannels[i]);
+            }
         }
     }
     /**
@@ -64,22 +73,33 @@ export class OfferPool {
             const myAnswers = answers.filter(a => this.offers.has(a.offerId));
             // Process each answer
             for (const answer of myAnswers) {
-                // Notify ServicePool
+                // Get the original offer, peer connection, and data channel
+                const offer = this.offers.get(answer.offerId);
+                const pc = this.peerConnections.get(answer.offerId);
+                const channel = this.dataChannels.get(answer.offerId);
+                if (!offer || !pc) {
+                    continue; // Offer or peer connection already consumed, skip
+                }
+                // Remove from pool BEFORE processing to prevent duplicate processing
+                this.offers.delete(answer.offerId);
+                this.peerConnections.delete(answer.offerId);
+                this.dataChannels.delete(answer.offerId);
+                // Notify ServicePool with answer, original peer connection, and data channel
                 await this.options.onAnswered({
                     offerId: answer.offerId,
                     answererId: answer.answererId,
                     sdp: answer.sdp,
+                    peerConnection: pc,
+                    dataChannel: channel,
                     answeredAt: answer.answeredAt
                 });
-                // Remove consumed offer from pool
-                this.offers.delete(answer.offerId);
             }
             // Immediate refill if below pool size
             if (this.offers.size < this.options.poolSize) {
                 const needed = this.options.poolSize - this.offers.size;
                 try {
-                    const newOffers = await this.options.onRefill(needed);
-                    await this.addOffers(newOffers);
+                    const result = await this.options.onRefill(needed);
+                    await this.addOffers(result.offers, result.peerConnections, result.dataChannels);
                 }
                 catch (refillError) {
                     this.options.onError(refillError, 'refill');
@@ -104,6 +124,12 @@ export class OfferPool {
     getActiveOfferIds() {
         return Array.from(this.offers.keys());
     }
+    /**
+     * Get all active peer connections
+     */
+    getActivePeerConnections() {
+        return Array.from(this.peerConnections.values());
+    }
     /**
      * Get the last poll timestamp
      */

package/dist/peer/exchanging-ice-state.js

@@ -21,14 +21,22 @@ export class ExchangingIceState extends PeerState {
         this.pollingInterval = setInterval(async () => {
             try {
                 const candidates = await this.peer.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
+                if (candidates.length > 0) {
+                    console.log(`📥 Received ${candidates.length} remote ICE candidate(s)`);
+                }
                 for (const cand of candidates) {
                     if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
+                        const type = cand.candidate.candidate.includes('typ host') ? 'host' :
+                            cand.candidate.candidate.includes('typ srflx') ? 'srflx' :
+                                cand.candidate.candidate.includes('typ relay') ? 'relay' : 'unknown';
+                        console.log(`🧊 Adding remote ${type} ICE candidate:`, cand.candidate.candidate);
                         try {
                             await this.peer.pc.addIceCandidate(new this.peer.RTCIceCandidate(cand.candidate));
+                            console.log(`✅ Added remote ${type} ICE candidate`);
                             this.lastIceTimestamp = cand.createdAt;
                         }
                         catch (err) {
-                            console.warn('Failed to add ICE candidate:', err);
+                            console.warn(`⚠️ Failed to add remote ${type} ICE candidate:`, err);
                             this.lastIceTimestamp = cand.createdAt;
                         }
                     }
@@ -38,7 +46,7 @@ export class ExchangingIceState extends PeerState {
                 }
             }
             catch (err) {
-                console.error('Error polling for ICE candidates:', err);
+                console.error('❌ Error polling for ICE candidates:', err);
                 if (err instanceof Error && err.message.includes('not found')) {
                     this.cleanup();
                     const { FailedState } = await import('./failed-state.js');

package/dist/peer/index.d.ts

@@ -32,7 +32,7 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
      * RTCPeerConnection state
      */
     get connectionState(): RTCPeerConnectionState;
-    constructor(offersApi: RondevuOffers, rtcConfig?: RTCConfiguration, rtcPeerConnection?: typeof RTCPeerConnection, rtcSessionDescription?: typeof RTCSessionDescription, rtcIceCandidate?: typeof RTCIceCandidate);
+    constructor(offersApi: RondevuOffers, rtcConfig?: RTCConfiguration, existingPeerConnection?: RTCPeerConnection, rtcPeerConnection?: typeof RTCPeerConnection, rtcSessionDescription?: typeof RTCSessionDescription, rtcIceCandidate?: typeof RTCIceCandidate);
     /**
      * Set up peer connection event handlers
      */