@seams/voiceid 0.0.0-stage → 0.24.0

package/dist/public/sdk/voiceid/unlock-E7YHqBGT.js

@@ -0,0 +1 @@
+import"./prompt-CCrXTRRx.js";import{a as e,n as t}from"./deviceBridge-wRAbqdap.js";import{f as n,o as r,s as i}from"./enrollment-DIRoCkx5.js";import{IndexedDBManager as a,fetchWithWalletHomeDiscovery as o,readAuthMethodEnabled as s}from"../voiceid-host.js";async function c(e){let{authMethod:t,challenge:n}=e;if(n.walletId!==t.walletId||n.walletAuthMethodId!==t.walletAuthMethodId||n.walletAuthorityId!==t.walletAuthorityId||n.deviceKeyId!==t.deviceKeyId)throw Error(`VoiceID challenge does not match the selected device method.`);let r=await e.capture({challenge:n,signal:e.signal,onCapture:e.onCapture,phrase:e.phrase});try{if(e.signal.aborted)throw Error(`VoiceID unlock was cancelled.`);let n=await e.http.verify({assertion:r.assertion,signal:e.signal});if(e.signal.aborted)throw Error(`VoiceID unlock was cancelled.`);if(n.walletSession.walletId!==t.walletId||n.walletSession.authMethodId!==t.walletAuthMethodId||n.walletSession.authorityId!==t.walletAuthorityId||n.custodyEnvelope.factor.deviceKeyId!==t.deviceKeyId)throw Error(`VoiceID server verified a different device method.`);return await e.install(n,r.factorSecret32)}finally{r.factorSecret32.fill(0)}}async function l(t,c,l){if(!await s(t.walletId,t.walletAuthMethodId))throw Error(`VoiceID is turned off in this browser. Enable it in Authentication methods.`);let u=await t.prepareSession(c),f=await a.getWalletAuthMethodV2(t.walletAuthMethodId);if(!f||f.kind!==`voiceid`||f.status!==`active`||f.walletId!==t.walletId||f.walletAuthMethodId!==t.walletAuthMethodId)throw Error(`Activate VoiceID on this device before unlocking this wallet.`);let p=new e(t.relayerUrl,location.origin,o);if(!await r(await i(t.walletId,t.walletAuthMethodId)))throw Error(`Unlock with a passkey, then open Manage voice to import or record your enrollment.`);await n(l),c.throwIfAborted(),t.assertActive();let m=await p.challenge({walletId:t.walletId,walletAuthMethodId:t.walletAuthMethodId,signal:AbortSignal.any([c,AbortSignal.timeout(15e3)])});t.assertActive();let h={authMethod:f,challenge:m,http:p,install:u};return c.throwIfAborted(),{kind:`recording`,expiresAtMs:m.expiresAtMs,action:d.bind(null,h)}}function u(e,t,n,r){return e({walletSession:n.walletSession,operationCredential:n.operationCredential,custodyEnvelope:n.custodyEnvelope,factorSecret32:r,signal:t,near:n.near})}async function d(e,n,r,i){return await c({authMethod:e.authMethod,challenge:e.challenge,http:e.http,capture:t,install:u.bind(null,e.install,n),signal:n,onCapture:r,phrase:i})}export{l as prepareUnlockSurface};

package/dist/public/sdk/voiceid/voice-activity-worklet.js

