@alexkroman1/aai-ui 1.9.2 → 1.11.0

package/dist/{session-core-D3NDaySY.js → session-core-KUoY-0JO.js}

@@ -1,7 +1,108 @@
-import "./types.js";
+import { FILE_SEND_BACKOFF_MS, MIC_SEND_MAX_BUFFERED_BYTES } from "./types.js";
 import { DEFAULT_MAX_HISTORY, FILE_UPLOAD_CHUNK_BYTES, WS_OPEN, errorMessage, safeJsonParse } from "@alexkroman1/aai";
 import { ServerMessageSchema, lenientParse } from "@alexkroman1/aai/protocol";
+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.
+*
+* Split out of `session-core.ts`: this module owns the async
+* mic-permission → worklet-registration → `VoiceIO` bring-up (and its
+* staleness/failure handling), while `session-core.ts` owns the state store
+* and connection lifecycle.
+*/
+/**
+* Initialize audio capture and playback after the server sends a ready config.
+*
+* Lifecycle: dynamically import audio modules -> request microphone access ->
+* register AudioWorklet processors -> create a `VoiceIO` instance -> send
+* `audio_ready` to the server -> transition state to `"listening"`.
+*
+* Uses the connection `generation` counter to detect if `connect()` was called
+* (or a reconnect happened) while awaiting async operations; if so, the stale
+* VoiceIO is closed immediately to prevent it from being assigned to a newer
+* connection.
+*
+* `fatal` selects the failure mode: voice sessions (`config` handshake) can't
+* function without the mic, so failure there sets the error state and ends
+* the session; a text-only session's opt-in record button must not brick an
+* otherwise healthy session, so failure there is a banner (`error` set,
+* state kept) and the session stays interactive.
+*/
+async function initAudioCapture(conn, msg, deps, fatal) {
+	if (conn.audioSetupInFlight) return;
+	conn.audioSetupInFlight = true;
+	const gen = conn.generation;
+	const stale = () => conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN;
+	const reportAudioFailure = (message) => {
+		if (fatal) deps.updateState({
+			state: "error",
+			error: {
+				code: "audio",
+				message
+			},
+			running: false,
+			recording: false
+		});
+		else {
+			deps.cleanupAudio();
+			deps.updateState({
+				error: {
+					code: "audio",
+					message
+				},
+				recording: false
+			});
+		}
+	};
+	try {
+		const [{ createVoiceIO }, captureWorklet, playbackWorklet] = await Promise.all([
+			import("./audio.js"),
+			import("./worklets/capture-processor.js").then((m) => m.default),
+			import("./worklets/playback-processor.js").then((m) => m.default)
+		]);
+		const io = await createVoiceIO({
+			sttSampleRate: msg.sampleRate,
+			ttsSampleRate: msg.ttsSampleRate,
+			captureWorkletSrc: captureWorklet,
+			playbackWorkletSrc: playbackWorklet,
+			onMicData: (pcm16) => {
+				try {
+					deps.sendAudio(new Uint8Array(pcm16));
+				} catch {
+					console.debug("[aai-ui] sendAudio dropped: connection closed");
+				}
+			},
+			onError: (err) => {
+				if (conn.generation !== gen) return;
+				reportAudioFailure(err.message);
+			}
+		});
+		if (stale()) {
+			io.close().catch(() => {});
+			return;
+		}
+		conn.voiceIO?.close().catch(() => {});
+		conn.voiceIO = io;
+		if (conn.preInitAudio.length > 0) {
+			for (const chunk of conn.preInitAudio) io.enqueue(chunk.buffer);
+			conn.preInitAudio = [];
+		}
+		deps.sendJson({ type: "audio_ready" });
+		deps.updateState({ recording: true });
+		if (conn.preInitDone) {
+			conn.preInitDone = false;
+			deps.settleWhenAudioDrained(io);
+		} else deps.updateState({ state: "listening" });
+	} catch (err) {
+		if (stale()) return;
+		reportAudioFailure(`Microphone access failed: ${errorMessage(err)}`);
+	} finally {
+		if (conn.generation === gen) conn.audioSetupInFlight = false;
+	}
+}
+//#endregion
 //#region session-core-messages.ts
 /**
 * Incoming-message handling for the voice session core.
@@ -48,7 +149,7 @@ function appendCapped(list, item, cap) {
 * dedup) that previously lived as closure locals in `createSessionCore`.
 */
 function createMessageHandlers(deps) {
-	const { getSnapshot, updateState, conn } = deps;
+	const { getSnapshot, updateState, conn, discardUpload, 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. */
@@ -93,7 +194,7 @@ function createMessageHandlers(deps) {
 	function clearRecoveredError() {
 		const snap = getSnapshot();
 		if (snap.state === "error") updateState({
-			state: "disconnected",
+			state: "listening",
 			error: null
 		});
 		else if (snap.error !== null) updateState({ error: null });
@@ -104,14 +205,18 @@ function createMessageHandlers(deps) {
 			code: e.code,
 			message: e.message
 		} });
-		else updateState({
-			state: "error",
-			error: {
-				code: e.code,
-				message: e.message
-			},
-			running: false
-		});
+		else {
+			cleanupAudio();
+			updateState({
+				state: "error",
+				error: {
+					code: e.code,
+					message: e.message
+				},
+				running: false,
+				recording: false
+			});
+		}
 	}
 	/** Single entry point for all server->client session events. */
 	function handleEvent(e) {
@@ -169,6 +274,7 @@ function createMessageHandlers(deps) {
 				break;
 			case "reset":
 				handlerGeneration++;
+				discardUpload();
 				conn.voiceIO?.flush();
 				updateState({
 					...CLEARED_SESSION_STATE,
@@ -188,25 +294,31 @@ function createMessageHandlers(deps) {
 	/** Enqueue a PCM16 audio chunk for playback. Transitions state to `"speaking"` on the first chunk. */
 	function playAudioChunk(chunk) {
 		const snap = getSnapshot();
-		if (snap.state === "disconnected" && snap.error !== null) return;
+		if (snap.state === "error" || snap.state === "disconnected" && snap.error !== null) return;
 		if (snap.state !== "speaking") updateState({ state: "speaking" });
 		if (conn.voiceIO) conn.voiceIO.enqueue(chunk.buffer);
 		else if (conn.preInitAudio.length < MAX_PREINIT_AUDIO_CHUNKS) conn.preInitAudio.push(chunk);
 	}
+	/** See {@link MessageHandlers.settleWhenAudioDrained}. Captures
+	*  `handlerGeneration` so a completion (or failure) that lands after a turn
+	*  boundary is discarded instead of overwriting the newer turn's state. */
+	function settleWhenAudioDrained(io) {
+		const gen = handlerGeneration;
+		io.done().then(() => {
+			if (handlerGeneration !== gen) return;
+			updateState({ state: "listening" });
+		}).catch((err) => {
+			console.warn("Audio playback done failed:", err);
+		});
+	}
 	/**
 	* Signal that the server has finished sending audio for this turn.
 	* Waits for the audio queue to drain, then transitions state to `"listening"`.
 	* Uses the `handlerGeneration` counter to discard stale completions from interrupted turns.
 	*/
 	function playAudioDone() {
-		const gen = handlerGeneration;
 		const io = conn.voiceIO;
-		if (io) io.done().then(() => {
-			if (handlerGeneration !== gen) return;
-			updateState({ state: "listening" });
-		}).catch((err) => {
-			console.warn("Audio playback done failed:", err);
-		});
+		if (io) settleWhenAudioDrained(io);
 		else {
 			conn.preInitDone = true;
 			updateState({ state: "listening" });
@@ -244,7 +356,46 @@ function createMessageHandlers(deps) {
 		}
 		handleEvent(msg);
 	}
-	return { handleMessage };
+	return {
+		handleMessage,
+		settleWhenAudioDrained
+	};
+}
+//#endregion
+//#region session-core-reconnect.ts
+/**
+* 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.
+*/
+/**
+* Backoff for automatic reconnects after an unexpected close (partysocket):
+* exponential from 1s, capped at 15s, giving up after 10 attempts. Applies
+* only to the default socket implementation — an injected
+* `options.WebSocket` (tests) never reconnects on its own.
+*/
+const RECONNECT_OPTIONS = {
+	minReconnectionDelay: 1e3,
+	maxReconnectionDelay: 15e3,
+	reconnectionDelayGrowFactor: 2,
+	maxRetries: 10
+};
+/**
+* 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.
+*/
+function openReconnectingSocket(urlProvider) {
+	return new ReconnectingWebSocket(urlProvider, void 0, RECONNECT_OPTIONS);
+}
+/**
+* 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.
+*/
+function reconnectPending(socket) {
+	return socket instanceof ReconnectingWebSocket && socket.shouldReconnect && socket.retryCount < RECONNECT_OPTIONS.maxRetries;
 }
 //#endregion
 //#region session-core-upload.ts
@@ -273,7 +424,7 @@ function createUploadSender(deps) {
 	*  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 > 65536) await new Promise((r) => setTimeout(r, 50));
+			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));
@@ -325,6 +476,16 @@ function createUploadSender(deps) {
 	};
 }
 //#endregion
+//#region session-core-url.ts
+/** Build the session WebSocket URL from the platform URL and resume state. */
+function buildWsUrl(platformUrl, resume, sessionId) {
+	const wsUrl = new URL("websocket", platformUrl.endsWith("/") ? platformUrl : `${platformUrl}/`);
+	wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
+	if (sessionId) wsUrl.searchParams.set("sessionId", sessionId);
+	else if (resume) wsUrl.searchParams.set("resume", "1");
+	return wsUrl;
+}
+//#endregion
 //#region session-core.ts
 /**
 * Framework-agnostic voice session core.
@@ -339,82 +500,6 @@ function createUploadSender(deps) {
 * No dependency on React, Preact, or any UI framework.
 */
 /**
-* Initialize audio capture and playback after the server sends a ready config.
-*
-* Lifecycle: dynamically import audio modules -> request microphone access ->
-* register AudioWorklet processors -> create a `VoiceIO` instance -> send
-* `audio_ready` to the server -> transition state to `"listening"`.
-*
-* Uses the connection `generation` counter to detect if `connect()` was called
-* while awaiting async operations; if so, the stale VoiceIO is closed immediately
-* to prevent it from being assigned to a newer connection.
-*
-* On failure (e.g. microphone permission denied, WebSocket closed mid-setup),
-* sets the error state and transitions to `"disconnected"`.
-*/
-async function initAudioCapture(conn, msg, deps) {
-	if (conn.audioSetupInFlight) return;
-	conn.audioSetupInFlight = true;
-	const gen = conn.generation;
-	try {
-		const [{ createVoiceIO }, captureWorklet, playbackWorklet] = await Promise.all([
-			import("./audio.js"),
-			import("./worklets/capture-processor.js").then((m) => m.default),
-			import("./worklets/playback-processor.js").then((m) => m.default)
-		]);
-		const io = await createVoiceIO({
-			sttSampleRate: msg.sampleRate,
-			ttsSampleRate: msg.ttsSampleRate,
-			captureWorkletSrc: captureWorklet,
-			playbackWorkletSrc: playbackWorklet,
-			onMicData: (pcm16) => {
-				try {
-					deps.sendAudio(new Uint8Array(pcm16));
-				} catch {
-					console.debug("[aai-ui] sendAudio dropped: connection closed");
-				}
-			}
-		});
-		if (conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN) {
-			io.close();
-			return;
-		}
-		conn.voiceIO = io;
-		if (conn.preInitAudio.length > 0) {
-			for (const chunk of conn.preInitAudio) io.enqueue(chunk.buffer);
-			conn.preInitAudio = [];
-		}
-		deps.sendJson({ type: "audio_ready" });
-		deps.updateState({ recording: true });
-		if (conn.preInitDone) {
-			conn.preInitDone = false;
-			io.done().then(() => {
-				if (conn.generation !== gen) return;
-				deps.updateState({ state: "listening" });
-			}).catch(() => deps.updateState({ state: "listening" }));
-		} else deps.updateState({ state: "listening" });
-	} catch (err) {
-		if (conn.generation !== gen || !conn.ws || conn.ws.readyState !== WS_OPEN) return;
-		deps.updateState({
-			state: "error",
-			error: {
-				code: "audio",
-				message: `Microphone access failed: ${errorMessage(err)}`
-			},
-			running: false
-		});
-	} finally {
-		conn.audioSetupInFlight = false;
-	}
-}
-function buildWsUrl(platformUrl, resume, sessionId) {
-	const wsUrl = new URL("websocket", platformUrl.endsWith("/") ? platformUrl : `${platformUrl}/`);
-	wsUrl.protocol = wsUrl.protocol === "https:" ? "wss:" : "ws:";
-	if (sessionId) wsUrl.searchParams.set("sessionId", sessionId);
-	else if (resume) wsUrl.searchParams.set("resume", "1");
-	return wsUrl;
-}
-/**
 * Create a framework-agnostic voice session core that connects to an AAI
 * server via WebSocket.
 *
@@ -427,7 +512,6 @@ function buildWsUrl(platformUrl, resume, sessionId) {
 * @public
 */
 function createSessionCore(options) {
-	const WS = options.WebSocket ?? WebSocket;
 	let currentSnapshot = {
 		...CLEARED_SESSION_STATE,
 		state: "disconnected",
@@ -483,7 +567,7 @@ function createSessionCore(options) {
 	function cleanupAudio() {
 		upload.discard();
 		conn.audioSetupInFlight = false;
-		conn.voiceIO?.close();
+		conn.voiceIO?.close().catch(() => {});
 		conn.voiceIO = null;
 		conn.preInitAudio = [];
 		conn.preInitDone = false;
@@ -496,24 +580,28 @@ function createSessionCore(options) {
 	}
 	function sendAudio(bytes) {
 		if (!conn.ws || conn.ws.readyState !== WS_OPEN) return;
-		if (conn.ws.bufferedAmount > 65536) return;
+		if (conn.ws.bufferedAmount > MIC_SEND_MAX_BUFFERED_BYTES) return;
 		conn.ws.send(bytes);
 	}
-	const audioDeps = {
-		sendJson,
-		sendAudio,
-		updateState
-	};
 	const upload = createUploadSender({
 		conn,
 		getSnapshot,
 		sendJson
 	});
-	const { handleMessage } = createMessageHandlers({
+	const { handleMessage, settleWhenAudioDrained } = createMessageHandlers({
 		getSnapshot,
 		updateState,
-		conn
+		conn,
+		discardUpload: upload.discard,
+		cleanupAudio
 	});
+	const audioDeps = {
+		sendJson,
+		sendAudio,
+		updateState,
+		settleWhenAudioDrained,
+		cleanupAudio
+	};
 	/** Abort the in-flight connection and release audio + WebSocket resources. */
 	function teardownConnection() {
 		connectionController?.abort();
@@ -534,7 +622,7 @@ function createSessionCore(options) {
 		};
 		const audioOut = config.audioOut !== false;
 		updateState({ audioOut });
-		if (audioOut) initAudioCapture(conn, config, audioDeps);
+		if (audioOut) initAudioCapture(conn, config, audioDeps, true);
 		else {
 			sendJson({ type: "audio_ready" });
 			updateState({ state: "listening" });
@@ -547,7 +635,27 @@ 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.
+	*/
+	function currentWsUrl() {
+		const resumeId = !hasConnected ? options.resumeSessionId : void 0;
+		return buildWsUrl(options.platformUrl, hasConnected, resumeId).toString();
+	}
+	/** Open a socket: an injected constructor as-is (tests), or partysocket's
+	*  reconnecting WebSocket — same interface, plus reconnect-on-close. */
+	function openSocket() {
+		if (options.WebSocket) return new options.WebSocket(currentWsUrl());
+		return openReconnectingSocket(currentWsUrl);
+	}
 	function connect(opts) {
+		if (opts?.signal?.aborted) {
+			disconnect();
+			return;
+		}
 		updateState({
 			state: "connecting",
 			error: null
@@ -558,11 +666,10 @@ function createSessionCore(options) {
 		connectionController = controller;
 		const { signal: sig } = controller;
 		if (opts?.signal) opts.signal.addEventListener("abort", () => disconnect(), { signal: sig });
-		const resumeId = !hasConnected ? options.resumeSessionId : void 0;
-		const wsUrl = buildWsUrl(options.platformUrl, hasConnected, resumeId);
-		const socket = new WS(wsUrl.toString());
+		const socket = openSocket();
 		socket.binaryType = "arraybuffer";
 		conn.ws = socket;
+		let socketErrored = false;
 		socket.addEventListener("open", () => {
 			updateState({ state: "ready" });
 		}, { signal: sig });
@@ -570,18 +677,47 @@ function createSessionCore(options) {
 			const config = handleMessage(event.data);
 			if (config) onServerConfig(config);
 		}, { signal: sig });
+		socket.addEventListener("error", () => {
+			socketErrored = true;
+		}, { signal: sig });
 		socket.addEventListener("close", () => {
 			if (sig.aborted) return;
-			controller.abort();
 			cleanupAudio();
-			updateState({
+			if (reconnectPending(socket)) {
+				conn.generation++;
+				socketErrored = false;
+				updateState({
+					state: "connecting",
+					recording: false
+				});
+				return;
+			}
+			controller.abort();
+			socket.close();
+			conn.ws = null;
+			if (socketErrored) updateState({
+				state: "error",
+				error: {
+					code: "connection",
+					message: "WebSocket connection error"
+				},
+				running: false,
+				recording: false
+			});
+			else if (currentSnapshot.state === "error") updateState({
+				running: false,
+				recording: false
+			});
+			else updateState({
 				state: "disconnected",
+				error: null,
 				running: false,
 				recording: false
 			});
 		}, { signal: sig });
 	}
 	function cancel() {
+		if (!conn.ws || conn.ws.readyState !== WS_OPEN) return;
 		conn.voiceIO?.flush();
 		updateState({ state: "listening" });
 		sendJson({ type: "cancel" });
@@ -595,6 +731,7 @@ function createSessionCore(options) {
 		}
 		resetState();
 		disconnect();
+		updateState({ running: true });
 		connect();
 	}
 	function disconnect() {
@@ -609,7 +746,7 @@ function createSessionCore(options) {
 		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);
+		initAudioCapture(conn, cfg, audioDeps, false);
 	}
 	function stopRecording() {
 		if (currentSnapshot.audioOut || !currentSnapshot.recording) return;

package/dist/session-core-audio-setup.d.ts

@@ -0,0 +1,36 @@
+import type { ClientMessage } from "@alexkroman1/aai/protocol";
+import type { VoiceIO } from "./audio.ts";
+import type { ConnState, SessionSnapshot } from "./session-core-types.ts";
+/** Dependencies `initAudioCapture` needs from the owning session core. */
+export type AudioSetupDeps = {
+    sendJson: (msg: ClientMessage) => void;
+    sendAudio: (bytes: Uint8Array) => void;
+    updateState: (partial: Partial<SessionSnapshot>) => void;
+    /** Turn-boundary-guarded drain from the message handlers — replays a
+     *  buffered `audio_done` without stomping a barge-in's state. */
+    settleWhenAudioDrained: (io: VoiceIO) => void;
+    /** Release the mic/VoiceIO (used when the audio path dies non-fatally). */
+    cleanupAudio: () => void;
+};
+/**
+ * Initialize audio capture and playback after the server sends a ready config.
+ *
+ * Lifecycle: dynamically import audio modules -> request microphone access ->
+ * register AudioWorklet processors -> create a `VoiceIO` instance -> send
+ * `audio_ready` to the server -> transition state to `"listening"`.
+ *
+ * Uses the connection `generation` counter to detect if `connect()` was called
+ * (or a reconnect happened) while awaiting async operations; if so, the stale
+ * VoiceIO is closed immediately to prevent it from being assigned to a newer
+ * connection.
+ *
+ * `fatal` selects the failure mode: voice sessions (`config` handshake) can't
+ * function without the mic, so failure there sets the error state and ends
+ * the session; a text-only session's opt-in record button must not brick an
+ * otherwise healthy session, so failure there is a banner (`error` set,
+ * state kept) and the session stays interactive.
+ */
+export declare function initAudioCapture(conn: ConnState, msg: {
+    sampleRate: number;
+    ttsSampleRate: number;
+}, deps: AudioSetupDeps, fatal: boolean): Promise<void>;

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-KUoY-0JO.js";
 export { createSessionCore };

package/dist/sync-mic.d.ts

@@ -0,0 +1,49 @@
+/**
+ * WebRTC microphone capture for sync mode.
+ *
+ * Captures voice through `getUserMedia` with the WebRTC voice-processing
+ * constraints (echo cancellation, noise suppression, auto gain — the
+ * processing that makes the energy VAD in `sync-vad.ts` reliable), runs an
+ * AudioWorklet that batches raw frames to the main thread, feeds them
+ * through the utterance detector, and hands each completed utterance to
+ * the sync session as one HTTP turn. No WebSocket anywhere on the path.
+ *
+ * The worklet module ships inline as a data URI, so sync mode needs no
+ * separately-served processor file.
+ */
+import type { SyncSession } from "./sync-session.ts";
+import { type UtteranceDetectorOptions } from "./sync-vad.ts";
+/** Default capture rate — what the STT providers expect. */
+export declare const DEFAULT_SYNC_MIC_SAMPLE_RATE = 16000;
+/** Data URI form of the capture processor (no served asset, no blob URL). */
+export declare const CAPTURE_WORKLET_DATA_URI: string;
+/** Clamp-and-convert one Float32 capture batch to PCM16. */
+export declare function floatToPcm16(samples: Float32Array): Int16Array;
+/** Configuration for {@link startSyncMicrophone}. */
+export type SyncMicrophoneOptions = {
+    /** The session each completed utterance is sent through. */
+    session: Pick<SyncSession, "sendPcm16">;
+    /** Capture/STT sample rate. Defaults to {@link DEFAULT_SYNC_MIC_SAMPLE_RATE}. */
+    sampleRate?: number | undefined;
+    /** VAD tuning overrides (see {@link UtteranceDetectorOptions}). */
+    vad?: Omit<UtteranceDetectorOptions, "sampleRate"> | undefined;
+    /** Speech onset confirmed — a turn will follow once the user pauses. */
+    onSpeechStart?: (() => void) | undefined;
+    /** An utterance was endpointed and its turn dispatched. */
+    onSpeechEnd?: (() => void) | undefined;
+    /** Capture or turn failure (the mic keeps running unless stopped). */
+    onError?: ((err: Error) => void) | undefined;
+};
+/** Live microphone handle returned by {@link startSyncMicrophone}. */
+export type SyncMicrophone = {
+    /** True while the detector is inside an utterance. */
+    readonly speaking: boolean;
+    /** Release the mic, the AudioContext, and flush a trailing utterance. */
+    stop(): Promise<void>;
+};
+/**
+ * Open the microphone and stream endpointed utterances into a sync session.
+ *
+ * @throws If microphone access is denied or worklet registration fails.
+ */
+export declare function startSyncMicrophone(opts: SyncMicrophoneOptions): Promise<SyncMicrophone>;