0.7.2

ICE candidate handler was being set up AFTER setLocalDescription, but ICE
gathering starts when setLocalDescription is called. This meant candidates
were generated before the handler was attached, so they were never sent to
the server, causing connection failures.

Fixed by:
- Setting up ICE handler BEFORE setLocalDescription in both offer and answer flows
- Changed setupIceCandidateHandler() to use this.peer.offerId instead of parameter
- Handler now checks this.peer.offerId before sending (waits for it to be set)

Order of operations now:
1. Set up ICE candidate handler
2. Call setLocalDescription (ICE gathering starts)
3. Set this.peer.offerId (handler can now send candidates)

This ensures all ICE candidates are captured and sent to the server.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@xtr-dev/rondevu-client",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@xtr-dev/rondevu-client",
-      "version": "0.7.0",
+      "version": "0.7.2",
       "license": "MIT",
       "dependencies": {
         "@xtr-dev/rondevu-client": "^0.5.1"

package.json

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

src/peer/answering-state.ts

@@ -23,27 +23,16 @@ export class AnsweringState extends PeerState {
         sdp: offerSdp
       });
 
+      // Enable trickle ICE - set up handler before ICE gathering starts
+      this.setupIceCandidateHandler();
+
       // Create answer
       const answer = await this.peer.pc.createAnswer();
-      await this.peer.pc.setLocalDescription(answer);
+      await this.peer.pc.setLocalDescription(answer); // ICE gathering starts here
 
       // 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: RTCPeerConnectionIceEvent) => {
-        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
       const { ExchangingIceState } = await import('./exchanging-ice-state.js');
       this.peer.setState(new ExchangingIceState(this.peer, offerId, options));

src/peer/creating-offer-state.ts

@@ -24,9 +24,13 @@ export class CreatingOfferState extends PeerState {
         this.peer.emitEvent('datachannel', channel);
       }
 
+      // Enable trickle ICE - set up handler before ICE gathering starts
+      // Handler will check this.peer.offerId before sending
+      this.setupIceCandidateHandler();
+
       // Create WebRTC offer
       const offer = await this.peer.pc.createOffer();
-      await this.peer.pc.setLocalDescription(offer);
+      await this.peer.pc.setLocalDescription(offer); // ICE gathering starts here
 
       // Send offer to server immediately (don't wait for ICE)
       const offers = await this.peer.offersApi.create([{
@@ -36,21 +40,7 @@ export class CreatingOfferState extends PeerState {
       }]);
 
       const offerId = offers[0].id;
-      this.peer.offerId = offerId;
-
-      // Enable trickle ICE - send candidates as they arrive
-      this.peer.pc.onicecandidate = async (event: RTCPeerConnectionIceEvent) => {
-        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.offerId = offerId; // Now handler can send candidates
 
       // Transition to waiting for answer
       const { WaitingForAnswerState } = await import('./waiting-for-answer-state.js');

src/peer/index.ts

@@ -26,6 +26,12 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
 
   private _state: PeerState;
 
+  // Event handler references for cleanup
+  private connectionStateChangeHandler?: () => void;
+  private dataChannelHandler?: (event: RTCDataChannelEvent) => void;
+  private trackHandler?: (event: RTCTrackEvent) => void;
+  private iceCandidateErrorHandler?: (event: Event) => void;
+
   /**
    * Current connection state name
    */
@@ -68,7 +74,7 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
    * Set up peer connection event handlers
    */
   private setupPeerConnection(): void {
-    this.pc.onconnectionstatechange = () => {
+    this.connectionStateChangeHandler = () => {
       switch (this.pc.connectionState) {
         case 'connected':
           this.setState(new ConnectedState(this));
@@ -86,18 +92,22 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
           break;
       }
     };
+    this.pc.addEventListener('connectionstatechange', this.connectionStateChangeHandler);
 
-    this.pc.ondatachannel = (event) => {
+    this.dataChannelHandler = (event: RTCDataChannelEvent) => {
       this.emitEvent('datachannel', event.channel);
     };
+    this.pc.addEventListener('datachannel', this.dataChannelHandler);
 
-    this.pc.ontrack = (event) => {
+    this.trackHandler = (event: RTCTrackEvent) => {
       this.emitEvent('track', event);
     };
+    this.pc.addEventListener('track', this.trackHandler);
 
-    this.pc.onicecandidateerror = (event) => {
+    this.iceCandidateErrorHandler = (event: Event) => {
       console.error('ICE candidate error:', event);
     };
+    this.pc.addEventListener('icecandidateerror', this.iceCandidateErrorHandler);
   }
 
   /**
@@ -145,6 +155,20 @@ export default class RondevuPeer extends EventEmitter<PeerEvents> {
    * Close the connection and clean up
    */
   async close(): Promise<void> {
+    // 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();
   }

src/peer/state.ts

@@ -6,6 +6,8 @@ import type RondevuPeer from './index.js';
  * Implements the State pattern for managing WebRTC connection lifecycle
  */
 export abstract class PeerState {
+  protected iceCandidateHandler?: (event: RTCPeerConnectionIceEvent) => void;
+
   constructor(protected peer: RondevuPeer) {}
 
   abstract get name(): string;
@@ -29,8 +31,31 @@ export abstract class PeerState {
     }
   }
 
+  /**
+   * Setup trickle ICE candidate handler
+   * Sends local ICE candidates to server as they are discovered
+   */
+  protected setupIceCandidateHandler(): void {
+    this.iceCandidateHandler = async (event: RTCPeerConnectionIceEvent) => {
+      if (event.candidate && this.peer.offerId) {
+        const candidateData = event.candidate.toJSON();
+        if (candidateData.candidate && candidateData.candidate !== '') {
+          try {
+            await this.peer.offersApi.addIceCandidates(this.peer.offerId, [candidateData]);
+          } catch (err) {
+            console.error('Error sending ICE candidate:', err);
+          }
+        }
+      }
+    };
+    this.peer.pc.addEventListener('icecandidate', this.iceCandidateHandler);
+  }
+
   cleanup(): void {
-    // Override in states that need cleanup
+    // Clean up ICE candidate handler if it exists
+    if (this.iceCandidateHandler) {
+      this.peer.pc.removeEventListener('icecandidate', this.iceCandidateHandler);
+    }
   }
 
   async close(): Promise<void> {