@alexkroman1/aai-ui 1.9.2 → 1.10.0

package/dist/session-core-messages.d.ts

@@ -26,6 +26,10 @@ type MessageHandlerDeps = {
     getSnapshot: () => SessionSnapshot;
     updateState: (partial: Partial<SessionSnapshot>) => void;
     conn: ConnState;
+    /** Invalidate any in-flight file upload (the upload sender's `discard`). */
+    discardUpload: () => void;
+    /** Release the microphone/VoiceIO (the session core's `cleanupAudio`). */
+    cleanupAudio: () => void;
 };
 type MessageHandlers = {
     /**
@@ -38,6 +42,14 @@ type MessageHandlers = {
      * otherwise `undefined`.
      */
     handleMessage(data: unknown): SessionConfigMessage | undefined;
+    /**
+     * Wait for `io`'s playback queue to drain, then transition to `"listening"`
+     * — guarded by the same turn-boundary generation the live `audio_done`
+     * path uses. `initAudioCapture` routes the pre-init greeting replay
+     * through this so a barge-in mid-greeting can't be stomped by the
+     * replayed completion resolving late.
+     */
+    settleWhenAudioDrained(io: NonNullable<ConnState["voiceIO"]>): void;
 };
 /**
  * Create the server→client message handlers for one session core.

package/dist/session-core-reconnect.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Automatic reconnection for the browser session socket, built on
+ * partysocket's `ReconnectingWebSocket`. Kept out of `session-core.ts` so
+ * the state machine there reads as protocol logic, not socket plumbing.
+ */
+import ReconnectingWebSocket from "partysocket/ws";
+/**
+ * Open partysocket's reconnecting WebSocket. The URL is a *provider*,
+ * re-evaluated on every attempt, so each retry picks up the current resume
+ * URL rather than the one the session started with.
+ */
+export declare function openReconnectingSocket(urlProvider: () => string): ReconnectingWebSocket;
+/**
+ * True while `socket` is a reconnecting socket that will retry after the
+ * close event currently being handled. partysocket schedules the retry
+ * *before* dispatching `close`, so `retryCount` already names the attempt
+ * just scheduled — at `maxRetries` it has given up.
+ */
+export declare function reconnectPending(socket: unknown): boolean;

package/dist/session-core-url.d.ts

@@ -0,0 +1,2 @@
+/** Build the session WebSocket URL from the platform URL and resume state. */
+export declare function buildWsUrl(platformUrl: string, resume: boolean, sessionId?: string): URL;

package/dist/session-core.js

@@ -1,2 +1,2 @@
-import { t as createSessionCore } from "./session-core-D3NDaySY.js";
+import { t as createSessionCore } from "./session-core-Cfz7PPhN.js";
 export { createSessionCore };

package/dist/{tool-call-block-7f1GTG-P.js → tool-call-block-DIxpG8GM.js}

@@ -1,9 +1,9 @@
 import { useTheme } from "./context.js";
-import { r as TEXT_FAINT } from "./_colors-DJUordGv.js";
+import { r as TEXT_FAINT } from "./_colors-DYX7XRTr.js";
 import { t as Eyebrow } from "./eyebrow-C6ZFuiz6.js";
-import { n as tryParseJSON, t as truncate } from "./_utils-5cs73OrA.js";
+import { n as tryParseJSON, t as truncate } from "./_utils-CN1yVgYS.js";
 import clsx from "clsx";
-import { createContext, useContext, useMemo, useState } from "react";
+import { createContext, memo, useContext, useMemo, useState } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region components/tool-config-context.ts
 /**
@@ -40,6 +40,10 @@ function formatResult(result) {
 * While the tool call is pending a shimmer animation is shown. Once
 * complete, clicking the row expands the formatted JSON result.
 *
+* Memoized: tool-call objects are referentially stable across session
+* snapshots and rows are keyed on the stable `callId`, so a list update only
+* re-renders the rows whose tool call actually changed.
+*
 * @example
 * ```tsx
 * <ToolCallBlock toolCall={toolCall} />
@@ -50,10 +54,11 @@ function formatResult(result) {
 *
 * @public
 */
