@xtr-dev/rondevu-client 0.6.0 → 0.7.1

package/dist/peer/answering-state.d.ts

@@ -0,0 +1,11 @@
+import { PeerState } from './state.js';
+import type { PeerOptions } from './types.js';
+import type RondevuPeer from './index.js';
+/**
+ * Answering an offer and sending to server
+ */
+export declare class AnsweringState extends PeerState {
+    constructor(peer: RondevuPeer);
+    get name(): string;
+    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
+}

package/dist/peer/answering-state.js

@@ -0,0 +1,36 @@
+import { PeerState } from './state.js';
+/**
+ * Answering an offer and sending to server
+ */
+export class AnsweringState extends PeerState {
+    constructor(peer) {
+        super(peer);
+    }
+    get name() { return 'answering'; }
+    async answer(offerId, offerSdp, options) {
+        try {
+            this.peer.role = 'answerer';
+            this.peer.offerId = offerId;
+            // Set remote description
+            await this.peer.pc.setRemoteDescription({
+                type: 'offer',
+                sdp: offerSdp
+            });
+            // Create answer
+            const answer = await this.peer.pc.createAnswer();
+            await this.peer.pc.setLocalDescription(answer);
+            // Send answer to server immediately (don't wait for ICE)
+            await this.peer.offersApi.answer(offerId, answer.sdp);
+            // Enable trickle ICE - send candidates as they arrive
+            this.setupIceCandidateHandler(offerId);
+            // Transition to exchanging ICE
+            const { ExchangingIceState } = await import('./exchanging-ice-state.js');
+            this.peer.setState(new ExchangingIceState(this.peer, offerId, options));
+        }
+        catch (error) {
+            const { FailedState } = await import('./failed-state.js');
+            this.peer.setState(new FailedState(this.peer, error));
+            throw error;
+        }
+    }
+}

package/dist/peer/closed-state.d.ts

@@ -0,0 +1,8 @@
+import { PeerState } from './state.js';
+/**
+ * Closed state - connection has been terminated
+ */
+export declare class ClosedState extends PeerState {
+    get name(): string;
+    cleanup(): void;
+}

package/dist/peer/closed-state.js

@@ -0,0 +1,10 @@
+import { PeerState } from './state.js';
+/**
+ * Closed state - connection has been terminated
+ */
+export class ClosedState extends PeerState {
+    get name() { return 'closed'; }
+    cleanup() {
+        this.peer.pc.close();
+    }
+}

package/dist/peer/connected-state.d.ts

@@ -0,0 +1,8 @@
+import { PeerState } from './state.js';
+/**
+ * Connected state - peer connection is established
+ */
+export declare class ConnectedState extends PeerState {
+    get name(): string;
+    cleanup(): void;
+}

package/dist/peer/connected-state.js

@@ -0,0 +1,11 @@
+import { PeerState } from './state.js';
+/**
+ * Connected state - peer connection is established
+ */
+export class ConnectedState extends PeerState {
+    get name() { return 'connected'; }
+    cleanup() {
+        // Keep connection alive, but stop any polling
+        // The peer connection will handle disconnects via onconnectionstatechange
+    }
+}

package/dist/peer/creating-offer-state.d.ts

@@ -0,0 +1,12 @@
+import { PeerState } from './state.js';
+import type { PeerOptions } from './types.js';
+import type RondevuPeer from './index.js';
+/**
+ * Creating offer and sending to server
+ */
+export declare class CreatingOfferState extends PeerState {
+    private options;
+    constructor(peer: RondevuPeer, options: PeerOptions);
+    get name(): string;
+    createOffer(options: PeerOptions): Promise<string>;
+}

package/dist/peer/creating-offer-state.js

