@seams/voice-capture 0.0.0-stage → 0.66.0

package/dist/esm/config.js

@@ -0,0 +1,42 @@
+//#region src/config.ts
+const DEFAULTS = {
+	assetBase: null,
+	microphonePreference: null,
+	styleNonce: null,
+	label: "Voice capture",
+	place: "this page",
+	site: "this site",
+	recoveryHint: "Reload the page and try again.",
+	cacheName: "seams-voice-capture-models-v1"
+};
+let current = DEFAULTS;
+/** Sets where the assets are and how the page names itself. Call it once, before a recording. */
+function configureVoiceCapture(config) {
+	const base = new URL(config.assetBase, globalThis.document?.baseURI);
+	if (!base.pathname.endsWith("/")) base.pathname += "/";
+	current = {
+		assetBase: base,
+		microphonePreference: config.microphonePreference ?? null,
+		styleNonce: config.styleNonce ?? null,
+		label: config.label ?? DEFAULTS.label,
+		place: config.place ?? DEFAULTS.place,
+		site: config.site ?? DEFAULTS.site,
+		recoveryHint: config.recoveryHint ?? DEFAULTS.recoveryHint,
+		cacheName: config.cacheName ?? DEFAULTS.cacheName
+	};
+}
+function captureConfig() {
+	return current;
+}
+/** The nonce for a style element, or undefined when the page has none. */
+function styleNonce() {
+	const nonce = current.styleNonce;
+	return (typeof nonce === "function" ? nonce() : nonce) ?? void 0;
+}
+/** The URL of one asset file. It throws before `configureVoiceCapture` set the folder. */
+function assetUrl(fileName) {
+	if (!current.assetBase) throw new Error("Call configureVoiceCapture({ assetBase }) before you load a voice asset.");
+	return new URL(fileName, current.assetBase);
+}
+//#endregion
+export { assetUrl, captureConfig, configureVoiceCapture, styleNonce };

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import { configureVoiceCapture } from "./config.js";
+import { BrowserInferenceModel, VoiceAssetLoadError, voiceInferenceEngine } from "./inference.js";
+import { createVoiceActivity, levelDetector, voiceActivityModel } from "./voiceActivity.js";
+import { endPauseMs, expectedSpeechMs } from "./speechPause.js";
+import { MAX_SAMPLES, SAMPLE_RATE, pcm16Wav } from "./wav.js";
+import { VoiceMicrophoneInterruptedError, openVoiceMicrophone, rememberVoiceMicrophone, useSystemVoiceMicrophone } from "./microphoneInput.js";
+import { InsufficientVoiceAudioError, recordVoice, requireVoiceForeground, requireVoiceUserAction, voiceQualityMessage } from "./microphone.js";
+export { BrowserInferenceModel, InsufficientVoiceAudioError, MAX_SAMPLES, SAMPLE_RATE, VoiceAssetLoadError, VoiceMicrophoneInterruptedError, configureVoiceCapture, createVoiceActivity, endPauseMs, expectedSpeechMs, levelDetector, openVoiceMicrophone, pcm16Wav, recordVoice, rememberVoiceMicrophone, requireVoiceForeground, requireVoiceUserAction, useSystemVoiceMicrophone, voiceActivityModel, voiceInferenceEngine, voiceQualityMessage };

package/dist/esm/inference.js