-function ToolCallBlock({ toolCall, className }) {
+const ToolCallBlock = memo(function ToolCallBlock({ toolCall, className }) {
 	const [isOpen, setIsOpen] = useState(false);
 	const theme = useTheme();
-	const config = useToolConfig()[toolCall.name];
+	const toolConfig = useToolConfig();
+	const config = Object.hasOwn(toolConfig, toolCall.name) ? toolConfig[toolCall.name] : void 0;
 	const isPending = toolCall.status === "pending";
 	const title = config?.label || toolCall.name;
 	const icon = config?.icon;
@@ -128,6 +133,6 @@ function ToolCallBlock({ toolCall, className }) {
 			})]
 		})]
 	});
-}
+});
 //#endregion
 export { ToolConfigContext as n, ToolCallBlock as t };

package/dist/types.d.ts

@@ -81,17 +81,25 @@ export type VoiceSessionOptions = {
      * Called when the server sends a session ID in the config message.
      * Use this to store the ID (e.g. in localStorage) for reconnection
      * via `resumeSessionId`.
+     *
+     * Treat session IDs as sensitive: whoever holds one can resume the
+     * session and read its replayed history. They travel as a WebSocket
+     * query parameter (browsers cannot set WS headers), so they may appear
+     * in proxy and server access logs — don't put them in shared URLs.
      */
     onSessionId?: ((sessionId: string) => void) | undefined;
     /**
      * Session ID from a previous connection. When set, the server will
      * attempt to restore persisted session state (if the agent has
-     * `persistence` enabled).
+     * `persistence` enabled). Sensitive — see {@link onSessionId}.
      */
     resumeSessionId?: string | undefined;
     /**
-     * WebSocket constructor override. Defaults to the native `WebSocket`.
-     * Primarily useful for testing with a mock WebSocket.
+     * WebSocket constructor override. Primarily useful for testing with a mock
+     * WebSocket. When omitted, the session uses a reconnecting WebSocket
+     * (partysocket) that retries with exponential backoff after an unexpected
+     * close and resumes the session; an injected constructor is used as-is and
+     * never reconnects on its own.
      */
     WebSocket?: WebSocketConstructor | undefined;
 };

package/dist/worklets/capture-processor.d.ts

@@ -1,4 +1,4 @@
 /** Raw worklet source — exported so tests can evaluate the processor directly. */