@@ -0,0 +1,43 @@
+import { PeerState } from './state.js';
+/**
+ * Creating offer and sending to server
+ */
+export class CreatingOfferState extends PeerState {
+    constructor(peer, options) {
+        super(peer);
+        this.options = options;
+    }
+    get name() { return 'creating-offer'; }
+    async createOffer(options) {
+        try {
+            this.peer.role = 'offerer';
+            // Create data channel if requested
+            if (options.createDataChannel !== false) {
+                const channel = this.peer.pc.createDataChannel(options.dataChannelLabel || 'data');
+                this.peer.emitEvent('datachannel', channel);
+            }
+            // Create WebRTC offer
+            const offer = await this.peer.pc.createOffer();
+            await this.peer.pc.setLocalDescription(offer);
+            // Send offer to server immediately (don't wait for ICE)
+            const offers = await this.peer.offersApi.create([{
+                    sdp: offer.sdp,
+                    topics: options.topics,
+                    ttl: options.ttl || 300000
+                }]);
+            const offerId = offers[0].id;
+            this.peer.offerId = offerId;
+            // Enable trickle ICE - send candidates as they arrive
+            this.setupIceCandidateHandler(offerId);
+            // Transition to waiting for answer
+            const { WaitingForAnswerState } = await import('./waiting-for-answer-state.js');
+            this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));
+            return offerId;
+        }
+        catch (error) {
+            const { FailedState } = await import('./failed-state.js');
+            this.peer.setState(new FailedState(this.peer, error));
+            throw error;
+        }
+    }
+}

package/dist/peer/exchanging-ice-state.d.ts

@@ -0,0 +1,17 @@
+import { PeerState } from './state.js';
+import type { PeerOptions } from './types.js';
+import type RondevuPeer from './index.js';
+/**
+ * Exchanging ICE candidates and waiting for connection
+ */
+export declare class ExchangingIceState extends PeerState {
+    private offerId;
+    private options;
+    private pollingInterval?;
+    private timeout?;
+    private lastIceTimestamp;
+    constructor(peer: RondevuPeer, offerId: string, options: PeerOptions);
+    get name(): string;
+    private startPolling;
+    cleanup(): void;
+}

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

@@ -0,0 +1,56 @@
+import { PeerState } from './state.js';
+/**
+ * Exchanging ICE candidates and waiting for connection
+ */
+export class ExchangingIceState extends PeerState {
+    constructor(peer, offerId, options) {
+        super(peer);
+        this.offerId = offerId;
+        this.options = options;
+        this.lastIceTimestamp = 0;
+        this.startPolling();
+    }
+    get name() { return 'exchanging-ice'; }
+    startPolling() {
+        const connectionTimeout = this.options.timeouts?.iceConnection || 30000;
+        this.timeout = setTimeout(async () => {
+            this.cleanup();
+            const { FailedState } = await import('./failed-state.js');
+            this.peer.setState(new FailedState(this.peer, new Error('ICE connection timeout')));
+        }, connectionTimeout);
+        this.pollingInterval = setInterval(async () => {
+            try {
+                const candidates = await this.peer.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
+                for (const cand of candidates) {
+                    if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
+                        try {
+                            await this.peer.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
+                            this.lastIceTimestamp = cand.createdAt;
+                        }
+                        catch (err) {
+                            console.warn('Failed to add ICE candidate:', err);
+                            this.lastIceTimestamp = cand.createdAt;
+                        }
+                    }
+                    else {
+                        this.lastIceTimestamp = cand.createdAt;
+                    }
+                }
+            }
+            catch (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');
+                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
+                }
+            }
+        }, 1000);
+    }
+    cleanup() {
+        if (this.pollingInterval)
+            clearInterval(this.pollingInterval);
+        if (this.timeout)
+            clearTimeout(this.timeout);
+    }
+}

package/dist/peer/failed-state.d.ts

@@ -0,0 +1,10 @@
+import { PeerState } from './state.js';
+/**
+ * Failed state - connection attempt failed
+ */
+export declare class FailedState extends PeerState {
+    private error;
+    constructor(peer: any, error: Error);
+    get name(): string;
+    cleanup(): void;
+}

package/dist/peer/failed-state.js

@@ -0,0 +1,16 @@
+import { PeerState } from './state.js';
+/**
+ * Failed state - connection attempt failed
+ */
+export class FailedState extends PeerState {
+    constructor(peer, error) {
+        super(peer);
+        this.error = error;
+        peer.emitEvent('failed', error);
+    }
+    get name() { return 'failed'; }
+    cleanup() {
+        // Connection is failed, clean up resources
+        this.peer.pc.close();
+    }
+}

package/dist/peer/idle-state.d.ts

@@ -0,0 +1,7 @@
+import { PeerState } from './state.js';
+import type { PeerOptions } from './types.js';
+export declare class IdleState extends PeerState {
+    get name(): string;
+    createOffer(options: PeerOptions): Promise<string>;
+    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
+}

package/dist/peer/idle-state.js

