react-jssip-kit 0.7.7 → 0.7.9

package/dist/index.js

@@ -468,6 +468,175 @@ function removeSessionState(state, sessionId) {
   });
 }
 
+// src/jssip-lib/sip/debugLogging.ts
+var describePc = (pc) => ({
+  connectionState: pc?.connectionState,
+  signalingState: pc?.signalingState,
+  iceConnectionState: pc?.iceConnectionState
+});
+var SipDebugLogger = class {
+  constructor() {
+    this.enabled = false;
+    this.statsStops = /* @__PURE__ */ new Map();
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    if (!enabled) {
+      this.statsStops.forEach((stop) => stop());
+      this.statsStops.clear();
+    }
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  logLocalAudioError(sessionId, message, pc, extra) {
+    if (!this.enabled)
+      return;
+    console.error(message, {
+      sessionId,
+      pc: describePc(pc),
+      ...extra
+    });
+    void this.logOutboundStats(sessionId, pc, message);
+  }
+  logRemoteAudioError(sessionId, message, pc, extra) {
+    if (!this.enabled)
+      return;
+    console.error(message, {
+      sessionId,
+      pc: describePc(pc),
+      ...extra
+    });
+    void this.logInboundStats(sessionId, pc, message);
+  }
+  logMicRecoveryDrop(payload) {
+    if (!this.enabled)
+      return;
+    console.error("[sip] microphone dropped", payload);
+  }
+  logIceReady(sessionId, payload) {
+    if (!this.enabled)
+      return;
+    console.info("[sip] ice ready", { sessionId, ...payload });
+  }
+  logIceReadyConfig(sessionId, delayMs) {
+    if (!this.enabled)
+      return;
+    console.info("[sip] ice ready config", { sessionId, delayMs });
+  }
+  startCallStatsLogging(sessionId, session) {
+    if (!this.enabled || this.statsStops.has(sessionId))
+      return;
+    let pc = session?.connection ?? null;
+    const onPeer = (data) => {
+      pc = data.peerconnection;
+    };
+    session.on?.("peerconnection", onPeer);
+    const intervalMs = 3e3;
+    const logStats = async () => {
+      if (!this.enabled || !pc?.getStats)
+        return;
+      try {
+        const report = await pc.getStats();
+        const { outboundAudio, inboundAudio } = collectAudioStats(report);
+        console.info("[sip] call stats", {
+          sessionId,
+          pc: describePc(pc),
+          outboundAudio,
+          inboundAudio
+        });
+      } catch (err) {
+        console.error("[sip] call stats failed", { sessionId, error: err });
+      }
+    };
+    const timer = setInterval(() => {
+      void logStats();
+    }, intervalMs);
+    void logStats();
+    const stop = () => {
+      clearInterval(timer);
+      session.off?.("peerconnection", onPeer);
+      this.statsStops.delete(sessionId);
+    };
+    this.statsStops.set(sessionId, stop);
+  }
+  stopCallStatsLogging(sessionId) {
+    const stop = this.statsStops.get(sessionId);
+    if (stop)
+      stop();
+  }
+  async logOutboundStats(sessionId, pc, context) {
+    if (!pc?.getStats)
+      return;
+    try {
+      const report = await pc.getStats();
+      const { outboundAudio } = collectAudioStats(report);
+      if (outboundAudio.length) {
+        console.info("[sip] outgoing audio stats", {
+          sessionId,
+          context,
+          outboundAudio
+        });
+      }
+    } catch (err) {
+      console.error("[sip] outgoing audio stats failed", {
+        sessionId,
+        context,
+        error: err
+      });
+    }
+  }
+  async logInboundStats(sessionId, pc, context) {
+    if (!pc?.getStats)
+      return;
+    try {
+      const report = await pc.getStats();
+      const { inboundAudio } = collectAudioStats(report);
+      if (inboundAudio.length) {
+        console.error("[sip] incoming audio stats", {
+          sessionId,
+          context,
+          inboundAudio
+        });
+      }
+    } catch (err) {
+      console.error("[sip] incoming audio stats failed", {
+        sessionId,
+        context,
+        error: err
+      });
+    }
+  }
+};
+var sipDebugLogger = new SipDebugLogger();
+function collectAudioStats(report) {
+  const outboundAudio = [];
+  const inboundAudio = [];
+  report.forEach((stat) => {
+    const kind = stat.kind ?? stat.mediaType;
+    if (stat.type === "outbound-rtp" && kind === "audio") {
+      outboundAudio.push({
+        id: stat.id,
+        packetsSent: stat.packetsSent,
+        bytesSent: stat.bytesSent,
+        jitter: stat.jitter,
+        roundTripTime: stat.roundTripTime
+      });
+    }
+    if (stat.type === "inbound-rtp" && kind === "audio") {
+      inboundAudio.push({
+        id: stat.id,
+        packetsReceived: stat.packetsReceived,
+        packetsLost: stat.packetsLost,
+        bytesReceived: stat.bytesReceived,
+        jitter: stat.jitter,
+        roundTripTime: stat.roundTripTime
+      });
+    }
+  });
+  return { outboundAudio, inboundAudio };
+}
+
 // src/jssip-lib/sip/handlers/sessionHandlers.ts
 function createSessionHandlers(deps) {
   const {
@@ -476,8 +645,20 @@ function createSessionHandlers(deps) {
     rtc,
     detachSessionHandlers,
     onSessionFailed,
-    sessionId
+    sessionId,
+    iceCandidateReadyDelayMs
   } = deps;
+  let iceReadyCalled = false;
+  let iceReadyTimer = null;
+  const clearIceReadyTimer = () => {
+    if (!iceReadyTimer)
+      return;
+    clearTimeout(iceReadyTimer);
+    iceReadyTimer = null;
+  };
+  if (typeof iceCandidateReadyDelayMs === "number") {
+    sipDebugLogger.logIceReadyConfig(sessionId, iceCandidateReadyDelayMs);
+  }
   return {
     progress: (e) => {
       emitter.emit("progress", e);
@@ -500,6 +681,7 @@ function createSessionHandlers(deps) {
     },
     ended: (e) => {
       emitter.emit("ended", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       const nextSessions = state.getState().sessions.filter((s) => s.id !== sessionId);
@@ -509,6 +691,7 @@ function createSessionHandlers(deps) {
     },
     failed: (e) => {
       emitter.emit("failed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       const cause = e?.cause || "call failed";
@@ -537,13 +720,55 @@ function createSessionHandlers(deps) {
     reinvite: (e) => emitter.emit("reinvite", e),
     update: (e) => emitter.emit("update", e),
     sdp: (e) => emitter.emit("sdp", e),
-    icecandidate: (e) => emitter.emit("icecandidate", e),
+    icecandidate: (e) => {
+      const candidate = e?.candidate;
+      const ready = typeof e?.ready === "function" ? e.ready : null;
+      const delayMs = typeof iceCandidateReadyDelayMs === "number" ? iceCandidateReadyDelayMs : null;
+      if (!iceReadyCalled && ready && delayMs != null) {
+        if (candidate?.type === "srflx" && candidate?.relatedAddress != null && candidate?.relatedPort != null) {
+          iceReadyCalled = true;
+          if (iceReadyTimer) {
+            clearTimeout(iceReadyTimer);
+            iceReadyTimer = null;
+          }
+          sipDebugLogger.logIceReady(sessionId, {
+            source: "srflx",
+            delayMs,
+            candidateType: candidate?.type
+          });
+          ready();
+        } else if (!iceReadyTimer && delayMs > 0) {
+          iceReadyTimer = setTimeout(() => {
+            iceReadyTimer = null;
+            if (iceReadyCalled)
+              return;
+            iceReadyCalled = true;
+            sipDebugLogger.logIceReady(sessionId, {
+              source: "timer",
+              delayMs,
+              candidateType: candidate?.type
+            });
+            ready();
+          }, delayMs);
+        } else if (delayMs === 0) {
+          iceReadyCalled = true;
+          sipDebugLogger.logIceReady(sessionId, {
+            source: "immediate",
+            delayMs,
+            candidateType: candidate?.type
+          });
+          ready();
+        }
+      }
+      emitter.emit("icecandidate", e);
+    },
     refer: (e) => emitter.emit("refer", e),
     replaces: (e) => emitter.emit("replaces", e),
     newDTMF: (e) => emitter.emit("newDTMF", e),
     newInfo: (e) => emitter.emit("newInfo", e),
     getusermediafailed: (e) => {
       emitter.emit("getusermediafailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("getUserMedia failed", e);
@@ -553,6 +778,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:createofferfailed": (e) => {
       emitter.emit("peerconnection:createofferfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection createOffer failed", e);
@@ -562,6 +788,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:createanswerfailed": (e) => {
       emitter.emit("peerconnection:createanswerfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection createAnswer failed", e);
@@ -571,6 +798,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:setlocaldescriptionfailed": (e) => {
       emitter.emit("peerconnection:setlocaldescriptionfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection setLocalDescription failed", e);
@@ -580,6 +808,7 @@ function createSessionHandlers(deps) {
     },
     "peerconnection:setremotedescriptionfailed": (e) => {
       emitter.emit("peerconnection:setremotedescriptionfailed", e);
+      clearIceReadyTimer();
       detachSessionHandlers();
       rtc.cleanup();
       onSessionFailed("peer connection setRemoteDescription failed", e);
@@ -842,6 +1071,9 @@ var SessionLifecycle = class {
     this.attachSessionHandlers = deps.attachSessionHandlers;
     this.getMaxSessionCount = deps.getMaxSessionCount;
   }
+  setDebugEnabled(enabled) {
+    sipDebugLogger.setEnabled(enabled);
+  }
   handleNewRTCSession(e) {
     const session = e.session;
     const sessionId = String(
@@ -870,71 +1102,12 @@ var SessionLifecycle = class {
     const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
     this.sessionManager.setSession(sessionId, session);
     this.attachSessionHandlers(sessionId, session);
+    this.attachCallStatsLogging(sessionId, session);
     if (e.originator === "local" && !rtc.mediaStream) {
-      const maxAttempts = 5;
-      const retryDelayMs = 500;
-      let attempts = 0;
-      let retryScheduled = false;
-      let retryTimer = null;
-      let stopped = false;
-      const tryBindFromPc = (pc) => {
-        if (stopped || !pc || this.sessionManager.getRtc(sessionId)?.mediaStream) {
-          return false;
-        }
-        const audioSender = pc?.getSenders?.()?.find((s) => s.track?.kind === "audio");
-        const audioTrack = audioSender?.track;
-        if (!audioTrack)
-          return false;
-        const outgoingStream = new MediaStream([audioTrack]);
-        this.sessionManager.setSessionMedia(sessionId, outgoingStream);
-        return true;
-      };
-      const scheduleRetry = (pc) => {
-        if (stopped || retryScheduled || attempts >= maxAttempts) {
-          session.off?.("peerconnection", onPeer);
-          return;
-        }
-        retryScheduled = true;
-        attempts += 1;
-        retryTimer = setTimeout(() => {
-          retryScheduled = false;
-          retryTimer = null;
-          if (tryBindFromPc(pc)) {
-            session.off?.("peerconnection", onPeer);
-            return;
-          }
-          scheduleRetry(pc);
-        }, retryDelayMs);
-      };
-      const onPeer = (data) => {
-        if (stopped)
-          return;
-        if (tryBindFromPc(data.peerconnection)) {
-          session.off?.("peerconnection", onPeer);
-          return;
-        }
-        scheduleRetry(data.peerconnection);
-      };
-      const stopRetry = () => {
-        if (stopped)
-          return;
-        stopped = true;
-        if (retryTimer) {
-          clearTimeout(retryTimer);
-          retryTimer = null;
-        }
-        session.off?.("peerconnection", onPeer);
-        session.off?.("ended", stopRetry);
-        session.off?.("failed", stopRetry);
-      };
-      const existingPc = session?.connection;
-      if (!tryBindFromPc(existingPc)) {
-        if (existingPc)
-          scheduleRetry(existingPc);
-        session.on?.("peerconnection", onPeer);
-      }
-      session.on?.("ended", stopRetry);
-      session.on?.("failed", stopRetry);
+      this.bindLocalOutgoingAudio(sessionId, session);
+    }
+    if (e.originator === "remote") {
+      this.bindRemoteIncomingAudio(sessionId, session);
     }
     holdOtherSessions(this.state, sessionId, (id) => {
       const otherRtc = this.sessionManager.getRtc(id);
@@ -951,6 +1124,414 @@ var SessionLifecycle = class {
     });
     this.emit("newRTCSession", e);
   }
+  bindLocalOutgoingAudio(sessionId, session) {
+    const maxAttempts = 50;
+    const retryDelayMs = 500;
+    let attempts = 0;
+    let retryScheduled = false;
+    let retryTimer = null;
+    let stopped = false;
+    let exhausted = false;
+    let exhaustedCheckUsed = false;
+    let attachedPc = null;
+    const logLocalAudioError = (message, pc, extra) => {
+      sipDebugLogger.logLocalAudioError(sessionId, message, pc, extra);
+    };
+    const tryBindFromPc = (pc) => {
+      if (stopped || !pc || this.sessionManager.getRtc(sessionId)?.mediaStream) {
+        return false;
+      }
+      const audioSender = pc?.getSenders?.()?.find((s) => s.track?.kind === "audio");
+      const audioTrack = audioSender?.track;
+      if (!audioTrack) {
+        logLocalAudioError(
+          "[sip] outgoing audio bind failed: no audio track",
+          pc
+        );
+        return false;
+      }
+      const outgoingStream = new MediaStream([audioTrack]);
+      this.sessionManager.setSessionMedia(sessionId, outgoingStream);
+      return true;
+    };
+    const onPcStateChange = () => {
+      if (stopped)
+        return;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (tryBindFromPc(attachedPc))
+          stopRetry();
+        return;
+      }
+      if (tryBindFromPc(attachedPc))
+        stopRetry();
+    };
+    const attachPcListeners = (pc) => {
+      if (!pc || pc === attachedPc)
+        return;
+      if (attachedPc) {
+        attachedPc.removeEventListener?.(
+          "signalingstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "connectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "iceconnectionstatechange",
+          onPcStateChange
+        );
+      }
+      attachedPc = pc;
+      attachedPc.addEventListener?.("signalingstatechange", onPcStateChange);
+      attachedPc.addEventListener?.("connectionstatechange", onPcStateChange);
+      attachedPc.addEventListener?.("iceconnectionstatechange", onPcStateChange);
+    };
+    const clearRetryTimer = () => {
+      if (!retryTimer)
+        return;
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    };
+    const stopRetry = () => {
+      if (stopped)
+        return;
+      stopped = true;
+      clearRetryTimer();
+      if (attachedPc) {
+        attachedPc.removeEventListener?.(
+          "signalingstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "connectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "iceconnectionstatechange",
+          onPcStateChange
+        );
+        attachedPc = null;
+      }
+      session.off?.("peerconnection", onPeer);
+      session.off?.("confirmed", onConfirmed);
+      session.off?.("ended", stopRetry);
+      session.off?.("failed", stopRetry);
+    };
+    const scheduleRetry = (pc) => {
+      if (stopped || retryScheduled || exhausted)
+        return;
+      if (attempts >= maxAttempts) {
+        logLocalAudioError(
+          "[sip] outgoing audio bind failed: max retries reached",
+          pc,
+          { attempts }
+        );
+        exhausted = true;
+        clearRetryTimer();
+        return;
+      }
+      if (!pc) {
+        logLocalAudioError(
+          "[sip] outgoing audio bind failed: missing peerconnection",
+          pc
+        );
+      }
+      retryScheduled = true;
+      attempts += 1;
+      retryTimer = setTimeout(() => {
+        retryScheduled = false;
+        retryTimer = null;
+        if (tryBindFromPc(pc)) {
+          stopRetry();
+          return;
+        }
+        scheduleRetry(pc);
+      }, retryDelayMs);
+    };
+    const onPeer = (data) => {
+      if (stopped)
+        return;
+      attachPcListeners(data.peerconnection);
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (tryBindFromPc(data.peerconnection))
+          stopRetry();
+        return;
+      }
+      if (tryBindFromPc(data.peerconnection)) {
+        stopRetry();
+        return;
+      }
+      scheduleRetry(data.peerconnection);
+    };
+    const onConfirmed = () => {
+      if (stopped)
+        return;
+      const currentPc = session?.connection ?? attachedPc;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (tryBindFromPc(currentPc))
+          stopRetry();
+        return;
+      }
+      if (tryBindFromPc(currentPc)) {
+        stopRetry();
+        return;
+      }
+      scheduleRetry(currentPc);
+    };
+    const existingPc = session?.connection;
+    if (!tryBindFromPc(existingPc)) {
+      if (existingPc) {
+        attachPcListeners(existingPc);
+        scheduleRetry(existingPc);
+      }
+      session.on?.("peerconnection", onPeer);
+    }
+    session.on?.("confirmed", onConfirmed);
+    session.on?.("ended", stopRetry);
+    session.on?.("failed", stopRetry);
+  }
+  bindRemoteIncomingAudio(sessionId, session) {
+    const maxAttempts = 50;
+    const retryDelayMs = 500;
+    let attempts = 0;
+    let retryScheduled = false;
+    let retryTimer = null;
+    let stopped = false;
+    let exhausted = false;
+    let exhaustedCheckUsed = false;
+    let attachedPc = null;
+    let attachedTrack = null;
+    const logRemoteAudioError = (message, pc, extra) => {
+      sipDebugLogger.logRemoteAudioError(sessionId, message, pc, extra);
+    };
+    const logMissingReceiver = (pc, note) => {
+      logRemoteAudioError(
+        "[sip] incoming audio bind failed: no remote track",
+        pc,
+        { note }
+      );
+    };
+    const getRemoteAudioTrack = (pc) => {
+      const receiver = pc?.getReceivers?.()?.find((r) => r.track?.kind === "audio");
+      return receiver?.track ?? null;
+    };
+    const attachTrackListeners = (track) => {
+      if (!track || track === attachedTrack)
+        return;
+      if (attachedTrack) {
+        attachedTrack.removeEventListener?.("ended", onRemoteEnded);
+        attachedTrack.removeEventListener?.("mute", onRemoteMuted);
+      }
+      attachedTrack = track;
+      attachedTrack.addEventListener?.("ended", onRemoteEnded);
+      attachedTrack.addEventListener?.("mute", onRemoteMuted);
+    };
+    const checkRemoteTrack = (pc) => {
+      if (stopped || !pc)
+        return false;
+      const track = getRemoteAudioTrack(pc);
+      if (!track)
+        return false;
+      attachTrackListeners(track);
+      if (track.readyState !== "live") {
+        logRemoteAudioError("[sip] incoming audio track not live", pc, {
+          trackState: track.readyState
+        });
+      }
+      return true;
+    };
+    const onRemoteEnded = () => {
+      logRemoteAudioError("[sip] incoming audio track ended", attachedPc);
+    };
+    const onRemoteMuted = () => {
+      logRemoteAudioError("[sip] incoming audio track muted", attachedPc);
+    };
+    const onPcStateChange = () => {
+      if (stopped)
+        return;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (checkRemoteTrack(attachedPc))
+          stopRetry();
+        return;
+      }
+      if (checkRemoteTrack(attachedPc))
+        stopRetry();
+    };
+    const attachPcListeners = (pc) => {
+      if (!pc || pc === attachedPc)
+        return;
+      if (attachedPc) {
+        attachedPc.removeEventListener?.(
+          "signalingstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "connectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "iceconnectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.("track", onTrack);
+      }
+      attachedPc = pc;
+      attachedPc.addEventListener?.("signalingstatechange", onPcStateChange);
+      attachedPc.addEventListener?.("connectionstatechange", onPcStateChange);
+      attachedPc.addEventListener?.("iceconnectionstatechange", onPcStateChange);
+      attachedPc.addEventListener?.("track", onTrack);
+    };
+    const clearRetryTimer = () => {
+      if (!retryTimer)
+        return;
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    };
+    const stopRetry = () => {
+      if (stopped)
+        return;
+      stopped = true;
+      clearRetryTimer();
+      if (attachedPc) {
+        attachedPc.removeEventListener?.(
+          "signalingstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "connectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.(
+          "iceconnectionstatechange",
+          onPcStateChange
+        );
+        attachedPc.removeEventListener?.("track", onTrack);
+        attachedPc = null;
+      }
+      if (attachedTrack) {
+        attachedTrack.removeEventListener?.("ended", onRemoteEnded);
+        attachedTrack.removeEventListener?.("mute", onRemoteMuted);
+        attachedTrack = null;
+      }
+      session.off?.("peerconnection", onPeer);
+      session.off?.("confirmed", onConfirmed);
+      session.off?.("ended", stopRetry);
+      session.off?.("failed", stopRetry);
+    };
+    const scheduleRetry = (pc) => {
+      if (stopped || retryScheduled || exhausted)
+        return;
+      if (attempts >= maxAttempts) {
+        logRemoteAudioError(
+          "[sip] incoming audio bind failed: max retries reached",
+          pc,
+          { attempts }
+        );
+        exhausted = true;
+        clearRetryTimer();
+        return;
+      }
+      retryScheduled = true;
+      attempts += 1;
+      retryTimer = setTimeout(() => {
+        retryScheduled = false;
+        retryTimer = null;
+        if (checkRemoteTrack(pc)) {
+          stopRetry();
+          return;
+        }
+        if (!pc)
+          logMissingReceiver(pc, "missing peerconnection");
+        scheduleRetry(pc);
+      }, retryDelayMs);
+    };
+    const onTrack = () => {
+      if (stopped)
+        return;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (checkRemoteTrack(attachedPc))
+          stopRetry();
+        return;
+      }
+      if (checkRemoteTrack(attachedPc))
+        stopRetry();
+    };
+    const onPeer = (data) => {
+      if (stopped)
+        return;
+      attachPcListeners(data.peerconnection);
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (checkRemoteTrack(data.peerconnection))
+          stopRetry();
+        return;
+      }
+      if (checkRemoteTrack(data.peerconnection)) {
+        stopRetry();
+        return;
+      }
+      scheduleRetry(data.peerconnection);
+    };
+    const onConfirmed = () => {
+      if (stopped)
+        return;
+      const currentPc = session?.connection ?? attachedPc;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (checkRemoteTrack(currentPc))
+          stopRetry();
+        return;
+      }
+      if (checkRemoteTrack(currentPc)) {
+        stopRetry();
+        return;
+      }
+      logMissingReceiver(currentPc, "confirmed without remote track");
+      scheduleRetry(currentPc);
+    };
+    const existingPc = session?.connection;
+    if (!checkRemoteTrack(existingPc)) {
+      if (existingPc) {
+        attachPcListeners(existingPc);
+        scheduleRetry(existingPc);
+      }
+      session.on?.("peerconnection", onPeer);
+    }
+    session.on?.("confirmed", onConfirmed);
+    session.on?.("ended", stopRetry);
+    session.on?.("failed", stopRetry);
+  }
+  attachCallStatsLogging(sessionId, session) {
+    const onConfirmed = () => {
+      sipDebugLogger.startCallStatsLogging(sessionId, session);
+    };
+    const onEnd = () => {
+      sipDebugLogger.stopCallStatsLogging(sessionId);
+    };
+    session.on?.("confirmed", onConfirmed);
+    session.on?.("ended", onEnd);
+    session.on?.("failed", onEnd);
+  }
 };
 
 // src/jssip-lib/sip/micRecovery.ts
@@ -1011,15 +1592,11 @@ var MicRecoveryManager = class {
       const senderLive = sender?.track?.readyState === "live";
       if (trackLive && senderLive)
         return;
-      this.deps.emitError(
-        {
-          cause: "microphone dropped",
-          trackLive,
-          senderLive
-        },
-        "MICROPHONE_DROPPED",
-        "microphone dropped"
-      );
+      sipDebugLogger.logMicRecoveryDrop({
+        sessionId,
+        trackLive,
+        senderLive
+      });
       retries += 1;
       if (trackLive && !senderLive && track) {
         await rtc.replaceAudioTrack(track);
@@ -1128,9 +1705,11 @@ var SipClient = class extends EventTargetEmitter {
       micRecoveryIntervalMs,
       micRecoveryMaxRetries,
       maxSessionCount,
+      iceCandidateReadyDelayMs,
       ...uaCfg
     } = config;
     this.maxSessionCount = typeof maxSessionCount === "number" ? maxSessionCount : Infinity;
+    this.iceCandidateReadyDelayMs = typeof iceCandidateReadyDelayMs === "number" ? iceCandidateReadyDelayMs : void 0;
     this.micRecovery.configure({
       enabled: Boolean(enableMicRecovery),
       intervalMs: micRecoveryIntervalMs,
@@ -1138,6 +1717,7 @@ var SipClient = class extends EventTargetEmitter {
     });
     const debug = cfgDebug ?? this.getPersistedDebug() ?? this.debugPattern;
     this.userAgent.start(uri, password, uaCfg, { debug });
+    this.lifecycle.setDebugEnabled(Boolean(debug));
     this.attachUAHandlers();
     this.attachBeforeUnload();
     this.syncDebugInspector(debug);
@@ -1218,6 +1798,7 @@ var SipClient = class extends EventTargetEmitter {
   setDebug(debug) {
     this.debugPattern = debug;
     this.userAgent.setDebug(debug);
+    this.lifecycle.setDebugEnabled(Boolean(debug));
     this.syncDebugInspector(debug);
   }
   attachSessionHandlers(sessionId, session) {
@@ -1276,6 +1857,7 @@ var SipClient = class extends EventTargetEmitter {
       emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
       onSessionFailed: (err, event) => this.onSessionFailed(err, event),
       enableMicrophoneRecovery: (confirmedSessionId) => this.micRecovery.enable(confirmedSessionId),
+      iceCandidateReadyDelayMs: this.iceCandidateReadyDelayMs,
       sessionId
     });
   }
@@ -1431,14 +2013,17 @@ var SipClient = class extends EventTargetEmitter {
   syncDebugInspector(debug) {
     if (typeof window === "undefined")
       return;
-    this.toggleStateLogger(Boolean(debug));
+    const persisted = this.getPersistedDebug();
+    const effectiveDebug = debug ?? persisted ?? this.debugPattern;
+    this.lifecycle.setDebugEnabled(Boolean(effectiveDebug));
+    this.toggleStateLogger(Boolean(effectiveDebug));
     const win = window;
     const disabledInspector = () => {
       console.warn("SIP debug inspector disabled; enable debug to inspect.");
       return null;
     };
-    win.sipState = () => debug ? this.stateStore.getState() : disabledInspector();
-    win.sipSessions = () => debug ? this.getSessions() : disabledInspector();
+    win.sipState = () => effectiveDebug ? this.stateStore.getState() : disabledInspector();
+    win.sipSessions = () => effectiveDebug ? this.getSessions() : disabledInspector();
   }
   toggleStateLogger(enabled) {
     if (!enabled) {
@@ -1451,22 +2036,10 @@ var SipClient = class extends EventTargetEmitter {
     let prev = this.stateStore.getState();
     console.info("[sip][state]", { initial: true }, prev);
     this.stateLogOff = this.stateStore.onChange((next) => {
-      const changes = this.diffState(prev, next);
-      if (changes) {
-        console.info("[sip][state]", changes, next);
-      }
+      console.info("[sip][state]", next);
       prev = next;
     });
   }
-  diffState(prev, next) {
-    const changed = {};
-    for (const key of Object.keys(next)) {
-      if (prev[key] !== next[key]) {
-        changed[key] = { from: prev[key], to: next[key] };
-      }
-    }
-    return Object.keys(changed).length ? changed : null;
-  }
   getPersistedDebug() {
     if (typeof window === "undefined")
       return void 0;