@craftedxp/voice-js 0.2.0

package/dist/browser.js

@@ -0,0 +1,725 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  buildWsUrl: () => buildWsUrl,
+  configureVoiceClient: () => configureVoiceClient,
+  createAudioCapture: () => createAudioCapture,
+  createAudioPlayback: () => createAudioPlayback,
+  createProtocolState: () => createProtocolState,
+  createReconnectingWebSocket: () => createReconnectingWebSocket,
+  handleServerMessage: () => handleServerMessage
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/config.ts
+function normalizeConfig(config) {
+  if (!config) throw new Error("configureVoiceClient: config is required");
+  if ("apiKey" in config) {
+    throw new Error(
+      "configureVoiceClient: `apiKey` is no longer supported. Embedding sk_ in JS code ships server-grade credentials to every client. Pass `fetchToken: async ({ agentId }) => { /* call YOUR backend mint */ }` instead \u2014 see the @craftedxp/voice-js README for the migration recipe."
+    );
+  }
+  if (!config.apiBase) {
+    throw new Error("configureVoiceClient: apiBase is required");
+  }
+  if (typeof config.fetchToken !== "function") {
+    throw new Error("configureVoiceClient: fetchToken must be a function");
+  }
+  return {
+    ...config,
+    apiBase: config.apiBase.replace(/\/+$/, "")
+  };
+}
+function mergeStartCallContext(factory, call) {
+  const context = factory.defaultContext || call.context ? { ...factory.defaultContext ?? {}, ...call.context ?? {} } : void 0;
+  const metadata = factory.defaultMetadata || call.metadata ? { ...factory.defaultMetadata ?? {}, ...call.metadata ?? {} } : void 0;
+  return { context, metadata };
+}
+
+// src/worklets/mic-downsampler.worklet.js
+var mic_downsampler_worklet_default = "// AudioWorklet \u2014 runs off the main thread in the audio rendering graph.\n//\n// Input: Float32 samples at the AudioContext's native sampleRate (typically\n// 48000 Hz on desktop, 44100 Hz on some iOS devices).\n// Output: 16 kHz mono Int16 PCM, shipped to the main thread via\n// `port.postMessage(ArrayBuffer, [ArrayBuffer])` (transferred, not copied).\n//\n// Why AudioWorklet instead of ScriptProcessorNode: ScriptProcessorNode is\n// deprecated + main-thread-bound, so any JS jank produces audible audio\n// glitches. AudioWorklet's `process()` runs on the audio rendering thread\n// at the graph's block cadence (128 frames by default) and backpressures\n// via returning `true` / `false`.\n//\n// This file is loaded as text (see tsup.config.ts loader) and registered\n// at runtime via `audioWorklet.addModule(blobUrl)`.\n\nclass MicDownsampler extends AudioWorkletProcessor {\n  constructor() {\n    super()\n    // Target sample rate for STT. Matches Deepgram Nova-3 + the platform's\n    // server-side SAMPLE_RATE constant in AgentCallHandler.\n    this.targetRate = 16000\n    // Accumulator for the downsample. We collect incoming samples and emit\n    // an Int16 chunk when we've accumulated ~1024 target-rate samples\n    // (~64 ms at 16 kHz) \u2014 matches the mobile SDK's chunk size so both\n    // platforms have the same server-side framing.\n    this.outputFrames = 1024\n    this.acc = []\n    // Running index used for fractional resampling.\n    this.readCursor = 0\n  }\n\n  // `inputs[0][0]` = first channel of first input. 128 Float32 samples per\n  // call at the context's sampleRate. Return true = keep processing.\n  process(inputs) {\n    const input = inputs[0]\n    if (!input || input.length === 0) return true\n    const channel = input[0]\n    if (!channel || channel.length === 0) return true\n\n    const ctxRate = sampleRate // global inside AudioWorkletProcessor\n    const ratio = ctxRate / this.targetRate\n\n    // Simple linear-interp downsample. For 48000 \u2192 16000 that's 3:1, which\n    // linear handles fine for voice. Anti-alias filtering would be\n    // theoretically better but inaudible for speech.\n    for (let i = 0; i < channel.length; i++) {\n      this.acc.push(channel[i])\n    }\n\n    while (this.acc.length - this.readCursor >= ratio * this.outputFrames) {\n      const out = new Int16Array(this.outputFrames)\n      let readIdx = this.readCursor\n      for (let i = 0; i < this.outputFrames; i++) {\n        // Linear interp between floor(readIdx) and ceil(readIdx)\n        const low = Math.floor(readIdx)\n        const high = Math.min(low + 1, this.acc.length - 1)\n        const frac = readIdx - low\n        const sample = this.acc[low] * (1 - frac) + this.acc[high] * frac\n        // Clip + convert to int16\n        const clipped = Math.max(-1, Math.min(1, sample))\n        out[i] = clipped < 0 ? clipped * 0x8000 : clipped * 0x7fff\n        readIdx += ratio\n      }\n      // Transfer the ArrayBuffer (zero-copy) to the main thread.\n      this.port.postMessage(out.buffer, [out.buffer])\n      this.readCursor = readIdx\n    }\n\n    // Garbage-collect the consumed portion of `acc` every so often so it\n    // doesn't grow without bound. Leave ~one chunk of headroom.\n    if (this.readCursor > ratio * this.outputFrames) {\n      this.acc = this.acc.slice(Math.floor(this.readCursor))\n      this.readCursor -= Math.floor(this.readCursor)\n    }\n\n    return true\n  }\n}\n\nregisterProcessor('mic-downsampler', MicDownsampler)\n";
+
+// src/AudioCapture.ts
+var VOLUME_INTERVAL_MS = 100;
+var createAudioCapture = (options) => {
+  let audioContext = null;
+  let mediaStream = null;
+  let sourceNode = null;
+  let workletNode = null;
+  let analyser = null;
+  let volumeTimer = null;
+  let muted = false;
+  let capturing = false;
+  const computeRms = (buf) => {
+    let sum = 0;
+    for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i];
+    const rms = Math.sqrt(sum / buf.length);
+    return Math.min(1, rms * 1.8);
+  };
+  const start = async () => {
+    if (capturing) return;
+    try {
+      mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          // Hand tuning for voice agent use: we want the raw signal so the
+          // server-side STT can do its own noise handling. Disable browser
+          // AEC/AGC/NR — experimentally they fight with whatever processing
+          // the TTS playback path feeds back in over speakers.
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true,
+          channelCount: 1
+        }
+      });
+      audioContext = new AudioContext();
+      if (audioContext.state === "suspended") await audioContext.resume();
+      const blob = new Blob([mic_downsampler_worklet_default], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      try {
+        await audioContext.audioWorklet.addModule(url);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+      sourceNode = audioContext.createMediaStreamSource(mediaStream);
+      workletNode = new AudioWorkletNode(audioContext, "mic-downsampler");
+      workletNode.port.onmessage = (event) => {
+        if (muted) return;
+        options.onChunk(event.data);
+      };
+      if (options.onVolume) {
+        analyser = audioContext.createAnalyser();
+        analyser.fftSize = 256;
+        sourceNode.connect(analyser);
+        const buf = new Float32Array(analyser.fftSize);
+        volumeTimer = setInterval(() => {
+          if (!analyser) return;
+          analyser.getFloatTimeDomainData(buf);
+          options.onVolume?.(computeRms(buf));
+        }, VOLUME_INTERVAL_MS);
+      }
+      sourceNode.connect(workletNode);
+      const sink = audioContext.createGain();
+      sink.gain.value = 0;
+      workletNode.connect(sink).connect(audioContext.destination);
+      capturing = true;
+    } catch (err) {
+      const wrapped = err instanceof Error ? err : new Error(typeof err === "string" ? err : "capture failed");
+      options.onError?.(wrapped);
+      throw wrapped;
+    }
+  };
+  const stop = () => {
+    if (!capturing) return;
+    capturing = false;
+    if (volumeTimer) {
+      clearInterval(volumeTimer);
+      volumeTimer = null;
+    }
+    try {
+      workletNode?.disconnect();
+      analyser?.disconnect();
+      sourceNode?.disconnect();
+    } catch {
+    }
+    workletNode = null;
+    analyser = null;
+    sourceNode = null;
+    if (mediaStream) {
+      for (const track of mediaStream.getTracks()) track.stop();
+      mediaStream = null;
+    }
+    if (audioContext && audioContext.state !== "closed") {
+      void audioContext.close().catch(() => void 0);
+    }
+    audioContext = null;
+  };
+  return {
+    start,
+    stop,
+    mute: (v) => {
+      muted = v;
+    },
+    isCapturing: () => capturing
+  };
+};
+
+// src/AudioPlayback.ts
+var DEFAULT_SAMPLE_RATE = 16e3;
+var VOLUME_INTERVAL_MS2 = 100;
+var createAudioPlayback = (options = {}) => {
+  const sampleRate = options.sampleRate ?? DEFAULT_SAMPLE_RATE;
+  let audioContext = null;
+  let gainNode = null;
+  let analyser = null;
+  let volumeTimer = null;
+  let nextStartTime = 0;
+  let scheduledNodes = [];
+  let speaking = false;
+  const ensureContext = async () => {
+    if (audioContext) {
+      if (audioContext.state === "suspended") await audioContext.resume();
+      return;
+    }
+    audioContext = new AudioContext({ sampleRate });
+    gainNode = audioContext.createGain();
+    if (options.onVolume) {
+      analyser = audioContext.createAnalyser();
+      analyser.fftSize = 256;
+      gainNode.connect(analyser);
+      const buf = new Float32Array(analyser.fftSize);
+      volumeTimer = setInterval(() => {
+        if (!analyser) return;
+        analyser.getFloatTimeDomainData(buf);
+        let sum = 0;
+        for (let i = 0; i < buf.length; i++) sum += buf[i] * buf[i];
+        const rms = Math.sqrt(sum / buf.length);
+        options.onVolume?.(Math.min(1, rms * 1.8));
+      }, VOLUME_INTERVAL_MS2);
+    }
+    gainNode.connect(audioContext.destination);
+    nextStartTime = audioContext.currentTime;
+  };
+  const setSpeaking = (v) => {
+    if (v === speaking) return;
+    speaking = v;
+    options.onSpeakingChange?.(v);
+  };
+  const pruneFinished = () => {
+    const now = audioContext?.currentTime ?? 0;
+    scheduledNodes = scheduledNodes.filter((n) => {
+      const node = n;
+      return (node._endsAt ?? 0) > now;
+    });
+    if (scheduledNodes.length === 0) setSpeaking(false);
+  };
+  const enqueue = (pcm) => {
+    if (!audioContext) {
+      void ensureContext().then(() => enqueue(pcm));
+      return;
+    }
+    if (!audioContext || !gainNode) return;
+    const int16 = new Int16Array(pcm);
+    if (int16.length === 0) return;
+    const audioBuffer = audioContext.createBuffer(1, int16.length, sampleRate);
+    const float32 = audioBuffer.getChannelData(0);
+    for (let i = 0; i < int16.length; i++) {
+      float32[i] = int16[i] / 32768;
+    }
+    const node = audioContext.createBufferSource();
+    node.buffer = audioBuffer;
+    node.connect(gainNode);
+    const now = audioContext.currentTime;
+    const startAt = Math.max(now, nextStartTime);
+    node.start(startAt);
+    const duration = int16.length / sampleRate;
+    node._endsAt = startAt + duration;
+    nextStartTime = startAt + duration;
+    scheduledNodes.push(node);
+    setSpeaking(true);
+    node.onended = () => pruneFinished();
+  };
+  const flush = () => {
+    if (!audioContext || !gainNode) return;
+    for (const node of scheduledNodes) {
+      try {
+        node.stop();
+      } catch {
+      }
+    }
+    scheduledNodes = [];
+    gainNode.disconnect();
+    gainNode = audioContext.createGain();
+    if (analyser) {
+      analyser.disconnect();
+      gainNode.connect(analyser);
+    }
+    gainNode.connect(audioContext.destination);
+    nextStartTime = audioContext.currentTime;
+    setSpeaking(false);
+  };
+  const close = () => {
+    flush();
+    if (volumeTimer) {
+      clearInterval(volumeTimer);
+      volumeTimer = null;
+    }
+    if (audioContext && audioContext.state !== "closed") {
+      void audioContext.close().catch(() => void 0);
+    }
+    audioContext = null;
+    gainNode = null;
+    analyser = null;
+  };
+  const resume = async () => {
+    await ensureContext();
+  };
+  return { enqueue, flush, close, resume };
+};
+
+// src/ReconnectingWebSocket.ts
+var READYSTATE_OPEN = 1;
+var READYSTATE_CLOSED = 3;
+var createReconnectingWebSocket = (options, onEvent) => {
+  const maxRetries = options.maxRetries ?? 3;
+  const initialBackoff = options.initialBackoffMs ?? 500;
+  const maxBackoff = options.maxBackoffMs ?? 8e3;
+  let ws = null;
+  let intentionalClose = false;
+  let retries = 0;
+  let backoff = initialBackoff;
+  let reconnectTimer = null;
+  const openOnce = () => {
+    ws = options.wsFactory(options.url);
+    ws.binaryType = "arraybuffer";
+    ws.onopen = () => {
+      if (retries === 0) onEvent({ type: "open" });
+      else onEvent({ type: "reconnected" });
+      retries = 0;
+      backoff = initialBackoff;
+    };
+    ws.onmessage = (ev) => {
+      onEvent({ type: "message", data: ev.data });
+    };
+    ws.onerror = () => {
+      onEvent({ type: "error", error: new Error("WebSocket error") });
+    };
+    ws.onclose = (ev) => {
+      ws = null;
+      const shouldRetry = !intentionalClose && retries < maxRetries;
+      if (!shouldRetry) {
+        onEvent({
+          type: "close",
+          code: ev.code,
+          reason: ev.reason,
+          permanent: true
+        });
+        return;
+      }
+      onEvent({
+        type: "close",
+        code: ev.code,
+        reason: ev.reason,
+        permanent: false
+      });
+      retries++;
+      const delay = Math.min(backoff, maxBackoff);
+      backoff = Math.min(backoff * 2, maxBackoff);
+      reconnectTimer = setTimeout(openOnce, delay);
+    };
+  };
+  openOnce();
+  return {
+    send: (data) => {
+      if (ws && ws.readyState === READYSTATE_OPEN) ws.send(data);
+    },
+    close: (code = 1e3, reason = "client-requested") => {
+      intentionalClose = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      try {
+        ws?.close(code, reason);
+      } catch {
+      }
+    },
+    readyState: () => ws?.readyState ?? READYSTATE_CLOSED
+  };
+};
+
+// src/protocol.ts
+var createProtocolState = () => ({
+  state: "idle",
+  transcript: [],
+  agentBubbleId: null,
+  idCounter: 0,
+  endReason: null
+});
+var mapEndReason = (raw) => {
+  if (raw === "agent_ended") return "agent_ended";
+  if (raw === "caller_hung_up") return "user_hangup";
+  if (raw === "silence_timeout" || raw === "max_duration") return "timeout";
+  return "error";
+};
+function handleServerMessage(raw, state, cb) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  switch (msg.type) {
+    case "connected":
+      setState(state, "listening", cb);
+      return;
+    case "transcript": {
+      const text = msg.text ?? "";
+      if (!text) return;
+      const isFinal = !!msg.isFinal;
+      if (!isFinal) setState(state, "user_speaking", cb);
+      upsertUserPartial(state, text, isFinal);
+      cb.onTranscript(state.transcript);
+      return;
+    }
+    case "agent_turn_start": {
+      const id = `m${state.idCounter++}`;
+      state.agentBubbleId = id;
+      state.transcript = [...state.transcript, { id, role: "agent", text: "" }];
+      cb.onTranscript(state.transcript);
+      cb.onAgentTurnStart();
+      setState(state, "agent_speaking", cb);
+      return;
+    }
+    case "agent_text": {
+      const delta = msg.text ?? "";
+      if (!delta || !state.agentBubbleId) return;
+      const id = state.agentBubbleId;
+      state.transcript = state.transcript.map(
+        (e) => e.id === id && e.role === "agent" ? { ...e, text: e.text + delta } : e
+      );
+      cb.onTranscript(state.transcript);
+      return;
+    }
+    case "agent_turn_end":
+      state.agentBubbleId = null;
+      setState(state, "listening", cb);
+      return;
+    case "interrupt":
+      cb.onInterrupt();
+      return;
+    case "agent_turn_abort": {
+      const committed = (msg.committedText ?? "").trim();
+      if (state.agentBubbleId) {
+        const id = state.agentBubbleId;
+        if (committed) {
+          state.transcript = state.transcript.map(
+            (e) => e.id === id && e.role === "agent" ? { ...e, text: committed, interrupted: true } : e
+          );
+        } else {
+          state.transcript = state.transcript.filter((e) => e.id !== id);
+        }
+        cb.onTranscript(state.transcript);
+      }
+      state.agentBubbleId = null;
+      return;
+    }
+    case "tool_call":
+      state.transcript = [
+        ...state.transcript,
+        {
+          id: `m${state.idCounter++}`,
+          role: "tool",
+          text: `\u2192 ${String(msg.tool ?? "?")}(${msg.args ? JSON.stringify(msg.args) : ""})`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      return;
+    case "tool_result":
+      state.transcript = [
+        ...state.transcript,
+        {
+          id: `m${state.idCounter++}`,
+          role: "tool",
+          text: `${msg.ok ? "\u2713" : "\u2717"} ${String(msg.tool ?? "?")}`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      return;
+    case "call_end": {
+      const reasonRaw = String(msg.reason ?? "");
+      const reason = mapEndReason(reasonRaw);
+      state.endReason = reason;
+      state.transcript = [
+        ...state.transcript,
+        {
+          id: `m${state.idCounter++}`,
+          role: "system",
+          text: `call ended${reasonRaw ? ` (${reasonRaw})` : ""}`
+        }
+      ];
+      cb.onTranscript(state.transcript);
+      cb.onCallEnd(reason);
+      return;
+    }
+    case "error": {
+      const code = msg.code ?? "server_error";
+      const message = msg.message ?? "server error";
+      cb.onError({ code, message });
+      return;
+    }
+  }
+}
+var setState = (state, next, cb) => {
+  if (state.state === next) return;
+  state.state = next;
+  cb.onState(next);
+};
+var upsertUserPartial = (state, text, isFinal) => {
+  let idx = -1;
+  for (let i = state.transcript.length - 1; i >= 0; i--) {
+    const e = state.transcript[i];
+    if (e.role === "user" && e.committed === false) {
+      idx = i;
+      break;
+    }
+  }
+  if (idx === -1) {
+    state.transcript = [
+      ...state.transcript,
+      { id: `m${state.idCounter++}`, role: "user", text, committed: isFinal }
+    ];
+    return;
+  }
+  const target = state.transcript[idx];
+  const next = [...state.transcript];
+  next[idx] = { ...target, text, committed: isFinal };
+  state.transcript = next;
+};
+function buildWsUrl(args) {
+  const base = new URL(args.apiBase);
+  const proto = base.protocol === "https:" ? "wss:" : "ws:";
+  const bargeQS = args.bargeIn === false ? "&barge=off" : "";
+  return `${proto}//${base.host}/v1/agents/${encodeURIComponent(args.agentId)}/call?token=${encodeURIComponent(args.token)}${bargeQS}`;
+}
+
+// src/VoiceClient.ts
+var BrowserVoiceClient = class {
+  constructor(args) {
+    this.rws = null;
+    this.capture = null;
+    this.playback = null;
+    this.muted = false;
+    this.inputVolume = 0;
+    this.outputVolume = 0;
+    this.startedAt = null;
+    this.endedFired = false;
+    this.lastError = null;
+    this.end = () => {
+      this.teardown("user_hangup");
+    };
+    this.mute = () => {
+      if (this.muted) return;
+      this.muted = true;
+      this.capture?.mute(true);
+    };
+    this.unmute = () => {
+      if (!this.muted) return;
+      this.muted = false;
+      this.capture?.mute(false);
+    };
+    // ---------------------------------------------------------------
+    // Internal
+    // ---------------------------------------------------------------
+    this.setState = (next) => {
+      if (this.proto.state === next) return;
+      this.proto.state = next;
+      this.args.options.onStateChange?.(next);
+    };
+    this.emitError = (err) => {
+      this.lastError = err;
+      this.args.options.onError?.(err);
+    };
+    this.handleSocketEvent = (ev) => {
+      switch (ev.type) {
+        case "open":
+          void this.startCapture();
+          break;
+        case "reconnected":
+          this.proto.transcript = [];
+          this.proto.agentBubbleId = null;
+          this.args.options.onTranscript?.(this.proto.transcript);
+          void this.startCapture();
+          this.setState("listening");
+          break;
+        case "message":
+          if (typeof ev.data === "string") {
+            handleServerMessage(ev.data, this.proto, {
+              onState: this.setState,
+              onTranscript: (entries) => this.args.options.onTranscript?.(entries),
+              onError: this.emitError,
+              onInterrupt: () => this.playback?.flush(),
+              onAgentTurnStart: () => void 0,
+              onCallEnd: (reason) => this.teardown(reason)
+            });
+          } else {
+            this.playback?.enqueue(ev.data);
+          }
+          break;
+        case "close":
+          if (ev.permanent) {
+            const reason = this.proto.endReason ?? (this.lastError ? "error" : "user_hangup");
+            this.teardown(reason);
+          }
+          break;
+        case "error":
+          this.emitError({ code: "socket_error", message: ev.error.message });
+          break;
+      }
+    };
+    this.startCapture = async () => {
+      if (this.capture?.isCapturing()) return;
+      this.capture = createAudioCapture({
+        onChunk: (pcm) => {
+          this.rws?.send(pcm);
+        },
+        onVolume: (v) => {
+          this.inputVolume = v;
+          this.args.options.onVolume?.({ input: v, output: this.outputVolume });
+        },
+        onError: (err) => {
+          this.emitError({
+            code: err.name === "NotAllowedError" ? "mic_denied" : "mic_start_failed",
+            message: err.message
+          });
+        }
+      });
+      if (this.muted) this.capture.mute(true);
+      try {
+        await this.capture.start();
+      } catch {
+      }
+    };
+    this.teardown = (reason) => {
+      this.capture?.stop();
+      this.capture = null;
+      this.playback?.close();
+      this.playback = null;
+      try {
+        this.rws?.close(1e3, reason);
+      } catch {
+      }
+      this.rws = null;
+      this.setState("ended");
+      this.fireEndOnce(reason);
+    };
+    this.fireEndOnce = (reason) => {
+      if (this.endedFired) return;
+      this.endedFired = true;
+      const startedAt = this.startedAt ?? Date.now();
+      this.args.options.onEnd?.({
+        reason,
+        errorCode: reason === "error" ? this.lastError?.code : void 0,
+        durationMs: Date.now() - startedAt
+      });
+    };
+    this.args = args;
+    this.proto = createProtocolState();
+  }
+  // ---------------------------------------------------------------
+  // Call interface
+  // ---------------------------------------------------------------
+  get state() {
+    return this.proto.state;
+  }
+  get transcript() {
+    return this.proto.transcript.slice();
+  }
+  get isMuted() {
+    return this.muted;
+  }
+  // ---------------------------------------------------------------
+  // Lifecycle — called by the factory immediately after construction.
+  // Resolves once the WS is open and capture is starting; mid-call
+  // failures arrive via `onError`.
+  // ---------------------------------------------------------------
+  async start() {
+    this.setState("connecting");
+    this.startedAt = Date.now();
+    const url = buildWsUrl({
+      apiBase: this.args.config.apiBase,
+      agentId: this.args.options.agentId,
+      token: this.args.token,
+      bargeIn: this.args.options.bargeIn
+    });
+    this.playback = createAudioPlayback({
+      onVolume: (v) => {
+        this.outputVolume = v;
+        this.args.options.onVolume?.({ input: this.inputVolume, output: v });
+      }
+    });
+    try {
+      await this.playback.resume();
+    } catch {
+    }
+    this.rws = createReconnectingWebSocket(
+      {
+        url,
+        wsFactory: this.args.wsFactory,
+        maxRetries: 3
+      },
+      (ev) => this.handleSocketEvent(ev)
+    );
+  }
+};
+
+// src/browser.ts
+var browserWsFactory = (url) => new globalThis.WebSocket(url);
+var BrowserVoiceFactory = class {
+  constructor(config) {
+    this.startCall = async (options) => {
+      if (!options.agentId) {
+        throw new Error("startCall: agentId is required");
+      }
+      const { context, metadata } = mergeStartCallContext(this.config, options);
+      const fetchArgs = {
+        agentId: options.agentId,
+        userId: options.userId,
+        context,
+        metadata
+      };
+      let token;
+      if (options.token) {
+        token = options.token;
+      } else {
+        token = await this.config.fetchToken(fetchArgs);
+        if (!token) {
+          throw new Error("configureVoiceClient.fetchToken returned empty token");
+        }
+      }
+      const client = new BrowserVoiceClient({
+        config: this.config,
+        // Carry merged context/metadata through to startCall so server can
+        // see what the SDK saw.
+        options: { ...options, context, metadata },
+        token,
+        wsFactory: browserWsFactory
+      });
+      await client.start();
+      return client;
+    };
+    this.config = config;
+  }
+};
+function configureVoiceClient(config) {
+  return new BrowserVoiceFactory(normalizeConfig(config));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildWsUrl,
+  configureVoiceClient,
+  createAudioCapture,
+  createAudioPlayback,
+  createProtocolState,
+  createReconnectingWebSocket,
+  handleServerMessage
+});
+//# sourceMappingURL=browser.js.map