@alexkroman1/aai-ui 0.12.3 → 0.14.0

package/dist/audio/index.js

@@ -0,0 +1,431 @@
+import { CAPTURE_STOP_ACK_TIMEOUT_MS, MIC_BUFFER_SECONDS, PLAYBACK_DONE_MAX_WAIT_MS, PLAYBACK_DONE_POLL_MS, VOICE_CAPTURE_CONSTRAINTS } from "../types.js";
+//#region src/audio/capture.ts
+/**
+* The capture half's primitives, shared by the audio path (`audio/voice-io.ts`) and
+* the pre-connect capture (`audio/preconnect.ts`): the rate assertion, the
+* failed-init release, and the capture worklet node's port protocol.
+*
+* @module
+*/
+/**
+* Throw unless the browser honored a requested context sample rate. The
+* requested rates are never advisory: captured audio is tagged with the
+* requested rate on the wire, so a context running at some other rate ships
+* audio that only sounds like speech to the wrong decoder. Every capture
+* path must call this after context creation.
+*/
+function assertGranted(granted, requested, side) {
+	if (granted === requested) return;
+	throw new Error(`Browser refused the ${side} sample rate: asked for ${requested} Hz, got ${granted} Hz`);
+}
+/**
+* The error a dead worklet processor reports.
+*
+* A processor exception permanently kills the node — no further messages or
+* audio will ever arrive — so both sides log it and hand it on. One spelling of
+* that, because the pair differed only in the word "capture"/"playback" and in
+* what the playback side has to settle afterwards.
+*/
+function workletCrash(side) {
+	const err = /* @__PURE__ */ new Error(`Audio ${side} worklet crashed`);
+	console.error("[aai-ui]", err.message);
+	return err;
+}
+/**
+* Release a microphone that was (or later gets) granted while another init
+* step failed; if `getUserMedia` itself rejected, this is a no-op. Without
+* it, a mic granted after a failed init keeps the browser's recording
+* indicator lit with no way to turn it off.
+*/
+function releaseStreamOnFailure(streamPromise) {
+	streamPromise.then((s) => {
+		for (const t of s.getTracks()) t.stop();
+	}).catch(() => {});
+}
+/**
+* Wire one capture worklet node: node construction, the chunk/silent/stopped
+* port protocol, and the stop→ack handshake. No `processorOptions`: the
+* worklet reads the context rate from its global scope (callers assert the
+* granted rate first) and owns its own batching default — re-spelling
+* defaults caller-side is drift.
+*/
+function createCaptureNode(ctx, onChunk, onSilent) {
+	const node = new AudioWorkletNode(ctx, "capture-processor", {
+		channelCount: 1,
+		channelCountMode: "explicit"
+	});
+	let onStopped = null;
+	node.port.onmessage = (e) => {
+		const d = e.data;
+		if (d.event === "chunk" && d.buffer) onChunk(d.buffer);
+		else if (d.event === "silent") onSilent?.();
+		else if (d.event === "stopped") {
+			onStopped?.();
+			onStopped = null;
+		}
+	};
+	return {
+		node,
+		start() {
+			node.port.postMessage({ event: "start" });
+		},
+		stop() {
+			const { promise, resolve } = Promise.withResolvers();
+			const cap = setTimeout(resolve, CAPTURE_STOP_ACK_TIMEOUT_MS);
+			onStopped = () => {
+				clearTimeout(cap);
+				resolve();
+			};
+			node.port.postMessage({ event: "stop" });
+			return promise;
+		}
+	};
+}
+//#endregion
+//#region src/audio/preconnect.ts
+/**
+* Pre-connect capture: the microphone opened before the session's audio rates
+* are known, and the resample that fits its buffer to the rate the server
+* then names. `createVoiceIO` (`audio/voice-io.ts`) is what takes it over.
+*
+* @module
+*/
+/**
+* Open a {@link PreConnectCapture}: ask for the microphone and start buffering
+* at `sampleRate`, keeping at most the latest `maxSeconds` — the most RECENT
+* audio rather than the first, so the buffer always runs contiguously into
+* the live stream that follows it.
+*
+* Rejects like {@link createVoiceIO} does (a denied prompt, a refused rate);
+* the caller falls back to opening the path the ordinary way.
+*/
+async function openPreConnectCapture(opts) {
+	const { sampleRate, captureWorkletSrc, maxSeconds } = opts;
+	const ctx = new AudioContext({
+		sampleRate,
+		latencyHint: "interactive"
+	});
+	const streamPromise = navigator.mediaDevices.getUserMedia({ audio: {
+		deviceId: { ideal: "default" },
+		...VOICE_CAPTURE_CONSTRAINTS
+	} });
+	let stream;
+	try {
+		[stream] = await Promise.all([
+			streamPromise,
+			ctx.resume(),
+			ctx.audioWorklet.addModule(captureWorkletSrc)
+		]);
+		assertGranted(ctx.sampleRate, sampleRate, "capture");
+	} catch (err) {
+		releaseStreamOnFailure(streamPromise);
+		await ctx.close().catch(() => {});
+		throw err;
+	}
+	const maxBytes = Math.round(sampleRate * maxSeconds) * 2;
+	let chunks = [];
+	let bytes = 0;
+	let silent = false;
+	let sinks = null;
+	const mic = ctx.createMediaStreamSource(stream);
+	const capture = createCaptureNode(ctx, (pcm16) => {
+		if (sinks) {
+			sinks.onChunk(pcm16);
+			return;
+		}
+		chunks.push(pcm16);
+		bytes += pcm16.byteLength;
+		while (bytes > maxBytes && chunks.length > 1) bytes -= chunks.shift()?.byteLength ?? 0;
+	}, () => {
+		if (sinks) sinks.onSilent?.();
+		else silent = true;
+	});
+	mic.connect(capture.node);
+	capture.start();
+	/** Take the buffer, leaving it empty. */
+	const takeChunks = () => {
+		const taken = chunks;
+		chunks = [];
+		bytes = 0;
+		return taken;
+	};
+	let closed = false;
+	const closeCtx = async () => {
+		if (closed) return;
+		closed = true;
+		mic.disconnect();
+		capture.node.disconnect();
+		await ctx.close().catch((err) => {
+			console.warn("AudioContext close failed:", err);
+		});
+	};
+	return {
+		sampleRate,
+		stream,
+		ctx,
+		handOff(next) {
+			sinks = next;
+			const buffered = takeChunks();
+			if (buffered.length > 0) next.onBuffered(buffered);
+			if (silent) next.onSilent?.();
+			return {
+				mic,
+				capture
+			};
+		},
+		async detach() {
+			await capture.stop();
+			await closeCtx();
+			return {
+				chunks: takeChunks(),
+				sampleRate
+			};
+		},
+		async close() {
+			if (!closed) await capture.stop();
+			for (const t of stream.getTracks()) t.stop();
+			await closeCtx();
+		}
+	};
+}
+/** Float32 → PCM16, clamped and scaled as the capture worklet does. */
+function encodePcm16(samples) {
+	const pcm = new Int16Array(samples.length);
+	for (let i = 0; i < samples.length; i++) {
+		const s = Math.max(-1, Math.min(1, samples[i] ?? 0));
+		pcm[i] = s < 0 ? s * 32768 : s * 32767;
+	}
+	return pcm.buffer;
+}
+/**
+* Convert buffered PCM16 from one rate to another with the browser's own
+* band-limited resampler (an `OfflineAudioContext` render), re-cut into
+* {@link MIC_BUFFER_SECONDS} chunks so the burst matches the live cadence.
+*
+* Never rejects: pre-connect audio is a bonus, and a browser that cannot
+* render it offline loses the bonus rather than the session.
+*/
+async function resamplePcm16(chunks, fromRate, toRate) {
+	const total = chunks.reduce((n, c) => n + c.byteLength / 2, 0);
+	if (total === 0) return [];
+	if (fromRate === toRate) return chunks;
+	try {
+		const outLength = Math.round(total * toRate / fromRate);
+		const offline = new OfflineAudioContext(1, outLength, toRate);
+		const input = offline.createBuffer(1, total, fromRate);
+		const samples = input.getChannelData(0);
+		let at = 0;
+		for (const chunk of chunks) for (const v of new Int16Array(chunk)) samples[at++] = v / 32768;
+		const source = offline.createBufferSource();
+		source.buffer = input;
+		source.connect(offline.destination);
+		source.start();
+		const rendered = (await offline.startRendering()).getChannelData(0);
+		const size = Math.max(1, Math.round(toRate * MIC_BUFFER_SECONDS));
+		const out = [];
+		for (let start = 0; start < rendered.length; start += size) out.push(encodePcm16(rendered.subarray(start, start + size)));
+		return out;
+	} catch (err) {
+		console.warn("[aai-ui] pre-connect audio dropped: resample failed", err);
+		return [];
+	}
+}
+/**
+* Wire and start a fresh capture node on `ctx`, first flushing any audio a
+* detached {@link PreConnectCapture} held, resampled to `ctx`'s rate.
+*/
+async function startCapture(ctx, stream, opts) {
+	const mic = ctx.createMediaStreamSource(stream);
+	const capture = createCaptureNode(ctx, opts.onMicData, opts.onMicSilent);
+	mic.connect(capture.node);
+	if (opts.buffered) {
+		const { chunks, sampleRate } = opts.buffered;
+		const resampled = await resamplePcm16(chunks, sampleRate, ctx.sampleRate);
+		if (resampled.length > 0) opts.onBuffered(resampled);
+	}
+	capture.start();
+	return {
+		mic,
+		capture
+	};
+}
+//#endregion
+//#region src/audio/voice-io.ts
+/**
+* Create a {@link VoiceIO} instance that captures microphone audio and
+* plays back TTS audio using the Web Audio API.
+*
+* Playback runs on a context at the TTS sample rate for fidelity, and capture
+* on its own context at the STT rate so the *browser* performs the rate
+* conversion with its band-limited resampler. The two collapse into one
+* context when the rates match. A browser that declines either requested rate
+* fails init rather than falling back to converting in the worklet, which
+* would alias.
+*
+* @param opts - Voice I/O configuration options.
+* @returns A promise that resolves to a {@link VoiceIO} handle.
+* @throws If microphone access is denied or AudioWorklet registration fails.
+*/
+async function createVoiceIO(opts) {
+	const { sttSampleRate, ttsSampleRate, captureWorkletSrc, playbackWorkletSrc, onMicData, onError, onPlaybackStats, onPlaybackProgress, onMicSilent, preConnect } = opts;
+	const onPreConnectAudio = opts.onPreConnectAudio ?? ((chunks) => {
+		for (const chunk of chunks) onMicData(chunk);
+	});
+	const adopted = preConnect?.sampleRate === sttSampleRate ? preConnect : null;
+	const detached = preConnect && !adopted ? await preConnect.detach() : null;
+	const ctx = new AudioContext({
+		sampleRate: ttsSampleRate,
+		latencyHint: "playback"
+	});
+	const sharesContext = !adopted && sttSampleRate === ttsSampleRate;
+	const capCtx = adopted?.ctx ?? (sharesContext ? ctx : new AudioContext({
+		sampleRate: sttSampleRate,
+		latencyHint: "interactive"
+	}));
+	async function closeContexts() {
+		const contexts = sharesContext ? [ctx] : [ctx, capCtx];
+		await Promise.all(contexts.map((c) => c.close().catch((err) => {
+			console.warn("AudioContext close failed:", err);
+		})));
+	}
+	const streamPromise = preConnect ? Promise.resolve(preConnect.stream) : navigator.mediaDevices.getUserMedia({ audio: {
+		deviceId: { ideal: "default" },
+		...VOICE_CAPTURE_CONSTRAINTS
+	} });
+	let stream;
+	try {
+		[stream] = await Promise.all([
+			streamPromise,
+			ctx.resume(),
+			capCtx.resume(),
+			adopted ? void 0 : capCtx.audioWorklet.addModule(captureWorkletSrc),
+			ctx.audioWorklet.addModule(playbackWorkletSrc)
+		]);
+		assertGranted(capCtx.sampleRate, sttSampleRate, "capture");
+		assertGranted(ctx.sampleRate, ttsSampleRate, "playback");
+	} catch (err) {
+		releaseStreamOnFailure(streamPromise);
+		await closeContexts();
+		throw err;
+	}
+	const { mic, capture } = adopted ? adopted.handOff({
+		onBuffered: onPreConnectAudio,
+		onChunk: onMicData,
+		onSilent: onMicSilent
+	}) : await startCapture(capCtx, stream, {
+		onMicData,
+		onMicSilent,
+		buffered: detached,
+		onBuffered: onPreConnectAudio
+	});
+	capture.node.onprocessorerror = () => onError?.(workletCrash("capture"));
+	let playNode = null;
+	/**
+	* Turn ids for the drain handshake. Every `done()` posts a fresh id and the
+	* worklet echoes it on the matching 'stop', so a stop the worklet posted for
+	* an EARLIER turn — already in flight when a barge-in flushed that turn —
+	* cannot settle the current turn's wait. Dropping only `reason: 'interrupt'`
+	* stops was not enough: the stale one is a legitimate drain stop, just for a
+	* turn the host has already moved past, and settling on it reports the live
+	* reply finished while it is still speaking.
+	*/
+	let turnSeq = 0;
+	/**
+	* The drain wait in flight, if any.
+	*
+	* ONE field, because the resolver and the turn it belongs to are one fact:
+	* as two independently-nulled variables they could disagree, and did — the
+	* suspended-context branch of `done()` cleared the turn and left the resolver
+	* set. A single nullable makes that unrepresentable.
+	*/
+	let pendingStop = null;
+	const lifecycle = new AbortController();
+	/** Settle whatever drain wait is pending and forget the turn it belonged to. */
+	function settlePendingStop() {
+		const pending = pendingStop;
+		pendingStop = null;
+		pending?.settle();
+	}
+	function onWorkletStop(msg) {
+		if (msg.stats && msg.stats.concealedSamples > 0) onPlaybackStats?.(msg.stats);
+		if (msg.reason === "interrupt") return;
+		if (pendingStop !== null && msg.turn !== pendingStop.turn) return;
+		settlePendingStop();
+	}
+	function ensurePlayNode() {
+		if (playNode) return playNode;
+		const node = new AudioWorkletNode(ctx, "playback-processor");
+		node.connect(ctx.destination);
+		node.port.onmessage = (e) => {
+			if (e.data.event === "stop") onWorkletStop(e.data);
+			else if (e.data.event === "progress") onPlaybackProgress?.(e.data.bufferedMs);
+		};
+		node.onprocessorerror = () => {
+			const err = workletCrash("playback");
+			settlePendingStop();
+			onError?.(err);
+		};
+		playNode = node;
+		return node;
+	}
+	const io = {
+		enqueue(pcm16Buffer) {
+			if (lifecycle.signal.aborted) return;
+			if (pcm16Buffer.byteLength === 0) return;
+			ensurePlayNode().port.postMessage({
+				event: "write",
+				buffer: new Uint8Array(pcm16Buffer)
+			}, [pcm16Buffer]);
+		},
+		done() {
+			if (!playNode) return Promise.resolve();
+			const turn = ++turnSeq;
+			playNode.port.postMessage({
+				event: "done",
+				turn
+			});
+			if (ctx.state !== "running") {
+				settlePendingStop();
+				return Promise.resolve();
+			}
+			const { promise, resolve } = Promise.withResolvers();
+			settlePendingStop();
+			const settle = () => {
+				clearInterval(poll);
+				clearTimeout(cap);
+				if (pendingStop?.settle === settle) pendingStop = null;
+				resolve();
+			};
+			const poll = setInterval(() => {
+				if (ctx.state !== "running") settle();
+			}, PLAYBACK_DONE_POLL_MS);
+			const cap = setTimeout(settle, PLAYBACK_DONE_MAX_WAIT_MS);
+			pendingStop = {
+				turn,
+				settle
+			};
+			return promise;
+		},
+		flush() {
+			if (!playNode) return;
+			settlePendingStop();
+			playNode.port.postMessage({ event: "interrupt" });
+		},
+		async close() {
+			if (lifecycle.signal.aborted) return;
+			lifecycle.abort();
+			await capture.stop();
+			mic.disconnect();
+			capture.node.disconnect();
+			if (playNode) playNode.disconnect();
+			for (const t of stream.getTracks()) t.stop();
+			await closeContexts();
+		},
+		async [Symbol.asyncDispose]() {
+			await io.close();
+		}
+	};
+	return io;
+}
+//#endregion
+export { createVoiceIO, openPreConnectCapture };

