@absolutejs/voice 0.0.22-beta.67 → 0.0.22-beta.670

package/dist/client/htmxBootstrap.js

@@ -1,3 +1,6 @@
+// src/internal/html.ts
+var escapeHtml = (value) => String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
 var DEFAULT_QUERY_PARAM = "sessionId";
@@ -100,37 +103,89 @@ var createMicrophoneCapture = (options) => {
   let sourceNode = null;
   let processorNode = null;
   let mediaStream = null;
-  const start = async () => {
-    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
-      throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
-    }
-    const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
-    if (!AudioContextCtor) {
-      throw new Error("Browser microphone capture requires AudioContext support.");
-    }
-    mediaStream = await navigator.mediaDevices.getUserMedia({
-      audio: {
-        channelCount: options.channelCount ?? 1
+  let lifecycleGeneration = 0;
+  let startPromise = null;
+  const release = (resources) => {
+    resources.processorNode?.disconnect();
+    resources.sourceNode?.disconnect();
+    resources.mediaStream?.getTracks().forEach((track) => track.stop());
+    resources.audioContext?.close();
+  };
+  const start = () => {
+    if (mediaStream)
+      return Promise.resolve();
+    if (startPromise)
+      return startPromise;
+    const generation = ++lifecycleGeneration;
+    const operation = async () => {
+      if (!options.stream && (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia)) {
+        throw new Error("Browser microphone capture requires navigator.mediaDevices.getUserMedia.");
+      }
+      const AudioContextCtor = (typeof window !== "undefined" ? window.AudioContext ?? window.webkitAudioContext : undefined) ?? AudioContext;
+      if (!AudioContextCtor) {
+        throw new Error("Browser microphone capture requires AudioContext support.");
+      }
+      let pendingAudioContext = null;
+      let pendingMediaStream = null;
+      let pendingProcessorNode = null;
+      let pendingSourceNode = null;
+      try {
+        pendingMediaStream = options.stream ?? await navigator.mediaDevices.getUserMedia({
+          audio: {
+            autoGainControl: true,
+            channelCount: options.channelCount ?? 1,
+            echoCancellation: true,
+            noiseSuppression: true
+          }
+        });
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
+        }
+        pendingAudioContext = new AudioContextCtor;
+        if (pendingAudioContext.state === "suspended") {
+          await pendingAudioContext.resume();
+        }
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
+        }
+        pendingSourceNode = pendingAudioContext.createMediaStreamSource(pendingMediaStream);
+        pendingProcessorNode = pendingAudioContext.createScriptProcessor(4096, 1, 1);
+        pendingProcessorNode.onaudioprocess = (event) => {
+          const channel = event.inputBuffer.getChannelData(0);
+          const downsampled = downsampleBuffer(channel, pendingAudioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
+          const pcm = floatTo16BitPCM(downsampled);
+          options.onLevel?.(getPcmLevel(pcm));
+          options.onAudio(pcm);
+        };
+        pendingSourceNode.connect(pendingProcessorNode);
+        pendingProcessorNode.connect(pendingAudioContext.destination);
+        if (generation !== lifecycleGeneration) {
+          throw new Error("Microphone capture stopped during startup.");
+        }
+        audioContext = pendingAudioContext;
+        mediaStream = pendingMediaStream;
+        processorNode = pendingProcessorNode;
+        sourceNode = pendingSourceNode;
+      } catch (error) {
+        release({
+          audioContext: pendingAudioContext,
+          mediaStream: pendingMediaStream,
+          processorNode: pendingProcessorNode,
+          sourceNode: pendingSourceNode
+        });
+        throw error;
       }
-    });
-    audioContext = new AudioContextCtor;
-    sourceNode = audioContext.createMediaStreamSource(mediaStream);
-    processorNode = audioContext.createScriptProcessor(4096, 1, 1);
-    processorNode.onaudioprocess = (event) => {
-      const channel = event.inputBuffer.getChannelData(0);
-      const downsampled = downsampleBuffer(channel, audioContext?.sampleRate ?? 48000, options.sampleRateHz ?? 16000);
-      const pcm = floatTo16BitPCM(downsampled);
-      options.onLevel?.(getPcmLevel(pcm));
-      options.onAudio(pcm);
     };
-    sourceNode.connect(processorNode);
-    processorNode.connect(audioContext.destination);
+    const pending = operation().finally(() => {
+      if (startPromise === pending)
+        startPromise = null;
+    });
+    startPromise = pending;
+    return pending;
   };
   const stop = () => {
-    processorNode?.disconnect();
-    sourceNode?.disconnect();
-    mediaStream?.getTracks().forEach((track) => track.stop());
-    audioContext?.close();
+    lifecycleGeneration += 1;
+    release({ audioContext, mediaStream, processorNode, sourceNode });
     options.onLevel?.(0);
     audioContext = null;
     mediaStream = null;
@@ -181,13 +236,25 @@ var serverMessageToAction = (message) => {
     case "assistant":
       return {
         text: message.text,
+        turnId: message.turnId,
         type: "assistant"
       };
+    case "assistant_delta":
+      return {
+        delta: message.delta,
+        turnId: message.turnId,
+        type: "assistant_delta"
+      };
     case "complete":
       return {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "connection":
+      return {
+        reconnect: message.reconnect,
+        type: "connection"
+      };
     case "call_lifecycle":
       return {
         event: message.event,
@@ -197,8 +264,11 @@ var serverMessageToAction = (message) => {
     case "error":
       return {
         message: normalizeErrorMessage(message.message),
+        recoverable: message.recoverable,
         type: "error"
       };
+    case "call_control_ack":
+      return null;
     case "final":
       return {
         transcript: message.transcript,
@@ -209,9 +279,29 @@ var serverMessageToAction = (message) => {
         transcript: message.transcript,
         type: "partial"
       };
+    case "playback_rate":
+      return {
+        rate: message.rate,
+        type: "playback_rate"
+      };
+    case "replay":
+      return {
+        assistantTexts: message.assistantTexts,
+        call: message.call,
+        partial: message.partial,
+        scenarioId: message.scenarioId,
+        sessionId: message.sessionId,
+        sessionMetadata: message.sessionMetadata,
+        status: message.status,
+        turns: message.turns,
+        type: "replay"
+      };
     case "session":
       return {
+        paused: message.paused,
+        pauseExpiresAt: message.pauseExpiresAt,
         sessionId: message.sessionId,
+        sessionMetadata: message.sessionMetadata,
         scenarioId: message.scenarioId,
         status: message.status,
         type: "session"
@@ -226,30 +316,276 @@ var serverMessageToAction = (message) => {
   }
 };
 
+// node_modules/@absolutejs/media/dist/index.js
+var TAU = Math.PI * 2;
+var pushIssue = (issues, severity, code, message) => {
+  issues.push({ code, message, severity });
+};
+var average = (values) => values.length === 0 ? undefined : values.reduce((total, value) => total + value, 0) / values.length;
+var max = (values) => values.length === 0 ? undefined : Math.max(...values);
+var numericStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+var booleanStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "boolean" ? value : undefined;
+};
+var stringStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "string" ? value : undefined;
+};
+var statKey = (stat) => String(stat.id ?? stringStat(stat, "ssrc") ?? numericStat(stat, "ssrc") ?? stringStat(stat, "trackIdentifier") ?? stringStat(stat, "mid") ?? "unknown");
+var secondsToMs = (value) => value === undefined ? undefined : value * 1000;
+var normalizeWebRTCStat = (stat) => {
+  const sample = {};
+  for (const [key, value] of Object.entries(stat)) {
+    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      sample[key] = value;
+    }
+  }
+  return sample;
+};
+var buildMediaWebRTCStatsReport = (input = {}) => {
+  const stats = input.stats ?? [];
+  const issues = [];
+  const inbound = stats.filter((stat) => stat.type === "inbound-rtp" && stringStat(stat, "kind") !== "video");
+  const outbound = stats.filter((stat) => stat.type === "outbound-rtp" && stringStat(stat, "kind") !== "video");
+  const candidatePairs = stats.filter((stat) => stat.type === "candidate-pair");
+  const audioTracks = stats.filter((stat) => (stat.type === "track" || stat.type === "media-source") && stringStat(stat, "kind") === "audio");
+  const activeCandidatePairs = candidatePairs.filter((stat) => booleanStat(stat, "selected") === true || booleanStat(stat, "nominated") === true || stringStat(stat, "state") === "succeeded").length;
+  const liveAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") !== "ended" && stringStat(stat, "trackState") !== "ended" && booleanStat(stat, "ended") !== true).length;
+  const endedAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") === "ended" || stringStat(stat, "trackState") === "ended" || booleanStat(stat, "ended") === true).length;
+  const inboundPackets = inbound.reduce((total, stat) => total + (numericStat(stat, "packetsReceived") ?? 0), 0);
+  const outboundPackets = outbound.reduce((total, stat) => total + (numericStat(stat, "packetsSent") ?? 0), 0);
+  const packetsLost = [...inbound, ...outbound].reduce((total, stat) => total + Math.max(0, numericStat(stat, "packetsLost") ?? 0), 0);
+  const packetLossDenominator = inboundPackets + packetsLost;
+  const packetLossRatio = packetLossDenominator === 0 ? 0 : packetsLost / packetLossDenominator;
+  const bytesReceived = inbound.reduce((total, stat) => total + (numericStat(stat, "bytesReceived") ?? 0), 0);
+  const bytesSent = outbound.reduce((total, stat) => total + (numericStat(stat, "bytesSent") ?? 0), 0);
+  const roundTripTimeMs = max(candidatePairs.map((stat) => secondsToMs(numericStat(stat, "currentRoundTripTime") ?? numericStat(stat, "roundTripTime"))).filter((value) => value !== undefined));
+  const jitterMs = max([...inbound, ...outbound].map((stat) => secondsToMs(numericStat(stat, "jitter"))).filter((value) => value !== undefined));
+  const jitterBufferDelayMs = max(inbound.map((stat) => {
+    const delay = numericStat(stat, "jitterBufferDelay");
+    const emitted = numericStat(stat, "jitterBufferEmittedCount");
+    return delay !== undefined && emitted !== undefined && emitted > 0 ? delay / emitted * 1000 : undefined;
+  }).filter((value) => value !== undefined));
+  const audioLevels = audioTracks.map((stat) => numericStat(stat, "audioLevel")).filter((value) => value !== undefined);
+  if (input.requireConnectedCandidatePair && candidatePairs.length > 0 && activeCandidatePairs === 0) {
+    pushIssue(issues, "error", "media.webrtc_candidate_pair_missing", "No active WebRTC candidate pair was observed.");
+  }
+  if (input.requireLiveAudioTrack && liveAudioTracks === 0) {
+    pushIssue(issues, "error", "media.webrtc_audio_track_missing", "No live WebRTC audio track was observed.");
+  }
+  if (input.maxPacketLossRatio !== undefined && packetLossRatio > input.maxPacketLossRatio) {
+    pushIssue(issues, "warning", "media.webrtc_packet_loss", `Observed WebRTC packet loss ratio ${String(packetLossRatio)} above ${String(input.maxPacketLossRatio)}.`);
+  }
+  if (input.maxRoundTripTimeMs !== undefined && roundTripTimeMs !== undefined && roundTripTimeMs > input.maxRoundTripTimeMs) {
+    pushIssue(issues, "warning", "media.webrtc_round_trip_time", `Observed WebRTC RTT ${String(roundTripTimeMs)}ms above ${String(input.maxRoundTripTimeMs)}ms.`);
+  }
+  if (input.maxJitterMs !== undefined && jitterMs !== undefined && jitterMs > input.maxJitterMs) {
+    pushIssue(issues, "warning", "media.webrtc_jitter", `Observed WebRTC jitter ${String(jitterMs)}ms above ${String(input.maxJitterMs)}ms.`);
+  }
+  return {
+    activeCandidatePairs,
+    audioLevelAverage: average(audioLevels),
+    bytesReceived,
+    bytesSent,
+    checkedAt: Date.now(),
+    endedAudioTracks,
+    inboundPackets,
+    issues,
+    jitterBufferDelayMs,
+    jitterMs,
+    liveAudioTracks,
+    outboundPackets,
+    packetLossRatio,
+    packetsLost,
+    roundTripTimeMs,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    totalStats: stats.length
+  };
+};
+var collectMediaWebRTCStats = async (input) => {
+  const report = await input.peerConnection.getStats(input.selector ?? null);
+  return [...report.values()].map(normalizeWebRTCStat);
+};
+var buildMediaWebRTCStreamContinuityReport = (input = {}) => {
+  const stats = input.stats ?? [];
+  const previousStats = input.previousStats ?? [];
+  const issues = [];
+  const previousByKey = new Map(previousStats.map((stat) => [statKey(stat), stat]));
+  const audioRtp = stats.filter((stat) => (stat.type === "inbound-rtp" || stat.type === "outbound-rtp") && stringStat(stat, "kind") !== "video" && stringStat(stat, "mediaType") !== "video");
+  const streams = audioRtp.map((stat) => {
+    const direction = stat.type === "outbound-rtp" ? "outbound" : "inbound";
+    const packetsKey = direction === "outbound" ? "packetsSent" : "packetsReceived";
+    const bytesKey = direction === "outbound" ? "bytesSent" : "bytesReceived";
+    const previous = previousByKey.get(statKey(stat));
+    const currentPackets = numericStat(stat, packetsKey);
+    const previousPackets = previous ? numericStat(previous, packetsKey) : undefined;
+    const currentBytes = numericStat(stat, bytesKey);
+    const previousBytes = previous ? numericStat(previous, bytesKey) : undefined;
+    const timeDeltaMs = stat.timestamp !== undefined && previous?.timestamp !== undefined ? stat.timestamp - previous.timestamp : undefined;
+    return {
+      bytesDelta: currentBytes !== undefined && previousBytes !== undefined ? currentBytes - previousBytes : undefined,
+      currentPackets,
+      direction,
+      id: statKey(stat),
+      packetDelta: currentPackets !== undefined && previousPackets !== undefined ? currentPackets - previousPackets : undefined,
+      previousPackets,
+      timeDeltaMs
+    };
+  });
+  const inbound = streams.filter((stream) => stream.direction === "inbound");
+  const outbound = streams.filter((stream) => stream.direction === "outbound");
+  const maxObservedGapMs = max(streams.map((stream) => stream.timeDeltaMs).filter((value) => value !== undefined));
+  const stalledInboundStreams = inbound.filter((stream) => input.maxInboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxInboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
+  const stalledOutboundStreams = outbound.filter((stream) => input.maxOutboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxOutboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
+  if (input.requireInboundAudio && inbound.length === 0) {
+    pushIssue(issues, "error", "media.webrtc_inbound_audio_missing", "No inbound WebRTC audio RTP stream was observed.");
+  }
+  if (input.requireOutboundAudio && outbound.length === 0) {
+    pushIssue(issues, "error", "media.webrtc_outbound_audio_missing", "No outbound WebRTC audio RTP stream was observed.");
+  }
+  if (input.maxGapMs !== undefined && maxObservedGapMs !== undefined && maxObservedGapMs > input.maxGapMs) {
+    pushIssue(issues, "warning", "media.webrtc_stream_gap", `Observed WebRTC stream sample gap ${String(maxObservedGapMs)}ms above ${String(input.maxGapMs)}ms.`);
+  }
+  if (stalledInboundStreams > 0) {
+    pushIssue(issues, "error", "media.webrtc_inbound_stalled", `${String(stalledInboundStreams)} inbound WebRTC audio stream(s) stopped receiving packets.`);
+  }
+  if (stalledOutboundStreams > 0) {
+    pushIssue(issues, "error", "media.webrtc_outbound_stalled", `${String(stalledOutboundStreams)} outbound WebRTC audio stream(s) stopped sending packets.`);
+  }
+  return {
+    checkedAt: Date.now(),
+    inboundAudioStreams: inbound.length,
+    issues,
+    maxObservedGapMs,
+    outboundAudioStreams: outbound.length,
+    stalledInboundStreams,
+    stalledOutboundStreams,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    streams,
+    totalStats: stats.length
+  };
+};
+
+// src/client/browserMedia.ts
+var DEFAULT_BROWSER_MEDIA_PATH = "/api/voice/browser-media";
+var DEFAULT_BROWSER_MEDIA_INTERVAL_MS = 5000;
+var resolvePeerConnection = async (options) => options.peerConnection ?? await options.getPeerConnection?.() ?? null;
+var postBrowserMediaReport = async (payload, options) => {
+  const requestFetch = options.fetch ?? globalThis.fetch;
+  if (!requestFetch) {
+    return;
+  }
+  await requestFetch(options.path ?? DEFAULT_BROWSER_MEDIA_PATH, {
+    body: JSON.stringify(payload),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    keepalive: true,
+    method: "POST"
+  });
+};
+var createVoiceBrowserMediaReporter = (options) => {
+  let interval = null;
+  let previousStats = [];
+  const reportOnce = async () => {
+    const peerConnection = await resolvePeerConnection(options);
+    if (!peerConnection) {
+      return;
+    }
+    const stats = await collectMediaWebRTCStats({ peerConnection });
+    const report = buildMediaWebRTCStatsReport({
+      ...options,
+      stats
+    });
+    const continuity = options.continuity === false ? undefined : buildMediaWebRTCStreamContinuityReport({
+      ...options.continuity,
+      previousStats,
+      stats
+    });
+    const payload = {
+      at: Date.now(),
+      continuity,
+      report,
+      scenarioId: options.getScenarioId?.() ?? null,
+      sessionId: options.getSessionId?.() ?? null
+    };
+    previousStats = stats;
+    options.onReport?.(payload);
+    await postBrowserMediaReport(payload, options);
+    return payload;
+  };
+  const run = () => {
+    reportOnce().catch((error) => {
+      options.onError?.(error);
+    });
+  };
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+  };
+  return {
+    close: stop,
+    reportOnce,
+    stop,
+    start: () => {
+      if (interval) {
+        return;
+      }
+      run();
+      interval = setInterval(run, options.intervalMs ?? DEFAULT_BROWSER_MEDIA_INTERVAL_MS);
+    }
+  };
+};
+
 // src/client/connection.ts
 var WS_OPEN = 1;
 var WS_CLOSED = 3;
 var WS_NORMAL_CLOSURE = 1000;
-var DEFAULT_MAX_RECONNECT_ATTEMPTS = 10;
+var WS_UNAUTHORIZED = 4401;
+var WS_FORBIDDEN = 4403;
+var WS_INITIALIZATION_FAILED = 4500;
+var DEFAULT_MAX_RECONNECT_ATTEMPTS = 15;
 var DEFAULT_PING_INTERVAL = 30000;
-var RECONNECT_DELAY_MS = 500;
+var DEFAULT_RECONNECT_RESET_AFTER_MS = 30000;
+var DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS = 5000;
+var DEFAULT_PREPARE_RECONNECT_TIMEOUT_MS = 1e4;
+var MAX_PENDING_CONTROL_MESSAGES = 100;
+var RECONNECT_BASE_DELAY_MS = 500;
+var DEFAULT_RECONNECT_MAX_DELAY_MS = 8000;
+var computeVoiceReconnectDelayMs = (attempt, baseMs, maxDelayMs) => Math.min(maxDelayMs, baseMs * 2 ** (Math.max(1, attempt) - 1));
 var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
+
+class VoiceReconnectRejectedError extends Error {
+  constructor(message = "Voice authorization could not be renewed.") {
+    super(message);
+    this.name = "VoiceReconnectRejectedError";
+  }
+}
 var noop = () => {};
+var noopAsync = () => Promise.resolve();
 var noopUnsubscribe = () => noop;
 var NOOP_CONNECTION = {
-  callControl: noop,
+  callControl: noopAsync,
   close: noop,
+  disconnect: noop,
   endTurn: noop,
+  send: noop,
+  sendAudio: noop,
+  simulateDisconnect: noop,
+  subscribe: noopUnsubscribe,
   getReadyState: () => WS_CLOSED,
   getScenarioId: () => "",
   getSessionId: () => "",
-  send: noop,
-  sendAudio: noop,
-  start: () => {},
-  subscribe: noopUnsubscribe
+  start: () => {}
 };
 var createSessionId = () => crypto.randomUUID();
-var buildWsUrl = (path, sessionId, scenarioId) => {
+var buildWsUrl = (path, sessionId, scenarioId, query) => {
   const { hostname, port, protocol } = window.location;
   const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
   const portSuffix = port ? `:${port}` : "";
@@ -258,6 +594,11 @@ var buildWsUrl = (path, sessionId, scenarioId) => {
   if (scenarioId) {
     url.searchParams.set(DEFAULT_SCENARIO_QUERY_PARAM, scenarioId);
   }
+  for (const [key, value] of Object.entries(query)) {
+    if (key !== "sessionId" && key !== DEFAULT_SCENARIO_QUERY_PARAM && value) {
+      url.searchParams.set(key, value);
+    }
+  }
   return url.toString();
 };
 var isVoiceServerMessage = (value) => {
@@ -268,11 +609,15 @@ var isVoiceServerMessage = (value) => {
     case "audio":
     case "assistant":
     case "call_lifecycle":
+    case "call_control_ack":
     case "complete":
+    case "connection":
     case "error":
     case "final":
     case "partial":
+    case "playback_rate":
     case "pong":
+    case "replay":
     case "session":
     case "turn":
       return true;
@@ -296,19 +641,45 @@ var createVoiceConnection = (path, options = {}) => {
     return NOOP_CONNECTION;
   }
   const listeners = new Set;
+  const pendingCallControls = new Map;
   const shouldReconnect = options.reconnect !== false;
   const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
+  const reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
   const pingInterval = options.pingInterval ?? DEFAULT_PING_INTERVAL;
+  const reconnectResetAfterMs = options.reconnectResetAfterMs ?? DEFAULT_RECONNECT_RESET_AFTER_MS;
+  let lifecycleGeneration = 0;
+  let disposed = false;
+  let reconnectPreparationAbort = null;
+  const computeReconnectDelayMs = (attempt) => computeVoiceReconnectDelayMs(attempt, RECONNECT_BASE_DELAY_MS, reconnectMaxDelayMs);
   const state = {
     isConnected: false,
     pendingMessages: [],
     scenarioId: options.scenarioId ?? null,
     pingInterval: null,
     reconnectAttempts: 0,
+    reconnectResetTimeout: null,
     reconnectTimeout: null,
     sessionId: options.sessionId ?? createSessionId(),
     ws: null
   };
+  const emitConnection = (reconnect) => {
+    listeners.forEach((listener) => listener(reconnect));
+  };
+  const emitTerminalFailure = (message) => {
+    listeners.forEach((listener) => listener({
+      message,
+      recoverable: false,
+      type: "error"
+    }));
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        maxAttempts: maxReconnectAttempts,
+        status: "exhausted"
+      },
+      type: "connection"
+    });
+  };
   const clearTimers = () => {
     if (state.pingInterval) {
       clearInterval(state.pingInterval);
@@ -318,6 +689,10 @@ var createVoiceConnection = (path, options = {}) => {
       clearTimeout(state.reconnectTimeout);
       state.reconnectTimeout = null;
     }
+    if (state.reconnectResetTimeout) {
+      clearTimeout(state.reconnectResetTimeout);
+      state.reconnectResetTimeout = null;
+    }
   };
   const flushPendingMessages = () => {
     if (state.ws?.readyState !== WS_OPEN) {
@@ -330,28 +705,111 @@ var createVoiceConnection = (path, options = {}) => {
       }
     }
   };
+  const rejectPendingCallControls = (message) => {
+    for (const pending of pendingCallControls.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(message));
+    }
+    pendingCallControls.clear();
+  };
   const scheduleReconnect = () => {
+    if (disposed)
+      return;
+    const scheduledGeneration = lifecycleGeneration;
     state.reconnectAttempts += 1;
-    state.reconnectTimeout = setTimeout(() => {
+    const delayMs = computeReconnectDelayMs(state.reconnectAttempts);
+    const nextAttemptAt = Date.now() + delayMs;
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        lastDisconnectAt: Date.now(),
+        maxAttempts: maxReconnectAttempts,
+        nextAttemptAt,
+        status: "reconnecting"
+      },
+      type: "connection"
+    });
+    state.reconnectTimeout = setTimeout(async () => {
+      if (disposed || lifecycleGeneration !== scheduledGeneration)
+        return;
       if (state.reconnectAttempts > maxReconnectAttempts) {
+        emitTerminalFailure("Voice connection could not be restored.");
+        return;
+      }
+      try {
+        if (options.prepareReconnect) {
+          const preparationAbort = new AbortController;
+          reconnectPreparationAbort = preparationAbort;
+          const timeout = setTimeout(() => preparationAbort.abort("Voice reconnect preparation timed out"), options.prepareReconnectTimeoutMs ?? DEFAULT_PREPARE_RECONNECT_TIMEOUT_MS);
+          try {
+            await Promise.race([
+              options.prepareReconnect({
+                attempt: state.reconnectAttempts,
+                path,
+                scenarioId: state.scenarioId,
+                sessionId: state.sessionId,
+                signal: preparationAbort.signal
+              }),
+              new Promise((_, reject) => {
+                preparationAbort.signal.addEventListener("abort", () => reject(new Error("Voice reconnect preparation timed out.")), { once: true });
+              })
+            ]);
+          } finally {
+            clearTimeout(timeout);
+            if (reconnectPreparationAbort === preparationAbort) {
+              reconnectPreparationAbort = null;
+            }
+          }
+        }
+      } catch (error) {
+        if (disposed || lifecycleGeneration !== scheduledGeneration)
+          return;
+        if (error instanceof VoiceReconnectRejectedError) {
+          emitTerminalFailure(error.message);
+          return;
+        }
+        if (state.reconnectAttempts < maxReconnectAttempts) {
+          scheduleReconnect();
+        } else {
+          emitTerminalFailure("Voice authorization could not be renewed for reconnect.");
+        }
         return;
       }
+      if (disposed || lifecycleGeneration !== scheduledGeneration)
+        return;
       connect();
-    }, RECONNECT_DELAY_MS);
+    }, delayMs);
   };
   const connect = () => {
-    const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
+    if (disposed)
+      return;
+    const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId, options.query ?? {}));
     ws.binaryType = "arraybuffer";
     ws.onopen = () => {
+      if (state.ws !== ws) {
+        ws.close(WS_NORMAL_CLOSURE);
+        return;
+      }
+      const wasReconnecting = state.reconnectAttempts > 0;
       state.isConnected = true;
-      state.reconnectAttempts = 0;
       flushPendingMessages();
-      listeners.forEach((listener) => listener({
-        scenarioId: state.scenarioId ?? undefined,
-        sessionId: state.sessionId,
-        status: "active",
-        type: "session"
-      }));
+      if (wasReconnecting) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastResumedAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "resumed"
+          },
+          type: "connection"
+        });
+        state.reconnectResetTimeout = setTimeout(() => {
+          if (state.ws === ws && ws.readyState === WS_OPEN) {
+            state.reconnectAttempts = 0;
+          }
+          state.reconnectResetTimeout = null;
+        }, reconnectResetAfterMs);
+      }
       state.pingInterval = setInterval(() => {
         if (ws.readyState === WS_OPEN) {
           ws.send(JSON.stringify({ type: "ping" }));
@@ -359,6 +817,8 @@ var createVoiceConnection = (path, options = {}) => {
       }, pingInterval);
     };
     ws.onmessage = (event) => {
+      if (state.ws !== ws)
+        return;
       const parsed = parseServerMessage(event);
       if (!parsed) {
         return;
@@ -367,29 +827,86 @@ var createVoiceConnection = (path, options = {}) => {
         state.sessionId = parsed.sessionId;
         state.scenarioId = parsed.scenarioId ?? state.scenarioId;
       }
+      if (parsed.type === "call_control_ack") {
+        const pending = pendingCallControls.get(parsed.requestId);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          pendingCallControls.delete(parsed.requestId);
+          if (parsed.ok) {
+            pending.resolve();
+          } else {
+            pending.reject(new Error(parsed.message ?? `${parsed.action} was not applied`));
+          }
+        }
+      }
       listeners.forEach((listener) => listener(parsed));
     };
     ws.onclose = (event) => {
+      if (state.ws !== ws)
+        return;
+      state.ws = null;
       state.isConnected = false;
       clearTimers();
-      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
+      rejectPendingCallControls("Voice connection interrupted");
+      const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && event.code !== WS_UNAUTHORIZED && event.code !== WS_FORBIDDEN && event.code !== WS_INITIALIZATION_FAILED && state.reconnectAttempts < maxReconnectAttempts;
+      const authorizationFailure = event.code === WS_UNAUTHORIZED || event.code === WS_FORBIDDEN;
+      const initializationFailure = event.code === WS_INITIALIZATION_FAILED;
+      if (authorizationFailure) {
+        listeners.forEach((listener) => listener({
+          message: event.code === WS_UNAUTHORIZED ? "Voice authorization expired or was rejected." : "Voice authorization was forbidden.",
+          recoverable: false,
+          type: "error"
+        }));
+      }
+      if (initializationFailure) {
+        listeners.forEach((listener) => listener({
+          message: "Voice provider initialization failed.",
+          recoverable: false,
+          type: "error"
+        }));
+      }
       if (reconnectable) {
         scheduleReconnect();
+      } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
+        if (authorizationFailure) {
+          emitConnection({
+            reconnect: {
+              attempts: state.reconnectAttempts,
+              lastDisconnectAt: Date.now(),
+              maxAttempts: maxReconnectAttempts,
+              status: "exhausted"
+            },
+            type: "connection"
+          });
+        } else if (!initializationFailure) {
+          emitTerminalFailure("Voice connection could not be restored.");
+        }
       }
     };
     state.ws = ws;
   };
   const sendSerialized = (value) => {
+    if (disposed)
+      return;
     if (state.ws?.readyState === WS_OPEN) {
       state.ws.send(value);
       return;
     }
+    if (typeof value !== "string") {
+      return;
+    }
+    if (state.pendingMessages.length >= MAX_PENDING_CONTROL_MESSAGES) {
+      state.pendingMessages.shift();
+    }
     state.pendingMessages.push(value);
   };
   const send = (message) => {
     sendSerialized(JSON.stringify(message));
   };
   const start = (input = {}) => {
+    if (input.sessionId && input.sessionId !== state.sessionId) {
+      throw new Error("Voice session switching requires a new connection instance.");
+    }
     if (input.sessionId) {
       state.sessionId = input.sessionId;
     }
@@ -397,9 +914,9 @@ var createVoiceConnection = (path, options = {}) => {
       state.scenarioId = input.scenarioId;
     }
     send({
-      type: "start",
+      scenarioId: state.scenarioId ?? undefined,
       sessionId: state.sessionId,
-      scenarioId: state.scenarioId ?? undefined
+      type: "start"
     });
   };
   const sendAudio = (audio) => {
@@ -409,20 +926,63 @@ var createVoiceConnection = (path, options = {}) => {
     send({ type: "end_turn" });
   };
   const callControl = (message) => {
-    send({
+    if (state.ws?.readyState !== WS_OPEN) {
+      return Promise.reject(new Error(`${message.action} is unavailable while disconnected`));
+    }
+    const requestId = crypto.randomUUID();
+    const { promise, reject, resolve } = Promise.withResolvers();
+    const timeout = setTimeout(() => {
+      pendingCallControls.delete(requestId);
+      reject(new Error(`${message.action} acknowledgement timed out`));
+    }, DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS);
+    pendingCallControls.set(requestId, { reject, resolve, timeout });
+    state.ws.send(JSON.stringify({
       ...message,
+      requestId,
       type: "call_control"
-    });
+    }));
+    return promise;
+  };
+  const close = (reason = "client-close") => {
+    disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
+    lifecycleGeneration += 1;
+    clearTimers();
+    rejectPendingCallControls("Voice connection closed");
+    state.pendingMessages.length = 0;
+    if (state.ws) {
+      const ws = state.ws;
+      state.ws = null;
+      if (ws.readyState === WS_OPEN) {
+        ws.send(JSON.stringify({ reason, type: "close" }));
+      }
+      ws.close(WS_NORMAL_CLOSURE);
+    }
+    state.isConnected = false;
+    listeners.clear();
   };
-  const close = () => {
+  const disconnect = () => {
+    disposed = true;
+    reconnectPreparationAbort?.abort();
+    reconnectPreparationAbort = null;
+    lifecycleGeneration += 1;
     clearTimers();
+    rejectPendingCallControls("Voice connection disconnected");
+    state.pendingMessages.length = 0;
     if (state.ws) {
-      state.ws.close(WS_NORMAL_CLOSURE);
+      const ws = state.ws;
       state.ws = null;
+      ws.close(WS_NORMAL_CLOSURE);
     }
     state.isConnected = false;
     listeners.clear();
   };
+  const simulateDisconnect = () => {
+    if (state.ws?.readyState === WS_OPEN) {
+      state.ws.close(4000, "absolutejs-voice-reconnect-proof");
+    }
+  };
   const subscribe = (callback) => {
     listeners.add(callback);
     return () => {
@@ -433,32 +993,66 @@ var createVoiceConnection = (path, options = {}) => {
   return {
     callControl,
     close,
+    disconnect,
     endTurn,
-    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
-    getScenarioId: () => state.scenarioId ?? "",
-    getSessionId: () => state.sessionId,
     send,
     sendAudio,
+    simulateDisconnect,
     start,
-    subscribe
+    subscribe,
+    getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
+    getScenarioId: () => state.scenarioId ?? "",
+    getSessionId: () => state.sessionId
   };
 };
 
 // src/client/store.ts
+var createInitialReconnectState = () => ({
+  attempts: 0,
+  maxAttempts: 0,
+  status: "idle"
+});
+var appendSegmentText = (accumulated, next) => {
+  const nextText = next.trim().replace(/\s+/g, " ");
+  if (!nextText)
+    return accumulated;
+  if (!accumulated)
+    return nextText;
+  if (accumulated === nextText || accumulated.endsWith(nextText)) {
+    return accumulated;
+  }
+  if (nextText.includes(accumulated))
+    return nextText;
+  return `${accumulated} ${nextText}`;
+};
+var joinPartial = (finalized, interim) => {
+  const interimText = interim.trim().replace(/\s+/g, " ");
+  if (!finalized)
+    return interimText;
+  if (!interimText || finalized.endsWith(interimText))
+    return finalized;
+  return `${finalized} ${interimText}`;
+};
 var createInitialState = () => ({
   assistantAudio: [],
+  assistantStreamingText: "",
   assistantTexts: [],
   call: null,
   error: null,
   isConnected: false,
-  scenarioId: null,
+  paused: false,
   partial: "",
+  playbackRate: null,
+  reconnect: createInitialReconnectState(),
+  scenarioId: null,
   sessionId: null,
+  sessionMetadata: null,
   status: "idle",
   turns: []
 });
 var createVoiceStreamStore = () => {
   let state = createInitialState();
+  let turnFinalText = "";
   const subscribers = new Set;
   const notify = () => {
     subscribers.forEach((subscriber) => subscriber());
@@ -482,9 +1076,16 @@ var createVoiceStreamStore = () => {
       case "assistant":
         state = {
           ...state,
+          assistantStreamingText: "",
           assistantTexts: [...state.assistantTexts, action.text]
         };
         break;
+      case "assistant_delta":
+        state = {
+          ...state,
+          assistantStreamingText: `${state.assistantStreamingText}${action.delta}`
+        };
+        break;
       case "complete":
         state = {
           ...state,
@@ -509,7 +1110,19 @@ var createVoiceStreamStore = () => {
       case "connected":
         state = {
           ...state,
-          isConnected: true
+          isConnected: true,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect
+        };
+        break;
+      case "connection":
+        state = {
+          ...state,
+          reconnect: action.reconnect
         };
         break;
       case "disconnected":
@@ -521,33 +1134,67 @@ var createVoiceStreamStore = () => {
       case "error":
         state = {
           ...state,
-          error: action.message
+          error: action.message,
+          ...action.recoverable === false ? { isConnected: false, status: "failed" } : {}
         };
         break;
       case "final":
+        turnFinalText = appendSegmentText(turnFinalText, action.transcript.text);
         state = {
           ...state,
-          partial: action.transcript.text,
-          turns: state.turns.map((turn) => turn)
+          partial: turnFinalText
         };
         break;
       case "partial":
         state = {
           ...state,
-          partial: action.transcript.text
+          partial: joinPartial(turnFinalText, action.transcript.text)
+        };
+        break;
+      case "playback_rate":
+        state = {
+          ...state,
+          playbackRate: Math.max(0.5, Math.min(2, action.rate))
+        };
+        break;
+      case "replay":
+        turnFinalText = action.partial;
+        state = {
+          ...state,
+          assistantStreamingText: "",
+          assistantTexts: [...action.assistantTexts],
+          call: action.call ?? null,
+          error: null,
+          isConnected: action.status === "active",
+          partial: action.partial,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          sessionId: action.sessionId,
+          sessionMetadata: action.sessionMetadata ?? state.sessionMetadata,
+          status: action.status,
+          turns: [...action.turns]
         };
         break;
       case "session":
         state = {
           ...state,
           error: null,
+          paused: action.paused ?? false,
+          pauseExpiresAt: action.pauseExpiresAt,
           scenarioId: action.scenarioId ?? state.scenarioId,
           isConnected: action.status === "active",
           sessionId: action.sessionId,
+          sessionMetadata: action.sessionMetadata ?? state.sessionMetadata,
           status: action.status
         };
         break;
       case "turn":
+        turnFinalText = "";
         state = {
           ...state,
           partial: "",
@@ -574,30 +1221,86 @@ var createVoiceStreamStore = () => {
 var createVoiceStream = (path, options = {}) => {
   const connection = createVoiceConnection(path, options);
   const store = createVoiceStreamStore();
+  const browserMediaReporter = options.browserMedia && typeof window !== "undefined" ? createVoiceBrowserMediaReporter({
+    ...options.browserMedia,
+    getScenarioId: () => options.browserMedia ? options.browserMedia.getScenarioId?.() ?? connection.getScenarioId() : connection.getScenarioId(),
+    getSessionId: () => options.browserMedia ? options.browserMedia.getSessionId?.() ?? connection.getSessionId() : connection.getSessionId()
+  }) : null;
   const subscribers = new Set;
+  let disposed = false;
   const start = (input) => Promise.resolve().then(() => {
+    if (disposed)
+      return;
     if (!input?.sessionId && !input?.scenarioId) {
       return;
     }
     connection.start(input);
+    browserMediaReporter?.start();
   });
   const notify = () => {
     subscribers.forEach((subscriber) => subscriber());
   };
+  const reportReconnect = () => {
+    if (!options.reconnectReportPath || typeof fetch === "undefined") {
+      return;
+    }
+    const snapshot = store.getSnapshot();
+    const body = JSON.stringify({
+      at: Date.now(),
+      reconnect: snapshot.reconnect,
+      scenarioId: snapshot.scenarioId,
+      sessionId: connection.getSessionId(),
+      turnIds: snapshot.turns.map((turn) => turn.id)
+    });
+    fetch(options.reconnectReportPath, {
+      body,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      keepalive: true,
+      method: "POST"
+    }).catch(() => {});
+  };
   const unsubscribeConnection = connection.subscribe((message) => {
     const action = serverMessageToAction(message);
     if (action) {
       store.dispatch(action);
+      if (message.type === "connection") {
+        reportReconnect();
+      }
       notify();
     }
   });
   return {
+    start,
+    get assistantAudio() {
+      return store.getSnapshot().assistantAudio;
+    },
+    get assistantTexts() {
+      return store.getSnapshot().assistantTexts;
+    },
+    get assistantStreamingText() {
+      return store.getSnapshot().assistantStreamingText;
+    },
+    get call() {
+      return store.getSnapshot().call;
+    },
     callControl(message) {
-      connection.callControl(message);
+      return connection.callControl(message);
+    },
+    close(reason) {
+      disposed = true;
+      unsubscribeConnection();
+      browserMediaReporter?.close();
+      connection.close(reason);
+      store.dispatch({ type: "disconnected" });
+      notify();
     },
-    close() {
+    disconnect() {
+      disposed = true;
       unsubscribeConnection();
-      connection.close();
+      browserMediaReporter?.close();
+      connection.disconnect();
       store.dispatch({ type: "disconnected" });
       notify();
     },
@@ -616,44 +1319,52 @@ var createVoiceStream = (path, options = {}) => {
     get isConnected() {
       return store.getSnapshot().isConnected;
     },
-    get scenarioId() {
-      return store.getSnapshot().scenarioId;
-    },
-    start,
     get partial() {
       return store.getSnapshot().partial;
     },
-    get sessionId() {
-      return connection.getSessionId();
-    },
-    get status() {
-      return store.getSnapshot().status;
+    get playbackRate() {
+      return store.getSnapshot().playbackRate;
     },
-    get turns() {
-      return store.getSnapshot().turns;
+    get paused() {
+      return store.getSnapshot().paused;
     },
-    get assistantTexts() {
-      return store.getSnapshot().assistantTexts;
+    get pauseExpiresAt() {
+      return store.getSnapshot().pauseExpiresAt;
     },
-    get assistantAudio() {
-      return store.getSnapshot().assistantAudio;
+    get reconnect() {
+      return store.getSnapshot().reconnect;
     },
-    get call() {
-      return store.getSnapshot().call;
+    get scenarioId() {
+      return store.getSnapshot().scenarioId;
     },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
+    get sessionId() {
+      return connection.getSessionId();
+    },
+    get sessionMetadata() {
+      return store.getSnapshot().sessionMetadata;
+    },
+    simulateDisconnect() {
+      connection.simulateDisconnect();
+    },
+    get status() {
+      return store.getSnapshot().status;
+    },
     subscribe(subscriber) {
       subscribers.add(subscriber);
       return () => {
         subscribers.delete(subscriber);
       };
+    },
+    get turns() {
+      return store.getSnapshot().turns;
     }
   };
 };
 
-// src/audioConditioning.ts
+// src/core/audioConditioning.ts
 var DEFAULT_TARGET_LEVEL = 0.08;
 var DEFAULT_MAX_GAIN = 3;
 var DEFAULT_NOISE_GATE_THRESHOLD = 0.006;
@@ -671,34 +1382,37 @@ var resolveAudioConditioningConfig = (config) => {
   };
 };
 
-// src/turnProfiles.ts
+// src/core/turnProfiles.ts
 var TURN_PROFILE_DEFAULTS = {
   balanced: {
     qualityProfile: "general",
+    minSilenceMs: 400,
     silenceMs: 1400,
     speechThreshold: 0.012,
     transcriptStabilityMs: 1000
   },
   fast: {
     qualityProfile: "general",
+    minSilenceMs: 300,
     silenceMs: 700,
     speechThreshold: 0.015,
     transcriptStabilityMs: 450
   },
   "long-form": {
     qualityProfile: "general",
+    minSilenceMs: 600,
     silenceMs: 2200,
     speechThreshold: 0.01,
     transcriptStabilityMs: 1500
   }
 };
 var QUALITY_PROFILE_DEFAULTS = {
-  general: {},
   "accent-heavy": {
     silenceMs: 1200,
     speechThreshold: 0.01,
     transcriptStabilityMs: 1200
   },
+  general: {},
   "noisy-room": {
     silenceMs: 2000,
     speechThreshold: 0.02,
@@ -717,16 +1431,18 @@ var resolveTurnDetectionConfig = (config) => {
   const qualityProfile = config?.qualityProfile ?? DEFAULT_QUALITY_PROFILE;
   const preset = TURN_PROFILE_DEFAULTS[profile];
   const quality = QUALITY_PROFILE_DEFAULTS[qualityProfile];
+  const silenceMs = config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs;
   return {
     profile,
     qualityProfile,
-    silenceMs: config?.silenceMs ?? quality.silenceMs ?? preset.silenceMs,
+    minSilenceMs: Math.min(silenceMs, config?.minSilenceMs ?? quality.minSilenceMs ?? preset.minSilenceMs),
+    silenceMs,
     speechThreshold: config?.speechThreshold ?? quality.speechThreshold ?? preset.speechThreshold,
     transcriptStabilityMs: config?.transcriptStabilityMs ?? quality.transcriptStabilityMs ?? preset.transcriptStabilityMs
   };
 };
 
-// src/presets.ts
+// src/core/presets.ts
 var PRESET_INPUTS = {
   chat: {
     audioConditioning: {
@@ -747,8 +1463,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "short-command",
-      profile: "balanced"
+      profile: "balanced",
+      qualityProfile: "short-command"
     }
   },
   default: {
@@ -763,8 +1479,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "general",
-      profile: "fast"
+      profile: "fast",
+      qualityProfile: "general"
     }
   },
   dictation: {
@@ -786,8 +1502,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "accent-heavy",
-      profile: "long-form"
+      profile: "long-form",
+      qualityProfile: "accent-heavy"
     }
   },
   "guided-intake": {
@@ -809,8 +1525,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "turn-scoped",
     turnDetection: {
-      qualityProfile: "accent-heavy",
-      profile: "long-form"
+      profile: "long-form",
+      qualityProfile: "accent-heavy"
     }
   },
   "noisy-room": {
@@ -832,8 +1548,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "noisy-room",
       profile: "long-form",
+      qualityProfile: "noisy-room",
       silenceMs: 2100,
       speechThreshold: 0.02,
       transcriptStabilityMs: 1650
@@ -858,8 +1574,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "noisy-room",
       profile: "long-form",
+      qualityProfile: "noisy-room",
       silenceMs: 660,
       speechThreshold: 0.012,
       transcriptStabilityMs: 300
@@ -884,8 +1600,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "noisy-room",
       profile: "long-form",
+      qualityProfile: "noisy-room",
       silenceMs: 620,
       speechThreshold: 0.012,
       transcriptStabilityMs: 280
@@ -910,8 +1626,8 @@ var PRESET_INPUTS = {
     },
     sttLifecycle: "continuous",
     turnDetection: {
-      qualityProfile: "noisy-room",
-      profile: "long-form"
+      profile: "long-form",
+      qualityProfile: "noisy-room"
     }
   }
 };
@@ -935,14 +1651,20 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 // src/client/controller.ts
 var createInitialState2 = (stream) => ({
   assistantAudio: [...stream.assistantAudio],
+  assistantStreamingText: stream.assistantStreamingText,
   assistantTexts: [...stream.assistantTexts],
   call: stream.call,
   error: stream.error,
   isConnected: stream.isConnected,
   isRecording: false,
+  paused: stream.paused,
+  pauseExpiresAt: stream.pauseExpiresAt,
   partial: stream.partial,
+  playbackRate: stream.playbackRate,
+  reconnect: stream.reconnect,
   recordingError: null,
   sessionId: stream.sessionId,
+  sessionMetadata: stream.sessionMetadata,
   scenarioId: stream.scenarioId,
   status: stream.status,
   turns: [...stream.turns]
@@ -954,6 +1676,9 @@ var createVoiceController = (path, options = {}) => {
     ...options.connection
   });
   let capture = null;
+  let captureGeneration = 0;
+  let disposed = false;
+  let startRecordingPromise = null;
   let state = createInitialState2(stream);
   const subscribers = new Set;
   const notify = () => {
@@ -965,12 +1690,18 @@ var createVoiceController = (path, options = {}) => {
     state = {
       ...state,
       assistantAudio: [...stream.assistantAudio],
+      assistantStreamingText: stream.assistantStreamingText,
       assistantTexts: [...stream.assistantTexts],
       call: stream.call,
       error: stream.error,
       isConnected: stream.isConnected,
+      paused: stream.paused,
+      pauseExpiresAt: stream.pauseExpiresAt,
       partial: stream.partial,
+      playbackRate: stream.playbackRate,
+      reconnect: stream.reconnect,
       sessionId: stream.sessionId,
+      sessionMetadata: stream.sessionMetadata,
       scenarioId: stream.scenarioId,
       status: stream.status,
       turns: [...stream.turns]
@@ -994,12 +1725,20 @@ var createVoiceController = (path, options = {}) => {
     capture = createMicrophoneCapture({
       channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
       onLevel: options.capture?.onLevel,
-      onAudio: (audio) => stream.sendAudio(audio),
-      sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
+      onAudio: (audio) => {
+        if (options.capture?.onAudio) {
+          options.capture.onAudio(audio, stream.sendAudio);
+          return;
+        }
+        stream.sendAudio(audio);
+      },
+      sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz,
+      ...options.capture?.stream ? { stream: options.capture.stream } : {}
     });
     return capture;
   };
   const stopRecording = () => {
+    captureGeneration += 1;
     capture?.stop();
     capture = null;
     state = {
@@ -1009,43 +1748,88 @@ var createVoiceController = (path, options = {}) => {
     notify();
   };
   const startRecording = async () => {
+    if (disposed) {
+      throw new Error("Voice controller is closed.");
+    }
     if (state.isRecording) {
       return;
     }
-    try {
-      state = {
-        ...state,
-        recordingError: null
-      };
-      notify();
-      await ensureCapture().start();
-      state = {
-        ...state,
-        isRecording: true
-      };
-      notify();
-    } catch (error) {
-      capture = null;
-      state = {
-        ...state,
-        isRecording: false,
-        recordingError: error instanceof Error ? error.message : String(error)
-      };
-      notify();
-      throw error;
-    }
-  };
-  const close = () => {
-    unsubscribeStream();
-    stopRecording();
-    stream.close();
-  };
-  return {
-    bindHTMX(bindingOptions) {
-      return bindVoiceHTMX(stream, bindingOptions);
-    },
-    callControl: (message) => stream.callControl(message),
-    close,
+    if (startRecordingPromise)
+      return startRecordingPromise;
+    const generation = ++captureGeneration;
+    const activeCapture = ensureCapture();
+    const operation = (async () => {
+      try {
+        state = {
+          ...state,
+          recordingError: null
+        };
+        notify();
+        await activeCapture.start();
+        if (disposed || generation !== captureGeneration || capture !== activeCapture) {
+          activeCapture.stop();
+          return;
+        }
+        state = {
+          ...state,
+          isRecording: true
+        };
+        notify();
+      } catch (error) {
+        activeCapture.stop();
+        if (generation !== captureGeneration || capture !== activeCapture) {
+          throw error;
+        }
+        capture = null;
+        state = {
+          ...state,
+          isRecording: false,
+          recordingError: error instanceof Error ? error.message : String(error)
+        };
+        notify();
+        throw error;
+      }
+    })();
+    const pending = operation.finally(() => {
+      if (startRecordingPromise === pending)
+        startRecordingPromise = null;
+    });
+    startRecordingPromise = pending;
+    return startRecordingPromise;
+  };
+  const close = (reason) => {
+    disposed = true;
+    unsubscribeStream();
+    stopRecording();
+    stream.close(reason);
+  };
+  const disconnect = () => {
+    disposed = true;
+    unsubscribeStream();
+    stopRecording();
+    stream.disconnect();
+  };
+  return {
+    close,
+    disconnect,
+    startRecording,
+    stopRecording,
+    get assistantAudio() {
+      return state.assistantAudio;
+    },
+    get assistantTexts() {
+      return state.assistantTexts;
+    },
+    get assistantStreamingText() {
+      return state.assistantStreamingText;
+    },
+    bindHTMX(bindingOptions) {
+      return bindVoiceHTMX(stream, bindingOptions);
+    },
+    get call() {
+      return state.call;
+    },
+    callControl: (message) => stream.callControl(message),
     endTurn: () => stream.endTurn(),
     get error() {
       return state.error;
@@ -1061,21 +1845,35 @@ var createVoiceController = (path, options = {}) => {
     get partial() {
       return state.partial;
     },
+    get playbackRate() {
+      return state.playbackRate;
+    },
+    get paused() {
+      return state.paused;
+    },
+    get pauseExpiresAt() {
+      return state.pauseExpiresAt;
+    },
+    get reconnect() {
+      return state.reconnect;
+    },
     get recordingError() {
       return state.recordingError;
     },
+    get scenarioId() {
+      return state.scenarioId;
+    },
     sendAudio: (audio) => stream.sendAudio(audio),
     get sessionId() {
       return state.sessionId;
     },
-    get scenarioId() {
-      return state.scenarioId;
+    get sessionMetadata() {
+      return state.sessionMetadata;
     },
-    startRecording,
+    simulateDisconnect: () => stream.simulateDisconnect(),
     get status() {
       return state.status;
     },
-    stopRecording,
     subscribe: (subscriber) => {
       subscribers.add(subscriber);
       return () => {
@@ -1091,15 +1889,778 @@ var createVoiceController = (path, options = {}) => {
     },
     get turns() {
       return state.turns;
+    }
+  };
+};
+
+// src/client/timeStretch.ts
+var HOP_MS = 10;
+var SEEK_MS = 5;
+var ENERGY_EPSILON = 0.000001;
+var HALF = 0.5;
+var MS_PER_SECOND = 1000;
+var makeHann = (length) => {
+  const weights = new Float32Array(length);
+  for (let index = 0;index < length; index += 1) {
+    weights[index] = HALF - HALF * Math.cos(2 * Math.PI * index / length);
+  }
+  return weights;
+};
+var correlationScore = (base, start, ref, length) => {
+  let dot = 0;
+  let energy = 0;
+  for (let index = 0;index < length; index += 1) {
+    const sample = base[start + index] ?? 0;
+    dot += sample * (ref[index] ?? 0);
+    energy += sample * sample;
+  }
+  return dot / Math.sqrt(energy + ENERGY_EPSILON);
+};
+var overlapAddGrain = (src, off, tail, weights, hop) => {
+  const out = new Float32Array(hop);
+  const nextTail = new Float32Array(hop);
+  for (let index = 0;index < hop; index += 1) {
+    out[index] = (tail[index] ?? 0) + (src[off + index] ?? 0) * (weights[index] ?? 0);
+    nextTail[index] = (src[off + hop + index] ?? 0) * (weights[hop + index] ?? 0);
+  }
+  return { nextTail, out };
+};
+var createTimeStretcher = () => {
+  let sampleRate = 0;
+  let channelCount = 0;
+  let hop = 0;
+  let frameLen = 0;
+  let seek = 0;
+  let weights = new Float32Array(0);
+  let buffers = [];
+  let inputStart = 0;
+  let analysisPos = 0;
+  let olaTail = [];
+  let naturalRef = null;
+  const init = (rate, channels) => {
+    sampleRate = rate;
+    channelCount = channels;
+    hop = Math.max(1, Math.round(sampleRate * HOP_MS / MS_PER_SECOND));
+    frameLen = hop * 2;
+    seek = Math.max(1, Math.round(sampleRate * SEEK_MS / MS_PER_SECOND));
+    weights = makeHann(frameLen);
+    buffers = Array.from({ length: channels }, () => new Float32Array(0));
+    olaTail = Array.from({ length: channels }, () => new Float32Array(hop));
+    inputStart = 0;
+    analysisPos = seek;
+    naturalRef = null;
+  };
+  const reset = () => {
+    buffers = buffers.map(() => new Float32Array(0));
+    olaTail = olaTail.map(() => new Float32Array(hop));
+    inputStart = 0;
+    analysisPos = seek;
+    naturalRef = null;
+  };
+  const append = (input) => {
+    for (let channel = 0;channel < channelCount; channel += 1) {
+      const incoming = input[channel] ?? input[0] ?? new Float32Array(0);
+      const existing = buffers[channel] ?? new Float32Array(0);
+      const merged = new Float32Array(existing.length + incoming.length);
+      merged.set(existing, 0);
+      merged.set(incoming, existing.length);
+      buffers[channel] = merged;
+    }
+  };
+  const inputEnd = () => inputStart + (buffers[0]?.length ?? 0);
+  const compact = () => {
+    const keepFrom = Math.max(inputStart, Math.floor(analysisPos) - seek - 1);
+    if (keepFrom <= inputStart)
+      return;
+    const drop = keepFrom - inputStart;
+    for (let channel = 0;channel < channelCount; channel += 1) {
+      buffers[channel] = (buffers[channel] ?? new Float32Array(0)).slice(drop);
+    }
+    inputStart = keepFrom;
+  };
+  const bestOffset = (center) => {
+    if (!naturalRef)
+      return 0;
+    const [base] = buffers;
+    if (!base)
+      return 0;
+    let bestDelta = 0;
+    let bestScore = -Infinity;
+    for (let delta = -seek;delta <= seek; delta += 1) {
+      const score = correlationScore(base, center + delta - inputStart, naturalRef, frameLen);
+      if (score <= bestScore)
+        continue;
+      bestScore = score;
+      bestDelta = delta;
+    }
+    return bestDelta;
+  };
+  const process = (input, speed, rate) => {
+    const channels = Math.max(1, input.length);
+    if (sampleRate !== rate || channelCount !== channels)
+      init(rate, channels);
+    append(input);
+    const analysisHop = hop * speed;
+    const segments = Array.from({ length: channelCount }, () => []);
+    const emitGrain = (pos) => {
+      const off = pos - inputStart;
+      for (let channel = 0;channel < channelCount; channel += 1) {
+        const src = buffers[channel];
+        const tail = olaTail[channel];
+        if (!src || !tail)
+          continue;
+        const grain = overlapAddGrain(src, off, tail, weights, hop);
+        olaTail[channel] = grain.nextTail;
+        segments[channel]?.push(grain.out);
+      }
+    };
+    const captureRef = (pos) => {
+      const ref = new Float32Array(frameLen);
+      const refOff = pos + hop - inputStart;
+      const [base] = buffers;
+      if (base)
+        ref.set(base.subarray(refOff, refOff + frameLen));
+      naturalRef = ref;
+    };
+    const canEmit = () => Math.floor(analysisPos) - seek >= inputStart && Math.floor(analysisPos) + seek + frameLen + hop <= inputEnd();
+    while (canEmit()) {
+      const center = Math.round(analysisPos);
+      const pos = center + bestOffset(center);
+      emitGrain(pos);
+      captureRef(pos);
+      analysisPos += analysisHop;
+    }
+    compact();
+    return segments.map((channelSegments) => {
+      const total = channelSegments.reduce((sum, seg) => sum + seg.length, 0);
+      const merged = new Float32Array(total);
+      let offset = 0;
+      for (const seg of channelSegments) {
+        merged.set(seg, offset);
+        offset += seg.length;
+      }
+      return merged;
+    });
+  };
+  return { process, reset };
+};
+
+// src/client/audioPlayer.ts
+var activeAudioPlayers = new Set;
+var DEFAULT_LOOKAHEAD_MS = 15;
+var DEFAULT_VOLUME = 1;
+var DEFAULT_PLAYBACK_RATE = 1;
+var MIN_PLAYBACK_RATE = 0.5;
+var MAX_PLAYBACK_RATE = 2;
+var STRETCH_BYPASS_EPSILON = 0.01;
+var ANALYSER_FFT_SIZE = 256;
+var PCM_BYTE_MIDPOINT = 128;
+var GAP_EPSILON_S = 0.03;
+var createInitialState3 = () => ({
+  activeSourceCount: 0,
+  error: null,
+  isActive: false,
+  isPlaying: false,
+  lastInterruptLatencyMs: undefined,
+  lastPlaybackStopLatencyMs: undefined,
+  processedChunkCount: 0,
+  queuedChunkCount: 0
+});
+var getAudioContextCtor = () => {
+  if (typeof window === "undefined") {
+    return typeof AudioContext === "undefined" ? undefined : AudioContext;
+  }
+  return window.AudioContext ?? window.webkitAudioContext;
+};
+var clampVolume = (volume) => {
+  if (typeof volume !== "number" || !Number.isFinite(volume)) {
+    return DEFAULT_VOLUME;
+  }
+  return Math.min(1, Math.max(0, volume));
+};
+var clampPlaybackRate = (rate) => {
+  if (typeof rate !== "number" || !Number.isFinite(rate)) {
+    return DEFAULT_PLAYBACK_RATE;
+  }
+  return Math.min(MAX_PLAYBACK_RATE, Math.max(MIN_PLAYBACK_RATE, rate));
+};
+var decodePCM16LEChunk = (audioContext, chunk) => {
+  const { format } = chunk;
+  if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
+    throw new Error(`Unsupported assistant audio format: ${format.container}/${format.encoding}`);
+  }
+  const bytes = chunk.chunk;
+  const channels = Math.max(1, format.channels);
+  const sampleCount = Math.floor(bytes.byteLength / 2);
+  const frameCount = Math.max(1, Math.floor(sampleCount / channels));
+  const audioBuffer = audioContext.createBuffer(channels, frameCount, format.sampleRateHz);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
+    const channelData = audioBuffer.getChannelData(channelIndex);
+    for (let frameIndex = 0;frameIndex < frameCount; frameIndex += 1) {
+      const sampleIndex = frameIndex * channels + channelIndex;
+      const sampleOffset = sampleIndex * 2;
+      if (sampleOffset + 1 >= bytes.byteLength) {
+        channelData[frameIndex] = 0;
+        continue;
+      }
+      channelData[frameIndex] = view.getInt16(sampleOffset, true) / 32768;
+    }
+  }
+  return audioBuffer;
+};
+var createVoiceAudioPlayer = (source, options = {}) => {
+  const subscribers = new Set;
+  const sourceNodes = new Set;
+  const lookaheadSeconds = (options.lookaheadMs ?? DEFAULT_LOOKAHEAD_MS) / 1000;
+  let state = createInitialState3();
+  let audioContext = null;
+  let outputNode = null;
+  let analyserNode = null;
+  let analyserBuffer = null;
+  let volume = clampVolume(options.volume);
+  let playbackRate = clampPlaybackRate(options.playbackRate);
+  let stretcher = null;
+  let queueEndTime = 0;
+  let syncPromise = Promise.resolve();
+  let interruptStartedAt = null;
+  let interruptPromise = null;
+  let resolveInterruptPromise = null;
+  let interruptFallbackTimer = null;
+  let concurrencyCounted = false;
+  let observedPeakConcurrency = 0;
+  let scheduledDurationMs = 0;
+  let gapCount = 0;
+  let totalGapMs = 0;
+  let maxGapMs = 0;
+  let errorCount = 0;
+  let hasScheduledAnyChunk = false;
+  const sampleConcurrency = () => {
+    if (activeAudioPlayers.size > observedPeakConcurrency) {
+      observedPeakConcurrency = activeAudioPlayers.size;
+    }
+  };
+  const markPlayerActive = () => {
+    if (concurrencyCounted) {
+      return;
+    }
+    concurrencyCounted = true;
+    activeAudioPlayers.add(sampleConcurrency);
+    for (const sample of activeAudioPlayers) {
+      sample();
+    }
+  };
+  const markPlayerInactive = () => {
+    if (!concurrencyCounted) {
+      return;
+    }
+    concurrencyCounted = false;
+    activeAudioPlayers.delete(sampleConcurrency);
+  };
+  const notify = () => {
+    for (const subscriber of subscribers) {
+      subscriber();
+    }
+  };
+  const setState = (next) => {
+    state = {
+      ...state,
+      ...next
+    };
+    notify();
+  };
+  const clearError = () => {
+    if (state.error !== null) {
+      setState({ error: null });
+    }
+  };
+  const clearInterruptTimer = () => {
+    if (interruptFallbackTimer !== null) {
+      clearTimeout(interruptFallbackTimer);
+      interruptFallbackTimer = null;
+    }
+  };
+  const resolveInterrupt = (latencyMs) => {
+    clearInterruptTimer();
+    interruptStartedAt = null;
+    stretcher?.reset();
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: false,
+      lastInterruptLatencyMs: latencyMs,
+      lastPlaybackStopLatencyMs: state.lastPlaybackStopLatencyMs ?? latencyMs
+    });
+    resolveInterruptPromise?.();
+    resolveInterruptPromise = null;
+    interruptPromise = null;
+  };
+  const estimateOutputStopLatencyMs = (context) => {
+    if (!context) {
+      return 0;
+    }
+    return Math.max(0, ((context.baseLatency ?? 0) + (context.outputLatency ?? 0)) * 1000);
+  };
+  const applyOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = volume;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const muteOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = 0;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const maybeResolveInterrupt = () => {
+    if (interruptStartedAt === null || sourceNodes.size > 0) {
+      return;
+    }
+    resolveInterrupt(Date.now() - interruptStartedAt);
+  };
+  const ensureAudioContext = async () => {
+    if (audioContext) {
+      return audioContext;
+    }
+    if (options.createAudioContext) {
+      audioContext = options.createAudioContext();
+    } else {
+      const AudioContextCtor = getAudioContextCtor();
+      if (!AudioContextCtor) {
+        throw new Error("Assistant audio playback requires AudioContext support.");
+      }
+      audioContext = new AudioContextCtor;
+    }
+    if (audioContext.createGain) {
+      outputNode = audioContext.createGain();
+      outputNode.connect?.(audioContext.destination);
+      if (audioContext.createAnalyser) {
+        analyserNode = audioContext.createAnalyser();
+        analyserNode.fftSize = ANALYSER_FFT_SIZE;
+        analyserBuffer = new Uint8Array(analyserNode.fftSize);
+        outputNode.connect?.(analyserNode);
+      }
+    }
+    queueEndTime = audioContext.currentTime;
+    return audioContext;
+  };
+  const scheduleBuffer = (context, buffer, rate) => {
+    const node = context.createBufferSource();
+    node.buffer = buffer;
+    if (node.playbackRate) {
+      node.playbackRate.value = rate;
+    }
+    node.connect(outputNode ?? context.destination);
+    node.onended = () => {
+      sourceNodes.delete(node);
+      node.disconnect?.();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isPlaying: sourceNodes.size > 0 && state.isActive
+      });
+      maybeResolveInterrupt();
+    };
+    const earliestStart = context.currentTime + lookaheadSeconds;
+    const startAt = Math.max(earliestStart, queueEndTime);
+    if (hasScheduledAnyChunk && earliestStart > queueEndTime + GAP_EPSILON_S) {
+      const gapMs = (earliestStart - queueEndTime) * 1000;
+      gapCount += 1;
+      totalGapMs += gapMs;
+      maxGapMs = Math.max(maxGapMs, gapMs);
+    }
+    hasScheduledAnyChunk = true;
+    scheduledDurationMs += buffer.duration / rate * 1000;
+    sampleConcurrency();
+    queueEndTime = startAt + buffer.duration / rate;
+    sourceNodes.add(node);
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: true
+    });
+    node.start(startAt);
+  };
+  const scheduleChunk = async (chunk) => {
+    const context = await ensureAudioContext();
+    const buffer = decodePCM16LEChunk(context, chunk);
+    if (Math.abs(playbackRate - 1) <= STRETCH_BYPASS_EPSILON) {
+      stretcher?.reset();
+      scheduleBuffer(context, buffer, playbackRate);
+      return;
+    }
+    const channels = Math.max(1, chunk.format.channels);
+    const input = [];
+    for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
+      input.push(buffer.getChannelData(channelIndex));
+    }
+    stretcher ??= createTimeStretcher();
+    const stretched = stretcher.process(input, playbackRate, chunk.format.sampleRateHz);
+    const outLength = stretched[0]?.length ?? 0;
+    if (outLength === 0) {
+      return;
+    }
+    const outBuffer = context.createBuffer(channels, outLength, chunk.format.sampleRateHz);
+    for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
+      const channelOut = stretched[channelIndex];
+      if (!channelOut)
+        continue;
+      outBuffer.getChannelData(channelIndex).set(channelOut);
+    }
+    scheduleBuffer(context, outBuffer, 1);
+  };
+  const stopQueuedPlayback = (options2) => {
+    for (const node of [...sourceNodes]) {
+      node.stop?.();
+    }
+    queueEndTime = audioContext ? audioContext.currentTime : 0;
+    if (options2?.forceClear) {
+      for (const node of sourceNodes) {
+        node.disconnect?.();
+      }
+      sourceNodes.clear();
+      maybeResolveInterrupt();
+    }
+  };
+  const sync = async () => {
+    if (!state.isActive) {
+      return;
+    }
+    const nextChunks = source.assistantAudio.slice(state.processedChunkCount);
+    if (nextChunks.length === 0) {
+      return;
+    }
+    try {
+      clearError();
+      for (const chunk of nextChunks) {
+        await scheduleChunk(chunk);
+      }
+      setState({
+        processedChunkCount: source.assistantAudio.length,
+        queuedChunkCount: state.queuedChunkCount + nextChunks.length
+      });
+    } catch (error) {
+      errorCount += 1;
+      setState({
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const queueSync = () => {
+    syncPromise = syncPromise.then(() => sync(), () => sync());
+    return syncPromise;
+  };
+  const unsubscribeSource = source.subscribe(() => {
+    if (options.autoStart && !state.isActive && source.assistantAudio.length > 0) {
+      player.start();
+      return;
+    }
+    if (state.isActive) {
+      queueSync();
+    }
+  });
+  const player = {
+    get activeSourceCount() {
+      return state.activeSourceCount;
     },
-    get assistantTexts() {
-      return state.assistantTexts;
+    close: async () => {
+      markPlayerInactive();
+      unsubscribeSource();
+      stopQueuedPlayback({ forceClear: true });
+      clearInterruptTimer();
+      resolveInterruptPromise?.();
+      resolveInterruptPromise = null;
+      interruptPromise = null;
+      interruptStartedAt = null;
+      if (audioContext && audioContext.state !== "closed") {
+        await audioContext.close();
+      }
+      audioContext = null;
+      outputNode?.disconnect?.();
+      outputNode = null;
+      analyserNode?.disconnect?.();
+      analyserNode = null;
+      analyserBuffer = null;
+      queueEndTime = 0;
+      setState({
+        activeSourceCount: 0,
+        isActive: false,
+        isPlaying: false
+      });
     },
-    get assistantAudio() {
-      return state.assistantAudio;
+    get error() {
+      return state.error;
     },
-    get call() {
-      return state.call;
+    getOutputLevel: () => {
+      if (!analyserNode || !analyserBuffer) {
+        return 0;
+      }
+      analyserNode.getByteTimeDomainData(analyserBuffer);
+      let sumSquares = 0;
+      for (const sample of analyserBuffer) {
+        const centered = (sample - PCM_BYTE_MIDPOINT) / PCM_BYTE_MIDPOINT;
+        sumSquares += centered * centered;
+      }
+      return Math.sqrt(sumSquares / analyserBuffer.length);
+    },
+    getSnapshot: () => state,
+    getIntegritySummary: () => {
+      const chunksReceived = source.assistantAudio.length;
+      const chunksScheduled = state.processedChunkCount;
+      return {
+        chunksReceived,
+        chunksScheduled,
+        errorCount,
+        gapCount,
+        maxConcurrentPlayers: observedPeakConcurrency,
+        maxGapMs: Math.round(maxGapMs),
+        ok: observedPeakConcurrency <= 1 && errorCount === 0 && chunksScheduled >= chunksReceived,
+        scheduledDurationMs: Math.round(scheduledDurationMs),
+        totalGapMs: Math.round(totalGapMs)
+      };
+    },
+    interrupt: async () => {
+      const startedAt = Date.now();
+      const context = await ensureAudioContext();
+      interruptStartedAt = startedAt;
+      muteOutputGain(context);
+      const playbackStopLatencyMs = Date.now() - startedAt + estimateOutputStopLatencyMs(context);
+      setState({
+        isActive: false,
+        isPlaying: sourceNodes.size > 0,
+        lastPlaybackStopLatencyMs: playbackStopLatencyMs
+      });
+      if (sourceNodes.size === 0) {
+        resolveInterrupt(playbackStopLatencyMs);
+        return;
+      }
+      if (!interruptPromise) {
+        interruptPromise = new Promise((resolve) => {
+          resolveInterruptPromise = resolve;
+        });
+      }
+      clearInterruptTimer();
+      interruptFallbackTimer = setTimeout(() => {
+        for (const node of sourceNodes) {
+          node.disconnect?.();
+        }
+        sourceNodes.clear();
+        resolveInterrupt(Date.now() - startedAt);
+      }, 250);
+      stopQueuedPlayback();
+      await interruptPromise;
+    },
+    get isActive() {
+      return state.isActive;
+    },
+    get isPlaying() {
+      return state.isPlaying;
+    },
+    get lastInterruptLatencyMs() {
+      return state.lastInterruptLatencyMs;
+    },
+    get lastPlaybackStopLatencyMs() {
+      return state.lastPlaybackStopLatencyMs;
+    },
+    pause: async () => {
+      if (!audioContext) {
+        setState({
+          activeSourceCount: 0,
+          isActive: false,
+          isPlaying: false
+        });
+        return;
+      }
+      await audioContext.suspend();
+      markPlayerInactive();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isActive: false,
+        isPlaying: false
+      });
+    },
+    get playbackRate() {
+      return playbackRate;
+    },
+    get processedChunkCount() {
+      return state.processedChunkCount;
+    },
+    get queuedChunkCount() {
+      return state.queuedChunkCount;
+    },
+    setPlaybackRate: (nextRate) => {
+      playbackRate = clampPlaybackRate(nextRate);
+    },
+    setVolume: (nextVolume) => {
+      volume = clampVolume(nextVolume);
+      applyOutputGain(audioContext);
+    },
+    start: async () => {
+      try {
+        clearError();
+        const context = await ensureAudioContext();
+        applyOutputGain(context);
+        if (context.state === "suspended") {
+          await context.resume();
+        }
+        markPlayerActive();
+        setState({
+          activeSourceCount: sourceNodes.size,
+          isActive: true,
+          isPlaying: context.state === "running"
+        });
+        await queueSync();
+      } catch (error) {
+        errorCount += 1;
+        markPlayerInactive();
+        setState({
+          error: error instanceof Error ? error.message : String(error),
+          isActive: false,
+          isPlaying: false
+        });
+        throw error;
+      }
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    get volume() {
+      return volume;
+    }
+  };
+  return player;
+};
+
+// src/client/bargeInMonitor.ts
+var DEFAULT_THRESHOLD_MS = 250;
+var createEventId = () => `barge-in:${Date.now()}:${crypto.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
+var summarize = (events, thresholdMs) => {
+  const stopped = events.filter((event) => event.status === "stopped");
+  const latencies = stopped.map((event) => event.latencyMs).filter((value) => typeof value === "number");
+  const failed = stopped.filter((event) => typeof event.latencyMs === "number" && event.latencyMs > thresholdMs).length;
+  const passed = stopped.length - failed;
+  return {
+    averageLatencyMs: latencies.length > 0 ? Math.round(latencies.reduce((total, value) => total + value, 0) / latencies.length) : undefined,
+    events: [...events],
+    failed,
+    lastEvent: events.at(-1),
+    passed,
+    status: events.length === 0 ? "empty" : failed > 0 ? "fail" : stopped.length === 0 ? "warn" : "pass",
+    thresholdMs,
+    total: stopped.length
+  };
+};
+var createVoiceBargeInMonitor = (options = {}) => {
+  const listeners = new Set;
+  const thresholdMs = options.thresholdMs ?? DEFAULT_THRESHOLD_MS;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const events = [];
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const postEvent = (event) => {
+    if (!options.path || typeof fetchImpl !== "function") {
+      return;
+    }
+    fetchImpl(options.path, {
+      body: JSON.stringify(event),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    }).catch(() => {});
+  };
+  const record = (status, input) => {
+    const event = {
+      at: Date.now(),
+      id: createEventId(),
+      latencyMs: input.latencyMs,
+      playbackStopLatencyMs: input.playbackStopLatencyMs,
+      reason: input.reason,
+      sessionId: input.sessionId,
+      status,
+      thresholdMs
+    };
+    events.push(event);
+    postEvent(event);
+    emit();
+    return event;
+  };
+  return {
+    getSnapshot: () => summarize(events, thresholdMs),
+    recordRequested: (input) => record("requested", input),
+    recordSkipped: (input) => record("skipped", input),
+    recordStopped: (input) => record("stopped", input),
+    subscribe: (subscriber) => {
+      listeners.add(subscriber);
+      return () => {
+        listeners.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/client/duplex.ts
+var DEFAULT_INTERRUPT_THRESHOLD = 0.08;
+var shouldInterruptForLevel = (level, options = {}) => (options.enabled ?? true) && level >= (options.interruptThreshold ?? DEFAULT_INTERRUPT_THRESHOLD);
+var bindVoiceBargeIn = (controller, player, options = {}) => {
+  let lastPartial = controller.partial;
+  const interruptIfPlaying = (reason) => {
+    if (!player.isPlaying || options.enabled === false) {
+      options.monitor?.recordSkipped({
+        reason,
+        sessionId: controller.sessionId
+      });
+      return;
+    }
+    options.monitor?.recordRequested({
+      reason,
+      sessionId: controller.sessionId
+    });
+    player.interrupt().then(() => {
+      options.monitor?.recordStopped({
+        latencyMs: player.lastInterruptLatencyMs,
+        playbackStopLatencyMs: player.lastPlaybackStopLatencyMs,
+        reason,
+        sessionId: controller.sessionId
+      });
+    });
+  };
+  const unsubscribe = controller.subscribe(() => {
+    if (options.interruptOnPartial === false) {
+      lastPartial = controller.partial;
+      return;
+    }
+    if (!lastPartial && controller.partial) {
+      interruptIfPlaying("partial-transcript");
+    }
+    lastPartial = controller.partial;
+  });
+  return {
+    close: () => {
+      unsubscribe();
+    },
+    handleLevel: (level) => {
+      if (shouldInterruptForLevel(level, options)) {
+        interruptIfPlaying("input-level");
+      }
+    },
+    sendAudio: (audio) => {
+      interruptIfPlaying("manual-audio");
+      controller.sendAudio(audio);
     }
   };
 };
@@ -1126,8 +2687,7 @@ var DEFAULT_GUIDED_PROMPTS = [
   "Now describe what you are trying to do or test.",
   "Finish with any detail that feels blocked, risky, or unclear."
 ];
-var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
-var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var clamp = (value, min, max2) => Math.min(max2, Math.max(min, value));
 var readErrorField = (value, key) => {
   const candidate = value[key];
   if (typeof candidate === "string" && candidate.trim()) {
@@ -1160,6 +2720,17 @@ var formatErrorMessage = (error) => {
   }
   return "Unexpected error";
 };
+var formatReconnectState = (reconnect) => {
+  const pieces = [reconnect.status];
+  if (reconnect.attempts > 0 || reconnect.maxAttempts > 0) {
+    pieces.push(`${reconnect.attempts}/${reconnect.maxAttempts} attempts`);
+  }
+  if (reconnect.nextAttemptAt) {
+    const waitMs = Math.max(0, reconnect.nextAttemptAt - Date.now());
+    pieces.push(`retry in ${Math.ceil(waitMs / 100) / 10}s`);
+  }
+  return pieces.join(" · ");
+};
 var createInitialVoiceWaveLevels = (count = VOICE_WAVE_POINTS) => Array.from({ length: count }, () => 0);
 var pushVoiceWaveLevel = (levels, nextLevel, count = VOICE_WAVE_POINTS) => {
   const next = levels.slice(-(count - 1));
@@ -1216,6 +2787,20 @@ var parsePromptList = (value) => {
   } catch {}
   return DEFAULT_GUIDED_PROMPTS;
 };
+var parseOptionalNumber = (value) => {
+  if (!value) {
+    return;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+};
+var resolveElement2 = (root, selector, ctor) => {
+  if (!selector) {
+    return null;
+  }
+  const value = document.querySelector(selector);
+  return value instanceof ctor ? value : null;
+};
 var requireElement = (root, selector, ctor, name) => {
   const value = selector ? document.querySelector(selector) : null;
   if (value instanceof ctor) {
@@ -1266,11 +2851,20 @@ var initVoiceHTMXRoot = (root) => {
   const guidedPrompts = parsePromptList(root.dataset.voiceGuidedPrompts);
   const guidedLabel = root.dataset.voiceGuidedLabel ?? DEFAULT_GUIDED_LABEL;
   const generalLabel = root.dataset.voiceGeneralLabel ?? DEFAULT_GENERAL_LABEL;
+  const reconnectReportPath = root.dataset.voiceReconnectReportPath;
+  const bargeInPath = root.dataset.voiceBargeInPath;
+  const bargeInMonitor = bargeInPath ? createVoiceBargeInMonitor({
+    path: bargeInPath,
+    thresholdMs: parseOptionalNumber(root.dataset.voiceBargeInThresholdMs)
+  }) : null;
+  const bargeInRecentWindowMs = parseOptionalNumber(root.dataset.voiceBargeInRecentWindowMs) ?? 4000;
+  const bargeInSpeechThreshold = parseOptionalNumber(root.dataset.voiceBargeInSpeechThreshold) ?? 0.04;
   const syncElement = requireElement(document, root.dataset.voiceSync, HTMLElement, "voice-htmx-sync");
   const connectionMetric = requireElement(root, root.dataset.voiceConnection, HTMLElement, "metric-connection");
   const errorStatus = requireElement(root, root.dataset.voiceError, HTMLElement, "status-error");
   const microphoneStatus = requireElement(root, root.dataset.voiceMicrophone, HTMLElement, "status-mic");
   const promptStatus = requireElement(root, root.dataset.voicePrompt, HTMLElement, "status-prompt");
+  const reconnectStatus = resolveElement2(root, root.dataset.voiceReconnect, HTMLElement);
   const chatList = requireElement(root, root.dataset.voiceChat, HTMLElement, "chat-list");
   const startGuidedButton = requireElement(root, root.dataset.voiceStartGuided, HTMLButtonElement, "start-guided");
   const startGeneralButton = requireElement(root, root.dataset.voiceStartGeneral, HTMLButtonElement, "start-general");
@@ -1279,35 +2873,70 @@ var initVoiceHTMXRoot = (root) => {
   const voiceMonitorCopy = requireElement(root, root.dataset.voiceMonitorCopy, HTMLElement, "voice-monitor-copy");
   const voiceWaveGlow = requireElement(root, root.dataset.voiceWaveGlow, SVGPathElement, "voice-wave-glow");
   const voiceWavePath = requireElement(root, root.dataset.voiceWavePath, SVGPathElement, "voice-wave-path");
+  let activeMode = null;
+  let hasStartedModes = {
+    general: false,
+    guided: false
+  };
+  let isCapturing = false;
+  let micError = null;
+  let waveLevels = createInitialVoiceWaveLevels();
+  let guidedBargeInBinding = null;
+  let generalBargeInBinding = null;
   const guidedVoice = createVoiceController(guidedPath, {
     capture: {
+      onAudio: (audio, sendAudio) => {
+        if (guidedBargeInBinding) {
+          guidedBargeInBinding.sendAudio(audio);
+          return;
+        }
+        sendAudio(audio);
+      },
       onLevel: (level) => {
+        guidedBargeInBinding?.handleLevel(level);
         waveLevels = pushVoiceWaveLevel(waveLevels, level);
         renderWave();
       }
     },
+    connection: {
+      reconnectReportPath
+    },
     preset: "guided-intake"
   });
   const generalVoice = createVoiceController(generalPath, {
     capture: {
+      onAudio: (audio, sendAudio) => {
+        if (generalBargeInBinding) {
+          generalBargeInBinding.sendAudio(audio);
+          return;
+        }
+        sendAudio(audio);
+      },
       onLevel: (level) => {
+        generalBargeInBinding?.handleLevel(level);
         waveLevels = pushVoiceWaveLevel(waveLevels, level);
         renderWave();
       }
     },
+    connection: {
+      reconnectReportPath
+    },
     preset: "dictation"
   });
   const stopGuidedBinding = guidedVoice.bindHTMX({ element: syncElement });
   const stopGeneralBinding = generalVoice.bindHTMX({ element: syncElement });
-  let activeMode = null;
-  let hasStartedModes = {
-    general: false,
-    guided: false
-  };
-  let isCapturing = false;
-  let micError = null;
-  let waveLevels = createInitialVoiceWaveLevels();
+  const guidedAudioPlayer = createVoiceAudioPlayer(guidedVoice);
+  const generalAudioPlayer = createVoiceAudioPlayer(generalVoice);
+  guidedBargeInBinding = bindVoiceBargeIn(guidedVoice, guidedAudioPlayer, {
+    interruptThreshold: bargeInSpeechThreshold,
+    monitor: bargeInMonitor ?? undefined
+  });
+  generalBargeInBinding = bindVoiceBargeIn(generalVoice, generalAudioPlayer, {
+    interruptThreshold: bargeInSpeechThreshold,
+    monitor: bargeInMonitor ?? undefined
+  });
   const currentVoice = () => activeMode === "general" ? generalVoice : guidedVoice;
+  const currentAudioPlayer = () => activeMode === "general" ? generalAudioPlayer : guidedAudioPlayer;
   const renderWave = () => {
     const path = createVoiceWavePath(waveLevels);
     voiceWaveGlow.setAttribute("d", path);
@@ -1319,9 +2948,12 @@ var initVoiceHTMXRoot = (root) => {
   const render = () => {
     const voice = currentVoice();
     const hasStarted = (activeMode ? hasStartedModes[activeMode] : false) || voice.turns.length > 0;
-    const status = voice.status;
+    const { status } = voice;
     connectionMetric.textContent = voice.isConnected ? "Connected" : "Waiting";
     errorStatus.textContent = micError || voice.error || "None";
+    if (reconnectStatus) {
+      reconnectStatus.textContent = formatReconnectState(voice.reconnect);
+    }
     microphoneStatus.textContent = isCapturing ? DEFAULT_MIC_LIVE : DEFAULT_MIC_IDLE;
     promptStatus.textContent = resolvePromptMessage({
       guidedPrompts,
@@ -1385,8 +3017,18 @@ var initVoiceHTMXRoot = (root) => {
       render();
     }
   };
-  guidedVoice.subscribe(render);
-  generalVoice.subscribe(render);
+  guidedVoice.subscribe(() => {
+    if (guidedVoice.assistantAudio.length > 0) {
+      guidedAudioPlayer.start().catch(() => {});
+    }
+    render();
+  });
+  generalVoice.subscribe(() => {
+    if (generalVoice.assistantAudio.length > 0) {
+      generalAudioPlayer.start().catch(() => {});
+    }
+    render();
+  });
   startGuidedButton.addEventListener("click", () => {
     startMode("guided");
   });
@@ -1396,9 +3038,16 @@ var initVoiceHTMXRoot = (root) => {
   stopButton.addEventListener("click", () => {
     stopMic();
   });
+  root.addEventListener("absolute-voice-simulate-disconnect", () => {
+    currentVoice().simulateDisconnect();
+  });
   window.addEventListener("beforeunload", () => {
     guidedVoice.stopRecording();
     generalVoice.stopRecording();
+    guidedBargeInBinding?.close();
+    generalBargeInBinding?.close();
+    guidedAudioPlayer.close();
+    generalAudioPlayer.close();
     stopGuidedBinding();
     stopGeneralBinding();
     guidedVoice.close();