@@ -0,0 +1,14 @@
+import { PeerState } from './state.js';
+export class IdleState extends PeerState {
+    get name() { return 'idle'; }
+    async createOffer(options) {
+        const { CreatingOfferState } = await import('./creating-offer-state.js');
+        this.peer.setState(new CreatingOfferState(this.peer, options));
+        return this.peer.state.createOffer(options);
+    }
+    async answer(offerId, offerSdp, options) {
+        const { AnsweringState } = await import('./answering-state.js');
+        this.peer.setState(new AnsweringState(this.peer));
+        return this.peer.state.answer(offerId, offerSdp, options);
+    }
+}

package/dist/peer/index.d.ts

@@ -1,60 +1,8 @@
 import { RondevuOffers } from '../offers.js';
 import { EventEmitter } from '../event-emitter.js';
-/**
- * Timeout configurations for different connection phases
- */
-export interface PeerTimeouts {
-    /** Timeout for ICE gathering (default: 10000ms) */
-    iceGathering?: number;
-    /** Timeout for waiting for answer (default: 30000ms) */
-    waitingForAnswer?: number;
-    /** Timeout for creating answer (default: 10000ms) */
-    creatingAnswer?: number;
-    /** Timeout for ICE connection (default: 30000ms) */
-    iceConnection?: number;
-}
-/**
- * Options for creating a peer connection
- */
-export interface PeerOptions {
-    /** RTCConfiguration for the peer connection */
-    rtcConfig?: RTCConfiguration;
-    /** Topics to advertise this connection under */
-    topics: string[];
-    /** How long the offer should live (milliseconds) */
-    ttl?: number;
-    /** Whether to create a data channel automatically (for offerer) */
-    createDataChannel?: boolean;
-    /** Label for the automatically created data channel */
-    dataChannelLabel?: string;
-    /** Timeout configurations */
-    timeouts?: PeerTimeouts;
-}
-/**
- * Events emitted by RondevuPeer
- */
-export interface PeerEvents extends Record<string, (...args: any[]) => void> {
-    'state': (state: string) => void;
-    'connected': () => void;
-    'disconnected': () => void;
-    'failed': (error: Error) => void;
-    'datachannel': (channel: RTCDataChannel) => void;
-    'track': (event: RTCTrackEvent) => void;
-}
-/**
- * Base class for peer connection states
- */
-declare abstract class PeerState {
-    protected peer: RondevuPeer;
-    constructor(peer: RondevuPeer);
-    abstract get name(): string;
-    createOffer(options: PeerOptions): Promise<string>;
-    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
-    handleAnswer(sdp: string): Promise<void>;
-    handleIceCandidate(candidate: any): Promise<void>;
-    cleanup(): void;
-    close(): void;
-}
+import type { PeerOptions, PeerEvents } from './types.js';
+import { PeerState } from './state.js';
+export type { PeerTimeouts, PeerOptions, PeerEvents } from './types.js';
 /**
  * High-level WebRTC peer connection manager with state-based lifecycle
  * Handles offer/answer exchange, ICE candidates, timeouts, and error recovery
@@ -65,6 +13,10 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
     offerId?: string;
     role?: 'offerer' | 'answerer';
     private _state;
+    private connectionStateChangeHandler?;
+    private dataChannelHandler?;
+    private trackHandler?;
+    private iceCandidateErrorHandler?;
     /**
      * Current connection state name
      */
@@ -106,6 +58,5 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
     /**
      * Close the connection and clean up
      */
-    close(): void;
+    close(): Promise<void>;
 }
-export {};

package/dist/peer/index.js

@@ -1,287 +1,8 @@
 import { EventEmitter } from '../event-emitter.js';
