@intellectif/lk-react 23.1.0 → 23.1.2

package/dist/useSpeechRecorder-zIi9Dlw8.js

@@ -0,0 +1,709 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/hooks/speech-recorder/machine.ts
+/** The state a recorder mounts in, on a server as on a client. */
+const IDLE_RECORDER = {
+	status: "idle",
+	error: null,
+	level: 0,
+	elapsedMs: 0,
+	take: null,
+	takesUsed: 0
+};
+/**
+* Applies one event. Returns the state it was given, unchanged and identical,
+* when the event moves nothing — so a block arriving after teardown costs no
+* render.
+*/
+function reduceRecorder(state, event) {
+	switch (event.kind) {
+		case "requested": return {
+			...state,
+			status: "requesting-permission",
+			error: null,
+			level: 0,
+			elapsedMs: 0,
+			take: null
+		};
+		case "started": return state.status === "requesting-permission" ? {
+			...state,
+			status: "recording"
+		} : state;
+		case "progress": return state.status === "recording" ? {
+			...state,
+			level: event.level,
+			elapsedMs: event.elapsedMs
+		} : state;
+		case "captured": return {
+			...state,
+			status: "recorded",
+			error: null,
+			level: 0,
+			elapsedMs: event.take.durationMs,
+			take: event.take,
+			takesUsed: state.takesUsed + 1
+		};
+		case "failed": return {
+			...state,
+			status: "error",
+			error: event.error,
+			level: 0,
+			take: null
+		};
+		case "discarded": return {
+			...state,
+			status: "idle",
+			error: null,
+			level: 0,
+			elapsedMs: 0,
+			take: null
+		};
+		case "reset": return state === IDLE_RECORDER ? state : IDLE_RECORDER;
+	}
+}
+//#endregion
+//#region src/hooks/speech-recorder/resample.ts
+/**
+* Turning the blocks a capture node delivers into one mono 16 kHz signal.
+*
+* 16 kHz mono is the rate every mainstream assessor accepts and the rate
+* `inspectWav` measures exactly, while a microphone is opened at whatever rate
+* the device runs at — 44.1 or 48 kHz on most, already 16 kHz on some. The
+* three steps are separated and pure so the arithmetic that decides what a
+* server will measure can be tested without a browser.
+*/
+/** The capture rate every mainstream assessor accepts. */
+const TARGET_SAMPLE_RATE = 16e3;
+/**
+* Where the anti-alias filter stops passing, as a fraction of the target rate.
+*
+* Below 0.5 on purpose: a filter cutting at exactly the target's Nyquist is
+* only 6 dB down there and its transition band folds straight back into the
+* signal. Cutting at 7.2 kHz leaves the transition band room to finish before
+* 8 kHz, and speech carries next to nothing in the 800 Hz that costs.
+*/
+const CUTOFF_FRACTION = .45;
+/**
+* Half the kernel width, counted in target-rate sample periods. Sixteen
+* periods of taps is enough Hann-windowed sinc to put a tone an octave above
+* the cutoff far below anything a meter or an assessor would notice, and short
+* enough that filtering a whole take costs a fraction of a second.
+*/
+const KERNEL_HALF_PERIODS = 8;
+/**
+* Averages the channels of one capture block into mono.
+*
+* Always allocates, never returns what it was given: a `ScriptProcessorNode`
+* hands out the same buffer on every callback and overwrites it in place, so a
+* mono capture that passed the input straight through would find every block
+* it had kept replaced by the last one.
+*
+* Channels of unequal length are read to the shortest. Nothing should produce
+* them, and the alternative to a bound is reading past the end of one and
+* poisoning the whole take with NaN.
+*/
+function downmix(channels) {
+	if (channels.length === 0) return /* @__PURE__ */ new Float32Array(0);
+	let frames = channels[0].length;
+	for (const channel of channels) if (channel.length < frames) frames = channel.length;
+	const mono = new Float32Array(frames);
+	for (const channel of channels) for (let frame = 0; frame < frames; frame += 1) mono[frame] += channel[frame];
+	for (let frame = 0; frame < frames; frame += 1) mono[frame] /= channels.length;
+	return mono;
+}
+/** Concatenates captured blocks into the single signal a take is encoded from. */
+function joinBlocks(blocks, frames) {
+	const joined = new Float32Array(frames);
+	let at = 0;
+	for (const block of blocks) {
+		joined.set(block, at);
+		at += block.length;
+	}
+	return joined;
+}
+/**
+* A windowed-sinc low-pass, applied at the input rate before any samples are
+* dropped.
+*
+* Without it, resampling is aliasing: every component above the target's
+* Nyquist folds back down into the speech band as a tone that was never
+* spoken, and an assessor scores what it hears. The window is Hann and the
+* kernel is normalised to unit gain, so a signal already inside the band comes
+* through at its own amplitude.
+*
+* Edges are extended by repeating the first and last sample rather than by
+* zero-padding, which would put a step — and so a click — at each end of every
+* take.
+*/
+function lowPass(samples, inputRate) {
+	const cutoff = TARGET_SAMPLE_RATE * CUTOFF_FRACTION / inputRate;
+	const half = Math.max(1, Math.round(KERNEL_HALF_PERIODS * inputRate / TARGET_SAMPLE_RATE));
+	const taps = new Float32Array(half * 2 + 1);
+	let gain = 0;
+	for (let tap = 0; tap < taps.length; tap += 1) {
+		const at = tap - half;
+		const angle = 2 * Math.PI * cutoff * at;
+		const sinc = at === 0 ? 2 * cutoff : Math.sin(angle) / (Math.PI * at);
+		const window = .5 - .5 * Math.cos(2 * Math.PI * tap / (taps.length - 1));
+		taps[tap] = sinc * window;
+		gain += taps[tap];
+	}
+	for (let tap = 0; tap < taps.length; tap += 1) taps[tap] /= gain;
+	const last = samples.length - 1;
+	const filtered = new Float32Array(samples.length);
+	for (let index = 0; index < samples.length; index += 1) {
+		let total = 0;
+		for (let tap = 0; tap < taps.length; tap += 1) {
+			const at = index + tap - half;
+			total += taps[tap] * samples[at < 0 ? 0 : at > last ? last : at];
+		}
+		filtered[index] = total;
+	}
+	return filtered;
+}
+/**
+* Resamples mono samples from `inputRate` to {@link TARGET_SAMPLE_RATE}.
+*
+* Every path returns an array the caller owns, the equal-rate one included, so
+* no caller has to know whether it was handed its own buffer back.
+*
+* The filter runs only when the rate is coming down. Interpolating upwards
+* invents no frequencies above the input's own Nyquist, so there is nothing
+* for an anti-alias filter to remove and applying one would only dull a
+* recording a 16 kHz device already captured cleanly.
+*/
+function resampleToTarget(samples, inputRate) {
+	if (samples.length === 0) return /* @__PURE__ */ new Float32Array(0);
+	if (inputRate === 16e3) return samples.slice();
+	const source = inputRate > 16e3 ? lowPass(samples, inputRate) : samples;
+	const length = Math.round(samples.length * TARGET_SAMPLE_RATE / inputRate);
+	const resampled = new Float32Array(length);
+	const step = inputRate / TARGET_SAMPLE_RATE;
+	const last = source.length - 1;
+	for (let index = 0; index < length; index += 1) {
+		const at = index * step;
+		const left = Math.min(Math.floor(at), last);
+		const right = Math.min(left + 1, last);
+		const fraction = at - left;
+		resampled[index] = source[left] * (1 - fraction) + source[right] * fraction;
+	}
+	return resampled;
+}
+//#endregion
+//#region src/hooks/speech-recorder/wav.ts
+/**
+* 16-bit PCM WAV, and the two level measurements taken over the same samples.
+*
+* This is the one format the SDK's `inspectWav` reads, so these bytes are the
+* bytes a server measures a take with — anything else would need a decoder on
+* the application's side before a grade could exist. Nothing here touches Web
+* Audio, which is why the encoder can be unit tested against `inspectWav`
+* itself rather than against a browser.
+*/
+/** The media type of what {@link encodeWav16} returns. */
+const WAV_MIME_TYPE = "audio/wav";
+/** RIFF + a 16-byte `fmt ` + `data`, every field fixed-size. */
+const HEADER_BYTES = 44;
+/** Writes four ASCII characters, which is all a RIFF tag ever is. */
+function writeTag(view, offset, tag) {
+	for (let index = 0; index < tag.length; index += 1) view.setUint8(offset + index, tag.charCodeAt(index));
+}
+/**
+* Encodes mono samples as a 16-bit PCM WAV.
+*
+* The two scale factors are not a typo. Signed 16-bit runs from -32768 to
+* 32767, so a single factor cannot reach full scale in both directions: 0x7fff
+* throughout leaves a full-scale negative peak reading -0.99997, and 0x8000
+* throughout overflows into the positive at +1. Each sign gets the factor that
+* lands exactly on its own limit.
+*
+* The buffer is named in the return type because a `Blob` refuses a view that
+* might be backed by a `SharedArrayBuffer`, and these bytes go straight into
+* one.
+*/
+function encodeWav16(samples, sampleRate) {
+	const dataBytes = samples.length * 2;
+	const bytes = new Uint8Array(HEADER_BYTES + dataBytes);
+	const view = new DataView(bytes.buffer);
+	writeTag(view, 0, "RIFF");
+	view.setUint32(4, 36 + dataBytes, true);
+	writeTag(view, 8, "WAVE");
+	writeTag(view, 12, "fmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, 1, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, sampleRate * 2, true);
+	view.setUint16(32, 2, true);
+	view.setUint16(34, 16, true);
+	writeTag(view, 36, "data");
+	view.setUint32(40, dataBytes, true);
+	for (let index = 0; index < samples.length; index += 1) {
+		const sample = samples[index];
+		const clamped = sample < -1 ? -1 : sample > 1 ? 1 : sample;
+		view.setInt16(HEADER_BYTES + index * 2, Math.round(clamped * (clamped < 0 ? 32768 : 32767)), true);
+	}
+	return bytes;
+}
+/** The loudest sample, 0..1 — what a take reports as its `peakLevel`. */
+function peakOf(samples) {
+	let peak = 0;
+	for (let index = 0; index < samples.length; index += 1) {
+		const magnitude = Math.abs(samples[index]);
+		if (magnitude > peak) peak = magnitude;
+	}
+	return peak > 1 ? 1 : peak;
+}
+/**
+* Root mean square, 0..1 — what the recorder reports as its `level`.
+*
+* RMS rather than the peak, because a meter driven by peaks sits near full
+* scale on any speech at all and tells a learner nothing about whether they
+* are being heard. It is also the measure `inspectWav` decides voiced time
+* with, so what the meter shows and what the server later counts as speech are
+* the same quantity.
+*/
+function rmsOf(samples) {
+	if (samples.length === 0) return 0;
+	let total = 0;
+	for (let index = 0; index < samples.length; index += 1) total += samples[index] * samples[index];
+	const rms = Math.sqrt(total / samples.length);
+	return rms > 1 ? 1 : rms;
+}
+//#endregion
+//#region src/hooks/speech-recorder/worklet.ts
+/**
+* The audio worklet processor, and the module URL it is loaded through.
+*
+* The processor must run inside `AudioWorkletGlobalScope`, which can only be
+* reached by URL. Source text turned into a Blob URL is the only form of that
+* which needs nothing of the consuming application: `import.meta` is not
+* available in every target this package is bundled for — the CommonJS build
+* among them — and a separate asset file would have to be copied into the
+* public directory of every application that installs the SDK.
+*
+* An application whose Content-Security-Policy refuses that URL self-hosts the
+* same source and passes its URL as `workletUrl` instead. The source is public
+* for exactly that reason — see {@link CAPTURE_PROCESSOR_SOURCE}.
+*/
+/** The name the processor registers itself under, and is constructed by. */
+const CAPTURE_PROCESSOR = "lk-speech-capture";
+/**
+* The audio worklet module `useSpeechRecorder` captures through, as source
+* text — exported so an application with a strict Content-Security-Policy can
+* serve it itself.
+*
+* By default the hook loads this text from a `blob:` URL. A worklet module is
+* loaded as a script, so it is `script-src` that must allow `blob:` —
+* `worker-src` does not govern it. Where that is refused, write this string to
+* a file your policy's `script-src` does allow, at build time and from the
+* installed package so it moves with the version you run, and pass that file's
+* URL as `workletUrl`:
+*
+* ```ts
+* import { writeFileSync } from 'node:fs';
+* import { CAPTURE_PROCESSOR_SOURCE } from '@intellectif/lk-react/hooks/useSpeechRecorder';
+*
+* writeFileSync('public/lk-speech-capture.js', CAPTURE_PROCESSOR_SOURCE);
+* ```
+*
+* **The contract** a module at `workletUrl` must meet, which this source does:
+* register an `AudioWorkletProcessor` under the name `lk-speech-capture`, and
+* from its `process(inputs)` post the first input's channels to its `port` as
+* an array with one `Float32Array` per channel, **copied** — the render
+* quantum's buffers belong to the audio thread and are overwritten on the next
+* quantum, so a block posted without copying arrives as whatever the
+* microphone heard some milliseconds later. Return `true`, which keeps the
+* processor alive while its source is silent. Anything else changes what is
+* recorded, so serve this text unchanged rather than a copy of your own.
+*/
+const CAPTURE_PROCESSOR_SOURCE = `class LkSpeechCapture extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0];
+    if (input === undefined || input.length === 0) {
+      return true;
+    }
+    const block = [];
+    for (let channel = 0; channel < input.length; channel += 1) {
+      block.push(input[channel].slice());
+    }
+    this.port.postMessage(block);
+    return true;
+  }
+}
+registerProcessor(${JSON.stringify(CAPTURE_PROCESSOR)}, LkSpeechCapture);
+`;
+/**
+* Wraps {@link CAPTURE_PROCESSOR_SOURCE} in an object URL.
+*
+* Returns `null` where object URLs are unavailable — a server render, a test
+* environment, a hardened embedder — rather than throwing, because the caller
+* has a working fallback for exactly that case and a missing URL factory is
+* not a failed recording.
+*
+* Called from `start()` and never at module scope: `URL.createObjectURL` is a
+* browser global, and reading one while a module is evaluated is what breaks a
+* server render.
+*/
+function createProcessorUrl() {
+	const urls = globalThis.URL;
+	if (urls === void 0) return null;
+	const create = urls.createObjectURL;
+	const revoke = urls.revokeObjectURL;
+	if (create === void 0 || revoke === void 0) return null;
+	const url = create.call(urls, new Blob([CAPTURE_PROCESSOR_SOURCE], { type: "text/javascript" }));
+	return {
+		url,
+		release: () => {
+			revoke.call(urls, url);
+		}
+	};
+}
+//#endregion
+//#region src/hooks/useSpeechRecorder.ts
+/**
+* A `ScriptProcessorNode`'s buffer, in frames.
+*
+* This fallback runs its callback on the main thread, so the buffer has to
+* hold whatever a render blocks it for; 4096 frames is about 85 ms at 48 kHz,
+* and a smaller one drops samples out of the middle of a take whenever the
+* page is busy. The worklet path, which runs on the audio thread, needs none
+* of this.
+*/
+const PROCESSOR_BUFFER_FRAMES = 4096;
+/** How often the meter and the elapsed time may move. */
+const LEVEL_UPDATES_PER_SECOND = 10;
+function stopTracks(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+function closeQuietly(context) {
+	context.close().catch(() => {});
+}
+/**
+* Which refusal `getUserMedia` made.
+*
+* Read from `name`, not from the message: messages are localised and are
+* rewritten between browser versions, while the names are specified. Anything
+* unrecognised is `failed` rather than a guess — telling a learner their
+* permission was denied when their device was busy sends them to the wrong
+* setting.
+*/
+function microphoneError(error) {
+	switch (error?.name) {
+		case "NotAllowedError":
+		case "SecurityError": return "permission-denied";
+		case "NotFoundError": return "no-device";
+		case "NotSupportedError": return "unsupported";
+		default: return "failed";
+	}
+}
+/**
+* The worklet capture node, or `null` when this engine cannot build one.
+*
+* `null` rather than a throw for every one of its reasons — no
+* `AudioWorkletNode`, no worklet thread, an object URL the page's
+* Content-Security-Policy refuses, a module that fails to load — because none
+* of them is a failed recording: the caller has a working fallback for all of
+* them, and only the absence of both is an unsupported browser.
+*/
+async function createWorkletNode(context, workletUrl, onBlock) {
+	const AudioWorkletNodeConstructor = globalThis.AudioWorkletNode;
+	const worklet = context.audioWorklet;
+	if (AudioWorkletNodeConstructor === void 0 || worklet === void 0) return null;
+	const minted = workletUrl === void 0 ? createProcessorUrl() : null;
+	const url = workletUrl ?? minted?.url;
+	if (url === void 0) return null;
+	try {
+		await worklet.addModule(url);
+		const node = new AudioWorkletNodeConstructor(context, CAPTURE_PROCESSOR);
+		node.port.onmessage = (event) => {
+			onBlock(event.data);
+		};
+		return {
+			node,
+			detach: () => {
+				node.port.onmessage = null;
+			}
+		};
+	} catch {
+		return null;
+	} finally {
+		minted?.release();
+	}
+}
+/** The `ScriptProcessorNode` fallback, or `null` on an engine without one. */
+function createProcessorNode(context, onBlock) {
+	const create = context.createScriptProcessor;
+	if (create === void 0) return null;
+	const node = create.call(context, PROCESSOR_BUFFER_FRAMES, 1, 1);
+	node.onaudioprocess = (event) => {
+		const buffer = event.inputBuffer;
+		const channels = [];
+		for (let channel = 0; channel < buffer.numberOfChannels; channel += 1) channels.push(buffer.getChannelData(channel));
+		onBlock(channels);
+	};
+	return {
+		node,
+		detach: () => {
+			node.onaudioprocess = null;
+		}
+	};
+}
+/**
+* Records a take of speech as mono 16-bit PCM WAV at 16 kHz.
+*
+* That is the one format the SDK measures directly: `inspectWav` reads it
+* without a decoding library, and it is what every mainstream pronunciation
+* assessor accepts. A take is captured at whatever rate the device runs at,
+* downmixed to mono, low-pass filtered and resampled, then encoded — so what a
+* server measures is what this hook produced, not a claim about it.
+*
+* **Server rendering.** `status`, `error` and `canRecord` are derived from the
+* take count alone and never from a browser global, so the markup a server
+* produces is the markup the browser's first render produces. Support is
+* discovered inside {@link SpeechRecorder.start} and reported as
+* `error: 'unsupported'`; the obvious `!!navigator.mediaDevices` guard at
+* render time would make a server render and its hydration disagree.
+*
+* **Identity.** `start`, `stop`, `discard` and `reset` keep one identity for the
+* life of the hook, so they are safe in a dependency array. The returned object keeps
+* one identity for as long as none of its values changes, so a render caused
+* by something else does not invalidate an effect that depends on it.
+*
+* `start()` does nothing when no take remains, so `canRecord` is presentation:
+* mark the control `aria-disabled` rather than `disabled`, which would take it
+* out of the tab order and leave a learner nothing to read.
+*
+* ```tsx
+* const recorder = useSpeechRecorder({ maxDurationMs: 20_000, maxTakes: 3 });
+* <button
+*   type="button"
+*   aria-disabled={!recorder.canRecord}
+*   onClick={() => {
+*     void recorder.start();
+*   }}
+* >
+*   Record
+* </button>
+* ```
+*/
+function useSpeechRecorder(options) {
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	const [state, setState] = useState(IDLE_RECORDER);
+	const stateRef = useRef(IDLE_RECORDER);
+	const sessionRef = useRef(null);
+	const startingRef = useRef(false);
+	const attemptRef = useRef(0);
+	const dispatch = useCallback((event) => {
+		const next = reduceRecorder(stateRef.current, event);
+		if (next === stateRef.current) return;
+		stateRef.current = next;
+		setState(next);
+	}, []);
+	const endSession = useCallback(() => {
+		const session = sessionRef.current;
+		sessionRef.current = null;
+		session?.release();
+	}, []);
+	const finish = useCallback(() => {
+		const session = sessionRef.current;
+		if (session === null) return;
+		sessionRef.current = null;
+		session.release();
+		const { minDurationMs } = optionsRef.current;
+		const samples = resampleToTarget(joinBlocks(session.blocks, session.frames), session.rate);
+		const durationMs = samples.length / TARGET_SAMPLE_RATE * 1e3;
+		if (minDurationMs !== void 0 && durationMs < minDurationMs) {
+			dispatch({
+				kind: "failed",
+				error: "too-short"
+			});
+			return;
+		}
+		dispatch({
+			kind: "captured",
+			take: {
+				blob: new Blob([encodeWav16(samples, TARGET_SAMPLE_RATE)], { type: WAV_MIME_TYPE }),
+				mimeType: WAV_MIME_TYPE,
+				durationMs,
+				peakLevel: peakOf(samples)
+			}
+		});
+	}, [dispatch]);
+	const handleBlock = useCallback((channels) => {
+		const session = sessionRef.current;
+		if (session === null) return;
+		let block = downmix(channels);
+		const room = session.maxFrames - session.frames;
+		if (block.length > room) block = block.subarray(0, room);
+		session.blocks.push(block);
+		session.frames += block.length;
+		const level = rmsOf(block);
+		if (level > session.peak) session.peak = level;
+		if (session.frames >= session.maxFrames) {
+			finish();
+			return;
+		}
+		if (session.frames - session.reportedAt < session.rate / LEVEL_UPDATES_PER_SECOND) return;
+		session.reportedAt = session.frames;
+		const peak = session.peak;
+		session.peak = 0;
+		dispatch({
+			kind: "progress",
+			level: peak,
+			elapsedMs: session.frames / session.rate * 1e3
+		});
+	}, [dispatch, finish]);
+	const start = useCallback(async () => {
+		const { maxDurationMs, maxTakes, workletUrl } = optionsRef.current;
+		if (startingRef.current || sessionRef.current !== null) return;
+		if (maxTakes !== void 0 && stateRef.current.takesUsed >= maxTakes) return;
+		const attempt = attemptRef.current;
+		startingRef.current = true;
+		dispatch({ kind: "requested" });
+		let release = () => {};
+		try {
+			const view = globalThis;
+			const devices = view.navigator?.mediaDevices;
+			const getUserMedia = devices?.getUserMedia;
+			const AudioContextConstructor = view.AudioContext;
+			if (devices === void 0 || getUserMedia === void 0 || AudioContextConstructor === void 0) {
+				dispatch({
+					kind: "failed",
+					error: "unsupported"
+				});
+				return;
+			}
+			let stream;
+			try {
+				stream = await getUserMedia.call(devices, { audio: true });
+			} catch (error) {
+				dispatch({
+					kind: "failed",
+					error: microphoneError(error)
+				});
+				return;
+			}
+			release = () => {
+				stopTracks(stream);
+			};
+			if (attempt !== attemptRef.current) {
+				release();
+				dispatch({ kind: "discarded" });
+				return;
+			}
+			let context;
+			try {
+				context = new AudioContextConstructor();
+			} catch {
+				release();
+				dispatch({
+					kind: "failed",
+					error: "unsupported"
+				});
+				return;
+			}
+			const open = context;
+			release = () => {
+				stopTracks(stream);
+				closeQuietly(open);
+			};
+			const attached = await createWorkletNode(open, workletUrl, handleBlock) ?? createProcessorNode(open, handleBlock);
+			if (attached === null) {
+				release();
+				dispatch({
+					kind: "failed",
+					error: "unsupported"
+				});
+				return;
+			}
+			const source = open.createMediaStreamSource(stream);
+			const sink = open.createGain();
+			sink.gain.value = 0;
+			source.connect(attached.node);
+			attached.node.connect(sink);
+			sink.connect(open.destination);
+			release = () => {
+				attached.detach();
+				attached.node.disconnect();
+				source.disconnect();
+				sink.disconnect();
+				stopTracks(stream);
+				closeQuietly(open);
+			};
+			if (attempt !== attemptRef.current) {
+				release();
+				dispatch({ kind: "discarded" });
+				return;
+			}
+			sessionRef.current = {
+				blocks: [],
+				frames: 0,
+				rate: open.sampleRate,
+				maxFrames: Math.max(1, Math.floor(maxDurationMs / 1e3 * open.sampleRate)),
+				peak: 0,
+				reportedAt: 0,
+				release
+			};
+			dispatch({ kind: "started" });
+		} catch {
+			release();
+			sessionRef.current = null;
+			dispatch({
+				kind: "failed",
+				error: "failed"
+			});
+		} finally {
+			startingRef.current = false;
+		}
+	}, [dispatch, handleBlock]);
+	const stop = useCallback(() => {
+		if (sessionRef.current === null) {
+			attemptRef.current += 1;
+			return;
+		}
+		finish();
+	}, [finish]);
+	const discard = useCallback(() => {
+		attemptRef.current += 1;
+		endSession();
+		dispatch({ kind: "discarded" });
+	}, [dispatch, endSession]);
+	const reset = useCallback(() => {
+		attemptRef.current += 1;
+		endSession();
+		dispatch({ kind: "reset" });
+	}, [dispatch, endSession]);
+	useEffect(() => {
+		return () => {
+			attemptRef.current += 1;
+			endSession();
+		};
+	}, [endSession]);
+	const { maxTakes } = options;
+	return useMemo(() => ({
+		status: state.status,
+		error: state.error,
+		level: state.level,
+		elapsedMs: state.elapsedMs,
+		take: state.take,
+		takesUsed: state.takesUsed,
+		canRecord: maxTakes === void 0 || state.takesUsed < maxTakes,
+		start,
+		stop,
+		discard,
+		reset
+	}), [
+		state,
+		maxTakes,
+		start,
+		stop,
+		discard,
+		reset
+	]);
+}
+//#endregion
+export { CAPTURE_PROCESSOR_SOURCE as n, useSpeechRecorder as t };
+
+//# sourceMappingURL=useSpeechRecorder-zIi9Dlw8.js.map