@voiceinput/core 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,2173 @@
+import { VoiceInputError, VoiceInputError as VoiceInputError$1 } from "@voiceinput/provider";
+//#region src/audio-worklet-source.ts
+const VOICE_INPUT_PROCESSOR_NAME = "voiceinput-pcm16";
+/** Self-contained so the emitted function can also be loaded as a worklet. */
+function registerVoiceInputPcm16Processor(ProcessorBase, sourceSampleRate, register, processorName) {
+	class VoiceInputPcm16Processor extends ProcessorBase {
+		#frameSamples;
+		#ratio;
+		#input = [];
+		#filter;
+		#filterHistory;
+		#position = 0;
+		#frame;
+		#frameOffset = 0;
+		#filterIndex = 0;
+		constructor(options) {
+			super();
+			const processorOptions = options.processorOptions ?? {};
+			const targetSampleRate = processorOptions.targetSampleRate ?? 16e3;
+			this.#frameSamples = processorOptions.frameSamples ?? 320;
+			this.#ratio = sourceSampleRate / targetSampleRate;
+			this.#filter = this.#createLowPassFilter();
+			this.#filterHistory = new Float32Array(this.#filter.length);
+			this.#frame = new Int16Array(this.#frameSamples);
+			this.port.onmessage = (event) => {
+				if (typeof event.data === "object" && event.data !== null && "type" in event.data && event.data.type === "flush") {
+					this.#flush();
+					this.port.postMessage({ type: "flushed" });
+				}
+			};
+		}
+		process(inputs) {
+			const channels = inputs[0];
+			const sampleCount = channels?.[0]?.length ?? 0;
+			if (channels === void 0 || channels.length === 0 || sampleCount === 0) return true;
+			for (let index = 0; index < sampleCount; index += 1) {
+				let monoSample = 0;
+				for (const channel of channels) monoSample += channel[index] ?? 0;
+				this.#input.push(this.#filterSample(monoSample / channels.length));
+			}
+			this.#drain();
+			return true;
+		}
+		#createLowPassFilter() {
+			if (this.#ratio <= 1) return [1];
+			const tapCount = 31;
+			const center = 15;
+			const cutoff = .45 / this.#ratio;
+			const coefficients = [];
+			let sum = 0;
+			for (let index = 0; index < tapCount; index += 1) {
+				const offset = index - center;
+				const coefficient = (offset === 0 ? 2 * cutoff : Math.sin(2 * Math.PI * cutoff * offset) / (Math.PI * offset)) * (.42 - .5 * Math.cos(2 * Math.PI * index / 30) + .08 * Math.cos(4 * Math.PI * index / 30));
+				coefficients.push(coefficient);
+				sum += coefficient;
+			}
+			return coefficients.map((coefficient) => coefficient / sum);
+		}
+		#filterSample(sample) {
+			this.#filterHistory[this.#filterIndex] = sample;
+			let filtered = 0;
+			for (let tap = 0; tap < this.#filter.length; tap += 1) {
+				const historyIndex = (this.#filterIndex - tap + this.#filter.length) % this.#filter.length;
+				filtered += (this.#filter[tap] ?? 0) * (this.#filterHistory[historyIndex] ?? 0);
+			}
+			this.#filterIndex = (this.#filterIndex + 1) % this.#filter.length;
+			return filtered;
+		}
+		#drain() {
+			while (this.#position + 1 < this.#input.length) {
+				const lower = Math.floor(this.#position);
+				const fraction = this.#position - lower;
+				const first = this.#input[lower] ?? 0;
+				const sample = first + ((this.#input[lower + 1] ?? first) - first) * fraction;
+				const clamped = Math.max(-1, Math.min(1, sample));
+				this.#frame[this.#frameOffset] = clamped < 0 ? clamped * 32768 : clamped * 32767;
+				this.#frameOffset += 1;
+				if (this.#frameOffset === this.#frame.length) {
+					this.#emitFrame(this.#frame);
+					this.#frame = new Int16Array(this.#frameSamples);
+					this.#frameOffset = 0;
+				}
+				this.#position += this.#ratio;
+			}
+			const consumed = Math.min(Math.floor(this.#position), Math.max(0, this.#input.length - 1));
+			if (consumed > 0) {
+				this.#input.splice(0, consumed);
+				this.#position -= consumed;
+			}
+		}
+		#flush() {
+			const lastSample = this.#input.at(-1);
+			if (lastSample !== void 0) {
+				this.#input.push(lastSample);
+				this.#drain();
+			}
+			if (this.#frameOffset > 0) this.#emitFrame(this.#frame.slice(0, this.#frameOffset));
+			this.#input.length = 0;
+			this.#position = 0;
+			this.#frame = new Int16Array(this.#frameSamples);
+			this.#frameOffset = 0;
+		}
+		#emitFrame(frame) {
+			const buffer = frame.buffer;
+			this.port.postMessage(buffer, [buffer]);
+		}
+	}
+	register(processorName, VoiceInputPcm16Processor);
+}
+const AUDIO_WORKLET_SOURCE = `(${registerVoiceInputPcm16Processor.toString()})(AudioWorkletProcessor, sampleRate, registerProcessor, ${JSON.stringify(VOICE_INPUT_PROCESSOR_NAME)});`;
+//#endregion
+//#region src/browser-audio.ts
+const DEFAULT_FRAME_DURATION_MS = 20;
+const FLUSH_TIMEOUT_MS = 500;
+function getBrowserVoiceInputSupport() {
+	const missingCapabilities = [];
+	const browser = globalThis;
+	if (globalThis.isSecureContext !== true) missingCapabilities.push("secure-context");
+	if (typeof navigator === "undefined" || navigator.mediaDevices === void 0) missingCapabilities.push("media-devices");
+	else if (typeof navigator.mediaDevices.getUserMedia !== "function") missingCapabilities.push("get-user-media");
+	if (browser.AudioContext === void 0 && browser.webkitAudioContext === void 0) missingCapabilities.push("audio-context");
+	else {
+		const AudioContextConstructor = browser.AudioContext ?? browser.webkitAudioContext;
+		if (AudioContextConstructor === void 0 || !("audioWorklet" in AudioContextConstructor.prototype) || typeof globalThis.AudioWorkletNode !== "function") missingCapabilities.push("audio-worklet");
+	}
+	return Object.freeze({
+		isSupported: missingCapabilities.length === 0,
+		missingCapabilities: Object.freeze(missingCapabilities)
+	});
+}
+function createBrowserAudioSource(options = {}) {
+	const frameDurationMs = options.frameDurationMs ?? DEFAULT_FRAME_DURATION_MS;
+	if (!Number.isFinite(frameDurationMs) || frameDurationMs <= 0) throw new VoiceInputError$1({
+		code: "invalid-configuration",
+		message: "frameDurationMs must be a positive finite number."
+	});
+	const workletModuleUrl = options.workletModuleUrl === void 0 ? void 0 : String(options.workletModuleUrl);
+	if (workletModuleUrl !== void 0 && workletModuleUrl.trim().length === 0) throw new VoiceInputError$1({
+		code: "invalid-configuration",
+		message: "workletModuleUrl must be a non-empty URL."
+	});
+	return { async prepare(prepareOptions) {
+		assertBrowserSupport();
+		assertUserActivation();
+		return prepareBrowserAudio(prepareOptions, {
+			constraints: options.constraints,
+			frameDurationMs,
+			workletModuleUrl
+		});
+	} };
+}
+async function prepareBrowserAudio(prepareOptions, options) {
+	const { abortSignal, sampleRate } = prepareOptions;
+	throwIfAborted(abortSignal);
+	let mediaStream;
+	let audioContext;
+	let sourceNode;
+	let workletNode;
+	let silentOutput;
+	let streamController;
+	let closeContextPromise;
+	let flushTimer;
+	let resolveFlush;
+	let started = false;
+	let closed = false;
+	let tracksStopped = false;
+	const stream = new ReadableStream({ start(controller) {
+		streamController = controller;
+	} }, {
+		highWaterMark: sampleRate * 15,
+		size: (chunk) => chunk.length
+	});
+	const cleanup = (error) => {
+		if (closed) return;
+		closed = true;
+		abortSignal.removeEventListener("abort", handleAbort);
+		safely$1(() => sourceNode?.disconnect());
+		safely$1(() => workletNode?.disconnect());
+		safely$1(() => silentOutput?.disconnect());
+		safely$1(() => workletNode?.port.close());
+		stopTracks();
+		if (audioContext !== void 0 && audioContext.state !== "closed") closeContextPromise ??= audioContext.close().catch(() => {});
+		if (streamController !== void 0) {
+			if (error === void 0) safely$1(() => streamController?.close());
+			else safely$1(() => streamController?.error(error));
+		}
+		if (flushTimer !== void 0) {
+			clearTimeout(flushTimer);
+			flushTimer = void 0;
+		}
+		resolveFlush?.();
+		resolveFlush = void 0;
+	};
+	function stopTracks() {
+		if (tracksStopped || mediaStream === void 0) return;
+		tracksStopped = true;
+		for (const track of mediaStream.getTracks()) safely$1(() => track.stop());
+	}
+	const handleAbort = () => cleanup();
+	abortSignal.addEventListener("abort", handleAbort, { once: true });
+	try {
+		mediaStream = await navigator.mediaDevices.getUserMedia({
+			audio: {
+				...options.constraints,
+				channelCount: 1
+			},
+			video: false
+		});
+		if (closed || abortSignal.aborted) stopTracks();
+		throwIfAborted(abortSignal);
+		prepareOptions.onAcquired?.();
+		throwIfAborted(abortSignal);
+		audioContext = createAudioContext(getAudioContextConstructor(), sampleRate);
+		if (audioContext.audioWorklet === void 0) throw unsupportedBrowser(["audio-worklet"]);
+		try {
+			await loadWorklet(audioContext, options.workletModuleUrl);
+		} catch (cause) {
+			throwIfAborted(abortSignal);
+			throw new VoiceInputError$1({
+				code: "audio-error",
+				message: "The microphone AudioWorklet could not be loaded. Check workletModuleUrl and the page's Content Security Policy.",
+				retryable: true,
+				cause
+			});
+		}
+		throwIfAborted(abortSignal);
+		sourceNode = audioContext.createMediaStreamSource(mediaStream);
+		workletNode = new AudioWorkletNode(audioContext, VOICE_INPUT_PROCESSOR_NAME, {
+			numberOfInputs: 1,
+			numberOfOutputs: 1,
+			outputChannelCount: [1],
+			channelCount: 1,
+			channelCountMode: "explicit",
+			channelInterpretation: "speakers",
+			processorOptions: {
+				frameSamples: Math.max(1, Math.round(sampleRate * options.frameDurationMs / 1e3)),
+				targetSampleRate: sampleRate
+			}
+		});
+		silentOutput = audioContext.createGain();
+		silentOutput.gain.value = 0;
+		workletNode.connect(silentOutput);
+		silentOutput.connect(audioContext.destination);
+		workletNode.port.onmessage = (event) => {
+			if (closed || streamController === void 0) return;
+			const data = event.data;
+			if (data instanceof ArrayBuffer || data instanceof Int16Array) {
+				const chunk = data instanceof ArrayBuffer ? new Int16Array(data) : data;
+				if ((streamController.desiredSize ?? 0) < chunk.length) {
+					cleanup(new VoiceInputError$1({
+						code: "audio-error",
+						retryable: true,
+						message: "The application stopped consuming microphone audio."
+					}));
+					return;
+				}
+				streamController.enqueue(chunk);
+			} else if (typeof data === "object" && data !== null && "type" in data && data.type === "flushed") {
+				resolveFlush?.();
+				resolveFlush = void 0;
+			}
+		};
+		workletNode.port.onmessageerror = (event) => {
+			cleanup(new VoiceInputError$1({
+				code: "audio-error",
+				message: "The browser could not read microphone audio frames.",
+				retryable: true,
+				cause: event
+			}));
+		};
+		workletNode.addEventListener("processorerror", (event) => {
+			cleanup(new VoiceInputError$1({
+				code: "audio-error",
+				message: "The microphone audio processor stopped unexpectedly.",
+				retryable: true,
+				cause: event
+			}));
+		}, { once: true });
+		for (const track of mediaStream.getAudioTracks()) track.addEventListener("ended", () => {
+			if (!closed) cleanup(new VoiceInputError$1({
+				code: "audio-error",
+				message: "The microphone stopped unexpectedly.",
+				retryable: true
+			}));
+		}, { once: true });
+		if (audioContext.state !== "running") await audioContext.resume();
+		throwIfAborted(abortSignal);
+		audioContext.addEventListener("statechange", () => {
+			if (started && !closed && audioContext?.state !== "running") cleanup(new VoiceInputError$1({
+				code: "audio-error",
+				retryable: true,
+				message: "Microphone capture was interrupted. Start a new recording to continue."
+			}));
+		});
+		return {
+			stream,
+			start() {
+				if (closed || started) return;
+				started = true;
+				sourceNode?.connect(workletNode);
+			},
+			async stop() {
+				stopTracks();
+				if (!closed && started && workletNode !== void 0) {
+					safely$1(() => sourceNode?.disconnect());
+					started = false;
+					await new Promise((resolve) => {
+						resolveFlush = resolve;
+						flushTimer = setTimeout(resolve, FLUSH_TIMEOUT_MS);
+						workletNode?.port.postMessage({ type: "flush" });
+					});
+				}
+				cleanup();
+				await closeContextPromise;
+			},
+			abort() {
+				cleanup();
+			}
+		};
+	} catch (error) {
+		cleanup();
+		if (VoiceInputError$1.isInstance(error)) throw error;
+		throw normalizeBrowserAudioError(error);
+	}
+}
+function normalizeBrowserAudioError(error) {
+	const name = getErrorName(error);
+	if (name === "NotAllowedError" || name === "SecurityError") return new VoiceInputError$1({
+		code: "permission-denied",
+		message: "Microphone permission was denied.",
+		cause: error
+	});
+	if (name === "NotFoundError" || name === "DevicesNotFoundError") return new VoiceInputError$1({
+		code: "device-not-found",
+		message: "No microphone is available.",
+		cause: error
+	});
+	if (name === "NotReadableError" || name === "TrackStartError" || name === "AbortError") return new VoiceInputError$1({
+		code: "device-busy",
+		message: "The microphone is unavailable or in use by another application.",
+		retryable: true,
+		cause: error
+	});
+	return new VoiceInputError$1({
+		code: "audio-error",
+		message: "The browser audio pipeline failed.",
+		retryable: true,
+		cause: error
+	});
+}
+function assertBrowserSupport() {
+	const support = getBrowserVoiceInputSupport();
+	if (!support.isSupported) throw unsupportedBrowser(support.missingCapabilities);
+}
+function assertUserActivation() {
+	if (navigator.userActivation !== void 0 && navigator.userActivation.isActive === false) throw new VoiceInputError$1({
+		code: "permission-denied",
+		message: "Microphone access must be started directly from a user interaction."
+	});
+}
+function unsupportedBrowser(missingCapabilities) {
+	return new VoiceInputError$1({
+		code: "unsupported-browser",
+		message: `Voice input is unavailable because the browser is missing: ${missingCapabilities.join(", ")}.`
+	});
+}
+function getAudioContextConstructor() {
+	const browser = globalThis;
+	const AudioContextConstructor = browser.AudioContext ?? browser.webkitAudioContext;
+	if (AudioContextConstructor === void 0) throw unsupportedBrowser(["audio-context"]);
+	return AudioContextConstructor;
+}
+function createAudioContext(AudioContextConstructor, sampleRate) {
+	try {
+		return new AudioContextConstructor({
+			latencyHint: "interactive",
+			sampleRate
+		});
+	} catch (error) {
+		const name = getErrorName(error);
+		if (name !== "NotSupportedError" && name !== "TypeError") throw error;
+		return new AudioContextConstructor({ latencyHint: "interactive" });
+	}
+}
+async function loadWorklet(context, moduleUrl) {
+	if (moduleUrl !== void 0) {
+		await context.audioWorklet.addModule(moduleUrl);
+		return;
+	}
+	const url = URL.createObjectURL(new Blob([AUDIO_WORKLET_SOURCE], { type: "text/javascript" }));
+	try {
+		await context.audioWorklet.addModule(url);
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw signal.reason ?? new DOMException("The operation was aborted.", "AbortError");
+}
+function getErrorName(error) {
+	return typeof error === "object" && error !== null && "name" in error ? String(error.name) : void 0;
+}
+function safely$1(operation) {
+	try {
+		operation();
+	} catch {}
+}
+//#endregion
+//#region src/audio-queue.ts
+/** A bounded FIFO shared by startup buffering and a slow provider transport. */
+var AudioQueue = class {
+	maximumSamples;
+	#chunks = [];
+	#samples = 0;
+	#closed = false;
+	#wake;
+	constructor(maximumSamples) {
+		this.maximumSamples = maximumSamples;
+	}
+	push(chunk) {
+		if (this.#closed) return;
+		if (this.#samples + chunk.length > this.maximumSamples) throw new VoiceInputError$1({
+			code: "network-error",
+			retryable: true,
+			message: "Audio could not be sent fast enough. Recording stopped before the audio buffer overflowed."
+		});
+		this.#chunks.push(chunk.slice());
+		this.#samples += chunk.length;
+		this.#wake?.();
+		this.#wake = void 0;
+	}
+	async read() {
+		while (!this.#closed && this.#chunks.length === 0) await new Promise((resolve) => {
+			this.#wake = resolve;
+		});
+		const chunk = this.#chunks.shift();
+		if (chunk) this.#samples -= chunk.length;
+		return chunk;
+	}
+	close(discard = false) {
+		this.#closed = true;
+		if (discard) {
+			this.#chunks = [];
+			this.#samples = 0;
+		}
+		this.#wake?.();
+		this.#wake = void 0;
+	}
+};
+//#endregion
+//#region src/transcript-boundary.ts
+const WORD_CHARACTER = /[\p{L}\p{N}]/u;
+const NO_SPACE_CHARACTER = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
+const WHITESPACE_CHARACTER = /\s/u;
+const OPENING_PUNCTUATION = /[(\u005b{<\u2018\u201c（［｛〈《「『【〔]/u;
+const CLOSING_PUNCTUATION = /[.,!?;:%)\]}\u003e\u2019\u201d\u2026。、，．！？：；）］｝〉》」』】〕]/u;
+function appendTranscriptPart(current, part) {
+	return `${current}${normalizeTranscriptInsertion(current, "", part)}`;
+}
+function normalizeTranscriptInsertion(left, right, text) {
+	const core = text.replace(/^\s+/u, "").replace(/\s+$/u, "");
+	if (core.length === 0) return "";
+	return `${needsBoundarySpace(left.at(-1), core.at(0), "left") ? " " : ""}${core}${needsBoundarySpace(core.at(-1), right.at(0), "right") ? " " : ""}`;
+}
+function needsBoundarySpace(left, right, side) {
+	if (left === void 0 || right === void 0 || WHITESPACE_CHARACTER.test(left) || WHITESPACE_CHARACTER.test(right) || OPENING_PUNCTUATION.test(left) || CLOSING_PUNCTUATION.test(right) || NO_SPACE_CHARACTER.test(left) && NO_SPACE_CHARACTER.test(right)) return false;
+	return WORD_CHARACTER.test(left) || WORD_CHARACTER.test(right) || side === "right" && CLOSING_PUNCTUATION.test(left);
+}
+//#endregion
+//#region src/session.ts
+const DEFAULT_MAX_DURATION_MS = 3e5;
+const DEFAULT_CONNECTION_TIMEOUT_MS = 15e3;
+const DURATION_WARNING_MS = 3e4;
+const FINALIZATION_TIMEOUT_MS = 5e3;
+function createVoiceInputSession(options) {
+	assertProvider(options.provider);
+	assertAudioSource(options.audioSource);
+	if (options.textEngine !== void 0) assertTextEngine(options.textEngine);
+	const configuration = validateSessionConfiguration(options);
+	return new VoiceInputSessionController(options.provider, options.audioSource, options.textEngine, configuration);
+}
+var VoiceInputSessionController = class {
+	#listeners = /* @__PURE__ */ new Set();
+	#provider;
+	#audioSource;
+	#textEngine;
+	#configuration;
+	#snapshot = Object.freeze({
+		status: "idle",
+		transcript: "",
+		interimTranscript: "",
+		finalTranscript: "",
+		error: null
+	});
+	#activeRun;
+	#nextOptions;
+	updateOptions(options) {
+		this.#nextOptions = options;
+	}
+	constructor(provider, audioSource, textEngine, configuration) {
+		this.#provider = provider;
+		this.#audioSource = audioSource;
+		this.#textEngine = textEngine;
+		this.#configuration = configuration;
+	}
+	getSnapshot() {
+		return this.#snapshot;
+	}
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	async start() {
+		if (this.#snapshot.status !== "idle" && this.#snapshot.status !== "error") return;
+		try {
+			if (this.#nextOptions) {
+				const options = this.#nextOptions;
+				assertProvider(options.provider);
+				assertAudioSource(options.audioSource);
+				this.#provider = options.provider;
+				this.#audioSource = options.audioSource;
+				this.#configuration = validateSessionConfiguration(options);
+			}
+		} catch (error) {
+			this.#setPreflightError(this.#normalizeValidationError(error));
+			return;
+		}
+		this.#setSnapshot({
+			transcript: "",
+			interimTranscript: "",
+			finalTranscript: "",
+			error: null
+		});
+		const transcriptionOptions = getTranscriptionOptions(this.#configuration);
+		try {
+			this.#provider.validateOptions(transcriptionOptions);
+		} catch (error) {
+			this.#setPreflightError(this.#normalizeValidationError(error));
+			return;
+		}
+		const run = {
+			abortController: new AbortController(),
+			queue: new AudioQueue(this.#provider.sampleRate * 15),
+			closedSegments: /* @__PURE__ */ new Set(),
+			implicitSegment: 0,
+			cleanup: []
+		};
+		this.#textEngine?.begin();
+		this.#activeRun = run;
+		if (this.#textEngine) run.cleanup.push(this.#textEngine.subscribe((event) => {
+			if (!this.#isActive(run)) return;
+			if (event.type === "text-limit") this.#emit(event);
+			const reason = event.type === "text-limit" ? "max-length" : event.type === "reset" ? "replaced" : "target-unavailable";
+			queueMicrotask(() => {
+				if (this.#isActive(run)) this.stop(reason);
+			});
+		}));
+		if (typeof document !== "undefined") {
+			const onVisibility = () => {
+				if (document.hidden && this.#isActive(run)) this.stop("backgrounded");
+			};
+			document.addEventListener("visibilitychange", onVisibility);
+			run.cleanup.push(() => document.removeEventListener("visibilitychange", onVisibility));
+		}
+		this.#transition("requesting-permission");
+		if (!this.#isActive(run)) return;
+		const startConnectionDeadline = () => {
+			if (this.#isActive(run)) this.#scheduleConnectionDeadline(run);
+		};
+		let audio;
+		try {
+			const preparation = Promise.resolve(this.#audioSource.prepare({
+				sampleRate: this.#provider.sampleRate,
+				abortSignal: run.abortController.signal,
+				onAcquired: startConnectionDeadline
+			}));
+			preparation.then((lateAudio) => {
+				if (!this.#isActive(run)) safely(() => lateAudio.abort(run.abortController.signal.reason ?? "stale-session"));
+			}, () => {});
+			audio = await untilAborted(preparation, run.abortController.signal);
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "audio-error"));
+			return;
+		}
+		if (!this.#isActive(run)) {
+			safely(() => audio.abort("stale-session"));
+			return;
+		}
+		run.audio = audio;
+		startConnectionDeadline();
+		run.captureTask = this.#captureAudio(run, audio.stream);
+		this.#scheduleDurationLimit(run);
+		try {
+			await untilAborted(Promise.resolve(audio.start()), run.abortController.signal);
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "audio-error"));
+			return;
+		}
+		if (!this.#isActive(run)) return;
+		this.#transition("connecting");
+		if (!this.#isActive(run)) return;
+		let providerSession;
+		try {
+			const opening = Promise.resolve(this.#provider.doOpen({
+				...transcriptionOptions,
+				abortSignal: run.abortController.signal
+			}));
+			opening.then((lateSession) => {
+				if (!this.#isActive(run)) safely(() => lateSession.abort(run.abortController.signal.reason ?? "stale-session"));
+			}, () => {});
+			providerSession = await untilAborted(opening, run.abortController.signal);
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "provider-error"));
+			return;
+		}
+		if (!this.#isActive(run)) {
+			safely(() => providerSession.abort("stale-session"));
+			safely(() => audio.abort("stale-session"));
+			return;
+		}
+		run.providerSession = providerSession;
+		run.providerTask = this.#consumeProviderStream(run, providerSession);
+		run.audioTask = this.#pumpAudio(run, providerSession);
+		this.#clearConnectionTimer(run);
+		this.#transition("listening");
+	}
+	async stop(reason = "user") {
+		const run = this.#activeRun;
+		if (run === void 0) return;
+		if (run.stopPromise === void 0) run.stopPromise = this.#performStop(run, reason);
+		await run.stopPromise;
+	}
+	async cancel() {
+		const run = this.#activeRun;
+		if (run === void 0) return;
+		this.#activeRun = void 0;
+		this.#abortRun(run, "cancelled");
+		this.#textEngine?.cancel();
+		this.#setSnapshot({
+			transcript: this.#snapshot.finalTranscript,
+			interimTranscript: "",
+			error: null
+		});
+		this.#transition("idle");
+		this.#emit({ type: "cancel" });
+	}
+	async toggle() {
+		if (this.#activeRun === void 0) await this.start();
+		else await this.stop();
+	}
+	async #performStop(run, reason) {
+		this.#clearRunTimers(run);
+		this.#transition("stopping");
+		if (!this.#isActive(run)) return;
+		const audio = run.audio;
+		const providerSession = run.providerSession;
+		const audioTask = run.audioTask;
+		const providerTask = run.providerTask;
+		if (providerSession === void 0) {
+			if (!await this.#completeTextEngine(run)) return;
+			this.#activeRun = void 0;
+			this.#abortRun(run, reason);
+			this.#transition("idle");
+			this.#emit({
+				type: "stop",
+				reason
+			});
+			return;
+		}
+		try {
+			await withTimeout((async () => {
+				await audio?.stop();
+				await run.captureTask;
+				await audioTask;
+				if (!this.#isActive(run)) return;
+				await providerSession.finish();
+				await providerTask;
+			})(), FINALIZATION_TIMEOUT_MS, this.#provider.provider);
+			if (!this.#isActive(run)) return;
+			if (!await this.#completeTextEngine(run)) return;
+			this.#activeRun = void 0;
+			this.#clearRunTimers(run);
+			for (const cleanup of run.cleanup.splice(0)) cleanup();
+			run.queue.close(true);
+			this.#transition("idle");
+			this.#emit({
+				type: "stop",
+				reason
+			});
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "provider-error"));
+		}
+	}
+	async #consumeProviderStream(run, session) {
+		const reader = session.stream.getReader();
+		try {
+			while (this.#isActive(run)) {
+				const result = await reader.read();
+				if (result.done || !this.#isActive(run)) break;
+				if (this.#handleProviderPart(run, result.value)) return;
+			}
+			if (this.#isActive(run) && this.#snapshot.status !== "stopping" && this.#snapshot.status !== "error") this.#failRun(run, new VoiceInputError({
+				code: "provider-error",
+				message: `${this.#provider.provider} ended the transcription stream unexpectedly.`,
+				provider: this.#provider.provider,
+				retryable: true
+			}));
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "provider-error"));
+		} finally {
+			reader.releaseLock();
+		}
+	}
+	#handleProviderPart(run, part) {
+		if (!this.#isActive(run)) return true;
+		const segmentId = part.type === "interim" || part.type === "final" ? part.segmentId ?? `legacy:${run.implicitSegment}` : "";
+		if (part.type === "interim" || part.type === "final") {
+			if (typeof segmentId !== "string" || segmentId.length === 0) throw new TypeError("Transcription segmentId must be a nonempty string.");
+			if (run.closedSegments.has(segmentId)) return false;
+			if (part.type === "final") {
+				run.closedSegments.add(segmentId);
+				run.implicitSegment++;
+			}
+		}
+		switch (part.type) {
+			case "interim": {
+				this.#textEngine?.applyInterim(part.text, segmentId);
+				const previousTranscript = this.#snapshot.transcript;
+				const transcript = appendTranscriptPart(this.#snapshot.finalTranscript, part.text);
+				this.#setSnapshot({
+					interimTranscript: part.text,
+					transcript
+				});
+				this.#emit({
+					type: "interim",
+					text: part.text,
+					segmentId,
+					transcript,
+					transcriptChanged: transcript !== previousTranscript
+				});
+				return false;
+			}
+			case "final": {
+				this.#textEngine?.applyFinal(part.text, segmentId);
+				const previousTranscript = this.#snapshot.transcript;
+				const previousFinalTranscript = this.#snapshot.finalTranscript;
+				const finalTranscript = appendTranscriptPart(previousFinalTranscript, part.text);
+				this.#setSnapshot({
+					finalTranscript,
+					interimTranscript: "",
+					transcript: finalTranscript
+				});
+				this.#emit({
+					type: "final",
+					text: part.text,
+					segmentId,
+					transcript: finalTranscript,
+					transcriptChanged: finalTranscript !== previousTranscript,
+					finalTranscriptChanged: finalTranscript !== previousFinalTranscript
+				});
+				return false;
+			}
+			case "error":
+				this.#failRun(run, VoiceInputError.isInstance(part.error) ? part.error : this.#normalizeError(part.error, "provider-error"));
+				return true;
+			case "speech-start":
+				this.#emit({ type: "speech-start" });
+				return false;
+			case "speech-end":
+				this.#emit({ type: "speech-end" });
+				return false;
+		}
+	}
+	async #captureAudio(run, stream) {
+		const reader = stream.getReader();
+		const cancelReader = () => {
+			reader.cancel().catch(() => {});
+		};
+		run.abortController.signal.addEventListener("abort", cancelReader, { once: true });
+		try {
+			while (this.#isActive(run)) {
+				const result = await reader.read();
+				if (result.done || !this.#isActive(run)) break;
+				if (!(result.value instanceof Int16Array)) throw new VoiceInputError({
+					code: "audio-error",
+					message: "The audio source emitted a non-PCM16 audio chunk."
+				});
+				run.queue.push(result.value);
+			}
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "audio-error"));
+		} finally {
+			run.abortController.signal.removeEventListener("abort", cancelReader);
+			reader.releaseLock();
+			run.queue.close();
+		}
+	}
+	async #pumpAudio(run, session) {
+		try {
+			while (this.#isActive(run)) {
+				const chunk = await run.queue.read();
+				if (!chunk || !this.#isActive(run)) return;
+				await untilAborted(Promise.resolve(session.sendAudio(chunk)), run.abortController.signal);
+			}
+		} catch (error) {
+			if (this.#isActive(run)) this.#failRun(run, this.#normalizeError(error, "audio-error"));
+		}
+	}
+	#scheduleDurationLimit(run) {
+		const { maxDurationMs } = this.#configuration;
+		const warningDelayMs = maxDurationMs - DURATION_WARNING_MS;
+		const warn = () => {
+			if (this.#isActive(run) && this.#snapshot.status !== "stopping") this.#emit({
+				type: "duration-warning",
+				remainingMs: Math.min(DURATION_WARNING_MS, maxDurationMs),
+				maxDurationMs
+			});
+		};
+		if (warningDelayMs <= 0) warn();
+		else run.warningTimer = setTimeout(warn, warningDelayMs);
+		run.durationTimer = setTimeout(() => {
+			if (this.#isActive(run) && this.#snapshot.status !== "stopping") this.stop("max-duration");
+		}, maxDurationMs);
+	}
+	#scheduleConnectionDeadline(run) {
+		if (run.connectionDeadlineStarted === true) return;
+		run.connectionDeadlineStarted = true;
+		const { connectionTimeoutMs } = this.#configuration;
+		run.connectionTimer = setTimeout(() => {
+			if (!this.#isActive(run)) return;
+			this.#failRun(run, new VoiceInputError({
+				code: "network-error",
+				message: `${this.#provider.provider} did not connect within ${connectionTimeoutMs} ms. Check the network and try again.`,
+				provider: this.#provider.provider,
+				retryable: true
+			}));
+		}, connectionTimeoutMs);
+	}
+	#setPreflightError(error) {
+		this.#setSnapshot({
+			transcript: "",
+			interimTranscript: "",
+			finalTranscript: "",
+			error
+		});
+		this.#transition("error");
+		this.#emit({
+			type: "error",
+			error
+		});
+	}
+	#failRun(run, error) {
+		if (!this.#isActive(run)) return;
+		this.#activeRun = void 0;
+		this.#abortRun(run, error);
+		this.#textEngine?.cancel();
+		this.#setSnapshot({
+			transcript: this.#snapshot.finalTranscript,
+			interimTranscript: "",
+			error
+		});
+		this.#transition("error");
+		this.#emit({
+			type: "error",
+			error
+		});
+	}
+	#abortRun(run, reason) {
+		this.#clearRunTimers(run);
+		for (const cleanup of run.cleanup.splice(0)) cleanup();
+		run.queue.close(true);
+		safely(() => run.audio?.abort(reason));
+		safely(() => run.abortController.abort(reason));
+		safely(() => run.providerSession?.abort(reason));
+	}
+	#normalizeValidationError(error) {
+		if (VoiceInputError.isInstance(error)) return error;
+		return new VoiceInputError({
+			code: "invalid-configuration",
+			message: `The ${this.#provider.provider} provider could not validate the session options.`,
+			provider: this.#provider.provider,
+			cause: error
+		});
+	}
+	#normalizeError(error, code) {
+		if (VoiceInputError.isInstance(error)) return error;
+		return new VoiceInputError({
+			code,
+			message: code === "audio-error" ? "The audio source failed." : `${this.#provider.provider} failed during the transcription session.`,
+			...code === "provider-error" ? { provider: this.#provider.provider } : {},
+			retryable: true,
+			cause: error
+		});
+	}
+	#isActive(run) {
+		return this.#activeRun === run;
+	}
+	#transition(status) {
+		const previousStatus = this.#snapshot.status;
+		if (previousStatus === status) return;
+		this.#setSnapshot({ status });
+		this.#emit({
+			type: "status-change",
+			previousStatus,
+			status
+		});
+	}
+	#setSnapshot(patch) {
+		this.#snapshot = Object.freeze({
+			...this.#snapshot,
+			...patch
+		});
+	}
+	#emit(event) {
+		for (const listener of this.#listeners) try {
+			listener(event);
+		} catch (error) {
+			reportUnhandledError$1(error);
+		}
+	}
+	#clearRunTimers(run) {
+		this.#clearConnectionTimer(run);
+		if (run.warningTimer !== void 0) {
+			clearTimeout(run.warningTimer);
+			delete run.warningTimer;
+		}
+		if (run.durationTimer !== void 0) {
+			clearTimeout(run.durationTimer);
+			delete run.durationTimer;
+		}
+	}
+	#clearConnectionTimer(run) {
+		if (run.connectionTimer !== void 0) {
+			clearTimeout(run.connectionTimer);
+			delete run.connectionTimer;
+		}
+	}
+	async #completeTextEngine(run) {
+		const completion = this.#textEngine?.complete();
+		if (completion === void 0) return this.#isActive(run);
+		if (completion.processing) this.#transition("processing");
+		const errors = await completion.result;
+		if (!this.#isActive(run)) return false;
+		for (const error of errors) {
+			this.#setSnapshot({ error });
+			this.#emit({
+				type: "error",
+				error
+			});
+		}
+		return true;
+	}
+};
+function getTranscriptionOptions(options) {
+	return {
+		...options.language === void 0 ? {} : { language: options.language },
+		...options.vocabulary === void 0 ? {} : { vocabulary: options.vocabulary },
+		...options.endpointing === void 0 ? {} : { endpointing: options.endpointing }
+	};
+}
+function isValidLanguage(language) {
+	if (language.length === 0 || language !== language.trim()) return false;
+	try {
+		return Intl.getCanonicalLocales(language).length === 1;
+	} catch {
+		return false;
+	}
+}
+function validateSessionConfiguration(options) {
+	const issues = [];
+	const language = options.language;
+	const vocabulary = options.vocabulary;
+	const endpointing = options.endpointing;
+	const maxDurationMs = options.maxDurationMs;
+	const connectionTimeoutMs = options.connectionTimeoutMs;
+	let validatedLanguage;
+	let validatedVocabulary;
+	let validatedEndpointing;
+	if (language !== void 0) {
+		if (typeof language !== "string" || !isValidLanguage(language)) issues.push("language: must be a valid BCP 47 language tag without whitespace.");
+		else validatedLanguage = language;
+	}
+	if (vocabulary !== void 0) {
+		if (!Array.isArray(vocabulary)) issues.push("vocabulary: must be an array of strings.");
+		else {
+			const copy = [...vocabulary];
+			for (const [index, term] of copy.entries()) if (typeof term !== "string" || term.length === 0 || term !== term.trim()) issues.push(`vocabulary.${index}: must be a non-empty string with no outer whitespace.`);
+			validatedVocabulary = Object.freeze(copy);
+		}
+	}
+	if (endpointing === false) validatedEndpointing = false;
+	else if (endpointing !== void 0) {
+		if (!isObject(endpointing) || !hasOnlySilenceMs(endpointing)) issues.push("endpointing: must be false or an object containing only silenceMs.");
+		else {
+			const silenceMs = endpointing["silenceMs"];
+			if (!isPositiveInteger(silenceMs)) issues.push("endpointing.silenceMs: must be a positive safe integer.");
+			else validatedEndpointing = { silenceMs };
+		}
+	}
+	if (maxDurationMs !== void 0 && !isPositiveInteger(maxDurationMs)) issues.push("maxDurationMs: must be a positive safe integer.");
+	if (connectionTimeoutMs !== void 0 && !isPositiveInteger(connectionTimeoutMs)) issues.push("connectionTimeoutMs: must be a positive safe integer.");
+	if (issues.length > 0) {
+		const cause = new TypeError(issues.join("; "));
+		throw new VoiceInputError({
+			code: "invalid-configuration",
+			message: cause.message,
+			cause
+		});
+	}
+	return {
+		...getTranscriptionOptions({
+			language: validatedLanguage,
+			vocabulary: validatedVocabulary,
+			endpointing: validatedEndpointing
+		}),
+		maxDurationMs: maxDurationMs ?? DEFAULT_MAX_DURATION_MS,
+		connectionTimeoutMs: connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS
+	};
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlySilenceMs(value) {
+	let count = 0;
+	for (const key in value) if (key !== "silenceMs" || ++count > 1) return false;
+	return count === 1 && Object.hasOwn(value, "silenceMs");
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function assertProvider(provider) {
+	if (typeof provider !== "object" || provider === null || provider.specificationVersion !== "v1" || typeof provider.provider !== "string" || provider.provider.length === 0 || typeof provider.modelId !== "string" || provider.modelId.length === 0 || !Number.isInteger(provider.sampleRate) || provider.sampleRate <= 0 || typeof provider.validateOptions !== "function" || typeof provider.doOpen !== "function") throw new VoiceInputError({
+		code: "invalid-configuration",
+		message: "provider must implement the VoiceInputProviderV1 specification."
+	});
+}
+function assertAudioSource(audioSource) {
+	if (typeof audioSource !== "object" || audioSource === null || typeof audioSource.prepare !== "function") throw new VoiceInputError({
+		code: "invalid-configuration",
+		message: "audioSource must implement the VoiceAudioSource interface."
+	});
+}
+function assertTextEngine(textEngine) {
+	if (typeof textEngine !== "object" || textEngine === null || typeof textEngine.begin !== "function" || typeof textEngine.applyInterim !== "function" || typeof textEngine.applyFinal !== "function" || typeof textEngine.complete !== "function" || typeof textEngine.cancel !== "function") throw new VoiceInputError({
+		code: "invalid-configuration",
+		message: "textEngine must implement the VoiceInputTextEngine interface."
+	});
+}
+function safely(operation) {
+	try {
+		operation();
+	} catch (error) {
+		reportUnhandledError$1(error);
+	}
+}
+function reportUnhandledError$1(error) {
+	const reportError = globalThis.reportError;
+	if (typeof reportError === "function") reportError(error);
+	else queueMicrotask(() => {
+		throw error;
+	});
+}
+async function untilAborted(promise, signal) {
+	if (signal.aborted) throw signal.reason;
+	let onAbort;
+	try {
+		return await Promise.race([promise, new Promise((_resolve, reject) => {
+			onAbort = () => reject(signal.reason);
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
+}
+async function withTimeout(promise, timeoutMs, provider) {
+	let timer;
+	try {
+		await Promise.race([promise, new Promise((_resolve, reject) => {
+			timer = setTimeout(() => {
+				reject(new VoiceInputError({
+					code: "provider-error",
+					message: `${provider} did not finish the transcription session in time.`,
+					provider,
+					retryable: true
+				}));
+			}, timeoutMs);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/text-engine/history.ts
+/** History belongs to one attachment, never to a provider or recording. */
+var TextHistory = class {
+	#past = [];
+	#future = [];
+	#group = 0;
+	clear() {
+		this.#past = [];
+		this.#future = [];
+		this.breakGroup();
+	}
+	breakGroup() {
+		this.#group += 1;
+	}
+	record(before, after, key) {
+		if (before.value === after.value) return;
+		const now = Date.now();
+		const groupedKey = `${this.#group}:${key}`;
+		const last = this.#past.at(-1);
+		if (last?.key === groupedKey && last.after.value === before.value && (key.startsWith("voice:") || key === "composition" || now - last.at < 1e3) && last) {
+			last.after = after;
+			last.at = now;
+			if (last.before.value === last.after.value) this.#past.pop();
+		} else this.#past.push({
+			before,
+			after,
+			key: groupedKey,
+			at: now
+		});
+		this.#future = [];
+		while (this.#past.length > 100 || this.#retainedBytes() > 2097152) this.#past.shift();
+	}
+	undo() {
+		this.breakGroup();
+		const entry = this.#past.pop();
+		if (!entry) return void 0;
+		this.#future.push(entry);
+		return entry.before;
+	}
+	redo() {
+		this.breakGroup();
+		const entry = this.#future.pop();
+		if (!entry) return void 0;
+		this.#past.push(entry);
+		return entry.after;
+	}
+	#retainedBytes() {
+		return this.#past.reduce((bytes, item) => bytes + 2 * (item.before.value.length + item.after.value.length), 0);
+	}
+};
+//#endregion
+//#region src/text-engine/dom-target.ts
+const SUPPORTED_INPUT_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"search",
+	"url",
+	"tel"
+]);
+var TextTargetAdapter = class {
+	#controlled;
+	#callbacks;
+	#target = null;
+	#writeDepth = 0;
+	#observer;
+	#form = null;
+	#composing = false;
+	constructor(controlled, callbacks) {
+		this.#controlled = controlled;
+		this.#callbacks = callbacks;
+	}
+	get target() {
+		return this.#target;
+	}
+	get isControlled() {
+		return this.#controlled !== void 0;
+	}
+	attach(target) {
+		assertSupportedTarget(target);
+		this.detach();
+		this.#target = target;
+		const value = this.#controlled?.getValue() ?? target.value;
+		this.#withGuard(() => {
+			if (target.value !== value) target.value = value;
+		});
+		target.addEventListener("beforeinput", this.#handleBeforeInput);
+		target.addEventListener("keydown", this.#handleKeyDown);
+		target.addEventListener("compositionstart", this.#handleCompositionStart);
+		target.addEventListener("compositionend", this.#handleCompositionEnd);
+		this.#form = target.form;
+		this.#form?.addEventListener("reset", this.#handleReset);
+		this.#observer = new MutationObserver(() => this.#callbacks.onAvailability());
+		this.#observer.observe(target, {
+			attributes: true,
+			attributeFilter: [
+				"disabled",
+				"readonly",
+				"type",
+				"maxlength"
+			]
+		});
+		for (let ancestor = target.parentElement; ancestor; ancestor = ancestor.parentElement) this.#observer.observe(ancestor, {
+			attributes: true,
+			attributeFilter: ["disabled"]
+		});
+		target.addEventListener("input", this.#handleInput);
+		target.addEventListener("select", this.#handleSelectionChange);
+		target.ownerDocument.addEventListener("selectionchange", this.#handleSelectionChange);
+		return value;
+	}
+	detach() {
+		const target = this.#target;
+		if (target === null) return;
+		target.removeEventListener("beforeinput", this.#handleBeforeInput);
+		target.removeEventListener("keydown", this.#handleKeyDown);
+		target.removeEventListener("compositionstart", this.#handleCompositionStart);
+		target.removeEventListener("compositionend", this.#handleCompositionEnd);
+		this.#form?.removeEventListener("reset", this.#handleReset);
+		this.#form = null;
+		this.#observer?.disconnect();
+		this.#observer = void 0;
+		this.#composing = false;
+		target.removeEventListener("input", this.#handleInput);
+		target.removeEventListener("select", this.#handleSelectionChange);
+		target.ownerDocument.removeEventListener("selectionchange", this.#handleSelectionChange);
+		this.#target = null;
+	}
+	isWritable() {
+		return this.#target !== null && isSupportedTarget(this.#target) && !this.#target.matches(":disabled") && !this.#target.readOnly;
+	}
+	readValue() {
+		return this.#target?.value ?? "";
+	}
+	readSelection() {
+		return this.#target === null || !isSupportedTarget(this.#target) ? null : readSelection(this.#target);
+	}
+	readSelectionWhenValueIs(value) {
+		return this.#target !== null && isSupportedTarget(this.#target) && this.#target.value === value ? readSelection(this.#target) : null;
+	}
+	applyMutation(mutation) {
+		const target = this.#target;
+		if (target === null || !this.isWritable() || this.#composing) return;
+		this.#withGuard(() => {
+			setNativeValue(target, mutation.value);
+			restoreSelection(target, mutation.selection);
+			if (!mutation.changed) return;
+			try {
+				if (!this.#controlled?.dispatchInput) this.#controlled?.onValueChange(mutation.value);
+			} catch (error) {
+				this.#callbacks.onUnhandledError(error);
+			}
+			if (this.#controlled === void 0 || this.#controlled.dispatchInput) {
+				const InputEventConstructor = target.ownerDocument.defaultView?.InputEvent ?? InputEvent;
+				target.dispatchEvent(new InputEventConstructor("input", {
+					bubbles: true,
+					inputType: "insertText"
+				}));
+			}
+		});
+	}
+	synchronize(value, selection) {
+		const target = this.#target;
+		if (target === null || !isSupportedTarget(target) || this.#composing) return;
+		this.#withGuard(() => {
+			if (target.value !== value) target.value = value;
+			restoreSelection(target, selection);
+		});
+	}
+	#handleBeforeInput = (event) => {
+		if (this.#writeDepth !== 0) return;
+		const inputType = event.inputType ?? "insertText";
+		if (inputType === "historyUndo" || inputType === "historyRedo") {
+			if (event.cancelable && !this.#composing) {
+				event.preventDefault();
+				this.#callbacks.onHistory(inputType === "historyRedo");
+			}
+			return;
+		}
+		this.#callbacks.onBeforeInput(inputType);
+	};
+	#handleKeyDown = (rawEvent) => {
+		const event = rawEvent;
+		if (event.defaultPrevented || event.isComposing || this.#composing || !this.isWritable()) return;
+		const modifier = event.ctrlKey || event.metaKey;
+		const key = event.key.toLowerCase();
+		if (modifier && !event.altKey && (key === "z" || event.ctrlKey && key === "y")) {
+			event.preventDefault();
+			this.#callbacks.onHistory(key === "y" || event.shiftKey);
+		}
+	};
+	#handleCompositionStart = () => {
+		this.#composing = true;
+		this.#callbacks.onComposition(true);
+	};
+	#handleCompositionEnd = () => {
+		this.#composing = false;
+		const target = this.#target;
+		queueMicrotask(() => {
+			if (target === this.#target) this.#callbacks.onComposition(false);
+		});
+	};
+	#handleReset = (event) => {
+		const target = this.#target;
+		queueMicrotask(() => {
+			if (!event.defaultPrevented && target === this.#target) this.#callbacks.onReset();
+		});
+	};
+	#handleInput = () => {
+		if (this.#writeDepth === 0) this.#callbacks.onInput();
+	};
+	#handleSelectionChange = () => {
+		if (this.#writeDepth === 0) this.#callbacks.onSelectionChange();
+	};
+	#withGuard(operation) {
+		this.#writeDepth += 1;
+		try {
+			operation();
+		} finally {
+			this.#writeDepth -= 1;
+		}
+	}
+};
+function assertSupportedTarget(target) {
+	if (!isSupportedTarget(target)) throw invalidTarget();
+}
+function isSupportedTarget(target) {
+	if (typeof target !== "object" || target === null) return false;
+	if (target.tagName === "TEXTAREA") return true;
+	return target.tagName === "INPUT" && SUPPORTED_INPUT_TYPES.has(target.type);
+}
+function readSelection(target) {
+	const start = target.selectionStart;
+	const end = target.selectionEnd;
+	if (start === null || end === null) throw invalidTarget("The text target does not expose a selection.");
+	const direction = target.selectionDirection;
+	return {
+		start,
+		end,
+		direction: direction === "forward" || direction === "backward" ? direction : "none"
+	};
+}
+function restoreSelection(target, selection) {
+	if (selection === null) return;
+	const start = Math.min(selection.start, target.value.length);
+	const end = Math.min(selection.end, target.value.length);
+	target.setSelectionRange(start, end, selection.direction);
+}
+function invalidTarget(message = "Text targets must be <textarea> elements or <input> elements of type text, search, url, or tel.") {
+	return new VoiceInputError$1({
+		code: "invalid-configuration",
+		message
+	});
+}
+function setNativeValue(target, value) {
+	const view = target.ownerDocument.defaultView;
+	const prototype = target.tagName === "TEXTAREA" ? view?.HTMLTextAreaElement.prototype : view?.HTMLInputElement.prototype;
+	const descriptor = prototype && Object.getOwnPropertyDescriptor(prototype, "value");
+	if (descriptor?.set) descriptor.set.call(target, value);
+	else target.value = value;
+}
+//#endregion
+//#region src/text-engine/ownership-model.ts
+var TextOwnershipModel = class {
+	#interimBehavior;
+	#maxLength = -1;
+	#source = "final";
+	#limit;
+	#value = "";
+	#selection = null;
+	#spans = [];
+	#provisional;
+	#currentFinalSpan;
+	#interimTranscript = "";
+	#runId = 0;
+	#runActive = false;
+	#nextSpanId = 1;
+	#nextGeneration = 1;
+	constructor(interimBehavior) {
+		this.#interimBehavior = interimBehavior;
+	}
+	configureMutation(maxLength, source) {
+		this.#maxLength = maxLength;
+		this.#source = source;
+		this.#limit = void 0;
+	}
+	takeLimit() {
+		const limit = this.#limit;
+		this.#limit = void 0;
+		return limit;
+	}
+	#limitReplacement(start, end, text) {
+		if (this.#maxLength < 0) return text;
+		const available = Math.max(0, this.#maxLength - (this.#value.length - (end - start)));
+		if (text.length < available || text.length === 0) return text;
+		let insertedText = "";
+		for (const { segment } of new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(text)) {
+			if (insertedText.length + segment.length > available) break;
+			insertedText += segment;
+		}
+		this.#limit = {
+			type: "text-limit",
+			maxLength: this.#maxLength,
+			text,
+			insertedText,
+			source: this.#source
+		};
+		return insertedText;
+	}
+	setInterimBehavior(behavior) {
+		this.#interimBehavior = behavior;
+	}
+	get value() {
+		return this.#value;
+	}
+	get selection() {
+		return this.#selection === null ? null : {
+			start: this.#selection.start,
+			end: this.#selection.end,
+			direction: this.#selection.direction
+		};
+	}
+	get hasSelection() {
+		return this.#selection !== null;
+	}
+	get isRunActive() {
+		return this.#runActive;
+	}
+	getSnapshot() {
+		const selection = this.#selection === null ? null : Object.freeze({
+			start: this.#selection.start,
+			end: this.#selection.end,
+			direction: this.#selection.direction
+		});
+		const spans = this.#spans.map((span) => Object.freeze({
+			id: span.id,
+			start: span.start,
+			end: span.end,
+			text: this.#value.slice(span.start, span.end),
+			state: span.state
+		}));
+		return Object.freeze({
+			value: this.#value,
+			selection,
+			interimTranscript: this.#interimTranscript,
+			spans: Object.freeze(spans)
+		});
+	}
+	replaceTarget(value) {
+		this.freezeForTargetReplacement();
+		this.#value = value;
+		this.#selection = null;
+		this.#spans = [];
+		this.#provisional = void 0;
+		this.#currentFinalSpan = void 0;
+	}
+	captureSelection(selection) {
+		this.#freezeProvisional();
+		this.#currentFinalSpan = void 0;
+		this.#selection = toMutableSelection(selection);
+	}
+	begin() {
+		this.#runId += 1;
+		this.#runActive = true;
+		this.#interimTranscript = "";
+		this.#provisional = void 0;
+		this.#currentFinalSpan = void 0;
+	}
+	applyInterim(text, canInsert) {
+		if (!this.#runActive || !canInsert) return null;
+		this.#interimTranscript = text;
+		if (this.#interimBehavior === "expose") return null;
+		if (this.#provisional !== void 0) {
+			if (this.proveSpan(this.#provisional)) return this.#replaceOwnedSpan(this.#provisional, text, "provisional").mutation;
+			this.#abandonProvisional();
+		}
+		if (text.length === 0 || !canInsert) return null;
+		const inserted = this.#insertAtAnchor(text, "provisional");
+		this.#provisional = inserted?.span;
+		return inserted?.mutation ?? null;
+	}
+	applyFinal(text, canInsert) {
+		if (!this.#runActive || !canInsert) return null;
+		this.#interimTranscript = "";
+		let finalized;
+		let mutation = null;
+		if (this.#provisional !== void 0) {
+			if (this.proveSpan(this.#provisional)) {
+				const replaced = this.#replaceOwnedSpan(this.#provisional, text, "finalized");
+				finalized = replaced?.span;
+				mutation = replaced?.mutation ?? null;
+			} else this.#abandonProvisional();
+			this.#provisional = void 0;
+		}
+		if (finalized === void 0 && text.length > 0 && canInsert) {
+			const inserted = this.#insertAtAnchor(text, "finalized");
+			finalized = inserted?.span;
+			mutation = inserted?.mutation ?? mutation;
+		}
+		if (finalized !== void 0) this.#mergeFinalizedSpan(finalized);
+		return mutation;
+	}
+	complete(canInsert) {
+		let mutation = null;
+		if (this.#runActive && this.#provisional !== void 0) {
+			if (this.proveSpan(this.#provisional)) {
+				this.#provisional.state = "finalized";
+				delete this.#provisional.replacedText;
+				this.#mergeFinalizedSpan(this.#provisional);
+			} else this.#abandonProvisional();
+			this.#provisional = void 0;
+		} else if (this.#runActive && this.#interimBehavior === "expose" && this.#interimTranscript.length > 0 && canInsert) {
+			const inserted = this.#insertAtAnchor(this.#interimTranscript, "finalized");
+			if (inserted !== void 0) {
+				this.#mergeFinalizedSpan(inserted.span);
+				mutation = inserted.mutation;
+			}
+		}
+		this.#interimTranscript = "";
+		const runId = this.#runId;
+		const spans = this.#spans.filter((span) => span.runId === runId && span.state === "finalized");
+		this.#runActive = false;
+		this.#currentFinalSpan = void 0;
+		return {
+			mutation,
+			runId,
+			spans
+		};
+	}
+	cancel() {
+		let mutation = null;
+		if (this.#provisional !== void 0) {
+			if (this.proveSpan(this.#provisional)) mutation = this.#removeOwnedSpan(this.#provisional);
+			else this.#abandonProvisional();
+		}
+		this.#provisional = void 0;
+		this.#interimTranscript = "";
+		this.#currentFinalSpan = void 0;
+		this.#runActive = false;
+		return mutation;
+	}
+	freezeForTargetReplacement() {
+		this.#freezeProvisional();
+		for (const span of this.#spans) if (span.state === "finalized") {
+			span.state = "frozen";
+			span.generation = this.#nextGeneration++;
+		}
+		this.#currentFinalSpan = void 0;
+	}
+	destroy() {
+		this.freezeForTargetReplacement();
+		this.#selection = null;
+		this.#interimTranscript = "";
+		this.#runActive = false;
+	}
+	beforeInput() {
+		this.#freezeProvisional();
+		this.#currentFinalSpan = void 0;
+	}
+	reconcileExternalValue(value, committedSelection) {
+		if (value === this.#value) {
+			if (committedSelection !== null && !sameSelection$1(this.#selection, committedSelection)) {
+				this.#freezeProvisional();
+				this.#currentFinalSpan = void 0;
+				this.#selection = toMutableSelection(committedSelection);
+			}
+			return;
+		}
+		const edit = findSingleEdit(this.#value, value);
+		const delta = edit.newEnd - edit.oldEnd;
+		const adjustedSelection = adjustSelectionForEdit(this.#selection, edit, delta);
+		const provisional = this.#provisional;
+		const provisionalOverlaps = provisional !== void 0 && spanOverlapsEdit(provisional, edit);
+		this.#adjustSpansForEdit(edit.oldStart, edit.oldEnd, delta);
+		this.#value = value;
+		this.#selection = adjustedSelection;
+		this.#currentFinalSpan = void 0;
+		if (provisionalOverlaps) {
+			this.#interimTranscript = "";
+			this.#provisional = void 0;
+		} else if (this.#provisional !== void 0 && !this.proveSpan(this.#provisional)) this.#abandonProvisional();
+		if (committedSelection !== null && !sameSelection$1(this.#selection, committedSelection)) {
+			this.#freezeProvisional();
+			this.#selection = toMutableSelection(committedSelection);
+		}
+	}
+	selectionChanged(selection) {
+		if (sameSelection$1(this.#selection, selection)) return;
+		this.#freezeProvisional();
+		this.#currentFinalSpan = void 0;
+		this.#selection = toMutableSelection(selection);
+	}
+	proveSpan(span) {
+		return this.#spans.includes(span) && span.start >= 0 && span.end >= span.start && span.end <= this.#value.length && this.#value.slice(span.start, span.end) === span.expectedText;
+	}
+	getSpanText(span) {
+		return this.#value.slice(span.start, span.end);
+	}
+	canApplyTransform(span, generation, originalText) {
+		return span.generation === generation && span.state === "finalized" && this.proveSpan(span) && this.#value.slice(span.start, span.end) === originalText;
+	}
+	applyTransform(span, text) {
+		const replacement = this.#limitReplacement(span.start, span.end, normalizeInsertion(this.#value.slice(0, span.start), this.#value.slice(span.end), text));
+		const changed = this.#replaceText(span.start, span.end, replacement, span.id);
+		if (replacement.length === 0) {
+			this.#spans = this.#spans.filter((candidate) => candidate !== span);
+			this.#selection = {
+				start: span.start,
+				end: span.start,
+				direction: "none",
+				replacePending: false
+			};
+		} else {
+			span.end = span.start + replacement.length;
+			span.state = "transformed";
+			span.generation = this.#nextGeneration++;
+			span.expectedText = replacement;
+			this.#selection = {
+				start: span.end,
+				end: span.end,
+				direction: "none",
+				replacePending: false
+			};
+		}
+		return this.#createMutation(changed);
+	}
+	freezeFailedTransform(span) {
+		if (span.state === "finalized" && this.proveSpan(span)) {
+			span.state = "frozen";
+			span.generation = this.#nextGeneration++;
+		}
+	}
+	#insertAtAnchor(text, state) {
+		const selection = this.#selection;
+		if (selection === null) return;
+		const start = selection.start;
+		const end = selection.replacePending ? selection.end : selection.start;
+		const replacement = this.#limitReplacement(start, end, normalizeInsertion(this.#value.slice(0, start), this.#value.slice(end), text));
+		if (replacement.length === 0) return;
+		selection.replacePending = false;
+		const replacedText = this.#value.slice(start, end);
+		const changed = this.#replaceText(start, end, replacement);
+		const span = {
+			id: this.#nextSpanId++,
+			start,
+			end: start + replacement.length,
+			state,
+			runId: this.#runId,
+			generation: this.#nextGeneration++,
+			expectedText: replacement,
+			...end > start ? { replacedText } : {}
+		};
+		this.#spans.push(span);
+		this.#selection = {
+			start: span.end,
+			end: span.end,
+			direction: "none",
+			replacePending: false
+		};
+		return {
+			mutation: this.#createMutation(changed),
+			span
+		};
+	}
+	#replaceOwnedSpan(span, text, state) {
+		const replacement = this.#limitReplacement(span.start, span.end, normalizeInsertion(this.#value.slice(0, span.start), this.#value.slice(span.end), text));
+		if (replacement.length === 0) return { mutation: this.#removeOwnedSpan(span) };
+		const changed = this.#replaceText(span.start, span.end, replacement, span.id);
+		span.end = span.start + replacement.length;
+		span.state = state;
+		span.generation = this.#nextGeneration++;
+		span.expectedText = replacement;
+		if (state === "finalized") delete span.replacedText;
+		this.#selection = {
+			start: span.end,
+			end: span.end,
+			direction: "none",
+			replacePending: false
+		};
+		return {
+			mutation: this.#createMutation(changed),
+			span
+		};
+	}
+	#removeOwnedSpan(span) {
+		const start = span.start;
+		const replacement = span.replacedText ?? "";
+		const changed = this.#replaceText(start, span.end, replacement, span.id);
+		this.#spans = this.#spans.filter((candidate) => candidate !== span);
+		this.#selection = {
+			start,
+			end: start + replacement.length,
+			direction: "none",
+			replacePending: replacement.length > 0
+		};
+		return this.#createMutation(changed);
+	}
+	#replaceText(start, end, replacement, excludedSpanId) {
+		const previousValue = this.#value;
+		const nextValue = `${previousValue.slice(0, start)}${replacement}${previousValue.slice(end)}`;
+		if (nextValue === previousValue) return false;
+		const delta = replacement.length - (end - start);
+		this.#adjustSpansForEdit(start, end, delta, excludedSpanId);
+		this.#value = nextValue;
+		return true;
+	}
+	#mergeFinalizedSpan(span) {
+		const previous = this.#currentFinalSpan;
+		if (previous !== void 0 && previous !== span && previous.state === "finalized" && previous.runId === span.runId && previous.end === span.start && this.proveSpan(previous) && this.proveSpan(span)) {
+			previous.end = span.end;
+			previous.generation = this.#nextGeneration++;
+			previous.expectedText = this.#value.slice(previous.start, previous.end);
+			this.#spans = this.#spans.filter((candidate) => candidate !== span);
+			this.#currentFinalSpan = previous;
+			return;
+		}
+		this.#currentFinalSpan = span;
+	}
+	#freezeProvisional() {
+		if (this.#provisional !== void 0) {
+			this.#provisional.state = "frozen";
+			this.#provisional.generation = this.#nextGeneration++;
+			this.#provisional = void 0;
+		}
+		this.#interimTranscript = "";
+		this.#currentFinalSpan = void 0;
+	}
+	#abandonProvisional() {
+		const provisional = this.#provisional;
+		if (provisional !== void 0) {
+			this.#spans = this.#spans.filter((span) => span !== provisional);
+			this.#provisional = void 0;
+		}
+		this.#interimTranscript = "";
+		this.#currentFinalSpan = void 0;
+	}
+	#adjustSpansForEdit(start, end, delta, excludedSpanId) {
+		const retained = [];
+		for (const span of this.#spans) if (span.id === excludedSpanId) retained.push(span);
+		else if (span.end <= start) retained.push(span);
+		else if (span.start >= end) {
+			span.start += delta;
+			span.end += delta;
+			retained.push(span);
+		} else {
+			if (span === this.#provisional) this.#provisional = void 0;
+			if (span === this.#currentFinalSpan) this.#currentFinalSpan = void 0;
+		}
+		this.#spans = retained;
+	}
+	#createMutation(changed) {
+		return {
+			changed,
+			selection: this.selection,
+			value: this.#value
+		};
+	}
+};
+function normalizeInsertion(left, right, text) {
+	return normalizeTranscriptInsertion(left, right, text);
+}
+function findSingleEdit(previous, next) {
+	let prefix = 0;
+	const maximumPrefix = Math.min(previous.length, next.length);
+	while (prefix < maximumPrefix && previous[prefix] === next[prefix]) prefix += 1;
+	let suffix = 0;
+	const maximumSuffix = Math.min(previous.length - prefix, next.length - prefix);
+	while (suffix < maximumSuffix && previous[previous.length - suffix - 1] === next[next.length - suffix - 1]) suffix += 1;
+	return {
+		oldStart: prefix,
+		oldEnd: previous.length - suffix,
+		newEnd: next.length - suffix
+	};
+}
+function adjustSelectionForEdit(selection, edit, delta) {
+	if (selection === null) return null;
+	if (selection.end <= edit.oldStart) return selection;
+	if (selection.start >= edit.oldEnd) return {
+		...selection,
+		start: selection.start + delta,
+		end: selection.end + delta
+	};
+	return {
+		start: edit.newEnd,
+		end: edit.newEnd,
+		direction: "none",
+		replacePending: false
+	};
+}
+function spanOverlapsEdit(span, edit) {
+	return !(span.end <= edit.oldStart || span.start >= edit.oldEnd);
+}
+function toMutableSelection(selection) {
+	return {
+		...selection,
+		replacePending: selection.start !== selection.end
+	};
+}
+function sameSelection$1(current, next) {
+	return current !== null && current.start === next.start && current.end === next.end && (current.start === current.end || current.direction === next.direction);
+}
+//#endregion
+//#region src/text-engine/transform.ts
+var TransformTimeoutError = class extends Error {
+	constructor() {
+		super("Transcript transform timed out.");
+		this.name = "TransformTimeoutError";
+	}
+};
+async function runTransformWithTimeout(transform, timeoutMs) {
+	let timer;
+	try {
+		const result = transform();
+		return await Promise.race([Promise.resolve(result), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(new TransformTimeoutError()), timeoutMs);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+//#endregion
+//#region src/text-engine/controller.ts
+var VoiceInputTextEngineController = class {
+	#controlled;
+	#transformTranscript;
+	#transformTimeoutMs;
+	#model;
+	#target;
+	#nextOptions;
+	updateOptions(options) {
+		if (options.interimBehavior !== void 0 && options.interimBehavior !== "inline" && options.interimBehavior !== "expose") throw invalidConfiguration$1("interimBehavior must be inline or expose.");
+		if (options.transformTimeoutMs !== void 0 && (!Number.isInteger(options.transformTimeoutMs) || options.transformTimeoutMs <= 0)) throw invalidConfiguration$1("transformTimeoutMs must be a positive finite integer.");
+		if (options.transformTranscript !== void 0 && typeof options.transformTranscript !== "function") throw invalidConfiguration$1("transformTranscript must be a function.");
+		this.#nextOptions = options;
+	}
+	#completionGeneration = 0;
+	#history = new TextHistory();
+	#listeners = /* @__PURE__ */ new Set();
+	#suppressed = /* @__PURE__ */ new Set();
+	#closedSegments = /* @__PURE__ */ new Set();
+	#implicitSegment = 0;
+	#currentSegment;
+	#limitedSegment;
+	#composing = false;
+	#beforeInput;
+	#inputType = "insertText";
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	isWritable() {
+		return this.#target.isWritable();
+	}
+	undo() {
+		this.#restoreHistory(false);
+	}
+	redo() {
+		this.#restoreHistory(true);
+	}
+	#restoreHistory(redo) {
+		if (!this.isWritable() || this.#composing) return;
+		const state = redo ? this.#history.redo() : this.#history.undo();
+		if (!state) return;
+		this.#takeOwnership();
+		this.#invalidateCompletion();
+		this.#model.replaceTarget(state.value);
+		if (state.selection) this.#model.captureSelection(state.selection);
+		this.#target.applyMutation({
+			...state,
+			changed: true
+		});
+	}
+	#takeOwnership() {
+		if (this.#currentSegment !== void 0) this.#suppressed.add(this.#currentSegment);
+		this.#model.beforeInput();
+		this.#history.breakGroup();
+	}
+	#emit(event) {
+		for (const listener of this.#listeners) try {
+			listener(event);
+		} catch (error) {
+			reportUnhandledError(error);
+		}
+	}
+	#state() {
+		return {
+			value: this.#model.value,
+			selection: this.#target.readSelection() ?? this.#model.selection
+		};
+	}
+	#availabilityChanged() {
+		if (!this.isWritable()) {
+			this.#takeOwnership();
+			this.#invalidateCompletion();
+			this.#emit({ type: "target-unavailable" });
+		}
+	}
+	#reset() {
+		this.#beforeInput = void 0;
+		this.#takeOwnership();
+		this.#invalidateCompletion();
+		this.#model.replaceTarget(this.#target.readValue());
+		this.#model.cancel();
+		this.#history.clear();
+		this.#emit({ type: "reset" });
+	}
+	constructor(options) {
+		this.#controlled = options.controlled;
+		this.#transformTranscript = options.transformTranscript;
+		this.#transformTimeoutMs = options.transformTimeoutMs;
+		this.#model = new TextOwnershipModel(options.interimBehavior);
+		this.#target = new TextTargetAdapter(options.controlled, {
+			onBeforeInput: (inputType) => {
+				this.#beforeInput = this.#state();
+				this.#inputType = inputType;
+				if (!this.#composing) {
+					if (this.#currentSegment !== void 0) this.#suppressed.add(this.#currentSegment);
+					this.#model.beforeInput();
+				}
+			},
+			onHistory: (redo) => this.#restoreHistory(redo),
+			onComposition: (active) => {
+				if (active) this.#takeOwnership();
+				this.#composing = active;
+				if (!active) {
+					this.#handleInput();
+					this.#history.breakGroup();
+				}
+			},
+			onReset: () => this.#reset(),
+			onAvailability: () => this.#availabilityChanged(),
+			onInput: () => this.#handleInput(),
+			onSelectionChange: () => this.#handleSelectionChange(),
+			onUnhandledError: reportUnhandledError
+		});
+	}
+	getSnapshot() {
+		return this.#model.getSnapshot();
+	}
+	setTarget(target) {
+		if (target === this.#target.target) return;
+		const wasAttached = this.#target.target !== null;
+		this.#takeOwnership();
+		this.#history.clear();
+		this.#beforeInput = void 0;
+		this.#composing = false;
+		this.#invalidateCompletion();
+		this.#model.cancel();
+		if (wasAttached) this.#emit({ type: "reset" });
+		if (target === null) {
+			this.#target.detach();
+			this.#model.replaceTarget("");
+			return;
+		}
+		const value = this.#target.attach(target);
+		this.#model.replaceTarget(value);
+		this.#target.synchronize(this.#model.value, this.#model.selection);
+	}
+	captureSelection() {
+		if (!this.#target.isWritable()) return null;
+		this.#reconcileUncontrolledDomValue();
+		const selection = this.#target.readSelection();
+		if (selection === null) return null;
+		if (!sameSelection(this.#model.selection, selection)) this.#takeOwnership();
+		this.#model.captureSelection(selection);
+		return Object.freeze({ ...selection });
+	}
+	reconcileControlledValue(value) {
+		if (this.#controlled === void 0) throw invalidConfiguration$1("reconcileControlledValue is only available for controlled text engines.");
+		if (typeof value !== "string") throw invalidConfiguration$1("A controlled value must be a string.");
+		if (this.#composing) return;
+		if (value !== this.#model.value) this.#history.clear();
+		const committedSelection = this.#target.readSelectionWhenValueIs(value);
+		this.#model.reconcileExternalValue(value, committedSelection);
+		if (this.#currentSegment !== void 0 && !this.#model.getSnapshot().spans.some((span) => span.state === "provisional")) this.#suppressed.add(this.#currentSegment);
+		this.#target.synchronize(this.#model.value, this.#model.selection);
+	}
+	begin() {
+		if (this.#nextOptions) {
+			this.#model.setInterimBehavior(this.#nextOptions.interimBehavior ?? "inline");
+			this.#transformTranscript = this.#nextOptions.transformTranscript;
+			this.#transformTimeoutMs = this.#nextOptions.transformTimeoutMs ?? 1e4;
+		}
+		this.#invalidateCompletion();
+		this.#model.begin();
+		this.#suppressed.clear();
+		this.#closedSegments.clear();
+		this.#implicitSegment = 0;
+		this.#currentSegment = void 0;
+		this.#limitedSegment = void 0;
+		this.#history.breakGroup();
+		if (!this.#model.hasSelection) this.captureSelection();
+	}
+	applyInterim(text, segmentId) {
+		this.#applyTranscript(text, segmentId, false);
+	}
+	applyFinal(text, segmentId) {
+		this.#applyTranscript(text, segmentId, true);
+	}
+	#applyTranscript(text, segmentId, final) {
+		if (typeof text !== "string" || !this.#model.isRunActive) return;
+		const id = segmentId ?? `implicit:${this.#implicitSegment}`;
+		if (this.#closedSegments.has(id)) return;
+		this.#reconcileUncontrolledDomValue();
+		if (this.#currentSegment !== void 0 && this.#currentSegment !== id) this.#takeOwnership();
+		if (this.#currentSegment !== id) this.#history.breakGroup();
+		this.#currentSegment = id;
+		if (this.#composing || !this.isWritable() || this.#limitedSegment !== void 0 && this.#limitedSegment !== id) {
+			this.#suppressed.add(id);
+			this.#model.beforeInput();
+		}
+		if (!this.#suppressed.has(id)) {
+			const before = this.#state();
+			this.#model.configureMutation(this.#target.target?.maxLength ?? -1, final ? "final" : "interim");
+			const mutation = final ? this.#model.applyFinal(text, true) : this.#model.applyInterim(text, true);
+			this.#applyMutation(mutation, before, `voice:${id}`);
+			const limit = this.#model.takeLimit();
+			if (limit) {
+				const firstLimit = this.#limitedSegment === void 0;
+				this.#limitedSegment = id;
+				if (firstLimit) this.#emit(limit);
+			}
+		}
+		if (final) {
+			this.#closedSegments.add(id);
+			this.#currentSegment = void 0;
+			this.#implicitSegment += 1;
+			this.#history.breakGroup();
+		}
+	}
+	complete() {
+		if (!this.#model.isRunActive) return {
+			processing: false,
+			result: Promise.resolve([])
+		};
+		const before = this.#state();
+		this.#model.configureMutation(this.#target.target?.maxLength ?? -1, "final");
+		const completion = this.#model.complete(this.#target.isWritable() && !this.#composing);
+		this.#applyMutation(completion.mutation, before, `voice:${this.#currentSegment}`);
+		const limit = this.#model.takeLimit();
+		if (limit) this.#emit(limit);
+		this.#history.breakGroup();
+		const processing = this.#transformTranscript !== void 0 && completion.spans.length > 0;
+		const completionGeneration = ++this.#completionGeneration;
+		if (!processing || this.#transformTranscript === void 0) return {
+			processing: false,
+			result: Promise.resolve([])
+		};
+		return {
+			processing: true,
+			result: Promise.all(completion.spans.map((span) => this.#transformSpan(span, completionGeneration))).then((errors) => errors.filter(isVoiceInputError))
+		};
+	}
+	cancel() {
+		this.#invalidateCompletion();
+		const before = this.#state();
+		if (!this.isWritable() || this.#composing) this.#takeOwnership();
+		this.#applyMutation(this.#model.cancel(), before, `voice:${this.#currentSegment}`);
+		this.#currentSegment = void 0;
+		this.#history.breakGroup();
+	}
+	destroy() {
+		this.#invalidateCompletion();
+		this.#model.destroy();
+		this.#target.detach();
+		this.#history.clear();
+		this.#listeners.clear();
+	}
+	async #transformSpan(span, completionGeneration) {
+		const transform = this.#transformTranscript;
+		if (transform === void 0 || !this.#model.proveSpan(span)) return null;
+		const generation = span.generation;
+		const originalText = this.#model.getSpanText(span);
+		const transcript = originalText.trim();
+		try {
+			const transformed = await runTransformWithTimeout(() => transform(transcript), this.#transformTimeoutMs);
+			if (typeof transformed !== "string") throw new TypeError("transformTranscript must resolve to a string.");
+			if (!this.isWritable() || this.#composing || completionGeneration !== this.#completionGeneration || !this.#model.canApplyTransform(span, generation, originalText)) return null;
+			const before = this.#state();
+			this.#model.configureMutation(this.#target.target?.maxLength ?? -1, "transform");
+			this.#history.breakGroup();
+			this.#applyMutation(this.#model.applyTransform(span, transformed), before, `transform:${span.id}`);
+			const limit = this.#model.takeLimit();
+			if (limit) this.#emit(limit);
+			return null;
+		} catch (cause) {
+			if (completionGeneration !== this.#completionGeneration) return null;
+			this.#model.freezeFailedTransform(span);
+			return new VoiceInputError$1({
+				code: "transform-error",
+				message: cause instanceof TransformTimeoutError ? `Transcript transform timed out after ${this.#transformTimeoutMs}ms.` : "Transcript transform failed.",
+				cause
+			});
+		}
+	}
+	#handleInput() {
+		const selection = this.#target.readSelection();
+		const before = this.#beforeInput ?? {
+			value: this.#model.value,
+			selection: this.#model.selection
+		};
+		this.#beforeInput = void 0;
+		this.#model.reconcileExternalValue(this.#target.readValue(), selection);
+		const key = this.#composing ? "composition" : this.#inputType;
+		if (![
+			"insertText",
+			"deleteContentBackward",
+			"deleteContentForward",
+			"composition"
+		].includes(key)) this.#history.breakGroup();
+		this.#history.record(before, this.#state(), key);
+	}
+	#handleSelectionChange() {
+		const selection = this.#target.readSelection();
+		if (selection !== null && !this.#composing) {
+			if (!sameSelection(selection, this.#model.selection)) this.#takeOwnership();
+			this.#model.selectionChanged(selection);
+		}
+	}
+	#reconcileUncontrolledDomValue() {
+		if (this.#target.isControlled || this.#target.target === null) return;
+		const value = this.#target.readValue();
+		if (value !== this.#model.value) {
+			this.#takeOwnership();
+			this.#history.clear();
+			this.#model.reconcileExternalValue(value, this.#target.readSelection());
+		}
+	}
+	#applyMutation(mutation, before, key = "voice") {
+		if (mutation !== null) {
+			if (before && mutation.changed) this.#history.record(before, mutation, key);
+			this.#target.applyMutation(mutation);
+		}
+	}
+	#invalidateCompletion() {
+		this.#completionGeneration += 1;
+	}
+};
+function invalidConfiguration$1(message) {
+	return new VoiceInputError$1({
+		code: "invalid-configuration",
+		message
+	});
+}
+function isVoiceInputError(error) {
+	return error !== null;
+}
+function reportUnhandledError(error) {
+	const reportError = globalThis.reportError;
+	if (typeof reportError === "function") reportError(error);
+	else queueMicrotask(() => {
+		throw error;
+	});
+}
+function sameSelection(left, right) {
+	return left?.start === right?.start && left?.end === right?.end && (left?.start === left?.end || left?.direction === right?.direction);
+}
+//#endregion
+//#region src/text-engine.ts
+const DEFAULT_TRANSFORM_TIMEOUT_MS = 1e4;
+function createVoiceInputTextEngine(options = {}) {
+	const interimBehavior = options.interimBehavior ?? "inline";
+	if (interimBehavior !== "inline" && interimBehavior !== "expose") throw invalidConfiguration("interimBehavior must be either \"inline\" or \"expose\".");
+	if (options.transformTimeoutMs !== void 0 && (!Number.isFinite(options.transformTimeoutMs) || !Number.isInteger(options.transformTimeoutMs) || options.transformTimeoutMs <= 0)) throw invalidConfiguration("transformTimeoutMs must be a positive finite integer.");
+	if (options.controlled !== void 0 && (typeof options.controlled.getValue !== "function" || typeof options.controlled.onValueChange !== "function")) throw invalidConfiguration("controlled must provide getValue and onValueChange functions.");
+	if (options.transformTranscript !== void 0 && typeof options.transformTranscript !== "function") throw invalidConfiguration("transformTranscript must be a function.");
+	return new VoiceInputTextEngineController({
+		interimBehavior,
+		controlled: options.controlled,
+		transformTranscript: options.transformTranscript,
+		transformTimeoutMs: options.transformTimeoutMs ?? DEFAULT_TRANSFORM_TIMEOUT_MS
+	});
+}
+function invalidConfiguration(message) {
+	return new VoiceInputError$1({
+		code: "invalid-configuration",
+		message
+	});
+}
+//#endregion
+export { AUDIO_WORKLET_SOURCE as VOICE_INPUT_AUDIO_WORKLET_SOURCE, VoiceInputError, createBrowserAudioSource, createVoiceInputSession, createVoiceInputTextEngine, getBrowserVoiceInputSupport, normalizeBrowserAudioError };
+
+//# sourceMappingURL=index.js.map