-export declare const captureProcessorSource = "\nclass CaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    this.recording = false;\n    const opts = options.processorOptions || {};\n    this.fromRate = opts.contextRate || sampleRate;\n    this.toRate = opts.sttSampleRate || sampleRate;\n    this.ratio = this.fromRate / this.toRate;\n    this.needsResample = this.fromRate !== this.toRate;\n    // Streaming-resampler state carried across process() blocks so the output\n    // clock doesn't drift and there's no discontinuity at 128-sample block\n    // boundaries. `prev` is the previous block's last input sample (used to\n    // interpolate across the boundary); `pos` is the fractional read position,\n    // in input samples, relative to an extended [prev, ...input] frame. Start\n    // at 1 so the first output is input[0] (not the bogus initial prev).\n    this.prev = 0;\n    this.pos = 1;\n    // Output buffer reused across process() calls -- the render quantum is a\n    // fixed size, so allocating per call would churn the realtime audio thread.\n    this.resampleBuf = null;\n    // Int16 accumulation buffer: flushed to the main thread as one transferred\n    // ArrayBuffer once ~bufferSeconds of output samples are batched. Sized 2x\n    // the flush target so a whole render quantum always fits before flushing.\n    this.targetSamples = Math.max(1, Math.round(this.toRate * (opts.bufferSeconds || 0.1)));\n    this.pending = new Int16Array(this.targetSamples * 2);\n    this.pendingLen = 0;\n    this.port.onmessage = (e) => {\n      if (e.data.event === 'start') this.recording = true;\n      else if (e.data.event === 'stop') {\n        // Final flush so the tail of speech isn't dropped on close.\n        this.flush();\n        this.recording = false;\n      }\n    };\n  }\n\n  resample(input) {\n    const ratio = this.ratio;\n    const n = input.length;\n    if (n === 0) return new Float32Array(0);\n    // At most ceil(n / ratio) + 1 outputs per block (pos starts in [0, ratio)).\n    const maxLen = Math.ceil(n / ratio) + 1;\n    if (this.resampleBuf === null || this.resampleBuf.length < maxLen) {\n      this.resampleBuf = new Float32Array(maxLen);\n    }\n    const out = this.resampleBuf;\n    // Extended frame: index 0 = prev (previous block's last sample),\n    // index k>=1 = input[k-1]. Interpolate at fractional positions stepping by\n    // ratio, carrying `pos` across calls to preserve the sample clock.\n    let count = 0;\n    let pos = this.pos;\n    while (pos < n) {\n      const idx = pos | 0;\n      const frac = pos - idx;\n      const a = idx === 0 ? this.prev : input[idx - 1];\n      const b = input[idx];\n      out[count++] = a + frac * (b - a);\n      pos += ratio;\n    }\n    // Shift the origin to this block's last sample for the next call.\n    this.prev = input[n - 1];\n    this.pos = pos - n;\n    return out.subarray(0, count);\n  }\n\n  // Convert Float32 -> Int16 and append to the pending batch. Writes through\n  // an Int16Array directly (assignment truncates like DataView.setInt16).\n  accumulate(samples) {\n    let buf = this.pending;\n    if (this.pendingLen + samples.length > buf.length) {\n      // Defensive: only reachable if a render quantum outproduces the 1x\n      // headroom above the flush target (never with 128-sample quanta).\n      const grown = new Int16Array((this.pendingLen + samples.length) * 2);\n      grown.set(buf.subarray(0, this.pendingLen));\n      this.pending = grown;\n      buf = grown;\n    }\n    for (let i = 0; i < samples.length; i++) {\n      const s = Math.max(-1, Math.min(1, samples[i]));\n      buf[this.pendingLen++] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n  }\n\n  // Post the batched samples as one transferred ArrayBuffer and reset.\n  flush() {\n    if (this.pendingLen === 0) return;\n    const buffer = this.pending.buffer.slice(0, this.pendingLen * 2);\n    this.pendingLen = 0;\n    this.port.postMessage({ event: 'chunk', buffer }, [buffer]);\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || !input[0] || !this.recording) return true;\n\n    const samples = this.needsResample ? this.resample(input[0]) : input[0];\n    this.accumulate(samples);\n    if (this.pendingLen >= this.targetSamples) this.flush();\n    return true;\n  }\n}\n\nregisterProcessor('capture-processor', CaptureProcessor);\n";
+export declare const captureProcessorSource = "\nclass CaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    this.recording = false;\n    const opts = options.processorOptions || {};\n    this.fromRate = opts.contextRate || sampleRate;\n    this.toRate = opts.sttSampleRate || sampleRate;\n    this.ratio = this.fromRate / this.toRate;\n    this.needsResample = this.fromRate !== this.toRate;\n    // Streaming-resampler state carried across process() blocks so the output\n    // clock doesn't drift and there's no discontinuity at 128-sample block\n    // boundaries. `prev` is the previous block's last input sample (used to\n    // interpolate across the boundary); `pos` is the fractional read position,\n    // in input samples, relative to an extended [prev, ...input] frame. Start\n    // at 1 so the first output is input[0] (not the bogus initial prev).\n    this.prev = 0;\n    this.pos = 1;\n    // Output buffer reused across process() calls -- the render quantum is a\n    // fixed size, so allocating per call would churn the realtime audio thread.\n    this.resampleBuf = null;\n    // Int16 accumulation buffer: flushed to the main thread as one transferred\n    // ArrayBuffer once ~bufferSeconds of output samples are batched. Sized 2x\n    // the flush target so a whole render quantum always fits before flushing.\n    this.targetSamples = Math.max(1, Math.round(this.toRate * (opts.bufferSeconds || 0.1)));\n    this.pending = new Int16Array(this.targetSamples * 2);\n    this.pendingLen = 0;\n    this.port.onmessage = (e) => {\n      if (e.data.event === 'start') this.recording = true;\n      else if (e.data.event === 'stop') {\n        // Final flush so the tail of speech isn't dropped on close, then ack\n        // so the host knows the tail chunk (if any) has been posted and it is\n        // safe to tear the context down.\n        this.flush();\n        this.recording = false;\n        this.port.postMessage({ event: 'stopped' });\n      }\n    };\n  }\n\n  resample(input) {\n    const ratio = this.ratio;\n    const n = input.length;\n    if (n === 0) return new Float32Array(0);\n    // At most ceil(n / ratio) + 1 outputs per block (pos starts in [0, ratio)).\n    const maxLen = Math.ceil(n / ratio) + 1;\n    if (this.resampleBuf === null || this.resampleBuf.length < maxLen) {\n      this.resampleBuf = new Float32Array(maxLen);\n    }\n    const out = this.resampleBuf;\n    // Extended frame: index 0 = prev (previous block's last sample),\n    // index k>=1 = input[k-1]. Interpolate at fractional positions stepping by\n    // ratio, carrying `pos` across calls to preserve the sample clock.\n    let count = 0;\n    let pos = this.pos;\n    while (pos < n) {\n      const idx = pos | 0;\n      const frac = pos - idx;\n      const a = idx === 0 ? this.prev : input[idx - 1];\n      const b = input[idx];\n      out[count++] = a + frac * (b - a);\n      pos += ratio;\n    }\n    // Shift the origin to this block's last sample for the next call.\n    this.prev = input[n - 1];\n    this.pos = pos - n;\n    return out.subarray(0, count);\n  }\n\n  // Convert Float32 -> Int16 and append to the pending batch. Writes through\n  // an Int16Array directly (assignment truncates like DataView.setInt16).\n  accumulate(samples) {\n    let buf = this.pending;\n    if (this.pendingLen + samples.length > buf.length) {\n      // Defensive: only reachable if a render quantum outproduces the 1x\n      // headroom above the flush target (never with 128-sample quanta).\n      const grown = new Int16Array((this.pendingLen + samples.length) * 2);\n      grown.set(buf.subarray(0, this.pendingLen));\n      this.pending = grown;\n      buf = grown;\n    }\n    for (let i = 0; i < samples.length; i++) {\n      const s = Math.max(-1, Math.min(1, samples[i]));\n      buf[this.pendingLen++] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n  }\n\n  // Post the batched samples as one transferred ArrayBuffer and reset.\n  flush() {\n    if (this.pendingLen === 0) return;\n    const buffer = this.pending.buffer.slice(0, this.pendingLen * 2);\n    this.pendingLen = 0;\n    this.port.postMessage({ event: 'chunk', buffer }, [buffer]);\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || !input[0] || !this.recording) return true;\n\n    const samples = this.needsResample ? this.resample(input[0]) : input[0];\n    this.accumulate(samples);\n    if (this.pendingLen >= this.targetSamples) this.flush();\n    return true;\n  }\n}\n\nregisterProcessor('capture-processor', CaptureProcessor);\n";
 declare const src: string;
 export default src;