@@ -0,0 +1,193 @@
+import { assetUrl, captureConfig } from "./config.js";
+//#region src/inference.ts
+const DOWNLOAD_IDLE_TIMEOUT_MS = 3e4;
+var VoiceAssetLoadError = class extends Error {
+	constructor(kind, message, options) {
+		super(message, options);
+		this.kind = kind;
+		this.name = "VoiceAssetLoadError";
+	}
+};
+async function openModelCache() {
+	try {
+		return await caches.open(captureConfig().cacheName);
+	} catch {
+		return null;
+	}
+}
+var BrowserInferenceAsset = class {
+	pending = null;
+	progress = { kind: "checking_cache" };
+	listeners = /* @__PURE__ */ new Set();
+	constructor(asset) {
+		this.asset = asset;
+	}
+	get size() {
+		return this.asset.bytes;
+	}
+	async download(onProgress) {
+		if (onProgress) {
+			this.listeners.add(onProgress);
+			onProgress(this.progress);
+		}
+		try {
+			if (!this.pending) this.pending = this.bytes().catch(this.failed);
+			const bytes = await this.pending;
+			this.publish({ kind: "ready" });
+			return bytes;
+		} finally {
+			if (onProgress) this.listeners.delete(onProgress);
+		}
+	}
+	failed = (error) => {
+		this.pending = null;
+		this.progress = { kind: "checking_cache" };
+		throw error;
+	};
+	publish(progress) {
+		this.progress = progress;
+		for (const listener of this.listeners) listener(progress);
+	}
+	async valid(bytes) {
+		if (bytes.byteLength !== this.asset.bytes) return false;
+		const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+		let hex = "";
+		for (const byte of digest) hex += byte.toString(16).padStart(2, "0");
+		return hex === this.asset.sha256;
+	}
+	async bytes() {
+		const { fileName, sha256 } = this.asset;
+		this.publish({ kind: "checking_cache" });
+		const cache = await openModelCache();
+		const cacheKey = new URL(`${fileName}?sha256=${sha256}`, assetUrl("")).href;
+		try {
+			const response = await cache?.match(cacheKey);
+			if (response) {
+				const bytes = await response.arrayBuffer();
+				if (await this.valid(bytes)) return bytes;
+				await cache?.delete(cacheKey);
+			}
+		} catch {}
+		let bytes;
+		try {
+			bytes = await this.fetchBytes();
+		} catch (error) {
+			if (!(error instanceof VoiceAssetLoadError) || error.kind !== "connection") throw error;
+			bytes = await this.fetchBytes();
+		}
+		if (cache) try {
+			await cache.put(cacheKey, new Response(bytes, { headers: { "Content-Type": "application/octet-stream" } }));
+		} catch {}
+		return bytes;
+	}
+	async fetchBytes() {
+		const { fileName } = this.asset;
+		const label = typeof this.asset.label === "function" ? this.asset.label() : this.asset.label;
+		const controller = new AbortController();
+		let idle = setTimeout(abortDownload.bind(null, controller), DOWNLOAD_IDLE_TIMEOUT_MS);
+		this.publish({
+			kind: "downloading",
+			received: 0
+		});
+		try {
+			const response = await fetch(assetUrl(fileName), {
+				credentials: "omit",
+				cache: "reload",
+				signal: controller.signal
+			});
+			if (!response.ok || !response.body) {
+				const transient = [
+					408,
+					429,
+					500,
+					502,
+					503,
+					504
+				].includes(response.status);
+				throw new VoiceAssetLoadError(transient ? "connection" : "unavailable", transient ? `${label} download was interrupted. Check your connection and retry.` : `${label} is unavailable from ${captureConfig().site}. ${captureConfig().recoveryHint}`);
+			}
+			const reader = response.body.getReader();
+			const bytes = new Uint8Array(this.asset.bytes);
+			let received = 0;
+			try {
+				while (true) {
+					const chunk = await reader.read();
+					if (chunk.done) break;
+					clearTimeout(idle);
+					idle = setTimeout(abortDownload.bind(null, controller), DOWNLOAD_IDLE_TIMEOUT_MS);
+					if (received + chunk.value.length > bytes.length) throw new VoiceAssetLoadError("integrity", `${label} size is invalid. Retry loading.`);
+					bytes.set(chunk.value, received);
+					received += chunk.value.length;
+					this.publish({
+						kind: "downloading",
+						received
+					});
+				}
+			} finally {
+				await reader.cancel().catch(ignoreCancelledDownload);
+				reader.releaseLock();
+			}
+			if (received !== bytes.length || !await this.valid(bytes.buffer)) throw new VoiceAssetLoadError("integrity", `${label} integrity check failed. Retry loading.`);
+			return bytes.buffer;
+		} catch (error) {
+			if (error instanceof VoiceAssetLoadError) throw error;
+			throw new VoiceAssetLoadError("connection", `${label} download was interrupted. Check your connection and retry.`, { cause: error });
+		} finally {
+			clearTimeout(idle);
+			controller.abort();
+		}
+	}
+};
+function abortDownload(controller) {
+	controller.abort();
+}
+function ignoreCancelledDownload() {}
+const voiceInferenceEngine = new BrowserInferenceAsset({
+	fileName: "ort-wasm-simd-threaded.wasm",
+	sha256: "3398c10d07d229bd91b364548e130e0e51a8e5704b88c7c083ebbeb78842dee2",
+	bytes: 14239897,
+	label: () => `${captureConfig().label} engine`
+});
+var BrowserInferenceModel = class {
+	asset;
+	session = null;
+	constructor(asset) {
+		this.asset = new BrowserInferenceAsset(asset);
+	}
+	prepare() {
+		if (!this.session) this.session = this.load().catch(this.failed);
+		return this.session;
+	}
+	/** Runs the model on one row of samples, as its `samples` input. Dispose the outputs. */
+	async run(samples) {
+		const session = await this.prepare();
+		const { Tensor } = await import("onnxruntime-web/wasm");
+		const input = new Tensor("float32", samples, [1, samples.length]);
+		try {
+			return await session.run({ samples: input });
+		} finally {
+			input.dispose();
+		}
+	}
+	failed = (error) => {
+		this.session = null;
+		throw error;
+	};
+	async load() {
+		try {
+			const ort = await import("onnxruntime-web/wasm");
+			ort.env.wasm.numThreads = 1;
+			ort.env.wasm.wasmPaths = assetUrl("").href;
+			ort.env.wasm.wasmBinary = await voiceInferenceEngine.download();
+			const bytes = await this.asset.download();
+			return await ort.InferenceSession.create(bytes, { executionProviders: ["wasm"] });
+		} catch (error) {
+			if (error instanceof VoiceAssetLoadError) throw error;
+			const { label, recoveryHint } = captureConfig();
+			console.error(`[${label}] inference engine could not start`, error);
+			throw new VoiceAssetLoadError("initialization", `${label} could not start. Retry loading. If it still fails, ${recoveryHint.charAt(0).toLowerCase()}${recoveryHint.slice(1)}`, { cause: error });
+		}
+	}
+};
+//#endregion
+export { BrowserInferenceModel, VoiceAssetLoadError, voiceInferenceEngine };