package/dist/audio/preconnect.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Pre-connect capture: the microphone opened before the session's audio rates
+ * are known, and the resample that fits its buffer to the rate the server
+ * then names. `createVoiceIO` (`audio/voice-io.ts`) is what takes it over.
+ *
+ * @module
+ */
+import { type CaptureNode } from "./capture.ts";
+/**
+ * A microphone opened BEFORE the session's audio rates are known, buffering
+ * what the caller says until {@link createVoiceIO} takes it over.
+ *
+ * The connect-time half of pre-connect audio: the server names its STT rate
+ * only in its `config` frame, one handshake (and on the platform, possibly a
+ * sandbox boot) after the user pressed start — and an eager caller is talking
+ * by then. This captures at a guessed rate; {@link createVoiceIO} adopts it
+ * whole when the guess was right and resamples the buffer when it was not.
+ */
+export type PreConnectCapture = {
+    /** The rate this capture runs at — the guess. */
+    readonly sampleRate: number;
+    /** The granted microphone, handed to the {@link VoiceIO} that takes over. */
+    readonly stream: MediaStream;
+    /** The capture context, adopted as the path's own when the rate matches. */
+    readonly ctx: AudioContext;
+    /**
+     * Adopt the running capture: flush the buffer to `onBuffered`, then route
+     * every later frame to `onChunk` — synchronously, so nothing interleaves.
+     */
+    handOff(sinks: {
+        onBuffered: (chunks: ArrayBuffer[]) => void;
+        onChunk: (pcm16: ArrayBuffer) => void;
+        onSilent?: (() => void) | undefined;
+    }): {
+        mic: MediaStreamAudioSourceNode;
+        capture: CaptureNode;
+    };
+    /**
+     * Stop capturing (after the worklet's tail flush) and close the context,
+     * keeping the stream: for a path at another rate. Never rejects.
+     */
+    detach(): Promise<{
+        chunks: ArrayBuffer[];
+        sampleRate: number;
+    }>;
+    /** Release everything, stream included. Best-effort, idempotent. */
+    close(): Promise<void>;
+};
+/**
+ * Open a {@link PreConnectCapture}: ask for the microphone and start buffering
+ * at `sampleRate`, keeping at most the latest `maxSeconds` — the most RECENT
+ * audio rather than the first, so the buffer always runs contiguously into
+ * the live stream that follows it.
+ *
+ * Rejects like {@link createVoiceIO} does (a denied prompt, a refused rate);
+ * the caller falls back to opening the path the ordinary way.
+ */
+export declare function openPreConnectCapture(opts: {
+    sampleRate: number;
+    captureWorkletSrc: string;
+    maxSeconds: number;
+}): Promise<PreConnectCapture>;
+/**
+ * Convert buffered PCM16 from one rate to another with the browser's own
+ * band-limited resampler (an `OfflineAudioContext` render), re-cut into
+ * {@link MIC_BUFFER_SECONDS} chunks so the burst matches the live cadence.
+ *
+ * Never rejects: pre-connect audio is a bonus, and a browser that cannot
+ * render it offline loses the bonus rather than the session.
+ */
+export declare function resamplePcm16(chunks: ArrayBuffer[], fromRate: number, toRate: number): Promise<ArrayBuffer[]>;
+/**
+ * Wire and start a fresh capture node on `ctx`, first flushing any audio a
+ * detached {@link PreConnectCapture} held, resampled to `ctx`'s rate.
+ */
+export declare function startCapture(ctx: AudioContext, stream: MediaStream, opts: {
+    onMicData: (pcm16: ArrayBuffer) => void;
+    onMicSilent?: (() => void) | undefined;
+    buffered: {
+        chunks: ArrayBuffer[];
+        sampleRate: number;
+    } | null;
+    onBuffered: (chunks: ArrayBuffer[]) => void;
+}): Promise<{
+    mic: MediaStreamAudioSourceNode;
+    capture: CaptureNode;
+}>;

