react-jssip-kit 0.7.6 → 0.7.8

package/dist/index.cjs

@@ -481,7 +481,6 @@ function createSessionHandlers(deps) {
     rtc,
     detachSessionHandlers,
     onSessionFailed,
-    onSessionConfirmed,
     sessionId
   } = deps;
   return {
@@ -502,7 +501,7 @@ function createSessionHandlers(deps) {
     },
     confirmed: (e) => {
       emitter.emit("confirmed", e);
-      onSessionConfirmed?.(sessionId);
+      deps.enableMicrophoneRecovery?.(sessionId);
     },
     ended: (e) => {
       emitter.emit("ended", e);
@@ -614,8 +613,8 @@ var WebRTCSessionController = class {
   }
   cleanup(stopTracks = true) {
     const pc = this.getPC();
+    const isClosed = pc?.connectionState === "closed" || pc?.signalingState === "closed";
     if (pc && typeof pc.getSenders === "function") {
-      const isClosed = pc.connectionState === "closed" || pc.signalingState === "closed";
       if (!isClosed) {
         for (const s of pc.getSenders()) {
           try {
@@ -626,8 +625,14 @@ var WebRTCSessionController = class {
       }
     }
     if (stopTracks && this.mediaStream) {
-      for (const t of this.mediaStream.getTracks())
+      const senderTracks = pc && !isClosed ? new Set(
+        pc.getSenders().map((s) => s.track).filter((t) => Boolean(t))
+      ) : null;
+      for (const t of this.mediaStream.getTracks()) {
+        if (senderTracks?.has(t))
+          continue;
         t.stop();
+      }
     }
     this.mediaStream = null;
     this.currentSession = null;
@@ -706,29 +711,14 @@ var WebRTCSessionController = class {
 var SessionManager = class {
   constructor() {
     this.entries = /* @__PURE__ */ new Map();
-    this.pendingMediaQueue = [];
-    this.pendingMediaTtlMs = 3e4;
-  }
-  setPendingMediaTtl(ms) {
-    if (typeof ms === "number" && ms > 0)
-      this.pendingMediaTtlMs = ms;
-  }
-  enqueueOutgoingMedia(stream) {
-    this.pendingMediaQueue.push({ stream, addedAt: Date.now() });
-  }
-  dequeueOutgoingMedia() {
-    const now = Date.now();
-    while (this.pendingMediaQueue.length) {
-      const next = this.pendingMediaQueue.shift();
-      if (!next)
-        break;
-      if (now - next.addedAt <= this.pendingMediaTtlMs) {
-        return next.stream;
-      } else {
-        next.stream.getTracks().forEach((t) => t.stop());
-      }
+  }
+  stopMediaStream(stream) {
+    if (!stream)
+      return;
+    for (const t of stream.getTracks()) {
+      if (t.readyState !== "ended")
+        t.stop();
     }
-    return null;
   }
   getOrCreateRtc(sessionId, session) {
     let entry = this.entries.get(sessionId);
@@ -770,6 +760,9 @@ var SessionManager = class {
       session: null,
       media: null
     };
+    if (entry.media && entry.media !== stream) {
+      this.stopMediaStream(entry.media);
+    }
     entry.media = stream;
     entry.rtc.setMediaStream(stream);
     this.entries.set(sessionId, entry);
@@ -799,15 +792,16 @@ var SessionManager = class {
     const entry = this.entries.get(sessionId);
     if (entry) {
       entry.rtc.cleanup();
+      this.stopMediaStream(entry.media);
       this.entries.delete(sessionId);
     }
   }
   cleanupAllSessions() {
     for (const [, entry] of this.entries.entries()) {
       entry.rtc.cleanup();
+      this.stopMediaStream(entry.media);
     }
     this.entries.clear();
-    this.pendingMediaQueue = [];
   }
   answer(sessionId, options) {
     const rtc = this.getRtc(sessionId);
@@ -843,6 +837,165 @@ var SessionManager = class {
   }
 };
 
+// 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);
+  }
+  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/sessionLifecycle.ts
 var SessionLifecycle = class {
   constructor(deps) {
@@ -853,37 +1006,48 @@ 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(session?.id ?? crypto.randomUUID?.() ?? Date.now());
+    const sessionId = String(
+      session?.id ?? crypto.randomUUID?.() ?? Date.now()
+    );
     const currentSessions = this.state.getState().sessions;
     if (currentSessions.length >= this.getMaxSessionCount()) {
       try {
-        session.terminate?.({ status_code: 486, reason_phrase: "Busy Here" });
+        session.terminate?.({
+          status_code: 486,
+          reason_phrase: "Busy Here"
+        });
       } catch {
       }
       if (e.originator === "remote") {
         this.emit("missed", e);
+      } else {
+        this.emitError(
+          "max session count reached",
+          "MAX_SESSIONS_REACHED",
+          "max session count reached"
+        );
       }
-      this.emitError("max session count reached", "MAX_SESSIONS_REACHED", "max session count reached");
       return;
     }
-    const outgoingMedia = e.originator === "local" ? this.sessionManager.dequeueOutgoingMedia() : null;
-    if (outgoingMedia)
-      this.sessionManager.setSessionMedia(sessionId, outgoingMedia);
     const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
-    if (outgoingMedia)
-      rtc.setMediaStream(outgoingMedia);
     this.sessionManager.setSession(sessionId, session);
     this.attachSessionHandlers(sessionId, session);
-    holdOtherSessions(
-      this.state,
-      sessionId,
-      (id) => {
-        const otherRtc = this.sessionManager.getRtc(id);
-        otherRtc?.hold();
-      }
-    );
+    this.attachCallStatsLogging(sessionId, session);
+    if (e.originator === "local" && !rtc.mediaStream) {
+      this.bindLocalOutgoingAudio(sessionId, session);
+    }
+    if (e.originator === "remote") {
+      this.bindRemoteIncomingAudio(sessionId, session);
+    }
+    holdOtherSessions(this.state, sessionId, (id) => {
+      const otherRtc = this.sessionManager.getRtc(id);
+      otherRtc?.hold();
+    });
     const sdpHasVideo = e.request?.body && e.request.body.toString().includes("m=video") || session?.connection?.getReceivers?.()?.some((r) => r.track?.kind === "video");
     upsertSessionState(this.state, sessionId, {
       direction: e.originator,
@@ -895,6 +1059,530 @@ 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
+var MicRecoveryManager = class {
+  constructor(deps) {
+    this.enabled = false;
+    this.defaults = {
+      intervalMs: 2e3,
+      maxRetries: Infinity
+    };
+    this.active = /* @__PURE__ */ new Map();
+    this.deps = deps;
+  }
+  configure(config) {
+    if (typeof config.enabled === "boolean") {
+      this.enabled = config.enabled;
+    }
+    if (typeof config.intervalMs === "number") {
+      this.defaults.intervalMs = config.intervalMs;
+    }
+    if (typeof config.maxRetries === "number") {
+      this.defaults.maxRetries = config.maxRetries;
+    }
+  }
+  enable(sessionId, options = {}) {
+    if (!this.enabled)
+      return () => {
+      };
+    this.disable(sessionId);
+    const intervalMs = options.intervalMs ?? this.defaults.intervalMs;
+    const maxRetries = options.maxRetries ?? this.defaults.maxRetries;
+    let retries = 0;
+    let stopped = false;
+    const startedAt = Date.now();
+    const warmupMs = Math.max(intervalMs * 2, 2e3);
+    const tick = async () => {
+      if (stopped || retries >= maxRetries)
+        return;
+      const rtc = this.deps.getRtc(sessionId);
+      const session2 = this.deps.getSession(sessionId);
+      if (!rtc || !session2)
+        return;
+      const sessionState = this.deps.getSessionState(sessionId);
+      if (sessionState?.muted)
+        return;
+      const stream = rtc.mediaStream;
+      const track = stream?.getAudioTracks?.()[0];
+      const pc2 = session2?.connection;
+      const sender = pc2?.getSenders?.()?.find((s) => s.track?.kind === "audio");
+      if (!track && !sender)
+        return;
+      if (Date.now() - startedAt < warmupMs)
+        return;
+      if (pc2?.connectionState === "new" || pc2?.connectionState === "connecting" || pc2?.iceConnectionState === "new" || pc2?.iceConnectionState === "checking") {
+        return;
+      }
+      const trackLive = track?.readyState === "live";
+      const senderLive = sender?.track?.readyState === "live";
+      if (trackLive && senderLive)
+        return;
+      sipDebugLogger.logMicRecoveryDrop({
+        sessionId,
+        trackLive,
+        senderLive
+      });
+      retries += 1;
+      if (trackLive && !senderLive && track) {
+        await rtc.replaceAudioTrack(track);
+        return;
+      }
+      let nextStream;
+      try {
+        const deviceId = track?.getSettings?.().deviceId ?? sender?.track?.getSettings?.().deviceId;
+        nextStream = await this.deps.requestMicrophoneStream(deviceId);
+      } catch (err) {
+        console.warn("[sip] mic recovery failed to get stream", err);
+        return;
+      }
+      const nextTrack = nextStream.getAudioTracks()[0];
+      if (!nextTrack)
+        return;
+      await rtc.replaceAudioTrack(nextTrack);
+      this.deps.setSessionMedia(sessionId, nextStream);
+    };
+    const timer = setInterval(() => {
+      void tick();
+    }, intervalMs);
+    void tick();
+    const session = this.deps.getSession(sessionId);
+    const pc = session?.connection;
+    const onIceChange = () => {
+      const state = pc?.iceConnectionState;
+      if (state === "failed" || state === "disconnected")
+        void tick();
+    };
+    pc?.addEventListener?.("iceconnectionstatechange", onIceChange);
+    const stop = () => {
+      stopped = true;
+      clearInterval(timer);
+      pc?.removeEventListener?.("iceconnectionstatechange", onIceChange);
+    };
+    this.active.set(sessionId, { stop });
+    return stop;
+  }
+  disable(sessionId) {
+    const entry = this.active.get(sessionId);
+    if (!entry)
+      return false;
+    entry.stop();
+    this.active.delete(sessionId);
+    return true;
+  }
+  cleanupAll() {
+    this.active.forEach((entry) => entry.stop());
+    this.active.clear();
+  }
 };
 
 // src/jssip-lib/sip/client.ts
@@ -907,12 +1595,6 @@ var SipClient = class extends EventTargetEmitter {
     this.sessionHandlers = /* @__PURE__ */ new Map();
     this.maxSessionCount = Infinity;
     this.sessionManager = new SessionManager();
-    this.micRecovery = /* @__PURE__ */ new Map();
-    this.micRecoveryEnabled = false;
-    this.micRecoveryDefaults = {
-      intervalMs: 2e3,
-      maxRetries: Infinity
-    };
     this.errorHandler = options.errorHandler ?? new SipErrorHandler({
       formatter: options.formatError,
       messages: options.errorMessages
@@ -934,6 +1616,14 @@ var SipClient = class extends EventTargetEmitter {
       attachSessionHandlers: (sessionId, session) => this.attachSessionHandlers(sessionId, session),
       getMaxSessionCount: () => this.maxSessionCount
     });
+    this.micRecovery = new MicRecoveryManager({
+      getRtc: (sessionId) => this.sessionManager.getRtc(sessionId),
+      getSession: (sessionId) => this.sessionManager.getSession(sessionId),
+      getSessionState: (sessionId) => this.stateStore.getState().sessions.find((s) => s.id === sessionId),
+      setSessionMedia: (sessionId, stream) => this.sessionManager.setSessionMedia(sessionId, stream),
+      emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
+      requestMicrophoneStream: (deviceId) => this.requestMicrophoneStreamInternal(deviceId)
+    });
     if (typeof window !== "undefined") {
       window.sipDebugBridge = (debug) => this.setDebug(debug ?? true);
     }
@@ -950,20 +1640,17 @@ var SipClient = class extends EventTargetEmitter {
       micRecoveryIntervalMs,
       micRecoveryMaxRetries,
       maxSessionCount,
-      pendingMediaTtlMs,
       ...uaCfg
     } = config;
     this.maxSessionCount = typeof maxSessionCount === "number" ? maxSessionCount : Infinity;
-    this.micRecoveryEnabled = Boolean(enableMicRecovery);
-    if (typeof micRecoveryIntervalMs === "number") {
-      this.micRecoveryDefaults.intervalMs = micRecoveryIntervalMs;
-    }
-    if (typeof micRecoveryMaxRetries === "number") {
-      this.micRecoveryDefaults.maxRetries = micRecoveryMaxRetries;
-    }
-    this.sessionManager.setPendingMediaTtl(pendingMediaTtlMs);
+    this.micRecovery.configure({
+      enabled: Boolean(enableMicRecovery),
+      intervalMs: micRecoveryIntervalMs,
+      maxRetries: micRecoveryMaxRetries
+    });
     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);
@@ -981,10 +1668,15 @@ var SipClient = class extends EventTargetEmitter {
   call(target, callOptions = {}) {
     try {
       const opts = this.ensureMediaConstraints(callOptions);
-      if (opts.mediaStream)
-        this.sessionManager.enqueueOutgoingMedia(opts.mediaStream);
       const ua = this.userAgent.getUA();
-      ua?.call(target, opts);
+      const session = ua?.call(target, opts);
+      if (session && opts.mediaStream) {
+        const sessionId = String(session?.id ?? "");
+        if (sessionId) {
+          this.sessionManager.setSessionMedia(sessionId, opts.mediaStream);
+          this.sessionManager.setSession(sessionId, session);
+        }
+      }
     } catch (e) {
       const err = this.emitError(e, "CALL_FAILED", "call failed");
       this.cleanupAllSessions();
@@ -1039,6 +1731,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) {
@@ -1074,14 +1767,13 @@ var SipClient = class extends EventTargetEmitter {
   cleanupSession(sessionId, session) {
     const targetSession = session ?? this.sessionManager.getSession(sessionId) ?? this.sessionManager.getRtc(sessionId)?.currentSession;
     this.detachSessionHandlers(sessionId, targetSession);
-    this.disableMicrophoneRecovery(sessionId);
+    this.micRecovery.disable(sessionId);
     this.sessionManager.cleanupSession(sessionId);
     removeSessionState(this.stateStore, sessionId);
   }
   cleanupAllSessions() {
     this.sessionManager.cleanupAllSessions();
-    this.micRecovery.forEach((entry) => entry.stop());
-    this.micRecovery.clear();
+    this.micRecovery.cleanupAll();
     this.sessionHandlers.clear();
     this.stateStore.setState({
       sessions: [],
@@ -1095,12 +1787,9 @@ var SipClient = class extends EventTargetEmitter {
       state: this.stateStore,
       rtc,
       detachSessionHandlers: () => this.cleanupSession(sessionId, session),
+      emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
       onSessionFailed: (err, event) => this.onSessionFailed(err, event),
-      onSessionConfirmed: (confirmedSessionId) => {
-        if (this.micRecoveryEnabled) {
-          this.enableMicrophoneRecovery(confirmedSessionId);
-        }
-      },
+      enableMicrophoneRecovery: (confirmedSessionId) => this.micRecovery.enable(confirmedSessionId),
       sessionId
     });
   }
@@ -1208,102 +1897,6 @@ var SipClient = class extends EventTargetEmitter {
   setSessionMedia(sessionId, stream) {
     this.sessionManager.setSessionMedia(sessionId, stream);
   }
-  enableMicrophoneRecovery(sessionId, options = {}) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return () => {
-      };
-    this.disableMicrophoneRecovery(resolved);
-    const intervalMs = options.intervalMs ?? this.micRecoveryDefaults.intervalMs;
-    const maxRetries = options.maxRetries ?? this.micRecoveryDefaults.maxRetries;
-    let retries = 0;
-    let stopped = false;
-    const startedAt = Date.now();
-    const warmupMs = Math.max(intervalMs * 2, 2e3);
-    const tick = async () => {
-      if (stopped || retries >= maxRetries)
-        return;
-      const rtc = this.sessionManager.getRtc(resolved);
-      const session2 = this.sessionManager.getSession(resolved);
-      if (!rtc || !session2)
-        return;
-      const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
-      if (sessionState?.muted)
-        return;
-      const stream = rtc.mediaStream;
-      const track = stream?.getAudioTracks?.()[0];
-      const pc2 = session2?.connection;
-      const sender = pc2?.getSenders?.().find((s) => s.track?.kind === "audio");
-      if (!track && !sender)
-        return;
-      if (Date.now() - startedAt < warmupMs)
-        return;
-      if (pc2?.connectionState === "new" || pc2?.connectionState === "connecting" || pc2?.iceConnectionState === "new" || pc2?.iceConnectionState === "checking") {
-        return;
-      }
-      const trackLive = track?.readyState === "live";
-      const senderLive = sender?.track?.readyState === "live";
-      if (trackLive && senderLive)
-        return;
-      this.emitError(
-        {
-          cause: "microphone dropped",
-          trackLive,
-          senderLive
-        },
-        "MICROPHONE_DROPPED",
-        "microphone dropped"
-      );
-      retries += 1;
-      if (trackLive && !senderLive && track) {
-        await rtc.replaceAudioTrack(track);
-        return;
-      }
-      let nextStream;
-      try {
-        const deviceId = track?.getSettings?.().deviceId ?? sender?.track?.getSettings?.().deviceId;
-        nextStream = await this.requestMicrophoneStreamInternal(deviceId);
-      } catch (err) {
-        console.warn("[sip] mic recovery failed to get stream", err);
-        return;
-      }
-      const nextTrack = nextStream.getAudioTracks()[0];
-      if (!nextTrack)
-        return;
-      await rtc.replaceAudioTrack(nextTrack);
-      this.sessionManager.setSessionMedia(resolved, nextStream);
-    };
-    const timer = setInterval(() => {
-      void tick();
-    }, intervalMs);
-    void tick();
-    const session = this.sessionManager.getSession(resolved);
-    const pc = session?.connection;
-    const onIceChange = () => {
-      const state = pc?.iceConnectionState;
-      if (state === "failed" || state === "disconnected")
-        void tick();
-    };
-    pc?.addEventListener?.("iceconnectionstatechange", onIceChange);
-    const stop = () => {
-      stopped = true;
-      clearInterval(timer);
-      pc?.removeEventListener?.("iceconnectionstatechange", onIceChange);
-    };
-    this.micRecovery.set(resolved, { stop });
-    return stop;
-  }
-  disableMicrophoneRecovery(sessionId) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    const entry = this.micRecovery.get(resolved);
-    if (!entry)
-      return false;
-    entry.stop();
-    this.micRecovery.delete(resolved);
-    return true;
-  }
   switchCameraSession(sessionId, track) {
     if (!this.sessionExists(sessionId))
       return false;
@@ -1352,14 +1945,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) {
@@ -1372,22 +1968,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;
@@ -1469,8 +2053,6 @@ function useSipActions() {
       getSessionIds: () => client.getSessionIds(),
       getSessions: () => client.getSessions(),
       setSessionMedia: (...args) => client.setSessionMedia(...args),
-      enableMicrophoneRecovery: (...args) => client.enableMicrophoneRecovery(...args),
-      disableMicrophoneRecovery: (...args) => client.disableMicrophoneRecovery(...args),
       switchCamera: (...args) => client.switchCameraSession(...args),
       enableVideo: (...args) => client.enableVideoSession(...args),
       disableVideo: (...args) => client.disableVideoSession(...args)
@@ -1544,6 +2126,7 @@ function createCallPlayer(audioEl) {
     return () => session.off("peerconnection", onPeer);
   };
   function bindToSession(session) {
+    clearAudioStream(audioEl.srcObject);
     if (session?.direction === "outgoing" && session.connection instanceof RTCPeerConnection) {
       cleanupTrackListener = dispose(cleanupTrackListener);
       cleanupTrackListener = attachTracks(session.connection);
@@ -1560,6 +2143,7 @@ function createCallPlayer(audioEl) {
       const e = payload?.data;
       cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
       cleanupTrackListener = dispose(cleanupTrackListener);
+      clearAudioStream(audioEl.srcObject);
       if (!e?.session)
         return;
       cleanupSessionPeerListener = listenSessionPeerconnection(e.session);