@alexkroman1/aai-ui 1.16.0 → 3.0.0

package/dist/{session-core-B64kau_v.js → session-core-BM3WHeoY.js}

@@ -1,8 +1,7 @@
-import { FILE_SEND_BACKOFF_MS, MIC_SEND_MAX_BUFFERED_BYTES } from "./types.js";
+import { MIC_SEND_MAX_BUFFERED_BYTES } from "./types.js";
+import { DEFAULT_MAX_HISTORY, WS_OPEN, errorMessage, safeJsonParse } from "@alexkroman1/aai";
 import { ServerMessageSchema, lenientParse } from "@alexkroman1/aai/protocol";
-import { DEFAULT_MAX_HISTORY, FILE_UPLOAD_CHUNK_BYTES, WS_OPEN, errorMessage, safeJsonParse } from "@alexkroman1/aai";
 import ReconnectingWebSocket from "partysocket/ws";
-import { MAX_SYNC_AUDIO_SECONDS } from "@alexkroman1/aai/stt";
 //#region session-core-audio-setup.ts
 /**
 * Audio-path initialization for the voice session core.
@@ -36,6 +35,7 @@ async function initAudioCapture(conn, msg, deps, fatal) {
 	const gen = conn.generation;
 	const stale = () => conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN;
 	const reportAudioFailure = (message) => {
+		deps.cleanupAudio();
 		if (fatal) deps.updateState({
 			state: "error",
 			error: {
@@ -45,16 +45,13 @@ async function initAudioCapture(conn, msg, deps, fatal) {
 			running: false,
 			recording: false
 		});
-		else {
-			deps.cleanupAudio();
-			deps.updateState({
-				error: {
-					code: "audio",
-					message
-				},
-				recording: false
-			});
-		}
+		else deps.updateState({
+			error: {
+				code: "audio",
+				message
+			},
+			recording: false
+		});
 	};
 	try {
 		const [{ createVoiceIO }, captureWorklet, playbackWorklet] = await Promise.all([
@@ -74,6 +71,12 @@ async function initAudioCapture(conn, msg, deps, fatal) {
 					console.debug("[aai-ui] sendAudio dropped: connection closed");
 				}
 			},
+			onPlaybackStats: (stats) => {
+				console.warn("[aai-ui] playback concealed a gap in this turn", stats);
+			},
+			onMicSilent: () => {
+				console.warn("[aai-ui] microphone is delivering only silence — check the selected input device");
+			},
 			onError: (err) => {
 				if (conn.generation !== gen) return;
 				reportAudioFailure(err.message);
@@ -149,7 +152,7 @@ function appendCapped(list, item, cap) {
 * dedup) that previously lived as closure locals in `createSessionCore`.
 */
 function createMessageHandlers(deps) {
-	const { getSnapshot, updateState, conn, discardUpload, cleanupAudio } = deps;
+	const { getSnapshot, updateState, conn, cleanupAudio } = deps;
 	/** Incremented on each turn boundary -- stale async callbacks compare against this. */
 	let handlerGeneration = 0;
 	/** Monotonically increasing counter for custom events -- used by useEvent to deduplicate. */
@@ -207,6 +210,7 @@ function createMessageHandlers(deps) {
 		} });
 		else {
 			cleanupAudio();
+			conn.generation++;
 			updateState({
 				state: "error",
 				error: {
@@ -274,7 +278,6 @@ function createMessageHandlers(deps) {
 				break;
 			case "reset":
 				handlerGeneration++;
-				discardUpload();
 				conn.voiceIO?.flush();
 				updateState({
 					...CLEARED_SESSION_STATE,
@@ -347,7 +350,6 @@ function createMessageHandlers(deps) {
 		if (msg.type === "config") return {
 			sampleRate: msg.sampleRate,
 			ttsSampleRate: msg.ttsSampleRate,
-			audioOut: msg.audioOut,
 			sid: msg.sessionId
 		};
 		if (msg.type === "audio_done") {
@@ -398,84 +400,6 @@ function reconnectPending(socket) {
 	return socket instanceof ReconnectingWebSocket && socket.shouldReconnect && socket.retryCount < RECONNECT_OPTIONS.maxRetries;
 }
 //#endregion
-//#region session-core-upload.ts
-/**
-* File-upload transcription for the session core (`sendAudioFile`).
-*
-* Split out of `session-core.ts`: this module owns the decode → frame →
-* reliable-send pipeline for uploaded audio, plus the two guards that keep
-* it exclusive — an in-flight lock (no second upload, no mic start
-* mid-upload) and an epoch that in-flight sends compare against so a
-* reset/close/reconnect abandons them instead of streaming a stale clip
-* into the fresh session.
-*/
-function createUploadSender(deps) {
-	const { conn, getSnapshot, sendJson } = deps;
-	/** True while a `sendAudioFile` upload is decoding or streaming. Blocks the
-	*  mic (and a second upload) so file bytes never interleave with live audio. */
-	let uploadInFlight = false;
-	/** Bumped whenever conversation/connection state is discarded (reset, close,
-	*  reconnect). An in-flight upload compares against it between chunks and
-	*  aborts instead of streaming a stale clip into the fresh session. */
-	let uploadEpoch = 0;
-	/** Stream `bytes` to the socket in chunks, waiting out backpressure.
-	*  Unlike live mic frames (dropped under backpressure — stale speech is
-	*  worthless), file audio must arrive completely. Aborts if the connection
-	*  closes or the session is reset (`epoch` moves on) between chunks. */
-	async function sendBytesReliably(bytes, epoch) {
-		for (let i = 0; i < bytes.byteLength; i += FILE_UPLOAD_CHUNK_BYTES) {
-			while (epoch === uploadEpoch && conn.ws && conn.ws.readyState === WS_OPEN && conn.ws.bufferedAmount > MIC_SEND_MAX_BUFFERED_BYTES) await new Promise((r) => setTimeout(r, FILE_SEND_BACKOFF_MS));
-			if (epoch !== uploadEpoch) throw new Error("sendAudioFile: session was reset mid-send");
-			if (!conn.ws || conn.ws.readyState !== WS_OPEN) throw new Error("sendAudioFile: connection closed mid-send");
-			conn.ws.send(bytes.subarray(i, i + FILE_UPLOAD_CHUNK_BYTES));
-		}
-	}
-	/** Validate that an upload may start; returns the session's ready config. */
-	function assertUploadReady() {
-		const cfg = conn.readyConfig;
-		if (!(cfg && conn.ws) || conn.ws.readyState !== WS_OPEN) throw new Error("sendAudioFile: session is not connected");
-		const snap = getSnapshot();
-		if (snap.audioOut) throw new Error("sendAudioFile is only available in text-only sessions (tts: none()) — voice sessions stream the microphone instead");
-		if (snap.recording) throw new Error("sendAudioFile: stop recording before uploading a file");
-		if (uploadInFlight) throw new Error("sendAudioFile: another upload is already in progress");
-		return cfg;
-	}
-	async function sendAudioFile(file) {
-		const cfg = assertUploadReady();
-		uploadInFlight = true;
-		const epoch = uploadEpoch;
-		try {
-			const { decodeAudioToPcm16 } = await import("./audio.js");
-			const clip = await decodeAudioToPcm16(await file.arrayBuffer(), cfg.sampleRate);
-			if (getSnapshot().recording || conn.audioSetupInFlight) throw new Error("sendAudioFile: stop recording before uploading a file");
-			if (epoch !== uploadEpoch) throw new Error("sendAudioFile: session was reset mid-send");
-			if (clip.length / cfg.sampleRate <= MAX_SYNC_AUDIO_SECONDS) {
-				const bytes = new Uint8Array(clip.buffer, clip.byteOffset, clip.byteLength);
-				sendJson({
-					type: "transcribe_file_start",
-					sampleRate: cfg.sampleRate,
-					byteLength: bytes.byteLength
-				});
-				await sendBytesReliably(bytes, epoch);
-				sendJson({ type: "transcribe_file_end" });
-				return;
-			}
-			const padded = new Int16Array(clip.length + cfg.sampleRate);
-			padded.set(clip);
-			await sendBytesReliably(new Uint8Array(padded.buffer), epoch);
-		} finally {
-			uploadInFlight = false;
-		}
-	}
-	return {
-		sendAudioFile,
-		inFlight: () => uploadInFlight,
-		discard: () => {
-			uploadEpoch++;
-		}
-	};
-}
-//#endregion
 //#region session-core-url.ts
 /** Build the session WebSocket URL from the platform URL and resume state. */
 function buildWsUrl(platformUrl, resume, sessionId) {
@@ -518,7 +442,6 @@ function createSessionCore(options) {
 		contentVersion: 0,
 		started: false,
 		running: false,
-		audioOut: true,
 		recording: false,
 		apiUrl: buildWsUrl(options.platformUrl, false).toString()
 	};
@@ -564,8 +487,16 @@ function createSessionCore(options) {
 	};
 	let connectionController = null;
 	let hasConnected = false;
+	/**
+	* The session ID to resume: seeded from `options.resumeSessionId`, then
+	* kept current from every `config` frame. Reconnect URLs carry it as
+	* `?sessionId=<id>` so the server re-registers the SAME session id —
+	* that key is what per-session tool state (`ctx.state`) lives under, so
+	* a reconnect that omits it gets a fresh session with none of the
+	* agent's context, greeting suppression aside.
+	*/
+	let sessionId = options.resumeSessionId;
 	function cleanupAudio() {
-		upload.discard();
 		conn.audioSetupInFlight = false;
 		conn.voiceIO?.close().catch(() => {});
 		conn.voiceIO = null;
@@ -583,16 +514,10 @@ function createSessionCore(options) {
 		if (conn.ws.bufferedAmount > MIC_SEND_MAX_BUFFERED_BYTES) return;
 		conn.ws.send(bytes);
 	}
-	const upload = createUploadSender({
-		conn,
-		getSnapshot,
-		sendJson
-	});
 	const { handleMessage, settleWhenAudioDrained } = createMessageHandlers({
 		getSnapshot,
 		updateState,
 		conn,
-		discardUpload: upload.discard,
 		cleanupAudio
 	});
 	const audioDeps = {
@@ -613,20 +538,17 @@ function createSessionCore(options) {
 	/** React to the server's `config` message: record it, set up the audio
 	*  path for the session's mode, and replay history on reconnect. */
 	function onServerConfig(config) {
-		if (config.sid) options.onSessionId?.(config.sid);
+		if (config.sid) {
+			sessionId = config.sid;
+			options.onSessionId?.(config.sid);
+		}
 		const isReconnect = hasConnected;
 		hasConnected = true;
 		conn.readyConfig = {
 			sampleRate: config.sampleRate,
 			ttsSampleRate: config.ttsSampleRate
 		};
-		const audioOut = config.audioOut !== false;
-		updateState({ audioOut });
-		if (audioOut) initAudioCapture(conn, config, audioDeps, true);
-		else {
-			sendJson({ type: "audio_ready" });
-			updateState({ state: "listening" });
-		}
+		initAudioCapture(conn, config, audioDeps, true);
 		if (isReconnect && currentSnapshot.messages.length > 0) sendJson({
 			type: "history",
 			messages: currentSnapshot.messages.map((m) => ({
@@ -639,11 +561,12 @@ function createSessionCore(options) {
 	* The WebSocket URL for the *next* connection attempt. Evaluated per
 	* attempt (partysocket takes it as a URL provider), so once the first
 	* `config` arrives, every reconnect — automatic or explicit — carries
-	* `resume=1` and the session resumes instead of starting over.
+	* `?sessionId=<id>` and the server resumes the SAME session (id, tool
+	* state) instead of minting a new one. `resume=1` remains only as the
+	* greeting-suppression fallback for a server whose config carried no id.
 	*/
 	function currentWsUrl() {
-		const resumeId = !hasConnected ? options.resumeSessionId : void 0;
-		return buildWsUrl(options.platformUrl, hasConnected, resumeId).toString();
+		return buildWsUrl(options.platformUrl, hasConnected, sessionId).toString();
 	}
 	/** Open a socket: an injected constructor as-is (tests), or partysocket's
 	*  reconnecting WebSocket — same interface, plus reconnect-on-close. */
@@ -723,7 +646,6 @@ function createSessionCore(options) {
 		sendJson({ type: "cancel" });
 	}
 	function reset() {
-		upload.discard();
 		conn.voiceIO?.flush();
 		if (conn.ws && conn.ws.readyState === WS_OPEN) {
 			sendJson({ type: "reset" });
@@ -742,17 +664,6 @@ function createSessionCore(options) {
 			recording: false
 		});
 	}
-	function startRecording() {
-		if (currentSnapshot.audioOut || currentSnapshot.recording || conn.audioSetupInFlight || upload.inFlight()) return;
-		const cfg = conn.readyConfig;
-		if (!(cfg && conn.ws) || conn.ws.readyState !== WS_OPEN) return;
-		initAudioCapture(conn, cfg, audioDeps, false);
-	}
-	function stopRecording() {
-		if (currentSnapshot.audioOut || !currentSnapshot.recording) return;
-		cleanupAudio();
-		updateState({ recording: false });
-	}
 	function start() {
 		updateState({
 			started: true,
@@ -777,9 +688,6 @@ function createSessionCore(options) {
 		disconnect,
 		start,
 		toggle,
-		startRecording,
-		stopRecording,
-		sendAudioFile: upload.sendAudioFile,
 		[Symbol.dispose]() {
 			disconnect();
 		}

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

@@ -17,8 +17,6 @@ export declare const CLEARED_SESSION_STATE: {
 export type SessionConfigMessage = {
     sampleRate: number;
     ttsSampleRate: number;
-    /** False for text-only agents (`tts: none()`) — see ReadyConfigSchema. */
-    audioOut?: boolean | undefined;
     sid?: string | undefined;
 };
 /** Dependencies the message handlers need from the owning session core. */
@@ -26,8 +24,6 @@ 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;
 };

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

@@ -27,17 +27,7 @@ export type CustomEvent = {
  */
 export type SessionSnapshot = {
     readonly state: AgentState;
-    /**
-     * False when the server declared the session text-only (`tts: none()`):
-     * no audio frames will arrive and replies render as text. True until the
-     * server's `config` message says otherwise (voice is the default).
-     */
-    readonly audioOut: boolean;
-    /**
-     * True while the microphone is live and streaming to the server. Voice
-     * sessions record for their whole lifetime; text-only sessions toggle this
-     * via `startRecording()` / `stopRecording()` (the record button).
-     */
+    /** True while the microphone is live and streaming to the server. */
     readonly recording: boolean;
     /**
      * The WebSocket URL a program can connect to directly (the same endpoint
@@ -94,22 +84,6 @@ export type SessionCore = {
     start(): void;
     /** Toggle between connected and disconnected states. */
     toggle(): void;
-    /**
-     * Start streaming microphone audio (text-only sessions). Requests mic
-     * access on first use. No-op in voice sessions, where the mic is always on.
-     */
-    startRecording(): void;
-    /** Stop streaming microphone audio (text-only sessions). No-op in voice sessions. */
-    stopRecording(): void;
-    /**
-     * Decode an audio file (any format the browser can decode), resample it to
-     * the session's STT rate, and stream it to the server for transcription.
-     * Text-only sessions (`tts: none()`) only — voice sessions stream the
-     * microphone instead and reject. Also rejects when no session is connected,
-     * the mic is recording, another upload is in flight, or the file cannot be
-     * decoded. Resolves once the audio has been handed to the socket.
-     */
-    sendAudioFile(file: Blob): Promise<void>;
     /** Alias for `disconnect` for use with `using`. */
     [Symbol.dispose](): void;
 };

package/dist/session-core.js

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

package/dist/types.d.ts

@@ -1,5 +1,28 @@
 import type { SessionErrorCode } from "@alexkroman1/aai/protocol";
-export { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES, } from "@alexkroman1/aai";
+export { CAPTURE_STOP_ACK_TIMEOUT_MS, DEFAULT_STT_SAMPLE_RATE, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES, MIC_SILENCE_PROBE_MS, PLAYBACK_BUFFER_SECONDS, PLAYBACK_CONCEAL_FADE_MS, PLAYBACK_CONCEAL_FLOOR, PLAYBACK_DONE_MAX_WAIT_MS, PLAYBACK_DONE_POLL_MS, PLAYBACK_JITTER_MS, PLAYBACK_REFILL_MS, } from "@alexkroman1/aai";
+/**
+ * `getUserMedia` audio constraints for every capture path in this package.
+ *
+ * Defined once because four copies of this object drifted apart trivially, and
+ * the flags are not cosmetic — each one rewrites the signal before STT (and
+ * before the sync path's energy VAD) ever sees it:
+ *
+ * - **`autoGainControl: false`** — AGC continuously retargets level, which
+ *   means riding the noise floor up through silence. An energy VAD calibrated
+ *   against a moving floor is calibrated against nothing.
+ * - **`noiseSuppression: false`** / **`voiceIsolation: false`** — both discard
+ *   signal to make speech sound cleaner to a human, and both can gate a quiet
+ *   room to *exact* zeros, which is also what a dead microphone looks like
+ *   (see `MIC_SILENCE_PROBE_MS`).
+ * - **`echoCancellation: true`** — this one stays on. The mic is open while
+ *   the agent speaks (barge-in needs it), so without AEC the agent hears
+ *   itself and interrupts its own reply.
+ *
+ * Cast because `voiceIsolation` is newer than TypeScript's DOM lib.
+ *
+ * @public
+ */
+export declare const VOICE_CAPTURE_CONSTRAINTS: MediaTrackConstraints;
 /**
  * Current state of the voice agent session.
  *

package/dist/types.js

@@ -1,2 +1,32 @@
-import { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES } from "@alexkroman1/aai";
-export { FILE_SEND_BACKOFF_MS, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES };
+import { CAPTURE_STOP_ACK_TIMEOUT_MS, DEFAULT_STT_SAMPLE_RATE, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES, MIC_SILENCE_PROBE_MS, PLAYBACK_BUFFER_SECONDS, PLAYBACK_CONCEAL_FADE_MS, PLAYBACK_CONCEAL_FLOOR, PLAYBACK_DONE_MAX_WAIT_MS, PLAYBACK_DONE_POLL_MS, PLAYBACK_JITTER_MS, PLAYBACK_REFILL_MS } from "@alexkroman1/aai";
+//#region types.ts
+/**
+* `getUserMedia` audio constraints for every capture path in this package.
+*
+* Defined once because four copies of this object drifted apart trivially, and
+* the flags are not cosmetic — each one rewrites the signal before STT (and
+* before the sync path's energy VAD) ever sees it:
+*
+* - **`autoGainControl: false`** — AGC continuously retargets level, which
+*   means riding the noise floor up through silence. An energy VAD calibrated
+*   against a moving floor is calibrated against nothing.
+* - **`noiseSuppression: false`** / **`voiceIsolation: false`** — both discard
+*   signal to make speech sound cleaner to a human, and both can gate a quiet
+*   room to *exact* zeros, which is also what a dead microphone looks like
+*   (see `MIC_SILENCE_PROBE_MS`).
+* - **`echoCancellation: true`** — this one stays on. The mic is open while
+*   the agent speaks (barge-in needs it), so without AEC the agent hears
+*   itself and interrupts its own reply.
+*
+* Cast because `voiceIsolation` is newer than TypeScript's DOM lib.
+*
+* @public
+*/
+const VOICE_CAPTURE_CONSTRAINTS = {
+	echoCancellation: true,
+	noiseSuppression: false,
+	autoGainControl: false,
+	voiceIsolation: false
+};
+//#endregion
+export { CAPTURE_STOP_ACK_TIMEOUT_MS, DEFAULT_STT_SAMPLE_RATE, MIC_BUFFER_SECONDS, MIC_SEND_MAX_BUFFERED_BYTES, MIC_SILENCE_PROBE_MS, PLAYBACK_BUFFER_SECONDS, PLAYBACK_CONCEAL_FADE_MS, PLAYBACK_CONCEAL_FLOOR, PLAYBACK_DONE_MAX_WAIT_MS, PLAYBACK_DONE_POLL_MS, PLAYBACK_JITTER_MS, PLAYBACK_REFILL_MS, VOICE_CAPTURE_CONSTRAINTS };

package/dist/worklets/_module-url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Blob-URL module for an inlined AudioWorklet processor source.
+ *
+ * A blob URL rather than a data URI because the agent page's CSP allows
+ * `script-src blob:` but not `data:` — a data-URI module fails `addModule`
+ * with the opaque "Unable to load a worklet's module". Every inline worklet
+ * in this package must load through this helper so that constraint lives in
+ * one place.
+ */
+export declare function workletModuleUrl(source: string): string;

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, 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;
+export declare const captureProcessorSource = "\nclass CaptureProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    this.recording = false;\n    const opts = options.processorOptions || {};\n    // The context runs at the STT rate, so this is both the input and the\n    // output rate \u2014 there is nothing to convert.\n    this.rate = opts.sampleRate || sampleRate;\n    // Int16 accumulation buffer: flushed to the main thread as one transferred\n    // ArrayBuffer once ~bufferSeconds of samples are batched. Sized 2x the\n    // flush target so a whole render quantum always fits before flushing.\n    this.targetSamples = Math.max(1, Math.round(this.rate * (opts.bufferSeconds || 0.1)));\n    this.pending = new Int16Array(this.targetSamples * 2);\n    this.pendingLen = 0;\n    // Dead-mic probe: samples left to inspect before concluding the device\n    // delivers nothing but digital silence. Only consumed while recording, so\n    // the cost disappears after the window (or after the first real sample).\n    this.probeSamplesLeft = Math.round(\n      (this.rate * (opts.silenceProbeMs ?? 1500)) / 1000,\n    );\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  // 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  // Watch the first window of input for any nonzero sample. One is enough to\n  // prove the device is live \u2014 a real mic in a quiet room still carries a\n  // noise floor, so all-zeros means muted, wrong input, or no input at all.\n  probeForSilence(channel) {\n    for (let i = 0; i < channel.length; i++) {\n      if (channel[i] !== 0) {\n        this.probeSamplesLeft = 0;\n        return;\n      }\n    }\n    this.probeSamplesLeft -= channel.length;\n    if (this.probeSamplesLeft <= 0) {\n      this.port.postMessage({ event: 'silent' });\n    }\n  }\n\n  process(inputs) {\n    const input = inputs[0];\n    if (!input || !input[0] || !this.recording) return true;\n\n    if (this.probeSamplesLeft > 0) this.probeForSilence(input[0]);\n\n    this.accumulate(input[0]);\n    if (this.pendingLen >= this.targetSamples) this.flush();\n    return true;\n  }\n}\n\nregisterProcessor('capture-processor', CaptureProcessor);\n";
+declare const _default: string;
+export default _default;

package/dist/worklets/capture-processor.js

@@ -1,3 +1,5 @@
+import { MIC_BUFFER_SECONDS, MIC_SILENCE_PROBE_MS } from "../types.js";
+import { t as workletModuleUrl } from "../_module-url-C_4gRVL0.js";
 //#region worklets/capture-processor.ts
 const CaptureProcessorWorklet = `
 class CaptureProcessor extends AudioWorkletProcessor {
@@ -5,27 +7,21 @@ class CaptureProcessor extends AudioWorkletProcessor {
     super();
     this.recording = false;
     const opts = options.processorOptions || {};
-    this.fromRate = opts.contextRate || sampleRate;
-    this.toRate = opts.sttSampleRate || sampleRate;
-    this.ratio = this.fromRate / this.toRate;
-    this.needsResample = this.fromRate !== this.toRate;
-    // Streaming-resampler state carried across process() blocks so the output
-    // clock doesn't drift and there's no discontinuity at 128-sample block
-    // boundaries. \`prev\` is the previous block's last input sample (used to
-    // interpolate across the boundary); \`pos\` is the fractional read position,
-    // in input samples, relative to an extended [prev, ...input] frame. Start
-    // at 1 so the first output is input[0] (not the bogus initial prev).
-    this.prev = 0;
-    this.pos = 1;
-    // Output buffer reused across process() calls -- the render quantum is a
-    // fixed size, so allocating per call would churn the realtime audio thread.
-    this.resampleBuf = null;
+    // The context runs at the STT rate, so this is both the input and the
+    // output rate — there is nothing to convert.
+    this.rate = opts.sampleRate || sampleRate;
     // Int16 accumulation buffer: flushed to the main thread as one transferred
-    // ArrayBuffer once ~bufferSeconds of output samples are batched. Sized 2x
-    // the flush target so a whole render quantum always fits before flushing.
-    this.targetSamples = Math.max(1, Math.round(this.toRate * (opts.bufferSeconds || 0.1)));
+    // ArrayBuffer once ~bufferSeconds of samples are batched. Sized 2x the
+    // flush target so a whole render quantum always fits before flushing.
+    this.targetSamples = Math.max(1, Math.round(this.rate * (opts.bufferSeconds || ${MIC_BUFFER_SECONDS})));
     this.pending = new Int16Array(this.targetSamples * 2);
     this.pendingLen = 0;
+    // Dead-mic probe: samples left to inspect before concluding the device
+    // delivers nothing but digital silence. Only consumed while recording, so
+    // the cost disappears after the window (or after the first real sample).
+    this.probeSamplesLeft = Math.round(
+      (this.rate * (opts.silenceProbeMs ?? ${MIC_SILENCE_PROBE_MS})) / 1000,
+    );
     this.port.onmessage = (e) => {
       if (e.data.event === 'start') this.recording = true;
       else if (e.data.event === 'stop') {
@@ -39,35 +35,6 @@ class CaptureProcessor extends AudioWorkletProcessor {
     };
   }
 
-  resample(input) {
-    const ratio = this.ratio;
-    const n = input.length;
-    if (n === 0) return new Float32Array(0);
-    // At most ceil(n / ratio) + 1 outputs per block (pos starts in [0, ratio)).
-    const maxLen = Math.ceil(n / ratio) + 1;
-    if (this.resampleBuf === null || this.resampleBuf.length < maxLen) {
-      this.resampleBuf = new Float32Array(maxLen);
-    }
-    const out = this.resampleBuf;
-    // Extended frame: index 0 = prev (previous block's last sample),
-    // index k>=1 = input[k-1]. Interpolate at fractional positions stepping by
-    // ratio, carrying \`pos\` across calls to preserve the sample clock.
-    let count = 0;
-    let pos = this.pos;
-    while (pos < n) {
-      const idx = pos | 0;
-      const frac = pos - idx;
-      const a = idx === 0 ? this.prev : input[idx - 1];
-      const b = input[idx];
-      out[count++] = a + frac * (b - a);
-      pos += ratio;
-    }
-    // Shift the origin to this block's last sample for the next call.
-    this.prev = input[n - 1];
-    this.pos = pos - n;
-    return out.subarray(0, count);
-  }
-
   // Convert Float32 -> Int16 and append to the pending batch. Writes through
   // an Int16Array directly (assignment truncates like DataView.setInt16).
   accumulate(samples) {
@@ -94,12 +61,29 @@ class CaptureProcessor extends AudioWorkletProcessor {
     this.port.postMessage({ event: 'chunk', buffer }, [buffer]);
   }
 
+  // Watch the first window of input for any nonzero sample. One is enough to
+  // prove the device is live — a real mic in a quiet room still carries a
+  // noise floor, so all-zeros means muted, wrong input, or no input at all.
+  probeForSilence(channel) {
+    for (let i = 0; i < channel.length; i++) {
+      if (channel[i] !== 0) {
+        this.probeSamplesLeft = 0;
+        return;
+      }
+    }
+    this.probeSamplesLeft -= channel.length;
+    if (this.probeSamplesLeft <= 0) {
+      this.port.postMessage({ event: 'silent' });
+    }
+  }
+
   process(inputs) {
     const input = inputs[0];
     if (!input || !input[0] || !this.recording) return true;
 
-    const samples = this.needsResample ? this.resample(input[0]) : input[0];
-    this.accumulate(samples);
+    if (this.probeSamplesLeft > 0) this.probeForSilence(input[0]);
+
+    this.accumulate(input[0]);
     if (this.pendingLen >= this.targetSamples) this.flush();
     return true;
   }
@@ -109,7 +93,6 @@ registerProcessor('capture-processor', CaptureProcessor);
 `;
 /** Raw worklet source — exported so tests can evaluate the processor directly. */
 const captureProcessorSource = CaptureProcessorWorklet;
-const script = new Blob([CaptureProcessorWorklet], { type: "application/javascript" });
-const src = URL.createObjectURL(script);
+var capture_processor_default = workletModuleUrl(CaptureProcessorWorklet);
 //#endregion
-export { captureProcessorSource, src as default };
+export { captureProcessorSource, capture_processor_default as default };

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  // `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;
+export declare const playbackProcessorSource = "\nclass PlaybackProcessor extends AudioWorkletProcessor {\n  constructor(options) {\n    super();\n    const opts = options.processorOptions || {};\n    // The node's context IS the playback context (audio.ts asserts its rate),\n    // so the worklet-global sampleRate is authoritative; the option exists\n    // for the node-less test harness.\n    const rate = opts.sampleRate ?? sampleRate;\n    // Fill target for the start of a turn. If 'done' arrives first (short\n    // utterance), start immediately instead of waiting for audio that is\n    // never coming.\n    this.jitterSamples = Math.floor((rate * (opts.jitterMs ?? 400)) / 1000);\n    // Fill target after an underrun \u2014 see PLAYBACK_REFILL_MS.\n    this.refillSamples = Math.floor((rate * (opts.refillMs ?? 200)) / 1000);\n    // Concealment source: a ring of the most recently played samples, looped\n    // under a decaying gain to cover a gap. Sized to the fade window, with a\n    // per-sample decay that reaches the floor exactly at its end.\n    this.concealCapacity = Math.max(1, Math.floor((rate * 40) / 1000));\n    this.concealBuf = new Float32Array(this.concealCapacity);\n    this.concealDecay = Math.exp(Math.log(0.001) / this.concealCapacity);\n    // Float32 ring buffer \u2014 PLAYBACK_BUFFER_SECONDS at the context sample\n    // rate. Allocated once for the node's lifetime; per-turn state resets via\n    // resetTurn(). writePos and readPos are absolute (monotonic) sample\n    // counts; the buffer is indexed modulo capacity so a longer reply keeps\n    // playing instead of 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        // Applied eagerly, not deferred to the next process(): onmessage and\n        // process() never interleave (one audio thread), and a deferred\n        // interrupt would let 'write'/'done' frames for the NEXT turn\n        // coalesce in ahead of it and be wiped by the reset along with the\n        // cancelled turn's audio.\n        this.stopTurn('interrupt');\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.isDone = false;\n    this.playing = false;\n    // Whether any real audio has been rendered this turn. Separates a turn's\n    // pre-roll (nothing to extrapolate from, and not a defect) from a\n    // mid-turn underrun.\n    this.hasPlayed = false;\n    this.fillTarget = this.jitterSamples;\n    // Carry-over byte for split samples across chunks\n    this.carry = null;\n    this.writePos = 0;\n    this.readPos = 0;\n    // Concealment ring state and the current fade position.\n    this.concealLen = 0;\n    this.concealWrite = 0;\n    this.concealPos = 0;\n    this.concealGain = 1;\n    // Episode flags, so a multi-quantum gap counts as one event.\n    this.concealing = false;\n    this.concealedSilence = false;\n    // Reported to the host on 'stop'. A fresh object per turn: the one just\n    // posted must not be mutated by the next turn.\n    this.stats = {\n      concealedSamples: 0,\n      silentConcealedSamples: 0,\n      concealmentEvents: 0,\n      silentConcealmentEvents: 0,\n    };\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, stats: this.stats });\n    this.resetTurn();\n  }\n\n  // Cover a quantum (from `start`) where real audio should have been.\n  //\n  // Before the turn's first samples there is nothing to extrapolate from, so\n  // the gap is plain silence and counted as nothing \u2014 WebRTC likewise only\n  // counts concealment once playout has begun. After that, loop the retained\n  // tail under a decaying gain: a hard zero-fill is a discontinuity mid-word,\n  // which is the click that makes a brief stall sound like breakage.\n  coverGap(out, start) {\n    if (!this.hasPlayed) {\n      out.fill(0, start);\n      return;\n    }\n    if (!this.concealing) {\n      this.concealing = true;\n      this.concealedSilence = false;\n      this.stats.concealmentEvents++;\n    }\n    const total = out.length - start;\n    const len = this.concealLen;\n    let silent = 0;\n    // Second condition: once the fade has decayed to the floor, every sample\n    // the loop would emit is 0 anyway \u2014 bulk-fill instead of running 128\n    // branchy iterations per quantum for the whole tail of a long stall.\n    if (len === 0 || this.concealGain < 0.001) {\n      out.fill(0, start);\n      silent = total;\n    } else {\n      let g = this.concealGain;\n      for (let i = start; i < out.length; i++) {\n        if (g < 0.001) {\n          // The fade has run out: keep counting the gap, but stop looping a\n          // fragment that is now inaudible anyway.\n          out[i] = 0;\n          silent++;\n          continue;\n        }\n        out[i] = this.concealBuf[this.concealPos] * g;\n        this.concealPos = this.concealPos + 1 === len ? 0 : this.concealPos + 1;\n        g *= this.concealDecay;\n      }\n      this.concealGain = g;\n    }\n    this.stats.concealedSamples += total;\n    if (silent > 0) {\n      this.stats.silentConcealedSamples += silent;\n      if (!this.concealedSilence) {\n        this.concealedSilence = true;\n        this.stats.silentConcealmentEvents++;\n      }\n    }\n  }\n\n  // Retain the tail of a rendered quantum as the next gap's concealment\n  // source, and close any episode the real audio just ended.\n  rememberTail(out, n) {\n    const cap = this.concealCapacity;\n    const take = Math.min(n, cap);\n    // Bulk copies (this runs on every cleanly rendered quantum): the tail is\n    // one contiguous source run, landing in at most two ring runs.\n    const tail = out.subarray(n - take, n);\n    const first = Math.min(take, cap - this.concealWrite);\n    this.concealBuf.set(tail.subarray(0, first), this.concealWrite);\n    if (take > first) this.concealBuf.set(tail.subarray(first), 0);\n    this.concealWrite = (this.concealWrite + take) % cap;\n    this.concealLen = Math.min(cap, this.concealLen + take);\n    // Read the loop oldest-first; once the ring is full the write cursor is\n    // the oldest retained sample.\n    this.concealPos = this.concealLen === cap ? this.concealWrite : 0;\n    this.concealing = false;\n    this.concealGain = 1;\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    const avail = this.writePos - this.readPos;\n\n    // Filling: wait for the target. 'done' short-circuits it \u2014 what is\n    // buffered is all there will be, so there is nothing left to wait for.\n    if (!this.playing) {\n      if (avail >= this.fillTarget || this.isDone) {\n        this.playing = true;\n      } else {\n        this.coverGap(out, 0);\n        return true;\n      }\n    }\n\n    // Underrun: this quantum cannot be filled and more audio is still coming.\n    // Go back to filling (at the refill target) and cover the gap, leaving\n    // readPos untouched \u2014 the fragment stays buffered and plays intact once\n    // the buffer recovers, instead of being dribbled out a few samples at a\n    // time for the rest of the turn.\n    if (avail < out.length && !this.isDone) {\n      this.playing = false;\n      this.fillTarget = this.refillSamples;\n      this.coverGap(out, 0);\n      return true;\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      // Only reachable with n < out.length on the turn's final partial\n      // quantum (the underrun branch above catches every other case).\n      out.fill(0, n);\n      this.hasPlayed = true;\n      this.rememberTail(out, n);\n      return true;\n    }\n\n    // Drained and done: end the turn. Not reachable mid-turn \u2014 an empty\n    // buffer with audio still coming is the underrun branch above.\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 _default: string;
+export default _default;