react-jssip-kit 0.7.8 → 1.0.0

package/dist/index.cjs

@@ -8,7 +8,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var JsSIP__default = /*#__PURE__*/_interopDefault(JsSIP);
 
-// src/jssip-lib/sip/debugger.ts
+// src/core/modules/debug/sip-debugger.ts
 var SipDebugger = class {
   constructor(storageKey = "sip-debug-enabled", defaultPattern = "JsSIP:*") {
     this.enabled = false;
@@ -27,7 +27,6 @@ var SipDebugger = class {
     try {
       if (typeof JsSIP__default.default?.debug?.enable === "function") {
         JsSIP__default.default.debug.enable(pattern);
-        this.logger = console;
       }
       storage?.setItem?.(this.storageKey, pattern || this.defaultPattern);
       try {
@@ -119,6 +118,25 @@ if (typeof window !== "undefined") {
   sipDebugger.attachToWindow();
   sipDebugger.initFromSession();
 }
+
+// src/core/contracts/state.ts
+var SipStatus = {
+  Disconnected: "disconnected",
+  Connecting: "connecting",
+  Connected: "connected",
+  Registered: "registered",
+  Unregistered: "unregistered",
+  RegistrationFailed: "registrationFailed"
+};
+var CallStatus = {
+  Idle: "idle",
+  Dialing: "dialing",
+  Ringing: "ringing",
+  Active: "active",
+  Hold: "hold"
+};
+Object.values(SipStatus);
+Object.values(CallStatus);
 var SipUserAgent = class {
   constructor() {
     this._ua = null;
@@ -229,26 +247,7 @@ var SipUserAgent = class {
   }
 };
 
-// src/jssip-lib/core/types.ts
-var SipStatus = {
-  Disconnected: "disconnected",
-  Connecting: "connecting",
-  Connected: "connected",
-  Registered: "registered",
-  Unregistered: "unregistered",
-  RegistrationFailed: "registrationFailed"
-};
-var CallStatus = {
-  Idle: "idle",
-  Dialing: "dialing",
-  Ringing: "ringing",
-  Active: "active",
-  Hold: "hold"
-};
-Object.values(SipStatus);
-Object.values(CallStatus);
-
-// src/jssip-lib/core/eventEmitter.ts
+// src/core/modules/event/event-target.emitter.ts
 var EventTargetEmitter = class {
   constructor() {
     this.target = new EventTarget();
@@ -265,56 +264,14 @@ var EventTargetEmitter = class {
   }
 };
 
-// src/jssip-lib/core/sipErrorHandler.ts
-var SipErrorHandler = class {
-  constructor(options = {}) {
-    this.formatter = options.formatter;
-    this.messages = options.messages;
-  }
-  format(input) {
-    const { code, raw, fallback } = input;
-    const mappedMessage = code && this.messages ? this.messages[code] : void 0;
-    if (this.formatter) {
-      const custom = this.formatter({
-        raw,
-        code,
-        fallback: mappedMessage ?? fallback
-      });
-      const message2 = custom?.message ?? custom?.cause ?? mappedMessage ?? fallback ?? this.readRawMessage(raw) ?? "unknown error";
-      return {
-        cause: custom?.cause ?? message2,
-        code: custom?.code ?? code,
-        raw: custom?.raw ?? raw,
-        message: message2
-      };
-    }
-    const message = mappedMessage ?? this.readRawMessage(raw) ?? fallback ?? "unknown error";
-    return {
-      cause: message,
-      code,
-      raw,
-      message
-    };
-  }
-  readRawMessage(raw) {
-    if (raw == null)
-      return void 0;
-    if (typeof raw === "string")
-      return raw;
-    if (typeof raw?.cause === "string")
-      return raw.cause;
-    if (typeof raw?.message === "string")
-      return raw.message;
-    return void 0;
-  }
-};
-
-// src/jssip-lib/core/sipState.ts
+// src/core/modules/state/sip.state.ts
 function getInitialSipState() {
   return {
     sipStatus: SipStatus.Disconnected,
     error: null,
-    sessions: []
+    sessions: [],
+    sessionsById: {},
+    sessionIds: []
   };
 }
 function shallowEqual(objA, objB) {
@@ -333,7 +290,7 @@ function shallowEqual(objA, objB) {
   return true;
 }
 
-// src/jssip-lib/core/sipStateStore.ts
+// src/core/modules/state/sip.state.store.ts
 var SipStateStore = class {
   constructor() {
     this.state = getInitialSipState();
@@ -385,468 +342,90 @@ var SipStateStore = class {
   }
 };
 
-// src/jssip-lib/sip/handlers/uaHandlers.ts
-function createUAHandlers(deps) {
-  const { emitter, state, cleanupAllSessions, emitError, onNewRTCSession } = deps;
-  return {
-    connecting: (e) => {
-      emitter.emit("connecting", e);
-      state.batchSet({ sipStatus: SipStatus.Connecting });
-    },
-    connected: (e) => {
-      emitter.emit("connected", e);
-      state.batchSet({ sipStatus: SipStatus.Connected });
-    },
-    disconnected: (e) => {
-      emitter.emit("disconnected", e);
-      cleanupAllSessions();
-      state.reset();
-    },
-    registered: (e) => {
-      emitter.emit("registered", e);
-      state.batchSet({ sipStatus: SipStatus.Registered, error: null });
-    },
-    unregistered: (e) => {
-      emitter.emit("unregistered", e);
-      state.batchSet({ sipStatus: SipStatus.Unregistered });
-    },
-    registrationFailed: (e) => {
-      emitter.emit("registrationFailed", e);
-      cleanupAllSessions();
-      emitError(
-        {
-          raw: e,
-          cause: e?.cause,
-          statusCode: e?.response?.status_code,
-          statusText: e?.response?.reason_phrase
-        },
-        "REGISTRATION_FAILED",
-        "registration failed"
-      );
-      state.batchSet({
-        sipStatus: SipStatus.RegistrationFailed,
-        error: e?.cause || "registration failed"
-      });
-    },
-    newRTCSession: onNewRTCSession,
-    newMessage: (e) => emitter.emit("newMessage", e),
-    sipEvent: (e) => emitter.emit("sipEvent", e),
-    newOptions: (e) => emitter.emit("newOptions", e)
-  };
-}
-
-// src/jssip-lib/sip/sessionState.ts
-function holdOtherSessions(state, sessionId, holdFn) {
-  const current = state.getState();
-  current.sessions.forEach((s) => {
-    if (s.id === sessionId)
+// src/core/modules/debug/sip-debug.runtime.ts
+var SESSION_DEBUG_KEY = "sip-debug-enabled";
+var SipDebugRuntime = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  attachBridge(setDebug) {
+    if (typeof window === "undefined")
       return;
-    if (s.status === CallStatus.Active) {
-      holdFn(s.id);
+    window.sipDebugBridge = (debug) => setDebug(debug ?? true);
+  }
+  getPersistedDebug() {
+    if (typeof window === "undefined")
+      return void 0;
+    try {
+      const persisted = window.sessionStorage.getItem(SESSION_DEBUG_KEY);
+      if (!persisted)
+        return void 0;
+      return persisted;
+    } catch {
+      return void 0;
     }
-  });
-}
-function upsertSessionState(state, sessionId, partial) {
-  const current = state.getState();
-  const existing = current.sessions.find((s) => s.id === sessionId);
-  const base = existing ?? {
-    id: sessionId,
-    status: CallStatus.Idle,
-    direction: null,
-    from: null,
-    to: null,
-    muted: false,
-    acceptedAt: null,
-    mediaKind: "audio",
-    remoteVideoEnabled: false
-  };
-  const nextSession = { ...base, ...partial };
-  const sessions = existing ? current.sessions.map((s) => s.id === sessionId ? nextSession : s) : [...current.sessions, nextSession];
-  state.setState({ sessions });
-}
-function removeSessionState(state, sessionId) {
-  const current = state.getState();
-  const sessions = current.sessions.filter((s) => s.id !== sessionId);
-  state.setState({
-    sessions,
-    error: null
-  });
-}
+  }
+  syncInspector(effectiveDebug) {
+    if (typeof window === "undefined")
+      return;
+    const enabled = Boolean(effectiveDebug);
+    this.deps.setDebugEnabled(enabled);
+    this.toggleStateLogger(enabled);
+    const win = window;
+    const disabledInspector = () => {
+      console.warn("SIP debug inspector disabled; enable debug to inspect.");
+      return null;
+    };
+    win.sipState = () => enabled ? this.deps.getState() : disabledInspector();
+    win.sipSessions = () => enabled ? this.deps.getSessions() : disabledInspector();
+  }
+  cleanup() {
+    this.toggleStateLogger(false);
+  }
+  toggleStateLogger(enabled) {
+    if (!enabled) {
+      this.stateLogOff?.();
+      this.stateLogOff = void 0;
+      return;
+    }
+    if (this.stateLogOff)
+      return;
+    let prev = this.deps.getState();
+    console.info("[sip][state]", { initial: true }, prev);
+    this.stateLogOff = this.deps.onChange((next) => {
+      console.info("[sip][state]", next);
+      prev = next;
+    });
+  }
+};
 
-// src/jssip-lib/sip/handlers/sessionHandlers.ts
-function createSessionHandlers(deps) {
-  const {
-    emitter,
-    state,
-    rtc,
-    detachSessionHandlers,
-    onSessionFailed,
-    sessionId
-  } = deps;
+// src/core/modules/event/sip-event-manager.adapter.ts
+function createSipEventManager(client) {
   return {
-    progress: (e) => {
-      emitter.emit("progress", e);
-    },
-    accepted: (e) => {
-      emitter.emit("accepted", e);
-      state.batchSet({
-        sessions: state.getState().sessions.map(
-          (s) => s.id === sessionId ? {
-            ...s,
-            status: CallStatus.Active,
-            acceptedAt: s.acceptedAt ?? Date.now()
-          } : s
-        )
-      });
-    },
-    confirmed: (e) => {
-      emitter.emit("confirmed", e);
-      deps.enableMicrophoneRecovery?.(sessionId);
-    },
-    ended: (e) => {
-      emitter.emit("ended", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      const nextSessions = state.getState().sessions.filter((s) => s.id !== sessionId);
-      state.batchSet({
-        sessions: nextSessions
-      });
-    },
-    failed: (e) => {
-      emitter.emit("failed", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      const cause = e?.cause || "call failed";
-      onSessionFailed(cause, e);
-      const nextSessions = state.getState().sessions.filter((s) => s.id !== sessionId);
-      state.batchSet({
-        sessions: nextSessions
-      });
-    },
-    muted: () => {
-      emitter.emit("muted", void 0);
-      upsertSessionState(state, sessionId, { muted: true });
-    },
-    unmuted: () => {
-      emitter.emit("unmuted", void 0);
-      upsertSessionState(state, sessionId, { muted: false });
-    },
-    hold: () => {
-      emitter.emit("hold", void 0);
-      upsertSessionState(state, sessionId, { status: CallStatus.Hold });
-    },
-    unhold: () => {
-      emitter.emit("unhold", void 0);
-      upsertSessionState(state, sessionId, { status: CallStatus.Active });
-    },
-    reinvite: (e) => emitter.emit("reinvite", e),
-    update: (e) => emitter.emit("update", e),
-    sdp: (e) => emitter.emit("sdp", e),
-    icecandidate: (e) => 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);
-      detachSessionHandlers();
-      rtc.cleanup();
-      onSessionFailed("getUserMedia failed", e);
-      state.batchSet({
-        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
-      });
-    },
-    "peerconnection:createofferfailed": (e) => {
-      emitter.emit("peerconnection:createofferfailed", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      onSessionFailed("peer connection createOffer failed", e);
-      state.batchSet({
-        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
-      });
-    },
-    "peerconnection:createanswerfailed": (e) => {
-      emitter.emit("peerconnection:createanswerfailed", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      onSessionFailed("peer connection createAnswer failed", e);
-      state.batchSet({
-        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
-      });
-    },
-    "peerconnection:setlocaldescriptionfailed": (e) => {
-      emitter.emit("peerconnection:setlocaldescriptionfailed", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      onSessionFailed("peer connection setLocalDescription failed", e);
-      state.batchSet({
-        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
-      });
-    },
-    "peerconnection:setremotedescriptionfailed": (e) => {
-      emitter.emit("peerconnection:setremotedescriptionfailed", e);
-      detachSessionHandlers();
-      rtc.cleanup();
-      onSessionFailed("peer connection setRemoteDescription failed", e);
-      state.batchSet({
-        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
-      });
+    onUA(event, handler) {
+      return client.on(event, handler);
     },
-    peerconnection: (e) => emitter.emit("peerconnection", e)
+    onSession(sessionId, event, handler) {
+      const session = client.getSession(sessionId);
+      if (!session)
+        return () => {
+        };
+      session.on(event, handler);
+      return () => session.off(event, handler);
+    }
   };
 }
 
-// src/jssip-lib/sip/sessionController.ts
-var WebRTCSessionController = class {
+// src/core/modules/debug/sip-debug.logger.ts
+var describePc = (pc) => ({
+  connectionState: pc?.connectionState,
+  signalingState: pc?.signalingState,
+  iceConnectionState: pc?.iceConnectionState
+});
+var SipDebugLogger = class {
   constructor() {
-    this.currentSession = null;
-    this.mediaStream = null;
-  }
-  setSession(session) {
-    this.currentSession = session;
-  }
-  setMediaStream(stream) {
-    this.mediaStream = stream;
-  }
-  getPC() {
-    return this.currentSession?.connection ?? null;
-  }
-  cleanup(stopTracks = true) {
-    const pc = this.getPC();
-    const isClosed = pc?.connectionState === "closed" || pc?.signalingState === "closed";
-    if (pc && typeof pc.getSenders === "function") {
-      if (!isClosed) {
-        for (const s of pc.getSenders()) {
-          try {
-            s.replaceTrack(null);
-          } catch {
-          }
-        }
-      }
-    }
-    if (stopTracks && this.mediaStream) {
-      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;
-  }
-  answer(options = {}) {
-    return this.currentSession ? (this.currentSession.answer(options), true) : false;
-  }
-  hangup(options) {
-    return this.currentSession ? (this.currentSession.terminate(
-      options ?? { status_code: 486, reason_phrase: "Busy Here" }
-    ), true) : false;
-  }
-  mute() {
-    this.mediaStream?.getAudioTracks().forEach((t) => t.enabled = false);
-    return this.currentSession ? (this.currentSession.mute({ audio: true }), true) : false;
-  }
-  unmute() {
-    this.mediaStream?.getAudioTracks().forEach((t) => t.enabled = true);
-    return this.currentSession ? (this.currentSession.unmute({ audio: true }), true) : false;
-  }
-  hold() {
-    return this.currentSession ? (this.currentSession.hold(), true) : false;
-  }
-  unhold() {
-    return this.currentSession ? (this.currentSession.unhold(), true) : false;
-  }
-  sendDTMF(tones, options) {
-    return this.currentSession ? (this.currentSession.sendDTMF(tones, options), true) : false;
-  }
-  transfer(target, options) {
-    return this.currentSession ? (this.currentSession.refer(target, options), true) : false;
-  }
-  enableVideo() {
-    this.mediaStream?.getVideoTracks().forEach((t) => t.enabled = true);
-  }
-  disableVideo() {
-    this.mediaStream?.getVideoTracks().forEach((t) => t.enabled = false);
-  }
-  async switchCamera(nextVideoTrack) {
-    const pc = this.getPC();
-    if (!pc)
-      return false;
-    if (!this.mediaStream)
-      this.mediaStream = new MediaStream();
-    const old = this.mediaStream.getVideoTracks()[0];
-    this.mediaStream.addTrack(nextVideoTrack);
-    if (old)
-      this.mediaStream.removeTrack(old);
-    const sender = pc.getSenders?.().find((s) => s.track?.kind === "video");
-    if (sender)
-      await sender.replaceTrack(nextVideoTrack);
-    if (old && old !== nextVideoTrack)
-      old.stop();
-    return true;
-  }
-  async replaceAudioTrack(nextAudioTrack) {
-    const pc = this.getPC();
-    if (!pc)
-      return false;
-    if (!this.mediaStream)
-      this.mediaStream = new MediaStream();
-    const old = this.mediaStream.getAudioTracks()[0];
-    this.mediaStream.addTrack(nextAudioTrack);
-    if (old)
-      this.mediaStream.removeTrack(old);
-    const sender = pc.getSenders?.().find((s) => s.track?.kind === "audio");
-    if (sender)
-      await sender.replaceTrack(nextAudioTrack);
-    if (old && old !== nextAudioTrack)
-      old.stop();
-    return true;
-  }
-};
-
-// src/jssip-lib/sip/sessionManager.ts
-var SessionManager = class {
-  constructor() {
-    this.entries = /* @__PURE__ */ new Map();
-  }
-  stopMediaStream(stream) {
-    if (!stream)
-      return;
-    for (const t of stream.getTracks()) {
-      if (t.readyState !== "ended")
-        t.stop();
-    }
-  }
-  getOrCreateRtc(sessionId, session) {
-    let entry = this.entries.get(sessionId);
-    if (!entry) {
-      entry = {
-        rtc: new WebRTCSessionController(),
-        session: null,
-        media: null
-      };
-      this.entries.set(sessionId, entry);
-    }
-    if (session) {
-      entry.session = session;
-      entry.rtc.setSession(session);
-    }
-    if (entry.media)
-      entry.rtc.setMediaStream(entry.media);
-    return entry.rtc;
-  }
-  getRtc(sessionId) {
-    return this.entries.get(sessionId)?.rtc ?? null;
-  }
-  setSession(sessionId, session) {
-    const entry = this.entries.get(sessionId);
-    if (entry) {
-      entry.session = session;
-      entry.rtc.setSession(session);
-    } else {
-      this.entries.set(sessionId, {
-        rtc: new WebRTCSessionController(),
-        session,
-        media: null
-      });
-    }
-  }
-  setSessionMedia(sessionId, stream) {
-    const entry = this.entries.get(sessionId) ?? {
-      rtc: new WebRTCSessionController(),
-      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);
-  }
-  getSession(sessionId) {
-    return this.entries.get(sessionId)?.session ?? null;
-  }
-  getSessionIds() {
-    return Array.from(this.entries.keys());
-  }
-  getSessions() {
-    return Array.from(this.entries.entries()).map(([id, entry]) => ({
-      id,
-      session: entry.session
-    }));
-  }
-  getActiveSessionId(activeStatuses = ["active"]) {
-    for (const [id, entry] of Array.from(this.entries.entries()).reverse()) {
-      const status = entry.session?.status;
-      if (status && activeStatuses.includes(String(status).toLowerCase())) {
-        return id;
-      }
-    }
-    return null;
-  }
-  cleanupSession(sessionId) {
-    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();
-  }
-  answer(sessionId, options) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.answer(options) : false;
-  }
-  hangup(sessionId, options) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.hangup(options) : false;
-  }
-  mute(sessionId) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.mute() : false;
-  }
-  unmute(sessionId) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.unmute() : false;
-  }
-  hold(sessionId) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.hold() : false;
-  }
-  unhold(sessionId) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.unhold() : false;
-  }
-  sendDTMF(sessionId, tones, options) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.sendDTMF(tones, options) : false;
-  }
-  transfer(sessionId, target, options) {
-    const rtc = this.getRtc(sessionId);
-    return rtc ? rtc.transfer(target, options) : false;
-  }
-};
-
-// 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();
+    this.enabled = false;
+    this.statsStops = /* @__PURE__ */ new Map();
   }
   setEnabled(enabled) {
     this.enabled = enabled;
@@ -883,6 +462,16 @@ var SipDebugLogger = class {
       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;
@@ -996,43 +585,582 @@ function collectAudioStats(report) {
   return { outboundAudio, inboundAudio };
 }
 
-// src/jssip-lib/sip/sessionLifecycle.ts
-var SessionLifecycle = class {
+// src/core/modules/media/mic-recovery.manager.ts
+var MicRecoveryManager = class {
   constructor(deps) {
-    this.state = deps.state;
-    this.sessionManager = deps.sessionManager;
-    this.emit = deps.emit;
-    this.emitError = deps.emitError;
-    this.attachSessionHandlers = deps.attachSessionHandlers;
-    this.getMaxSessionCount = deps.getMaxSessionCount;
+    this.enabled = false;
+    this.defaults = {
+      intervalMs: 2e3,
+      maxRetries: Infinity
+    };
+    this.active = /* @__PURE__ */ new Map();
+    this.syncedSenderTrackId = /* @__PURE__ */ new Map();
+    this.deps = deps;
   }
-  setDebugEnabled(enabled) {
-    sipDebugLogger.setEnabled(enabled);
+  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;
+    }
   }
-  handleNewRTCSession(e) {
-    const session = e.session;
-    const sessionId = String(
-      session?.id ?? crypto.randomUUID?.() ?? Date.now()
-    );
-    const currentSessions = this.state.getState().sessions;
-    if (currentSessions.length >= this.getMaxSessionCount()) {
-      try {
-        session.terminate?.({
+  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 (!track && sender?.track?.readyState === "live") {
+        const nextId = sender.track.id;
+        const prevId = this.syncedSenderTrackId.get(sessionId);
+        if (prevId === nextId)
+          return;
+        this.syncedSenderTrackId.set(sessionId, nextId);
+        this.deps.setSessionMedia(sessionId, new MediaStream([sender.track]));
+        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;
+      }
+    };
+    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);
+    this.syncedSenderTrackId.delete(sessionId);
+    return true;
+  }
+  cleanupAll() {
+    this.active.forEach((entry) => entry.stop());
+    this.active.clear();
+    this.syncedSenderTrackId.clear();
+  }
+};
+
+// src/core/modules/runtime/browser-unload.runtime.ts
+var BrowserUnloadRuntime = class {
+  attach(onBeforeUnload) {
+    if (typeof window === "undefined" || this.handler)
+      return;
+    this.handler = () => onBeforeUnload();
+    window.addEventListener("beforeunload", this.handler);
+  }
+  detach() {
+    if (typeof window === "undefined" || !this.handler)
+      return;
+    window.removeEventListener("beforeunload", this.handler);
+    this.handler = void 0;
+  }
+};
+
+// src/core/modules/media/webrtc-session.controller.ts
+var WebRTCSessionController = class {
+  constructor() {
+    this.currentSession = null;
+    this.mediaStream = null;
+  }
+  setSession(session) {
+    this.currentSession = session;
+  }
+  setMediaStream(stream) {
+    this.mediaStream = stream;
+  }
+  getPC() {
+    return this.currentSession?.connection ?? null;
+  }
+  cleanup(stopTracks = true) {
+    const pc = this.getPC();
+    const isClosed = pc?.connectionState === "closed" || pc?.signalingState === "closed";
+    if (pc && typeof pc.getSenders === "function") {
+      if (!isClosed) {
+        for (const sender of pc.getSenders()) {
+          try {
+            sender.replaceTrack(null);
+          } catch {
+          }
+        }
+      }
+    }
+    if (stopTracks && this.mediaStream) {
+      const senderTracks = pc && !isClosed ? new Set(
+        pc.getSenders().map((sender) => sender.track).filter((track) => Boolean(track))
+      ) : null;
+      for (const track of this.mediaStream.getTracks()) {
+        if (senderTracks?.has(track))
+          continue;
+        track.stop();
+      }
+    }
+    this.mediaStream = null;
+    this.currentSession = null;
+  }
+  answer(options = {}) {
+    return this.currentSession ? (this.currentSession.answer(options), true) : false;
+  }
+  hangup(options) {
+    return this.currentSession ? (this.currentSession.terminate(
+      options ?? { status_code: 486, reason_phrase: "Busy Here" }
+    ), true) : false;
+  }
+  mute() {
+    this.mediaStream?.getAudioTracks().forEach((track) => track.enabled = false);
+    return this.currentSession ? (this.currentSession.mute({ audio: true }), true) : false;
+  }
+  unmute() {
+    this.mediaStream?.getAudioTracks().forEach((track) => track.enabled = true);
+    return this.currentSession ? (this.currentSession.unmute({ audio: true }), true) : false;
+  }
+  hold() {
+    return this.currentSession ? (this.currentSession.hold(), true) : false;
+  }
+  unhold() {
+    return this.currentSession ? (this.currentSession.unhold(), true) : false;
+  }
+  sendDTMF(tones, options) {
+    return this.currentSession ? (this.currentSession.sendDTMF(tones, options), true) : false;
+  }
+  transfer(target, options) {
+    return this.currentSession ? (this.currentSession.refer(target, options), true) : false;
+  }
+  async replaceAudioTrack(nextAudioTrack) {
+    const pc = this.getPC();
+    if (!pc)
+      return false;
+    if (!this.mediaStream)
+      this.mediaStream = new MediaStream();
+    const old = this.mediaStream.getAudioTracks()[0];
+    this.mediaStream.addTrack(nextAudioTrack);
+    if (old)
+      this.mediaStream.removeTrack(old);
+    const sender = pc.getSenders?.().find((entry) => entry.track?.kind === "audio");
+    if (sender)
+      await sender.replaceTrack(nextAudioTrack);
+    if (old && old !== nextAudioTrack)
+      old.stop();
+    return true;
+  }
+};
+
+// src/core/modules/session/session.manager.ts
+var SessionManager = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  stopMediaStream(stream) {
+    if (!stream)
+      return;
+    for (const track of stream.getTracks()) {
+      if (track.readyState !== "ended")
+        track.stop();
+    }
+  }
+  getOrCreateRtc(sessionId, session) {
+    let entry = this.entries.get(sessionId);
+    if (!entry) {
+      entry = {
+        rtc: new WebRTCSessionController(),
+        session: null,
+        media: null
+      };
+      this.entries.set(sessionId, entry);
+    }
+    if (session) {
+      entry.session = session;
+      entry.rtc.setSession(session);
+    }
+    if (entry.media)
+      entry.rtc.setMediaStream(entry.media);
+    return entry.rtc;
+  }
+  getRtc(sessionId) {
+    return this.entries.get(sessionId)?.rtc ?? null;
+  }
+  setSession(sessionId, session) {
+    const entry = this.entries.get(sessionId);
+    if (entry) {
+      entry.session = session;
+      entry.rtc.setSession(session);
+    } else {
+      this.entries.set(sessionId, {
+        rtc: new WebRTCSessionController(),
+        session,
+        media: null
+      });
+    }
+  }
+  setSessionMedia(sessionId, stream) {
+    const entry = this.entries.get(sessionId) ?? {
+      rtc: new WebRTCSessionController(),
+      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);
+  }
+  getSession(sessionId) {
+    return this.entries.get(sessionId)?.session ?? null;
+  }
+  getSessionIds() {
+    return Array.from(this.entries.keys());
+  }
+  getSessions() {
+    return Array.from(this.entries.entries()).map(([id, entry]) => ({
+      id,
+      session: entry.session
+    }));
+  }
+  cleanupSession(sessionId) {
+    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();
+  }
+  answer(sessionId, options) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.answer(options) : false;
+  }
+  hangup(sessionId, options) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.hangup(options) : false;
+  }
+  mute(sessionId) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.mute() : false;
+  }
+  unmute(sessionId) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.unmute() : false;
+  }
+  hold(sessionId) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.hold() : false;
+  }
+  unhold(sessionId) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.unhold() : false;
+  }
+  sendDTMF(sessionId, tones, options) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.sendDTMF(tones, options) : false;
+  }
+  transfer(sessionId, target, options) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.transfer(target, options) : false;
+  }
+};
+
+// src/core/modules/session/session.state.projector.ts
+function toSessionMaps(sessions) {
+  const sessionsById = {};
+  const sessionIds = [];
+  for (const session of sessions) {
+    sessionsById[session.id] = session;
+    sessionIds.push(session.id);
+  }
+  return { sessionsById, sessionIds };
+}
+function holdOtherSessions(state, sessionId, holdFn) {
+  const current = state.getState();
+  current.sessionIds.forEach((id) => {
+    if (id === sessionId)
+      return;
+    const session = current.sessionsById[id];
+    if (session?.status === CallStatus.Active) {
+      holdFn(id);
+    }
+  });
+}
+function upsertSessionState(state, sessionId, partial) {
+  const current = state.getState();
+  const existing = current.sessionsById[sessionId];
+  const base = existing ?? {
+    id: sessionId,
+    status: CallStatus.Idle,
+    direction: null,
+    from: null,
+    to: null,
+    muted: false,
+    acceptedAt: null
+  };
+  const nextSession = { ...base, ...partial };
+  const sessions = current.sessionIds.map(
+    (id) => id === sessionId ? nextSession : current.sessionsById[id]
+  );
+  if (!existing) {
+    sessions.push(nextSession);
+  }
+  const { sessionsById, sessionIds } = toSessionMaps(sessions);
+  state.setState({ sessions, sessionsById, sessionIds });
+}
+function removeSessionState(state, sessionId) {
+  const current = state.getState();
+  const sessions = current.sessionIds.filter((id) => id !== sessionId).map((id) => current.sessionsById[id]);
+  const { sessionsById, sessionIds } = toSessionMaps(sessions);
+  state.setState({
+    sessions,
+    sessionsById,
+    sessionIds,
+    error: null
+  });
+}
+
+// src/core/modules/session/session.handlers.ts
+function createSessionHandlers(deps) {
+  const {
+    emitter,
+    state,
+    rtc,
+    detachSessionHandlers,
+    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);
+    },
+    accepted: (e) => {
+      emitter.emit("accepted", e);
+      const existing = state.getState().sessionsById[sessionId];
+      upsertSessionState(state, sessionId, {
+        status: CallStatus.Active,
+        acceptedAt: existing?.acceptedAt ?? Date.now()
+      });
+    },
+    confirmed: (e) => {
+      emitter.emit("confirmed", e);
+      deps.enableMicrophoneRecovery?.(sessionId);
+    },
+    ended: (e) => {
+      emitter.emit("ended", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    failed: (e) => {
+      emitter.emit("failed", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    muted: (e) => {
+      emitter.emit("muted", e);
+      upsertSessionState(state, sessionId, { muted: true });
+    },
+    unmuted: (e) => {
+      emitter.emit("unmuted", e);
+      upsertSessionState(state, sessionId, { muted: false });
+    },
+    hold: (e) => {
+      emitter.emit("hold", e);
+      upsertSessionState(state, sessionId, { status: CallStatus.Hold });
+    },
+    unhold: (e) => {
+      emitter.emit("unhold", e);
+      upsertSessionState(state, sessionId, { status: CallStatus.Active });
+    },
+    reinvite: (e) => emitter.emit("reinvite", e),
+    update: (e) => emitter.emit("update", e),
+    sdp: (e) => emitter.emit("sdp", 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();
+      removeSessionState(state, sessionId);
+    },
+    "peerconnection:createofferfailed": (e) => {
+      emitter.emit("peerconnection:createofferfailed", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    "peerconnection:createanswerfailed": (e) => {
+      emitter.emit("peerconnection:createanswerfailed", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    "peerconnection:setlocaldescriptionfailed": (e) => {
+      emitter.emit("peerconnection:setlocaldescriptionfailed", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    "peerconnection:setremotedescriptionfailed": (e) => {
+      emitter.emit("peerconnection:setremotedescriptionfailed", e);
+      clearIceReadyTimer();
+      detachSessionHandlers();
+      rtc.cleanup();
+      removeSessionState(state, sessionId);
+    },
+    peerconnection: (e) => emitter.emit("peerconnection", e)
+  };
+}
+
+// src/core/modules/session/session.lifecycle.ts
+var SessionLifecycle = class {
+  constructor(deps) {
+    this.state = deps.state;
+    this.sessionManager = deps.sessionManager;
+    this.emit = deps.emit;
+    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 currentSessions = this.state.getState().sessions;
+    if (currentSessions.length >= this.getMaxSessionCount()) {
+      try {
+        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"
-        );
-      }
-      return;
     }
     const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
     this.sessionManager.setSession(sessionId, session);
@@ -1048,14 +1176,11 @@ var SessionLifecycle = class {
       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,
       from: e.originator === "remote" ? e.request.from.uri.user : null,
       to: e.request.to.uri.user,
-      status: e.originator === "remote" ? CallStatus.Ringing : CallStatus.Dialing,
-      mediaKind: sdpHasVideo ? "video" : "audio",
-      remoteVideoEnabled: sdpHasVideo
+      status: e.originator === "remote" ? CallStatus.Ringing : CallStatus.Dialing
     });
     this.emit("newRTCSession", e);
   }
@@ -1123,7 +1248,10 @@ var SessionLifecycle = class {
       attachedPc = pc;
       attachedPc.addEventListener?.("signalingstatechange", onPcStateChange);
       attachedPc.addEventListener?.("connectionstatechange", onPcStateChange);
-      attachedPc.addEventListener?.("iceconnectionstatechange", onPcStateChange);
+      attachedPc.addEventListener?.(
+        "iceconnectionstatechange",
+        onPcStateChange
+      );
     };
     const clearRetryTimer = () => {
       if (!retryTimer)
@@ -1131,7 +1259,7 @@ var SessionLifecycle = class {
       clearTimeout(retryTimer);
       retryTimer = null;
     };
-    const stopRetry = () => {
+    const stopRetry = (opts = {}) => {
       if (stopped)
         return;
       stopped = true;
@@ -1232,8 +1360,8 @@ var SessionLifecycle = class {
       session.on?.("peerconnection", onPeer);
     }
     session.on?.("confirmed", onConfirmed);
-    session.on?.("ended", stopRetry);
-    session.on?.("failed", stopRetry);
+    session.on?.("ended", (e) => stopRetry());
+    session.on?.("failed", (e) => stopRetry());
   }
   bindRemoteIncomingAudio(sessionId, session) {
     const maxAttempts = 50;
@@ -1299,11 +1427,11 @@ var SessionLifecycle = class {
           return;
         exhaustedCheckUsed = true;
         if (checkRemoteTrack(attachedPc))
-          stopRetry();
+          stopRetry({ keepTrack: true });
         return;
       }
       if (checkRemoteTrack(attachedPc))
-        stopRetry();
+        stopRetry({ keepTrack: true });
     };
     const attachPcListeners = (pc) => {
       if (!pc || pc === attachedPc)
@@ -1326,7 +1454,10 @@ var SessionLifecycle = class {
       attachedPc = pc;
       attachedPc.addEventListener?.("signalingstatechange", onPcStateChange);
       attachedPc.addEventListener?.("connectionstatechange", onPcStateChange);
-      attachedPc.addEventListener?.("iceconnectionstatechange", onPcStateChange);
+      attachedPc.addEventListener?.(
+        "iceconnectionstatechange",
+        onPcStateChange
+      );
       attachedPc.addEventListener?.("track", onTrack);
     };
     const clearRetryTimer = () => {
@@ -1335,7 +1466,7 @@ var SessionLifecycle = class {
       clearTimeout(retryTimer);
       retryTimer = null;
     };
-    const stopRetry = () => {
+    const stopRetry = (opts = {}) => {
       if (stopped)
         return;
       stopped = true;
@@ -1356,7 +1487,7 @@ var SessionLifecycle = class {
         attachedPc.removeEventListener?.("track", onTrack);
         attachedPc = null;
       }
-      if (attachedTrack) {
+      if (attachedTrack && !opts.keepTrack) {
         attachedTrack.removeEventListener?.("ended", onRemoteEnded);
         attachedTrack.removeEventListener?.("mute", onRemoteMuted);
         attachedTrack = null;
@@ -1385,7 +1516,7 @@ var SessionLifecycle = class {
         retryScheduled = false;
         retryTimer = null;
         if (checkRemoteTrack(pc)) {
-          stopRetry();
+          stopRetry({ keepTrack: true });
           return;
         }
         if (!pc)
@@ -1401,11 +1532,11 @@ var SessionLifecycle = class {
           return;
         exhaustedCheckUsed = true;
         if (checkRemoteTrack(attachedPc))
-          stopRetry();
+          stopRetry({ keepTrack: true });
         return;
       }
       if (checkRemoteTrack(attachedPc))
-        stopRetry();
+        stopRetry({ keepTrack: true });
     };
     const onPeer = (data) => {
       if (stopped)
@@ -1416,11 +1547,11 @@ var SessionLifecycle = class {
           return;
         exhaustedCheckUsed = true;
         if (checkRemoteTrack(data.peerconnection))
-          stopRetry();
+          stopRetry({ keepTrack: true });
         return;
       }
       if (checkRemoteTrack(data.peerconnection)) {
-        stopRetry();
+        stopRetry({ keepTrack: true });
         return;
       }
       scheduleRetry(data.peerconnection);
@@ -1428,205 +1559,341 @@ var SessionLifecycle = class {
     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);
+      const currentPc = session?.connection ?? attachedPc;
+      if (exhausted) {
+        if (exhaustedCheckUsed)
+          return;
+        exhaustedCheckUsed = true;
+        if (checkRemoteTrack(currentPc))
+          stopRetry({ keepTrack: true });
         return;
       }
-      const nextTrack = nextStream.getAudioTracks()[0];
-      if (!nextTrack)
+      if (checkRemoteTrack(currentPc)) {
+        stopRetry({ keepTrack: true });
         return;
-      await rtc.replaceAudioTrack(nextTrack);
-      this.deps.setSessionMedia(sessionId, nextStream);
+      }
+      logMissingReceiver(currentPc, "confirmed without remote track");
+      scheduleRetry(currentPc);
     };
-    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();
+    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);
     };
-    pc?.addEventListener?.("iceconnectionstatechange", onIceChange);
-    const stop = () => {
-      stopped = true;
-      clearInterval(timer);
-      pc?.removeEventListener?.("iceconnectionstatechange", onIceChange);
+    const onEnd = () => {
+      sipDebugLogger.stopCallStatsLogging(sessionId);
     };
-    this.active.set(sessionId, { stop });
-    return stop;
+    session.on?.("confirmed", onConfirmed);
+    session.on?.("ended", onEnd);
+    session.on?.("failed", onEnd);
   }
-  disable(sessionId) {
-    const entry = this.active.get(sessionId);
-    if (!entry)
+};
+
+// src/core/modules/session/session.module.ts
+var SessionModule = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.sessionHandlers = /* @__PURE__ */ new Map();
+    this.lifecycle = new SessionLifecycle({
+      state: deps.state,
+      sessionManager: deps.sessionManager,
+      emit: (event, payload) => deps.emitter.emit(event, payload),
+      attachSessionHandlers: (sessionId, session) => this.attachSessionHandlers(sessionId, session),
+      getMaxSessionCount: deps.getMaxSessionCount
+    });
+  }
+  setDebugEnabled(enabled) {
+    this.lifecycle.setDebugEnabled(enabled);
+  }
+  handleNewRTCSession(e) {
+    this.lifecycle.handleNewRTCSession(e);
+  }
+  setSessionMedia(sessionId, stream) {
+    this.deps.sessionManager.setSessionMedia(sessionId, stream);
+  }
+  setSession(sessionId, session) {
+    this.deps.sessionManager.setSession(sessionId, session);
+  }
+  answerSession(sessionId, options = {}) {
+    if (!sessionId || !this.sessionExists(sessionId))
       return false;
-    entry.stop();
-    this.active.delete(sessionId);
+    return this.deps.sessionManager.answer(sessionId, options);
+  }
+  hangupSession(sessionId, options) {
+    if (!sessionId || !this.sessionExists(sessionId))
+      return false;
+    return this.deps.sessionManager.hangup(sessionId, options);
+  }
+  hangupAll(options) {
+    const ids = this.getSessionIds();
+    ids.forEach((id) => this.hangupSession(id, options));
+    return ids.length > 0;
+  }
+  toggleMuteSession(sessionId) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    const muted = sessionState?.muted ?? false;
+    if (muted) {
+      this.deps.sessionManager.unmute(resolved);
+      return true;
+    }
+    this.deps.sessionManager.mute(resolved);
     return true;
   }
-  cleanupAll() {
-    this.active.forEach((entry) => entry.stop());
-    this.active.clear();
+  toggleHoldSession(sessionId) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    const isOnHold = sessionState?.status === CallStatus.Hold;
+    if (isOnHold) {
+      this.deps.sessionManager.unhold(resolved);
+      return true;
+    }
+    if (sessionState?.status === CallStatus.Active) {
+      this.deps.sessionManager.hold(resolved);
+      return true;
+    }
+    return true;
+  }
+  sendDTMFSession(sessionId, tones, options) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    if (sessionState?.status === CallStatus.Active) {
+      this.deps.sessionManager.sendDTMF(resolved, tones, options);
+    }
+    return true;
+  }
+  transferSession(sessionId, target, options) {
+    const resolved = this.resolveExistingSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.deps.state.getState().sessionsById[resolved];
+    if (sessionState?.status === CallStatus.Active) {
+      this.deps.sessionManager.transfer(resolved, target, options);
+    }
+    return true;
+  }
+  getSession(sessionId) {
+    return this.deps.sessionManager.getSession(sessionId);
+  }
+  getSessionIds() {
+    return this.deps.sessionManager.getSessionIds();
+  }
+  getSessions() {
+    return this.deps.sessionManager.getSessions();
+  }
+  cleanupAllSessions() {
+    this.deps.sessionManager.cleanupAllSessions();
+    this.deps.micRecovery.cleanupAll();
+    this.sessionHandlers.clear();
+    this.deps.state.setState({
+      sessions: [],
+      sessionsById: {},
+      sessionIds: [],
+      error: null
+    });
+  }
+  attachSessionHandlers(sessionId, session) {
+    const handlers = this.createSessionHandlersFor(sessionId, session);
+    this.sessionHandlers.set(sessionId, handlers);
+    Object.keys(handlers).forEach((ev) => {
+      const h = handlers[ev];
+      if (h)
+        session.on(ev, h);
+    });
+  }
+  detachSessionHandlers(sessionId, session) {
+    const handlers = this.sessionHandlers.get(sessionId);
+    if (!handlers || !session)
+      return;
+    Object.keys(handlers).forEach((ev) => {
+      const h = handlers[ev];
+      if (h)
+        session.off(ev, h);
+    });
+    this.sessionHandlers.delete(sessionId);
+  }
+  cleanupSession(sessionId, session) {
+    const targetSession = session ?? this.deps.sessionManager.getSession(sessionId) ?? this.deps.sessionManager.getRtc(sessionId)?.currentSession;
+    this.detachSessionHandlers(sessionId, targetSession);
+    this.deps.micRecovery.disable(sessionId);
+    this.deps.sessionManager.cleanupSession(sessionId);
+    removeSessionState(this.deps.state, sessionId);
+  }
+  createSessionHandlersFor(sessionId, session) {
+    const rtc = this.deps.sessionManager.getOrCreateRtc(sessionId, session);
+    return createSessionHandlers({
+      emitter: this.deps.emitter,
+      state: this.deps.state,
+      rtc,
+      detachSessionHandlers: () => this.cleanupSession(sessionId, session),
+      enableMicrophoneRecovery: (confirmedSessionId) => this.deps.micRecovery.enable(confirmedSessionId),
+      iceCandidateReadyDelayMs: this.deps.getIceCandidateReadyDelayMs(),
+      sessionId
+    });
+  }
+  resolveSessionId(sessionId) {
+    if (sessionId)
+      return sessionId;
+    const state = this.deps.state.getState();
+    const activeId = state.sessionIds.find(
+      (id) => state.sessionsById[id]?.status === CallStatus.Active
+    );
+    return activeId ?? state.sessionIds[0] ?? null;
+  }
+  sessionExists(sessionId) {
+    return !!this.deps.sessionManager.getSession(sessionId) || !!this.deps.sessionManager.getRtc(sessionId);
+  }
+  resolveExistingSessionId(sessionId) {
+    const id = this.resolveSessionId(sessionId);
+    if (!id)
+      return null;
+    return this.sessionExists(id) ? id : null;
   }
 };
 
-// src/jssip-lib/sip/client.ts
-var SESSION_DEBUG_KEY = "sip-debug-enabled";
-var SipClient = class extends EventTargetEmitter {
-  constructor(options = {}) {
-    super();
-    this.userAgent = new SipUserAgent();
-    this.stateStore = new SipStateStore();
-    this.sessionHandlers = /* @__PURE__ */ new Map();
-    this.maxSessionCount = Infinity;
-    this.sessionManager = new SessionManager();
-    this.errorHandler = options.errorHandler ?? new SipErrorHandler({
-      formatter: options.formatError,
-      messages: options.errorMessages
+// src/core/modules/ua/ua.handlers.ts
+function createUAHandlers(deps) {
+  const { emitter, state, cleanupAllSessions, onNewRTCSession } = deps;
+  return {
+    connecting: (e) => {
+      emitter.emit("connecting", e);
+      state.batchSet({ sipStatus: SipStatus.Connecting });
+    },
+    connected: (e) => {
+      emitter.emit("connected", e);
+      state.batchSet({ sipStatus: SipStatus.Connected });
+    },
+    disconnected: (e) => {
+      emitter.emit("disconnected", e);
+      cleanupAllSessions();
+      state.reset();
+    },
+    registered: (e) => {
+      emitter.emit("registered", e);
+      state.batchSet({ sipStatus: SipStatus.Registered, error: null });
+    },
+    unregistered: (e) => {
+      emitter.emit("unregistered", e);
+      state.batchSet({ sipStatus: SipStatus.Unregistered });
+    },
+    registrationFailed: (e) => {
+      emitter.emit("registrationFailed", e);
+      cleanupAllSessions();
+      state.batchSet({
+        sipStatus: SipStatus.RegistrationFailed,
+        error: e?.cause || "registration failed"
+      });
+    },
+    newRTCSession: onNewRTCSession,
+    newMessage: (e) => emitter.emit("newMessage", e),
+    sipEvent: (e) => emitter.emit("sipEvent", e),
+    newOptions: (e) => emitter.emit("newOptions", e)
+  };
+}
+
+// src/core/modules/ua/ua.module.ts
+var UaModule = class {
+  constructor(deps) {
+    this.userAgent = deps.userAgent;
+    this.uaHandlers = deps.createHandlers();
+    this.uaHandlerKeys = Object.keys(this.uaHandlers);
+  }
+  start(uri, password, config, debug) {
+    this.userAgent.start(uri, password, config, { debug });
+    this.attachHandlers();
+  }
+  stop() {
+    this.detachHandlers();
+    this.userAgent.stop();
+  }
+  register() {
+    this.userAgent.register();
+  }
+  setDebug(debug) {
+    this.userAgent.setDebug(debug);
+  }
+  attachHandlers() {
+    const ua = this.userAgent.ua;
+    if (!ua)
+      return;
+    this.detachHandlers();
+    this.uaHandlerKeys.forEach((event) => {
+      const handler = this.uaHandlers[event];
+      if (handler)
+        ua.on(event, handler);
     });
-    this.debugPattern = options.debug;
-    this.uaHandlers = createUAHandlers({
-      emitter: this,
-      state: this.stateStore,
-      cleanupAllSessions: () => this.cleanupAllSessions(),
-      emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
-      onNewRTCSession: (e) => this.onNewRTCSession(e)
+  }
+  detachHandlers() {
+    const ua = this.userAgent.ua;
+    if (!ua)
+      return;
+    this.uaHandlerKeys.forEach((event) => {
+      const handler = this.uaHandlers[event];
+      if (handler)
+        ua.off(event, handler);
     });
-    this.uaHandlerKeys = Object.keys(this.uaHandlers);
-    this.lifecycle = new SessionLifecycle({
-      state: this.stateStore,
-      sessionManager: this.sessionManager,
-      emit: (event, payload) => this.emit(event, payload),
-      emitError: (raw, code, fallback) => this.emitError(raw, code, fallback),
-      attachSessionHandlers: (sessionId, session) => this.attachSessionHandlers(sessionId, session),
-      getMaxSessionCount: () => this.maxSessionCount
+  }
+};
+
+// src/core/client/sip.client.ts
+var SipClient = class extends EventTargetEmitter {
+  constructor(options = {}) {
+    super();
+    this.userAgent = new SipUserAgent();
+    this.stateStore = new SipStateStore();
+    this.maxSessionCount = Infinity;
+    this.sessionManager = new SessionManager();
+    this.unloadRuntime = new BrowserUnloadRuntime();
+    this.debugPattern = options.debug;
+    this.uaModule = new UaModule({
+      userAgent: this.userAgent,
+      createHandlers: () => createUAHandlers({
+        emitter: this,
+        state: this.stateStore,
+        cleanupAllSessions: () => this.cleanupAllSessions(),
+        onNewRTCSession: (e) => this.onNewRTCSession(e)
+      })
     });
     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)
+      getSessionState: (sessionId) => this.stateStore.getState().sessionsById[sessionId],
+      setSessionMedia: (sessionId, stream) => this.sessionManager.setSessionMedia(sessionId, stream)
     });
-    if (typeof window !== "undefined") {
-      window.sipDebugBridge = (debug) => this.setDebug(debug ?? true);
-    }
+    this.sessionModule = new SessionModule({
+      state: this.stateStore,
+      emitter: this,
+      sessionManager: this.sessionManager,
+      micRecovery: this.micRecovery,
+      getMaxSessionCount: () => this.maxSessionCount,
+      getIceCandidateReadyDelayMs: () => this.iceCandidateReadyDelayMs
+    });
+    this.debugRuntime = new SipDebugRuntime({
+      getState: () => this.stateStore.getState(),
+      onChange: (listener) => this.stateStore.onChange(listener),
+      getSessions: () => this.getSessions(),
+      setDebugEnabled: (enabled) => this.sessionModule.setDebugEnabled(enabled)
+    });
+    this.debugRuntime.attachBridge(
+      (debug) => this.setDebug(debug)
+    );
   }
   get state() {
     return this.stateStore.getState();
@@ -1640,388 +1907,184 @@ 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,
       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);
+    const debug = cfgDebug ?? this.debugRuntime.getPersistedDebug() ?? this.debugPattern;
+    this.uaModule.start(uri, password, uaCfg, debug);
+    this.sessionModule.setDebugEnabled(Boolean(debug));
+    this.unloadRuntime.attach(() => {
+      this.hangupAll();
+      this.disconnect();
+    });
+    this.debugRuntime.syncInspector(debug);
   }
   registerUA() {
-    this.userAgent.register();
+    this.uaModule.register();
   }
   disconnect() {
-    this.detachBeforeUnload();
-    this.detachUAHandlers();
-    this.userAgent.stop();
+    this.unloadRuntime.detach();
+    this.uaModule.stop();
     this.cleanupAllSessions();
     this.stateStore.reset();
+    this.debugRuntime.cleanup();
   }
   call(target, callOptions = {}) {
     try {
-      const opts = this.ensureMediaConstraints(callOptions);
       const ua = this.userAgent.getUA();
-      const session = ua?.call(target, opts);
-      if (session && opts.mediaStream) {
+      const session = ua?.call(target, callOptions);
+      if (session && callOptions.mediaStream) {
         const sessionId = String(session?.id ?? "");
         if (sessionId) {
-          this.sessionManager.setSessionMedia(sessionId, opts.mediaStream);
-          this.sessionManager.setSession(sessionId, session);
+          this.sessionModule.setSessionMedia(sessionId, callOptions.mediaStream);
+          this.sessionModule.setSession(sessionId, session);
         }
       }
     } catch (e) {
-      const err = this.emitError(e, "CALL_FAILED", "call failed");
+      console.error(e);
       this.cleanupAllSessions();
-      this.stateStore.batchSet({
-        error: err.cause
-      });
     }
   }
-  answer(sessionId, options = {}) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    return this.answerSession(resolved, options);
-  }
-  hangup(sessionId, options) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    return this.hangupSession(resolved, options);
-  }
   hangupAll(options) {
     const ids = this.getSessionIds();
     ids.forEach((id) => this.hangupSession(id, options));
     return ids.length > 0;
   }
-  toggleMute(sessionId) {
-    return this.toggleMuteSession(sessionId);
-  }
-  toggleHold(sessionId) {
-    return this.toggleHoldSession(sessionId);
-  }
-  sendDTMF(sessionId, tones, options) {
-    return this.sendDTMFSession(sessionId, tones, options);
-  }
-  transfer(sessionId, target, options) {
-    return this.transferSession(sessionId, target, options);
-  }
   onChange(fn) {
     return this.stateStore.onChange(fn);
   }
-  attachUAHandlers() {
-    const ua = this.userAgent.ua;
-    if (!ua)
-      return;
-    this.detachUAHandlers();
-    this.uaHandlerKeys.forEach((ev) => {
-      const h = this.uaHandlers[ev];
-      if (h)
-        ua.on(ev, h);
-    });
-  }
   setDebug(debug) {
     this.debugPattern = debug;
-    this.userAgent.setDebug(debug);
-    this.lifecycle.setDebugEnabled(Boolean(debug));
-    this.syncDebugInspector(debug);
-  }
-  attachSessionHandlers(sessionId, session) {
-    const handlers = this.createSessionHandlersFor(sessionId, session);
-    this.sessionHandlers.set(sessionId, handlers);
-    Object.keys(handlers).forEach((ev) => {
-      const h = handlers[ev];
-      if (h)
-        session.on(ev, h);
-    });
-  }
-  detachSessionHandlers(sessionId, session) {
-    const handlers = this.sessionHandlers.get(sessionId);
-    if (!handlers || !session)
-      return;
-    Object.keys(handlers).forEach((ev) => {
-      const h = handlers[ev];
-      if (h)
-        session.off(ev, h);
-    });
-    this.sessionHandlers.delete(sessionId);
-  }
-  detachUAHandlers() {
-    const ua = this.userAgent.ua;
-    if (!ua)
-      return;
-    this.uaHandlerKeys.forEach((ev) => {
-      const h = this.uaHandlers[ev];
-      if (h)
-        ua.off(ev, h);
-    });
-  }
-  cleanupSession(sessionId, session) {
-    const targetSession = session ?? this.sessionManager.getSession(sessionId) ?? this.sessionManager.getRtc(sessionId)?.currentSession;
-    this.detachSessionHandlers(sessionId, targetSession);
-    this.micRecovery.disable(sessionId);
-    this.sessionManager.cleanupSession(sessionId);
-    removeSessionState(this.stateStore, sessionId);
+    this.uaModule.setDebug(debug);
+    this.sessionModule.setDebugEnabled(Boolean(debug));
+    const effectiveDebug = debug ?? this.debugRuntime.getPersistedDebug() ?? this.debugPattern;
+    this.debugRuntime.syncInspector(effectiveDebug);
   }
   cleanupAllSessions() {
-    this.sessionManager.cleanupAllSessions();
-    this.micRecovery.cleanupAll();
-    this.sessionHandlers.clear();
-    this.stateStore.setState({
-      sessions: [],
-      error: null
-    });
-  }
-  createSessionHandlersFor(sessionId, session) {
-    const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
-    return createSessionHandlers({
-      emitter: this,
-      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),
-      enableMicrophoneRecovery: (confirmedSessionId) => this.micRecovery.enable(confirmedSessionId),
-      sessionId
-    });
+    this.sessionModule.cleanupAllSessions();
   }
   onNewRTCSession(e) {
-    this.lifecycle.handleNewRTCSession(e);
-  }
-  onSessionFailed(error, event) {
-    const rawCause = event?.cause ?? error;
-    const statusCode = event?.message?.status_code;
-    const statusText = event?.message?.reason_phrase;
-    const causeText = rawCause || (statusCode ? `${statusCode}${statusText ? " " + statusText : ""}` : "call failed");
-    this.emitError(
-      { raw: event, cause: rawCause, statusCode, statusText },
-      "SESSION_FAILED",
-      causeText
-    );
-  }
-  emitError(raw, code, fallback) {
-    const payload = this.errorHandler.format({ raw, code, fallback });
-    this.emit("error", payload);
-    return payload;
-  }
-  resolveSessionId(sessionId) {
-    if (sessionId)
-      return sessionId;
-    const sessions = this.stateStore.getState().sessions;
-    const active = sessions.find((s) => s.status === CallStatus.Active);
-    return active?.id ?? sessions[0]?.id ?? null;
-  }
-  sessionExists(sessionId) {
-    return !!this.sessionManager.getSession(sessionId) || !!this.sessionManager.getRtc(sessionId);
-  }
-  resolveExistingSessionId(sessionId) {
-    const id = this.resolveSessionId(sessionId);
-    if (!id)
-      return null;
-    return this.sessionExists(id) ? id : null;
-  }
-  ensureMediaConstraints(opts) {
-    if (opts.mediaStream || opts.mediaConstraints)
-      return opts;
-    return { ...opts, mediaConstraints: { audio: true, video: false } };
+    this.sessionModule.handleNewRTCSession(e);
   }
   answerSession(sessionId, options = {}) {
-    if (!sessionId || !this.sessionExists(sessionId))
-      return false;
-    const opts = this.ensureMediaConstraints(options);
-    if (opts.mediaStream) {
-      this.sessionManager.setSessionMedia(sessionId, opts.mediaStream);
+    if (options.mediaStream) {
+      this.sessionModule.setSessionMedia(sessionId, options.mediaStream);
     }
-    return this.sessionManager.answer(sessionId, opts);
+    return this.sessionModule.answerSession(sessionId, options);
   }
   hangupSession(sessionId, options) {
-    if (!sessionId || !this.sessionExists(sessionId))
-      return false;
-    return this.sessionManager.hangup(sessionId, options);
+    return this.sessionModule.hangupSession(sessionId, options);
   }
   toggleMuteSession(sessionId) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
-    const muted = sessionState?.muted ?? false;
-    if (muted) {
-      this.sessionManager.unmute(resolved);
-      return true;
-    }
-    this.sessionManager.mute(resolved);
-    return true;
+    return this.sessionModule.toggleMuteSession(sessionId);
   }
   toggleHoldSession(sessionId) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
-    const isOnHold = sessionState?.status === CallStatus.Hold;
-    if (isOnHold) {
-      this.sessionManager.unhold(resolved);
-      return true;
-    }
-    if (sessionState?.status === CallStatus.Active) {
-      this.sessionManager.hold(resolved);
-      return true;
-    }
-    return true;
+    return this.sessionModule.toggleHoldSession(sessionId);
   }
   sendDTMFSession(sessionId, tones, options) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
-    if (sessionState?.status === CallStatus.Active)
-      this.sessionManager.sendDTMF(resolved, tones, options);
-    return true;
+    return this.sessionModule.sendDTMFSession(sessionId, tones, options);
   }
   transferSession(sessionId, target, options) {
-    const resolved = this.resolveExistingSessionId(sessionId);
-    if (!resolved)
-      return false;
-    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
-    if (sessionState?.status === CallStatus.Active)
-      this.sessionManager.transfer(resolved, target, options);
-    return true;
+    return this.sessionModule.transferSession(sessionId, target, options);
   }
   setSessionMedia(sessionId, stream) {
-    this.sessionManager.setSessionMedia(sessionId, stream);
-  }
-  switchCameraSession(sessionId, track) {
-    if (!this.sessionExists(sessionId))
-      return false;
-    const rtc = this.sessionManager.getRtc(sessionId);
-    return rtc ? rtc.switchCamera(track) : false;
-  }
-  enableVideoSession(sessionId) {
-    if (!this.sessionExists(sessionId))
-      return false;
-    const rtc = this.sessionManager.getRtc(sessionId);
-    rtc?.enableVideo();
-    return !!rtc;
-  }
-  disableVideoSession(sessionId) {
-    if (!this.sessionExists(sessionId))
-      return false;
-    const rtc = this.sessionManager.getRtc(sessionId);
-    rtc?.disableVideo();
-    return !!rtc;
+    this.sessionModule.setSessionMedia(sessionId, stream);
   }
   getSession(sessionId) {
-    return this.sessionManager.getSession(sessionId);
+    return this.sessionModule.getSession(sessionId);
   }
   getSessionIds() {
-    return this.sessionManager.getSessionIds();
+    return this.sessionModule.getSessionIds();
   }
   getSessions() {
-    return this.sessionManager.getSessions();
-  }
-  attachBeforeUnload() {
-    if (typeof window === "undefined" || this.unloadHandler)
-      return;
-    const handler = () => {
-      this.hangupAll();
-      this.disconnect();
-    };
-    window.addEventListener("beforeunload", handler);
-    this.unloadHandler = handler;
-  }
-  detachBeforeUnload() {
-    if (typeof window === "undefined" || !this.unloadHandler)
-      return;
-    window.removeEventListener("beforeunload", this.unloadHandler);
-    this.unloadHandler = void 0;
-  }
-  syncDebugInspector(debug) {
-    if (typeof window === "undefined")
-      return;
-    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 = () => effectiveDebug ? this.stateStore.getState() : disabledInspector();
-    win.sipSessions = () => effectiveDebug ? this.getSessions() : disabledInspector();
-  }
-  toggleStateLogger(enabled) {
-    if (!enabled) {
-      this.stateLogOff?.();
-      this.stateLogOff = void 0;
-      return;
-    }
-    if (this.stateLogOff)
-      return;
-    let prev = this.stateStore.getState();
-    console.info("[sip][state]", { initial: true }, prev);
-    this.stateLogOff = this.stateStore.onChange((next) => {
-      console.info("[sip][state]", next);
-      prev = next;
-    });
-  }
-  getPersistedDebug() {
-    if (typeof window === "undefined")
-      return void 0;
-    try {
-      const persisted = window.sessionStorage.getItem(SESSION_DEBUG_KEY);
-      if (!persisted)
-        return void 0;
-      return persisted;
-    } catch {
-      return void 0;
-    }
-  }
-  async requestMicrophoneStreamInternal(deviceId) {
-    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
-      throw new Error("getUserMedia not available");
-    }
-    const audio = deviceId && deviceId !== "default" ? { deviceId: { exact: deviceId } } : true;
-    try {
-      return await navigator.mediaDevices.getUserMedia({ audio });
-    } catch (err) {
-      const cause = err?.name || "getUserMedia failed";
-      this.emitError(
-        { raw: err, cause },
-        "MICROPHONE_UNAVAILABLE",
-        "microphone unavailable"
-      );
-      throw err;
-    }
+    return this.sessionModule.getSessions();
   }
 };
 function createSipClientInstance(options) {
   return new SipClient(options);
 }
-function createSipEventManager(client) {
+
+// src/core/modules/media/media.module.ts
+function createMediaModule(deps) {
+  const { client, eventManager } = deps;
   return {
-    onUA(event, handler) {
-      return client.on(event, handler);
+    getSession(sessionId) {
+      return client.getSession(sessionId);
     },
-    onSession(sessionId, event, handler) {
+    observePeerConnection(sessionId, onPeerConnection) {
       const session = client.getSession(sessionId);
-      if (!session)
+      if (!session) {
+        onPeerConnection(null);
         return () => {
         };
-      session.on(event, handler);
-      return () => session.off(event, handler);
+      }
+      const initialPc = session.connection ?? null;
+      onPeerConnection(initialPc);
+      return eventManager.onSession(sessionId, "peerconnection", (payload) => {
+        const pc = payload?.peerconnection ?? null;
+        onPeerConnection(pc);
+      });
+    },
+    buildRemoteStream(peerConnection) {
+      if (!peerConnection || typeof peerConnection.getReceivers !== "function") {
+        return null;
+      }
+      const tracks = peerConnection.getReceivers().map((receiver) => receiver.track).filter((track) => Boolean(track));
+      if (tracks.length === 0)
+        return null;
+      return new MediaStream(tracks);
     }
   };
 }
+
+// src/core/kernel/createSipKernel.ts
+function createSipKernel() {
+  const client = createSipClientInstance();
+  const eventManager = createSipEventManager(client);
+  const media = createMediaModule({ client, eventManager });
+  return {
+    client,
+    store: {
+      getState: () => client.state,
+      subscribe: (onStoreChange) => client.onChange(onStoreChange)
+    },
+    commands: {
+      connect: (uri, password, config) => client.connect(uri, password, config),
+      disconnect: () => client.disconnect(),
+      register: () => client.registerUA(),
+      setDebug: (debug) => client.setDebug(debug),
+      call: (target, options) => client.call(target, options),
+      answer: (sessionId, options) => client.answerSession(sessionId, options),
+      hangup: (sessionId, options) => client.hangupSession(sessionId, options),
+      hangupAll: (options) => client.hangupAll(options),
+      toggleMute: (sessionId) => client.toggleMuteSession(sessionId),
+      toggleHold: (sessionId) => client.toggleHoldSession(sessionId),
+      sendDTMF: (sessionId, tones, options) => client.sendDTMFSession(sessionId, tones, options),
+      transfer: (sessionId, target, options) => client.transferSession(sessionId, target, options),
+      getSession: (sessionId) => client.getSession(sessionId),
+      getSessionIds: () => client.getSessionIds(),
+      getSessions: () => client.getSessions(),
+      setSessionMedia: (sessionId, stream) => client.setSessionMedia(sessionId, stream)
+    },
+    events: {
+      onUA: (event, handler) => eventManager.onUA(event, handler),
+      onSession: (sessionId, event, handler) => eventManager.onSession(sessionId, event, handler)
+    },
+    eventManager,
+    media
+  };
+}
 var SipContext = react.createContext(null);
-function useSip() {
+
+// src/hooks/useSip.ts
+function useSipKernel() {
   const ctx = react.useContext(SipContext);
   if (!ctx)
     throw new Error("Must be used within SipProvider");
@@ -2030,177 +2093,190 @@ function useSip() {
 
 // src/hooks/useSipState.ts
 function useSipState() {
-  const { client } = useSip();
-  const subscribe = react.useCallback(
-    (onStoreChange) => client.onChange(onStoreChange),
-    [client]
-  );
-  const getSnapshot = react.useCallback(() => client.state, [client]);
-  return react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const { store } = useSipKernel();
+  return react.useSyncExternalStore(store.subscribe, store.getState, store.getState);
 }
 function useSipActions() {
-  const { client } = useSip();
+  const { commands } = useSipKernel();
   return react.useMemo(
     () => ({
-      call: (...args) => client.call(...args),
-      answer: (...args) => client.answerSession(...args),
-      hangup: (...args) => client.hangupSession(...args),
-      toggleMute: (...args) => client.toggleMuteSession(...args),
-      toggleHold: (...args) => client.toggleHoldSession(...args),
-      sendDTMF: (...args) => client.sendDTMFSession(...args),
-      transfer: (...args) => client.transferSession(...args),
-      getSession: (...args) => client.getSession(...args),
-      getSessionIds: () => client.getSessionIds(),
-      getSessions: () => client.getSessions(),
-      setSessionMedia: (...args) => client.setSessionMedia(...args),
-      switchCamera: (...args) => client.switchCameraSession(...args),
-      enableVideo: (...args) => client.enableVideoSession(...args),
-      disableVideo: (...args) => client.disableVideoSession(...args)
+      connect: commands.connect,
+      disconnect: commands.disconnect,
+      register: commands.register,
+      setDebug: commands.setDebug,
+      call: commands.call,
+      answer: commands.answer,
+      hangup: commands.hangup,
+      hangupAll: commands.hangupAll,
+      toggleMute: commands.toggleMute,
+      toggleHold: commands.toggleHold,
+      sendDTMF: commands.sendDTMF,
+      transfer: commands.transfer,
+      getSession: commands.getSession,
+      getSessionIds: commands.getSessionIds,
+      getSessions: commands.getSessions,
+      setSessionMedia: commands.setSessionMedia
     }),
-    [client]
+    [commands]
   );
 }
+function useSipSelector(selector, equalityFn = Object.is) {
+  const { store } = useSipKernel();
+  const selectorRef = react.useRef(selector);
+  const equalityFnRef = react.useRef(equalityFn);
+  const selectedRef = react.useRef(void 0);
+  const hasSelectedRef = react.useRef(false);
+  selectorRef.current = selector;
+  equalityFnRef.current = equalityFn;
+  const getSelection = () => {
+    const nextSelected = selectorRef.current(store.getState());
+    if (hasSelectedRef.current && equalityFnRef.current(selectedRef.current, nextSelected)) {
+      return selectedRef.current;
+    }
+    hasSelectedRef.current = true;
+    selectedRef.current = nextSelected;
+    return nextSelected;
+  };
+  return react.useSyncExternalStore(store.subscribe, getSelection, getSelection);
+}
+
+// src/hooks/useActiveSipSession.ts
+function useActiveSipSession() {
+  return useSipSelector((state) => {
+    const activeId = state.sessionIds.find(
+      (id) => state.sessionsById[id]?.status === CallStatus.Active
+    );
+    return activeId ? state.sessionsById[activeId] : null;
+  });
+}
 
-// src/hooks/useSipSessions.ts
+// src/hooks/useSipSession.ts
+function useSipSession(sessionId) {
+  return useSipSelector((state) => {
+    if (!sessionId)
+      return null;
+    return state.sessionsById[sessionId] ?? null;
+  });
+}
 function useSipSessions() {
-  const { sessions } = useSipState();
-  return { sessions };
+  const sessions = useSipSelector((state) => state.sessions);
+  return react.useMemo(() => ({ sessions }), [sessions]);
 }
 function useSipEvent(event, handler) {
-  const { sipEventManager } = useSip();
+  const { events } = useSipKernel();
   react.useEffect(() => {
     if (!handler)
       return;
-    return sipEventManager.onUA(event, handler);
-  }, [event, handler, sipEventManager]);
+    return events.onUA(event, handler);
+  }, [event, handler, events]);
 }
 function useSipSessionEvent(sessionId, event, handler) {
-  const { sipEventManager } = useSip();
+  const { events } = useSipKernel();
   react.useEffect(() => {
     if (!handler)
       return;
-    return sipEventManager.onSession(sessionId, event, handler);
-  }, [event, handler, sessionId, sipEventManager]);
+    return events.onSession(sessionId, event, handler);
+  }, [event, handler, sessionId, events]);
 }
-
-// src/jssip-lib/adapters/dom/createCallPlayer.ts
-function createCallPlayer(audioEl) {
-  let cleanupTrackListener = null;
-  let cleanupSessionPeerListener = null;
-  let cleanupClientListeners = null;
-  const dispose = (fn) => {
-    if (fn)
-      fn();
-    return null;
-  };
-  function clearAudioStream(stream) {
-    if (stream) {
-      for (const t of stream.getTracks()) {
-        t.stop();
-      }
+function useSessionMedia(sessionId) {
+  const { media } = useSipKernel();
+  const { sessionIds, sessionsById } = useSipSelector(
+    (state) => ({
+      sessionIds: state.sessionIds,
+      sessionsById: state.sessionsById
+    }),
+    (prev, next) => prev.sessionIds === next.sessionIds && prev.sessionsById === next.sessionsById
+  );
+  const [peerConnection, setPeerConnection] = react.useState(
+    null
+  );
+  const [remoteStream, setRemoteStream] = react.useState(null);
+  const resolvedSessionId = react.useMemo(() => {
+    if (sessionId)
+      return sessionId;
+    const activeId = sessionIds.find(
+      (id) => sessionsById[id]?.status === CallStatus.Active
+    );
+    return activeId ?? sessionIds[0];
+  }, [sessionId, sessionIds, sessionsById]);
+  const session = react.useMemo(
+    () => resolvedSessionId ? media.getSession(resolvedSessionId) : null,
+    [media, resolvedSessionId]
+  );
+  const sessionState = react.useMemo(() => {
+    if (!resolvedSessionId)
+      return null;
+    return sessionsById[resolvedSessionId] ?? null;
+  }, [sessionsById, resolvedSessionId]);
+  react.useEffect(() => {
+    if (!resolvedSessionId) {
+      setPeerConnection(null);
+      setRemoteStream(null);
+      return;
     }
-    audioEl.srcObject = null;
-  }
-  const attachTracks = (pc) => {
-    const onTrack = (e) => {
-      if (e.track.kind !== "audio")
-        return;
-      const nextStream = e.streams?.[0] ?? new MediaStream([e.track]);
-      const prev = audioEl.srcObject;
-      if (prev && prev !== nextStream) {
-        clearAudioStream(prev);
-      }
-      audioEl.srcObject = nextStream;
-      audioEl.play?.().catch(() => {
-      });
-    };
-    pc.addEventListener("track", onTrack);
-    return () => pc.removeEventListener("track", onTrack);
-  };
-  const listenSessionPeerconnection = (session) => {
-    const onPeer = (data) => {
-      cleanupTrackListener = dispose(cleanupTrackListener);
-      cleanupTrackListener = attachTracks(data.peerconnection);
-    };
-    session.on("peerconnection", onPeer);
-    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);
+    const off = media.observePeerConnection(resolvedSessionId, (pc) => {
+      setPeerConnection(pc);
+      setRemoteStream(media.buildRemoteStream(pc));
+    });
+    return off;
+  }, [media, resolvedSessionId]);
+  react.useEffect(() => {
+    if (!peerConnection) {
+      setRemoteStream(null);
+      return;
     }
-    cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
-    cleanupSessionPeerListener = listenSessionPeerconnection(session);
+    const update = () => {
+      setRemoteStream(media.buildRemoteStream(peerConnection));
+    };
+    peerConnection.addEventListener("track", update);
+    peerConnection.addEventListener("connectionstatechange", update);
+    peerConnection.addEventListener("iceconnectionstatechange", update);
+    update();
     return () => {
-      cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
-      cleanupTrackListener = dispose(cleanupTrackListener);
+      peerConnection.removeEventListener("track", update);
+      peerConnection.removeEventListener("connectionstatechange", update);
+      peerConnection.removeEventListener("iceconnectionstatechange", update);
     };
-  }
-  function bindToClient(client) {
-    const offNew = client.on("newRTCSession", (payload) => {
-      const e = payload?.data;
-      cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
-      cleanupTrackListener = dispose(cleanupTrackListener);
-      clearAudioStream(audioEl.srcObject);
-      if (!e?.session)
-        return;
-      cleanupSessionPeerListener = listenSessionPeerconnection(e.session);
-      if (e.session.direction === "outgoing" && e.session.connection instanceof RTCPeerConnection) {
-        cleanupTrackListener = attachTracks(e.session.connection);
-      }
-    });
-    const offEnded = client.on("ended", () => detach());
-    const offFailed = client.on("failed", () => detach());
-    const offDisconnected = client.on("disconnected", () => detach());
-    cleanupClientListeners = () => {
-      offNew();
-      offEnded();
-      offFailed();
-      offDisconnected();
+  }, [media, peerConnection]);
+  const tracks = remoteStream?.getTracks() ?? [];
+  const audioTracks = tracks.filter((track) => track.kind === "audio");
+  if (!sessionState) {
+    return {
+      sessionId: resolvedSessionId ?? "",
+      session,
+      peerConnection,
+      remoteStream,
+      audioTracks
     };
-    return cleanupClientListeners;
-  }
-  function detach() {
-    cleanupClientListeners = dispose(cleanupClientListeners);
-    cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
-    cleanupTrackListener = dispose(cleanupTrackListener);
-    clearAudioStream(audioEl.srcObject);
   }
   return {
-    bindToSession,
-    bindToClient,
-    detach
+    sessionId: sessionState.id,
+    session,
+    peerConnection,
+    remoteStream,
+    audioTracks
   };
 }
 function CallPlayer({ sessionId }) {
-  const { client } = useSip();
+  const { remoteStream } = useSessionMedia(sessionId);
   const audioRef = react.useRef(null);
   react.useEffect(() => {
     if (!audioRef.current)
       return;
-    const player = createCallPlayer(audioRef.current);
-    const session = sessionId ? client.getSession(sessionId) : null;
-    const off = session ? player.bindToSession(session) : player.bindToClient(client);
+    audioRef.current.srcObject = remoteStream;
+    audioRef.current.play?.().catch(() => {
+    });
     return () => {
-      off?.();
-      player.detach();
+      if (audioRef.current) {
+        audioRef.current.srcObject = null;
+      }
     };
-  }, [client, sessionId]);
+  }, [remoteStream]);
   return /* @__PURE__ */ jsxRuntime.jsx("audio", { ref: audioRef, autoPlay: true, playsInline: true });
 }
-function SipProvider({
-  client,
-  children,
-  sipEventManager
-}) {
-  const manager = react.useMemo(
-    () => sipEventManager ?? createSipEventManager(client),
-    [client, sipEventManager]
-  );
-  const contextValue = react.useMemo(() => ({ client, sipEventManager: manager }), [client, manager]);
-  return /* @__PURE__ */ jsxRuntime.jsx(SipContext.Provider, { value: contextValue, children });
+function SipProvider(props) {
+  const contextValue = react.useMemo(() => props.kernel, [props.kernel]);
+  return /* @__PURE__ */ jsxRuntime.jsx(SipContext.Provider, { value: contextValue, children: props.children });
 }
 
 Object.defineProperty(exports, "WebSocketInterface", {
@@ -2209,14 +2285,18 @@ Object.defineProperty(exports, "WebSocketInterface", {
 });
 exports.CallPlayer = CallPlayer;
 exports.CallStatus = CallStatus;
-exports.SipContext = SipContext;
 exports.SipProvider = SipProvider;
 exports.SipStatus = SipStatus;
 exports.createSipClientInstance = createSipClientInstance;
 exports.createSipEventManager = createSipEventManager;
-exports.useSip = useSip;
+exports.createSipKernel = createSipKernel;
+exports.useActiveSipSession = useActiveSipSession;
+exports.useSessionMedia = useSessionMedia;
 exports.useSipActions = useSipActions;
 exports.useSipEvent = useSipEvent;
+exports.useSipKernel = useSipKernel;
+exports.useSipSelector = useSipSelector;
+exports.useSipSession = useSipSession;
 exports.useSipSessionEvent = useSipSessionEvent;
 exports.useSipSessions = useSipSessions;
 exports.useSipState = useSipState;