package/dist/audio/voice-io.d.ts

@@ -0,0 +1,112 @@
+import { type PreConnectCapture } from "./preconnect.ts";
+/**
+ * How much of one turn's playback was covered by concealment rather than
+ * received audio — the playback worklet's underrun report, in the shape
+ * WebRTC's `inbound-rtp` audio stats use, so the numbers mean the same thing
+ * here as in a `getStats()` dump.
+ *
+ * A turn with `concealmentEvents: 0` never needed its jitter buffer; a turn
+ * with a high `silentConcealedSamples` share starved for longer than
+ * concealment can plausibly cover, which is a bandwidth problem rather than a
+ * buffer-tuning one.
+ *
+ * @public
+ */
+export type PlaybackStats = {
+    /** Samples emitted to cover a gap, including the silent ones. */
+    concealedSamples: number;
+    /** The subset of {@link PlaybackStats.concealedSamples} that were silence. */
+    silentConcealedSamples: number;
+    /** Distinct underrun episodes, however many render quanta each spanned. */
+    concealmentEvents: number;
+    /** Episodes that lasted long enough to decay to silence. */
+    silentConcealmentEvents: number;
+};
+/** Configuration for creating a {@link VoiceIO} instance. */
+export type VoiceIOOptions = {
+    /** Sample rate in Hz expected by the STT engine (e.g. 16000). */
+    sttSampleRate: number;
+    /** Sample rate in Hz used by the TTS engine (e.g. 22050). */
+    ttsSampleRate: number;
+    /** Source URL or data URI for the capture AudioWorklet processor. */
+    captureWorkletSrc: string;
+    /** Source URL or data URI for the playback AudioWorklet processor. */
+    playbackWorkletSrc: string;
+    /** Callback invoked with buffered PCM16 microphone data to send to the server. */
+    onMicData: (pcm16: ArrayBuffer) => void;
+    /**
+     * Called when an AudioWorklet processor throws and is killed by the browser
+     * (the node produces no further audio or messages), so the session can
+     * transition out of listening/speaking instead of looking healthy forever.
+     */
+    onError?: ((err: Error) => void) | undefined;
+    /**
+     * Called at the end of any turn whose playback had to conceal a gap. Never
+     * called for a clean turn, so it can be wired straight to a warning.
+     */
+    onPlaybackStats?: ((stats: PlaybackStats) => void) | undefined;
+    /**
+     * Called every {@link PLAYBACK_PROGRESS_INTERVAL_MS} while the playback
+     * buffer holds unplayed agent audio, with its depth in ms. Wire it to the
+     * session's `playback_progress` frame: it is the host's only closed-loop
+     * view of playback, and without it the host assumes every chunk it forwards
+     * starts playing on arrival at exactly 1.0x — so a client whose buffer runs
+     * ahead of the wall clock is told the line is silent while the caller is
+     * still listening. Unwired, the host degrades to that estimate.
+     */
+    onPlaybackProgress?: ((bufferedMs: number) => void) | undefined;
+    /**
+     * Called once if the microphone delivers nothing but digital silence for
+     * the first {@link MIC_SILENCE_PROBE_MS} of capture — a muted or wrong input
+     * device, which otherwise looks exactly like a user who hasn't spoken.
+     */
+    onMicSilent?: (() => void) | undefined;
+    /**
+     * A microphone already opened by {@link openPreConnectCapture}, whose buffered
+     * audio is the start of this path's capture. Ownership passes to the
+     * returned {@link VoiceIO}: its `close()` stops the stream.
+     */
+    preConnect?: PreConnectCapture | undefined;
+    /**
+     * Called once, before any live frame reaches `onMicData`, with the audio
+     * {@link VoiceIOOptions.preConnect} held — already at `sttSampleRate`, in
+     * order. Separate from `onMicData` because it is a deliberate burst the
+     * sender's backpressure check must not drop. Unwired, it goes to
+     * `onMicData` chunk by chunk.
+     */
+    onPreConnectAudio?: ((chunks: ArrayBuffer[]) => void) | undefined;
+};
+/**
+ * Audio I/O interface for voice capture and playback.
+ *
+ * Manages microphone capture via an AudioWorklet and TTS audio playback
+ * through a second AudioWorklet. Implements {@link AsyncDisposable} for
+ * resource cleanup.
+ */
+export type VoiceIO = AsyncDisposable & {
+    /** Enqueue a PCM16 audio buffer for playback through the TTS pipeline. */
+    enqueue(pcm16Buffer: ArrayBuffer): void;
+    /** Signal that all TTS audio for the current turn has been enqueued.
+     *  Resolves when the worklet has finished playing all buffered audio. */
+    done(): Promise<void>;
+    /** Immediately stop playback and discard any buffered TTS audio. */
+    flush(): void;
+    /** Release all audio resources (microphone, AudioContext, worklets). */
+    close(): Promise<void>;
+};
+/**
+ * Create a {@link VoiceIO} instance that captures microphone audio and
+ * plays back TTS audio using the Web Audio API.
+ *
+ * Playback runs on a context at the TTS sample rate for fidelity, and capture
+ * on its own context at the STT rate so the *browser* performs the rate
+ * conversion with its band-limited resampler. The two collapse into one
+ * context when the rates match. A browser that declines either requested rate
+ * fails init rather than falling back to converting in the worklet, which
+ * would alias.
+ *
+ * @param opts - Voice I/O configuration options.
+ * @returns A promise that resolves to a {@link VoiceIO} handle.
+ * @throws If microphone access is denied or AudioWorklet registration fails.
+ */
+export declare function createVoiceIO(opts: VoiceIOOptions): Promise<VoiceIO>;

package/dist/build-default-client.d.ts

@@ -0,0 +1 @@
+export {};