@seams/voice-capture 0.0.0-stage → 0.66.0

package/dist/esm/microphoneInput.js

@@ -0,0 +1,117 @@
+import { captureConfig } from "./config.js";
+//#region src/microphoneInput.ts
+let preference = { kind: "unread" };
+function concreteDeviceId(value) {
+	return typeof value === "string" && value.length > 0 && value !== "default" && value !== "communications";
+}
+async function readPreference() {
+	if (preference.kind !== "unread") return preference;
+	let saved = { kind: "system_default" };
+	try {
+		const raw = await captureConfig().microphonePreference?.read();
+		if (typeof raw === "object" && raw !== null && "kind" in raw && raw.kind === "device") {
+			const deviceId = "deviceId" in raw ? raw.deviceId : null;
+			if (concreteDeviceId(deviceId)) saved = {
+				kind: "device",
+				deviceId
+			};
+		}
+	} catch {}
+	if (preference.kind === "unread") preference = saved;
+	return preference;
+}
+function constraints(preference) {
+	const audio = {
+		channelCount: 1,
+		echoCancellation: true,
+		noiseSuppression: true,
+		autoGainControl: true
+	};
+	if (preference.kind === "device") audio.deviceId = { exact: preference.deviceId };
+	return {
+		audio,
+		video: false
+	};
+}
+/** Select the concrete input behind a browser's moving default-device alias. */
+async function resolvedPreference(settings) {
+	if (concreteDeviceId(settings.deviceId)) return {
+		kind: "device",
+		deviceId: settings.deviceId
+	};
+	if (settings.groupId) try {
+		const devices = await navigator.mediaDevices.enumerateDevices();
+		for (const device of devices) if (device.kind === "audioinput" && device.groupId === settings.groupId && concreteDeviceId(device.deviceId)) return {
+			kind: "device",
+			deviceId: device.deviceId
+		};
+	} catch {}
+	return { kind: "system_default" };
+}
+async function openVoiceMicrophone(signal) {
+	signal.throwIfAborted();
+	const preference = await readPreference();
+	signal.throwIfAborted();
+	let stream;
+	let selection = preference.kind === "device" ? "preferred" : "default";
+	try {
+		stream = await navigator.mediaDevices.getUserMedia(constraints(preference));
+	} catch (error) {
+		signal.throwIfAborted();
+		if (preference.kind !== "device" || !(error instanceof DOMException) || error.name !== "OverconstrainedError" && error.name !== "NotFoundError") throw error;
+		stream = await navigator.mediaDevices.getUserMedia(constraints({ kind: "system_default" }));
+		selection = "replacement";
+	}
+	const stop = stopMicrophone.bind(null, stream);
+	signal.addEventListener("abort", stop, { once: true });
+	try {
+		signal.throwIfAborted();
+		const track = stream.getAudioTracks()[0];
+		if (!track || track.readyState !== "live") throw new VoiceMicrophoneInterruptedError();
+		const settings = track.getSettings();
+		const resolved = await resolvedPreference(settings);
+		signal.throwIfAborted();
+		if (track.readyState !== "live") throw new VoiceMicrophoneInterruptedError();
+		return {
+			stream,
+			preference: resolved,
+			selection,
+			label: track.label || "Default microphone",
+			processing: {
+				noiseSuppression: settings.noiseSuppression ?? null,
+				echoCancellation: settings.echoCancellation ?? null,
+				autoGainControl: settings.autoGainControl ?? null,
+				sampleRate: settings.sampleRate ?? null
+			}
+		};
+	} catch (error) {
+		stop();
+		throw error;
+	} finally {
+		signal.removeEventListener("abort", stop);
+	}
+}
+function stopMicrophone(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+async function rememberVoiceMicrophone(microphone) {
+	if (microphone.preference.kind !== "device" || microphone.selection === "replacement") return;
+	await savePreference(microphone.preference);
+}
+async function useSystemVoiceMicrophone() {
+	await savePreference({ kind: "system_default" });
+}
+async function savePreference(selected) {
+	preference = selected;
+	try {
+		await captureConfig().microphonePreference?.save(selected);
+	} catch {}
+}
+var VoiceMicrophoneInterruptedError = class extends Error {
+	constructor() {
+		super("The microphone disconnected or stopped. Check your microphone and try again.");
+		this.name = "VoiceMicrophoneInterruptedError";
+	}
+};
+//#endregion
+export { VoiceMicrophoneInterruptedError, openVoiceMicrophone, rememberVoiceMicrophone, useSystemVoiceMicrophone };

package/dist/esm/speechPause.js

@@ -0,0 +1,33 @@
+//#region src/speechPause.ts
+/** The silence that ends a recording when the expected sentence is unknown or not yet said. */
+const END_PAUSE_MS = 1500;
+/**
+* The silence that ends a recording once the voiced time covers the expected sentence. A pause
+* inside the sentence comes before that point, so it still gets `END_PAUSE_MS`.
+*/
+const SHORT_END_PAUSE_MS = 800;
+/**
+* Voiced time of one spoken word at a fast pace. Normal speech is about 300 ms a word, and
+* pauses between words are not voiced, so most speakers pass this before the last word ends.
+*/
+const VOICED_MS_PER_WORD = 200;
+/** The silence that ends a recording after `voicedMs` of speech. */
+function endPauseMs(voicedMs, expectedSpeechMs) {
+	return expectedSpeechMs !== null && voicedMs >= expectedSpeechMs ? SHORT_END_PAUSE_MS : END_PAUSE_MS;
+}
+/**
+* The least voiced time of the whole `sentence` as people read it aloud. Digits, dots and dashes
+* are words of their own: "Send 0.01 NEAR to seams-v1.testnet" is read as 13 words ("send zero
+* point zero one near to seams dash v one dot testnet").
+*/
+function expectedSpeechMs(sentence) {
+	return sentence.trim().replace(/[.!?,;:]+$/, "").split(/\s+/).filter(Boolean).reduce((count, word) => count + spokenWords(word), 0) * VOICED_MS_PER_WORD;
+}
+function spokenWords(word) {
+	const letters = word.match(/[A-Za-z]+/g)?.length ?? 0;
+	const digits = word.match(/[0-9]/g)?.length ?? 0;
+	const marks = word.match(/[.\-_@]/g)?.length ?? 0;
+	return Math.max(1, letters + digits + marks);
+}
+//#endregion
+export { endPauseMs, expectedSpeechMs };

package/dist/esm/voiceActivity.js

@@ -0,0 +1,69 @@
+import { BrowserInferenceModel } from "./inference.js";
+//#region src/voiceActivity.ts
+const voiceActivityModel = new BrowserInferenceModel({
+	fileName: "silero-vad.onnx",
+	sha256: "2623a2953f6ff3d2c1e61740c6cdb7168133479b267dfef114a4a3cc5bdd788f",
+	bytes: 2327524,
+	label: "Speech detection"
+});
+/** The speech detection model. It downloads the model and the model engine on first use. */
+async function createVoiceActivity() {
+	return new VoiceActivity(await voiceActivityModel.prepare(), await import("onnxruntime-web/wasm"));
+}
+/**
+* A detector with no model and no download: every frame counts as speech, so only the level
+* check of the recorder decides. It cannot tell speech from other loud sound.
+*/
+const levelDetector = {
+	probability: async () => 1,
+	clear: () => {}
+};
+var VoiceActivity = class {
+	state = new Float32Array(256);
+	context = new Float32Array(64);
+	constructor(session, ort) {
+		this.session = session;
+		this.ort = ort;
+	}
+	async probability(frame) {
+		if (frame.length !== 512) throw new Error("Speech detection requires a 512-sample frame.");
+		const samples = new Float32Array(576);
+		samples.set(this.context);
+		samples.set(frame, 64);
+		const input = new this.ort.Tensor("float32", samples, [1, 576]);
+		const state = new this.ort.Tensor("float32", this.state, [
+			2,
+			1,
+			128
+		]);
+		const sr = new this.ort.Tensor("int64", BigInt64Array.of(16000n), []);
+		try {
+			const outputs = await this.session.run({
+				input,
+				state,
+				sr
+			});
+			try {
+				const probability = outputs.output?.data;
+				const nextState = outputs.stateN?.data;
+				if (!(probability instanceof Float32Array) || probability.length !== 1 || !Number.isFinite(probability[0]) || probability[0] < 0 || probability[0] > 1 || !(nextState instanceof Float32Array) || nextState.length !== 256) throw new Error("Speech detection returned an invalid result.");
+				this.state.set(nextState);
+				this.context.set(frame.subarray(448));
+				return probability[0];
+			} finally {
+				for (const output of Object.values(outputs)) output.dispose();
+			}
+		} finally {
+			input.dispose();
+			state.dispose();
+			sr.dispose();
+			samples.fill(0);
+		}
+	}
+	clear() {
+		this.state.fill(0);
+		this.context.fill(0);
+	}
+};
+//#endregion
+export { createVoiceActivity, levelDetector, voiceActivityModel };

package/dist/esm/wav.js

@@ -0,0 +1,36 @@
+//#region src/wav.ts
+const SAMPLE_RATE = 16e3;
+/** The Speak-to-Sign verifier refuses audio longer than 8 s. */
+const MAX_SAMPLES = 8 * SAMPLE_RATE;
+/**
+* 16 kHz mono PCM16 with the plain 44-byte header that the Speak-to-Sign verifier writes for its
+* canonical WAV, so the SHA-256 of these bytes is the audio digest of a verdict. Samples after
+* 8 s are left out.
+*/
+function pcm16Wav(samples) {
+	const count = Math.min(samples.length, MAX_SAMPLES);
+	const bytes = new Uint8Array(44 + count * 2);
+	const view = new DataView(bytes.buffer);
+	writeAscii(bytes, 0, "RIFF");
+	view.setUint32(4, 36 + count * 2, true);
+	writeAscii(bytes, 8, "WAVEfmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, 1, true);
+	view.setUint32(24, SAMPLE_RATE, true);
+	view.setUint32(28, SAMPLE_RATE * 2, true);
+	view.setUint16(32, 2, true);
+	view.setUint16(34, 16, true);
+	writeAscii(bytes, 36, "data");
+	view.setUint32(40, count * 2, true);
+	for (let index = 0; index < count; index += 1) {
+		const sample = Math.max(-1, Math.min(1, samples[index] ?? 0));
+		view.setInt16(44 + index * 2, Math.round(sample < 0 ? sample * 32768 : sample * 32767), true);
+	}
+	return bytes;
+}
+function writeAscii(bytes, offset, text) {
+	for (let index = 0; index < text.length; index += 1) bytes[offset + index] = text.charCodeAt(index);
+}
+//#endregion
+export { MAX_SAMPLES, SAMPLE_RATE, pcm16Wav };

package/dist/example/example.js

@@ -0,0 +1,71 @@
+// The example of @seams/voice-capture: one sentence on the phrase card, and three enrollment
+// phrases. It imports the built single-file package, so it needs no bundler.
+
+import { configureVoiceCapture, pcm16Wav, SAMPLE_RATE } from '../browser/index.js';
+import { openPhraseCard } from '../browser/card.js';
+
+configureVoiceCapture({ assetBase: '../assets/' });
+
+const ENROLLMENT_PHRASES = [
+  'My voice is my signature for this wallet.',
+  'I send money only when I say so.',
+  'Seams, please learn how I sound today.',
+];
+
+const log = document.querySelector('#log');
+const parent = document.querySelector('#card');
+const detector = () => (document.querySelector('#level').checked ? 'level' : 'model');
+
+/** Shows one sentence, records it and returns its WAV, or null when the person closed the card. */
+async function recordSentence(sentence, signal) {
+  const surface = openPhraseCard({ sentence, signal, detector: detector(), frame: { parent } });
+  try {
+    const recording = await surface.record();
+    if (recording.kind === 'cancelled') return null;
+    const seconds = recording.samples.length / SAMPLE_RATE;
+    const wav = pcm16Wav(recording.samples);
+    // The caller owns the samples: clear them after use.
+    recording.samples.fill(0);
+    // An application sends the WAV to its verifier here, and shows the answer on the same card.
+    void surface.show({
+      kind: 'check',
+      label: 'Checking',
+      caption: 'Your application checks the recording',
+      details: ['This example checks nothing.'],
+      segments: ['done', 'run'],
+    });
+    await new Promise((resolve) => setTimeout(resolve, 900));
+    await surface.show({
+      kind: 'result',
+      label: '',
+      headline: 'Recorded',
+      caption: sentence,
+      detail: `${seconds.toFixed(1)} s, ${wav.length} bytes of WAV`,
+      action: { label: 'Done' },
+      line: 'seal',
+    });
+    return { seconds, bytes: wav.length };
+  } finally {
+    surface.close();
+  }
+}
+
+document.querySelector('#sentence').addEventListener('click', async () => {
+  const result = await recordSentence('Send two NEAR to alice.testnet', new AbortController().signal);
+  log.textContent = result
+    ? `One sentence: ${result.seconds.toFixed(1)} s, ${result.bytes} bytes.`
+    : 'The recording was cancelled.';
+});
+
+document.querySelector('#enroll').addEventListener('click', async () => {
+  const lines = [];
+  for (const phrase of ENROLLMENT_PHRASES) {
+    const result = await recordSentence(phrase, new AbortController().signal);
+    if (!result) {
+      lines.push('The enrollment was cancelled.');
+      break;
+    }
+    lines.push(`"${phrase}": ${result.seconds.toFixed(1)} s, ${result.bytes} bytes.`);
+  }
+  log.textContent = lines.join('\n');
+});

package/dist/example/index.html

@@ -0,0 +1,29 @@
+<!doctype html>
+<html lang="en" data-theme="light">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>voice-capture example</title>
+    <style>
+      body { margin: 0; padding: 2rem 1rem; font-family: system-ui, sans-serif; background: #f5f6f8; color: #14161a; }
+      main { max-width: 26.25rem; margin: 0 auto; display: grid; gap: 1rem; }
+      .row { display: flex; gap: 0.5rem; flex-wrap: wrap; }
+      button.start { padding: 0.6rem 1rem; border-radius: 0.75rem; border: 1px solid #c9ced6; background: #fff; font: inherit; cursor: pointer; }
+      pre { margin: 0; padding: 0.75rem; background: #fff; border: 1px solid #dfe3e8; border-radius: 0.75rem; white-space: pre-wrap; font-size: 0.8rem; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>voice-capture</h1>
+      <p>This page uses only <code>@seams/voice-capture</code>. The audio stays in the page.</p>
+      <label><input type="checkbox" id="level" /> Record with no model download (the detector <code>level</code>)</label>
+      <div class="row">
+        <button class="start" id="sentence">Record one sentence</button>
+        <button class="start" id="enroll">Record three enrollment phrases</button>
+      </div>
+      <pre id="log" aria-live="polite">Nothing recorded yet.</pre>
+      <div id="card"></div>
+    </main>
+    <script type="module" src="./example.js"></script>
+  </body>
+</html>

package/dist/hosting.d.mts

@@ -0,0 +1,4 @@
+/** Every file of the asset folder. */
+export declare const voiceCaptureAssets: readonly string[];
+/** Copies the asset files into `outputDirectory` and returns their names. */
+export declare function copyVoiceCaptureAssets(outputDirectory: string): Promise<readonly string[]>;

package/dist/hosting.mjs

@@ -0,0 +1,26 @@
+// The files that a page must serve from the folder that it gives to configureVoiceCapture.
+
+import { cp, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const assets = fileURLToPath(new URL('./assets/', import.meta.url));
+
+/** Every file of the asset folder. The model engine is the file of the pinned onnxruntime-web. */
+export const voiceCaptureAssets = Object.freeze([
+  'silero-vad.onnx',
+  'voice-activity-worklet.js',
+  'ort-wasm-simd-threaded.mjs',
+  'ort-wasm-simd-threaded.wasm',
+  'NOTICE.txt',
+  'SILERO_LICENSE.txt',
+]);
+
+/** Copies the asset files into `outputDirectory` and returns their names. */
+export async function copyVoiceCaptureAssets(outputDirectory) {
+  await mkdir(outputDirectory, { recursive: true });
+  for (const fileName of voiceCaptureAssets) {
+    await cp(path.join(assets, fileName), path.join(outputDirectory, fileName));
+  }
+  return voiceCaptureAssets;
+}

package/dist/types/card/index.d.ts

@@ -0,0 +1,6 @@
+export { openPhraseCard, type PhraseCardFrame, type PhraseCardInput } from './surface';
+export type { PhraseCheckView, PhraseChoice, PhraseRecording, PhraseResultView, PhraseSegmentState, PhraseSurface, PhraseText, PhraseView, } from './types';
+export { leaveSurface, VoicePrompt, type PhraseDisplay, type PromptChange } from './prompt';
+export { PhraseCard, type HandedOverRows, type PromptCopy } from './phraseCard';
+export { VoiceRibbon, type VoiceCheckingStyle } from './ribbon';
+export { VoiceVisual } from './visual';

package/dist/types/card/phraseCard.d.ts

@@ -0,0 +1,72 @@
+import type { PhraseView } from './types';
+import type { VoicePrompt } from './prompt';
+export type PromptCopy = Readonly<{
+    label: string;
+    sentence: string;
+    message: string;
+    action: string;
+}>;
+/** What a card that takes another card's place shows at first: that card's rows. */
+export type HandedOverRows = Readonly<{
+    label: string;
+    message: string;
+}>;
+/** Draws the states of the phrase card. The surface owns the recording and the choices. */
+export declare class PhraseCard {
+    private readonly prompt;
+    private readonly copy;
+    private readonly line;
+    private readonly segments;
+    private readonly bar;
+    private readonly ring;
+    private readonly seal;
+    private readonly check;
+    private readonly motion;
+    private rows;
+    private states;
+    private rendering;
+    private morph;
+    private rotation;
+    private version;
+    private disposed;
+    constructor(prompt: VoicePrompt, copy: PromptCopy, handedOver?: HandedOverRows | null);
+    /** The sentence with Record, after a check or a result. The wave comes back. */
+    showPrompt(): Promise<void>;
+    /** The end of speech: the wave flattens and opens into segments, the first one filled. */
+    beginCheck(): void;
+    show(view: PhraseView): Promise<void>;
+    /** The line stays in the card, which fades out as a whole when its surface closes. */
+    dispose(): void;
+    /** A newer state supersedes any state still on its way in. */
+    private begin;
+    private stale;
+    private queue;
+    private promptRows;
+    /**
+     * Rows whose content changes fade out together; `apply` then writes the new state, the card
+     * takes its new height, the ribbon row glides to its new place, and the new rows fade in one
+     * after another.
+     */
+    private transition;
+    private markedText;
+    private detailNodes;
+    /** One line for the prompt; a caption and a detail line for the check and the result. */
+    private writeCaption;
+    private writeAction;
+    /** Changes the second caption line every 1.3 s and stays on the last line. */
+    private rotateDetails;
+    private swapDetail;
+    /** The flat line opens into six segments; the first stays filled, the rest turn to track. */
+    private openSegments;
+    /**
+     * Segments that finish fill one after another, 70 ms apart, and stop at a failed or held
+     * segment, which then shows its colour. Resolves when the result may follow.
+     */
+    private setSegments;
+    /** The segments fill, the gaps close, the line shrinks as the ring draws, then seal and check. */
+    private sealLine;
+    private resetLine;
+    private paintStates;
+    private layoutSegments;
+    private tween;
+}

package/dist/types/card/prompt.d.ts

@@ -0,0 +1,122 @@
+import type { VoiceCaptureEvent } from '../microphone';
+import type { VoiceCheckingStyle } from './ribbon';
+/** How the card shows a phrase: by default as it is, with a capital letter and a full stop. */
+export type PhraseDisplay = (phrase: string) => string;
+/** A new state of the card's rows. Rows that it leaves out keep their content. */
+export type PromptChange = Readonly<{
+    title?: string;
+    phrase?: string;
+    status?: string;
+    /** The record button's label, and whether it shows. */
+    action?: Readonly<{
+        label?: string;
+        hidden?: boolean;
+    }>;
+    /** Runs while the changing rows are out of sight, for state that goes with them. */
+    apply?: () => void;
+}>;
+export declare class VoicePrompt {
+    /** The text to show for a phrase, such as the phrase with its commas. */
+    private readonly display;
+    readonly element: HTMLElement;
+    readonly title: HTMLHeadingElement;
+    readonly phrase: HTMLParagraphElement;
+    readonly status: HTMLParagraphElement;
+    readonly record: HTMLButtonElement;
+    readonly cancel: HTMLButtonElement;
+    readonly progress: HTMLElement;
+    /** The wave under the phrase. */
+    readonly ribbon: SVGSVGElement;
+    /** The row of the record button, which a phrase card reuses for its action. */
+    readonly actionRow: HTMLElement;
+    private readonly microphone;
+    private microphoneRequested;
+    private readonly visual;
+    private disposed;
+    private pendingChange;
+    private changing;
+    /** The card has been laid out once, and has since been hidden (a Wallet confirm took its place). */
+    private laidOut;
+    private hidden;
+    private readonly sizes;
+    /** A newer resize stops the one in progress, and takes over what waits for it to end. */
+    private frameFill;
+    private readonly onFrameFitted;
+    constructor(document: Document, label: string, phrase: string, checking?: VoiceCheckingStyle, 
+    /** The text to show for a phrase, such as the phrase with its commas. */
+    display?: PhraseDisplay);
+    /**
+     * In an app's dialog with a step before this card, the corner control returns to that step.
+     * It still ends the card as cancelled; the Wallet tells the app that the person went back.
+     */
+    showBack(): void;
+    /**
+     * Moves the rows to a new state. The rows whose content changes fade out together, take their
+     * new content and fade in one after another; the other rows stay still. A change that comes
+     * during a fade joins it, so no state in between is drawn.
+     */
+    change(next: PromptChange): Promise<void>;
+    private readonly changesDrained;
+    private drainChanges;
+    /** The rows whose visible content `next` changes, top to bottom. */
+    private changingRows;
+    private rowOrder;
+    private writeChange;
+    /** The card is ready to record again, through a change of its rows. */
+    readyChange(message: string, next?: Omit<PromptChange, 'status'>): Promise<void>;
+    /** Starts without an entrance, because it takes another card's place. */
+    skipEntrance(): void;
+    /**
+     * In the Wallet iframe the parent eases the frame to every new card size. While the frame is
+     * taller than the card, the card fills it, so its edge follows the frame and never jumps; the
+     * surface around it keeps the card's own height, which is what the parent hears.
+     */
+    fillFrame(fromCssPx?: number, rows?: 'top' | 'center', onFitted?: () => void): void;
+    private readonly releaseRows;
+    private frameFitted;
+    /** The card's rows, top to bottom: everything but its glow, its close button and its download. */
+    private rows;
+    /** A Wallet confirm hid the card (wallet-service.css); when it shows again, its rows come back. */
+    private observeSize;
+    setPhrase(phrase: string): void;
+    readonly capture: (event: VoiceCaptureEvent) => void;
+    /**
+     * This card replaces `previous` in the same surface. It skips the entrance and starts with the
+     * rows that `previous` shows, so the swap does not show; the caller then changes the rows.
+     */
+    continueFrom(previous: Element): void;
+    /** Settle the visual when an enrollment sample is accepted. */
+    accepted(): void;
+    /** The wave rests flat while the glow keeps working. */
+    flattenLine(): void;
+    /** The glow settles. */
+    quietLine(): void;
+    /**
+     * Plays the unlock success in place and resolves when the check is drawn. Once
+     * the ring has formed it glides to the middle of `area` (the card by default).
+     */
+    succeed(headline: string, message: string, area?: SuccessArea): Promise<void>;
+    ready(message: string): void;
+    private readonly changeMicrophone;
+    private useSystemMicrophone;
+    dispose(): void;
+    /** The ribbon turns into the ring and the copy may change, so the card's rows hold their size. */
+    private lockLayout;
+    /**
+     * The ring has formed: the reading copy fades where it is, only the ring glides
+     * to the middle of the free space, and the success copy arrives in place around
+     * it, headline first. The rows keep their locked size throughout.
+     */
+    private beginSuccess;
+    private unlockLayout;
+}
+type SuccessArea = Readonly<{
+    top: number;
+    bottom: number;
+}>;
+/**
+ * A closed card fades out where it is, then goes. It leaves the layout at once, so a card or a
+ * confirm that comes next takes its place, and the frame never shows empty before it closes.
+ */
+export declare function leaveSurface(element: HTMLElement): void;
+export {};

package/dist/types/card/ribbon.d.ts

@@ -0,0 +1,62 @@
+import type { VoiceActivityEvent } from '../microphone';
+type RibbonPhase = 'idle' | 'listening' | 'processing';
+/** How the line shows that the voice is being checked. */
+export type VoiceCheckingStyle = 'ring' | 'segments';
+/** Visual feedback from recorder activity. Never opens or retains an audio stream. */
+export declare class VoiceRibbon {
+    private readonly checking;
+    readonly element: SVGSVGElement;
+    private readonly lines;
+    private readonly ripple;
+    private readonly track;
+    private readonly middle;
+    private readonly top;
+    private readonly bottom;
+    private readonly seal;
+    private readonly check;
+    private readonly motion;
+    private phase;
+    private stage;
+    private settleSuccess;
+    private successBegun;
+    private frame;
+    private previousTime;
+    private position;
+    private target;
+    private level;
+    private stopped;
+    constructor(document: Document, checking?: VoiceCheckingStyle);
+    readonly readLevel: () => number;
+    setPhase(phase: RibbonPhase): void;
+    /**
+     * Closes the ring into the success seal; resolves when the check is drawn.
+     * `begin` runs once the formed ring starts to close, after any capture in flight.
+     */
+    succeed(begin: () => void): Promise<void>;
+    add(event: VoiceActivityEvent): void;
+    dispose(): void;
+    private readonly awaitSuccess;
+    private settle;
+    private append;
+    private wake;
+    private readonly draw;
+    private idleAmplitude;
+    private paint;
+    private paintLine;
+    private paintSegments;
+    /** Each segment brightens one beat after the one before it, from the resting line's opacity. */
+    private segmentOpacity;
+    private paintCapture;
+    private paintJoin;
+    /** The auth menu ring's arc: it grows and shrinks on its own clock while the ring turns. */
+    private spinnerArc;
+    private beginSuccess;
+    private paintSuccess;
+    private paintSeal;
+    private paintArc;
+    private displacement;
+    private linePath;
+    /** The stroke between two distances on a half's capture track. */
+    private halfPath;
+}
+export {};