@streaming-cdn/rtc-web 1.3.12 → 1.3.14

package/dist/rtc-web.es.js

@@ -0,0 +1,1802 @@
+const fe = 0.02, ge = 1.4;
+function H(c, e, t = 0.02, i = 1.4) {
+  const n = c.filter((r) => r.level >= t);
+  if (n.length === 0) return null;
+  const s = n.reduce((r, o) => o.level > r.level ? o : r), a = n.find((r) => r.participantId === e);
+  return a ? s.participantId === e ? e : s.level >= a.level * i ? s.participantId : e : s.participantId;
+}
+function _(c) {
+  const e = [];
+  for (const t of c) {
+    if (String(t.type ?? "") !== "inbound-rtp" || String(t.kind ?? t.mediaType ?? "") !== "audio") continue;
+    const i = Number(t.audioLevel ?? NaN);
+    Number.isFinite(i) && e.push({ mid: typeof t.mid == "string" ? t.mid : null, level: i });
+  }
+  return e;
+}
+const f = {
+  audio: { active: !1, maxBitrate: 0, maxFramerate: 0, scaleResolutionDownBy: 4 },
+  low: { active: !0, maxBitrate: 35e4, maxFramerate: 15, scaleResolutionDownBy: 4 },
+  medium: { active: !0, maxBitrate: 11e5, maxFramerate: 24, scaleResolutionDownBy: 2 },
+  high: { active: !0, maxBitrate: 28e5, maxFramerate: 30, scaleResolutionDownBy: 1 }
+}, X = {
+  warmupSamples: 3,
+  poorSamplesToStepDown: 2,
+  goodSamplesToStepUp: 6,
+  criticalLossPct: 8,
+  criticalRttMs: 800,
+  poorLossPct: 3,
+  poorRttMs: 350,
+  goodLossPct: 1,
+  goodRttMs: 250,
+  sustainRatio: 0.8
+};
+function Z(c) {
+  const e = String(c ?? "").trim().toLowerCase();
+  return !e || e === "none" ? "" : e === "cpu" || e === "bandwidth" ? e : "other";
+}
+function ee(c, e, t, i, n = {}) {
+  const s = { ...X, ...n.thresholds }, a = ["low", "medium", "high"], r = n.ceiling && n.ceiling !== "audio" ? n.ceiling : "high", o = a.indexOf(r), l = a.indexOf(c), d = (n.samplesSeen ?? s.warmupSamples) + 1, u = d <= s.warmupSamples, m = Z(e.qualityLimitationReason), p = e.packetLossPct ?? 0, v = e.rttMs ?? 0, T = e.availableOutgoingBitrateBps, E = f[c].maxBitrate, w = p >= s.criticalLossPct || v >= s.criticalRttMs || m === "cpu", y = w || p >= s.poorLossPct || v >= s.poorRttMs || m === "bandwidth", b = T == null || T >= E * s.sustainRatio, C = p < s.goodLossPct && v < s.goodRttMs && !m && b, S = y ? t + 1 : 0, k = C ? i + 1 : 0, I = { quality: c, poorSamples: S, goodSamples: k, samplesSeen: d, changed: !1 };
+  return l > o ? { quality: a[o], poorSamples: 0, goodSamples: 0, samplesSeen: d, changed: !0 } : u ? I : w && l > 0 ? { quality: a[l - 1], poorSamples: 0, goodSamples: 0, samplesSeen: d, changed: !0 } : S >= s.poorSamplesToStepDown && l > 0 ? { quality: a[l - 1], poorSamples: 0, goodSamples: 0, samplesSeen: d, changed: !0 } : k >= s.goodSamplesToStepUp && l < o ? { quality: a[l + 1], poorSamples: 0, goodSamples: 0, samplesSeen: d, changed: !0 } : I;
+}
+function te(c, e) {
+  const t = c instanceof Map ? c : new Map(c);
+  let i = 0, n = 0, s = null, a = null, r = null;
+  for (const d of t.values()) {
+    const u = String(d.type ?? "");
+    if (u === "outbound-rtp" && String(d.kind ?? "") === "video" && (i += Number(d.packetsSent ?? 0), s = d.qualityLimitationReason ?? s), u === "remote-inbound-rtp" && String(d.kind ?? "") === "video") {
+      n += Number(d.packetsLost ?? 0);
+      const m = Number(d.roundTripTime ?? NaN);
+      Number.isFinite(m) && (a = m * 1e3);
+    }
+    if (u === "candidate-pair" && (d.nominated === !0 || String(d.state ?? "") === "succeeded")) {
+      const m = Number(d.currentRoundTripTime ?? NaN);
+      a == null && Number.isFinite(m) && (a = m * 1e3);
+      const p = Number(d.availableOutgoingBitrate ?? NaN);
+      Number.isFinite(p) && (r = p);
+    }
+  }
+  const o = { packetsSent: i, packetsLost: n, timestamp: Date.now() };
+  let l = null;
+  if (e) {
+    const d = i - e.packetsSent, u = n - e.packetsLost;
+    d > 0 && u >= 0 && (l = u / (d + u) * 100);
+  }
+  return {
+    sample: { packetLossPct: l, rttMs: a, availableOutgoingBitrateBps: r, qualityLimitationReason: s },
+    counters: o
+  };
+}
+const ie = {
+  audio: { active: !1, maxBitrate: 0, maxFramerate: 0, scaleResolutionDownBy: 4 }
+}, ne = { active: !0, maxBitrate: 4e6, maxFramerate: 30, scaleResolutionDownBy: 1 };
+class A {
+  options;
+  socket = null;
+  localStream = null;
+  screenStream = null;
+  peers = /* @__PURE__ */ new Map();
+  joinPromise = null;
+  resolveJoin = null;
+  rejectJoin = null;
+  joined = !1;
+  stopped = !1;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  qualityTimer = null;
+  speakerTimer = null;
+  activeSpeaker = null;
+  heartbeatDeadline = 0;
+  quality;
+  preferredVideoCodec;
+  signalQueue = Promise.resolve();
+  socketGeneration = 0;
+  constructor(e) {
+    this.options = e, this.localStream = e.localStream ?? null, this.quality = e.quality ?? "high", this.preferredVideoCodec = e.preferredVideoCodec ?? "auto";
+  }
+  async initialize() {
+    if (!globalThis.RTCPeerConnection || !globalThis.WebSocket)
+      throw new Error("This browser does not support WebRTC");
+  }
+  async join() {
+    if (!this.joined) {
+      if (this.joinPromise) return this.joinPromise;
+      this.joinPromise = this.connect();
+      try {
+        await this.joinPromise;
+      } finally {
+        this.joinPromise = null;
+      }
+    }
+  }
+  async leave() {
+    this.stopped = !0, this.clearConnectionTimers(), this.send({ type: "rtc.leave" }), this.joined = !1, this.socket?.close(1e3, "Participant left"), this.socket = null;
+    for (const e of this.peers.values()) e.connection.close();
+    this.peers.clear(), this.stopStream(this.localStream), this.stopStream(this.screenStream), this.localStream = null, this.screenStream = null;
+  }
+  setMuted(e) {
+    for (const t of this.localStream?.getAudioTracks() ?? []) t.enabled = !e;
+  }
+  async setCameraEnabled(e) {
+    if (e && !this.localStream?.getVideoTracks().length) {
+      const i = (await navigator.mediaDevices.getUserMedia({ video: { width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } } })).getVideoTracks()[0];
+      if (!i) throw new Error("Camera is unavailable");
+      this.localStream || (this.localStream = new MediaStream()), this.localStream.addTrack(i), this.screenStream?.getVideoTracks().some((n) => n.readyState === "live") || await this.replaceVideoTrack(i);
+      return;
+    }
+    for (const t of this.localStream?.getVideoTracks() ?? []) t.enabled = e;
+  }
+  async setScreenShareEnabled(e) {
+    if (!e) {
+      const n = this.screenStream;
+      this.screenStream = null, this.stopStream(n);
+      const s = this.localStream?.getVideoTracks()[0] ?? null;
+      await this.replaceVideoTrack(s), this.options.onEvent("screensharechange", { enabled: !1, stream: null });
+      return;
+    }
+    if (this.screenStream?.getVideoTracks()[0]?.readyState === "live") return;
+    const t = await navigator.mediaDevices.getDisplayMedia({
+      video: { width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } },
+      audio: !1
+    }), i = t.getVideoTracks()[0];
+    if (!i) throw new Error("Screen sharing is unavailable");
+    i.contentHint = "detail", this.screenStream = t, i.addEventListener("ended", () => {
+      this.screenStream?.getVideoTracks()[0]?.id === i.id && this.setScreenShareEnabled(!1);
+    });
+    try {
+      await this.replaceVideoTrack(i), this.options.onEvent("screensharechange", { enabled: !0, stream: t });
+    } catch (n) {
+      throw this.screenStream = null, this.stopStream(t), n;
+    }
+  }
+  async setDevice(e) {
+    const t = { deviceId: { exact: e.deviceId } }, i = await navigator.mediaDevices.getUserMedia(e.kind === "audioinput" ? { audio: t } : { video: { ...t, width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } } }), n = e.kind === "audioinput" ? i.getAudioTracks()[0] : i.getVideoTracks()[0];
+    if (!n) throw new Error("Selected media device is unavailable");
+    const s = e.kind === "audioinput" ? "audio" : "video", a = this.localStream?.getTracks().find((r) => r.kind === s);
+    if (this.localStream || (this.localStream = new MediaStream()), a && (this.localStream.removeTrack(a), a.stop()), this.localStream.addTrack(n), s === "video") {
+      this.screenStream?.getVideoTracks().some((r) => r.readyState === "live") || await this.replaceVideoTrack(n);
+      return;
+    }
+    for (const r of this.peers.values()) {
+      const o = r.connection.getSenders().find((l) => l.track?.kind === s);
+      o ? await o.replaceTrack(n) : r.connection.addTrack(n, this.localStream);
+    }
+    await this.applyVideoQuality();
+  }
+  async setQuality(e) {
+    this.quality = e;
+    for (const t of this.localStream?.getVideoTracks() ?? []) t.enabled = e !== "audio";
+    for (const t of this.peers.values())
+      t.quality = A.clampToCeiling(t.quality, e), t.poorSamples = 0, t.goodSamples = 0;
+    await this.applyVideoQuality();
+  }
+  static clampToCeiling(e, t) {
+    if (t === "audio") return e;
+    const i = ["low", "medium", "high"];
+    return i.indexOf(e) > i.indexOf(t) ? t : e;
+  }
+  async setPreferredVideoCodec(e) {
+    this.preferredVideoCodec = e;
+    for (const t of this.peers.values()) this.applyCodecPreference(t.connection);
+    await this.renegotiateAll();
+  }
+  getParticipants() {
+    return [...this.peers.values()].map((e) => e.identity);
+  }
+  getLocalStream() {
+    return this.localStream;
+  }
+  async setVideoTrack(e) {
+    if (e.kind !== "video") throw new Error("A video track is required");
+    this.localStream || (this.localStream = new MediaStream());
+    const t = this.localStream.getVideoTracks()[0];
+    t?.id !== e.id && (t && this.localStream.removeTrack(t), this.localStream.addTrack(e)), await this.replaceVideoTrack(e), this.options.onEvent("localstream", { stream: this.localStream, track: e });
+  }
+  getRemoteStreams() {
+    return [...this.peers.values()].map((e) => ({ participant: e.identity, stream: e.stream }));
+  }
+  getPrimaryPeerConnection() {
+    return this.peers.values().next().value?.connection ?? null;
+  }
+  sendChat(e, t) {
+    this.send({ type: "rtc.chat", message: e, participantIds: t ?? [] });
+  }
+  sendControl(e, t = {}) {
+    this.send({ type: "rtc.control", action: e, detail: t });
+  }
+  async connect() {
+    const { credential: e } = this.options;
+    if (!e.signalingToken || !e.signalingUrl || !e.roomId || !e.participantId)
+      throw new Error("A room signaling credential is required");
+    this.stopped = !1, !this.localStream && (this.options.audio || this.options.video) && (this.localStream = await navigator.mediaDevices.getUserMedia({ audio: this.options.audio, video: this.options.video })), this.localStream && this.options.onEvent("localstream", { stream: this.localStream }), await this.openSocket(!1);
+  }
+  async openSocket(e) {
+    const { credential: t } = this.options, i = new URL(t.signalingUrl, globalThis.location?.href);
+    i.protocol = i.protocol === "https:" ? "wss:" : "ws:";
+    const n = new Promise((o, l) => {
+      this.resolveJoin = o, this.rejectJoin = l;
+    }), s = new WebSocket(i, ["rtc-client", t.signalingToken]), a = ++this.socketGeneration;
+    this.socket = s;
+    const r = setTimeout(() => this.rejectJoin?.(new Error("RTC signaling timed out")), 15e3);
+    s.addEventListener("open", () => {
+      this.heartbeatDeadline = Date.now() + 45e3, this.startHeartbeat(s), this.startQualitySampling(), this.send({ type: "rtc.room.join" });
+    }), s.addEventListener("message", (o) => {
+      const l = String(o.data);
+      this.signalQueue = this.signalQueue.then(async () => {
+        this.socket !== s || this.socketGeneration !== a || await this.handleSignal(l);
+      }).catch((d) => {
+        const u = d instanceof Error ? d.message : "RTC signaling processing failed";
+        this.options.onEvent("signalingerror", { message: u }), this.joined || this.rejectJoin?.(new Error(u));
+      });
+    }), s.addEventListener("error", () => this.rejectJoin?.(new Error("RTC signaling connection failed"))), s.addEventListener("close", (o) => {
+      if (this.socket !== s) return;
+      this.socket = null, this.stopHeartbeat(), this.stopQualitySampling(), !this.joined && !e && this.rejectJoin?.(new Error(o.reason || "RTC signaling connection closed"));
+      const l = !this.stopped && (this.joined || e);
+      this.joined = !1, l ? (this.resetPeers(), this.options.onEvent("reconnecting", { reason: o.reason, code: o.code, attempt: this.reconnectAttempt + 1 }), this.scheduleReconnect()) : this.stopped || this.options.onEvent("disconnected", { reason: o.reason, code: o.code });
+    });
+    try {
+      await n, this.joined = !0, this.options.onEvent("connected", { participantId: t.participantId, resumed: e });
+    } finally {
+      clearTimeout(r), this.resolveJoin = null, this.rejectJoin = null;
+    }
+  }
+  async handleSignal(e) {
+    let t;
+    try {
+      t = JSON.parse(e);
+    } catch {
+      return;
+    }
+    const i = String(t.type ?? "");
+    if (i !== "ready") {
+      if (i === "pong") {
+        this.heartbeatDeadline = Date.now() + 45e3;
+        return;
+      }
+      if (i === "rtc.room.peers") {
+        this.reconnectAttempt = 0;
+        const n = Array.isArray(t.peers) ? t.peers : [];
+        for (const s of n) this.ensurePeer(s);
+        this.resolveJoin?.();
+        for (const s of n)
+          this.shouldInitiateOffer(s) && await this.createOffer(s);
+        return;
+      }
+      if (i === "rtc.room.join" && t.sender) {
+        this.options.onEvent("participantjoined", t.sender), this.ensurePeer(t.sender), this.shouldInitiateOffer(t.sender) && await this.createOffer(t.sender);
+        return;
+      }
+      if (i === "rtc.offer" && t.sender && t.description) {
+        const n = this.ensurePeer(t.sender);
+        n.offerTask && await n.offerTask;
+        const s = n.connection.signalingState !== "stable", a = !this.shouldInitiateOffer(t.sender);
+        if (s && !a) return;
+        s && await n.connection.setLocalDescription({ type: "rollback" }), await n.connection.setRemoteDescription(t.description);
+        const r = await n.connection.createAnswer();
+        await n.connection.setLocalDescription(r), this.send({
+          type: "rtc.answer",
+          targetParticipantId: t.sender.participantId,
+          negotiationId: t.negotiationId,
+          description: n.connection.localDescription
+        });
+        return;
+      }
+      if (i === "rtc.answer" && t.sender && t.description) {
+        const n = this.peers.get(t.sender.participantId);
+        if (!n || n.connection.signalingState !== "have-local-offer" || t.negotiationId && n.activeNegotiationId && t.negotiationId !== n.activeNegotiationId) return;
+        await n.connection.setRemoteDescription(t.description), n.activeNegotiationId = null;
+        return;
+      }
+      if (i === "rtc.ice" && t.sender && t.candidate) {
+        await this.ensurePeer(t.sender).connection.addIceCandidate(t.candidate).catch(() => {
+        });
+        return;
+      }
+      if ((i === "rtc.peer.left" || i === "rtc.leave") && t.sender) {
+        this.removePeer(t.sender.participantId);
+        return;
+      }
+      i === "rtc.chat" ? this.options.onEvent("chatupdate", t) : i === "rtc.control" && this.options.onEvent("control", t);
+    }
+  }
+  ensurePeer(e) {
+    const t = this.peers.get(e.participantId);
+    if (t) return t;
+    const i = new RTCPeerConnection({
+      iceServers: this.options.credential.iceServers ?? [],
+      iceTransportPolicy: this.options.iceTransportPolicy ?? "all"
+    }), n = new MediaStream(), s = {
+      identity: e,
+      connection: i,
+      stream: n,
+      makingOffer: !1,
+      offerTask: null,
+      activeNegotiationId: null,
+      quality: A.startingQuality(this.quality),
+      poorSamples: 0,
+      goodSamples: 0,
+      samplesSeen: 0,
+      counters: null
+    };
+    this.peers.set(e.participantId, s);
+    for (const o of this.localStream?.getAudioTracks() ?? []) i.addTrack(o, this.localStream);
+    const a = this.screenStream?.getVideoTracks().some((o) => o.readyState === "live") ? this.screenStream : this.localStream, r = a?.getVideoTracks()[0];
+    return r && a && (s.videoSender = i.addTrack(r, a)), !this.localStream?.getAudioTracks().length && this.options.receiveAudio && i.addTransceiver("audio", { direction: "recvonly" }), !r && this.options.receiveVideo && (s.videoTransceiver = i.addTransceiver("video", { direction: "recvonly" }), s.videoSender = s.videoTransceiver.sender), this.applyCodecPreference(i), this.applyVideoQuality(i), i.addEventListener("icecandidate", (o) => {
+      o.candidate && this.send({ type: "rtc.ice", targetParticipantId: e.participantId, candidate: o.candidate.toJSON() });
+    }), i.addEventListener("track", (o) => {
+      n.getTracks().some((l) => l.id === o.track.id) || n.addTrack(o.track), this.options.onEvent("remotestream", { participant: e, stream: n, track: o.track });
+    }), i.addEventListener("connectionstatechange", () => {
+      ["failed", "closed"].includes(i.connectionState) && this.removePeer(e.participantId), this.options.onEvent("peerconnectionstate", { participant: e, state: i.connectionState });
+    }), s;
+  }
+  async createOffer(e) {
+    const t = this.ensurePeer(e);
+    if (t.offerTask) return t.offerTask;
+    if (t.connection.signalingState !== "stable") return;
+    const i = this.performOffer(t);
+    t.offerTask = i;
+    try {
+      await i;
+    } finally {
+      t.offerTask === i && (t.offerTask = null);
+    }
+  }
+  async performOffer(e) {
+    e.makingOffer = !0;
+    try {
+      const t = await e.connection.createOffer({
+        offerToReceiveAudio: this.options.receiveAudio,
+        offerToReceiveVideo: this.options.receiveVideo
+      });
+      if (e.connection.signalingState !== "stable") return;
+      await e.connection.setLocalDescription(t);
+      const i = L();
+      e.activeNegotiationId = i, this.send({
+        type: "rtc.offer",
+        targetParticipantId: e.identity.participantId,
+        negotiationId: i,
+        description: e.connection.localDescription
+      });
+    } finally {
+      e.makingOffer = !1;
+    }
+  }
+  shouldInitiateOffer(e) {
+    return this.options.credential.participantId.localeCompare(e.participantId) < 0;
+  }
+  async renegotiateAll() {
+    for (const e of this.peers.values()) await this.createOffer(e.identity);
+  }
+  async replaceVideoTrack(e) {
+    let t = !1;
+    for (const i of this.peers.values()) {
+      const n = i.videoSender ?? i.connection.getSenders().find((a) => a.track?.kind === "video") ?? i.connection.getTransceivers().find((a) => a.receiver.track.kind === "video")?.sender, s = i.videoTransceiver ?? i.connection.getTransceivers().find((a) => a.sender === n);
+      if (n) {
+        const a = e ? this.options.receiveVideo ? "sendrecv" : "sendonly" : this.options.receiveVideo ? "recvonly" : "inactive";
+        s && s.direction !== a && (s.direction = a, t = !0), await n.replaceTrack(e), i.videoSender = n, s && (i.videoTransceiver = s);
+      } else e && (i.videoSender = i.connection.addTrack(e, this.screenStream ?? this.localStream ?? new MediaStream([e])), t = !0);
+    }
+    t && await this.renegotiateAll(), await this.applyVideoQuality();
+  }
+  async applyVideoQuality(e) {
+    const t = e ? [...this.peers.values()].filter((i) => i.connection === e) : [...this.peers.values()];
+    for (const i of t) await this.applyPeerVideoQuality(i);
+  }
+  /**
+   * Applies this connection's own tier. The room-wide setting is a ceiling
+   * rather than an instruction: asking for audio keeps every link on audio, but
+   * asking for high lets each link settle wherever it can actually hold.
+   */
+  async applyPeerVideoQuality(e) {
+    const t = this.screenStream?.getVideoTracks()[0]?.id;
+    for (const i of e.connection.getSenders().filter((n) => n.track?.kind === "video")) {
+      const n = !!(t && i.track?.id === t), s = n ? ne : this.quality === "audio" ? ie.audio : f[e.quality], a = i.getParameters(), r = a.encodings?.length ? a.encodings : [{}];
+      a.encodings = r.map((o) => ({ ...o, ...s })), a.degradationPreference = n ? "maintain-resolution" : "maintain-framerate", await i.setParameters(a);
+    }
+  }
+  startQualitySampling() {
+    this.stopQualitySampling(), this.qualityTimer = setInterval(() => {
+      this.samplePeerQuality();
+    }, 5e3), this.speakerTimer = setInterval(() => {
+      this.sampleActiveSpeaker();
+    }, 1e3);
+  }
+  stopQualitySampling() {
+    this.qualityTimer && clearInterval(this.qualityTimer), this.qualityTimer = null, this.speakerTimer && clearInterval(this.speakerTimer), this.speakerTimer = null;
+  }
+  async sampleActiveSpeaker() {
+    const e = [];
+    for (const i of [...this.peers.values()])
+      if (i.connection.connectionState === "connected")
+        try {
+          const n = await i.connection.getStats();
+          for (const s of _(n.values()))
+            e.push({ participantId: i.identity.participantId, level: s.level });
+        } catch {
+        }
+    const t = H(e, this.activeSpeaker);
+    t !== this.activeSpeaker && (this.activeSpeaker = t, this.options.onEvent("activespeaker", { participantId: t }));
+  }
+  async samplePeerQuality() {
+    if (this.quality !== "audio")
+      for (const e of [...this.peers.values()]) {
+        if (e.connection.connectionState !== "connected") continue;
+        let t;
+        try {
+          t = await e.connection.getStats();
+        } catch {
+          continue;
+        }
+        const { sample: i, counters: n } = te(t, e.counters);
+        e.counters = n;
+        const s = ee(e.quality, i, e.poorSamples, e.goodSamples, {
+          samplesSeen: e.samplesSeen,
+          ceiling: this.quality
+        });
+        e.poorSamples = s.poorSamples, e.goodSamples = s.goodSamples, e.samplesSeen = s.samplesSeen, s.changed && (e.quality = s.quality, await this.applyPeerVideoQuality(e).catch(() => {
+        }), this.options.onEvent("peerquality", { participantId: e.identity.participantId, quality: s.quality }));
+      }
+  }
+  /** A new link starts one step below the ceiling so it proves itself upward. */
+  static startingQuality(e) {
+    return e === "low" ? "low" : "medium";
+  }
+  applyCodecPreference(e) {
+    if (this.preferredVideoCodec === "auto" || !globalThis.RTCRtpReceiver?.getCapabilities) return;
+    const t = RTCRtpReceiver.getCapabilities("video")?.codecs ?? [], i = `video/${this.preferredVideoCodec}`, n = [
+      ...t.filter((s) => s.mimeType.toLowerCase() === i),
+      ...t.filter((s) => s.mimeType.toLowerCase() !== i)
+    ];
+    for (const s of e.getTransceivers())
+      s.receiver.track.kind === "video" && typeof s.setCodecPreferences == "function" && s.setCodecPreferences(n);
+  }
+  removePeer(e) {
+    const t = this.peers.get(e);
+    t && (t.connection.close(), this.peers.delete(e), this.options.onEvent("participantleft", t.identity));
+  }
+  resetPeers() {
+    for (const e of this.peers.values()) e.connection.close();
+    this.peers.clear();
+  }
+  startHeartbeat(e) {
+    this.stopHeartbeat(), this.stopQualitySampling(), this.heartbeatTimer = setInterval(() => {
+      if (!(this.socket !== e || e.readyState !== WebSocket.OPEN)) {
+        if (Date.now() > this.heartbeatDeadline) {
+          e.close(4e3, "Signaling heartbeat timed out");
+          return;
+        }
+        e.send("ping");
+      }
+    }, 2e4);
+  }
+  stopHeartbeat() {
+    this.heartbeatTimer && clearInterval(this.heartbeatTimer), this.heartbeatTimer = null;
+  }
+  clearConnectionTimers() {
+    this.stopHeartbeat(), this.stopQualitySampling(), this.reconnectTimer && clearTimeout(this.reconnectTimer), this.reconnectTimer = null;
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer || this.stopped) return;
+    const e = Math.min(3e4, 1e3 * 2 ** Math.min(this.reconnectAttempt, 5)) + Math.round(Math.random() * 300);
+    this.reconnectAttempt += 1, this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null, this.openSocket(!0).catch((t) => {
+        this.options.onEvent("signalingerror", { message: t instanceof Error ? t.message : "RTC signaling connection failed" }), this.scheduleReconnect();
+      });
+    }, e);
+  }
+  send(e) {
+    this.socket?.readyState === WebSocket.OPEN && this.socket.send(JSON.stringify({
+      clientMessageId: e.clientMessageId ?? L(),
+      ...e
+    }));
+  }
+  stopStream(e) {
+    for (const t of e?.getTracks() ?? []) t.stop();
+  }
+}
+function L() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+const M = { active: !0, maxBitrate: 4e6, maxFramerate: 30, scaleResolutionDownBy: 1 }, j = [
+  { rid: "a", maxBitrate: f.high.maxBitrate, maxFramerate: f.high.maxFramerate },
+  { rid: "b", maxBitrate: f.medium.maxBitrate, maxFramerate: f.medium.maxFramerate, scaleResolutionDownBy: 2 },
+  { rid: "c", maxBitrate: f.low.maxBitrate, maxFramerate: f.low.maxFramerate, scaleResolutionDownBy: 4 }
+], O = { high: "a", medium: "b", low: "c" };
+class se {
+  options;
+  apiBase;
+  socket = null;
+  connection = null;
+  sessionId = null;
+  localStream = null;
+  screenStream = null;
+  remotes = /* @__PURE__ */ new Map();
+  midToParticipant = /* @__PURE__ */ new Map();
+  // Announcements can arrive while our own session is still being created —
+  // existing publishers re-announce the moment they see our join — and must
+  // not be dropped, because nobody will repeat them. Keyed by participant so
+  // a duplicate replaces rather than queues: processing the same announcement
+  // twice used to race the first subscribe and draw an SFU 406.
+  pendingAnnouncements = /* @__PURE__ */ new Map();
+  videoSender = null;
+  joined = !1;
+  stopped = !1;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  heartbeatDeadline = 0;
+  speakerTimer = null;
+  activeSpeaker = null;
+  quality;
+  resolveJoin = null;
+  rejectJoin = null;
+  signalQueue = Promise.resolve();
+  negotiationQueue = Promise.resolve();
+  socketGeneration = 0;
+  constructor(e) {
+    this.options = e, this.localStream = e.localStream ?? null, this.quality = e.quality ?? "high", this.apiBase = new URL(e.credential.signalingUrl, globalThis.location?.href).origin;
+  }
+  async initialize() {
+    if (!globalThis.RTCPeerConnection || !globalThis.WebSocket)
+      throw new Error("This browser does not support WebRTC");
+  }
+  async join() {
+    if (this.joined) return;
+    const { credential: e } = this.options;
+    if (!e.signalingToken || !e.signalingUrl || !e.roomId || !e.participantId)
+      throw new Error("A room signaling credential is required");
+    this.stopped = !1, !this.localStream && (this.options.audio || this.options.video) && (this.localStream = await navigator.mediaDevices.getUserMedia({ audio: this.options.audio, video: this.options.video })), this.localStream && this.options.onEvent("localstream", { stream: this.localStream }), await this.openSocket(!1), await this.publish(), this.startSpeakerSampling(), this.announceTracks();
+    const t = [...this.pendingAnnouncements.values()];
+    this.pendingAnnouncements.clear();
+    for (const i of t)
+      await this.handleTrackAnnouncement(i.sender, i.detail);
+  }
+  async leave() {
+    this.stopped = !0, this.clearTimers(), this.send({ type: "rtc.leave" }), this.joined = !1, this.socket?.close(1e3, "Participant left"), this.socket = null, await this.closePublishedTracks().catch(() => {
+    }), this.connection?.close(), this.connection = null, this.sessionId = null, this.remotes.clear(), this.midToParticipant.clear(), this.stopStream(this.localStream), this.stopStream(this.screenStream), this.localStream = null, this.screenStream = null;
+  }
+  setMuted(e) {
+    for (const t of this.localStream?.getAudioTracks() ?? []) t.enabled = !e;
+  }
+  async setCameraEnabled(e) {
+    if (e && !this.localStream?.getVideoTracks().length) {
+      const i = (await navigator.mediaDevices.getUserMedia({ video: { width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } } })).getVideoTracks()[0];
+      if (!i) throw new Error("Camera is unavailable");
+      this.localStream || (this.localStream = new MediaStream()), this.localStream.addTrack(i), this.screenStream?.getVideoTracks().some((n) => n.readyState === "live") || await this.replaceVideoTrack(i);
+      return;
+    }
+    for (const t of this.localStream?.getVideoTracks() ?? []) t.enabled = e;
+  }
+  async setScreenShareEnabled(e) {
+    if (!e) {
+      const n = this.screenStream;
+      this.screenStream = null, this.stopStream(n);
+      const s = this.localStream?.getVideoTracks()[0] ?? null;
+      await this.replaceVideoTrack(s), this.options.onEvent("screensharechange", { enabled: !1, stream: null });
+      return;
+    }
+    if (this.screenStream?.getVideoTracks()[0]?.readyState === "live") return;
+    const t = await navigator.mediaDevices.getDisplayMedia({
+      video: { width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } },
+      audio: !1
+    }), i = t.getVideoTracks()[0];
+    if (!i) throw new Error("Screen sharing is unavailable");
+    i.contentHint = "detail", this.screenStream = t, i.addEventListener("ended", () => {
+      this.screenStream?.getVideoTracks()[0]?.id === i.id && this.setScreenShareEnabled(!1);
+    });
+    try {
+      await this.replaceVideoTrack(i), this.options.onEvent("screensharechange", { enabled: !0, stream: t });
+    } catch (n) {
+      throw this.screenStream = null, this.stopStream(t), n;
+    }
+  }
+  async setDevice(e) {
+    const t = { deviceId: { exact: e.deviceId } }, i = await navigator.mediaDevices.getUserMedia(e.kind === "audioinput" ? { audio: t } : { video: { ...t, width: { ideal: 1920 }, height: { ideal: 1080 }, frameRate: { ideal: 30, max: 30 } } }), n = e.kind === "audioinput" ? i.getAudioTracks()[0] : i.getVideoTracks()[0];
+    if (!n) throw new Error("Selected media device is unavailable");
+    const s = e.kind === "audioinput" ? "audio" : "video", a = this.localStream?.getTracks().find((o) => o.kind === s);
+    if (this.localStream || (this.localStream = new MediaStream()), a && (this.localStream.removeTrack(a), a.stop()), this.localStream.addTrack(n), s === "video") {
+      this.screenStream?.getVideoTracks().some((o) => o.readyState === "live") || await this.replaceVideoTrack(n);
+      return;
+    }
+    const r = this.connection?.getSenders().find((o) => o.track?.kind === "audio");
+    r && await r.replaceTrack(n);
+  }
+  /** One uplink serves everyone, so the requested quality applies directly. */
+  async setQuality(e) {
+    this.quality = e;
+    for (const t of this.localStream?.getVideoTracks() ?? []) t.enabled = e !== "audio";
+    await this.applyVideoQuality();
+  }
+  async setPreferredVideoCodec(e) {
+  }
+  async setVideoTrack(e) {
+    if (e.kind !== "video") throw new Error("A video track is required");
+    this.localStream || (this.localStream = new MediaStream());
+    const t = this.localStream.getVideoTracks()[0];
+    t?.id !== e.id && (t && this.localStream.removeTrack(t), this.localStream.addTrack(e)), await this.replaceVideoTrack(e), this.options.onEvent("localstream", { stream: this.localStream, track: e });
+  }
+  getParticipants() {
+    return [...this.remotes.values()].map((e) => e.identity);
+  }
+  getLocalStream() {
+    return this.localStream;
+  }
+  getRemoteStreams() {
+    return [...this.remotes.values()].map((e) => ({ participant: e.identity, stream: e.stream }));
+  }
+  getPrimaryPeerConnection() {
+    return this.connection;
+  }
+  sendChat(e, t) {
+    this.send({ type: "rtc.chat", message: e, participantIds: t ?? [] });
+  }
+  sendControl(e, t = {}) {
+    this.send({ type: "rtc.control", action: e, detail: t });
+  }
+  // --- signaling -----------------------------------------------------------
+  async openSocket(e) {
+    const { credential: t } = this.options, i = new URL(t.signalingUrl, globalThis.location?.href);
+    i.protocol = i.protocol === "https:" ? "wss:" : "ws:";
+    const n = new Promise((o, l) => {
+      this.resolveJoin = o, this.rejectJoin = l;
+    }), s = new WebSocket(i, ["rtc-client", t.signalingToken]), a = ++this.socketGeneration;
+    this.socket = s;
+    const r = setTimeout(() => this.rejectJoin?.(new Error("RTC signaling timed out")), 15e3);
+    s.addEventListener("open", () => {
+      this.heartbeatDeadline = Date.now() + 45e3, this.startHeartbeat(s), this.send({ type: "rtc.room.join" });
+    }), s.addEventListener("message", (o) => {
+      const l = String(o.data);
+      this.signalQueue = this.signalQueue.then(async () => {
+        this.socket !== s || this.socketGeneration !== a || await this.handleSignal(l);
+      }).catch((d) => {
+        const u = d instanceof Error ? d.message : "RTC signaling processing failed";
+        this.options.onEvent("signalingerror", { message: u }), this.joined || this.rejectJoin?.(new Error(u));
+      });
+    }), s.addEventListener("error", () => this.rejectJoin?.(new Error("RTC signaling connection failed"))), s.addEventListener("close", (o) => {
+      if (this.socket !== s) return;
+      this.socket = null, this.stopHeartbeat(), !this.joined && !e && this.rejectJoin?.(new Error(o.reason || "RTC signaling connection closed"));
+      const l = !this.stopped && (this.joined || e);
+      this.joined = !1, l ? (this.options.onEvent("reconnecting", { reason: o.reason, code: o.code, attempt: this.reconnectAttempt + 1 }), this.scheduleReconnect()) : this.stopped || this.options.onEvent("disconnected", { reason: o.reason, code: o.code });
+    });
+    try {
+      await n, this.joined = !0, this.options.onEvent("connected", { participantId: t.participantId, resumed: e });
+    } finally {
+      clearTimeout(r), this.resolveJoin = null, this.rejectJoin = null;
+    }
+  }
+  async handleSignal(e) {
+    let t;
+    try {
+      t = JSON.parse(e);
+    } catch {
+      return;
+    }
+    const i = String(t.type ?? "");
+    if (i !== "ready") {
+      if (i === "pong") {
+        this.heartbeatDeadline = Date.now() + 45e3;
+        return;
+      }
+      if (i === "rtc.room.peers") {
+        this.reconnectAttempt = 0, this.resolveJoin?.();
+        return;
+      }
+      if (i === "rtc.room.join" && t.sender) {
+        this.options.onEvent("participantjoined", t.sender), this.sessionId && this.announceTracks();
+        return;
+      }
+      if ((i === "rtc.peer.left" || i === "rtc.leave") && t.sender) {
+        this.removeRemote(t.sender.participantId);
+        return;
+      }
+      if (i === "rtc.control") {
+        if (String(t.action ?? "") === "sfu.tracks" && t.sender) {
+          await this.handleTrackAnnouncement(t.sender, t.detail);
+          return;
+        }
+        this.options.onEvent("control", t);
+        return;
+      }
+      i === "rtc.chat" && this.options.onEvent("chatupdate", t);
+    }
+  }
+  // --- SFU media -----------------------------------------------------------
+  async publish() {
+    const e = [
+      ...this.localStream?.getAudioTracks() ?? [],
+      ...this.localStream?.getVideoTracks() ?? []
+    ], t = new RTCPeerConnection({
+      iceServers: this.options.credential.iceServers ?? [],
+      iceTransportPolicy: this.options.iceTransportPolicy ?? "all"
+    });
+    this.connection = t, t.addEventListener("track", (r) => this.handleRemoteTrack(r)), t.addEventListener("connectionstatechange", () => {
+      this.options.onEvent("peerconnectionstate", { participant: this.selfIdentity(), state: t.connectionState });
+    });
+    const i = await this.sfuFetch("POST", "/v1/rtc/sfu/sessions");
+    if (this.sessionId = i.sessionId, e.length === 0) return;
+    const n = e.map((r) => t.addTransceiver(r, {
+      direction: "sendonly",
+      streams: this.localStream ? [this.localStream] : [],
+      ...r.kind === "video" ? { sendEncodings: j.map((o) => ({ ...o })) } : {}
+    })), s = await t.createOffer();
+    await t.setLocalDescription(s);
+    const a = await this.sfuFetch(
+      "POST",
+      `/v1/rtc/sfu/sessions/${encodeURIComponent(i.sessionId)}/tracks`,
+      {
+        sessionDescription: t.localDescription,
+        tracks: n.map((r) => ({
+          location: "local",
+          mid: r.mid,
+          trackName: this.trackName(r.sender.track)
+        }))
+      }
+    );
+    a.sessionDescription && await t.setRemoteDescription(a.sessionDescription), this.videoSender = t.getSenders().find((r) => r.track?.kind === "video") ?? null, await this.applyVideoQuality();
+  }
+  trackName(e) {
+    return `${this.options.credential.participantId}/${e.kind}`;
+  }
+  announceTracks() {
+    if (!this.sessionId) return;
+    const e = [
+      ...(this.localStream?.getAudioTracks() ?? []).map((t) => ({ trackName: this.trackName(t), kind: t.kind, simulcast: !1 })),
+      ...(this.localStream?.getVideoTracks() ?? []).map((t) => ({ trackName: this.trackName(t), kind: t.kind, simulcast: !0 }))
+    ];
+    e.length !== 0 && this.sendControl("sfu.tracks", { sessionId: this.sessionId, tracks: e });
+  }
+  async handleTrackAnnouncement(e, t) {
+    const i = String(t?.sessionId ?? ""), n = (t?.tracks ?? []).map((r) => ({ trackName: String(r.trackName ?? ""), simulcast: r.simulcast === !0 })).filter((r) => !!r.trackName), s = n.map((r) => r.trackName);
+    if (!i || s.length === 0 || e.participantId === this.options.credential.participantId) return;
+    if (!this.connection || !this.sessionId) {
+      this.pendingAnnouncements.set(e.participantId, { sender: e, detail: t ?? {} });
+      return;
+    }
+    const a = this.remotes.get(e.participantId) ?? {
+      identity: e,
+      stream: new MediaStream(),
+      sessionId: i,
+      trackNames: [],
+      simulcastNames: /* @__PURE__ */ new Set(),
+      mids: /* @__PURE__ */ new Map()
+    };
+    a.sessionId = i;
+    for (const r of n)
+      r.simulcast && a.simulcastNames.add(r.trackName);
+    this.remotes.set(e.participantId, a), this.negotiationQueue = this.negotiationQueue.then(async () => {
+      const r = s.filter((o) => !a.trackNames.includes(o));
+      r.length !== 0 && await this.subscribe(a, r);
+    }).catch((r) => {
+      this.options.onEvent("signalingerror", { message: r instanceof Error ? r.message : "SFU subscribe failed" });
+    }), await this.negotiationQueue;
+  }
+  async subscribe(e, t) {
+    const i = this.connection;
+    if (!i || !this.sessionId || t.length === 0) return;
+    const n = await this.sfuFetch("POST", `/v1/rtc/sfu/sessions/${encodeURIComponent(this.sessionId)}/tracks`, {
+      tracks: t.map((s) => ({
+        location: "remote",
+        sessionId: e.sessionId,
+        trackName: s,
+        // Start on the full layer and let the SFU fall down the alphabet when
+        // it is not available; a deliberate switch goes through
+        // setRemoteQuality instead.
+        ...e.simulcastNames.has(s) ? { simulcast: { preferredRid: "a", priorityOrdering: "asciibetical", ridNotAvailable: "asciibetical" } } : {}
+      }))
+    });
+    for (const s of n.tracks ?? [])
+      s.mid && (e.mids.set(s.mid, String(s.trackName ?? "")), this.midToParticipant.set(s.mid, e.identity.participantId));
+    if (e.trackNames = [.../* @__PURE__ */ new Set([...e.trackNames, ...t])], n.requiresImmediateRenegotiation && n.sessionDescription) {
+      await i.setRemoteDescription(n.sessionDescription);
+      const s = await i.createAnswer();
+      await i.setLocalDescription(s), await this.sfuFetch("PUT", `/v1/rtc/sfu/sessions/${encodeURIComponent(this.sessionId)}/renegotiate`, {
+        sessionDescription: i.localDescription
+      });
+    }
+  }
+  handleRemoteTrack(e) {
+    const t = e.transceiver?.mid ?? null, i = t ? this.midToParticipant.get(t) : void 0, n = i ? this.remotes.get(i) : void 0;
+    n && (n.stream.getTracks().some((s) => s.id === e.track.id) || n.stream.addTrack(e.track), this.options.onEvent("remotestream", { participant: n.identity, stream: n.stream, track: e.track }));
+  }
+  removeRemote(e) {
+    const t = this.remotes.get(e);
+    if (t) {
+      for (const i of t.mids.keys()) this.midToParticipant.delete(i);
+      this.remotes.delete(e), this.options.onEvent("participantleft", t.identity);
+    }
+  }
+  /**
+   * Switches which simulcast layer the SFU forwards for one participant's
+   * video — for example a thumbnail tile has no use for 720p. This changes
+   * only what this client receives; the publisher keeps sending every layer.
+   */
+  async setRemoteQuality(e, t) {
+    const i = this.remotes.get(e);
+    if (!i || !this.sessionId) return;
+    const n = [...i.mids.entries()].find(([, s]) => i.simulcastNames.has(s))?.[0];
+    n && await this.sfuFetch("PUT", `/v1/rtc/sfu/sessions/${encodeURIComponent(this.sessionId)}/tracks/update`, {
+      tracks: [{
+        mid: n,
+        simulcast: { preferredRid: O[t], priorityOrdering: "asciibetical", ridNotAvailable: "asciibetical" }
+      }]
+    });
+  }
+  async replaceVideoTrack(e) {
+    this.videoSender && (await this.videoSender.replaceTrack(e), await this.applyVideoQuality());
+  }
+  async applyVideoQuality() {
+    const e = this.videoSender;
+    if (!e) return;
+    const t = this.screenStream?.getVideoTracks()[0]?.id, i = !!(t && e.track?.id === t), n = e.getParameters(), s = n.encodings?.length ? n.encodings : [{}];
+    if (s.length > 1) {
+      const a = this.quality === "audio" ? null : O[this.quality];
+      n.encodings = s.map((r) => {
+        if (i)
+          return { ...r, active: r.rid === "a", ...r.rid === "a" ? { maxBitrate: M.maxBitrate, maxFramerate: M.maxFramerate } : {} };
+        const o = j.find((d) => d.rid === r.rid), l = a != null && String(r.rid ?? "") >= a;
+        return { ...r, ...o ?? {}, active: l };
+      });
+    } else {
+      const a = this.quality === "audio" ? f.audio : f[this.quality], r = i ? M : a;
+      n.encodings = s.map((o) => ({ ...o, ...r }));
+    }
+    n.degradationPreference = i ? "maintain-resolution" : "maintain-framerate", await e.setParameters(n);
+  }
+  async closePublishedTracks() {
+    const e = this.connection;
+    if (!e || !this.sessionId) return;
+    const t = e.getTransceivers().filter((i) => i.sender.track && i.mid).map((i) => ({ mid: i.mid }));
+    t.length !== 0 && await this.sfuFetch("PUT", `/v1/rtc/sfu/sessions/${encodeURIComponent(this.sessionId)}/tracks/close`, {
+      tracks: t,
+      force: !0
+    });
+  }
+  selfIdentity() {
+    return {
+      participantId: this.options.credential.participantId,
+      externalUserId: this.options.credential.externalUserId ?? this.options.credential.participantId,
+      displayName: this.options.credential.externalUserId ?? this.options.credential.participantId,
+      platform: "web"
+    };
+  }
+  async sfuFetch(e, t, i) {
+    const n = await fetch(`${this.apiBase}${t}`, {
+      method: e,
+      headers: {
+        authorization: `Bearer ${this.options.credential.signalingToken}`,
+        "content-type": "application/json"
+      },
+      body: i === void 0 ? void 0 : JSON.stringify(i)
+    });
+    if (!n.ok) throw new Error(`SFU request failed with HTTP ${n.status}`);
+    return n.json();
+  }
+  // --- plumbing shared with the mesh ---------------------------------------
+  startHeartbeat(e) {
+    this.stopHeartbeat(), this.heartbeatTimer = setInterval(() => {
+      if (!(this.socket !== e || e.readyState !== WebSocket.OPEN)) {
+        if (Date.now() > this.heartbeatDeadline) {
+          e.close(4e3, "Signaling heartbeat timed out");
+          return;
+        }
+        e.send("ping");
+      }
+    }, 2e4);
+  }
+  stopHeartbeat() {
+    this.heartbeatTimer && clearInterval(this.heartbeatTimer), this.heartbeatTimer = null;
+  }
+  startSpeakerSampling() {
+    this.stopSpeakerSampling(), this.speakerTimer = setInterval(() => {
+      this.sampleActiveSpeaker();
+    }, 1e3);
+  }
+  stopSpeakerSampling() {
+    this.speakerTimer && clearInterval(this.speakerTimer), this.speakerTimer = null;
+  }
+  async sampleActiveSpeaker() {
+    const e = this.connection;
+    if (!e || e.connectionState !== "connected") return;
+    let t;
+    try {
+      t = await e.getStats();
+    } catch {
+      return;
+    }
+    const i = [];
+    for (const s of _(t.values())) {
+      const a = s.mid ? this.midToParticipant.get(s.mid) : void 0;
+      a && i.push({ participantId: a, level: s.level });
+    }
+    const n = H(i, this.activeSpeaker);
+    n !== this.activeSpeaker && (this.activeSpeaker = n, this.options.onEvent("activespeaker", { participantId: n }));
+  }
+  clearTimers() {
+    this.stopHeartbeat(), this.stopSpeakerSampling(), this.reconnectTimer && clearTimeout(this.reconnectTimer), this.reconnectTimer = null;
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer || this.stopped) return;
+    const e = Math.min(3e4, 1e3 * 2 ** Math.min(this.reconnectAttempt, 5)) + Math.round(Math.random() * 300);
+    this.reconnectAttempt += 1, this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null, this.openSocket(!0).then(() => this.announceTracks()).catch((t) => {
+        this.options.onEvent("signalingerror", { message: t instanceof Error ? t.message : "RTC signaling connection failed" }), this.scheduleReconnect();
+      });
+    }, e);
+  }
+  send(e) {
+    this.socket?.readyState === WebSocket.OPEN && this.socket.send(JSON.stringify({
+      clientMessageId: e.clientMessageId ?? ae(),
+      ...e
+    }));
+  }
+  stopStream(e) {
+    for (const t of e?.getTracks() ?? []) t.stop();
+  }
+}
+function ae() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function ve(c, e = {}) {
+  const t = e.document ?? globalThis.document, i = !!(t && t.pictureInPictureEnabled);
+  let n = null;
+  function s() {
+    return n || (n = t.createElement("video"), n.muted = !0, n.playsInline = !0, n.style.position = "fixed", n.style.width = "1px", n.style.height = "1px", n.style.opacity = "0", n.style.pointerEvents = "none", n.addEventListener("leavepictureinpicture", () => e.onLeave?.()), t.body.appendChild(n), n);
+  }
+  function a(r) {
+    const o = c.getRemoteStreams();
+    return r ? o.find((l) => l.participant.participantId === r)?.stream ?? null : o[0]?.stream ?? c.getLocalStream();
+  }
+  return {
+    supported: i,
+    async enter(r) {
+      if (!i) throw new Error("This browser does not support picture-in-picture");
+      const o = a(r);
+      if (!o) throw new Error("No video stream is available for picture-in-picture");
+      const l = s();
+      l.srcObject !== o && (l.srcObject = o), await l.play().catch(() => {
+      }), await l.requestPictureInPicture();
+    },
+    async exit() {
+      t.pictureInPictureElement && typeof t.exitPictureInPicture == "function" && await t.exitPictureInPicture();
+    },
+    dispose() {
+      n?.remove(), n = null;
+    }
+  };
+}
+class re extends EventTarget {
+  mode;
+  options;
+  client = null;
+  peerConnection;
+  state = "initialized";
+  latestMediaScore = null;
+  latestQuality = null;
+  statsTimer = null;
+  statsRunning = !1;
+  previousCounters = null;
+  lastTelemetryAt = 0;
+  joinPromise = null;
+  requestedQuality;
+  effectiveQuality;
+  poorQualitySamples = 0;
+  goodQualitySamples = 0;
+  constructor(e) {
+    if (super(), !e.credential?.signalingToken || !e.credential.signalingUrl || !e.credential.roomId || !e.credential.participantId)
+      throw new Error("A valid room signaling credential is required");
+    this.mode = e.mode, this.requestedQuality = e.mode === "voice" ? "audio" : e.quality ?? "auto", this.effectiveQuality = this.requestedQuality === "auto" ? "medium" : this.requestedQuality, this.peerConnection = e.peerConnection ?? null, this.options = {
+      ...e,
+      audio: e.audio ?? !0,
+      video: e.mode === "voice" ? !1 : e.video ?? !0,
+      receiveAudio: e.receiveAudio ?? !0,
+      receiveVideo: e.mode === "voice" ? !1 : e.receiveVideo ?? !0,
+      statsInterval: Math.max(1e3, e.statsInterval ?? 5e3),
+      telemetryInterval: Math.max(1e4, e.telemetryInterval ?? 3e4),
+      autoReportStats: e.autoReportStats ?? !0
+    };
+  }
+  async initialize() {
+    if (this.client) return this;
+    try {
+      const t = (this.options.transport === "auto" ? this.mode === "meeting" ? "sfu" : "mesh" : this.options.transport ?? "mesh") === "sfu" ? se : A;
+      return this.client = new t({
+        credential: {
+          signalingToken: this.options.credential.signalingToken,
+          signalingUrl: this.options.credential.signalingUrl,
+          roomId: this.options.credential.roomId,
+          participantId: this.options.credential.participantId,
+          externalUserId: this.options.credential.externalUserId,
+          iceServers: this.options.credential.iceServers
+        },
+        audio: this.options.audio,
+        video: this.options.video,
+        receiveAudio: this.options.receiveAudio,
+        receiveVideo: this.options.receiveVideo,
+        quality: this.effectiveQuality,
+        preferredVideoCodec: this.options.preferredVideoCodec ?? "auto",
+        iceTransportPolicy: this.options.iceTransportPolicy ?? "all",
+        localStream: this.options.localStream,
+        onEvent: (i, n) => this.handleNativeEvent(i, n)
+      }), await this.client.initialize(), this.startStats(), this.emit("initialized", { mode: this.mode, sdkVersion: pe }), this.options.autoJoin && await this.join(), this;
+    } catch (e) {
+      this.state = "failed";
+      const t = z(e, "RTC initialization failed");
+      throw this.emit("error", g(t)), t;
+    }
+  }
+  async join() {
+    const e = this.requireClient();
+    return this.joinPromise ? this.joinPromise : (this.state = "joining", this.emit("joining", {}), this.joinPromise = e.join().catch((t) => {
+      this.state = "failed";
+      const i = z(t, "RTC connection failed");
+      throw this.emit("error", g(i)), i;
+    }).finally(() => {
+      this.joinPromise = null;
+    }), this.joinPromise);
+  }
+  async leave() {
+    this.client && (await this.joinPromise?.catch(() => {
+    }), await this.sampleAndReport("final").catch(() => {
+    }), await this.client.leave(), this.state = "disconnected", this.stopStats());
+  }
+  async setMuted(e) {
+    this.requireClient().setMuted(e), this.emit("mediachange", { kind: "audio", enabled: !e });
+  }
+  async setCameraEnabled(e) {
+    if (this.mode === "voice" && e) throw new Error("Camera is unavailable in voice mode");
+    await this.requireClient().setCameraEnabled(e), this.emit("mediachange", { kind: "video", enabled: e });
+  }
+  async setVideoTrack(e) {
+    if (this.mode === "voice") throw new Error("Camera is unavailable in voice mode");
+    await this.requireClient().setVideoTrack(e), this.emit("mediachange", { kind: "video", enabled: e.enabled, trackId: e.id });
+  }
+  async setScreenShareEnabled(e) {
+    await this.requireClient().setScreenShareEnabled(e), this.emit("mediachange", { kind: "screenshare", enabled: e });
+  }
+  async setDevice(e) {
+    await this.requireClient().setDevice(e), this.emit("devicechange", { deviceId: e.deviceId, kind: e.kind });
+  }
+  async setQuality(e) {
+    if (this.mode === "voice" && e !== "audio") throw new Error("Voice calls only support audio quality");
+    this.requestedQuality = e, this.poorQualitySamples = 0, this.goodQualitySamples = 0, await this.applyEffectiveQuality(e === "auto" ? "medium" : e, "manual");
+  }
+  async setPreferredVideoCodec(e) {
+    await this.requireClient().setPreferredVideoCodec(e), this.emit("codecchange", { preferredVideoCodec: e });
+  }
+  async getDevices() {
+    return navigator.mediaDevices?.enumerateDevices ? navigator.mediaDevices.enumerateDevices() : [];
+  }
+  getParticipants() {
+    return this.requireClient().getParticipants().map(F);
+  }
+  getLocalStream() {
+    return this.client?.getLocalStream() ?? null;
+  }
+  getRemoteStreams() {
+    return (this.client?.getRemoteStreams() ?? []).map((e) => ({
+      participant: F(e.participant),
+      stream: e.stream
+    }));
+  }
+  setPeerConnection(e) {
+    this.peerConnection = e, this.previousCounters = null;
+  }
+  async sendChatMessage(e, t) {
+    const i = e.trim();
+    if (!i) throw new Error("message is required");
+    this.requireClient().sendChat(i, t);
+  }
+  async sendControlMessage(e, t = {}) {
+    const i = e.trim();
+    if (!i) throw new Error("action is required");
+    this.requireClient().sendControl(i, t);
+  }
+  async createPoll(e, t, i = {}) {
+    const n = t.map((s) => s.trim()).filter(Boolean);
+    if (!e.trim() || n.length < 2) throw new Error("A poll requires a question and at least two options");
+    this.requireClient().sendControl("poll.create", {
+      poll: {
+        id: `poll-${crypto.randomUUID()}`,
+        question: e.trim(),
+        options: n,
+        votes: {},
+        ...i
+      }
+    });
+  }
+  async votePoll(e, t) {
+    this.requireClient().sendControl("poll.vote", { pollId: e, optionIndex: t });
+  }
+  async requestStageAccess() {
+    this.requireClient().sendControl("stage.request");
+  }
+  async cancelStageAccess() {
+    this.requireClient().sendControl("stage.cancel");
+  }
+  async joinStage() {
+    this.requireClient().sendControl("stage.join");
+  }
+  async leaveStage() {
+    this.requireClient().sendControl("stage.leave");
+  }
+  async grantStageAccess(e) {
+    this.requireClient().sendControl("stage.grant", { participantIds: e });
+  }
+  async denyStageAccess(e) {
+    this.requireClient().sendControl("stage.deny", { participantIds: e });
+  }
+  async startRecording(e = !1) {
+    this.requireClient().sendControl("recording.start", { allowMultiple: e });
+  }
+  async stopRecording(e) {
+    this.requireClient().sendControl("recording.stop", { recordingId: e });
+  }
+  async pauseRecording(e) {
+    this.requireClient().sendControl("recording.pause", { recordingId: e });
+  }
+  async resumeRecording(e) {
+    this.requireClient().sendControl("recording.resume", { recordingId: e });
+  }
+  async runPreflight(e = {}) {
+    const t = [], i = globalThis.isSecureContext === !0;
+    i || t.push("secure_context_required");
+    let n = "unavailable";
+    if (e.requestMedia !== !1 && navigator.mediaDevices?.getUserMedia)
+      try {
+        (await navigator.mediaDevices.getUserMedia({ audio: this.options.audio, video: this.options.video })).getTracks().forEach((m) => m.stop()), n = "granted";
+      } catch {
+        n = "denied", t.push("media_permission_denied");
+      }
+    const s = navigator.mediaDevices?.enumerateDevices ? await navigator.mediaDevices.enumerateDevices().catch(() => []) : [], a = s.filter((u) => u.kind === "audioinput").length, r = s.filter((u) => u.kind === "videoinput").length;
+    this.options.audio && a === 0 && t.push("microphone_unavailable"), this.options.video && r === 0 && t.push("camera_unavailable");
+    const o = e.probeUrl ?? this.options.preflightProbeUrl;
+    let l = null;
+    if (o) {
+      const u = performance.now();
+      try {
+        const m = await fetch(o, { method: "HEAD", cache: "no-store", credentials: "omit" });
+        l = Math.round(performance.now() - u), m.ok || t.push("network_probe_failed");
+      } catch {
+        t.push("network_probe_failed");
+      }
+    }
+    const d = {
+      passed: t.length === 0,
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      secureContext: i,
+      mediaPermission: n,
+      microphoneCount: a,
+      cameraCount: r,
+      probeLatencyMs: l,
+      effectiveConnectionType: J()?.effectiveType ?? null,
+      issues: t
+    };
+    return this.emit("preflight", d), this.options.autoReportStats && await this.reportQuality({
+      sampleType: "preflight",
+      sampledAt: d.sampledAt,
+      connectionState: d.passed ? "ready" : "failed",
+      rttMs: d.probeLatencyMs,
+      effectiveConnectionType: d.effectiveConnectionType
+    }).catch(() => {
+    }), d;
+  }
+  async collectQualitySample(e = "runtime") {
+    const t = this.options.statsProvider ? await this.options.statsProvider() : {}, i = this.peerConnection ? await he(this.peerConnection, this.previousCounters) : null;
+    i?.counters && (this.previousCounters = i.counters);
+    const s = { ...{
+      sampleType: e,
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      connectionState: this.peerConnection?.connectionState ?? this.state,
+      mediaScore: this.latestMediaScore,
+      networkScore: this.latestMediaScore == null ? 5 : Math.max(0, Math.min(5, Math.round(this.latestMediaScore))),
+      estimatedMos: 4.5,
+      rttMs: null,
+      jitterMs: null,
+      packetLossPct: null,
+      packetLossCumulativePct: null,
+      packetsLost: null,
+      packetsReceived: null,
+      inboundBitrateBps: null,
+      outboundBitrateBps: null,
+      availableOutgoingBitrateBps: null,
+      framesPerSecond: null,
+      frameWidth: null,
+      frameHeight: null,
+      framesDropped: null,
+      freezeCount: null,
+      freezeDurationMs: null,
+      concealedSamples: null,
+      codec: null,
+      transportProtocol: null,
+      candidateType: null,
+      qualityLimitationReason: null,
+      deviceMemoryGb: me(),
+      effectiveConnectionType: J()?.effectiveType ?? null
+    }, ...i?.sample ?? {}, ...t, sampleType: e, sampledAt: (/* @__PURE__ */ new Date()).toISOString() }, a = ue(s);
+    return s.networkScore = a.networkScore, s.estimatedMos = a.estimatedMos, this.latestQuality = s, s;
+  }
+  async reportQuality(e) {
+    const t = this.options.credential.telemetryToken, i = this.options.telemetryEndpoint ?? this.options.credential.telemetryEndpoint;
+    if (!t || !i) return;
+    const n = await fetch(i, {
+      method: "POST",
+      headers: { authorization: `Bearer ${t}`, "content-type": "application/json" },
+      body: JSON.stringify(e),
+      keepalive: e.sampleType === "final"
+    });
+    if (!n.ok) throw new Error(`RTC telemetry failed with HTTP ${n.status}`);
+  }
+  getStats() {
+    const e = this.client, t = e?.getLocalStream();
+    return {
+      state: this.state,
+      participantCount: e ? e.getParticipants().length + 1 : 0,
+      audioEnabled: !!t?.getAudioTracks().some((i) => i.enabled),
+      videoEnabled: !!t?.getVideoTracks().some((i) => i.enabled),
+      screenShareEnabled: !1,
+      latestMediaScore: this.latestMediaScore,
+      latestQuality: this.latestQuality,
+      sampledAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Escape hatch for advanced integrations. Prefer the stable SDK methods when possible. */
+  getNativeClient() {
+    return this.client;
+  }
+  destroy() {
+    this.stopStats(), this.client && this.client.leave(), this.client = null, this.joinPromise = null, this.peerConnection = null, this.state = "disconnected";
+  }
+  handleNativeEvent(e, t) {
+    e === "connected" ? (this.state = "connected", this.peerConnection = this.client?.getPrimaryPeerConnection() ?? null) : e === "disconnected" ? this.state = "disconnected" : e === "peerconnectionstate" && (this.peerConnection = this.client?.getPrimaryPeerConnection() ?? null), this.emit(e, t);
+  }
+  startStats() {
+    this.stopStats(), this.statsTimer = setInterval(() => {
+      this.sampleAndReport("runtime");
+    }, this.options.statsInterval);
+  }
+  async sampleAndReport(e) {
+    if (!this.statsRunning) {
+      this.statsRunning = !0;
+      try {
+        const t = await this.collectQualitySample(e);
+        await this.adaptQuality(t), this.emit("stats", { ...this.getStats(), latestQuality: t });
+        const i = Date.now(), n = e !== "runtime" || i - this.lastTelemetryAt >= this.options.telemetryInterval;
+        this.options.autoReportStats && n && (await this.reportQuality(t), this.lastTelemetryAt = i);
+      } catch (t) {
+        this.emit("telemetryerror", g(t));
+      } finally {
+        this.statsRunning = !1;
+      }
+    }
+  }
+  stopStats() {
+    this.statsTimer !== null && clearInterval(this.statsTimer), this.statsTimer = null;
+  }
+  async adaptQuality(e) {
+    if (this.requestedQuality !== "auto" || this.options.adaptiveQuality === !1 || this.mode === "voice") return;
+    if ((this.client?.getParticipants().length ?? 0) > 1) {
+      this.poorQualitySamples = 0, this.goodQualitySamples = 0, this.effectiveQuality !== "high" && await this.applyEffectiveQuality("high", "network");
+      return;
+    }
+    const t = String(e.qualityLimitationReason ?? "").toLowerCase(), i = (e.packetLossPct ?? 0) >= 8 || (e.rttMs ?? 0) >= 800 || t === "cpu" || t === "bandwidth", n = i || (e.packetLossPct ?? 0) >= 3 || (e.rttMs ?? 0) >= 350 || e.availableOutgoingBitrateBps != null && e.availableOutgoingBitrateBps < 35e4, s = (e.packetLossPct ?? 100) < 1 && (e.rttMs ?? 1e3) < 180 && !t && (e.availableOutgoingBitrateBps == null || e.availableOutgoingBitrateBps > 1e6);
+    this.poorQualitySamples = n ? this.poorQualitySamples + 1 : 0, this.goodQualitySamples = s ? this.goodQualitySamples + 1 : 0;
+    const a = ["low", "medium", "high"], r = a.indexOf(this.effectiveQuality);
+    i && r > 0 ? (this.poorQualitySamples = 0, await this.applyEffectiveQuality("low", "network")) : this.poorQualitySamples >= 2 && r > 0 ? (this.poorQualitySamples = 0, await this.applyEffectiveQuality(a[r - 1], "network")) : this.goodQualitySamples >= 6 && r >= 0 && r < a.length - 1 && (this.goodQualitySamples = 0, await this.applyEffectiveQuality(a[r + 1], "network"));
+  }
+  async applyEffectiveQuality(e, t) {
+    if (this.effectiveQuality === e && this.client) return;
+    const i = this.effectiveQuality;
+    this.effectiveQuality = e, this.client && await this.client.setQuality(e), this.emit("qualitychange", { requestedQuality: this.requestedQuality, quality: e, previous: i, reason: t });
+  }
+  requireClient() {
+    if (!this.client) throw new Error("Call initialize() before using the RTC client");
+    return this.client;
+  }
+  emit(e, t) {
+    const i = { type: e, detail: t, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    this.dispatchEvent(new CustomEvent(e, { detail: i })), this.options.onEvent?.(i);
+  }
+}
+async function ye(c) {
+  return new re(c).initialize();
+}
+let P = null;
+function W() {
+  if (P) return P;
+  const c = globalThis, e = c.AudioContext ?? c.webkitAudioContext;
+  return e ? (P = new e(), P) : null;
+}
+async function oe() {
+  const c = W();
+  return c ? (c.state === "suspended" && await c.resume().catch(() => {
+  }), c.state === "running") : !1;
+}
+class ce {
+  options;
+  media = null;
+  cadenceTimer = null;
+  oscillators = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this.options = e;
+  }
+  unlock() {
+    return oe();
+  }
+  startIncoming() {
+    this.start("incoming", this.options.ringtoneUrl);
+  }
+  startRingback() {
+    this.start("ringback", this.options.ringbackUrl);
+  }
+  stop() {
+    this.cadenceTimer && clearInterval(this.cadenceTimer), this.cadenceTimer = null, this.media?.pause(), this.media && (this.media.currentTime = 0), this.media = null;
+    for (const e of this.oscillators)
+      try {
+        e.stop();
+      } catch {
+      }
+    this.oscillators.clear();
+  }
+  start(e, t) {
+    if (this.stop(), this.options.sounds === !1) return;
+    if (t && typeof Audio < "u") {
+      this.media = new Audio(t), this.media.loop = !0, this.media.play().catch(() => {
+      });
+      return;
+    }
+    const i = () => this.playBuiltInTone(e);
+    i(), this.cadenceTimer = setInterval(i, e === "incoming" ? 3e3 : 3500);
+  }
+  playBuiltInTone(e) {
+    const t = W();
+    if (!t || t.state !== "running") return;
+    const i = e === "incoming" ? 1.25 : 1, n = e === "incoming" ? [440, 480] : [425], s = t.createGain(), a = t.currentTime;
+    s.gain.setValueAtTime(1e-4, a), s.gain.exponentialRampToValueAtTime(0.045, a + 0.025), s.gain.setValueAtTime(0.045, a + i - 0.06), s.gain.exponentialRampToValueAtTime(1e-4, a + i), s.connect(t.destination);
+    for (const r of n) {
+      const o = t.createOscillator();
+      o.type = "sine", o.frequency.value = r, o.connect(s), this.oscillators.add(o), o.onended = () => this.oscillators.delete(o), o.start(a), o.stop(a + i + 0.02);
+    }
+  }
+}
+class le extends EventTarget {
+  options;
+  socket = null;
+  stopped = !1;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  heartbeatDeadline = 0;
+  currentCall = null;
+  outgoingCallId = null;
+  mount = null;
+  terminalTimer = null;
+  tokenRefreshTimer = null;
+  tokenRequest = null;
+  currentToken;
+  currentTokenExpiresAt;
+  callAudio;
+  mediaClients = /* @__PURE__ */ new Map();
+  activeCallIds = /* @__PURE__ */ new Set();
+  seenInvitationIds = /* @__PURE__ */ new Set();
+  startCallRequest = null;
+  lastDisconnect = null;
+  constructor(e) {
+    if (super(), !e.token && !e.tokenProvider) throw new Error("A client token or tokenProvider is required");
+    if (e.token && !e.token.startsWith("rtcc_")) throw new Error("A valid RTC client token is required");
+    if (!e.signalingUrl && !e.apiBaseUrl && !globalThis.location?.origin)
+      throw new Error("signalingUrl or apiBaseUrl is required outside a browser");
+    this.options = e, this.currentToken = e.token ?? null, this.currentTokenExpiresAt = e.tokenExpiresAt, this.callAudio = new ce(e), this.mount = B(e.mount), this.scheduleTokenRefresh();
+  }
+  connect() {
+    if (!this.options.signalingUrl) throw new Error("signalingUrl is required to connect signaling");
+    return this.stopped = !1, this.scheduleTokenRefresh(), this.openSocket("initial"), this;
+  }
+  setMount(e) {
+    this.clearUi(), this.mount = B(e), this.currentCall && this.renderIncoming(this.currentCall);
+  }
+  /** Binds media lifetime to a call. Terminal call states automatically leave and destroy it. */
+  attachMediaClient(e, t) {
+    if (!e.trim()) throw new Error("callId is required");
+    return this.mediaClients.set(e, t), () => {
+      this.mediaClients.get(e) === t && this.mediaClients.delete(e);
+    };
+  }
+  /**
+   * Rings everyone in `targets` as a single call and connects whoever answers
+   * first; the rest stop ringing on their own. `target` still works and means a
+   * call with one recipient.
+   */
+  async startCall(e) {
+    if (this.startCallRequest) return this.startCallRequest;
+    if (this.activeCallIds.size > 0) throw new Error("Another call is already active");
+    const t = e.targets?.length ? e.targets : e.target ? [e.target] : [];
+    if (t.length === 0) throw new Error("startCall requires at least one target");
+    const i = { mode: e.mode, targets: t, metadata: e.metadata, idempotencyKey: e.idempotencyKey }, n = (async () => {
+      await this.callAudio.unlock(), this.callAudio.startRingback();
+      let s;
+      try {
+        s = await this.request("/v1/rtc/client/calls", {
+          method: "POST",
+          headers: e.idempotencyKey ? { "idempotency-key": e.idempotencyKey } : void 0,
+          body: JSON.stringify(i)
+        });
+      } catch (a) {
+        throw this.callAudio.stop(), a;
+      }
+      return !s.credential && s.callerCredential && (s.credential = s.callerCredential), this.outgoingCallId = String(s.call?.id ?? "") || null, this.outgoingCallId && this.activeCallIds.add(this.outgoingCallId), this.emit("outgoingcall", s), s;
+    })();
+    this.startCallRequest = n;
+    try {
+      return await n;
+    } finally {
+      this.startCallRequest === n && (this.startCallRequest = null);
+    }
+  }
+  async accept(e = this.currentCall?.id) {
+    if (!e) throw new Error("No incoming call is available");
+    const t = await this.callAction(e, "accept");
+    return this.activeCallIds.add(e), this.callAudio.stop(), this.dismiss(e), this.emit("callaccepted", t), t;
+  }
+  async reject(e = this.currentCall?.id) {
+    if (!e) throw new Error("No incoming call is available");
+    const t = await this.callAction(e, "reject");
+    return this.releaseMedia(e), this.showTerminal(e, "Call declined"), this.emit("callrejected", t), t;
+  }
+  async busy(e = this.currentCall?.id) {
+    if (!e) throw new Error("No incoming call is available");
+    const t = await this.callAction(e, "busy");
+    return this.releaseMedia(e), this.showTerminal(e, "Line busy"), t;
+  }
+  async end(e) {
+    this.callAudio.stop();
+    const t = await this.callAction(e, "end");
+    return this.releaseMedia(e), this.showTerminal(e, "Call ended"), t;
+  }
+  async cancel(e) {
+    this.callAudio.stop();
+    const t = await this.callAction(e, "cancel");
+    return this.releaseMedia(e), this.showTerminal(e, "Call cancelled"), t;
+  }
+  /** Injects an incoming call received through the application's own push or signaling channel. */
+  handleIncomingCall(e) {
+    if (!e?.id || !e.caller?.id || !e.caller.name || e.mode !== "voice" && e.mode !== "video")
+      throw new Error("Incoming call payload is invalid");
+    if (e.expiresAt && Date.parse(e.expiresAt) <= Date.now()) {
+      this.emit("callexpired", { id: e.id, expiresAt: e.expiresAt });
+      return;
+    }
+    if (this.currentCall?.id === e.id) {
+      this.currentCall = e, this.emit("callrestored", e);
+      return;
+    }
+    if (this.seenInvitationIds.has(e.id)) {
+      this.emit("callrestored", e);
+      return;
+    }
+    this.seenInvitationIds.add(e.id), this.activeCallIds.add(e.id), this.currentCall = e, this.callAudio.startIncoming(), this.renderIncoming(e), this.emit("incomingcall", e);
+  }
+  /** Applies a call state received through the application's own push or signaling channel. */
+  handleCallUpdate(e) {
+    const t = e.id === this.currentCall?.id || e.id === this.outgoingCallId;
+    t && e.status === "accepted" ? (this.activeCallIds.add(e.id), this.callAudio.stop(), this.dismiss(e.id)) : t && ["rejected", "busy", "cancelled", "ended", "failed", "missed"].includes(e.status) && this.showTerminal(e.id, de(e.status)), ["rejected", "busy", "cancelled", "ended", "failed", "missed"].includes(e.status) && this.releaseMedia(e.id), this.emit("callupdated", e);
+  }
+  disconnect() {
+    this.stopped = !0, this.reconnectTimer && clearTimeout(this.reconnectTimer), this.heartbeatTimer && clearInterval(this.heartbeatTimer), this.tokenRefreshTimer && clearTimeout(this.tokenRefreshTimer), this.reconnectTimer = null, this.heartbeatTimer = null, this.tokenRefreshTimer = null, this.socket?.close(1e3, "Client disconnected"), this.socket = null, this.callAudio.stop(), this.dismiss();
+    for (const e of this.mediaClients.keys()) this.releaseMedia(e);
+    this.activeCallIds.clear(), this.seenInvitationIds.clear();
+  }
+  destroy() {
+    this.disconnect(), this.mount = null;
+  }
+  async openSocket(e) {
+    if (!this.options.signalingUrl || this.stopped || this.socket?.readyState === WebSocket.OPEN || this.socket?.readyState === WebSocket.CONNECTING) return;
+    let t;
+    try {
+      t = await this.resolveToken(e, e === "reconnect");
+    } catch (s) {
+      this.emit("tokenerror", g(s)), !this.stopped && this.options.reconnect !== !1 && this.scheduleReconnect();
+      return;
+    }
+    if (this.stopped || this.socket) return;
+    const i = new URL(this.options.signalingUrl, globalThis.location?.href);
+    i.protocol = i.protocol === "https:" ? "wss:" : "ws:";
+    const n = new WebSocket(i, ["rtc-client", t]);
+    this.socket = n, n.addEventListener("open", () => {
+      const s = this.reconnectAttempt > 0, a = this.lastDisconnect;
+      this.reconnectAttempt = 0, this.heartbeatDeadline = Date.now() + 45e3, this.emit("signalingconnected", { resumed: s }), a && (this.reportSignalingDiagnostic({ event: "recovered", code: a.code, reason: a.reason, wasClean: a.wasClean, outageMs: Date.now() - a.at }), this.lastDisconnect = null), this.heartbeatTimer && clearInterval(this.heartbeatTimer), this.heartbeatTimer = setInterval(() => {
+        if (n.readyState === WebSocket.OPEN) {
+          if (Date.now() > this.heartbeatDeadline) {
+            n.close(4e3, "Signaling heartbeat timed out");
+            return;
+          }
+          n.send("ping");
+        }
+      }, 2e4);
+    }), n.addEventListener("message", (s) => {
+      this.heartbeatDeadline = Date.now() + 45e3, this.handleSignal(String(s.data));
+    }), n.addEventListener("close", (s) => {
+      if (this.socket !== n) return;
+      this.socket = null, this.heartbeatTimer && clearInterval(this.heartbeatTimer), this.heartbeatTimer = null;
+      const a = !this.stopped && this.options.reconnect !== !1, r = {
+        code: s.code,
+        reason: s.reason,
+        wasClean: s.wasClean,
+        willReconnect: a,
+        attempt: this.reconnectAttempt + 1
+      };
+      a && (this.lastDisconnect = { code: s.code, reason: s.reason, wasClean: s.wasClean, at: Date.now() }), this.emit("signalingdisconnected", r), this.reportSignalingDiagnostic({ event: a ? "reconnecting" : "disconnected", ...r }), a && this.scheduleReconnect();
+    }), n.addEventListener("error", () => {
+      const s = { message: "RTC signaling connection failed", reconnecting: !this.stopped && this.options.reconnect !== !1, attempt: this.reconnectAttempt + 1 };
+      this.emit("signalingerror", s), this.reportSignalingDiagnostic({ event: "error", attempt: s.attempt });
+    });
+  }
+  handleSignal(e) {
+    let t;
+    try {
+      t = JSON.parse(e);
+    } catch {
+      return;
+    }
+    const i = String(t.type ?? "");
+    if (i === "call.incoming" && t.call && typeof t.call == "object") {
+      this.handleIncomingCall(t.call);
+      return;
+    }
+    if (i === "call.updated") {
+      const n = t.call;
+      n?.id && n.status && this.handleCallUpdate({ id: n.id, status: n.status });
+      return;
+    }
+    i === "presence" ? this.emit("presence", { users: t.users ?? [] }) : i !== "pong" && this.emit(i || "signal", t);
+  }
+  async callAction(e, t) {
+    return this.request(`/v1/rtc/client/calls/${encodeURIComponent(e)}/${t}`, {
+      method: "POST",
+      body: "{}"
+    });
+  }
+  async request(e, t, i = !1) {
+    const n = this.options.apiBaseUrl ?? this.options.signalingUrl ?? globalThis.location?.origin;
+    if (!n) throw new Error("apiBaseUrl is required for call actions");
+    const s = new URL(n, globalThis.location?.href), a = await this.resolveToken("initial"), r = new Headers(t.headers);
+    r.set("authorization", `Bearer ${a}`), r.set("content-type", "application/json");
+    const o = await fetch(new URL(e, s.origin), { ...t, headers: r }), l = await o.json().catch(() => ({}));
+    if (o.status === 401 && this.options.tokenProvider && !i)
+      return await this.resolveToken("unauthorized", !0), this.request(e, t, !0);
+    if (!o.ok) {
+      const d = l.error;
+      throw new Error(typeof d == "string" ? d : d?.message || `RTC API failed with HTTP ${o.status}`);
+    }
+    return l;
+  }
+  renderIncoming(e) {
+    if (!this.mount) return;
+    this.clearUi();
+    const t = document.createElement("section");
+    t.dataset.rtcIncomingCall = e.id, t.setAttribute("role", "dialog"), t.setAttribute("aria-label", `Incoming ${e.mode} call from ${e.caller.name}`), Object.assign(t.style, {
+      display: "grid",
+      gap: "14px",
+      padding: "20px",
+      border: "1px solid #cbd8dc",
+      borderRadius: "8px",
+      background: "#fff",
+      color: "#102027",
+      boxShadow: "0 14px 38px #07101429",
+      fontFamily: "system-ui, sans-serif"
+    });
+    const i = document.createElement("small");
+    i.textContent = e.mode === "video" ? "Incoming video call" : "Incoming voice call", i.style.color = "#5d7079";
+    const n = document.createElement("strong");
+    n.textContent = e.caller.name, n.style.fontSize = "20px";
+    const s = document.createElement("div");
+    Object.assign(s.style, { display: "grid", gridTemplateColumns: "1fr 1fr", gap: "10px" });
+    const a = U("Decline", "#fff", "#a32920", "#d9a09b"), r = U("Answer", "#fff", "#08745f", "#08745f");
+    a.addEventListener("click", () => {
+      this.reject(e.id).catch((o) => this.emit("error", g(o)));
+    }), r.addEventListener("click", () => {
+      this.accept(e.id).catch((o) => this.emit("error", g(o)));
+    }), s.appendChild(a), s.appendChild(r), t.appendChild(i), t.appendChild(n), t.appendChild(s), this.mount.replaceChildren(t);
+  }
+  dismiss(e) {
+    e && this.currentCall?.id !== e && this.outgoingCallId !== e || (this.currentCall = null, (!e || this.outgoingCallId === e) && (this.outgoingCallId = null), this.callAudio.stop(), this.clearUi());
+  }
+  showTerminal(e, t) {
+    if (this.callAudio.stop(), this.currentCall?.id === e && (this.currentCall = null), this.outgoingCallId === e && (this.outgoingCallId = null), !this.mount) return;
+    this.clearUi();
+    const i = document.createElement("section");
+    i.dataset.rtcCallTerminal = e, i.setAttribute("role", "status"), Object.assign(i.style, {
+      display: "grid",
+      placeItems: "center",
+      gap: "10px",
+      minHeight: "150px",
+      padding: "20px",
+      border: "1px solid #cbd8dc",
+      borderRadius: "8px",
+      background: "#fff",
+      color: "#102027",
+      boxShadow: "0 14px 38px #07101429",
+      fontFamily: "system-ui, sans-serif"
+    });
+    const n = document.createElement("strong");
+    n.textContent = t, n.style.fontSize = "18px", i.appendChild(n), this.mount.replaceChildren(i);
+    const s = Math.max(0, this.options.terminalStateDurationMs ?? 1600);
+    this.terminalTimer = setTimeout(() => this.clearUi(), s);
+  }
+  clearUi() {
+    this.terminalTimer && clearTimeout(this.terminalTimer), this.terminalTimer = null, this.mount && this.mount.replaceChildren();
+  }
+  scheduleReconnect() {
+    this.reconnectTimer && clearTimeout(this.reconnectTimer);
+    const e = Math.min(3e4, 1e3 * 2 ** Math.min(this.reconnectAttempt, 5)) + Math.round(Math.random() * 300);
+    this.reconnectAttempt += 1, this.reconnectTimer = setTimeout(() => {
+      this.openSocket("reconnect");
+    }, e);
+  }
+  async resolveToken(e, t = !1) {
+    if (!t && this.currentToken && !this.tokenNeedsRefresh()) return this.currentToken;
+    if (!this.options.tokenProvider) {
+      if (!this.currentToken) throw new Error("A valid RTC client token is required");
+      return this.currentToken;
+    }
+    return this.tokenRequest ? this.tokenRequest : (this.tokenRequest = (async () => {
+      const i = await this.options.tokenProvider?.({ reason: e, previousExpiresAt: this.currentTokenExpiresAt }), n = typeof i == "string" ? { token: i } : i;
+      if (!n?.token?.startsWith("rtcc_")) throw new Error("tokenProvider returned an invalid RTC client token");
+      return this.currentToken = n.token, this.currentTokenExpiresAt = n.expiresAt, this.scheduleTokenRefresh(), this.emit("tokenrefreshed", { reason: e, expiresAt: n.expiresAt }), n.token;
+    })().finally(() => {
+      this.tokenRequest = null;
+    }), this.tokenRequest);
+  }
+  tokenNeedsRefresh() {
+    if (!this.currentTokenExpiresAt) return !1;
+    const e = Date.parse(this.currentTokenExpiresAt) - Date.now();
+    return Number.isFinite(e) ? e <= this.refreshSkew(e) : !0;
+  }
+  refreshSkew(e) {
+    const t = Math.max(5e3, this.options.tokenRefreshSkewMs ?? 3e5);
+    return Math.min(t, Math.max(5e3, e * 0.2));
+  }
+  scheduleTokenRefresh() {
+    if (this.tokenRefreshTimer && clearTimeout(this.tokenRefreshTimer), this.tokenRefreshTimer = null, this.stopped || !this.options.tokenProvider || !this.currentTokenExpiresAt) return;
+    const e = Date.parse(this.currentTokenExpiresAt) - Date.now();
+    if (!Number.isFinite(e)) return;
+    const t = Math.max(0, e - this.refreshSkew(e));
+    this.tokenRefreshTimer = setTimeout(() => {
+      this.tokenRefreshTimer = null, this.resolveToken("expiring", !0).catch((i) => {
+        this.emit("tokenerror", g(i)), this.stopped || (this.tokenRefreshTimer = setTimeout(() => this.scheduleTokenRefresh(), 3e4));
+      });
+    }, Math.min(t, 2147e6));
+  }
+  releaseMedia(e) {
+    this.activeCallIds.delete(e), this.seenInvitationIds.delete(e);
+    const t = this.mediaClients.get(e);
+    t && (this.mediaClients.delete(e), t.leave().catch(() => {
+    }).finally(() => t.destroy()));
+  }
+  reportSignalingDiagnostic(e) {
+    this.options.reportSignalingDiagnostics === !1 || this.stopped || this.request("/v1/rtc/client/signaling-events", {
+      method: "POST",
+      body: JSON.stringify({ ...e, occurredAt: (/* @__PURE__ */ new Date()).toISOString() })
+    }).catch((t) => this.emit("diagnosticserror", g(t)));
+  }
+  emit(e, t) {
+    const i = { type: e, detail: t, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    this.dispatchEvent(new CustomEvent(e, { detail: i })), this.options.onEvent?.(i);
+  }
+}
+function Se(c) {
+  const e = new le(c);
+  return c.autoConnect !== !1 && c.signalingUrl && e.connect(), e;
+}
+function B(c) {
+  return c ? typeof c == "string" ? document.querySelector(c) : c : null;
+}
+function U(c, e, t, i) {
+  const n = document.createElement("button");
+  return n.type = "button", n.textContent = c, Object.assign(n.style, {
+    minHeight: "44px",
+    border: `1px solid ${i}`,
+    borderRadius: "6px",
+    background: t,
+    color: e,
+    cursor: "pointer",
+    font: "inherit",
+    fontWeight: "700"
+  }), n;
+}
+function de(c) {
+  return {
+    rejected: "Call declined",
+    busy: "Line busy",
+    cancelled: "Call cancelled",
+    ended: "Call ended",
+    failed: "Call failed",
+    missed: "No answer"
+  }[c] ?? "Call ended";
+}
+function F(c) {
+  return {
+    id: c.participantId,
+    name: c.displayName,
+    role: "participant"
+  };
+}
+async function he(c, e) {
+  const t = await c.getStats(), i = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  let s = 0, a = 0, r = 0, o = 0, l = 0, d = 0, u = 0, m = 0, p = 0, v = 0, T = 0, E = 0, w = 0, y = null, b = null, C = null, S = null, k = null, I = null;
+  t.forEach((h) => {
+    n.set(h.id, h), h.type === "codec" && i.set(h.id, String(h.mimeType ?? ""));
+  }), t.forEach((h) => {
+    if (h.type === "inbound-rtp" && !h.isRemote && (s += Number(h.bytesReceived ?? 0), r += Math.max(0, Number(h.packetsLost ?? 0)), o += Math.max(0, Number(h.packetsReceived ?? 0)), Number.isFinite(h.jitter) && (l += Number(h.jitter), d += 1), u = Math.max(u, Number(h.framesPerSecond ?? 0)), m = Math.max(m, Number(h.frameWidth ?? 0)), p = Math.max(p, Number(h.frameHeight ?? 0)), v += Number(h.framesDropped ?? 0), T += Number(h.freezeCount ?? 0), E += Number(h.totalFreezesDuration ?? 0), w += Number(h.concealedSamples ?? 0), k ||= i.get(String(h.codecId ?? "")) ?? null), h.type === "outbound-rtp" && !h.isRemote && (a += Number(h.bytesSent ?? 0), I ||= h.qualityLimitationReason ? String(h.qualityLimitationReason) : null, k ||= i.get(String(h.codecId ?? "")) ?? null), h.type === "candidate-pair" && (h.selected || h.nominated) && h.state === "succeeded") {
+      y = Number.isFinite(h.currentRoundTripTime) ? Number(h.currentRoundTripTime) : y, b = Number.isFinite(h.availableOutgoingBitrate) ? Number(h.availableOutgoingBitrate) : b;
+      const R = n.get(h.localCandidateId);
+      C = R?.candidateType ? String(R.candidateType) : C, S = R?.protocol ? String(R.protocol) : S;
+    }
+  });
+  const D = Date.now(), q = e ? Math.max(1e-3, (D - e.timestamp) / 1e3) : 0, G = e ? Math.max(0, Math.round((s - e.inboundBytes) * 8 / q)) : null, K = e ? Math.max(0, Math.round((a - e.outboundBytes) * 8 / q)) : null, N = r + o, Q = e ? Math.max(0, r - e.packetsLost) : r, Y = e ? Math.max(0, o - e.packetsReceived) : o, V = Q + Y;
+  return {
+    counters: { timestamp: D, inboundBytes: s, outboundBytes: a, packetsLost: r, packetsReceived: o },
+    sample: {
+      rttMs: y === null ? null : y * 1e3,
+      jitterMs: d ? l / d * 1e3 : null,
+      packetLossPct: V ? Q / V * 100 : null,
+      packetLossCumulativePct: N ? r / N * 100 : null,
+      packetsLost: r,
+      packetsReceived: o,
+      inboundBitrateBps: G,
+      outboundBitrateBps: K,
+      availableOutgoingBitrateBps: b,
+      framesPerSecond: u || null,
+      frameWidth: m || null,
+      frameHeight: p || null,
+      framesDropped: v,
+      freezeCount: T,
+      freezeDurationMs: Math.round(E * 1e3),
+      concealedSamples: w,
+      codec: k,
+      transportProtocol: S,
+      candidateType: C,
+      qualityLimitationReason: I
+    }
+  };
+}
+function ue(c) {
+  let e = c.mediaScore == null ? 5 : Math.round($(Number(c.mediaScore), 0, 5));
+  const t = x(c.packetLossPct) ?? 0, i = x(c.rttMs) ?? 0, n = x(c.jitterMs) ?? 0, s = String(c.connectionState ?? "unknown").toLowerCase();
+  ["failed", "closed", "disconnected"].includes(s) ? e = 0 : ["reconnecting", "checking"].includes(s) && (e = Math.min(e, 2)), t >= 15 ? e = Math.min(e, 0) : t >= 8 ? e = Math.min(e, 1) : t >= 3 ? e = Math.min(e, 2) : t >= 1 && (e = Math.min(e, 3)), i >= 1200 ? e = Math.min(e, 0) : i >= 800 ? e = Math.min(e, 1) : i >= 400 ? e = Math.min(e, 2) : i >= 250 && (e = Math.min(e, 3)), n >= 150 ? e = Math.min(e, 1) : n >= 80 ? e = Math.min(e, 2) : n >= 40 && (e = Math.min(e, 3));
+  const a = Number($(4.5 - t * 0.09 - i * 11e-4 - n * 6e-3, 1, 4.5).toFixed(2));
+  return { networkScore: e, estimatedMos: a };
+}
+function J() {
+  return navigator.connection ?? null;
+}
+function me() {
+  const c = Number(navigator.deviceMemory);
+  return Number.isFinite(c) ? c : null;
+}
+function x(c) {
+  const e = Number(c);
+  return Number.isFinite(e) ? e : null;
+}
+function $(c, e, t) {
+  return Math.min(t, Math.max(e, c));
+}
+function g(c) {
+  return c instanceof Error ? { name: c.name, message: c.message } : { name: "ServiceError", message: String(c ?? "Service request failed") };
+}
+function z(c, e) {
+  return c instanceof Error ? c : new Error(e);
+}
+const pe = "1.3.14";
+export {
+  re as RtcClient,
+  le as RtcIncomingClient,
+  fe as SPEAKER_NOISE_FLOOR,
+  ge as SPEAKER_TAKEOVER_RATIO,
+  ve as createPictureInPictureController,
+  ye as createRtcClient,
+  Se as createRtcIncomingClient,
+  H as pickActiveSpeaker,
+  oe as unlockRtcCallAudio,
+  pe as version
+};