@talkif/webrtc 0.1.0

package/dist/index.js

@@ -0,0 +1,908 @@
+// src/data-channel.ts
+var KEEPALIVE_INTERVAL_MS = 2e3;
+var DataChannel = class {
+  channel;
+  keepalive = null;
+  handlers;
+  constructor(pc, handlers) {
+    this.handlers = handlers;
+    this.channel = pc.createDataChannel("pipecat", { ordered: true });
+    this.channel.onopen = () => this.startKeepalive();
+    this.channel.onclose = () => this.stopKeepalive();
+    this.channel.onmessage = (event) => this.handleMessage(event.data);
+  }
+  startKeepalive() {
+    this.stopKeepalive();
+    this.keepalive = setInterval(() => {
+      if (this.channel.readyState === "open") {
+        this.channel.send("ping");
+      }
+    }, KEEPALIVE_INTERVAL_MS);
+  }
+  stopKeepalive() {
+    if (this.keepalive) {
+      clearInterval(this.keepalive);
+      this.keepalive = null;
+    }
+  }
+  handleMessage(data) {
+    if (typeof data !== "string") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof parsed !== "object" || parsed === null) return;
+    const record = parsed;
+    if (record["type"] === "signalling" && typeof record["message"] === "object" && record["message"] !== null) {
+      this.handlers.onSignalling(record["message"]);
+      return;
+    }
+    this.handlers.onAppMessage(record);
+  }
+  /** Send an arbitrary JSON app message to the bot pipeline. */
+  sendAppMessage(message) {
+    if (this.channel.readyState !== "open") return false;
+    this.channel.send(JSON.stringify(message));
+    return true;
+  }
+  /** Tell the bot to enable/disable one of our media receivers. */
+  sendTrackStatus(message) {
+    if (this.channel.readyState !== "open") return false;
+    this.channel.send(JSON.stringify({ type: "signalling", message: { type: "trackStatus", ...message } }));
+    return true;
+  }
+  close() {
+    this.stopKeepalive();
+    this.channel.onopen = null;
+    this.channel.onclose = null;
+    this.channel.onmessage = null;
+    if (this.channel.readyState === "open" || this.channel.readyState === "connecting") {
+      this.channel.close();
+    }
+  }
+};
+
+// src/emitter.ts
+var Emitter = class {
+  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);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of [...set]) {
+      listener(payload);
+    }
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+};
+
+// src/events.ts
+var BACKOFF_MS = [500, 1e3, 2e3, 4e3, 8e3];
+var CallEventsClient = class {
+  options;
+  ws = null;
+  closed = false;
+  attempts = 0;
+  everConnected = false;
+  lastSeq = 0;
+  reconnectTimer = null;
+  constructor(options) {
+    this.options = options;
+  }
+  connect() {
+    if (this.closed || this.ws) return;
+    void this.open();
+  }
+  close() {
+    this.closed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close(1e3);
+    this.ws = null;
+  }
+  wsUrl() {
+    const base = this.options.baseUrl.replace(/\/$/, "").replace(/^http/, "ws");
+    return `${base}/api/v1/public/ws/events`;
+  }
+  async open() {
+    let token;
+    try {
+      token = await this.options.getToken();
+    } catch {
+      this.scheduleReconnect();
+      return;
+    }
+    if (this.closed) return;
+    const WS = this.options.webSocket ?? WebSocket;
+    const ws = new WS(this.wsUrl());
+    this.ws = ws;
+    ws.onopen = () => {
+      ws.send(JSON.stringify({ type: "auth", token }));
+      ws.send(
+        JSON.stringify({ type: "subscribe", ...this.everConnected ? { replay: true } : {} })
+      );
+    };
+    ws.onmessage = (message) => {
+      if (typeof message.data !== "string") return;
+      let envelope;
+      try {
+        envelope = JSON.parse(message.data);
+      } catch {
+        return;
+      }
+      if (typeof envelope.type !== "string" || typeof envelope.seq !== "number") return;
+      if (envelope.type === "subscribed") {
+        this.everConnected = true;
+        this.attempts = 0;
+        this.lastSeq = envelope.seq;
+        return;
+      }
+      if (envelope.type === "pong" || envelope.type === "unsubscribed") {
+        this.lastSeq = envelope.seq;
+        return;
+      }
+      if (this.lastSeq > 0 && envelope.seq > this.lastSeq + 1) {
+        this.options.onGap?.(this.lastSeq + 1, envelope.seq);
+      }
+      this.lastSeq = envelope.seq;
+      this.options.onEvent(envelope);
+    };
+    ws.onclose = (event) => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      this.lastSeq = 0;
+      if (event.code === 4403) {
+        this.closed = true;
+        return;
+      }
+      this.scheduleReconnect();
+    };
+    ws.onerror = () => {
+    };
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectTimer) return;
+    const delay = BACKOFF_MS[Math.min(this.attempts, BACKOFF_MS.length - 1)] ?? 8e3;
+    this.attempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.open();
+    }, delay);
+  }
+};
+
+// src/types.ts
+var TERMINAL_CALL_STATUSES = /* @__PURE__ */ new Set([
+  "COMPLETED",
+  "FAILED",
+  "NO_ANSWER",
+  "BUSY",
+  "CANCELED"
+]);
+var TalkifCallError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "TalkifCallError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+function isPublicConfig(config) {
+  return "publishableKey" in config;
+}
+
+// src/turnstile.ts
+var TURNSTILE_SCRIPT_URL = "https://challenges.cloudflare.com/turnstile/v0/api.js";
+var scriptPromise = null;
+function loadScript() {
+  if (typeof document === "undefined") {
+    return Promise.reject(new Error("Turnstile requires a browser environment"));
+  }
+  if (window.turnstile) return Promise.resolve();
+  scriptPromise ??= new Promise((resolve, reject) => {
+    const existing = document.querySelector(
+      `script[src="${TURNSTILE_SCRIPT_URL}"]`
+    );
+    if (existing) {
+      existing.addEventListener("load", () => resolve());
+      existing.addEventListener("error", () => reject(new Error("Turnstile script failed to load")));
+      if (window.turnstile) resolve();
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = TURNSTILE_SCRIPT_URL;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error("Turnstile script failed to load"));
+    document.head.appendChild(script);
+  });
+  return scriptPromise;
+}
+var TurnstileManager = class {
+  siteKey;
+  container = null;
+  widgetId = null;
+  pending = null;
+  constructor(siteKey) {
+    this.siteKey = siteKey;
+  }
+  /** Obtain a fresh Turnstile token. Rejects if the challenge fails. */
+  async getToken() {
+    await loadScript();
+    const turnstile = window.turnstile;
+    if (!turnstile) throw new Error("Turnstile unavailable after script load");
+    if (!this.container) {
+      this.container = document.createElement("div");
+      this.container.style.position = "fixed";
+      this.container.style.width = "0";
+      this.container.style.height = "0";
+      this.container.style.overflow = "hidden";
+      this.container.style.pointerEvents = "none";
+      this.container.setAttribute("aria-hidden", "true");
+      document.body.appendChild(this.container);
+    }
+    if (this.widgetId === null) {
+      this.widgetId = turnstile.render(this.container, {
+        sitekey: this.siteKey,
+        size: "invisible",
+        execution: "execute",
+        retry: "auto",
+        callback: (token) => {
+          this.pending?.resolve(token);
+          this.pending = null;
+        },
+        "error-callback": (code) => {
+          this.pending?.reject(new Error(`Turnstile challenge failed${code ? `: ${code}` : ""}`));
+          this.pending = null;
+        },
+        "expired-callback": () => {
+        }
+      });
+    }
+    return new Promise((resolve, reject) => {
+      if (this.pending) {
+        this.pending.reject(new Error("Turnstile challenge superseded"));
+      }
+      this.pending = { resolve, reject };
+      const id = this.widgetId;
+      if (id === null) {
+        reject(new Error("Turnstile widget not rendered"));
+        this.pending = null;
+        return;
+      }
+      try {
+        turnstile.reset(id);
+        turnstile.execute(id, { sitekey: this.siteKey });
+      } catch (err) {
+        this.pending = null;
+        reject(err instanceof Error ? err : new Error("Turnstile execute failed"));
+      }
+    });
+  }
+  dispose() {
+    if (this.widgetId !== null && window.turnstile) {
+      try {
+        window.turnstile.remove(this.widgetId);
+      } catch {
+      }
+    }
+    this.widgetId = null;
+    this.pending = null;
+    if (this.container) {
+      this.container.remove();
+      this.container = null;
+    }
+  }
+};
+
+// src/signaling.ts
+var SignalingError = class extends Error {
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message);
+    this.name = "SignalingError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var SESSION_REFRESH_MARGIN_MS = 6e4;
+var PublicSession = class {
+  config;
+  token = null;
+  expiresAt = 0;
+  flowIdValue = null;
+  inflight = null;
+  turnstile = null;
+  constructor(config) {
+    this.config = config;
+    if (config.turnstileSiteKey && !config.turnstileToken) {
+      this.turnstile = new TurnstileManager(config.turnstileSiteKey);
+    }
+  }
+  /** A fresh Turnstile token, from the manual supplier or the built-in
+   * manager; undefined when no gate is configured (dev/local). */
+  async turnstileToken() {
+    if (this.config.turnstileToken) {
+      return this.config.turnstileToken();
+    }
+    if (this.turnstile) {
+      return this.turnstile.getToken();
+    }
+    return void 0;
+  }
+  /** Tear down the Turnstile widget (call when the client is disposed). */
+  dispose() {
+    this.turnstile?.dispose();
+    this.turnstile = null;
+  }
+  /** Flow bound to the publishable key (known after the first exchange). */
+  get flowId() {
+    return this.flowIdValue;
+  }
+  async getToken() {
+    if (this.token && Date.now() < this.expiresAt - SESSION_REFRESH_MARGIN_MS) {
+      return this.token;
+    }
+    this.inflight ??= this.exchange().finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  invalidate() {
+    this.token = null;
+    this.expiresAt = 0;
+  }
+  async exchange() {
+    const doFetch = this.config.fetch ?? fetch;
+    const turnstileToken = await this.turnstileToken();
+    const response = await doFetch(
+      `${this.config.baseUrl.replace(/\/$/, "")}/api/v1/public/calls/session`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          publishableKey: this.config.publishableKey,
+          ...turnstileToken !== void 0 ? { turnstileToken } : {}
+        })
+      }
+    );
+    const parsed = await response.json().catch(() => null);
+    if (!response.ok) {
+      throw new SignalingError(
+        response.status,
+        "Session exchange failed \u2014 check the publishable key and that this origin is on its allowlist",
+        parsed
+      );
+    }
+    const session = parsed;
+    this.token = session.token;
+    this.expiresAt = Date.now() + session.expiresIn * 1e3;
+    this.flowIdValue = session.flowId;
+    return session.token;
+  }
+};
+var SignalingClient = class {
+  config;
+  session;
+  constructor(config) {
+    this.config = config;
+    this.session = isPublicConfig(config) ? new PublicSession(config) : null;
+  }
+  get isPublic() {
+    return this.session !== null;
+  }
+  get base() {
+    const baseUrl = this.config.baseUrl.replace(/\/$/, "");
+    if (isPublicConfig(this.config)) {
+      return `${baseUrl}/api/v1/public/calls`;
+    }
+    return `${baseUrl}/api/v1/accounts/${this.config.accountId}/calls/webrtc`;
+  }
+  async authorization() {
+    if (this.session) {
+      return `Bearer ${await this.session.getToken()}`;
+    }
+    return this.config.auth();
+  }
+  async request(method, path, body, retriedAuth = false) {
+    const doFetch = this.config.fetch ?? fetch;
+    const authorization = await this.authorization();
+    const response = await doFetch(`${this.base}${path}`, {
+      method,
+      headers: {
+        authorization,
+        ...body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+    });
+    if (response.status === 401 && this.session && !retriedAuth) {
+      this.session.invalidate();
+      return this.request(method, path, body, true);
+    }
+    let parsed = null;
+    const text = await response.text();
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      const message = typeof parsed === "object" && parsed !== null && "detail" in parsed ? String(parsed.detail) : typeof parsed === "object" && parsed !== null && "message" in parsed ? String(parsed.message) : `Signaling request failed: ${method} ${path} \u2192 ${response.status}`;
+      throw new SignalingError(response.status, message, parsed);
+    }
+    return parsed;
+  }
+  createCall(body) {
+    if (this.isPublic) {
+      return this.request("POST", "/calls", {});
+    }
+    return this.request("POST", "", body);
+  }
+  createTestCall(body) {
+    if (this.isPublic) {
+      throw new TalkifCallError(
+        "signaling-failed",
+        "Draft test calls are not available on the public surface"
+      );
+    }
+    return this.request("POST", "/test", body);
+  }
+  getIceServers() {
+    return this.request("GET", "/ice-servers");
+  }
+  sendOffer(callId, body) {
+    const path = this.isPublic ? `/calls/${callId}/offer` : `/${callId}/offer`;
+    return this.request("POST", path, body);
+  }
+  getCall(callId) {
+    const path = this.isPublic ? `/calls/${callId}` : `/${callId}`;
+    return this.request("GET", path);
+  }
+};
+function asSignalingCallError(error) {
+  if (error instanceof TalkifCallError) return error;
+  if (error instanceof SignalingError) {
+    const code = error.status === 401 ? "session-rejected" : error.status === 409 ? "call-active" : error.status === 429 ? "rate-limited" : error.status === 503 ? "no-agent" : "signaling-failed";
+    return new TalkifCallError(code, error.message, error);
+  }
+  const message = error instanceof Error ? error.message : "Signaling request failed";
+  return new TalkifCallError("signaling-failed", message, error);
+}
+
+// src/call.ts
+var PIPELINE_HEALTH_TIMEOUT_MS = 15e3;
+var ICE_FIRST_RELAY_TIMEOUT_MS = 1500;
+var TalkifCall = class {
+  signaling;
+  config;
+  emitter = new Emitter();
+  events = null;
+  pc = null;
+  localStream = null;
+  remoteAudio = null;
+  ownsAudioElement = false;
+  dataChannel = null;
+  iceServers = [];
+  durationTimer = null;
+  healthTimer = null;
+  pipelineConfirmed = false;
+  renegotiating = false;
+  _state = "idle";
+  _callId = null;
+  _botId = null;
+  _muted = false;
+  _durationSecs = 0;
+  constructor(config) {
+    this.config = config;
+    this.signaling = new SignalingClient(config);
+  }
+  // -- public surface -------------------------------------------------------
+  get state() {
+    return this._state;
+  }
+  get callId() {
+    return this._callId;
+  }
+  get botId() {
+    return this._botId;
+  }
+  get muted() {
+    return this._muted;
+  }
+  get durationSecs() {
+    return this._durationSecs;
+  }
+  on(event, listener) {
+    return this.emitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.emitter.off(event, listener);
+  }
+  /**
+   * External health signal (e.g. the dashboard's SSE layer saw a
+   * RUNNING/CONNECTED status). Cancels the REST health watchdog.
+   */
+  confirmPipelineHealthy() {
+    this.pipelineConfirmed = true;
+    if (this.healthTimer) {
+      clearTimeout(this.healthTimer);
+      this.healthTimer = null;
+    }
+  }
+  /**
+   * External terminal signal (e.g. SSE reported COMPLETED). Tears down and
+   * transitions to 'ended'.
+   */
+  endedExternally() {
+    if (this._state !== "connecting" && this._state !== "connected") return;
+    this.teardown();
+    this.setState("ended");
+    this.emitter.emit("ended", { reason: "external" });
+  }
+  /** Send an arbitrary JSON app message to the bot over the data channel. */
+  sendAppMessage(message) {
+    return this.dataChannel?.sendAppMessage(message) ?? false;
+  }
+  setMuted(muted) {
+    if (!this.localStream) return;
+    for (const track of this.localStream.getAudioTracks()) {
+      track.enabled = !muted;
+    }
+    this._muted = muted;
+    this.emitter.emit("mutechange", { muted });
+  }
+  /** User-initiated hangup. */
+  hangup() {
+    if (this._state === "idle" || this._state === "ended" || this._state === "error") return;
+    this.teardown();
+    this.setState("ended");
+    this.emitter.emit("ended", { reason: "local-hangup" });
+  }
+  /** Full teardown regardless of state — safe to call multiple times. */
+  dispose() {
+    this.teardown();
+    this.signaling.session?.dispose();
+    this.emitter.removeAll();
+  }
+  // -- lifecycle ------------------------------------------------------------
+  async start(options) {
+    if (this._state !== "idle") {
+      throw new TalkifCallError("signaling-failed", `Cannot start a call from state '${this._state}' \u2014 create a new TalkifCall`);
+    }
+    this.setState("requesting");
+    if (!this.signaling.isPublic && !options.flowId) {
+      throw new TalkifCallError("signaling-failed", "flowId is required in authenticated mode");
+    }
+    try {
+      const flowId = options.flowId ?? "";
+      const [callResponse, local] = await Promise.all([
+        options.draftDefinition !== void 0 ? this.signaling.createTestCall({
+          flowId,
+          definition: options.draftDefinition,
+          ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+        }) : this.signaling.createCall({
+          flowId,
+          ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+        }),
+        this.prepareLocal(options)
+      ]);
+      this._callId = callResponse.callId;
+      this.pc = local.pc;
+      this.localStream = local.stream;
+      this.setState("connecting");
+      this.pc.ontrack = (event) => {
+        const stream = event.streams[0];
+        if (!stream) return;
+        this.attachRemoteAudio(stream, options);
+        this.emitter.emit("track", { stream });
+      };
+      this.pc.onconnectionstatechange = () => {
+        const state = this.pc?.connectionState;
+        if (state === "failed" || state === "disconnected") {
+          this.fail(new TalkifCallError("connection-failed", "WebRTC connection failed"));
+        }
+      };
+      this.dataChannel = new DataChannel(this.pc, {
+        onSignalling: (message) => this.handleSignalling(message),
+        onAppMessage: (message) => this.emitter.emit("appmessage", { message })
+      });
+      const answer = await this.signaling.sendOffer(callResponse.callId, {
+        sdp: this.mustLocalSdp(),
+        iceServers: this.iceServers
+      });
+      await this.pc.setRemoteDescription({ type: "answer", sdp: answer.sdp });
+      this._botId = answer.botId ?? null;
+      this.setState("connected");
+      this.emitter.emit("connected", { callId: callResponse.callId, botId: this._botId });
+      this.startDurationTimer();
+      this.armHealthWatchdog(callResponse.callId);
+      this.connectEvents();
+    } catch (error) {
+      this.fail(
+        error instanceof TalkifCallError ? error : asSignalingCallError(error)
+      );
+      throw error;
+    }
+  }
+  async prepareLocal(options) {
+    const { iceServers } = await this.signaling.getIceServers();
+    this.iceServers = iceServers;
+    if (!navigator.mediaDevices?.getUserMedia) {
+      throw new TalkifCallError("media-unavailable", "Microphone access unavailable. This requires HTTPS or localhost.");
+    }
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: options.audio ?? true }).catch((cause) => {
+      throw new TalkifCallError("media-unavailable", "Microphone permission denied or unavailable", cause);
+    });
+    const pc = new RTCPeerConnection({
+      iceServers: iceServers.map((s) => ({
+        urls: s.urls,
+        ...s.username !== void 0 ? { username: s.username } : {},
+        ...s.credential !== void 0 ? { credential: s.credential } : {}
+      })),
+      iceTransportPolicy: "relay"
+    });
+    for (const track of stream.getTracks()) {
+      pc.addTrack(track, stream);
+    }
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    if (!offer.sdp) {
+      throw new TalkifCallError("signaling-failed", "Failed to create SDP offer");
+    }
+    await this.waitForFirstRelayCandidate(pc);
+    return { pc, stream };
+  }
+  waitForFirstRelayCandidate(pc) {
+    return new Promise((resolve) => {
+      if (pc.iceGatheringState === "complete") {
+        resolve();
+        return;
+      }
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        pc.removeEventListener("icecandidate", onCandidate);
+        pc.removeEventListener("icegatheringstatechange", onGatheringComplete);
+        resolve();
+      };
+      const timeout = setTimeout(finish, ICE_FIRST_RELAY_TIMEOUT_MS);
+      const onCandidate = (e) => {
+        if (e.candidate && e.candidate.type === "relay") finish();
+      };
+      const onGatheringComplete = () => {
+        if (pc.iceGatheringState === "complete") finish();
+      };
+      pc.addEventListener("icecandidate", onCandidate);
+      pc.addEventListener("icegatheringstatechange", onGatheringComplete);
+    });
+  }
+  attachRemoteAudio(stream, options) {
+    if (options.audioElement === null) return;
+    if (!this.remoteAudio) {
+      if (options.audioElement) {
+        this.remoteAudio = options.audioElement;
+        this.ownsAudioElement = false;
+      } else {
+        this.remoteAudio = new Audio();
+        this.remoteAudio.autoplay = true;
+        this.ownsAudioElement = true;
+      }
+    }
+    this.remoteAudio.srcObject = stream;
+  }
+  // -- data-channel protocol ------------------------------------------------
+  handleSignalling(message) {
+    switch (message.type) {
+      case "peerLeft":
+        if (this._state === "connected" || this._state === "connecting") {
+          this.teardown();
+          this.setState("ended");
+          this.emitter.emit("ended", { reason: "peer-left" });
+        }
+        break;
+      case "renegotiate":
+        void this.renegotiate();
+        break;
+      case "trackStatus":
+        break;
+    }
+  }
+  /**
+   * Bot asked for a new offer/answer cycle. Re-offer through the same relay
+   * endpoint. If the backend rejects re-offers (older deployments), the call
+   * keeps running on the existing session — surfaced via `renegotiated`.
+   */
+  async renegotiate() {
+    if (!this.pc || !this._callId || this.renegotiating) return;
+    this.renegotiating = true;
+    try {
+      const offer = await this.pc.createOffer({ iceRestart: true });
+      await this.pc.setLocalDescription(offer);
+      await this.waitForFirstRelayCandidate(this.pc);
+      const answer = await this.signaling.sendOffer(this._callId, {
+        sdp: this.mustLocalSdp(),
+        iceServers: this.iceServers
+      });
+      await this.pc.setRemoteDescription({ type: "answer", sdp: answer.sdp });
+      this.emitter.emit("renegotiated", { ok: true });
+    } catch {
+      this.emitter.emit("renegotiated", { ok: false });
+    } finally {
+      this.renegotiating = false;
+    }
+  }
+  // -- realtime events (public mode) ----------------------------------------
+  /**
+   * Public mode only: open the realtime events WebSocket for this call.
+   * Events double as the pipeline-health signal, and a terminal `status`
+   * event ends the call from the server side (e.g. max-duration reached).
+   */
+  connectEvents() {
+    const session = this.signaling.session;
+    if (!session) return;
+    this.events = new CallEventsClient({
+      baseUrl: this.config.baseUrl,
+      getToken: () => session.getToken(),
+      onEvent: (event) => this.handleCallEvent(event)
+    });
+    this.events.connect();
+  }
+  handleCallEvent(event) {
+    this.confirmPipelineHealthy();
+    this.emitter.emit("callevent", { event });
+    switch (event.type) {
+      case "transcript": {
+        const role = typeof event.data.role === "string" ? event.data.role : "unknown";
+        const content = typeof event.data.content === "string" ? event.data.content : "";
+        this.emitter.emit("transcript", { role, content, data: event.data });
+        break;
+      }
+      case "interim":
+        this.emitter.emit("interim", { data: event.data });
+        break;
+      case "tts": {
+        const text = typeof event.data.text === "string" ? event.data.text : "";
+        if (!text) break;
+        const timestamp = typeof event.data.timestamp === "number" ? event.data.timestamp : 0;
+        this.emitter.emit("ttschunk", { text, timestamp, data: event.data });
+        break;
+      }
+      case "tts_word": {
+        const word = typeof event.data.word === "string" ? event.data.word : "";
+        if (!word) break;
+        const ptsMs = typeof event.data.pts_ms === "number" ? event.data.pts_ms : null;
+        const timestamp = typeof event.data.timestamp === "number" ? event.data.timestamp : 0;
+        this.emitter.emit("ttsword", { word, ptsMs, timestamp, data: event.data });
+        break;
+      }
+      case "status": {
+        const status = typeof event.data.status === "string" ? event.data.status : "";
+        if (TERMINAL_CALL_STATUSES.has(status.toUpperCase())) {
+          this.endedExternally();
+        }
+        break;
+      }
+    }
+  }
+  // -- health watchdog ------------------------------------------------------
+  armHealthWatchdog(callId) {
+    this.pipelineConfirmed = false;
+    this.healthTimer = setTimeout(() => {
+      this.healthTimer = null;
+      if (this.pipelineConfirmed) return;
+      void this.verifyPipelineHealth(callId);
+    }, PIPELINE_HEALTH_TIMEOUT_MS);
+  }
+  async verifyPipelineHealth(callId) {
+    try {
+      const call = await this.signaling.getCall(callId);
+      if (this.pipelineConfirmed || !this.pc) return;
+      if (TERMINAL_CALL_STATUSES.has(call.status)) {
+        this.fail(new TalkifCallError("pipeline-dead", `Backend reports terminal status '${call.status}'`));
+        return;
+      }
+      this.pipelineConfirmed = true;
+    } catch {
+      if (this.pipelineConfirmed || !this.pc) return;
+      if (this.pc.connectionState === "connected") {
+        this.pipelineConfirmed = true;
+        return;
+      }
+      this.fail(new TalkifCallError("pipeline-dead", "No health signal, REST unreachable, media not connected"));
+    }
+  }
+  // -- internals ------------------------------------------------------------
+  mustLocalSdp() {
+    const sdp = this.pc?.localDescription?.sdp;
+    if (!sdp) {
+      throw new TalkifCallError("signaling-failed", "Local SDP missing");
+    }
+    return sdp;
+  }
+  startDurationTimer() {
+    this._durationSecs = 0;
+    this.durationTimer = setInterval(() => {
+      this._durationSecs += 1;
+      this.emitter.emit("tick", { durationSecs: this._durationSecs });
+    }, 1e3);
+  }
+  fail(error) {
+    if (this._state === "ended" || this._state === "error") return;
+    this.teardown();
+    this.setState("error");
+    this.emitter.emit("error", { error });
+  }
+  setState(state) {
+    const previous = this._state;
+    if (previous === state) return;
+    this._state = state;
+    this.emitter.emit("statechange", { state, previous });
+  }
+  teardown() {
+    this.events?.close();
+    this.events = null;
+    if (this.healthTimer) {
+      clearTimeout(this.healthTimer);
+      this.healthTimer = null;
+    }
+    this.pipelineConfirmed = false;
+    if (this.durationTimer) {
+      clearInterval(this.durationTimer);
+      this.durationTimer = null;
+    }
+    this.dataChannel?.close();
+    this.dataChannel = null;
+    if (this.localStream) {
+      for (const track of this.localStream.getTracks()) track.stop();
+      this.localStream = null;
+    }
+    if (this.remoteAudio) {
+      this.remoteAudio.pause();
+      this.remoteAudio.srcObject = null;
+      if (this.ownsAudioElement) this.remoteAudio = null;
+    }
+    if (this.pc) {
+      this.pc.ontrack = null;
+      this.pc.onconnectionstatechange = null;
+      this.pc.close();
+      this.pc = null;
+    }
+  }
+};
+export {
+  CallEventsClient,
+  PublicSession,
+  SignalingClient,
+  SignalingError,
+  TERMINAL_CALL_STATUSES,
+  TalkifCall,
+  TalkifCallError,
+  TurnstileManager,
+  isPublicConfig
+};
+//# sourceMappingURL=index.js.map