react-jssip-kit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1377 @@
+'use strict';
+
+var JsSIP = require('jssip');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var JsSIP__default = /*#__PURE__*/_interopDefault(JsSIP);
+
+// src/jssip-lib/sip/userAgent.ts
+var SipUserAgent = class {
+  constructor() {
+    this._ua = null;
+  }
+  get ua() {
+    return this._ua;
+  }
+  get isStarted() {
+    return !!this._ua;
+  }
+  get isRegistered() {
+    return !!this._ua?.isRegistered();
+  }
+  start(uri, password, config, opts) {
+    this.stop();
+    const uaCfg = this.buildUAConfig(config, uri, password);
+    this.ensureValid(uaCfg);
+    this.applyDebug(opts?.debug);
+    const ua = this.createUA(uaCfg);
+    ua.start();
+    this._ua = ua;
+    return ua;
+  }
+  register() {
+    const ua = this.getUA();
+    if (!ua?.isRegistered())
+      ua?.register();
+  }
+  stop() {
+    const ua = this._ua;
+    if (!ua)
+      return;
+    try {
+      if (ua.isRegistered())
+        ua.unregister();
+      ua.stop();
+    } finally {
+      this._ua = null;
+    }
+  }
+  getUA() {
+    return this._ua;
+  }
+  setDebug(debug) {
+    this.applyDebug(debug);
+  }
+  buildUAConfig(config, uri, password) {
+    return { ...config, uri, password };
+  }
+  ensureValid(cfg) {
+    const sockets = cfg.sockets;
+    if (!cfg.uri || !cfg.password || !sockets || Array.isArray(sockets) && sockets.length === 0) {
+      throw new Error(
+        "Invalid SIP connect args: require uri, password, and at least one socket"
+      );
+    }
+  }
+  applyDebug(debug) {
+    const enabled = debug === void 0 ? this.readSessionFlag() : !!debug;
+    const pattern = typeof debug === "string" ? debug : "JsSIP:*";
+    if (enabled) {
+      JsSIP__default.default.debug.enable(pattern);
+      const dbg = JsSIP__default.default.debug;
+      if (dbg?.setLogger)
+        dbg.setLogger(console);
+      else if (dbg)
+        dbg.logger = console;
+      this.persistSessionFlag();
+    } else {
+      JsSIP__default.default.debug?.disable?.();
+      this.clearSessionFlag();
+    }
+  }
+  createUA(cfg) {
+    return new JsSIP__default.default.UA(cfg);
+  }
+  readSessionFlag() {
+    try {
+      if (typeof window === "undefined")
+        return false;
+      return window.sessionStorage.getItem("sip-debug-enabled") === "true";
+    } catch {
+      return false;
+    }
+  }
+  persistSessionFlag() {
+    try {
+      if (typeof window !== "undefined") {
+        window.sessionStorage.setItem("sip-debug-enabled", "true");
+      }
+    } catch {
+    }
+  }
+  clearSessionFlag() {
+    try {
+      if (typeof window !== "undefined") {
+        window.sessionStorage.removeItem("sip-debug-enabled");
+      }
+    } catch {
+    }
+  }
+};
+
+// 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"
+};
+var CallDirection = {
+  Incoming: "incoming",
+  Outgoing: "outgoing",
+  None: "none"
+};
+Object.values(SipStatus);
+Object.values(CallStatus);
+Object.values(CallDirection);
+
+// src/jssip-lib/core/eventEmitter.ts
+var EventTargetEmitter = class {
+  constructor() {
+    this.target = new EventTarget();
+  }
+  on(event, fn) {
+    const wrapper = (e) => fn(e.detail);
+    this.target.addEventListener(event, wrapper);
+    return () => this.target.removeEventListener(event, wrapper);
+  }
+  emit(event, payload) {
+    this.target.dispatchEvent(
+      new CustomEvent(event, { detail: payload })
+    );
+  }
+};
+
+// 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
+function getInitialSipState() {
+  return {
+    sipStatus: SipStatus.Disconnected,
+    error: null,
+    sessions: []
+  };
+}
+function shallowEqual(objA, objB) {
+  if (objA === objB)
+    return true;
+  if (!objA || !objB)
+    return false;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (objA[key] !== objB[key])
+      return false;
+  }
+  return true;
+}
+
+// src/jssip-lib/core/sipStateStore.ts
+var SipStateStore = class {
+  constructor() {
+    this.state = getInitialSipState();
+    this.lastState = getInitialSipState();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.pendingState = null;
+    this.updateScheduled = false;
+  }
+  getState() {
+    return this.state;
+  }
+  onChange(fn) {
+    this.listeners.add(fn);
+    fn(this.state);
+    return () => this.listeners.delete(fn);
+  }
+  subscribe(fn) {
+    return this.onChange(fn);
+  }
+  setState(partial) {
+    if (!partial || Object.keys(partial).length === 0)
+      return;
+    const next = { ...this.state, ...partial };
+    if (next.sessions === this.lastState.sessions && shallowEqual(this.lastState, next)) {
+      return;
+    }
+    this.state = next;
+    this.lastState = next;
+    this.emit();
+  }
+  batchSet(partial) {
+    this.pendingState = { ...this.pendingState, ...partial };
+    if (!this.updateScheduled) {
+      this.updateScheduled = true;
+      queueMicrotask(() => {
+        if (this.pendingState)
+          this.setState(this.pendingState);
+        this.pendingState = null;
+        this.updateScheduled = false;
+      });
+    }
+  }
+  reset(overrides = {}) {
+    this.setState({ ...getInitialSipState(), ...overrides });
+  }
+  emit() {
+    for (const fn of this.listeners)
+      fn(this.state);
+  }
+};
+
+// 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/handlers/sessionHandlers.ts
+function createSessionHandlers(deps) {
+  const {
+    emitter,
+    state,
+    rtc,
+    detachSessionHandlers,
+    onSessionFailed,
+    sessionId
+  } = deps;
+  return {
+    progress: (e) => {
+      emitter.emit("progress", { sessionId, data: e });
+      state.batchSet({
+        sessions: state.getState().sessions.map(
+          (s) => s.id === sessionId ? { ...s, status: CallStatus.Ringing } : s
+        )
+      });
+    },
+    accepted: (e) => {
+      emitter.emit("accepted", { sessionId, data: 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", { sessionId, data: e }),
+    ended: (e) => {
+      emitter.emit("ended", { sessionId, data: e });
+      detachSessionHandlers();
+      rtc.cleanup();
+      const nextSessions = state.getState().sessions.filter((s) => s.id !== sessionId);
+      state.batchSet({
+        sessions: nextSessions
+      });
+    },
+    failed: (e) => {
+      emitter.emit("failed", { sessionId, data: 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", { sessionId, data: void 0 });
+      state.batchSet({
+        sessions: state.getState().sessions.map(
+          (s) => s.id === sessionId ? { ...s, muted: true } : s
+        )
+      });
+    },
+    unmuted: () => {
+      emitter.emit("unmuted", { sessionId, data: void 0 });
+      state.batchSet({
+        sessions: state.getState().sessions.map(
+          (s) => s.id === sessionId ? { ...s, muted: false } : s
+        )
+      });
+    },
+    hold: () => {
+      emitter.emit("hold", { sessionId, data: void 0 });
+      state.batchSet({
+        sessions: state.getState().sessions.map(
+          (s) => s.id === sessionId ? { ...s, status: CallStatus.Hold } : s
+        )
+      });
+    },
+    unhold: () => {
+      emitter.emit("unhold", { sessionId, data: void 0 });
+      state.batchSet({
+        sessions: state.getState().sessions.map(
+          (s) => s.id === sessionId ? { ...s, status: CallStatus.Active } : s
+        )
+      });
+    },
+    reinvite: (e) => emitter.emit("reinvite", { sessionId, data: e }),
+    update: (e) => emitter.emit("update", { sessionId, data: e }),
+    sdp: (e) => emitter.emit("sdp", { sessionId, data: e }),
+    icecandidate: (e) => emitter.emit("icecandidate", { sessionId, data: e }),
+    refer: (e) => emitter.emit("refer", { sessionId, data: e }),
+    replaces: (e) => emitter.emit("replaces", { sessionId, data: e }),
+    newDTMF: (e) => emitter.emit("newDTMF", { sessionId, data: e }),
+    newInfo: (e) => emitter.emit("newInfo", { sessionId, data: e }),
+    getusermediafailed: (e) => {
+      emitter.emit("getusermediafailed", { sessionId, data: 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", { sessionId, data: 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", { sessionId, data: 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", { sessionId, data: 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", { sessionId, data: e });
+      detachSessionHandlers();
+      rtc.cleanup();
+      onSessionFailed("peer connection setRemoteDescription failed", e);
+      state.batchSet({
+        sessions: state.getState().sessions.filter((s) => s.id !== sessionId)
+      });
+    },
+    peerconnection: (e) => emitter.emit("peerconnection", { sessionId, data: e })
+  };
+}
+
+// src/jssip-lib/sip/sessionController.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();
+    if (pc && typeof pc.getSenders === "function") {
+      const isClosed = pc.connectionState === "closed" || pc.signalingState === "closed";
+      if (!isClosed) {
+        for (const s of pc.getSenders()) {
+          try {
+            s.replaceTrack(null);
+          } catch {
+          }
+        }
+      }
+    }
+    if (stopTracks && this.mediaStream) {
+      for (const t of this.mediaStream.getTracks())
+        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;
+  }
+  attendedTransfer(otherSession) {
+    return this.currentSession ? (this.currentSession.refer(otherSession), 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 startScreenShare(getDisplayMedia) {
+    const display = await getDisplayMedia();
+    const screen = display.getVideoTracks()[0];
+    return screen ? this.switchCamera(screen) : false;
+  }
+};
+
+// src/jssip-lib/sip/sessionManager.ts
+var SessionManager = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.pendingMediaQueue = [];
+    this.pendingMediaTtlMs = 3e4;
+  }
+  setPendingMediaTtl(ms) {
+    if (typeof ms === "number" && ms > 0)
+      this.pendingMediaTtlMs = ms;
+  }
+  enqueueOutgoingMedia(stream) {
+    this.pendingMediaQueue.push({ stream, addedAt: Date.now() });
+  }
+  dequeueOutgoingMedia() {
+    const now = Date.now();
+    while (this.pendingMediaQueue.length) {
+      const next = this.pendingMediaQueue.shift();
+      if (!next)
+        break;
+      if (now - next.addedAt <= this.pendingMediaTtlMs) {
+        return next.stream;
+      } else {
+        next.stream.getTracks().forEach((t) => t.stop());
+      }
+    }
+    return null;
+  }
+  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
+    };
+    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.entries.delete(sessionId);
+    }
+  }
+  cleanupAllSessions() {
+    for (const [, entry] of this.entries.entries()) {
+      entry.rtc.cleanup();
+    }
+    this.entries.clear();
+    this.pendingMediaQueue = [];
+  }
+  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;
+  }
+  attendedTransfer(sessionId, otherSession) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.attendedTransfer(otherSession) : false;
+  }
+  startScreenShare(sessionId, getDisplayMedia) {
+    const rtc = this.getRtc(sessionId);
+    return rtc ? rtc.startScreenShare(getDisplayMedia) : false;
+  }
+};
+
+// src/jssip-lib/sip/sessionState.ts
+function holdOtherSessions(state, sessionId, holdFn, updateSession) {
+  const current = state.getState();
+  current.sessions.forEach((s) => {
+    if (s.id === sessionId)
+      return;
+    if (s.status === CallStatus.Active) {
+      holdFn(s.id);
+      updateSession(s.id, { status: CallStatus.Hold });
+    }
+  });
+}
+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: CallDirection.None,
+    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
+  });
+}
+
+// src/jssip-lib/sip/sessionLifecycle.ts
+var SessionLifecycle = 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;
+  }
+  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", { sessionId, data: e });
+      }
+      this.emitError("max session count reached", "MAX_SESSIONS_REACHED", "max session count reached");
+      return;
+    }
+    const outgoingMedia = e.originator === "local" ? this.sessionManager.dequeueOutgoingMedia() : null;
+    if (outgoingMedia)
+      this.sessionManager.setSessionMedia(sessionId, outgoingMedia);
+    const rtc = this.sessionManager.getOrCreateRtc(sessionId, session);
+    if (outgoingMedia)
+      rtc.setMediaStream(outgoingMedia);
+    this.sessionManager.setSession(sessionId, session);
+    this.attachSessionHandlers(sessionId, session);
+    holdOtherSessions(
+      this.state,
+      sessionId,
+      (id) => {
+        const otherRtc = this.sessionManager.getRtc(id);
+        otherRtc?.hold();
+      },
+      (id, partial) => upsertSessionState(this.state, id, partial)
+    );
+    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 === "remote" ? CallDirection.Incoming : CallDirection.Outgoing,
+      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
+    });
+    this.emit("newRTCSession", { sessionId, data: e });
+  }
+};
+
+// src/jssip-lib/sip/client.ts
+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
+    });
+    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)
+    });
+    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
+    });
+  }
+  get state() {
+    return this.stateStore.getState();
+  }
+  connect(uri, password, config) {
+    this.disconnect();
+    this.stateStore.setState({ sipStatus: SipStatus.Connecting });
+    const { debug: cfgDebug, maxSessionCount, pendingMediaTtlMs, ...uaCfg } = config;
+    this.maxSessionCount = typeof maxSessionCount === "number" ? maxSessionCount : Infinity;
+    this.sessionManager.setPendingMediaTtl(pendingMediaTtlMs);
+    const debug = this.debugPattern ?? cfgDebug;
+    this.userAgent.start(uri, password, uaCfg, { debug });
+    this.attachUAHandlers();
+  }
+  registerUA() {
+    this.userAgent.register();
+  }
+  disconnect() {
+    this.detachUAHandlers();
+    this.userAgent.stop();
+    this.cleanupAllSessions();
+    this.stateStore.reset();
+  }
+  call(target, callOptions = {}) {
+    try {
+      if (callOptions.mediaStream)
+        this.sessionManager.enqueueOutgoingMedia(callOptions.mediaStream);
+      const ua = this.userAgent.getUA();
+      ua?.call(target, callOptions);
+    } catch (e) {
+      const err = this.emitError(e, "CALL_FAILED", "call failed");
+      this.cleanupAllSessions();
+      this.stateStore.batchSet({
+        error: err.cause
+      });
+    }
+  }
+  answer(options = {}) {
+    return this.answerSession(void 0, options);
+  }
+  hangup(options) {
+    return this.hangupSession(void 0, options);
+  }
+  mute() {
+    return this.muteSession();
+  }
+  unmute() {
+    return this.unmuteSession();
+  }
+  hold() {
+    return this.holdSession();
+  }
+  unhold() {
+    return this.unholdSession();
+  }
+  sendDTMF(tones, options) {
+    const sessionId = this.resolveSessionId();
+    return this.sendDTMFSession(tones, options, sessionId ?? void 0);
+  }
+  transfer(target, options) {
+    return this.transferSession(target, options);
+  }
+  attendedTransfer(otherSession) {
+    return this.attendedTransferSession(otherSession);
+  }
+  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);
+  }
+  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 existingSession = this.sessionManager.getSession(sessionId);
+    this.emit("sessionCleanup", { sessionId, session: existingSession });
+    const targetSession = session ?? this.sessionManager.getSession(sessionId) ?? this.sessionManager.getRtc(sessionId)?.currentSession;
+    this.detachSessionHandlers(sessionId, targetSession);
+    this.sessionManager.cleanupSession(sessionId);
+    removeSessionState(this.stateStore, sessionId);
+  }
+  cleanupAllSessions() {
+    const ids = this.sessionManager.getSessionIds();
+    ids.forEach((id) => {
+      const s = this.sessionManager.getSession(id);
+      this.emit("sessionCleanup", { sessionId: id, session: s });
+    });
+    this.sessionManager.cleanupAllSessions();
+    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),
+      onSessionFailed: (err, event) => this.onSessionFailed(err, event),
+      sessionId
+    });
+  }
+  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;
+  }
+  answerSession(sessionIdOrOptions, options) {
+    const sessionId = typeof sessionIdOrOptions === "string" ? sessionIdOrOptions : this.resolveSessionId();
+    const opts = typeof sessionIdOrOptions === "string" ? options ?? {} : sessionIdOrOptions ?? {};
+    if (!sessionId)
+      return false;
+    holdOtherSessions(
+      this.stateStore,
+      sessionId,
+      (id) => {
+        const rtc = this.sessionManager.getRtc(id);
+        rtc?.hold();
+      },
+      (id, partial) => upsertSessionState(this.stateStore, id, partial)
+    );
+    return this.sessionManager.answer(sessionId, opts);
+  }
+  hangupSession(sessionIdOrOptions, options) {
+    const sessionId = typeof sessionIdOrOptions === "string" ? sessionIdOrOptions : this.resolveSessionId();
+    const opts = typeof sessionIdOrOptions === "string" ? options : sessionIdOrOptions;
+    if (!sessionId)
+      return false;
+    return this.sessionManager.hangup(sessionId, opts);
+  }
+  muteSession(sessionId) {
+    const resolved = this.resolveSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+    if (sessionState?.muted)
+      return true;
+    this.sessionManager.mute(resolved);
+    upsertSessionState(this.stateStore, resolved, { muted: true });
+    return true;
+  }
+  unmuteSession(sessionId) {
+    const resolved = this.resolveSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+    if (!sessionState?.muted)
+      return true;
+    this.sessionManager.unmute(resolved);
+    upsertSessionState(this.stateStore, resolved, { muted: false });
+    return true;
+  }
+  holdSession(sessionId) {
+    const resolved = this.resolveSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+    if (sessionState?.status === CallStatus.Active) {
+      this.sessionManager.hold(resolved);
+      upsertSessionState(this.stateStore, resolved, { status: CallStatus.Hold });
+    }
+    return true;
+  }
+  unholdSession(sessionId) {
+    const resolved = this.resolveSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+    if (sessionState?.status === CallStatus.Hold) {
+      this.sessionManager.unhold(resolved);
+      upsertSessionState(this.stateStore, resolved, {
+        status: CallStatus.Active
+      });
+    }
+    return true;
+  }
+  sendDTMFSession(tones, options, sessionId) {
+    const resolved = this.resolveSessionId(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;
+  }
+  transferSession(target, options, sessionId) {
+    const resolved = this.resolveSessionId(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;
+  }
+  attendedTransferSession(otherSession, sessionId) {
+    const resolved = this.resolveSessionId(sessionId);
+    if (!resolved)
+      return false;
+    const sessionState = this.stateStore.getState().sessions.find((s) => s.id === resolved);
+    if (sessionState?.status === CallStatus.Active)
+      this.sessionManager.attendedTransfer(resolved, otherSession);
+    return true;
+  }
+  setSessionMedia(sessionId, stream) {
+    this.sessionManager.setSessionMedia(sessionId, stream);
+  }
+  switchCameraSession(sessionId, track) {
+    const rtc = this.sessionManager.getRtc(sessionId);
+    return rtc ? rtc.switchCamera(track) : false;
+  }
+  startScreenShareSession(sessionId, getDisplayMedia) {
+    return this.sessionManager.startScreenShare(sessionId, getDisplayMedia);
+  }
+  enableVideoSession(sessionId) {
+    const rtc = this.sessionManager.getRtc(sessionId);
+    rtc?.enableVideo();
+    return !!rtc;
+  }
+  disableVideoSession(sessionId) {
+    const rtc = this.sessionManager.getRtc(sessionId);
+    rtc?.disableVideo();
+    return !!rtc;
+  }
+  getSession(sessionId) {
+    return this.sessionManager.getSession(sessionId);
+  }
+  getSessionIds() {
+    return this.sessionManager.getSessionIds();
+  }
+  getSessions() {
+    return this.sessionManager.getSessions();
+  }
+};
+function createSipClientInstance(options) {
+  return new SipClient(options);
+}
+function createSipEventManager(client) {
+  return {
+    on(event, handler) {
+      return client.on(event, handler);
+    },
+    onSession(sessionId, event, handler) {
+      return client.on(event, (payload) => {
+        if (payload && "sessionId" in payload && payload.sessionId === sessionId) {
+          handler(payload);
+        }
+      });
+    },
+    bind(handlers) {
+      const offs = [];
+      Object.keys(handlers).forEach((event) => {
+        const handler = handlers[event];
+        if (handler) {
+          offs.push(client.on(event, handler));
+        }
+      });
+      return () => offs.forEach((off) => off());
+    },
+    bindSession(sessionId, handlers) {
+      const offs = [];
+      Object.keys(handlers).forEach((event) => {
+        const handler = handlers[event];
+        if (handler) {
+          offs.push(
+            client.on(event, (payload) => {
+              if (payload && "sessionId" in payload && payload.sessionId === sessionId) {
+                handler(payload);
+              }
+            })
+          );
+        }
+      });
+      return () => offs.forEach((off) => off());
+    }
+  };
+}
+var SipContext = react.createContext(null);
+function useSip() {
+  const ctx = react.useContext(SipContext);
+  if (!ctx)
+    throw new Error("Must be used within SipProvider");
+  return ctx;
+}
+
+// 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);
+}
+function useSipActions() {
+  const { client } = useSip();
+  return react.useMemo(
+    () => ({
+      call: (...args) => client.call(...args),
+      answer: (...args) => client.answerSession(...args),
+      hangup: (...args) => client.hangupSession(...args),
+      mute: (...args) => client.muteSession(...args),
+      unmute: (...args) => client.unmuteSession(...args),
+      hold: (...args) => client.holdSession(...args),
+      unhold: (...args) => client.unholdSession(...args),
+      sendDTMF: (...args) => client.sendDTMFSession(...args),
+      transfer: (...args) => client.transferSession(...args),
+      attendedTransfer: (...args) => client.attendedTransferSession(...args),
+      getSession: (...args) => client.getSession(...args),
+      getSessionIds: () => client.getSessionIds(),
+      getSessions: () => client.getSessions(),
+      setSessionMedia: (...args) => client.setSessionMedia(...args),
+      switchCamera: (...args) => client.switchCameraSession(...args),
+      startScreenShare: (...args) => client.startScreenShareSession(...args),
+      enableVideo: (...args) => client.enableVideoSession(...args),
+      disableVideo: (...args) => client.disableVideoSession(...args)
+    }),
+    [client]
+  );
+}
+
+// src/hooks/useSipSessions.ts
+function useSipSessions() {
+  const { sessions } = useSipState();
+  return { sessions };
+}
+function useSipEvent(event, handler) {
+  const { sipEventManager } = useSip();
+  react.useEffect(() => {
+    if (!handler)
+      return;
+    return sipEventManager.on(event, handler);
+  }, [event, handler, sipEventManager]);
+}
+function useSipSessionEvent(sessionId, event, handler) {
+  const { sipEventManager } = useSip();
+  react.useEffect(() => {
+    if (!handler || !sessionId)
+      return;
+    return sipEventManager.onSession(sessionId, event, handler);
+  }, [event, handler, sessionId, sipEventManager]);
+}
+
+// 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();
+      }
+    }
+    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) {
+    if (session?.direction === "outgoing" && session.connection instanceof RTCPeerConnection) {
+      cleanupTrackListener = dispose(cleanupTrackListener);
+      cleanupTrackListener = attachTracks(session.connection);
+    }
+    cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
+    cleanupSessionPeerListener = listenSessionPeerconnection(session);
+    return () => {
+      cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
+      cleanupTrackListener = dispose(cleanupTrackListener);
+    };
+  }
+  function bindToClient(client) {
+    const offNew = client.on("newRTCSession", (payload) => {
+      const e = payload?.data;
+      cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
+      cleanupTrackListener = dispose(cleanupTrackListener);
+      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();
+    };
+    return cleanupClientListeners;
+  }
+  function detach() {
+    cleanupClientListeners = dispose(cleanupClientListeners);
+    cleanupSessionPeerListener = dispose(cleanupSessionPeerListener);
+    cleanupTrackListener = dispose(cleanupTrackListener);
+    clearAudioStream(audioEl.srcObject);
+  }
+  return {
+    bindToSession,
+    bindToClient,
+    detach
+  };
+}
+function CallPlayer({ sessionId }) {
+  const { client } = useSip();
+  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);
+    return () => {
+      off?.();
+      player.detach();
+    };
+  }, [client, sessionId]);
+  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 });
+}
+
+Object.defineProperty(exports, "WebSocketInterface", {
+  enumerable: true,
+  get: function () { return JsSIP.WebSocketInterface; }
+});
+exports.CallDirection = CallDirection;
+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.useSipActions = useSipActions;
+exports.useSipEvent = useSipEvent;
+exports.useSipSessionEvent = useSipSessionEvent;
+exports.useSipSessions = useSipSessions;
+exports.useSipState = useSipState;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map