@@ -0,0 +1,21 @@
+class VoiceActivityFrames extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.frame = new Float32Array(512);
+    this.offset = 0;
+  }
+  process(inputs) {
+    const channel = inputs[0]?.[0];
+    if (!channel) return true;
+    for (const sample of channel) {
+      this.frame[this.offset++] = sample;
+      if (this.offset === 512) {
+        this.port.postMessage(this.frame, [this.frame.buffer]);
+        this.frame = new Float32Array(512);
+        this.offset = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('voice-activity-frames', VoiceActivityFrames);

package/dist/types/activation/addVoiceId.d.ts

@@ -0,0 +1,11 @@
+import type { PreparedVoiceCapture } from '../capture/surface';
+import type { RegistrationCapability, RegistrationWebContext } from '@seams/wallet/voiceid-host';
+import { type WalletId } from '@seams/wallet/voiceid-host';
+import type { Variant } from '@seams/wallet/voiceid-host';
+type AddVoiceIdResult = Variant<Awaited<ReturnType<RegistrationCapability['activateAuthMethod']>>, 'kind', 'activated'>;
+export declare function prepareActivationSurface(input: {
+    readonly context: RegistrationWebContext;
+    readonly walletId: WalletId;
+}, signal: AbortSignal): Promise<PreparedVoiceCapture<AddVoiceIdResult>>;
+export {};
+//# sourceMappingURL=addVoiceId.d.ts.map

package/dist/types/activation/manageEnrollment.d.ts

@@ -0,0 +1,4 @@
+import type { RegistrationWebContext } from '@seams/wallet/voiceid-host';
+import { type VoiceEnrollmentScope } from '../browser/enrollmentStore';
+export declare function manageVoiceEnrollment(context: RegistrationWebContext, scope: VoiceEnrollmentScope, signal: AbortSignal): Promise<void>;
+//# sourceMappingURL=manageEnrollment.d.ts.map

package/dist/types/activation/ownerConfirmation.d.ts

@@ -0,0 +1,17 @@
+import type { RegistrationWebContext } from '@seams/wallet/voiceid-host';
+import { type VoiceEnrollmentScope, type VoiceEnrollmentSnapshot, type VoiceChangeGuard, type VoiceActivationGuard } from '../browser/enrollmentStore';
+type VoiceChangeAction = 'replace' | 'improve' | 'reset' | 'import';
+export declare function prepareVoiceOwner(scope: VoiceEnrollmentScope, target: 'enrolled'): Promise<VoiceChangeGuard>;
+export declare function prepareVoiceOwner(scope: VoiceEnrollmentScope, target: 'activating'): Promise<VoiceActivationGuard>;
+/** A verified, single-use permission for one enrollment change, never for signing or unlock. */
+export declare class ConfirmedVoiceChange {
+    private readonly binding;
+    private readonly expiresAtMs;
+    private readonly assertCurrentOwner;
+    private consumed;
+    private constructor();
+    static request(context: RegistrationWebContext, scope: VoiceEnrollmentScope, guard: VoiceChangeGuard, snapshot: VoiceEnrollmentSnapshot, action: VoiceChangeAction, signal: AbortSignal): Promise<ConfirmedVoiceChange>;
+    consume(scope: VoiceEnrollmentScope, guard: VoiceChangeGuard, snapshot: VoiceEnrollmentSnapshot, action: VoiceChangeAction, signal: AbortSignal): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ownerConfirmation.d.ts.map

package/dist/types/browser/deviceStore.d.ts

@@ -0,0 +1,19 @@
+import { parseVoiceIdDevicePublicKeyB64u } from '@seams/wallet/voiceid-host';
+import { type DigestB64u } from '@seams/wallet/voiceid-host';
+import type { WalletId, WalletAuthMethodId } from '@seams/wallet/voiceid-host';
+export type BrowserVoiceDevice = Readonly<{
+    kind: 'browser_voiceid_device_v1';
+    walletId: WalletId;
+    walletAuthMethodId: WalletAuthMethodId;
+    privateKey: CryptoKey;
+    publicKeyB64u: ReturnType<typeof parseVoiceIdDevicePublicKeyB64u>;
+    deviceKeyId: DigestB64u;
+    wrappingKey: CryptoKey;
+    nonce: Uint8Array<ArrayBuffer>;
+    ciphertext: ArrayBuffer;
+}>;
+export declare function deviceKey(walletId: WalletId, methodId: WalletAuthMethodId): string;
+export declare function readBrowserVoiceDevice(walletId: WalletId, methodId: WalletAuthMethodId): Promise<BrowserVoiceDevice | null>;
+export declare function createBrowserVoiceDevice(walletId: WalletId, methodId: WalletAuthMethodId): Promise<BrowserVoiceDevice>;
+export declare function openBrowserVoiceFactor(device: BrowserVoiceDevice): Promise<Uint8Array<ArrayBuffer>>;
+//# sourceMappingURL=deviceStore.d.ts.map

package/dist/types/browser/enrollment.d.ts

@@ -0,0 +1,37 @@
+import { type SpokenPhrase } from './phrase';
+import { type VoiceCaptureQuality, type VoiceCaptureObserver } from './microphone';
+import { type VoiceEnrollmentScope, type VoiceEnrollmentSnapshot, type VoiceOwnerGuard, type VoiceTemplateAccess } from './enrollmentStore';
+import type { ConfirmedVoiceChange } from '../activation/ownerConfirmation';
+import type { Variant } from '@seams/wallet/voiceid-host';
+type EnrollmentCapturePlan = {
+    readonly scope: VoiceEnrollmentScope;
+    readonly guard: VoiceOwnerGuard;
+} & ({
+    readonly kind: 'activate';
+    readonly snapshot: {
+        readonly kind: 'missing';
+    };
+    readonly confirmation?: never;
+} | {
+    readonly kind: 'replace';
+    readonly snapshot: VoiceEnrollmentSnapshot;
+    readonly confirmation: ConfirmedVoiceChange;
+} | {
+    readonly kind: 'improve';
+    readonly snapshot: Variant<VoiceEnrollmentSnapshot, 'kind', 'present'>;
+    readonly confirmation: ConfirmedVoiceChange;
+});
+export declare function enrollBrowserVoice(plan: EnrollmentCapturePlan, signal: AbortSignal): Promise<void>;
+export declare function verifyBrowserVoice(access: VoiceTemplateAccess, signal: AbortSignal, onCapture: VoiceCaptureObserver, phrase: SpokenPhrase): Promise<{
+    kind: 'matched';
+} | {
+    kind: 'mismatch';
+    quality: VoiceCaptureQuality;
+} | {
+    kind: 'phrase_mismatch';
+} | {
+    kind: 'insufficient_audio';
+    quality: VoiceCaptureQuality;
+}>;
+export {};
+//# sourceMappingURL=enrollment.d.ts.map

package/dist/types/browser/enrollmentStore.d.ts

@@ -0,0 +1,91 @@
+import type { Variant } from '@seams/wallet/voiceid-host';
+import type { WalletId, WalletAuthMethodId, WalletAuthorityId } from '@seams/wallet/voiceid-host';
+import type { DigestB64u } from '@seams/wallet/voiceid-host';
+import type { WalletSessionId } from '@seams/wallet/voiceid-host';
+import { type BrowserVoiceDevice } from './deviceStore';
+import type { ConfirmedVoiceChange } from '../activation/ownerConfirmation';
+export type VoiceEnrollmentScope = Readonly<{
+    walletId: WalletId;
+    authorityId: WalletAuthorityId;
+    walletAuthMethodId: WalletAuthMethodId;
+    deviceKeyId: DigestB64u;
+}>;
+export type VoiceEnrollment = Readonly<{
+    kind: 'browser_voiceid_enrollment_v2';
+    scope: VoiceEnrollmentScope;
+    model: string;
+    generation: string;
+    revision: number;
+    baseline: readonly number[];
+    adaptation: {
+        readonly kind: 'baseline';
+        readonly samples?: never;
+    } | {
+        readonly kind: 'adapted';
+        readonly samples: readonly (readonly number[])[];
+    };
+}>;
+export type VoiceEnrollmentSnapshot = {
+    readonly kind: 'missing';
+    readonly enrollment?: never;
+} | {
+    readonly kind: 'present';
+    readonly enrollment: VoiceEnrollment;
+};
+export type VoiceOwnerGuard = Readonly<{
+    sessionMethodId: WalletAuthMethodId;
+    walletSessionId: WalletSessionId;
+    lockGeneration: number;
+    expiresAtMs: number;
+    availabilityRevision: string;
+} & ({
+    target: 'activating';
+    confirmationMethodId?: never;
+} | {
+    target: 'enrolled';
+    confirmationMethodId: WalletAuthMethodId;
+})>;
+export type VoiceChangeGuard = Variant<VoiceOwnerGuard, 'target', 'enrolled'>;
+export type VoiceActivationGuard = Variant<VoiceOwnerGuard, 'target', 'activating'>;
+export declare function voiceEnrollmentScope(device: BrowserVoiceDevice, authorityId: WalletAuthorityId): VoiceEnrollmentScope;
+export declare function resolveVoiceEnrollmentScope(walletId: WalletId, methodId: WalletAuthMethodId): Promise<VoiceEnrollmentScope>;
+export declare function readVoiceEnrollment(scope: VoiceEnrollmentScope): Promise<VoiceEnrollment | null>;
+export declare function readImportableVoiceBaseline(): Promise<readonly number[] | null>;
+export declare function assertVoiceOwner(scope: VoiceEnrollmentScope, guard: VoiceOwnerGuard): Promise<void>;
+export type VoiceTemplateAccess = {
+    readonly kind: 'active';
+    readonly scope: VoiceEnrollmentScope;
+    readonly owner?: never;
+} | {
+    readonly kind: 'activation';
+    readonly scope: VoiceEnrollmentScope;
+    readonly owner: VoiceOwnerGuard;
+};
+export declare function readVoiceTemplate(access: VoiceTemplateAccess, signal: AbortSignal): Promise<{
+    template: number[];
+    baseline: number[];
+    kind: 'baseline' | 'adapted';
+}>;
+export type VoiceEnrollmentChange = {
+    readonly kind: 'activate';
+    readonly baseline: readonly number[];
+    readonly samples?: never;
+    readonly confirmation?: never;
+} | {
+    readonly kind: 'replace' | 'import';
+    readonly baseline: readonly number[];
+    readonly samples?: never;
+    readonly confirmation: ConfirmedVoiceChange;
+} | {
+    readonly kind: 'improve';
+    readonly samples: readonly (readonly number[])[];
+    readonly baseline?: never;
+    readonly confirmation: ConfirmedVoiceChange;
+} | {
+    readonly kind: 'reset';
+    readonly samples?: never;
+    readonly baseline?: never;
+    readonly confirmation: ConfirmedVoiceChange;
+};
+export declare function commitVoiceEnrollment(scope: VoiceEnrollmentScope, guard: VoiceOwnerGuard, snapshot: VoiceEnrollmentSnapshot, change: VoiceEnrollmentChange, signal: AbortSignal): Promise<void>;
+//# sourceMappingURL=enrollmentStore.d.ts.map

package/dist/types/browser/inference.d.ts

@@ -0,0 +1,39 @@
+import type { InferenceSession } from 'onnxruntime-web';
+type ModelAsset = Readonly<{
+    path: string;
+    sha256: string;
+    bytes: number;
+    label: string;
+}>;
+export type VoiceAssetProgress = {
+    kind: 'checking_cache';
+} | {
+    kind: 'downloading';
+    received: number;
+} | {
+    kind: 'ready';
+};
+declare class BrowserInferenceAsset {
+    private readonly asset;
+    private pending;
+    private progress;
+    private readonly listeners;
+    constructor(asset: ModelAsset);
+    get size(): number;
+    download(onProgress?: (progress: VoiceAssetProgress) => void): Promise<ArrayBuffer>;
+    private readonly failed;
+    private publish;
+    private valid;
+    private bytes;
+}
+export declare const voiceInferenceEngine: BrowserInferenceAsset;
+export declare class BrowserInferenceModel {
+    readonly asset: BrowserInferenceAsset;
+    private session;
+    constructor(asset: ModelAsset);
+    prepare(): Promise<InferenceSession>;
+    private readonly failed;
+    private load;
+}
+export {};
+//# sourceMappingURL=inference.d.ts.map

package/dist/types/browser/microphone.d.ts

@@ -0,0 +1,61 @@
+/** One 32 ms frame as the recorder judged it. No capture event carries the stream. */
+export type VoiceActivityEvent = Readonly<{
+    kind: 'activity';
+    rms: number;
+    /** The voice activity model and the level check both found speech. */
+    speech: boolean;
+    stream?: never;
+}>;
+export type VoiceCaptureEvent = {
+    readonly kind: 'listening';
+    readonly stream?: never;
+} | VoiceActivityEvent | {
+    readonly kind: 'processing';
+    readonly stream?: never;
+} | {
+    readonly kind: 'measured';
+    readonly quality: VoiceCaptureQuality;
+    readonly stream?: never;
+};
+export type VoiceCaptureObserver = (event: VoiceCaptureEvent) => void;
+export type VoiceCaptureQuality = Readonly<{
+    attemptId: string;
+    capturedAtMs: number;
+    durationMs: number;
+    recordingMs: number;
+    endedBy: 'pause' | 'limit' | 'stream_ended';
+    voicedMs: number;
+    peakFrameRms: number;
+    levelThreshold: number;
+    requiredVoicedMs: number;
+    microphone: string;
+    processing: Readonly<{
+        noiseSuppression: boolean | null;
+        echoCancellation: boolean | string | null;
+        autoGainControl: boolean | null;
+        sampleRate: number | null;
+    }>;
+    backgroundRms: number;
+    speechToBackgroundDb: number | null;
+    noise: 'high' | 'normal' | 'unknown';
+}>;
+type VoiceRecordingResult = {
+    kind: 'captured';
+    samples: Float32Array;
+    quality: VoiceCaptureQuality;
+} | {
+    kind: 'insufficient_audio';
+    quality: VoiceCaptureQuality;
+    samples?: never;
+};
+export declare function voiceQualityMessage(quality: VoiceCaptureQuality): string;
+/** Carries a typed capture rejection across the SDK's exception-based UI action boundary. */
+export declare class InsufficientVoiceAudioError extends Error {
+    readonly quality: VoiceCaptureQuality;
+    constructor(quality: VoiceCaptureQuality);
+}
+export declare function requireVoiceUserAction(): void;
+export declare function requireVoiceForeground(): void;
+export declare function recordVoice(signal: AbortSignal, onCapture: VoiceCaptureObserver): Promise<VoiceRecordingResult>;
+export {};
+//# sourceMappingURL=microphone.d.ts.map

package/dist/types/browser/model.d.ts

@@ -0,0 +1,8 @@
+import { BrowserInferenceModel } from './inference';
+export declare const VOICE_MODEL_ID = "redimnet-b1:e04dd7a6a1e23fc7b89e47682ea9d0a3946cf7bc59d07922c3db3efc52ae4269";
+export declare const VOICE_MATCH_THRESHOLD = 0.5;
+export declare const voiceModel: BrowserInferenceModel;
+export declare function voiceEmbedding(samples: Float32Array): Promise<number[]>;
+export declare function normalizeVoiceVector(values: readonly number[]): number[];
+export declare function voiceSimilarity(left: readonly number[], right: readonly number[]): number;
+//# sourceMappingURL=model.d.ts.map

package/dist/types/browser/phrase.d.ts

@@ -0,0 +1,35 @@
+import { BrowserInferenceModel } from './inference';
+import { SPOKEN_PHRASES } from './phraseVocabulary';
+export type SpokenPhrase = (typeof SPOKEN_PHRASES)[number];
+export declare const phraseModel: BrowserInferenceModel;
+export declare function newSpokenPhrase(previous: SpokenPhrase | null): SpokenPhrase;
+type PhraseRecognition = {
+    kind: 'recognized';
+    phrase: SpokenPhrase;
+    difference: number;
+    margin: number;
+    decodedText: string;
+} | {
+    kind: 'uncertain';
+    candidate: SpokenPhrase;
+    difference: number;
+    margin: number;
+    decodedText: string;
+    reason: 'different' | 'ambiguous' | 'negated';
+} | {
+    kind: 'empty';
+};
+/** A local phrase rejection can retry while the original server challenge is valid. */
+export declare class VoicePhraseMismatchError extends Error {
+    constructor();
+}
+export type PhraseCheck = {
+    kind: 'matched';
+    recognition: PhraseRecognition;
+} | {
+    kind: 'mismatch';
+    recognition: PhraseRecognition;
+};
+export declare function checkSpokenPhrase(samples: Float32Array, expected: SpokenPhrase): Promise<PhraseCheck>;
+export {};
+//# sourceMappingURL=phrase.d.ts.map

package/dist/types/browser/phraseVocabulary.d.ts

@@ -0,0 +1,3 @@
+export declare const SPOKEN_PHRASES: readonly ["please sign this trade now", "confirm my order for today", "i review every order carefully", "dump on them slowly", "send this order to market", "i'm here for the tech", "keep this trade on track", "the order book looks busy", "if you panic panic early", "i check the latest quote", "exit liquidity for all passengers", "no crying in the casino", "this trade fits my plan", "approve this transfer at once", "check the price before trading", "let this trade go through"];
+export declare const PHRASE_TOKEN_PIECES: readonly string[];
+//# sourceMappingURL=phraseVocabulary.d.ts.map

package/dist/types/browser/progress.d.ts

@@ -0,0 +1,2 @@
+export declare function prepareVoiceModelWithProgress(parent: HTMLElement): Promise<void>;
+//# sourceMappingURL=progress.d.ts.map

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

@@ -0,0 +1,63 @@
+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 {};
+//# sourceMappingURL=ribbon.d.ts.map

package/dist/types/browser/verificationError.d.ts

@@ -0,0 +1,6 @@
+import type { VoiceCaptureQuality } from './microphone';
+/** Keeps a local speaker rejection retryable without changing server authorization. */
+export declare class VoiceSpeakerMismatchError extends Error {
+    constructor(quality: VoiceCaptureQuality);
+}
+//# sourceMappingURL=verificationError.d.ts.map

package/dist/types/browser/voiceActivity.d.ts

@@ -0,0 +1,15 @@
+import { BrowserInferenceModel } from './inference';
+import type { InferenceSession } from 'onnxruntime-web';
+export declare const voiceActivityModel: BrowserInferenceModel;
+export declare function createVoiceActivity(): Promise<VoiceActivity>;
+declare class VoiceActivity {
+    private readonly session;
+    private readonly ort;
+    private readonly state;
+    private readonly context;
+    constructor(session: InferenceSession, ort: typeof import('onnxruntime-web/wasm'));
+    probability(frame: Float32Array): Promise<number>;
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=voiceActivity.d.ts.map

package/dist/types/capture/approval.d.ts

@@ -0,0 +1,36 @@
+import type { AuthMethodApprovalResult } from '@seams/wallet/voiceid-host';
+import type { ParentToChildEnvelope } from '@seams/wallet/voiceid-host';
+import { type ConfiguredWalletHost } from '@seams/wallet/voiceid-host';
+import { type TransactionReviewWire } from '@seams/wallet/voiceid-host';
+import type { WalletId } from '@seams/wallet/voiceid-host';
+export type VoiceIdPolicy = {
+    readonly kind: 'disabled';
+    readonly approval?: never;
+} | {
+    readonly kind: 'required';
+    readonly approval: VoiceIdApproval;
+};
+export declare function voiceIdPolicyForRequest(request: ParentToChildEnvelope, configuration: ConfiguredWalletHost): Promise<VoiceIdPolicy>;
+export declare class VoiceIdApproval {
+    private readonly reviewExpiresAtMs;
+    private readonly operationHash;
+    private readonly walletId;
+    private phrase;
+    private readonly prompt;
+    readonly surface: HTMLElement;
+    get messages(): {
+        confirm: string;
+        approved: string;
+    };
+    private state;
+    private constructor();
+    static forReview(review: TransactionReviewWire, operationHash: string, walletId: WalletId): VoiceIdApproval;
+    approve(signal: AbortSignal): Promise<AuthMethodApprovalResult>;
+    /** Binds one listening attempt to the operation and to what remains of the review. */
+    private beginAttempt;
+    /** Resolves when the person selects Try again; rejects when the review closes or expires. */
+    private waitForRetry;
+    consume(): void;
+    private assertListening;
+}
+//# sourceMappingURL=approval.d.ts.map

package/dist/types/capture/bridge.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceCaptureObserver } from '../browser/microphone';
+import { type SpokenPhrase } from '../browser/phrase';
+import type { AuthMethodApprovalResult } from '@seams/wallet/voiceid-host';
+import type { VoiceEnrollmentScope } from '../browser/enrollmentStore';
+export type VoiceBinding = Readonly<{
+    attemptId: string;
+    operationHash: string;
+    expiresAtMs: number;
+}>;
+export declare function sameVoiceBinding(left: VoiceBinding, right: VoiceBinding): boolean;
+export declare function listenForVoiceApproval(scope: VoiceEnrollmentScope, binding: VoiceBinding, timeoutMs: number, signal: AbortSignal, onCapture: VoiceCaptureObserver, phrase: SpokenPhrase): Promise<AuthMethodApprovalResult>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/types/capture/deviceBridge.d.ts

@@ -0,0 +1,29 @@
+import type { VoiceCaptureObserver } from '../browser/microphone';
+import { type SpokenPhrase } from '../browser/phrase';
+import { type VoiceIdWalletSessionChallenge } from '@seams/wallet/voiceid-host';
+import type { WalletId, WalletAuthMethodId } from '@seams/wallet/voiceid-host';
+import type { VoiceIdDeviceAssertion, VoiceIdDevicePublicKeyB64u } from '@seams/wallet/voiceid-host';
+import type { DigestB64u } from '@seams/wallet/voiceid-host';
+export declare function captureVoiceIdActivation(input: {
+    readonly walletId: WalletId;
+    readonly walletAuthMethodId: WalletAuthMethodId;
+    readonly signal: AbortSignal;
+    readonly onCapture: VoiceCaptureObserver;
+    readonly phrase: SpokenPhrase;
+}): Promise<{
+    kind: 'activated';
+    publicKeyB64u: VoiceIdDevicePublicKeyB64u;
+    deviceKeyId: DigestB64u;
+    factorSecret32: Uint8Array;
+}>;
+export declare function captureVoiceIdUnlock(input: {
+    readonly challenge: VoiceIdWalletSessionChallenge;
+    readonly signal: AbortSignal;
+    readonly onCapture: VoiceCaptureObserver;
+    readonly phrase: SpokenPhrase;
+}): Promise<{
+    kind: 'unlocked';
+    assertion: VoiceIdDeviceAssertion;
+    factorSecret32: Uint8Array;
+}>;
+//# sourceMappingURL=deviceBridge.d.ts.map

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

@@ -0,0 +1,41 @@
+import type { SpokenPhrase } from '../browser/phrase';
+import type { VoiceCaptureEvent } from '../browser/microphone';
+import type { VoiceCheckingStyle } from '../browser/ribbon';
+export declare class VoicePrompt {
+    readonly element: HTMLElement;
+    readonly title: HTMLHeadingElement;
+    readonly phrase: HTMLParagraphElement;
+    readonly status: HTMLParagraphElement;
+    readonly record: HTMLButtonElement;
+    readonly cancel: HTMLButtonElement;
+    readonly progress: HTMLElement;
+    private readonly visual;
+    private disposed;
+    constructor(document: Document, label: string, phrase: SpokenPhrase, checking?: VoiceCheckingStyle);
+    setPhrase(phrase: SpokenPhrase): void;
+    readonly capture: (event: VoiceCaptureEvent) => void;
+    /** Settle the visual when an enrollment sample is accepted. */
+    accepted(): 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;
+    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;
+}>;
+export {};
+//# sourceMappingURL=prompt.d.ts.map

package/dist/types/capture/surface.d.ts

@@ -0,0 +1,27 @@
+import type { AuthMethodCaptureMount } from '@seams/wallet/voiceid-host';
+import type { UiConfirmSurfaceMeasurementBinding } from '@seams/wallet/voiceid-host';
+import { type SpokenPhrase } from '../browser/phrase';
+import { type VoiceCaptureObserver } from '../browser/microphone';
+type CaptureAction<T> = (signal: AbortSignal, onCapture: VoiceCaptureObserver, phrase: SpokenPhrase) => Promise<T>;
+type PreparedRecording<T> = Readonly<{
+    kind: 'recording';
+    action: CaptureAction<T>;
+    expiresAtMs: number | null;
+}>;
+export type PreparedVoiceCapture<T> = PreparedRecording<T> | Readonly<{
+    kind: 'management';
+    action: (signal: AbortSignal) => Promise<T>;
+    expiresAtMs?: never;
+}>;
+type CapturePreparation<T> = (signal: AbortSignal, parent: HTMLElement) => Promise<PreparedVoiceCapture<T>>;
+export declare class VoiceIdCaptureCancelledError extends Error {
+    constructor();
+}
+export declare function showVoiceIdCaptureSurface<T>(input: {
+    readonly prepare: CapturePreparation<T>;
+    readonly purpose: 'activation' | 'unlock';
+    readonly measurement: UiConfirmSurfaceMeasurementBinding;
+    readonly mountCapture?: AuthMethodCaptureMount;
+}): Promise<T>;
+export {};
+//# sourceMappingURL=surface.d.ts.map

package/dist/types/capture/unlockFrame.d.ts

@@ -0,0 +1,13 @@
+import type { VoicePrompt } from './prompt';
+export declare class VoiceUnlockFrame {
+    private readonly prompt;
+    private readonly footer;
+    constructor(element: HTMLElement, prompt: VoicePrompt);
+    /** After an unlock the back control cannot act, so it fades and the success centers under the origin. */
+    succeed(): Readonly<{
+        top: number;
+        bottom: number;
+    }>;
+    dispose(): void;
+}
+//# sourceMappingURL=unlockFrame.d.ts.map

package/dist/types/capture/visual.d.ts

@@ -0,0 +1,24 @@
+import type { VoiceActivityEvent } from '../browser/microphone';
+import { type VoiceCheckingStyle } from '../browser/ribbon';
+/** Shared by enrollment, unlock and signing. The recorder remains the only audio owner. */
+export declare class VoiceVisual {
+    readonly element: SVGSVGElement;
+    readonly glow: HTMLDivElement;
+    private readonly ribbon;
+    private readonly prompt;
+    private readonly themeObserver;
+    private phase;
+    private disposed;
+    constructor(document: Document, prompt: HTMLElement, checking: VoiceCheckingStyle);
+    listen(): void;
+    add(event: VoiceActivityEvent): void;
+    checking(): void;
+    accept(): void;
+    ready(): void;
+    /** The glow settles while the ribbon closes into the success seal; resolves when the check is drawn. */
+    succeed(begin: () => void): Promise<void>;
+    stop(): void;
+    private setPhase;
+    private readonly render;
+}
+//# sourceMappingURL=visual.d.ts.map