@defcomm/meetingsdk 0.1.8 → 0.2.0

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: []
@@ -390,6 +392,7 @@ var SFUClient = class {
     this.trackToSource = /* @__PURE__ */ new Map();
     this.localTrackIds = /* @__PURE__ */ new Map();
     this.subscriberStatsTimer = null;
+    this.heartbeatTimer = null;
     this.apiBase = options.apiBase || "https://api.example.com/api";
     this.wsBase = options.wsBase || "wss://api.example.com/ws";
     this.participantId = options.participantId || this.createId();
@@ -434,6 +437,24 @@ var SFUClient = class {
     this.onError = options.onError || console.error;
     this.autoSubscribe = options.autoSubscribe !== false;
   }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState !== WebSocket.OPEN) return;
+      this.send({
+        type: "ping",
+        payload: {
+          nonce: crypto.randomUUID()
+        }
+      });
+    }, 1e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
   createId() {
     return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `id_${Math.random().toString(36).slice(2)}_${Date.now()}`;
   }
@@ -594,6 +615,7 @@ var SFUClient = class {
     );
     this.ws = ws;
     ws.onopen = () => {
+      this.startHeartbeat();
       this.setState("joining");
       this.joiningWithResume = Boolean(this.resumeToken);
       const joinPayload = {
@@ -617,6 +639,7 @@ var SFUClient = class {
       this.onError(event);
     };
     ws.onclose = () => {
+      this.stopHeartbeat();
       if (this.ws !== ws) return;
       this.ws = null;
       if (this.intentionalClose || this.state === "leaving") {
@@ -898,11 +921,21 @@ var SFUClient = class {
         break;
       }
       case "error": {
-        const error = new Error(payload.message || "SFU signaling error");
-        this.onError(error);
+        const message2 = payload.message || "SFU signaling error";
+        if (this.state === "reconnecting" && message2.includes("participant session is stale")) {
+          console.debug(
+            "[SFU] Ignoring stale-session error during recovery",
+            message2
+          );
+          return;
+        }
+        const error = new Error(message2);
         if (this.state === "joining" || this.state === "waiting_approval") {
+          this.onError(error);
           this.failJoin(error);
+          return;
         }
+        this.onError(error);
         break;
       }
       default:
@@ -980,17 +1013,49 @@ 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"));
+        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"));
+        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);
     };
@@ -1461,6 +1526,7 @@ var SFUClient = class {
     }
   }
   async leave() {
+    this.stopHeartbeat();
     this.intentionalClose = true;
     this.setState("leaving");
     if (this.reconnectTimer) {
@@ -1596,6 +1662,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