package/dist/worklets/capture-processor.js

@@ -29,9 +29,12 @@ class CaptureProcessor extends AudioWorkletProcessor {
     this.port.onmessage = (e) => {
       if (e.data.event === 'start') this.recording = true;
       else if (e.data.event === 'stop') {
-        // Final flush so the tail of speech isn't dropped on close.
+        // Final flush so the tail of speech isn't dropped on close, then ack
+        // so the host knows the tail chunk (if any) has been posted and it is
+        // safe to tear the context down.
         this.flush();
         this.recording = false;
+        this.port.postMessage({ event: 'stopped' });
       }
     };
   }

package/dist/worklets/playback-processor.d.ts

@@ -1,4 +1,4 @@
 /** Raw worklet source — exported so tests can evaluate the processor directly. */
-export declare const playbackProcessorSource = "\nclass PlaybackProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const rate = options.processorOptions?.sampleRate ?? 24000;\n    // Wait for ~400ms of audio before starting.\n    // If 'done' arrives first (short utterance), start immediately.\n    this.jitterSamples = Math.floor(rate * 0.4);\n    // Float32 ring buffer \u2014 60s at the context sample rate. Allocated once for\n    // the node's lifetime; per-turn state resets via resetTurn(). writePos and\n    // readPos are absolute (monotonic) sample counts; the buffer is indexed\n    // modulo capacity so a reply longer than 60s keeps playing instead of\n    // writing past the end and going silent.\n    this.capacity = rate * 60;\n    this.samples = new Float32Array(this.capacity);\n    // Platform endianness probe: the wire format is PCM16 little-endian, so\n    // the Int16Array fast path in ingestBytes is only valid on LE hosts\n    // (every shipping browser target; the DataView path is the fallback).\n    this.littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n    this.resetTurn();\n\n    this.port.onmessage = (e) => {\n      const d = e.data;\n      if (d.event === 'write') {\n        this.ingestBytes(d.buffer);\n      } else if (d.event === 'interrupt') {\n        this.interrupted = true;\n      } else if (d.event === 'done') {\n        this.isDone = true;\n      }\n    };\n  }\n\n  // Reset per-turn state so the node is reusable across replies without\n  // reallocating the sample buffer or re-instantiating the worklet.\n  resetTurn() {\n    this.interrupted = false;\n    this.isDone = false;\n    this.playing = false;\n    // Carry-over byte for split samples across chunks\n    this.carry = null;\n    this.writePos = 0;\n    this.readPos = 0;\n  }\n\n  // End the current turn: notify the host and rearm for the next reply.\n  // Must NOT return false from process() \u2014 a processor that stops is dead\n  // for good, forcing a new node (and buffer) per reply.\n  stopTurn() {\n    this.port.postMessage({ event: 'stop' });\n    this.resetTurn();\n  }\n\n  ingestBytes(uint8) {\n    let bytes = uint8;\n\n    if (this.carry !== null) {\n      const merged = new Uint8Array(1 + bytes.length);\n      merged[0] = this.carry;\n      merged.set(bytes, 1);\n      bytes = merged;\n      this.carry = null;\n    }\n\n    if (bytes.length % 2 !== 0) {\n      this.carry = bytes[bytes.length - 1];\n      bytes = bytes.subarray(0, bytes.length - 1);\n    }\n\n    if (bytes.length === 0) return;\n    const numSamples = bytes.length / 2;\n    const cap = this.capacity;\n    const samples = this.samples;\n    if (this.littleEndian && (bytes.byteOffset & 1) === 0) {\n      // Fast path: 2-byte-aligned LE bytes wrap directly as an Int16Array;\n      // copy wrap-aware in at most two runs with no per-sample DataView call\n      // or modulo. This runs on the realtime audio thread.\n      const int16 = new Int16Array(bytes.buffer, bytes.byteOffset, numSamples);\n      let src = 0;\n      let dst = this.writePos % cap;\n      while (src < numSamples) {\n        const run = Math.min(numSamples - src, cap - dst);\n        for (let j = 0; j < run; j++) {\n          samples[dst + j] = int16[src + j] / 0x8000;\n        }\n        src += run;\n        dst = 0;\n      }\n    } else {\n      // Odd byte offset (or big-endian host): fall back to per-sample reads.\n      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);\n      let dst = this.writePos % cap;\n      for (let i = 0; i < numSamples; i++) {\n        samples[dst] = view.getInt16(i * 2, true) / 0x8000;\n        dst++;\n        if (dst === cap) dst = 0;\n      }\n    }\n    this.writePos += numSamples;\n    // If the producer outran the consumer by more than the buffer holds, drop\n    // the oldest unplayed audio rather than reading samples we've overwritten.\n    if (this.writePos - this.readPos > this.capacity) {\n      this.readPos = this.writePos - this.capacity;\n    }\n  }\n\n  process(inputs, outputs) {\n    const out = outputs[0][0];\n    if (this.interrupted) {\n      out.fill(0);\n      this.stopTurn();\n      return true;\n    }\n\n    const avail = this.writePos - this.readPos;\n\n    // Wait for jitter buffer to fill, unless done (short utterance)\n    if (!this.playing) {\n      if (avail >= this.jitterSamples || this.isDone) {\n        this.playing = true;\n      } else {\n        out.fill(0);\n        return true;\n      }\n    }\n\n    if (avail > 0) {\n      const n = Math.min(avail, out.length);\n      // Copy from the ring buffer, splitting across the wrap boundary.\n      const start = this.readPos % this.capacity;\n      const first = Math.min(n, this.capacity - start);\n      out.set(this.samples.subarray(start, start + first), 0);\n      if (n > first) out.set(this.samples.subarray(0, n - first), first);\n      this.readPos += n;\n      out.fill(0, n);\n      return true;\n    }\n\n    // No data: output silence, end the turn only when done\n    out.fill(0);\n    if (this.isDone) {\n      this.stopTurn();\n    }\n    return true;\n  }\n}\n\nregisterProcessor('playback-processor', PlaybackProcessor);\n";
+export declare const playbackProcessorSource = "\nclass PlaybackProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const rate = options.processorOptions?.sampleRate ?? 24000;\n    // Wait for ~400ms of audio before starting.\n    // If 'done' arrives first (short utterance), start immediately.\n    this.jitterSamples = Math.floor(rate * 0.4);\n    // Float32 ring buffer \u2014 60s at the context sample rate. Allocated once for\n    // the node's lifetime; per-turn state resets via resetTurn(). writePos and\n    // readPos are absolute (monotonic) sample counts; the buffer is indexed\n    // modulo capacity so a reply longer than 60s keeps playing instead of\n    // writing past the end and going silent.\n    this.capacity = rate * 60;\n    this.samples = new Float32Array(this.capacity);\n    // Platform endianness probe: the wire format is PCM16 little-endian, so\n    // the Int16Array fast path in ingestBytes is only valid on LE hosts\n    // (every shipping browser target; the DataView path is the fallback).\n    this.littleEndian = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n    this.resetTurn();\n\n    this.port.onmessage = (e) => {\n      const d = e.data;\n      if (d.event === 'write') {\n        this.ingestBytes(d.buffer);\n      } else if (d.event === 'interrupt') {\n        this.interrupted = true;\n      } else if (d.event === 'done') {\n        this.isDone = true;\n      }\n    };\n  }\n\n  // Reset per-turn state so the node is reusable across replies without\n  // reallocating the sample buffer or re-instantiating the worklet.\n  resetTurn() {\n    this.interrupted = false;\n    this.isDone = false;\n    this.playing = false;\n    // Carry-over byte for split samples across chunks\n    this.carry = null;\n    this.writePos = 0;\n    this.readPos = 0;\n  }\n\n  // End the current turn: notify the host and rearm for the next reply.\n  // Must NOT return false from process() \u2014 a processor that stops is dead\n  // for good, forcing a new node (and buffer) per reply.\n  // `reason` ('interrupt' | 'done') tells the host which turn boundary this\n  // stop belongs to: interrupt-stops are dropped host-side (flush() already\n  // settled that turn), so they can never resolve a later turn's done() early.\n  stopTurn(reason) {\n    this.port.postMessage({ event: 'stop', reason });\n    this.resetTurn();\n  }\n\n  ingestBytes(uint8) {\n    let bytes = uint8;\n\n    if (this.carry !== null) {\n      const merged = new Uint8Array(1 + bytes.length);\n      merged[0] = this.carry;\n      merged.set(bytes, 1);\n      bytes = merged;\n      this.carry = null;\n    }\n\n    if (bytes.length % 2 !== 0) {\n      this.carry = bytes[bytes.length - 1];\n      bytes = bytes.subarray(0, bytes.length - 1);\n    }\n\n    if (bytes.length === 0) return;\n    const numSamples = bytes.length / 2;\n    const cap = this.capacity;\n    const samples = this.samples;\n    if (this.littleEndian && (bytes.byteOffset & 1) === 0) {\n      // Fast path: 2-byte-aligned LE bytes wrap directly as an Int16Array;\n      // copy wrap-aware in at most two runs with no per-sample DataView call\n      // or modulo. This runs on the realtime audio thread.\n      const int16 = new Int16Array(bytes.buffer, bytes.byteOffset, numSamples);\n      let src = 0;\n      let dst = this.writePos % cap;\n      while (src < numSamples) {\n        const run = Math.min(numSamples - src, cap - dst);\n        for (let j = 0; j < run; j++) {\n          samples[dst + j] = int16[src + j] / 0x8000;\n        }\n        src += run;\n        dst = 0;\n      }\n    } else {\n      // Odd byte offset (or big-endian host): fall back to per-sample reads.\n      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);\n      let dst = this.writePos % cap;\n      for (let i = 0; i < numSamples; i++) {\n        samples[dst] = view.getInt16(i * 2, true) / 0x8000;\n        dst++;\n        if (dst === cap) dst = 0;\n      }\n    }\n    this.writePos += numSamples;\n    // If the producer outran the consumer by more than the buffer holds, drop\n    // the oldest unplayed audio rather than reading samples we've overwritten.\n    if (this.writePos - this.readPos > this.capacity) {\n      this.readPos = this.writePos - this.capacity;\n    }\n  }\n\n  process(inputs, outputs) {\n    // No output wired up yet \u2014 nothing to render this quantum. Throwing here\n    // would permanently kill the processor (the node is persistent per\n    // session), so guard like the capture processor does.\n    if (!outputs[0] || !outputs[0][0]) return true;\n    const out = outputs[0][0];\n    if (this.interrupted) {\n      out.fill(0);\n      this.stopTurn('interrupt');\n      return true;\n    }\n\n    const avail = this.writePos - this.readPos;\n\n    // Wait for jitter buffer to fill, unless done (short utterance)\n    if (!this.playing) {\n      if (avail >= this.jitterSamples || this.isDone) {\n        this.playing = true;\n      } else {\n        out.fill(0);\n        return true;\n      }\n    }\n\n    if (avail > 0) {\n      const n = Math.min(avail, out.length);\n      // Copy from the ring buffer, splitting across the wrap boundary.\n      const start = this.readPos % this.capacity;\n      const first = Math.min(n, this.capacity - start);\n      out.set(this.samples.subarray(start, start + first), 0);\n      if (n > first) out.set(this.samples.subarray(0, n - first), first);\n      this.readPos += n;\n      out.fill(0, n);\n      return true;\n    }\n\n    // No data: output silence, end the turn only when done\n    out.fill(0);\n    if (this.isDone) {\n      this.stopTurn('done');\n    }\n    return true;\n  }\n}\n\nregisterProcessor('playback-processor', PlaybackProcessor);\n";
 declare const src: string;
 export default src;

