@defcomm/meetingsdk 0.1.8 → 0.1.9

package/dist/index.mjs

@@ -372,6 +372,8 @@ var SFUClient = class {
     this.maxReconnectAttempts = 8;
     this.reconnectBaseMs = 750;
     this.joinWaiter = null;
+    this.transportRecoveryInProgress = false;
+    this.transportRecoveryTimer = null;
     this.pendingIce = {
       publisher: [],
       subscriber: []
@@ -980,17 +982,73 @@ var SFUClient = class {
       if (event.candidate) this.sendCandidate("subscriber", event.candidate);
     };
     this.publisher.onconnectionstatechange = () => {
-      const state = this.publisher?.connectionState;
+      const publisher = this.publisher;
+      if (!publisher) return;
+      const state = publisher.connectionState;
+      console.debug("[SFU] Publisher connection state", {
+        connectionState: publisher.connectionState,
+        iceConnectionState: publisher.iceConnectionState,
+        iceGatheringState: publisher.iceGatheringState,
+        signalingState: publisher.signalingState
+      });
       if (state === "failed") {
-        this.onError(new Error("Publisher PeerConnection failed"));
+        const error = new Error("Publisher PeerConnection failed");
+        this.onError({
+          code: "SFU_ERROR",
+          message: error.message,
+          raw: error,
+          recoverable: true,
+          roomId: this.room,
+          participantId: this.currentParticipantId,
+          peer: "publisher",
+          connectionState: publisher.connectionState,
+          iceConnectionState: publisher.iceConnectionState
+        });
+        this.recoverWebRTC("publisher_failed");
       }
     };
     this.subscriber.onconnectionstatechange = () => {
-      const state = this.subscriber?.connectionState;
+      const subscriber = this.subscriber;
+      if (!subscriber) return;
+      const state = subscriber.connectionState;
+      console.debug("[SFU] Subscriber connection state", {
+        connectionState: subscriber.connectionState,
+        iceConnectionState: subscriber.iceConnectionState,
+        iceGatheringState: subscriber.iceGatheringState,
+        signalingState: subscriber.signalingState
+      });
       if (state === "failed") {
-        this.onError(new Error("Subscriber PeerConnection failed"));
+        const error = new Error("Subscriber PeerConnection failed");
+        this.onError({
+          code: "SFU_ERROR",
+          message: error.message,
+          raw: error,
+          recoverable: true,
+          roomId: this.room,
+          participantId: this.currentParticipantId,
+          peer: "subscriber",
+          connectionState: subscriber.connectionState,
+          iceConnectionState: subscriber.iceConnectionState
+        });
+        this.recoverWebRTC("subscriber_failed");
       }
     };
+    this.publisher.oniceconnectionstatechange = () => {
+      const publisher = this.publisher;
+      if (!publisher) return;
+      console.debug("[SFU] Publisher ICE state", {
+        iceConnectionState: publisher.iceConnectionState,
+        connectionState: publisher.connectionState
+      });
+    };
+    this.subscriber.oniceconnectionstatechange = () => {
+      const subscriber = this.subscriber;
+      if (!subscriber) return;
+      console.debug("[SFU] Subscriber ICE state", {
+        iceConnectionState: subscriber.iceConnectionState,
+        connectionState: subscriber.connectionState
+      });
+    };
     this.subscriber.ontrack = (event) => {
       void this.handleRemoteTrack(event);
     };
@@ -1596,6 +1654,44 @@ var SFUClient = class {
     } catch {
     }
   }
+  recoverWebRTC(reason) {
+    if (this.intentionalClose) return;
+    if (this.transportRecoveryInProgress) {
+      console.debug("[SFU] WebRTC recovery already in progress", {
+        reason
+      });
+      return;
+    }
+    this.transportRecoveryInProgress = true;
+    console.warn("[SFU] WebRTC transport failed; starting recovery", {
+      reason,
+      publisherState: this.publisher?.connectionState,
+      publisherIceState: this.publisher?.iceConnectionState,
+      subscriberState: this.subscriber?.connectionState,
+      subscriberIceState: this.subscriber?.iceConnectionState
+    });
+    this.setState("reconnecting");
+    this.transportRecoveryTimer = setTimeout(() => {
+      this.transportRecoveryTimer = null;
+      if (this.intentionalClose) {
+        this.transportRecoveryInProgress = false;
+        return;
+      }
+      const ws = this.ws;
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.close(4e3, "webrtc_recovery");
+        } catch (error) {
+          console.warn("[SFU] Failed to close WebSocket for recovery", error);
+          this.transportRecoveryInProgress = false;
+          this.scheduleReconnect();
+        }
+        return;
+      }
+      this.transportRecoveryInProgress = false;
+      this.scheduleReconnect();
+    }, 250);
+  }
 };
 
 // src/core/VideoCore.ts