package/dist/esm/microphone.js

@@ -0,0 +1,428 @@
+import { assetUrl, captureConfig } from "./config.js";
+import { createVoiceActivity, levelDetector } from "./voiceActivity.js";
+import { endPauseMs } from "./speechPause.js";
+import { SAMPLE_RATE } from "./wav.js";
+import { VoiceMicrophoneInterruptedError, openVoiceMicrophone, rememberVoiceMicrophone } from "./microphoneInput.js";
+//#region src/microphone.ts
+function voiceQualityMessage(quality) {
+	if (quality.noise === "high") return "Background noise is high. Move closer to the microphone and try again.";
+	return `Audio too brief or quiet: ${(quality.voicedMs / 1e3).toFixed(2)} of ${(quality.requiredVoicedMs / 1e3).toFixed(2)} seconds detected.`;
+}
+/** Carries a typed capture rejection across the SDK's exception-based UI action boundary. */
+var InsufficientVoiceAudioError = class extends Error {
+	constructor(quality) {
+		super(voiceQualityMessage(quality));
+		this.quality = quality;
+		this.name = "InsufficientVoiceAudioError";
+	}
+};
+const LEVEL_THRESHOLD = .006;
+const REQUIRED_VOICED_MS = 600;
+const MAX_RECORDING_MS = 8e3;
+const SPEECH_START_MS = 100;
+const VOICE_FRAME_MS = 32;
+/** Throws unless the page is in front and the person just acted on it (a click or a key). */
+function requireVoiceUserAction() {
+	requireVoiceForeground();
+	if (!navigator.userActivation.isActive) {
+		const { label, place } = captureConfig();
+		throw new Error(`Open ${place} and select Record to use ${label}.`);
+	}
+}
+/** Throws unless the page is visible and has the focus. */
+function requireVoiceForeground() {
+	if (document.visibilityState !== "visible" || !document.hasFocus()) {
+		const { label, place } = captureConfig();
+		throw new Error(`Keep ${place} open and focused to use ${label}.`);
+	}
+}
+function cancelled() {
+	return /* @__PURE__ */ new Error(`${captureConfig().label} recording was cancelled.`);
+}
+function detectorOf(options) {
+	return options.detector === "level" ? async () => levelDetector : createVoiceActivity;
+}
+/**
+* Records one utterance at 16 kHz. The recording ends after a pause, or after 8 s. A recording
+* with less than 0.6 s of speech is `insufficient_audio`. The samples hold the speech with 0.2 s
+* of margin on each side.
+*/
+async function recordVoice(signal, onCapture, options = {}) {
+	const expectedSpeechMs = options.expectedSpeechMs ?? null;
+	const createDetector = detectorOf(options);
+	if (signal.aborted) throw cancelled();
+	const attemptId = crypto.randomUUID();
+	onCapture({ kind: "opening" });
+	const microphone = await openVoiceMicrophone(signal);
+	const { stream } = microphone;
+	try {
+		if (signal.aborted) throw cancelled();
+		const clip = await new VoiceRecording(stream, signal, onCapture, expectedSpeechMs, createDetector).result.finally(onCapture.bind(null, { kind: "processing" }));
+		if (signal.aborted) throw cancelled();
+		const decoded = await new OfflineAudioContext(1, SAMPLE_RATE, SAMPLE_RATE).decodeAudioData(clip.bytes);
+		const renderer = new OfflineAudioContext(1, Math.ceil(decoded.duration * SAMPLE_RATE), SAMPLE_RATE);
+		const source = renderer.createBufferSource();
+		source.buffer = decoded;
+		source.connect(renderer.destination);
+		source.start();
+		try {
+			const rendered = await renderer.startRendering();
+			try {
+				if (signal.aborted) throw cancelled();
+				const samples = rendered.getChannelData(0);
+				const measurement = await measureAudio(samples, signal, await createDetector());
+				const quality = {
+					attemptId,
+					capturedAtMs: Date.now(),
+					durationMs: rendered.duration * 1e3,
+					recordingMs: clip.recordingMs,
+					endedBy: clip.endedBy,
+					voicedMs: measurement.voicedMs,
+					peakFrameRms: measurement.peakFrameRms,
+					levelThreshold: LEVEL_THRESHOLD,
+					requiredVoicedMs: REQUIRED_VOICED_MS,
+					microphone: microphone.label,
+					microphoneSelection: microphone.selection,
+					processing: microphone.processing,
+					backgroundRms: measurement.backgroundRms,
+					speechToBackgroundDb: measurement.speechToBackgroundDb,
+					noise: measurement.noise
+				};
+				onCapture({
+					kind: "measured",
+					quality
+				});
+				if (measurement.kind === "insufficient_audio") return {
+					kind: "insufficient_audio",
+					quality
+				};
+				const speech = samples.slice(Math.max(0, measurement.first - 3200), Math.min(samples.length, measurement.last + 3200));
+				await rememberVoiceMicrophone(microphone);
+				if (signal.aborted) {
+					speech.fill(0);
+					signal.throwIfAborted();
+				}
+				return {
+					kind: "captured",
+					samples: speech,
+					quality,
+					lastSoundAtMs: clip.lastSoundAtMs
+				};
+			} finally {
+				wipeAudioBuffer(rendered);
+			}
+		} finally {
+			wipeAudioBuffer(decoded);
+		}
+	} finally {
+		for (const track of stream.getTracks()) track.stop();
+	}
+}
+var VoiceRecording = class {
+	recorder;
+	chunks = [];
+	timer = null;
+	completion = deferred();
+	startedAtMs = performance.now();
+	ended = null;
+	activity = {
+		kind: "waiting",
+		activeMs: 0
+	};
+	audioContext = null;
+	worklet = null;
+	detector = null;
+	pending = Promise.resolve();
+	queuedFrames = 0;
+	closed = false;
+	result = this.completion.promise;
+	constructor(stream, signal, onCapture, expectedSpeechMs, createDetector) {
+		this.stream = stream;
+		this.signal = signal;
+		this.onCapture = onCapture;
+		this.expectedSpeechMs = expectedSpeechMs;
+		this.createDetector = createDetector;
+		this.recorder = new MediaRecorder(stream);
+		this.recorder.addEventListener("dataavailable", this.data);
+		this.recorder.addEventListener("stop", this.stopped);
+		this.recorder.addEventListener("error", this.failed);
+		for (const track of stream.getAudioTracks()) {
+			track.addEventListener("ended", this.interrupted);
+			track.addEventListener("mute", this.interrupted);
+		}
+		signal.addEventListener("abort", this.cancelled, { once: true });
+		this.timer = setTimeout(this.startupFailed, MAX_RECORDING_MS);
+		this.start();
+	}
+	async start() {
+		try {
+			await this.startPauseDetection();
+			this.signal.throwIfAborted();
+			this.startedAtMs = performance.now();
+			if (this.closed) return;
+			this.recorder.start();
+			if (this.timer !== null) clearTimeout(this.timer);
+			this.timer = setTimeout(this.stop.bind(this, "limit"), MAX_RECORDING_MS);
+			this.onCapture({ kind: "listening" });
+		} catch (error) {
+			this.cleanup();
+			this.completion.reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Speech detection could not start."));
+		}
+	}
+	data = (event) => {
+		this.chunks.push(event.data);
+	};
+	stop = (endedBy) => {
+		if (this.recorder.state === "inactive") return;
+		this.ended = {
+			endedBy,
+			recordingMs: performance.now() - this.startedAtMs,
+			lastSoundAtMs: this.activity.kind === "speaking" ? this.activity.lastSoundAtMs : null
+		};
+		this.recorder.stop();
+		this.stopTracks();
+	};
+	cancelled = () => {
+		if (this.recorder.state === "inactive") {
+			this.cleanup();
+			this.completion.reject(cancelled());
+			return;
+		}
+		this.stop("stream_ended");
+	};
+	startupFailed = () => {
+		this.cleanup();
+		this.completion.reject(/* @__PURE__ */ new Error("Speech detection startup timed out. Please try again."));
+	};
+	detectorFailed = (error) => {
+		this.cleanup();
+		this.completion.reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Speech detection failed."));
+	};
+	failed = () => {
+		this.cleanup();
+		this.completion.reject(/* @__PURE__ */ new Error(`${captureConfig().label} could not record this microphone.`));
+	};
+	interrupted = () => {
+		this.cleanup();
+		this.completion.reject(new VoiceMicrophoneInterruptedError());
+	};
+	stopped = () => {
+		const end = this.ended;
+		this.cleanup();
+		if (this.signal.aborted) {
+			this.completion.reject(cancelled());
+			return;
+		}
+		if (end === null) {
+			this.completion.reject(new VoiceMicrophoneInterruptedError());
+			return;
+		}
+		new Blob(this.chunks, { type: this.recorder.mimeType }).arrayBuffer().then(this.complete.bind(this, end), this.completion.reject.bind(this.completion));
+	};
+	complete = (end, bytes) => {
+		if (this.signal.aborted) {
+			this.completion.reject(cancelled());
+			return;
+		}
+		this.completion.resolve({
+			bytes,
+			...end
+		});
+	};
+	async startPauseDetection() {
+		const context = new AudioContext({ sampleRate: SAMPLE_RATE });
+		this.audioContext = context;
+		const resumed = context.resume();
+		this.detector = await this.createDetector();
+		this.signal.throwIfAborted();
+		if (context.sampleRate !== 16e3) throw new Error("Speech detection requires 16 kHz audio.");
+		await context.audioWorklet.addModule(assetUrl("voice-activity-worklet.js"));
+		this.signal.throwIfAborted();
+		const worklet = new AudioWorkletNode(context, "voice-activity-frames");
+		this.worklet = worklet;
+		worklet.port.onmessage = this.receiveFrame;
+		context.createMediaStreamSource(this.stream).connect(worklet);
+		worklet.connect(context.destination);
+		await resumed;
+	}
+	receiveFrame = (event) => {
+		if (!(event.data instanceof Float32Array) || event.data.length !== 512) {
+			this.failed();
+			return;
+		}
+		if (this.closed || this.recorder.state !== "recording") {
+			event.data.fill(0);
+			return;
+		}
+		if (++this.queuedFrames > 32) {
+			event.data.fill(0);
+			this.failed();
+			return;
+		}
+		this.pending = this.pending.then(this.processFrame.bind(this, event.data)).catch(this.detectorFailed);
+	};
+	async processFrame(frame) {
+		const detector = this.detector;
+		try {
+			if (this.closed || !detector) return;
+			const probability = await detector.probability(frame);
+			if (this.closed) {
+				detector.clear();
+				return;
+			}
+			let energy = 0;
+			for (const sample of frame) energy += sample * sample;
+			const rms = Math.sqrt(energy / frame.length);
+			const speech = probability >= .5 && rms >= LEVEL_THRESHOLD;
+			this.updateActivity(speech);
+			this.onCapture({
+				kind: "activity",
+				rms,
+				speech
+			});
+		} finally {
+			frame.fill(0);
+			this.queuedFrames -= 1;
+		}
+	}
+	updateActivity(audible) {
+		const now = performance.now();
+		switch (this.activity.kind) {
+			case "waiting": {
+				const activeMs = audible ? this.activity.activeMs + VOICE_FRAME_MS : 0;
+				this.activity = activeMs >= SPEECH_START_MS ? {
+					kind: "speaking",
+					lastSoundAtMs: now,
+					voicedMs: activeMs
+				} : {
+					kind: "waiting",
+					activeMs
+				};
+				return;
+			}
+			case "speaking": {
+				const { lastSoundAtMs, voicedMs } = this.activity;
+				if (audible) {
+					this.activity = {
+						kind: "speaking",
+						lastSoundAtMs: now,
+						voicedMs: voicedMs + VOICE_FRAME_MS
+					};
+					return;
+				}
+				if (now - lastSoundAtMs >= endPauseMs(voicedMs, this.expectedSpeechMs)) this.stop("pause");
+				return;
+			}
+			default: return assertNeverActivity(this.activity);
+		}
+	}
+	stopPauseDetection = () => {
+		this.closed = true;
+		if (this.worklet) {
+			this.worklet.port.onmessage = null;
+			this.worklet.port.close();
+			this.worklet.disconnect();
+		}
+		this.worklet = null;
+		this.detector?.clear();
+		this.detector = null;
+		const context = this.audioContext;
+		this.audioContext = null;
+		if (context) context.close().catch(ignoreClosedContext);
+	};
+	stopTracks() {
+		for (const track of this.stream.getTracks()) track.stop();
+	}
+	cleanup() {
+		for (const track of this.stream.getAudioTracks()) {
+			track.removeEventListener("ended", this.interrupted);
+			track.removeEventListener("mute", this.interrupted);
+		}
+		this.stopPauseDetection();
+		this.stopTracks();
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.signal.removeEventListener("abort", this.cancelled);
+		this.recorder.removeEventListener("dataavailable", this.data);
+		this.recorder.removeEventListener("stop", this.stopped);
+		this.recorder.removeEventListener("error", this.failed);
+	}
+};
+async function measureAudio(samples, signal, detector) {
+	let first = -1;
+	let last = 0;
+	let voicedSamples = 0;
+	let peakFrameRms = 0;
+	let backgroundEnergy = 0;
+	let backgroundSamples = 0;
+	let speechEnergy = 0;
+	const frame = new Float32Array(512);
+	try {
+		for (let offset = 0; offset < samples.length; offset += frame.length) {
+			signal.throwIfAborted();
+			frame.fill(0);
+			const count = Math.min(frame.length, samples.length - offset);
+			frame.set(samples.subarray(offset, offset + count));
+			let energy = 0;
+			for (const sample of frame) energy += sample * sample;
+			const rms = Math.sqrt(energy / count);
+			peakFrameRms = Math.max(peakFrameRms, rms);
+			if (!(await detector.probability(frame) >= .5 && rms >= LEVEL_THRESHOLD)) {
+				backgroundEnergy += energy;
+				backgroundSamples += count;
+				continue;
+			}
+			if (first < 0) first = offset;
+			last = offset + count;
+			voicedSamples += count;
+			speechEnergy += energy;
+		}
+	} finally {
+		frame.fill(0);
+		detector.clear();
+	}
+	const backgroundRms = Math.sqrt(backgroundEnergy / Math.max(1, backgroundSamples));
+	const speechRms = Math.sqrt(speechEnergy / Math.max(1, voicedSamples));
+	const speechToBackgroundDb = voicedSamples && backgroundSamples ? 20 * Math.log10(Math.max(speechRms, 1e-8) / Math.max(backgroundRms, 1e-8)) : null;
+	const noise = {
+		backgroundRms,
+		speechToBackgroundDb,
+		noise: backgroundRms >= LEVEL_THRESHOLD && (speechToBackgroundDb === null || speechToBackgroundDb < 10) ? "high" : backgroundSamples ? "normal" : "unknown"
+	};
+	const voicedMs = voicedSamples / SAMPLE_RATE * 1e3;
+	if (first < 0 || voicedMs < REQUIRED_VOICED_MS) return {
+		kind: "insufficient_audio",
+		voicedMs,
+		peakFrameRms,
+		...noise
+	};
+	return {
+		kind: "captured",
+		first,
+		last,
+		voicedMs,
+		peakFrameRms,
+		...noise
+	};
+}
+function wipeAudioBuffer(buffer) {
+	for (let channel = 0; channel < buffer.numberOfChannels; channel += 1) buffer.getChannelData(channel).fill(0);
+}
+function ignoreClosedContext() {}
+/** A promise with its two settle functions. */
+function deferred() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((onResolve, onReject) => {
+			resolve = onResolve;
+			reject = onReject;
+		}),
+		resolve,
+		reject
+	};
+}
+function assertNeverActivity(activity) {
+	throw new Error(`Unexpected speech activity: ${String(activity)}`);
+}
+//#endregion
+export { InsufficientVoiceAudioError, recordVoice, requireVoiceForeground, requireVoiceUserAction, voiceQualityMessage };