package/dist/worklets/playback-processor.js

@@ -47,8 +47,11 @@ class PlaybackProcessor extends AudioWorkletProcessor {
   // End the current turn: notify the host and rearm for the next reply.
   // Must NOT return false from process() — a processor that stops is dead
   // for good, forcing a new node (and buffer) per reply.
-  stopTurn() {
-    this.port.postMessage({ event: 'stop' });
+  // \`reason\` ('interrupt' | 'done') tells the host which turn boundary this
+  // stop belongs to: interrupt-stops are dropped host-side (flush() already
+  // settled that turn), so they can never resolve a later turn's done() early.
+  stopTurn(reason) {
+    this.port.postMessage({ event: 'stop', reason });
     this.resetTurn();
   }
 
@@ -106,10 +109,14 @@ class PlaybackProcessor extends AudioWorkletProcessor {
   }
 
   process(inputs, outputs) {
+    // No output wired up yet — nothing to render this quantum. Throwing here
+    // would permanently kill the processor (the node is persistent per
+    // session), so guard like the capture processor does.
+    if (!outputs[0] || !outputs[0][0]) return true;
     const out = outputs[0][0];
     if (this.interrupted) {
       out.fill(0);
-      this.stopTurn();
+      this.stopTurn('interrupt');
       return true;
     }
 
@@ -140,7 +147,7 @@ class PlaybackProcessor extends AudioWorkletProcessor {
     // No data: output silence, end the turn only when done
     out.fill(0);
     if (this.isDone) {
-      this.stopTurn();
+      this.stopTurn('done');
     }
     return true;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai-ui",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "type": "module",
   "files": [
     "dist",
@@ -18,12 +18,14 @@
   },
   "dependencies": {
     "clsx": "^2.1.1",
-    "@alexkroman1/aai": "1.9.2"
+    "partysocket": "^1.3.0",
+    "use-sync-external-store": "^1.6.0",
+    "@alexkroman1/aai": "1.10.0"
   },
   "peerDependencies": {
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "tailwindcss": "^4.3.2"
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tailwindcss": "^4.0.0"
   },
   "peerDependenciesMeta": {
     "tailwindcss": {
@@ -36,6 +38,7 @@
     "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
+    "@types/use-sync-external-store": "^1.5.0",
     "@vitejs/plugin-react": "^6.0.4",
     "jsdom": "^29.1.1",
     "react": "^19.2.8",

package/dist/default-client/assets/audio-Cs-6t_Wd.js

@@ -1 +0,0 @@
-import{t as e}from"./index-Bf4ZTNcx.js";async function t(e,t){let n=await new OfflineAudioContext(1,1,t).decodeAudioData(e),r=Math.ceil(n.duration*t),i=new OfflineAudioContext(1,r,t),a=i.createBufferSource();a.buffer=n,a.connect(i.destination),a.start();let o=(await i.startRendering()).getChannelData(0),s=new Int16Array(o.length);for(let e=0;e<o.length;e++){let t=Math.max(-1,Math.min(1,o[e]??0));s[e]=t<0?t*32768:t*32767}return s}async function n(t){let{sttSampleRate:n,ttsSampleRate:r,captureWorkletSrc:i,playbackWorkletSrc:a,onMicData:o}=t,s=r,c=new AudioContext({sampleRate:s,latencyHint:`playback`}),l=navigator.mediaDevices.getUserMedia({audio:{deviceId:{ideal:`default`},echoCancellation:!0,noiseSuppression:!0,autoGainControl:!0,voiceIsolation:!0}}),u;try{[u]=await Promise.all([l,c.resume(),c.audioWorklet.addModule(i),c.audioWorklet.addModule(a)])}catch(e){throw l.then(e=>{for(let t of e.getTracks())t.stop()}).catch(()=>{}),await c.close().catch(e=>{console.warn(`AudioContext close failed:`,e)}),e}let d=c.createMediaStreamSource(u),f=new AudioWorkletNode(c,`capture-processor`,{channelCount:1,channelCountMode:`explicit`,processorOptions:{contextRate:s,sttSampleRate:n,bufferSeconds:e}});d.connect(f),f.port.postMessage({event:`start`}),f.port.onmessage=e=>{e.data.event===`chunk`&&o(e.data.buffer)};let p=null,m=null,h=new AbortController;function g(){if(p)return p;let e=new AudioWorkletNode(c,`playback-processor`,{processorOptions:{sampleRate:s}});return e.connect(c.destination),e.port.onmessage=e=>{e.data.event===`stop`&&(m?.(),m=null)},p=e,e}let _={enqueue(e){h.signal.aborted||e.byteLength!==0&&g().port.postMessage({event:`write`,buffer:new Uint8Array(e)},[e])},done(){return!p||c.state!==`running`?Promise.resolve():new Promise(e=>{m=e,p?.port.postMessage({event:`done`})})},flush(){p&&p.port.postMessage({event:`interrupt`})},async close(){if(!h.signal.aborted){h.abort(),f.port.postMessage({event:`stop`}),d.disconnect(),f.disconnect(),p&&p.disconnect();for(let e of u.getTracks())e.stop();await c.close().catch(()=>{})}},async[Symbol.asyncDispose](){await _.close()}};return _}export{n as createVoiceIO,t as decodeAudioToPcm16};