@coventia/softphone 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2133 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/sources.ts
+function toDigits(number) {
+  return String(number ?? "").replace(/\D/g, "");
+}
+function normalizeResolvedName(raw, number) {
+  if (!raw) return null;
+  const trimmed = String(raw).trim();
+  if (!trimmed) return null;
+  const digits = toDigits(number);
+  if (!digits) return trimmed;
+  return toDigits(trimmed) === digits ? null : trimmed;
+}
+function withNameResolution(source, resolve) {
+  const cache = /* @__PURE__ */ new Map();
+  return async (params) => {
+    const entries2 = await source(params);
+    const wanted = [
+      ...new Set(entries2.filter((e) => e.name === null).map((e) => toDigits(e.number)))
+    ].filter((d) => d !== "" && !cache.has(d));
+    await Promise.all(
+      wanted.map(async (digits) => {
+        try {
+          const contact = await resolve(digits);
+          cache.set(digits, normalizeResolvedName(contact?.name ?? null, digits));
+        } catch {
+        }
+      })
+    );
+    return entries2.map((e) => {
+      if (e.name !== null) return e;
+      const resolved = cache.get(toDigits(e.number)) ?? null;
+      return resolved === null ? e : { ...e, name: resolved };
+    });
+  };
+}
+var init_sources = __esm({
+  "src/sources.ts"() {
+  }
+});
+
+// src/core/token-cache.ts
+function cachedTokenSource(inner) {
+  const existing = wrappers.get(inner);
+  if (existing) return existing;
+  const entry = { token: null, inflight: null };
+  const wrapper = {
+    async getToken(signal) {
+      if (isFresh(entry.token)) return entry.token;
+      if (entry.inflight !== null) return entry.inflight;
+      entry.inflight = (async () => {
+        try {
+          const token = await inner.getToken(signal);
+          entry.token = token;
+          return token;
+        } finally {
+          entry.inflight = null;
+        }
+      })();
+      return entry.inflight;
+    }
+  };
+  entries.set(inner, entry);
+  entries.set(wrapper, entry);
+  wrappers.set(inner, wrapper);
+  return wrapper;
+}
+function invalidateToken(source) {
+  const entry = entries.get(source);
+  if (!entry) return;
+  entry.token = null;
+}
+var SKEW_MS, entries, wrappers, isFresh;
+var init_token_cache = __esm({
+  "src/core/token-cache.ts"() {
+    SKEW_MS = 6e4;
+    entries = /* @__PURE__ */ new WeakMap();
+    wrappers = /* @__PURE__ */ new WeakMap();
+    isFresh = (token) => token !== null && token.expiresAt.getTime() - Date.now() > SKEW_MS;
+  }
+});
+
+// src/coventia/api.ts
+function createGet(config) {
+  const doFetch = config.fetch ? config.fetch : (...args) => globalThis.fetch(...args);
+  const base = config.baseUrl.replace(/\/+$/, "");
+  async function attempt(path, params, signal) {
+    const { token } = await config.tokenSource.getToken(signal);
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== "") qs.set(k, String(v));
+    }
+    const query = qs.toString();
+    const res = await doFetch(`${base}${path}${query ? `?${query}` : ""}`, {
+      // The RAW token, no `Bearer ` prefix — see `VoiceToken.token` (SPEC §6.1).
+      headers: { Authorization: token },
+      ...signal ? { signal } : {}
+    });
+    const body = await res.json().catch(() => null);
+    const message = body?.message ?? `${path} \u2014 HTTP ${res.status}`;
+    if (!res.ok) throw new ApiError(res.status, message);
+    if (body?.success === false) {
+      throw new ApiError(res.status, message);
+    }
+    return body;
+  }
+  return async function get(path, params = {}, signal) {
+    try {
+      return await attempt(path, params, signal);
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) throw error;
+      invalidateToken(config.tokenSource);
+      return attempt(path, params, signal);
+    }
+  };
+}
+var ApiError;
+var init_api = __esm({
+  "src/coventia/api.ts"() {
+    init_token_cache();
+    ApiError = class extends Error {
+      status;
+      constructor(status, message) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+      }
+    };
+  }
+});
+
+// src/coventia/sources.ts
+var sources_exports = {};
+__export(sources_exports, {
+  coventiaSources: () => coventiaSources,
+  resolverFromContacts: () => resolverFromContacts
+});
+function toHandledBy(row, chain = row.handled_by_chain ?? []) {
+  if (chain.length > 0) {
+    return chain.filter((h) => Boolean(h?.ext)).map((h) => ({ extension: h.ext, userId: h.user_id ?? null, name: h.name ?? null }));
+  }
+  const bare = row.extensions?.length ? row.extensions : [row.internal, row.last_internal];
+  return [...new Set(bare.filter((e) => Boolean(e)))].map((extension) => ({
+    extension,
+    userId: null,
+    name: null
+  }));
+}
+function resolverFromContacts(contacts) {
+  return async (number) => {
+    const digits = toDigits(number);
+    if (!digits) return null;
+    const page = await contacts({ search: number, skip: 0, limit: 10 });
+    return page.items.find((c) => toDigits(c.phone) === digits) ?? null;
+  };
+}
+function coventiaSources(config) {
+  const get = createGet(config);
+  const base = config.basePath ?? "/phone";
+  const org = config.organizationId ? { organization_id: config.organizationId } : {};
+  const coventiaContacts = async ({ search, skip, limit }) => {
+    const body = await get(
+      `${base}/webrtc/contacts`,
+      { ...org, search, skip, limit }
+    );
+    return { items: (body.contacts ?? []).map(toContact), total: body.total ?? 0 };
+  };
+  const coventiaResolve = async (number) => {
+    const digits = toDigits(number);
+    if (!digits) return null;
+    const body = await get(`${base}/webrtc/caller-name`, {
+      ...org,
+      number: digits
+    });
+    const name = normalizeResolvedName(body.name ?? null, digits);
+    return name === null ? null : { id: digits, name, phone: `+${digits}` };
+  };
+  const rawHistory = async ({
+    skip,
+    limit,
+    missed,
+    userId
+  }) => {
+    const body = await get(`${base}/calls`, {
+      ...org,
+      skip,
+      limit,
+      // Omitted rather than `'false'` — the backend only special-cases `missed=true`, so leaving it
+      // out entirely for "Todas" is equivalent and one less thing for a param dump to explain.
+      missed: missed ? "true" : void 0,
+      user_id: userId
+    });
+    return (body.calls ?? []).map((row) => {
+      const id = row._id ?? "";
+      const recorded = (row.recording_count ?? 0) > 0;
+      const missedRow = isMissed(row);
+      const handledBy = toHandledBy(row);
+      return {
+        id,
+        direction: toDirection(row.direction),
+        number: otherParty(row),
+        // Filled by `withNameResolution` at the mount — deduped by digits and cached across pages.
+        name: null,
+        at: toDate(row.created_at),
+        durationSec: row.duration ?? 0,
+        missed: missedRow,
+        ...missedRow ? { outcome: toOutcome(row) } : {},
+        // The DID is only ever the ORG's own number, which only an inbound call dials — an outbound
+        // row's `called_did` is the OTHER party (already `number` above); showing it again as "DID"
+        // would just repeat the row under a wrong label.
+        ...toDirection(row.direction) === "inbound" && row.called_did ? { did: row.called_did } : {},
+        recorded,
+        handledBy,
+        // The detail page's one enrichment fetch — signed recording URLs, plus this SAME chain with
+        // names resolved. Skipped when there is nothing to enrich: minting signed URLs and resolving
+        // names for a page of 30 calls nobody opens is pure waste.
+        ...recorded || handledBy.length > 0 ? {
+          loadDetail: async () => {
+            const detail = await get(`${base}/calls/${encodeURIComponent(id)}`, org);
+            return {
+              recordingUrls: detail.call?.recording_urls ?? [],
+              // `row`'s own bare-extension fields (read inside `toHandledBy` when the chain
+              // passed here is empty) still work as the fallback — only the CHAIN comes from the
+              // enriched response; the rest of `row` is unchanged.
+              handledBy: toHandledBy(row, detail.call?.handled_by_chain ?? [])
+            };
+          }
+        } : {}
+      };
+    });
+  };
+  const coventiaListAgents = async () => {
+    const body = await get(
+      `${base}/agents`,
+      org
+    );
+    const toAgent = (row) => ({ userId: row.user_id, name: row.name });
+    return {
+      me: body.me ? toAgent(body.me) : null,
+      people: (body.people ?? []).map(toAgent)
+    };
+  };
+  const contacts = config.contacts ?? coventiaContacts;
+  const resolve = config.resolveContact ?? (config.contacts ? resolverFromContacts(config.contacts) : coventiaResolve);
+  const history = withNameResolution(rawHistory, resolve);
+  return { contacts, history, resolveContact: resolve, listAgents: coventiaListAgents };
+}
+var toContact, toDirection, otherParty, isMissed, toOutcome, toDate;
+var init_sources2 = __esm({
+  "src/coventia/sources.ts"() {
+    init_sources();
+    init_api();
+    toContact = (row) => ({
+      id: row.wa_id,
+      name: row.name,
+      phone: `+${row.wa_id}`
+    });
+    toDirection = (raw) => raw === "outgoing" ? "outbound" : "inbound";
+    otherParty = (row) => toDirection(row.direction) === "outbound" ? row.called_did ?? row.destination ?? "" : row.caller_id ?? "";
+    isMissed = (row) => {
+      const d = String(row.disposition ?? "").trim().toLowerCase();
+      return d !== "" && d !== "answered";
+    };
+    toOutcome = (row) => {
+      switch (String(row.disposition ?? "").trim().toLowerCase()) {
+        case "no answer":
+          return "no-answer";
+        case "busy":
+          return "busy";
+        case "cancel":
+          return "cancelled";
+        case "failed":
+          return "failed";
+        default:
+          return "unavailable";
+      }
+    };
+    toDate = (raw) => {
+      if (raw === void 0) return /* @__PURE__ */ new Date(0);
+      const d = new Date(raw);
+      return Number.isNaN(d.getTime()) ? /* @__PURE__ */ new Date(0) : d;
+    };
+  }
+});
+
+// src/core/errors.ts
+function isSoftphoneError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.fatal === "boolean" && candidate.code in exports.ERROR_CATALOGUE;
+}
+function isFatal(error) {
+  return error.fatal;
+}
+function createError(code, cause) {
+  return new CatalogueError(code, cause);
+}
+exports.ERROR_CATALOGUE = void 0; var CatalogueError;
+var init_errors = __esm({
+  "src/core/errors.ts"() {
+    exports.ERROR_CATALOGUE = {
+      // ── Engine lifecycle ────────────────────────────────────────────────────────
+      "engine/duplicate-instance": {
+        fatal: true,
+        message: "A Softphone instance is already running on this page.",
+        solution: "Construct one Softphone and share it. React StrictMode double-mounts in development \u2014 hold the instance above the tree, or in a ref, and call destroy() on unmount."
+      },
+      "engine/not-started": {
+        fatal: false,
+        message: "The softphone has not been started.",
+        solution: "Await softphone.start() before placing or answering a call."
+      },
+      "engine/destroyed": {
+        fatal: true,
+        message: "This Softphone has been destroyed and cannot be reused.",
+        solution: "Construct a new Softphone."
+      },
+      // ── Auth ────────────────────────────────────────────────────────────────────
+      "auth/token-fetch-failed": {
+        fatal: true,
+        message: "Could not obtain a voice token from the token endpoint.",
+        solution: "Check that the token endpoint is reachable and that the headers callback returns a valid host-app session token."
+      },
+      "auth/token-rejected": {
+        fatal: true,
+        message: "The voice token was rejected.",
+        solution: "The token is expired, malformed, or scoped to a different organization. Mint a fresh one."
+      },
+      // ── Media ───────────────────────────────────────────────────────────────────
+      /*
+        NONE of the four codes below are ever actually raised via `createError` — nothing in the SDK
+        constructs a `SoftphoneError` with these codes today. Deleting them was the other option
+        (SPEC discussion); they stay, commented, because the taxonomy and Spanish copy (`error-text.ts`)
+        are worth keeping intact for whenever a real caller wants them, and a `SoftphoneErrorCode` union
+        is a cheap thing to keep honest with a comment, expensive to keep churning as a breaking change.
+      */
+      "media/permission-denied": {
+        fatal: true,
+        message: "Microphone permission was denied.",
+        solution: "The permission prompt names the TOP-LEVEL origin. Ask for it from a user gesture, and re-request via the browser UI if previously blocked."
+        // NEVER RAISED. `MicPermissionGate` (ui/permission/) handles this condition today — it predates
+        // this catalogue and has BETTER, browser-specific unblock instructions than a generic gate could
+        // show. It does not import this catalogue at all; the two are unconnected on purpose.
+      },
+      "media/no-input-device": {
+        fatal: true,
+        message: "No microphone is available.",
+        solution: "Ask the user to connect a microphone, then retry."
+        // NEVER RAISED — same reason as `media/permission-denied` above: `MicPermissionGate` already
+        // owns this.
+      },
+      "media/webrtc-unsupported": {
+        fatal: true,
+        message: "This browser does not expose the WebRTC APIs.",
+        solution: "Usually a privacy extension (uBlock Origin Extra, WebRTC Leak Prevent) disabling RTCPeerConnection \u2014 Twilio documents the same. Ask the user to disable it for this origin."
+        // NEVER RAISED — same reason again: `MicPermissionGate` already owns this.
+      },
+      "media/playback-blocked": {
+        fatal: false,
+        message: "The browser blocked audio playback (autoplay policy).",
+        solution: "Call softphone.startAudio() from a click handler. Until then the user cannot hear the caller, and an INCOMING RINGTONE WILL BE SILENT \u2014 this is how calls get missed."
+        /*
+          NEVER RAISED — different reason from the other three. This is not superseded by an existing
+          UI; the feature it describes (autoplay-recovery) is simply not built yet. `Softphone.canPlayAudio`
+          / `startAudio()` (core/softphone.ts) are Phase 2 and currently no-op stubs — `canPlayAudio`
+          always reports `true`. This is where that future work would report the block once it exists.
+        */
+      },
+      // ── Network / signalling ────────────────────────────────────────────────────
+      "net/registration-failed": {
+        fatal: true,
+        message: "SIP registration failed.",
+        solution: "Usually a stale credential. The engine refreshes and retries; if it persists, the extension may not exist."
+      },
+      "net/transport-failed": {
+        fatal: true,
+        message: "The signalling transport could not be established.",
+        solution: "Check the CSP connect-src directive and any corporate proxy blocking WSS."
+      },
+      "net/ice-failed": {
+        fatal: false,
+        message: "Media connectivity was lost; attempting an ICE restart.",
+        solution: 'Usually a network handoff (wifi \u2192 cellular). The engine recovers on its own; surface a "reconnecting" banner rather than ending the call.'
+        /*
+          NEVER RAISED. The "reconnecting" banner this `solution` describes already exists — CallScreen
+          shows "Reconectando…" directly off the call's own `reconnecting` STATE (`STATUS_LABEL` in
+          views/CallScreen.tsx), which the SIP engine drives without going through the error channel at
+          all. Raising this too would say the same fact twice through two different mechanisms. It would
+          only earn its keep for host-side OBSERVABILITY — counting ICE restarts independently of the UI
+          — which nobody has asked for yet.
+        */
+      },
+      // ── Call ────────────────────────────────────────────────────────────────────
+      "call/not-answerable": {
+        fatal: false,
+        message: "This call cannot be answered in its current state.",
+        solution: "Only a call in `ringing` may be answered. Check call.state first."
+      },
+      "call/busy": {
+        fatal: false,
+        message: "The remote party is busy.",
+        solution: 'Nothing to fix. Note SIP 486 is also what most endpoints send for a manual decline, so do not label this "busy" alone in your UI \u2014 it is equally often "did not answer".'
+      },
+      "call/no-answer": {
+        fatal: false,
+        message: "The remote party did not answer.",
+        solution: "Nothing to fix. Surface it to the user."
+      },
+      "call/rejected": {
+        fatal: false,
+        message: "The remote party rejected the call.",
+        solution: "Nothing to fix. Surface it to the user."
+      },
+      "call/missed": {
+        fatal: false,
+        message: "An incoming call was cancelled before it was answered.",
+        solution: "Nothing to fix \u2014 the caller gave up while it rang. Surface it, and log it as a missed call."
+      },
+      "call/failed": {
+        fatal: false,
+        message: "The call could not be completed.",
+        solution: "The catch-all for a call that never connected \u2014 a bad number, a rejected offer, a media failure. `cause` carries the underlying SIP cause. Nothing is fatal: the phone still works."
+      },
+      "call/transfer-failed": {
+        fatal: false,
+        message: "The transfer could not be completed.",
+        solution: "The original call is still up. Let the user retry or resume."
+      },
+      "call/unsupported": {
+        fatal: false,
+        message: "The provider does not support this operation.",
+        solution: "Guard the UI on the operation before offering it."
+      },
+      // ── Provider ────────────────────────────────────────────────────────────────
+      "provider/provision-failed": {
+        fatal: true,
+        message: "The provider could not issue SIP credentials.",
+        solution: "The backend reached the carrier but got no usable credential. Check the org has a SIP extension provisioned."
+      }
+    };
+    CatalogueError = class extends Error {
+      fatal;
+      code;
+      solution;
+      constructor(code, cause) {
+        const spec = exports.ERROR_CATALOGUE[code];
+        super(spec.message, cause === void 0 ? void 0 : { cause });
+        this.name = "SoftphoneError";
+        this.code = code;
+        this.fatal = spec.fatal;
+        this.solution = spec.solution;
+      }
+    };
+  }
+});
+
+// src/transports/sip/media.ts
+function buildAudioConstraints(deviceId) {
+  return { audio: deviceId ? { deviceId: { exact: deviceId } } : true, video: false };
+}
+function capIceGathering(session, capMs) {
+  let settled = false;
+  let timer;
+  const settle = (ready) => {
+    if (settled) return;
+    settled = true;
+    if (timer) clearTimeout(timer);
+    try {
+      ready();
+    } catch {
+    }
+  };
+  session.on("icecandidate", ({ ready }) => {
+    if (!timer) timer = setTimeout(() => settle(ready), capMs);
+  });
+  return () => {
+    if (timer) clearTimeout(timer);
+  };
+}
+var init_media = __esm({
+  "src/transports/sip/media.ts"() {
+  }
+});
+
+// src/transports/sip/ice.ts
+var DEFAULT_ICE_SERVERS, PC_CONFIG;
+var init_ice = __esm({
+  "src/transports/sip/ice.ts"() {
+    DEFAULT_ICE_SERVERS = [
+      { urls: "stun:stun.l.google.com:19302" }
+    ];
+    PC_CONFIG = { iceServers: [...DEFAULT_ICE_SERVERS] };
+  }
+});
+
+// src/transports/sip/session.ts
+function mapEndReason(e) {
+  if (e.originator === "local") return "local";
+  if (e.originator === "remote") return "remote";
+  return "failed";
+}
+function mapFailReason(e) {
+  switch (e.cause) {
+    // 486 Busy Here, 600 Busy Everywhere. Also what most endpoints send for a MANUAL DECLINE — SIP
+    // does not distinguish the two, and neither can we, which is why the copy covers both.
+    case "Busy":
+      return "busy";
+    /*
+          `Rejected` is 403 / 603 Decline — an explicit refusal, sent by the endpoints that bother to.
+          `Redirected` is 3xx: not literally a rejection, but it ends the same way — not connected, and
+          nothing to retry.
+    
+          (Both comments sit ABOVE the group rather than between the labels. A comment between two `case`
+          lines makes the first one non-empty to `no-fallthrough`, which then demands a `break` that
+          would be unreachable.)
+        */
+    case "Rejected":
+    case "Redirected":
+      return "rejected";
+    /*
+      `Unavailable` is 480 Temporarily Unavailable / 410 / 408 Request Timeout / 430 — THE ring-out
+      case, and the one that was missing. `No Answer` and `Expires` are local: our own no-answer
+      timer, and a session that expired.
+    */
+    case "Unavailable":
+    case "No Answer":
+    case "Expires":
+      return "no-answer";
+    case "Canceled":
+      return e.originator === "local" ? "local" : "remote";
+    // Everything else is a genuine failure worth naming: Not Found (404/604), Address Incomplete,
+    // Incompatible SDP, Authentication Error, WebRTC Error, RTP Timeout, Connection Error…
+    default:
+      return "failed";
+  }
+}
+function remoteNumberOf(session) {
+  const id = session.remote_identity;
+  return id?.uri?.user ?? id?.uri?.toString() ?? "";
+}
+var SipEngineCall;
+var init_session = __esm({
+  "src/transports/sip/session.ts"() {
+    init_media();
+    init_ice();
+    SipEngineCall = class {
+      id;
+      direction;
+      remoteNumber;
+      #session;
+      #deps;
+      #listeners = /* @__PURE__ */ new Set();
+      #ended = false;
+      #cancelIceCap = null;
+      /**
+       * The stream behind a LIVE device swap (`swapInputDevice`), if one has happened. Distinct from
+       * JsSIP's own original capture: that one is `_localMediaStreamLocallyGenerated` and JsSIP stops it
+       * itself on close (see `#end`'s comment). This one is ours — obtained with our own `getUserMedia`
+       * call, attached via `replaceTrack`, and never known to JsSIP at all — so nothing else will ever
+       * stop it unless we do, here.
+       */
+      #swappedStream = null;
+      constructor(session, deps) {
+        this.#session = session;
+        this.#deps = deps;
+        this.id = deps.id;
+        this.direction = session.direction === "incoming" ? "inbound" : "outbound";
+        this.remoteNumber = remoteNumberOf(session);
+        this.#wire();
+      }
+      /** @internal — the underlying session, for `completeTransfer`'s REFER…Replaces. */
+      get session() {
+        return this.#session;
+      }
+      onEvent(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+      }
+      // ── JsSIP events → raw engine signals ─────────────────────────────────────
+      #wire() {
+        const s = this.#session;
+        if (this.direction === "outbound") {
+          s.on("progress", () => this.#fire({ type: "progress", response: "ringing" }));
+        }
+        const wireRemoteTrack = (pc) => {
+          pc.ontrack = ({ streams }) => {
+            if (streams[0]) this.#fire({ type: "stream", stream: streams[0] });
+          };
+        };
+        s.on("peerconnection", ({ peerconnection }) => wireRemoteTrack(peerconnection));
+        if (s.connection) wireRemoteTrack(s.connection);
+        if (this.direction === "outbound" && this.#deps.iceGatheringCapMs) {
+          this.#cancelIceCap = capIceGathering(s, this.#deps.iceGatheringCapMs);
+        }
+        s.on("accepted", () => this.#onAccepted());
+        s.on("ended", (e) => this.#end(mapEndReason(e), e.cause));
+        s.on("failed", (e) => this.#end(mapFailReason(e), e.cause));
+        s.on("hold", ({ originator }) => this.#fire({ type: "held", originator }));
+        s.on("unhold", ({ originator }) => this.#fire({ type: "unheld", originator }));
+      }
+      /**
+       * The call is live. Nothing to swap: JsSIP opened the real microphone when the session was created,
+       * so the far end has had our actual audio from the first packet.
+       *
+       * There used to be a silent-mic dance here — place the call with a synthetic AudioContext track,
+       * swap the real mic in on accept — so a Bluetooth headset stayed in A2DP while the phone rang. It
+       * cost more than it bought: with no active capture, Firefox restricts ICE gathering and the offer
+       * goes out with no candidates at all, which no STUN or TURN server can fix.
+       */
+      #onAccepted() {
+        this.#fire({ type: "accepted" });
+      }
+      // ── Commands ───────────────────────────────────────────────────────────────
+      async answer() {
+        const deviceId = this.#deps.getInputDeviceId?.() ?? null;
+        this.#session.answer({
+          mediaConstraints: buildAudioConstraints(deviceId),
+          pcConfig: this.#deps.pcConfig ?? PC_CONFIG
+        });
+      }
+      /**
+       * Live-swap the outgoing microphone track — `CallEngine.setInputDevice` on a call that is already
+       * connected. Never touches the FIRST call's capture: that one is JsSIP's own `getUserMedia`, opened
+       * inside `answer()`/`ua.call()` (see `#onAccepted`'s comment on why that stays that way). This is
+       * only for a device chosen AFTER the call is already live.
+       *
+       * `RTCRtpSender.replaceTrack` rather than a fresh `answer()`/re-INVITE: it needs no SDP
+       * renegotiation and the far end never sees an interruption — exactly the mechanism real softphones
+       * use for "switch mic mid-call."
+       */
+      async swapInputDevice(deviceId) {
+        const pc = this.#session.connection;
+        if (!pc || this.#ended) return;
+        const sender = pc.getSenders().find((s) => s.track?.kind === "audio");
+        if (!sender) return;
+        let stream;
+        try {
+          stream = await navigator.mediaDevices.getUserMedia(buildAudioConstraints(deviceId));
+        } catch {
+          return;
+        }
+        if (this.#ended) {
+          for (const track2 of stream.getTracks()) track2.stop();
+          return;
+        }
+        const [track] = stream.getAudioTracks();
+        if (!track) return;
+        await sender.replaceTrack(track);
+        for (const oldTrack of this.#swappedStream?.getTracks() ?? []) oldTrack.stop();
+        this.#swappedStream = stream;
+      }
+      async reject() {
+        this.#deps.onReject?.();
+        this.#session.terminate({ status_code: 486, reason_phrase: "Busy Here" });
+      }
+      async hangup() {
+        this.#session.terminate();
+      }
+      mute(muted) {
+        if (muted) this.#session.mute({ audio: true });
+        else this.#session.unmute({ audio: true });
+      }
+      async hold() {
+        this.#session.hold();
+      }
+      async unhold() {
+        this.#session.unhold();
+      }
+      sendDigits(digits) {
+        this.#session.sendDTMF(digits);
+      }
+      async transfer(target) {
+        this.#session.refer(this.#deps.buildTarget(target));
+      }
+      async startConsult(target) {
+        return this.#deps.placeConsult(target);
+      }
+      async completeTransfer(consult) {
+        const consultSession = consult.session;
+        this.#session.refer(consultSession.remote_identity.uri.toString(), { replaces: consultSession });
+      }
+      // ── internals ──────────────────────────────────────────────────────────────
+      #end(reason, cause) {
+        if (this.#ended) return;
+        this.#ended = true;
+        this.#cancelIceCap?.();
+        for (const track of this.#swappedStream?.getTracks() ?? []) track.stop();
+        this.#swappedStream = null;
+        this.#fire({ type: "ended", reason, cause });
+        this.#listeners.clear();
+      }
+      #fire(event) {
+        if (this.#ended && event.type !== "ended") return;
+        for (const listener of [...this.#listeners]) listener(event);
+      }
+    };
+  }
+});
+
+// src/transports/sip/ua.ts
+function domainOf(credentials) {
+  const at = credentials.uri.lastIndexOf("@");
+  return at === -1 ? "" : credentials.uri.slice(at + 1);
+}
+var DEFAULT_ICE_CAP_MS, REGISTER_EXPIRES, SIGNAL_REFRESH_DEBOUNCE_MS, ERROR_DEBOUNCE_MS, CALL_END_CODES, callSeq, nextCallId, SipCallEngine;
+var init_ua = __esm({
+  "src/transports/sip/ua.ts"() {
+    init_session();
+    init_media();
+    init_ice();
+    init_errors();
+    DEFAULT_ICE_CAP_MS = 3e3;
+    REGISTER_EXPIRES = 580;
+    SIGNAL_REFRESH_DEBOUNCE_MS = 3e4;
+    ERROR_DEBOUNCE_MS = 3e4;
+    CALL_END_CODES = {
+      busy: "call/busy",
+      "no-answer": "call/no-answer",
+      rejected: "call/rejected",
+      failed: "call/failed"
+    };
+    callSeq = 0;
+    nextCallId = () => `sip-${++callSeq}`;
+    SipCallEngine = class {
+      constructor(provider, factory, options = {}) {
+        this.provider = provider;
+        this.factory = factory;
+        this.now = options.now ?? Date.now;
+      }
+      provider;
+      factory;
+      #state = "stopped";
+      #ua = null;
+      /** In-flight `#createUA()`. THE concurrency guard — see `#ensureUA`. */
+      #uaInFlight = null;
+      #domain = "";
+      #activeCall = null;
+      /** The chosen microphone, or `null` for the browser default. Read fresh by every new leg's
+       *  `mediaConstraints`, and pushed live to `#activeCall` by `setInputDevice`. */
+      #inputDeviceId = null;
+      #incomingListeners = /* @__PURE__ */ new Set();
+      #stateListeners = /* @__PURE__ */ new Set();
+      #errorListeners = /* @__PURE__ */ new Set();
+      #signalUnsub = null;
+      #signalConnectionUnsub = null;
+      #noInviteTimer;
+      #rejectGuardUntil = 0;
+      #signalRefreshAfter = 0;
+      #errorSentAfter = /* @__PURE__ */ new Map();
+      now;
+      #resolvedFactory = null;
+      async #resolveFactory() {
+        if (this.#resolvedFactory) return this.#resolvedFactory;
+        this.#resolvedFactory = typeof this.factory === "function" ? await this.factory() : this.factory;
+        return this.#resolvedFactory;
+      }
+      get state() {
+        return this.#state;
+      }
+      onIncoming(listener) {
+        this.#incomingListeners.add(listener);
+        return () => this.#incomingListeners.delete(listener);
+      }
+      onStateChange(listener) {
+        this.#stateListeners.add(listener);
+        return () => this.#stateListeners.delete(listener);
+      }
+      onError(listener) {
+        this.#errorListeners.add(listener);
+        return () => this.#errorListeners.delete(listener);
+      }
+      /**
+       * Switch the microphone: stored for every FUTURE leg's `mediaConstraints`, and — if a call is live
+       * right now — pushed to it immediately via `SipEngineCall.swapInputDevice` (SPEC §7 Phase 2, device
+       * management). `null` resets to the browser's own default device.
+       */
+      async setInputDevice(deviceId) {
+        this.#inputDeviceId = deviceId;
+        await this.#activeCall?.swapInputDevice(deviceId);
+      }
+      /**
+       * Report a failure, at most once per code per `ERROR_DEBOUNCE_MS`.
+       *
+       * A failing registrar retries, and one emission per attempt would flood a host's logging and make
+       * whatever the widget shows flicker. Debounced per CODE rather than globally, so a transport
+       * failure is never swallowed because a registration failure happened to precede it.
+       */
+      #reportError(code, cause) {
+        this.#emitError(createError(code, cause));
+      }
+      /**
+       * Emit, debouncing FATAL codes only.
+       *
+       * A failing registrar retries, and one emission per attempt would flood a host's logging and make
+       * whatever the widget shows flicker — so the same fatal code is reported at most once per window,
+       * per CODE, so a transport failure is never swallowed because a registration failure preceded it.
+       *
+       * Non-fatal codes are never debounced: they describe one call each, and two busy tones in a row are
+       * two facts, not a repeated one.
+       */
+      #emitError(error) {
+        if (error.fatal) {
+          const now = this.now();
+          if (now < (this.#errorSentAfter.get(error.code) ?? 0)) return;
+          this.#errorSentAfter.set(error.code, now + ERROR_DEBOUNCE_MS);
+        }
+        for (const listener of [...this.#errorListeners]) listener(error);
+      }
+      async start() {
+        this.#setState("starting");
+        if (this.provider.registrationMode === "persistent") {
+          await this.#ensureUA();
+          this.#setState("online");
+        } else {
+          const signal = this.provider.incomingSignal;
+          if (signal) {
+            await signal.connect();
+            this.#signalUnsub = signal.onSignal(() => void this.#onIncomingSignal());
+            this.#signalConnectionUnsub = signal.onConnectionChange?.(
+              (connected) => this.#setState(connected ? "online" : "offline")
+            ) ?? null;
+          }
+          this.#setState(signal?.onConnectionChange ? signal.connected ? "online" : "offline" : "online");
+        }
+      }
+      async stop() {
+        this.#clearNoInviteTimer();
+        this.#signalUnsub?.();
+        this.#signalUnsub = null;
+        this.#signalConnectionUnsub?.();
+        this.#signalConnectionUnsub = null;
+        this.provider.incomingSignal?.disconnect();
+        this.#teardownUA();
+        this.#setState("stopped");
+      }
+      async placeCall(destination, _options) {
+        const ua = await this.#ensureUA();
+        const session = await this.#callWhenRegistered(ua, this.#buildTarget(destination));
+        return this.#wrapCall(session);
+      }
+      // ── incoming (on-demand: push → register → INVITE) ────────────────────────
+      async #onIncomingSignal() {
+        if (this.now() < this.#rejectGuardUntil) return;
+        if (this.#activeCall) return;
+        try {
+          await this.#ensureUA();
+          this.#armNoInviteTeardown();
+        } catch {
+          this.#teardownUA();
+        }
+      }
+      #armNoInviteTeardown() {
+        const ms = this.provider.quirks?.noInviteTeardownMs;
+        if (!ms) return;
+        this.#clearNoInviteTimer();
+        this.#noInviteTimer = setTimeout(() => {
+          if (!this.#activeCall) this.#teardownUA();
+        }, ms);
+      }
+      /**
+       * Rebuild the incoming-signal channel with fresh credentials, after a registration failure.
+       *
+       * Registration fails when the credentials behind it have gone stale — and for Zadarma those come
+       * from the same WebRTC key the push socket is holding. Tearing down the UA alone leaves that stale
+       * key in place, so every subsequent attempt fails the same way and the phone is dead until the page
+       * is reloaded. Reconnecting re-fetches the key. The legacy hook did exactly this from both of its
+       * `registrationFailed` handlers.
+       *
+       * Debounced, which the legacy was not: a provider failing every attempt would otherwise become a
+       * tight loop against our backend and theirs.
+       */
+      async #refreshSignal() {
+        const signal = this.provider.incomingSignal;
+        if (!signal) return;
+        if (this.now() < this.#signalRefreshAfter) return;
+        this.#signalRefreshAfter = this.now() + SIGNAL_REFRESH_DEBOUNCE_MS;
+        try {
+          signal.disconnect();
+          await signal.connect();
+        } catch {
+        }
+      }
+      #clearNoInviteTimer() {
+        if (this.#noInviteTimer) clearTimeout(this.#noInviteTimer);
+        this.#noInviteTimer = void 0;
+      }
+      #onNewSession(session, originator) {
+        if (originator !== "remote") return;
+        this.#clearNoInviteTimer();
+        if (this.#activeCall || this.now() < this.#rejectGuardUntil) {
+          session.terminate({ status_code: 486, reason_phrase: "Busy Here" });
+          return;
+        }
+        const call = this.#wrapCall(session);
+        for (const listener of [...this.#incomingListeners]) listener(call);
+      }
+      // ── UA lifecycle ───────────────────────────────────────────────────────────
+      /**
+       * The single UA, created at most once — even under concurrent callers.
+       *
+       * **The `#ua` check alone is not a guard**, because everything after it awaits: two callers both
+       * see `null`, both `provision()`, both build a UA, and both REGISTER the same extension. Zadarma
+       * rejects the loser, `registrationFailed` tears down, and the survivor may be the one that was
+       * torn down. The visible symptom is two `get_webphone_data.php` calls at startup and a phone that
+       * never registers.
+       *
+       * Concurrency is the normal case here, not an edge: the push socket can signal twice in a
+       * heartbeat (SPEC §3.3 — a push is not an INVITE; it fires for transfers, retries and hangups),
+       * and `placeCall` can land on top of one. So the in-flight promise IS the guard.
+       */
+      async #ensureUA() {
+        if (this.#ua) return this.#ua;
+        this.#uaInFlight ??= this.#createUA().finally(() => {
+          this.#uaInFlight = null;
+        });
+        return this.#uaInFlight;
+      }
+      async #createUA() {
+        const factory = await this.#resolveFactory();
+        let credentials;
+        try {
+          credentials = await this.provider.provision();
+        } catch (cause) {
+          if (isSoftphoneError(cause)) this.#emitError(cause);
+          else this.#reportError("provider/provision-failed", cause);
+          throw cause;
+        }
+        this.#domain = domainOf(credentials);
+        const config = this.#uaConfig(credentials, factory);
+        const ua = factory.createUA(config);
+        ua.on("newRTCSession", ({ session, originator }) => this.#onNewSession(session, originator));
+        ua.on("disconnected", ({ error }) => {
+          if (!error) return;
+          this.#setState("reconnecting");
+          this.#reportError("net/transport-failed", error);
+        });
+        ua.on("connected", () => this.#setState("online"));
+        ua.on("registrationFailed", (e) => {
+          const detail = e;
+          this.#reportError("net/registration-failed", {
+            cause: detail?.cause,
+            status: detail?.response?.status_code,
+            domain: this.#domain,
+            hint: "A bare 401 with no auth challenge usually means the registrar is in the wrong datacenter (SPEC \xA73.1)."
+          });
+          this.#teardownUA();
+          void this.#refreshSignal();
+        });
+        this.#ua = ua;
+        ua.start();
+        return ua;
+      }
+      #uaConfig(credentials, factory) {
+        return {
+          sockets: [factory.createWebSocket(credentials.wsUrl)],
+          uri: credentials.uri,
+          authorization_user: credentials.authUser,
+          password: credentials.password,
+          register: true,
+          register_expires: REGISTER_EXPIRES,
+          connection_recovery_min_interval: 2,
+          connection_recovery_max_interval: 30,
+          // Generic — NOT a provider brand string. If a provider ever requires a specific UA header it
+          // belongs in the provider, not hard-coded here.
+          // NOT ours to choose: Zadarma refuses to register any client whose User-Agent it does not
+          // recognise (see ProviderQuirks.userAgent). The provider decides; the engine just sends it.
+          user_agent: this.provider.quirks?.userAgent ?? "Coventia Softphone"
+        };
+      }
+      #teardownUA() {
+        this.#uaInFlight = null;
+        if (!this.#ua) return;
+        try {
+          this.#ua.terminateSessions({ status_code: 487 });
+          this.#ua.stop();
+        } catch {
+        }
+        this.#ua = null;
+        this.#activeCall = null;
+      }
+      /** Place a call once the UA is registered (its 200 OK for REGISTER has arrived). */
+      /**
+       * **No `mediaStream`** — JsSIP calls `getUserMedia` itself, which is what opens a real capture.
+       *
+       * That is load-bearing, not incidental. Firefox restricts ICE gathering on a page with no active
+       * capture: it discards every address but the default route's ("Ignoring addr from interface other
+       * than …" in about:webrtc) and can end up gathering NOTHING, so the INVITE goes out with
+       * `c=IN IP4 0.0.0.0` and no candidates at all. No STUN or TURN server can rescue an offer that
+       * contains no candidates. The legacy hook passed `mediaConstraints` and nothing else, for what
+       * turns out to be a very good reason.
+       */
+      #callWhenRegistered(ua, target) {
+        const options = { mediaConstraints: buildAudioConstraints(this.#inputDeviceId), pcConfig: PC_CONFIG };
+        if (ua.isRegistered()) return Promise.resolve(ua.call(target, options));
+        return new Promise((resolve) => {
+          ua.on("registered", () => resolve(ua.call(target, options)));
+        });
+      }
+      #wrapCall(session) {
+        const call = new SipEngineCall(session, {
+          id: nextCallId(),
+          buildTarget: (t) => this.#buildTarget(t),
+          placeConsult: (t) => this.#placeConsult(t),
+          // The guard is tied to the reject ACTION, not to `ended` — a normal hangup must not arm it.
+          onReject: () => this.#startRejectGuard(),
+          iceGatheringCapMs: this.provider.quirks?.iceGatheringCapMs ?? DEFAULT_ICE_CAP_MS,
+          // Inbound answers open their own peer connection, so they need the same ICE servers the
+          // outbound leg got. Missing here, an ANSWERED call is the one that fails — the half nobody
+          // tests until a real person picks up.
+          pcConfig: PC_CONFIG,
+          // Read fresh at answer() time, not captured now — a device chosen while the phone is still
+          // ringing must still apply once it is picked up.
+          getInputDeviceId: () => this.#inputDeviceId
+        });
+        this.#activeCall = call;
+        call.onEvent((event) => {
+          if (event.type === "ended") {
+            const missed = call.direction === "inbound" && event.cause === "Canceled";
+            const code = missed ? "call/missed" : CALL_END_CODES[event.reason];
+            if (code) this.#reportError(code, event.cause);
+            if (this.#activeCall === call) this.#activeCall = null;
+            if (this.provider.registrationMode === "on-demand") this.#teardownUA();
+          }
+        });
+        return call;
+      }
+      async #placeConsult(target) {
+        const ua = await this.#ensureUA();
+        const consultSession = ua.call(this.#buildTarget(target), {
+          mediaConstraints: buildAudioConstraints(this.#inputDeviceId),
+          pcConfig: PC_CONFIG
+        });
+        return new SipEngineCall(consultSession, {
+          id: nextCallId(),
+          buildTarget: (x) => this.#buildTarget(x),
+          placeConsult: () => Promise.reject(new Error("cannot consult from a consult leg")),
+          iceGatheringCapMs: this.provider.quirks?.iceGatheringCapMs ?? DEFAULT_ICE_CAP_MS
+        });
+      }
+      #startRejectGuard() {
+        const ms = this.provider.quirks?.rejectGuardMs;
+        if (ms) this.#rejectGuardUntil = this.now() + ms;
+      }
+      #buildTarget(target) {
+        return target.includes("@") ? target : `sip:${target}@${this.#domain}`;
+      }
+      #setState(state) {
+        if (state === this.#state) return;
+        this.#state = state;
+        for (const listener of [...this.#stateListeners]) listener(state);
+      }
+    };
+  }
+});
+
+// src/transports/sip/real-factory.ts
+async function loadJsSipFactory() {
+  if (cached) return cached;
+  const mod = await import('jssip');
+  const JsSIP = mod.default ?? mod;
+  if (!JsSIP?.UA || !JsSIP?.WebSocketInterface) {
+    throw new Error("jssip: unexpected module shape (no UA / WebSocketInterface)");
+  }
+  cached = {
+    createWebSocket: (wsUrl) => new JsSIP.WebSocketInterface(wsUrl),
+    createUA: (config) => new JsSIP.UA(config)
+  };
+  return cached;
+}
+var cached;
+var init_real_factory = __esm({
+  "src/transports/sip/real-factory.ts"() {
+    cached = null;
+  }
+});
+
+// src/transports/providers/zadarma.ts
+function buildPushUrl(key, sip) {
+  const params = new URLSearchParams({ key, integrationType: "site", sipId: sip });
+  return `wss://ws.zadarma.com/webrtc_pushes?${params.toString()}`;
+}
+var PING, KEY_REFRESH_BUFFER_MS, ZADARMA_QUIRKS, ZadarmaPushSignal, ZadarmaProvider;
+var init_zadarma = __esm({
+  "src/transports/providers/zadarma.ts"() {
+    PING = { localMs: 3e4, globalMs: 6e4 };
+    KEY_REFRESH_BUFFER_MS = 2 * 60 * 60 * 1e3;
+    ZADARMA_QUIRKS = {
+      // Zadarma's registrar REFUSES to register a WebRTC client with any other User-Agent — a clean 401
+      // after a valid digest challenge, indistinguishable from a wrong password (§3.1). The old CRM
+      // hook carried this string; the port dropped it, and registration failed for exactly that reason.
+      userAgent: "Zadarma webRTC",
+      // Zadarma re-rings a declined call for ~30 s (return_timeout). Swallow those (§3.4).
+      rejectGuardMs: 35e3,
+      // A push is not an INVITE (§3.3). If none arrives, tear the fresh UA down.
+      noInviteTeardownMs: 5e3,
+      // A ceiling on ICE gathering, not a target: JsSIP sends as soon as gathering completes. 3 s leaves
+      // room for a TURN allocation (whose relay candidates arrive last) while still bounding the ~40 s
+      // Chrome can spend against an unreachable server. See `capIceGathering`.
+      iceGatheringCapMs: 3e3
+    };
+    ZadarmaPushSignal = class {
+      constructor(deps) {
+        this.deps = deps;
+      }
+      deps;
+      #socket = null;
+      #connected = false;
+      #pingTimers = [];
+      #refreshTimer;
+      #unwatchBackground;
+      #closed = false;
+      #listeners = /* @__PURE__ */ new Set();
+      #connectionListeners = /* @__PURE__ */ new Set();
+      async connect() {
+        if (this.#socket) return;
+        this.#closed = false;
+        this.#unwatchBackground ??= this.deps.watchBackgroundReconnect?.(() => void this.#reopen());
+        await this.#open();
+      }
+      async #open() {
+        const { key, sip, keyExpiresAt } = await this.deps.fetchKey();
+        if (this.#closed) return;
+        const socket = this.deps.createPushSocket(buildPushUrl(key, sip));
+        this.#socket = socket;
+        socket.on("connect", () => {
+          this.#setConnected(true);
+          this.#startPings(socket);
+        });
+        socket.on("update", () => this.#emit());
+        socket.on("disconnect", () => {
+          this.#stopPings();
+          this.#setConnected(false);
+        });
+        socket.on("connect_error", () => {
+          this.#stopPings();
+          this.#setConnected(false);
+        });
+        this.#armRefresh(keyExpiresAt);
+      }
+      /**
+       * Presence pings — **the reason an idle tab keeps receiving calls**.
+       *
+       * Zadarma's gateway decides whether the extension is online, and it decides from these. Without
+       * them the socket goes quiet, Zadarma marks the extension offline within minutes, and INVITEs stop
+       * being routed — with no error anywhere, because nothing failed. The only visible symptom is that
+       * the phone silently stops ringing until the page is reloaded.
+       *
+       * The names and intervals are Zadarma's, taken from the CRM hook that ran this in production for
+       * years. They are not ours to tune.
+       */
+      #startPings(socket) {
+        this.#stopPings();
+        this.#pingTimers = [
+          setInterval(() => socket.emit("localPing", {}), PING.localMs),
+          setInterval(() => socket.emit("globalPing", {}), PING.globalMs)
+        ];
+      }
+      #stopPings() {
+        for (const t of this.#pingTimers) clearInterval(t);
+        this.#pingTimers = [];
+      }
+      /**
+       * Rebuild the socket before the WebRTC key expires.
+       *
+       * The key is baked into the socket URL, so socket.io's own reconnection re-presents whatever it was
+       * given at construction. A tab left open past the key's 72 h lifetime would reconnect forever with
+       * a dead credential. Absolute, from the backend's `key_expires_at`, so it targets the real expiry
+       * rather than restarting a countdown on every reconnect.
+       */
+      #armRefresh(keyExpiresAt) {
+        clearTimeout(this.#refreshTimer);
+        if (!keyExpiresAt) return;
+        const ms = new Date(keyExpiresAt).getTime() - Date.now() - KEY_REFRESH_BUFFER_MS;
+        if (!Number.isFinite(ms) || ms <= 0) return;
+        this.#refreshTimer = setTimeout(() => void this.#reopen(), ms);
+      }
+      async #reopen() {
+        if (this.#closed) return;
+        this.#stopPings();
+        this.#socket?.close();
+        this.#socket = null;
+        this.#setConnected(false);
+        try {
+          await this.#open();
+        } catch {
+        }
+      }
+      disconnect() {
+        this.#closed = true;
+        this.#stopPings();
+        clearTimeout(this.#refreshTimer);
+        this.#refreshTimer = void 0;
+        this.#unwatchBackground?.();
+        this.#unwatchBackground = void 0;
+        this.#socket?.close();
+        this.#socket = null;
+        this.#setConnected(false);
+      }
+      onSignal(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+      }
+      onConnectionChange(listener) {
+        this.#connectionListeners.add(listener);
+        return () => this.#connectionListeners.delete(listener);
+      }
+      get connected() {
+        return this.#connected;
+      }
+      #setConnected(connected) {
+        if (this.#connected === connected) return;
+        this.#connected = connected;
+        for (const listener of [...this.#connectionListeners]) listener(connected);
+      }
+      #emit() {
+        for (const listener of [...this.#listeners]) listener();
+      }
+    };
+    ZadarmaProvider = class {
+      constructor(deps) {
+        this.deps = deps;
+        this.incomingSignal = new ZadarmaPushSignal(deps);
+      }
+      deps;
+      name = "zadarma";
+      // Zadarma's PBX ignores a standing registration — it routes INVITEs only to a UA that registered
+      // in response to a push (SPEC §3.2). Hence on-demand.
+      registrationMode = "on-demand";
+      quirks = ZADARMA_QUIRKS;
+      incomingSignal;
+      /**
+       * Per-registration credentialing: fetch a scoped key, then exchange it in the browser for
+       * ephemeral SIP creds. The key fetch is cheap and backend-cached; doing it here (rather than
+       * sharing state with the push signal) keeps the two paths independent.
+       */
+      async provision() {
+        const { key, sip } = await this.deps.fetchKey();
+        const { pass, domain } = await this.deps.exchangeWebphoneData(key, sip);
+        return {
+          uri: `sip:${sip}@${domain}`,
+          authUser: sip,
+          password: pass,
+          wsUrl: `wss://${domain}:4443`
+        };
+      }
+    };
+  }
+});
+
+// src/transports/providers/zadarma-browser.ts
+function makeFetchKey(config) {
+  const attempt = async () => {
+    let token;
+    try {
+      ({ token } = await config.tokenSource.getToken());
+    } catch (cause) {
+      throw createError("auth/token-fetch-failed", cause);
+    }
+    const qs = config.organizationId ? `?organization_id=${encodeURIComponent(config.organizationId)}` : "";
+    const res = await fetch(`${config.apiBase}/phone/webrtc/key${qs}`, {
+      headers: { Authorization: token }
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => null);
+      const message = body?.message ?? `webrtc/key HTTP ${res.status}`;
+      throw res.status === 401 ? new UnauthorizedKeyError(message) : new Error(message);
+    }
+    const data = await res.json();
+    return {
+      key: data.key,
+      sip: data.sip,
+      ...data.key_expires_at ? { keyExpiresAt: data.key_expires_at } : {}
+    };
+  };
+  return async () => {
+    try {
+      return await attempt();
+    } catch (error) {
+      if (!(error instanceof UnauthorizedKeyError)) throw error;
+      invalidateToken(config.tokenSource);
+      try {
+        return await attempt();
+      } catch (retryError) {
+        if (retryError instanceof UnauthorizedKeyError) {
+          throw createError("auth/token-rejected", retryError);
+        }
+        throw retryError;
+      }
+    }
+  };
+}
+async function exchangeWebphoneData(key, sip, timeoutMs = 1e4) {
+  const params = new URLSearchParams({
+    // Still sent: the endpoint wraps its response either way, and naming the callback keeps the
+    // wrapper predictable rather than relying on their default.
+    jsonpCallback: "cv",
+    integrationType: "site",
+    key,
+    sipId: sip
+  });
+  let res;
+  try {
+    res = await fetch(
+      `https://api.zadarma.com/sys/webrtc/get_webphone_data.php?${params.toString()}`,
+      { signal: AbortSignal.timeout(timeoutMs) }
+    );
+  } catch (cause) {
+    const timedOut = cause instanceof DOMException && cause.name === "TimeoutError";
+    throw new Error(timedOut ? "get_webphone_data timed out" : "get_webphone_data network error", {
+      cause
+    });
+  }
+  if (!res.ok) throw new Error(`get_webphone_data HTTP ${res.status}`);
+  const data = parseJsonp(await res.text());
+  if (!data || data.error || !data.pass || !data.domain) {
+    throw new Error(data?.error?.content ?? "get_webphone_data: missing SIP credentials");
+  }
+  return { pass: data.pass, domain: data.domain };
+}
+function parseJsonp(text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  const body = open !== -1 && close > open ? text.slice(open + 1, close) : text;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+function createPushSocket(url) {
+  const handlers = /* @__PURE__ */ new Map();
+  let client = null;
+  let closed = false;
+  void (async () => {
+    const mod = await import('socket.io-client-v2');
+    if (closed) return;
+    const connect = mod.default ?? mod.io;
+    if (!connect) throw new Error("socket.io-client-v2: no connect export");
+    const c = connect(url, {
+      transports: ["websocket"],
+      reconnection: true,
+      // The push socket drops on a schedule under background-tab timer throttling, NOT from network
+      // flakiness — every reconnect observed succeeds on the first attempt (push-socket-reliability.md
+      // §2.3, §5.1). There is nothing to back off from on that first attempt, so waiting the old 10s
+      // before retrying was pure, uncontested exposure — an inbound call landing in that window is
+      // lost, unqueued (Zadarma's gateway speaks EIO3, no offline redelivery). `reconnectionDelayMax`
+      // stays as the ceiling for a genuinely down gateway, where backing off still matters.
+      reconnectionDelay: 300,
+      reconnectionDelayMax: 3e4
+    });
+    client = c;
+    for (const [event, cbs] of handlers) for (const cb of cbs) c.on(event, cb);
+  })();
+  return {
+    on(event, cb) {
+      const list = handlers.get(event) ?? [];
+      list.push(cb);
+      handlers.set(event, list);
+      client?.on(event, cb);
+    },
+    emit(event, payload) {
+      client?.emit(event, payload);
+    },
+    close() {
+      closed = true;
+      client?.close();
+    },
+    get connected() {
+      return client?.connected ?? false;
+    }
+  };
+}
+function watchBackgroundReconnect(cb) {
+  if (typeof document === "undefined" || typeof Worker === "undefined") return () => {
+  };
+  let worker = null;
+  let blobUrl = null;
+  const ensureWorker = () => {
+    if (!worker) {
+      blobUrl = URL.createObjectURL(new Blob([HEARTBEAT_WORKER_SOURCE], { type: "application/javascript" }));
+      worker = new Worker(blobUrl);
+      worker.onmessage = (e) => {
+        if (e.data === "tick") cb();
+      };
+    }
+    return worker;
+  };
+  const onVisibilityChange = () => {
+    if (document.visibilityState === "hidden") {
+      ensureWorker().postMessage({ type: "start", intervalMs: BACKGROUND_RECONNECT_MS });
+    } else {
+      worker?.postMessage({ type: "stop" });
+    }
+  };
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  if (document.visibilityState === "hidden") onVisibilityChange();
+  return () => {
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    worker?.postMessage({ type: "stop" });
+    worker?.terminate();
+    if (blobUrl) URL.revokeObjectURL(blobUrl);
+  };
+}
+function makeZadarmaBrowserDeps(config) {
+  return {
+    fetchKey: makeFetchKey(config),
+    exchangeWebphoneData: (key, sip) => exchangeWebphoneData(key, sip),
+    createPushSocket,
+    watchBackgroundReconnect
+  };
+}
+var UnauthorizedKeyError, BACKGROUND_RECONNECT_MS, HEARTBEAT_WORKER_SOURCE;
+var init_zadarma_browser = __esm({
+  "src/transports/providers/zadarma-browser.ts"() {
+    init_token_cache();
+    init_errors();
+    UnauthorizedKeyError = class extends Error {
+    };
+    BACKGROUND_RECONNECT_MS = 2e4;
+    HEARTBEAT_WORKER_SOURCE = `
+  let timer;
+  self.onmessage = (e) => {
+    if (e.data.type === 'start') timer = setInterval(() => self.postMessage('tick'), e.data.intervalMs);
+    else if (e.data.type === 'stop') { clearInterval(timer); timer = undefined; }
+  };
+`;
+  }
+});
+
+// src/transports/zadarma-engine.ts
+var zadarma_engine_exports = {};
+__export(zadarma_engine_exports, {
+  createZadarmaEngine: () => createZadarmaEngine
+});
+function createZadarmaEngine(config) {
+  const provider = new ZadarmaProvider(
+    makeZadarmaBrowserDeps({ ...config, tokenSource: cachedTokenSource(config.tokenSource) })
+  );
+  return new SipCallEngine(provider, loadJsSipFactory);
+}
+var init_zadarma_engine = __esm({
+  "src/transports/zadarma-engine.ts"() {
+    init_ua();
+    init_real_factory();
+    init_zadarma();
+    init_zadarma_browser();
+    init_token_cache();
+  }
+});
+
+// src/core/emitter.ts
+var Emitter = class {
+  constructor(onListenerError) {
+    this.onListenerError = onListenerError;
+  }
+  onListenerError;
+  // A copy of the listener set is iterated on emit, so a listener that unsubscribes (or subscribes)
+  // during dispatch does not mutate the set mid-iteration.
+  #listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => this.off(event, listener);
+  }
+  once(event, listener) {
+    const wrapped = (payload) => {
+      off();
+      listener(payload);
+    };
+    const off = this.on(event, wrapped);
+    return off;
+  }
+  off(event, listener) {
+    const set = this.#listeners.get(event);
+    if (!set) return;
+    set.delete(listener);
+    if (set.size === 0) this.#listeners.delete(event);
+  }
+  emit(event, payload) {
+    const set = this.#listeners.get(event);
+    if (!set) return;
+    for (const listener of [...set]) {
+      try {
+        listener(payload);
+      } catch (error) {
+        this.onListenerError?.(event, error);
+      }
+    }
+  }
+  /** Drop every listener. Called on teardown so a destroyed object leaks nothing. */
+  clear() {
+    this.#listeners.clear();
+  }
+};
+
+// src/core/events.ts
+var SoftphoneEvent = /* @__PURE__ */ ((SoftphoneEvent2) => {
+  SoftphoneEvent2["StateChanged"] = "stateChanged";
+  SoftphoneEvent2["IncomingCall"] = "incomingCall";
+  SoftphoneEvent2["ActiveCallChanged"] = "activeCallChanged";
+  SoftphoneEvent2["PlaybackBlocked"] = "playbackBlocked";
+  SoftphoneEvent2["DeviceChange"] = "deviceChange";
+  SoftphoneEvent2["Error"] = "error";
+  SoftphoneEvent2["LeaderChanged"] = "leaderChanged";
+  return SoftphoneEvent2;
+})(SoftphoneEvent || {});
+var CallEvent = /* @__PURE__ */ ((CallEvent2) => {
+  CallEvent2["StateChanged"] = "stateChanged";
+  CallEvent2["Accepted"] = "accepted";
+  CallEvent2["Ended"] = "ended";
+  CallEvent2["Muted"] = "muted";
+  CallEvent2["Held"] = "held";
+  CallEvent2["Unheld"] = "unheld";
+  CallEvent2["Reconnecting"] = "reconnecting";
+  CallEvent2["Reconnected"] = "reconnected";
+  CallEvent2["DigitsSent"] = "digitsSent";
+  CallEvent2["RemotePartyUpdated"] = "remotePartyUpdated";
+  CallEvent2["RemoteStream"] = "remoteStream";
+  return CallEvent2;
+})(CallEvent || {});
+
+// src/core/call.ts
+var CALL_TRANSITIONS = {
+  ringing: ["answering", "ended"],
+  dialing: ["early", "active", "ended"],
+  early: ["active", "ended"],
+  answering: ["active", "ended"],
+  active: ["held", "reconnecting", "ended"],
+  held: ["active", "reconnecting", "ended"],
+  reconnecting: ["active", "held", "ended"],
+  ended: []
+};
+var INITIAL_STATES = {
+  inbound: "ringing",
+  outbound: "dialing"
+};
+function canTransition(from, to) {
+  return CALL_TRANSITIONS[from].includes(to);
+}
+function isTerminal(state) {
+  return CALL_TRANSITIONS[state].length === 0;
+}
+
+// src/core/call-impl.ts
+var CallImpl = class _CallImpl extends Emitter {
+  constructor(engineCall, onListenerError, onInternalError) {
+    super(onListenerError);
+    this.engineCall = engineCall;
+    this.onInternalError = onInternalError;
+    this.#onListenerError = onListenerError;
+    this.#state = INITIAL_STATES[engineCall.direction];
+    this.#remote = {
+      number: engineCall.remoteNumber,
+      displayName: engineCall.remoteNumber,
+      contact: null
+    };
+    this.#unsubscribe = engineCall.onEvent((event) => this.#onEngineEvent(event));
+  }
+  engineCall;
+  onInternalError;
+  #state;
+  #remote;
+  #answeredAt = null;
+  #muted = false;
+  #onHold = false;
+  #remoteStream = null;
+  #consultEngineCall = null;
+  #consultCall = null;
+  #unsubscribe;
+  #onListenerError;
+  get id() {
+    return this.engineCall.id;
+  }
+  get direction() {
+    return this.engineCall.direction;
+  }
+  get state() {
+    return this.#state;
+  }
+  get remote() {
+    return this.#remote;
+  }
+  get answeredAt() {
+    return this.#answeredAt;
+  }
+  get isMuted() {
+    return this.#muted;
+  }
+  get isOnHold() {
+    return this.#onHold;
+  }
+  get remoteStream() {
+    return this.#remoteStream;
+  }
+  // ── Raw engine signals → state machine ──────────────────────────────────────
+  #onEngineEvent(event) {
+    switch (event.type) {
+      case "progress":
+        this.#transition("early");
+        break;
+      case "accepted":
+        if (this.#answeredAt === null) this.#answeredAt = this.#now();
+        this.#transition("active");
+        this.emit("accepted" /* Accepted */, void 0);
+        break;
+      case "held":
+        this.#onHold = true;
+        if (this.#transition("held")) this.emit("held" /* Held */, { originator: event.originator });
+        break;
+      case "unheld":
+        this.#onHold = false;
+        if (this.#transition("active")) this.emit("unheld" /* Unheld */, { originator: event.originator });
+        break;
+      case "reconnecting":
+        if (this.#transition("reconnecting")) this.emit("reconnecting" /* Reconnecting */, void 0);
+        break;
+      case "reconnected":
+        if (this.#transition(this.#onHold ? "held" : "active"))
+          this.emit("reconnected" /* Reconnected */, void 0);
+        break;
+      case "ended":
+        this.#end(event.reason);
+        break;
+      case "stream":
+        this.#remoteStream = event.stream;
+        this.emit("remoteStream" /* RemoteStream */, { stream: event.stream });
+        break;
+    }
+  }
+  // ── Commands ────────────────────────────────────────────────────────────────
+  async answer() {
+    if (this.#state !== "ringing") {
+      throw this.#stateError("answer", "call/not-answerable");
+    }
+    this.#transition("answering");
+    await this.engineCall.answer();
+  }
+  async reject() {
+    if (this.#state !== "ringing") {
+      throw this.#stateError("reject", "call/not-answerable");
+    }
+    await this.engineCall.reject();
+  }
+  async hangup() {
+    if (isTerminal(this.#state)) return;
+    await this.engineCall.hangup();
+  }
+  mute(muted) {
+    if (this.#muted === muted) return;
+    this.#muted = muted;
+    this.engineCall.mute(muted);
+    this.emit("muted" /* Muted */, { muted });
+  }
+  async hold() {
+    if (this.#onHold || this.#state !== "active" && this.#state !== "reconnecting") return;
+    await this.engineCall.hold();
+  }
+  async unhold() {
+    if (!this.#onHold) return;
+    await this.engineCall.unhold();
+  }
+  sendDigits(digits) {
+    this.engineCall.sendDigits(digits);
+    this.emit("digitsSent" /* DigitsSent */, { digits });
+  }
+  async transfer(target) {
+    await this.engineCall.transfer(target);
+  }
+  async startConsult(target) {
+    await this.hold();
+    const consultEngineCall = await this.engineCall.startConsult(target);
+    this.#consultEngineCall = consultEngineCall;
+    const consult = new _CallImpl(consultEngineCall, this.#onListenerError, this.onInternalError);
+    this.#consultCall = consult;
+    return consult;
+  }
+  async completeTransfer() {
+    if (!this.#consultEngineCall) throw this.#stateError("completeTransfer", "call/unsupported");
+    await this.engineCall.completeTransfer(this.#consultEngineCall);
+  }
+  async cancelConsult() {
+    if (!this.#consultCall) return;
+    await this.#consultCall.hangup();
+    this.#consultCall = null;
+    this.#consultEngineCall = null;
+    await this.unhold();
+  }
+  // ── Internals ───────────────────────────────────────────────────────────────
+  #transition(to) {
+    const from = this.#state;
+    if (from === to) return false;
+    if (isTerminal(from)) return false;
+    if (!canTransition(from, to)) {
+      this.onInternalError?.(`illegal call transition ${from} \u2192 ${to} (SPEC \xA75.3)`);
+      return false;
+    }
+    this.#state = to;
+    this.emit("stateChanged" /* StateChanged */, { state: to, previous: from });
+    return true;
+  }
+  #end(reason) {
+    if (isTerminal(this.#state)) return;
+    const from = this.#state;
+    this.#state = "ended";
+    this.emit("stateChanged" /* StateChanged */, { state: "ended", previous: from });
+    this.emit("ended" /* Ended */, { reason });
+    this.#unsubscribe();
+    this.clear();
+  }
+  #stateError(op, _code) {
+    return new Error(`${op}() is not valid while call is '${this.#state}'`);
+  }
+  #now() {
+    return /* @__PURE__ */ new Date();
+  }
+  /** @internal — the Softphone updates caller identity once `resolveContact` resolves. */
+  setRemoteContact(contact) {
+    this.#remote = {
+      number: this.#remote.number,
+      displayName: contact.name ?? this.#remote.number,
+      contact
+    };
+    this.emit("remotePartyUpdated" /* RemotePartyUpdated */, void 0);
+  }
+};
+
+// src/core/backend.ts
+function coventiaBackend(config, tokenSource, fallbackBaseUrl) {
+  const baseUrl = config.baseUrl ?? fallbackBaseUrl;
+  if (!baseUrl) {
+    throw new Error(
+      "No base URL for the Coventia backend. Pass `coventia.baseUrl`, or a top-level `apiBase` on `createSoftphone` for it to fall back to."
+    );
+  }
+  let pending = null;
+  const load = () => {
+    pending ??= Promise.resolve().then(() => (init_sources2(), sources_exports)).then(
+      (m) => m.coventiaSources({ ...config, baseUrl, tokenSource })
+    );
+    return pending;
+  };
+  return {
+    contacts: async (params) => (await load()).contacts(params),
+    history: async (params) => (await load()).history(params),
+    resolveContact: async (number) => (await load()).resolveContact(number),
+    listAgents: async () => (await load()).listAgents()
+  };
+}
+
+// src/core/softphone-impl.ts
+init_token_cache();
+
+// src/core/env.ts
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function isWebRtcSupported() {
+  return isBrowser() && typeof RTCPeerConnection !== "undefined" && typeof navigator !== "undefined" && typeof navigator.mediaDevices?.getUserMedia === "function";
+}
+
+// src/core/tabs.ts
+var LOCK_NAME = "coventia-softphone:leader";
+function isWebLocksSupported() {
+  return isBrowser() && typeof navigator.locks?.request === "function";
+}
+function webLocksTabLock(lockName = LOCK_NAME) {
+  const controller = new AbortController();
+  let releaseHold;
+  return {
+    acquireLeadership() {
+      if (!isWebLocksSupported()) return Promise.resolve();
+      return new Promise((resolveAcquired) => {
+        navigator.locks.request(lockName, { signal: controller.signal }, () => {
+          resolveAcquired();
+          return new Promise((resolveHold) => {
+            releaseHold = resolveHold;
+          });
+        }).catch(() => {
+        });
+      });
+    },
+    release() {
+      if (releaseHold) {
+        const resolve = releaseHold;
+        releaseHold = void 0;
+        resolve();
+      } else {
+        controller.abort();
+      }
+    }
+  };
+}
+
+// src/core/softphone-impl.ts
+init_errors();
+var liveInstance = false;
+var BrowserAudioDevices = class {
+  inputs = [];
+  outputs = [];
+  currentInputId = null;
+  currentOutputId = null;
+  canSelectOutput;
+  #engine;
+  #onChange;
+  constructor(engine, onChange) {
+    this.#engine = engine;
+    this.#onChange = onChange;
+    this.canSelectOutput = isBrowser() && typeof HTMLMediaElement !== "undefined" && "setSinkId" in HTMLMediaElement.prototype;
+    if (isBrowser() && navigator.mediaDevices) {
+      void this.refresh();
+      navigator.mediaDevices.addEventListener?.("devicechange", () => void this.refresh());
+    }
+  }
+  async refresh() {
+    if (!isBrowser() || typeof navigator.mediaDevices?.enumerateDevices !== "function") return;
+    let all;
+    try {
+      all = await navigator.mediaDevices.enumerateDevices();
+    } catch {
+      return;
+    }
+    this.inputs = all.filter((d) => d.kind === "audioinput");
+    this.outputs = all.filter((d) => d.kind === "audiooutput");
+    if (this.currentInputId && !this.inputs.some((d) => d.deviceId === this.currentInputId)) {
+      this.currentInputId = null;
+    }
+    if (this.currentOutputId && !this.outputs.some((d) => d.deviceId === this.currentOutputId)) {
+      this.currentOutputId = null;
+    }
+    this.#onChange();
+  }
+  async setInput(deviceId) {
+    this.currentInputId = deviceId;
+    this.#onChange();
+    await this.#engine.setInputDevice?.(deviceId);
+  }
+  async setOutput(deviceId) {
+    this.currentOutputId = deviceId;
+    this.#onChange();
+  }
+  async setRingtoneOutput() {
+  }
+};
+var SoftphoneImpl = class extends Emitter {
+  #state = "stopped";
+  #lastError = null;
+  #activeCall = null;
+  #destroyed = false;
+  #startedHere = false;
+  #isLeader = false;
+  #engine;
+  #tabLock;
+  #resolveContact;
+  /** Contacts + history, whenever there is a Coventia backend to reach. The widget reads these. */
+  sources;
+  audio;
+  /**
+   * `tabLock` defaults to the real Web Locks implementation — not part of `SoftphoneConfig` (an
+   * internal seam, not something an integrator tunes). Tests construct this class directly with a
+   * fake for deterministic control; `createSoftphone()` never passes a third argument, so every
+   * existing test that goes through it is unaffected (`multi-tab-leader-election.md` §3.8).
+   */
+  constructor(engine, config, tabLock = webLocksTabLock()) {
+    super();
+    this.#engine = engine;
+    this.#tabLock = tabLock;
+    this.audio = new BrowserAudioDevices(
+      this.#engine,
+      () => this.emit("deviceChange" /* DeviceChange */, void 0)
+    );
+    this.sources = config.coventia || config.apiBase ? coventiaBackend(config.coventia ?? {}, cachedTokenSource(config.tokenSource), config.apiBase) : null;
+    this.#resolveContact = config.resolveContact ?? this.sources?.resolveContact;
+    this.#engine.onIncoming((engineCall) => this.#onIncoming(engineCall));
+    this.#engine.onStateChange((state) => this.#setState(state));
+    this.#engine.onError?.((error) => this.#onError(error));
+  }
+  get state() {
+    return this.#state;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  get isLeader() {
+    return this.#isLeader;
+  }
+  get activeCall() {
+    return this.#activeCall;
+  }
+  get canPlayAudio() {
+    return true;
+  }
+  async startAudio() {
+  }
+  async start() {
+    this.#assertUsable();
+    if (this.#startedHere) return;
+    if (liveInstance) {
+      throw new Error(
+        "A Softphone is already running on this page. Construct one and share it; call destroy() before starting another. (SPEC \xA75.3 / error engine/duplicate-instance)"
+      );
+    }
+    liveInstance = true;
+    this.#startedHere = true;
+    this.#setState("starting");
+    await this.#tabLock.acquireLeadership();
+    if (this.#destroyed) return;
+    this.#setLeader(true);
+    await this.#engine.start();
+  }
+  async stop() {
+    if (!this.#startedHere) return;
+    this.#tabLock.release();
+    if (this.#isLeader) {
+      await this.#engine.stop();
+      if (this.#activeCall) await this.#activeCall.hangup().catch(() => {
+      });
+    }
+    this.#setLeader(false);
+    this.#releaseInstance();
+    this.#setState("stopped");
+  }
+  async destroy() {
+    if (this.#destroyed) return;
+    this.#destroyed = true;
+    await this.stop().catch(() => {
+    });
+    this.#setState("destroyed");
+    this.clear();
+  }
+  async call(destination, options) {
+    this.#assertUsable();
+    if (this.#state !== "online" && this.#state !== "offline" && this.#state !== "starting") {
+      throw new Error(`Cannot place a call while softphone is '${this.#state}'.`);
+    }
+    if (this.#activeCall) {
+      throw new Error("A call is already in progress. Hang up before placing another.");
+    }
+    const engineCall = await this.#engine.placeCall(destination, options);
+    return this.#adopt(engineCall);
+  }
+  // ── internals ───────────────────────────────────────────────────────────────
+  #onIncoming(engineCall) {
+    if (this.#activeCall) {
+      void engineCall.reject().catch(() => {
+      });
+      return;
+    }
+    const call = this.#adopt(engineCall);
+    this.emit("incomingCall" /* IncomingCall */, call);
+  }
+  #adopt(engineCall) {
+    const call = new CallImpl(
+      engineCall,
+      (event, error) => this.#reportListenerError("call", event, error),
+      (message) => this.#reportInternalError(message)
+    );
+    this.#activeCall = call;
+    const off = call.on("ended" /* Ended */, () => {
+      off();
+      if (this.#activeCall === call) {
+        this.#activeCall = null;
+        this.emit("activeCallChanged" /* ActiveCallChanged */, { call: null });
+      }
+    });
+    if (this.#resolveContact) {
+      void this.#resolveContact(engineCall.remoteNumber).then((contact) => {
+        if (contact && this.#activeCall === call) call.setRemoteContact(contact);
+      }).catch(() => {
+      });
+    }
+    this.emit("activeCallChanged" /* ActiveCallChanged */, { call });
+    return call;
+  }
+  #setState(state) {
+    if (state === this.#state) return;
+    const previous = this.#state;
+    this.#state = state;
+    if (state === "online") this.#lastError = null;
+    this.emit("stateChanged" /* StateChanged */, { state, previous });
+  }
+  #setLeader(isLeader) {
+    if (isLeader === this.#isLeader) return;
+    this.#isLeader = isLeader;
+    this.emit("leaderChanged" /* LeaderChanged */, { isLeader });
+  }
+  /**
+   * Re-emit an engine failure to the host, and remember it if it is fatal.
+   *
+   * Every error is emitted; only fatal ones are retained. A non-fatal error is a fact about one call
+   * — the remote party was busy — and keeping it as softphone state would make a working phone look
+   * broken to anything that renders `lastError`.
+   */
+  #onError(error) {
+    if (isFatal(error)) this.#lastError = error;
+    this.emit("error" /* Error */, error);
+  }
+  #releaseInstance() {
+    if (this.#startedHere) {
+      liveInstance = false;
+      this.#startedHere = false;
+    }
+  }
+  #assertUsable() {
+    if (this.#destroyed) {
+      throw new Error("This Softphone has been destroyed. Construct a new one. (engine/destroyed)");
+    }
+  }
+  #reportListenerError(source, event, error) {
+    console.error(`[softphone] a ${source} '${String(event)}' listener threw:`, error);
+  }
+  #reportInternalError(message) {
+    console.error(`[softphone] ${message}`);
+  }
+};
+
+// src/core/default-provider.ts
+var LazyRelay = class {
+  #listeners = /* @__PURE__ */ new Set();
+  #realOff = /* @__PURE__ */ new Map();
+  #target = null;
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    if (this.#target) this.#realOff.set(listener, this.#target.on(listener));
+    return () => {
+      this.#listeners.delete(listener);
+      this.#realOff.get(listener)?.();
+      this.#realOff.delete(listener);
+    };
+  }
+  /** Called once the real engine exists — replays every listener registered before now onto it. */
+  attach(target) {
+    this.#target = target;
+    for (const listener of this.#listeners) this.#realOff.set(listener, target.on(listener));
+  }
+};
+function defaultZadarmaEngine(config) {
+  let real = null;
+  let pending = null;
+  const incoming = new LazyRelay();
+  const stateChange = new LazyRelay();
+  const error = new LazyRelay();
+  function load() {
+    pending ??= Promise.resolve().then(() => (init_zadarma_engine(), zadarma_engine_exports)).then(({ createZadarmaEngine: createZadarmaEngine2 }) => {
+      const engine = createZadarmaEngine2(config);
+      incoming.attach({ on: (l) => engine.onIncoming(l) });
+      stateChange.attach({ on: (l) => engine.onStateChange(l) });
+      error.attach({ on: (l) => engine.onError?.(l) ?? (() => {
+      }) });
+      real = engine;
+      return engine;
+    }).catch((cause) => {
+      pending = null;
+      throw cause;
+    });
+    return pending;
+  }
+  return {
+    get state() {
+      return real?.state ?? "stopped";
+    },
+    async start() {
+      await (await load()).start();
+    },
+    async stop() {
+      if (real) await real.stop();
+    },
+    async placeCall(destination, options) {
+      return (await load()).placeCall(destination, options);
+    },
+    onIncoming: (listener) => incoming.subscribe(listener),
+    onStateChange: (listener) => stateChange.subscribe(listener),
+    onError: (listener) => error.subscribe(listener)
+  };
+}
+
+// src/core/create.ts
+function createSoftphone(config) {
+  return new SoftphoneImpl(resolveEngine(config), config);
+}
+function resolveEngine(config) {
+  if (config.provider !== void 0) {
+    if (isCallEngine(config.provider)) return config.provider;
+    throw new Error(
+      '`config.provider` was set but is not a valid CallEngine \u2014 it needs at least `placeCall` and `onIncoming`. Pass `createZadarmaEngine(...)` from "@coventia/softphone/zadarma", a `MockProvider` from "@coventia/softphone/testing", or omit it entirely to use the default.'
+    );
+  }
+  if (config.apiBase) {
+    return defaultZadarmaEngine({
+      apiBase: config.apiBase,
+      tokenSource: config.tokenSource,
+      organizationId: config.coventia?.organizationId
+    });
+  }
+  throw new Error(
+    'No call engine configured. Pass `config.provider` explicitly \u2014 `createZadarmaEngine({ apiBase, tokenSource })` from "@coventia/softphone/zadarma", or a `MockProvider` from "@coventia/softphone/testing" \u2014 or set `config.apiBase` so a default Zadarma engine can be built.'
+  );
+}
+function isCallEngine(value) {
+  return typeof value === "object" && value !== null && typeof value.placeCall === "function" && typeof value.onIncoming === "function";
+}
+
+// src/index.ts
+init_errors();
+var VERSION = "0.0.0";
+
+exports.CALL_TRANSITIONS = CALL_TRANSITIONS;
+exports.CallEvent = CallEvent;
+exports.INITIAL_STATES = INITIAL_STATES;
+exports.SoftphoneEvent = SoftphoneEvent;
+exports.VERSION = VERSION;
+exports.canTransition = canTransition;
+exports.createSoftphone = createSoftphone;
+exports.isBrowser = isBrowser;
+exports.isFatal = isFatal;
+exports.isTerminal = isTerminal;
+exports.isWebRtcSupported = isWebRtcSupported;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map