-/**
- * Base class for peer connection states
- */
-class PeerState {
-    constructor(peer) {
-        this.peer = peer;
-    }
-    async createOffer(options) {
-        throw new Error(`Cannot create offer in ${this.name} state`);
-    }
-    async answer(offerId, offerSdp, options) {
-        throw new Error(`Cannot answer in ${this.name} state`);
-    }
-    async handleAnswer(sdp) {
-        throw new Error(`Cannot handle answer in ${this.name} state`);
-    }
-    async handleIceCandidate(candidate) {
-        // ICE candidates can arrive in multiple states, so default is to add them
-        if (this.peer.pc.remoteDescription) {
-            await this.peer.pc.addIceCandidate(new RTCIceCandidate(candidate));
-        }
-    }
-    cleanup() {
-        // Override in states that need cleanup
-    }
-    close() {
-        this.cleanup();
-        this.peer.setState(new ClosedState(this.peer));
-    }
-}
-/**
- * Initial idle state
- */
-class IdleState extends PeerState {
-    get name() { return 'idle'; }
-    async createOffer(options) {
-        this.peer.setState(new CreatingOfferState(this.peer, options));
-        return this.peer.state.createOffer(options);
-    }
-    async answer(offerId, offerSdp, options) {
-        this.peer.setState(new AnsweringState(this.peer));
-        return this.peer.state.answer(offerId, offerSdp, options);
-    }
-}
-/**
- * Creating offer and sending to server
- */
-class CreatingOfferState extends PeerState {
-    constructor(peer, options) {
-        super(peer);
-        this.options = options;
-    }
-    get name() { return 'creating-offer'; }
-    async createOffer(options) {
-        try {
-            this.peer.role = 'offerer';
-            // Create data channel if requested
-            if (options.createDataChannel !== false) {
-                const channel = this.peer.pc.createDataChannel(options.dataChannelLabel || 'data');
-                this.peer.emitEvent('datachannel', channel);
-            }
-            // Create WebRTC offer
-            const offer = await this.peer.pc.createOffer();
-            await this.peer.pc.setLocalDescription(offer);
-            // Send offer to server immediately (don't wait for ICE)
-            const offers = await this.peer.offersApi.create([{
-                    sdp: offer.sdp,
-                    topics: options.topics,
-                    ttl: options.ttl || 300000
-                }]);
-            const offerId = offers[0].id;
-            this.peer.offerId = offerId;
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
-            // Transition to waiting for answer
-            this.peer.setState(new WaitingForAnswerState(this.peer, offerId, options));
-            return offerId;
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}
-/**
- * Waiting for answer from another peer
- */
-class WaitingForAnswerState extends PeerState {
-    constructor(peer, offerId, options) {
-        super(peer);
-        this.offerId = offerId;
-        this.options = options;
-        this.startPolling();
-    }
-    get name() { return 'waiting-for-answer'; }
-    startPolling() {
-        const answerTimeout = this.options.timeouts?.waitingForAnswer || 30000;
-        this.timeout = setTimeout(() => {
-            this.cleanup();
-            this.peer.setState(new FailedState(this.peer, new Error('Timeout waiting for answer')));
-        }, answerTimeout);
-        this.pollingInterval = setInterval(async () => {
-            try {
-                const answers = await this.peer.offersApi.getAnswers();
-                const myAnswer = answers.find(a => a.offerId === this.offerId);
-                if (myAnswer) {
-                    this.cleanup();
-                    await this.handleAnswer(myAnswer.sdp);
-                }
-            }
-            catch (err) {
-                console.error('Error polling for answers:', err);
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.cleanup();
-                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
-                }
-            }
-        }, 2000);
-    }
-    async handleAnswer(sdp) {
-        try {
-            await this.peer.pc.setRemoteDescription({
-                type: 'answer',
-                sdp
-            });
-            // Transition to exchanging ICE
-            this.peer.setState(new ExchangingIceState(this.peer, this.offerId, this.options));
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-        }
-    }
-    cleanup() {
-        if (this.pollingInterval)
-            clearInterval(this.pollingInterval);
-        if (this.timeout)
-            clearTimeout(this.timeout);
-    }
-}
-/**
- * Answering an offer and sending to server
- */
-class AnsweringState extends PeerState {
-    constructor(peer) {
-        super(peer);
-    }
-    get name() { return 'answering'; }
-    async answer(offerId, offerSdp, options) {
-        try {
-            this.peer.role = 'answerer';
-            this.peer.offerId = offerId;
-            // Set remote description
-            await this.peer.pc.setRemoteDescription({
-                type: 'offer',
-                sdp: offerSdp
-            });
-            // Create answer
-            const answer = await this.peer.pc.createAnswer();
-            await this.peer.pc.setLocalDescription(answer);
-            // Send answer to server immediately (don't wait for ICE)
-            await this.peer.offersApi.answer(offerId, answer.sdp);
-            // Enable trickle ICE - send candidates as they arrive
-            this.peer.pc.onicecandidate = async (event) => {
-                if (event.candidate && offerId) {
-                    const candidateData = event.candidate.toJSON();
-                    if (candidateData.candidate && candidateData.candidate !== '') {
-                        try {
-                            await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
-                        }
-                        catch (err) {
-                            console.error('Error sending ICE candidate:', err);
-                        }
-                    }
-                }
-            };
-            // Transition to exchanging ICE
-            this.peer.setState(new ExchangingIceState(this.peer, offerId, options));
-        }
-        catch (error) {
-            this.peer.setState(new FailedState(this.peer, error));
-            throw error;
-        }
-    }
-}
-/**
- * Exchanging ICE candidates and waiting for connection
- */
-class ExchangingIceState extends PeerState {
-    constructor(peer, offerId, options) {
-        super(peer);
-        this.offerId = offerId;
-        this.options = options;
-        this.lastIceTimestamp = 0;
-        this.startPolling();
-    }
-    get name() { return 'exchanging-ice'; }
-    startPolling() {
-        const connectionTimeout = this.options.timeouts?.iceConnection || 30000;
-        this.timeout = setTimeout(() => {
-            this.cleanup();
-            this.peer.setState(new FailedState(this.peer, new Error('ICE connection timeout')));
-        }, connectionTimeout);
-        this.pollingInterval = setInterval(async () => {
-            try {
-                const candidates = await this.peer.offersApi.getIceCandidates(this.offerId, this.lastIceTimestamp);
-                for (const cand of candidates) {
-                    if (cand.candidate && cand.candidate.candidate && cand.candidate.candidate !== '') {
-                        try {
-                            await this.peer.pc.addIceCandidate(new RTCIceCandidate(cand.candidate));
-                            this.lastIceTimestamp = cand.createdAt;
-                        }
-                        catch (err) {
-                            console.warn('Failed to add ICE candidate:', err);
-                            this.lastIceTimestamp = cand.createdAt;
-                        }
-                    }
-                    else {
-                        this.lastIceTimestamp = cand.createdAt;
-                    }
-                }
-            }
-            catch (err) {
-                console.error('Error polling for ICE candidates:', err);
-                if (err instanceof Error && err.message.includes('not found')) {
-                    this.cleanup();
-                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
-                }
-            }
-        }, 1000);
-    }
-    cleanup() {
-        if (this.pollingInterval)
-            clearInterval(this.pollingInterval);
-        if (this.timeout)
-            clearTimeout(this.timeout);
-    }
-}
-/**
- * Successfully connected state
- */
-class ConnectedState extends PeerState {
-    get name() { return 'connected'; }
-    cleanup() {
-        // Keep connection alive, but stop any polling
-        // The peer connection will handle disconnects via onconnectionstatechange
-    }
-}
-/**
- * Failed state
- */
-class FailedState extends PeerState {
-    constructor(peer, error) {
-        super(peer);
-        this.error = error;
-        peer.emitEvent('failed', error);
-    }
-    get name() { return 'failed'; }
-    cleanup() {
-        // Connection is failed, clean up resources
-        this.peer.pc.close();
-    }
-}
-/**
- * Closed state
- */
-class ClosedState extends PeerState {
-    get name() { return 'closed'; }
-    cleanup() {
-        this.peer.pc.close();
-    }
-}
+import { IdleState } from './idle-state.js';
+import { ConnectedState } from './connected-state.js';
+import { FailedState } from './failed-state.js';
+import { ClosedState } from './closed-state.js';
 /**
  * High-level WebRTC peer connection manager with state-based lifecycle
  * Handles offer/answer exchange, ICE candidates, timeouts, and error recovery
@@ -321,7 +42,7 @@ export default class RondevuPeer extends EventEmitter {
      * Set up peer connection event handlers
      */
     setupPeerConnection() {
-        this.pc.onconnectionstatechange = () => {
+        this.connectionStateChangeHandler = () => {
             switch (this.pc.connectionState) {
                 case 'connected':
                     this.setState(new ConnectedState(this));
@@ -339,15 +60,19 @@ export default class RondevuPeer extends EventEmitter {
                     break;
             }
         };
-        this.pc.ondatachannel = (event) => {
+        this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        this.dataChannelHandler = (event) => {
             this.emitEvent('datachannel', event.channel);
         };
-        this.pc.ontrack = (event) => {
+        this.pc.addEventListener('datachannel', this.dataChannelHandler);
+        this.trackHandler = (event) => {
             this.emitEvent('track', event);
         };
-        this.pc.onicecandidateerror = (event) => {
+        this.pc.addEventListener('track', this.trackHandler);
+        this.iceCandidateErrorHandler = (event) => {
             console.error('ICE candidate error:', event);
         };
+        this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
     }
     /**
      * Set new state and emit state change event
@@ -385,8 +110,21 @@ export default class RondevuPeer extends EventEmitter {
     /**
      * Close the connection and clean up
      */
-    close() {
-        this._state.close();
+    async close() {
+        // Remove RTCPeerConnection event listeners
+        if (this.connectionStateChangeHandler) {
+            this.pc.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
+        }
+        if (this.dataChannelHandler) {
+            this.pc.removeEventListener('datachannel', this.dataChannelHandler);
+        }
+        if (this.trackHandler) {
+            this.pc.removeEventListener('track', this.trackHandler);
+        }
+        if (this.iceCandidateErrorHandler) {
+            this.pc.removeEventListener('icecandidateerror', this.iceCandidateErrorHandler);
+        }
+        await this._state.close();
         this.removeAllListeners();
     }
 }

package/dist/peer/state.d.ts

@@ -0,0 +1,23 @@
+import type { PeerOptions } from './types.js';
+import type RondevuPeer from './index.js';
+/**
+ * Base class for peer connection states
+ * Implements the State pattern for managing WebRTC connection lifecycle
+ */
+export declare abstract class PeerState {
+    protected peer: RondevuPeer;
+    protected iceCandidateHandler?: (event: RTCPeerConnectionIceEvent) => void;
+    constructor(peer: RondevuPeer);
+    abstract get name(): string;
+    createOffer(options: PeerOptions): Promise<string>;
+    answer(offerId: string, offerSdp: string, options: PeerOptions): Promise<void>;
+    handleAnswer(sdp: string): Promise<void>;
+    handleIceCandidate(candidate: any): Promise<void>;
+    /**
+     * Setup trickle ICE candidate handler
+     * Sends local ICE candidates to server as they are discovered
+     */
+    protected setupIceCandidateHandler(offerId: string): void;
+    cleanup(): void;
+    close(): Promise<void>;
+}

package/dist/peer/state.js

@@ -0,0 +1,55 @@
+/**
+ * Base class for peer connection states
+ * Implements the State pattern for managing WebRTC connection lifecycle
+ */
+export class PeerState {
+    constructor(peer) {
+        this.peer = peer;
+    }
+    async createOffer(options) {
+        throw new Error(`Cannot create offer in ${this.name} state`);
+    }
+    async answer(offerId, offerSdp, options) {
+        throw new Error(`Cannot answer in ${this.name} state`);
+    }
+    async handleAnswer(sdp) {
+        throw new Error(`Cannot handle answer in ${this.name} state`);
+    }
+    async handleIceCandidate(candidate) {
+        // ICE candidates can arrive in multiple states, so default is to add them
+        if (this.peer.pc.remoteDescription) {
+            await this.peer.pc.addIceCandidate(new RTCIceCandidate(candidate));
+        }
+    }
+    /**
+     * Setup trickle ICE candidate handler
+     * Sends local ICE candidates to server as they are discovered
+     */
+    setupIceCandidateHandler(offerId) {
+        this.iceCandidateHandler = async (event) => {
+            if (event.candidate && offerId) {
+                const candidateData = event.candidate.toJSON();
+                if (candidateData.candidate && candidateData.candidate !== '') {
+                    try {
+                        await this.peer.offersApi.addIceCandidates(offerId, [candidateData]);
+                    }
+                    catch (err) {
+                        console.error('Error sending ICE candidate:', err);
+                    }
+                }
+            }
+        };
+        this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
+    }
+    cleanup() {
+        // Clean up ICE candidate handler if it exists
+        if (this.iceCandidateHandler) {
+            this.peer.pc.removeEventListener('icecandidate', this.iceCandidateHandler);
+        }
+    }
+    async close() {
+        this.cleanup();
+        const { ClosedState } = await import('./closed-state.js');
+        this.peer.setState(new ClosedState(this.peer));
+    }
+}

package/dist/peer/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Timeout configurations for different connection phases
+ */
+export interface PeerTimeouts {
+    /** Timeout for ICE gathering (default: 10000ms) */
+    iceGathering?: number;
+    /** Timeout for waiting for answer (default: 30000ms) */
+    waitingForAnswer?: number;
+    /** Timeout for creating answer (default: 10000ms) */
+    creatingAnswer?: number;
+    /** Timeout for ICE connection (default: 30000ms) */
+    iceConnection?: number;
+}
+/**
+ * Options for creating a peer connection
+ */
+export interface PeerOptions {
+    /** RTCConfiguration for the peer connection */
+    rtcConfig?: RTCConfiguration;
+    /** Topics to advertise this connection under */
+    topics: string[];
+    /** How long the offer should live (milliseconds) */
+    ttl?: number;
+    /** Whether to create a data channel automatically (for offerer) */
+    createDataChannel?: boolean;
+    /** Label for the automatically created data channel */
+    dataChannelLabel?: string;
+    /** Timeout configurations */
+    timeouts?: PeerTimeouts;
+}
+/**
+ * Events emitted by RondevuPeer
+ */
+export interface PeerEvents extends Record<string, (...args: any[]) => void> {
+    'state': (state: string) => void;
+    'connected': () => void;
+    'disconnected': () => void;
+    'failed': (error: Error) => void;
+    'datachannel': (channel: RTCDataChannel) => void;
+    'track': (event: RTCTrackEvent) => void;
+}

package/dist/peer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/peer/waiting-for-answer-state.d.ts

@@ -0,0 +1,17 @@
+import { PeerState } from './state.js';
+import type { PeerOptions } from './types.js';
+import type RondevuPeer from './index.js';
+/**
+ * Waiting for answer from another peer
+ */
+export declare class WaitingForAnswerState extends PeerState {
+    private offerId;
+    private options;
+    private pollingInterval?;
+    private timeout?;
+    constructor(peer: RondevuPeer, offerId: string, options: PeerOptions);
+    get name(): string;
+    private startPolling;
+    handleAnswer(sdp: string): Promise<void>;
+    cleanup(): void;
+}

package/dist/peer/waiting-for-answer-state.js

@@ -0,0 +1,60 @@
+import { PeerState } from './state.js';
+/**
+ * Waiting for answer from another peer
+ */
+export class WaitingForAnswerState extends PeerState {
+    constructor(peer, offerId, options) {
+        super(peer);
+        this.offerId = offerId;
+        this.options = options;
+        this.startPolling();
+    }
+    get name() { return 'waiting-for-answer'; }
+    startPolling() {
+        const answerTimeout = this.options.timeouts?.waitingForAnswer || 30000;
+        this.timeout = setTimeout(async () => {
+            this.cleanup();
+            const { FailedState } = await import('./failed-state.js');
+            this.peer.setState(new FailedState(this.peer, new Error('Timeout waiting for answer')));
+        }, answerTimeout);
+        this.pollingInterval = setInterval(async () => {
+            try {
+                const answers = await this.peer.offersApi.getAnswers();
+                const myAnswer = answers.find((a) => a.offerId === this.offerId);
+                if (myAnswer) {
+                    this.cleanup();
+                    await this.handleAnswer(myAnswer.sdp);
+                }
+            }
+            catch (err) {
+                console.error('Error polling for answers:', err);
+                if (err instanceof Error && err.message.includes('not found')) {
+                    this.cleanup();
+                    const { FailedState } = await import('./failed-state.js');
+                    this.peer.setState(new FailedState(this.peer, new Error('Offer expired or not found')));
+                }
+            }
+        }, 2000);
+    }
+    async handleAnswer(sdp) {
+        try {
+            await this.peer.pc.setRemoteDescription({
+                type: 'answer',
+                sdp
+            });
+            // Transition to exchanging ICE
+            const { ExchangingIceState } = await import('./exchanging-ice-state.js');
+            this.peer.setState(new ExchangingIceState(this.peer, this.offerId, this.options));
+        }
+        catch (error) {
+            const { FailedState } = await import('./failed-state.js');
+            this.peer.setState(new FailedState(this.peer, error));
+        }
+    }
+    cleanup() {
+        if (this.pollingInterval)
+            clearInterval(this.pollingInterval);
+        if (this.timeout)
+            clearTimeout(this.timeout);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "TypeScript client for Rondevu topic-based peer discovery and signaling server",
   "type": "module",
   "main": "dist/index.js",