@baas-id/react 0.2.3 → 0.3.0

package/dist/types/continue.d.ts

@@ -1,3 +1,3 @@
 export { ContinueFlow, readHandoffCode, type ContinueFlowProps } from "./react/handoff/ContinueFlow";
 export { DEFAULT_MODELS_URL, MODELS_VERSION } from "./react/vision/modelsCdn";
-export { getStrings, LOCALES, type Locale, type Strings, type StringOverrides } from "./react/i18n";
+export { getStrings, LOCALES, type Locale, type Strings, type StringOverrides, type Formality } from "./react/i18n";

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export { EnrollmentFlow, SignInFlow, ReverificationFlow, IdentifyFlow, normalizeSession, captureNonceOf, type ApiSessionBody, type EnrollmentFlowProps, type SignInFlowProps, type ReverificationFlowProps, type IdentifyFlowProps, type Purpose, type IdentifyCandidate, type DuplicateCandidate, type VerificationFlowProps, type RpidSession, type SessionFlow, type VerificationResult, type VerificationAssessment, type DocumentAuthenticity, type RpidFlowEvent, type ExtractionRecord, type ExtractionField, type Appearance, type TenantInstructions, type TenantMessages, type SessionHandoff, type HandoffOption, } from "./react/flows";
+export type { ColorScheme } from "./react/theme/scheme";
 export { ContinueOnPhone, HandoffPanel, HandoffView, type ContinueOnPhoneProps, type HandoffMode, type HandoffCopy, } from "./react/handoff/ContinueOnPhone";
 export { ContinueFlow, readHandoffCode, type ContinueFlowProps } from "./react/handoff/ContinueFlow";
 export { createHandoff, handoffStatus, revokeHandoff, peekHandoff, claimHandoff, type HandoffCode, type HandoffStatus, type HandoffPhase, type HandoffPeek, } from "./react/handoff/api";
@@ -15,5 +16,4 @@ export { webAttestation, nativeAttestation, requestHash, type AttestationProvide
 export { preload, loadDocumentEngine, loadFaceEngine, cropQuality, DEFAULT_DETECTOR, type DetectorChoice, DEFAULT_MODELS_URL, MODELS_VERSION, modelsUrlOf, specularSignature, gridPeriodicity, cornerRadius, type PixelData, type CropSample, type CardOutline, type SpecularSignature, type CardDetection, type SideResult, type CropQuality, type FaceCentering, type EngineProgress, type ProgressFn, } from "./react/vision";
 export { EngineLoading, ProcessingOverlay, ProximityMeter, TurnGauge, YawDial, turnGaugeFrom, } from "./react/capture";
 export { proximityOf, distanceHintOf, distanceTrackPos, centeringFrom, centerBlocker, YAW_TARGET, CENTER_MIN, CONTAIN_MIN, FACE_W_MIN, FACE_W_MAX, FACE_W_COMFORT_MIN, FACE_W_COMFORT_MAX, faceWidthOf, type Proximity, type CenterBlocker, } from "./react/liveness";
-export { getStrings, reasonEntry, resolveLocale, browserLocale, DEFAULT_LOCALE, LOCALES, type Locale, type Strings, type StringOverrides, type Reason, type ClientReason, type ServerReason, type ReasonEntry, type Recovery, type GuideKey, type EngineStage, type DistanceHint, } from "./react/i18n";
-export { meshBenchmark, type MeshBench } from "./react/face/meshBench";
+export { getStrings, reasonEntry, resolveLocale, browserLocale, DEFAULT_LOCALE, LOCALES, formalityOverrides, ES_FORMAL, type Formality, type Locale, type Strings, type StringOverrides, type Reason, type ClientReason, type ServerReason, type ReasonEntry, type Recovery, type GuideKey, type EngineStage, type DistanceHint, } from "./react/i18n";

package/dist/types/preview.d.ts

@@ -1,5 +1,6 @@
 export { FlowPreview, type FlowPreviewProps, type PreviewScreen, type PreviewChallenge, type PreviewHandoff, } from "./react/preview/FlowPreview";
 export { appearanceStyle, appearanceGroups, FONT_STACKS, SDK_DEFAULTS, type Appearance, type ColorKey, type SafeFont, } from "./react/theme/appearance";
+export { darkPalette, liftOn, DARK, type ColorScheme } from "./react/theme/scheme";
 export { contrastChecks, contrastRatio, DEFAULT_COLORS, DEFAULT_RADIUS, CONTRAST_PAIRS, type ContrastCheck, } from "./react/preview/contrast";
 export { parseIntroBody, introFor, type TenantInstructions, type TenantMessages } from "./react/flows/experience";
-export { getStrings, LOCALES, type Locale, type Strings } from "./react/i18n";
+export { getStrings, LOCALES, type Locale, type Strings, type Formality } from "./react/i18n";

package/dist/types/react/DocumentCapture.d.ts

@@ -19,6 +19,7 @@ export interface DocumentCaptureProps {
     documentFrames?: number;
     captureNonce?: string | null;
     confirmCapture?: boolean;
+    flip?: boolean;
     detector?: "tiny" | "legacy";
     onCaptured: (serverResult: unknown, thumbnailDataUrl?: string) => void;
     onRejected?: (reason: string, detail?: unknown) => void;

package/dist/types/react/capture/api.d.ts

@@ -3,7 +3,12 @@ export interface RpidClientConfig {
     apiUrl: string;
     sessionId: string;
     captureToken: string;
+    locale?: string;
+    formality?: "formal" | "informal";
 }
+export declare function apiHeaders(cfg: Pick<RpidClientConfig, "captureToken" | "locale" | "formality">): Record<string, string>;
+export declare function langHeaders(locale?: string, formality?: "formal" | "informal"): Record<string, string>;
+export declare const withLanguage: (cfg: RpidClientConfig, locale?: string, formality?: "formal" | "informal") => RpidClientConfig;
 export type Json = Record<string, unknown>;
 export interface CaptureUpload {
     side?: "front" | "back";
@@ -19,6 +24,18 @@ export declare function uploadCaptureSignal(cfg: RpidClientConfig, kind: "docume
 export declare function uploadCapture(cfg: RpidClientConfig, kind: "document" | "face", blob: Blob, side?: "front" | "back", meta?: Record<string, unknown>, mrzReadings?: string[]): Promise<any>;
 export declare function finalizeSessionSignal(cfg: RpidClientConfig, signal?: AbortSignal): Promise<any>;
 export declare function finalizeSession(cfg: RpidClientConfig): Promise<any>;
+export interface MrzLayout {
+    rotation: 0 | 180;
+    orientation_source?: "mrz" | null;
+    type?: string | null;
+    image: [number, number];
+    box: number[] | null;
+    lines: number[][];
+    fields: Record<string, {
+        box: number[];
+        valid: boolean | null;
+    }>;
+}
 export interface MrzProbe {
     available: boolean;
     mrz: {
@@ -31,6 +48,7 @@ export interface MrzProbe {
         checks?: Record<string, boolean>;
         failed?: string[];
         fields?: Record<string, string | null>;
+        layout?: MrzLayout | null;
     };
     screen?: {
         available: boolean;

package/dist/types/react/capture/camera.d.ts

@@ -1,4 +1,5 @@
 export type CameraProfile = "default" | "document";
 export declare function cameraConstraints(facing: "environment" | "user", profile: CameraProfile): MediaTrackConstraints;
+export declare function parkCamera(stream: MediaStream, facing: "environment" | "user", profile: CameraProfile, graceMs?: number): void;
 export declare function openCamera(video: HTMLVideoElement, facing?: "environment" | "user", profile?: CameraProfile): Promise<MediaStream>;
 export declare function stopStream(stream: MediaStream | null | undefined): void;

package/dist/types/react/capture/debugCapture.d.ts

@@ -0,0 +1,31 @@
+import { type RpidClientConfig } from "./api";
+export interface DebugCaptureStatus {
+    enabled: boolean;
+    max_fps?: number;
+    long_side?: number;
+    quality?: number;
+}
+export declare function debugCaptureOf(cfg: RpidClientConfig): Promise<DebugCaptureStatus>;
+export declare function resetDebugCapture(): void;
+type Meta = Record<string, unknown>;
+export declare class DebugRecorder {
+    private cfg;
+    private step;
+    private t0;
+    private status;
+    private last;
+    private seq;
+    private inflight;
+    private scratch;
+    readonly ready: Promise<void>;
+    constructor(cfg: RpidClientConfig | null, step: "front" | "back" | "face", t0?: number);
+    get on(): boolean;
+    offer(source: CanvasImageSource & {
+        width?: number;
+        height?: number;
+        videoWidth?: number;
+        videoHeight?: number;
+    }, meta: Meta, now?: number, force?: boolean): void;
+}
+export declare const r2: (v: number | null | undefined, d?: number) => number | null;
+export {};

package/dist/types/react/capture/debugLog.d.ts

@@ -0,0 +1,25 @@
+import { type RpidClientConfig } from "./api";
+export type DebugEntry = Record<string, string | number | boolean | null | Array<string | number | null>>;
+export declare function scrub(s: unknown, max?: number): string;
+declare class DebugLog {
+    private cfg;
+    private queue;
+    private sent;
+    private seq;
+    private timer;
+    private undo;
+    private t0;
+    get on(): boolean;
+    start(cfg: RpidClientConfig): Promise<boolean>;
+    stop(): void;
+    add(e: DebugEntry): void;
+    perf(step: string, data: Record<string, number | string | null>): void;
+    camera(step: string, track: MediaStreamTrack | null | undefined): void;
+    flush(beacon: boolean): void;
+    private realFetch;
+    private hookConsole;
+    private hookErrors;
+    private hookFetch;
+}
+export declare const debugLog: DebugLog;
+export {};

package/dist/types/react/capture/index.d.ts

@@ -1,5 +1,5 @@
-export { uploadCapture, finalizeSession, probeDocument, uploadCaptureSignal, finalizeSessionSignal, probeDocumentSignal, errorCode, isAbort, rejectionOf, authenticityOf, type RpidClientConfig, type MrzProbe, type CaptureUpload, type Rejection, type DocumentAuthenticity, } from "./api";
-export { openCamera, stopStream, cameraConstraints, type CameraProfile } from "./camera";
+export { uploadCapture, finalizeSession, probeDocument, uploadCaptureSignal, finalizeSessionSignal, probeDocumentSignal, errorCode, isAbort, rejectionOf, authenticityOf, apiHeaders, langHeaders, withLanguage, type RpidClientConfig, type MrzProbe, type MrzLayout, type CaptureUpload, type Rejection, type DocumentAuthenticity, } from "./api";
+export { openCamera, parkCamera, stopStream, cameraConstraints, type CameraProfile } from "./camera";
 export { analyzeFrame, moireProbe, grabFrame, canvasToJpeg, thumbnailOf, readPixels, haptic, type Quality, type ProbeRegion, } from "./frames";
 export { demoDocumentFrame, demoFaceFrame } from "./demo";
 export { createCaptureRun, frameLoop, nextFrame, type CaptureRun, type TickResult } from "./run";

package/dist/types/react/document/DocumentParts.d.ts

@@ -24,6 +24,10 @@ export declare function CaptureReview({ image, aspect, review, t, confirm, outli
     confirm?: boolean;
     outline?: CardInset | null;
 }): import("react").JSX.Element;
+export declare function MrzOverlay({ mrz, t }: {
+    mrz: NonNullable<Review["mrz"]>;
+    t: Strings;
+}): import("react").JSX.Element;
 export declare function ReviewSheet({ review, t, confirm }: {
     review: Review;
     t: Strings;

package/dist/types/react/document/cornerOrder.d.ts

@@ -0,0 +1,38 @@
+import type { Quad } from "../vision/corners";
+export declare function signedArea(q: Quad): number;
+export declare const rotateQuad: (q: Quad, k: number) => Quad;
+export declare function canonicalQuad(q: Quad): {
+    quad: Quad;
+    reflected: boolean;
+};
+export declare function alignToPrevious(q: Quad, prev: Quad | null): Quad;
+export declare function modelRotation(model: Quad, ordered: Quad): number | null;
+export declare function geometricRotation(ordered: Quad): number;
+export declare const HEAD_MIN = 0.6;
+export declare function headRotation(canonical: Quad, stable: Quad, orient: readonly number[]): number | null;
+export declare class OrientationVote {
+    private readonly n;
+    private readonly share;
+    private readonly min;
+    private xs;
+    private k;
+    constructor(n?: number, share?: number, min?: number);
+    push(k: number | null): number | null;
+    get value(): number | null;
+    shift(by: number): void;
+    reset(): void;
+    private held;
+    lock(k: number): void;
+    get locked(): boolean;
+}
+export declare class CornerOrder {
+    private prev;
+    readonly orient: OrientationVote;
+    read(raw: Quad, fromModel: boolean, orient?: readonly number[] | null): Quad;
+    private canonLock;
+    rotationFor(stable: Quad): number;
+    settle(held: Quad, k: number): number;
+    flip(stable: Quad): number;
+    orientQuad(q: Quad): Quad;
+    reset(full?: boolean): void;
+}

package/dist/types/react/document/gate.d.ts

@@ -12,7 +12,7 @@ export declare const MIN_CARD_AREA = 0.14;
 export declare const CARD_AR_MIN = 1.25;
 export declare const CARD_AR_MAX = 2.05;
 export declare const TILT_HOLD_MAX = 35;
-export declare const LOW_CONTRAST_GRACE_MS = 3000;
+export declare const LOW_CONTRAST_GRACE_MS = 2000;
 export declare const MANUAL_SHUTTER_MS = 10000;
 export declare const DAMAGED_RETRY_LIMIT = 1;
 export declare const TERMINAL_DOC_REASONS: readonly string[];
@@ -64,6 +64,10 @@ export declare const GUIDE: {
         key: "wrong_side_back";
         tone: "warn";
     };
+    turn_over: {
+        key: "turn_over";
+        tone: "info";
+    };
     blurred: {
         key: "blurred";
         tone: "warn";

package/dist/types/react/document/mrz.d.ts

@@ -1,4 +1,4 @@
-import type { MrzProbe } from "../capture";
+import type { MrzLayout, MrzProbe } from "../capture";
 export declare const MRZ_PROBE_MS = 1100;
 export declare const MRZ_GRACE_MS = 5200;
 export declare const MRZ_READINGS_MAX = 7;
@@ -18,6 +18,8 @@ export declare class MrzGate {
     unavailable: boolean;
     readonly readings: string[];
     readonly enabled: boolean;
+    settledAbsent: boolean;
+    layout: MrzLayout | null;
     constructor(enabled: boolean);
     get initialStage(): MrzStage;
     private get active();
@@ -27,3 +29,4 @@ export declare class MrzGate {
     decide(now: number, goodSince: number): MrzDecision;
     reset(): void;
 }
+export declare function finalMrzStage(extraction: unknown, live: MrzStage): MrzStage | null;

package/dist/types/react/document/mrzMap.d.ts

@@ -0,0 +1,19 @@
+import type { MrzLayout } from "../capture";
+import type { Pt, Quad } from "./overlay";
+export interface CardRect {
+    key: string;
+    uv: [Pt, Pt, Pt, Pt];
+    valid?: boolean | null;
+}
+export interface MrzMap {
+    zone: CardRect | null;
+    lines: CardRect[];
+    fields: CardRect[];
+    center: Pt | null;
+}
+export declare function invert3(m: number[]): number[] | null;
+export declare function cardToQuad(q: Quad, p: Pt): Pt;
+export declare function boxToSent(b: number[], W: number, H: number, rotation: number): [Pt, Pt, Pt, Pt];
+export declare function mapLayout(layout: MrzLayout | null | undefined, quad: Quad | null): MrzMap | null;
+export declare const upsideDown: (m: MrzMap | null) => boolean;
+export declare function turnMap(m: MrzMap): MrzMap;

package/dist/types/react/document/review.d.ts

@@ -9,11 +9,26 @@ export interface ExtractionLike {
         kind?: string;
         valid?: boolean | null;
         raw?: unknown;
+        format?: string | null;
     }>;
     portrait?: {
         present?: boolean;
         box?: number[] | null;
     } | null;
+    orientation?: {
+        rotation?: number;
+        source?: string;
+    } | null;
+    mrz_layout?: {
+        rotation?: number;
+        orientation_source?: string | null;
+        image?: number[];
+        lines?: number[][];
+        fields?: Record<string, {
+            box?: number[];
+            valid?: boolean | null;
+        } | undefined>;
+    } | null;
 }
 export interface ReviewRegion {
     key: string;
@@ -29,11 +44,25 @@ export interface ReviewField {
     value: string;
     confirmed: boolean;
 }
+export interface ReviewMrzField extends ReviewRegion {
+    value: string;
+    valid: boolean | null;
+    n: number;
+    field: string;
+}
+export interface ReviewMrz {
+    status: "verified" | "unreadable";
+    lines: ReviewRegion[];
+    fields: ReviewMrzField[];
+}
 export interface Review {
     regions: ReviewRegion[];
     fields: ReviewField[];
+    mrz?: ReviewMrz | null;
+    turned?: 0 | 180;
 }
 export declare function maskNumber(v: string): string;
+export declare function turnOf(x: ExtractionLike | null | undefined): 0 | 180;
 export declare function reviewOf(x: ExtractionLike | null | undefined, imgW: number, imgH: number, t: Strings): Review;
 export declare const hasReview: (r: Review) => boolean;
 export interface CardInset {

package/dist/types/react/document/stats.d.ts

@@ -0,0 +1,20 @@
+export declare const GATES: readonly ["found", "side", "fill", "shape", "sharp", "glare", "light", "still"];
+export type Gate = (typeof GATES)[number];
+export declare function gateOf(issue: string): Gate;
+export declare class CaptureStats {
+    private readonly t0;
+    private w;
+    private all;
+    private lastOutline;
+    private hold;
+    private coach;
+    private mode;
+    constructor(t0: number);
+    frame(found: boolean, confidence: number, veto?: "geometry" | "edges" | "content"): void;
+    outline(mode: "edges" | "box" | null): void;
+    tick(gate: Gate | null, pFront: number | null, motion: number | null, stillOk: boolean | null, hold: number, coach: string): void;
+    searching(coach: string): void;
+    flush(now: number): Record<string, number | string | number[]>;
+    summary(now: number, outcome: "capture" | "closed", ttc: number | null): Record<string, number | string | number[] | null>;
+}
+export declare const statsDue: (openMs: number, sinceLastMs: number) => boolean;

package/dist/types/react/document/steady.d.ts

@@ -0,0 +1,90 @@
+import type { Quad } from "../vision/corners";
+export declare const PRESENCE_ON = 4;
+export declare const PRESENCE_OFF = 7;
+export declare class Presence {
+    private readonly onN;
+    private readonly offM;
+    private on;
+    private hits;
+    private misses;
+    constructor(onN?: number, offM?: number);
+    read(found: boolean): boolean;
+    get value(): boolean;
+    reset(): void;
+}
+export declare class SideVote {
+    private readonly n;
+    private xs;
+    constructor(n?: number);
+    push(pFront: number): number;
+    get value(): number;
+    reset(): void;
+}
+export declare const HOLD_MAX_DROP = 0.15;
+export declare class HoldMeter {
+    private readonly holdMs;
+    private readonly drainPerS;
+    private readonly maxDrop;
+    private pct;
+    private last;
+    constructor(holdMs: number, drainPerS?: number, maxDrop?: number);
+    good(now: number): number;
+    bad(now: number): number;
+    get value(): number;
+    reset(): void;
+}
+export declare const STILL_FRAC = 0.018;
+export declare const STILL_FRAC_MAX = 0.03;
+export declare const STILL_RELAX_MS = 1500;
+export declare const STILL_WINDOW_MS = 500;
+export declare const STILL_WINDOW_FAST_MS = 350;
+export declare const STILL_FAST_CONF = 0.9;
+export declare class Stillness {
+    private readonly windowMs;
+    private readonly frac;
+    private h;
+    constructor(windowMs?: number, frac?: number);
+    push(q: Quad, t: number): void;
+    spread(now: number, windowMs?: number): number | null;
+    still(now: number, opts?: {
+        windowMs?: number;
+        frac?: number;
+    }): boolean;
+    reset(): void;
+}
+export declare const stillFrac: (fullForMs: number, relaxed?: boolean) => number;
+export interface Coach<K> {
+    key: K;
+    changed: boolean;
+}
+export declare class CoachGate<K extends string> {
+    private readonly minGapMs;
+    private readonly settleMs;
+    private shown;
+    private pending;
+    private pendingSince;
+    private lastChange;
+    constructor(minGapMs?: number, settleMs?: number);
+    propose(key: K, now: number): Coach<K>;
+    force(key: K, now: number): Coach<K>;
+    get value(): K | null;
+    reset(): void;
+}
+export declare class OneEuro {
+    private readonly minCutoff;
+    private readonly beta;
+    private readonly dCutoff;
+    private x;
+    private dx;
+    private t;
+    constructor(minCutoff?: number, beta?: number, dCutoff?: number);
+    private static a;
+    filter(v: number, t: number): number;
+    reset(): void;
+}
+export declare class CornerFilter {
+    private f;
+    constructor(minCutoff?: number, beta?: number);
+    filter(q: Quad, t: number): Quad;
+    reset(): void;
+}

package/dist/types/react/document/track.d.ts

@@ -32,5 +32,10 @@ export interface QuadSource {
     info?(): {
         kind: "edges" | "box" | null;
         locks: readonly [boolean, boolean, boolean, boolean];
+        rot?: number | null;
+        mrz?: {
+            map: import("./mrzMap").MrzMap;
+            verified: boolean;
+        } | null;
     };
 }

package/dist/types/react/document/upright.d.ts

@@ -0,0 +1,5 @@
+import type { FaceDetection } from "../vision/face";
+export type Turn = 0 | 90 | 180 | 270;
+export declare function rotateCanvas(src: HTMLCanvasElement, deg: Turn): HTMLCanvasElement;
+export declare function uprightFace(f: FaceDetection): boolean;
+export declare function portraitTurn(crop: HTMLCanvasElement, faces: (c: HTMLCanvasElement) => Promise<FaceDetection[]>): Promise<Turn | null>;

package/dist/types/react/document/useDocumentCapture.d.ts

@@ -19,6 +19,9 @@ export interface Snapshot {
 }
 export declare const LOCK_MS = 520;
 export declare const REVIEW_MS = 2600;
+export declare const CROP_TURN_MIN = 1;
+export declare const OUTLINE_BETA = 0.015;
+export declare const FLIP_MANUAL_MS = 15000;
 export declare function cutUpload(full: HTMLCanvasElement, b: Box): HTMLCanvasElement;
 export interface UploadCandidate {
     canvas: HTMLCanvasElement;
@@ -66,12 +69,14 @@ export declare function useDocumentCapture(props: DocumentCaptureProps): {
         checks?: Record<string, boolean>;
         failed?: string[];
         fields?: Record<string, string | null>;
+        layout?: import("../capture").MrzLayout | null;
     } | null;
     mrzStage: MrzStage;
     retry: () => void;
     retriesLeft: number | null;
     final: boolean;
     manualReady: boolean;
+    manualOnly: boolean;
     shutter: () => void | undefined;
     review: ReviewView | null;
     snapshot: Snapshot | null;

package/dist/types/react/face/FaceGuide.d.ts

@@ -4,13 +4,13 @@ import type { PointsMotion } from "../document/track";
 import { type ScanState } from "./scanState";
 export type FaceGuideState = "neutral" | "aligned" | "capturing" | "done" | "warn";
 export type FaceCue = "turn_left" | "turn_right" | "move_closer" | null;
-export declare function FaceGuide({ src, oval, motion, state, scan, fills, progress, cue, guide, errorKey, t, }: {
+export declare function FaceGuide({ src, oval, state, scan, fills, progress, cue, guide, errorKey, t, motion, }: {
+    motion?: PointsMotion | null;
     src: {
         w: number;
         h: number;
     };
     oval: Ellipse;
-    motion: PointsMotion;
     state: FaceGuideState;
     scan: ScanState;
     fills: number[];

package/dist/types/react/face/faceFollow.d.ts

@@ -0,0 +1,32 @@
+import type { Ellipse } from "./faceView";
+export declare const SNAP_FROM = 1;
+export declare class FaceFollow {
+    private f;
+    private blend;
+    private last;
+    step(face: Ellipse | null, oval: Ellipse, locked: boolean, now: number): {
+        e: Ellipse;
+        alpha: number;
+        dashed: boolean;
+    } | null;
+    reset(): void;
+}
+export declare class FaceTrackStats {
+    frames: number;
+    found: number;
+    private prev;
+    private jit;
+    private t0;
+    alignedMs: number | null;
+    frame(center: {
+        x: number;
+        y: number;
+    } | null, aligned: boolean, now: number): void;
+    summary(): {
+        frames: number;
+        found: number;
+        rate: number;
+        jitterPx: number | null;
+        alignedMs: number | null;
+    };
+}

package/dist/types/react/face/scanState.d.ts

@@ -10,7 +10,6 @@ export declare function scanStateOf(s: {
     guide: GuideKey | string;
 }): ScanState;
 export declare const isLocked: (s: ScanState) => s is "challenge" | "done" | "aligned" | "verifying";
-export declare function meshLevel(s: ScanState): number;
 export declare function segmentFills(s: {
     step: number;
     total: number;

package/dist/types/react/flows/FlowResult.d.ts

@@ -1,13 +1,14 @@
-import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import { type Formality, type Locale, type StringOverrides, type Strings } from "../i18n";
 import type { VerificationResult } from "./types";
 export declare function FlowResult({ result, t }: {
     result: VerificationResult;
     t: Strings;
 }): import("react").JSX.Element;
-export declare function IdentifyOutcome({ reason, locale, overrides, onRestart, t, }: {
+export declare function IdentifyOutcome({ reason, locale, overrides, formality, onRestart, t, }: {
     reason: string;
     locale?: Locale;
     overrides?: StringOverrides;
+    formality?: Formality;
     onRestart: () => void;
     t: Strings;
 }): import("react").JSX.Element;

package/dist/types/react/flows/FlowShell.d.ts

@@ -1,9 +1,10 @@
 import { type ReactNode } from "react";
-import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import { type Formality, type Locale, type StringOverrides, type Strings } from "../i18n";
 import { type CaptureId, type FailureCause, type FailureText, type RetakeNotice, type Side, type Step, type Thumbs } from "./state";
 import type { Purpose } from "./types";
 import { type Appearance } from "../theme/appearance";
-export declare function FlowShell({ step, purpose, title, t, children, privacy, appearance, forceAppearance, screen, manageFocus, }: {
+import { type ColorScheme } from "../theme/scheme";
+export declare function FlowShell({ step, purpose, title, t, children, privacy, appearance, forceAppearance, screen, manageFocus, colorScheme, }: {
     step: Step;
     purpose: Purpose;
     title: string;
@@ -14,6 +15,7 @@ export declare function FlowShell({ step, purpose, title, t, children, privacy,
     forceAppearance?: boolean;
     screen?: string;
     manageFocus?: boolean;
+    colorScheme?: ColorScheme;
 }): import("react").JSX.Element;
 export declare function StepRail({ step, t, plan, retakes, }: {
     step: Step;
@@ -35,7 +37,8 @@ export declare function Preparing({ label, note }: {
     label: string;
     note?: string;
 }): import("react").JSX.Element;
-export declare function Failure({ reason, verdict, cause, text, locale, overrides, onRestart, t, takeFocus, }: {
+export declare function Failure({ reason, verdict, cause, text, locale, overrides, formality, onRestart, t, takeFocus, }: {
+    formality?: Formality;
     reason: string;
     verdict?: "REJECTED" | "NEEDS_REVIEW";
     cause?: FailureCause;

package/dist/types/react/flows/types.d.ts

@@ -1,4 +1,5 @@
-import type { Locale, StringOverrides } from "../i18n";
+import type { ColorScheme } from "../theme/scheme";
+import type { Formality, Locale, StringOverrides } from "../i18n";
 import type { DocumentAuthenticity } from "../capture";
 import type { SelfieQualityFloors } from "../face/qualityGate";
 import type { Appearance } from "../theme/appearance";
@@ -93,6 +94,7 @@ export interface SessionFlow {
     document?: boolean;
     documentSides?: "front_back" | "front";
     locale?: Locale;
+    formality?: Formality;
     appearance?: Appearance;
     instructions?: TenantInstructions;
     messages?: TenantMessages;
@@ -240,6 +242,8 @@ export interface VerificationFlowProps {
     source?: "camera" | "demo";
     locale?: Locale;
     strings?: StringOverrides;
+    formality?: Formality;
+    colorScheme?: ColorScheme;
     challengeMs?: number;
     debug?: boolean;
     onVerified: (result: VerificationResult) => void | Promise<void>;

package/dist/types/react/flows/useFlowSession.d.ts

@@ -2,10 +2,11 @@ import { type RpidClientConfig } from "../capture";
 import { type FlowState, type Side } from "./state";
 import type { SideRetake } from "../DocumentCapture";
 import type { ConsentChoice, Purpose, VerificationFlowProps, VerificationResult } from "./types";
-export declare function useFlowSession({ purpose, apiUrl, openSession, locale, strings: overrides, onVerified, onFailed, onEvent, source, consentChoice, diagnostics, }: VerificationFlowProps & {
+export declare function useFlowSession({ purpose, apiUrl, openSession, locale, strings: overrides, formality: formalityProp, onVerified, onFailed, onEvent, source, consentChoice, diagnostics, }: VerificationFlowProps & {
     purpose: Purpose;
     consentChoice?: ConsentChoice | null;
 }): {
+    formality: import("../i18n").Formality;
     state: FlowState;
     t: import("../i18n").Strings;
     locale: import("../i18n").Locale;

package/dist/types/react/handoff/ContinueFlow.d.ts

@@ -1,5 +1,6 @@
-import { type Locale, type StringOverrides, type Strings } from "../i18n";
+import { type Formality, type Locale, type StringOverrides, type Strings } from "../i18n";
 import type { RpidFlowEvent } from "../flows/types";
+import type { ColorScheme } from "../theme/scheme";
 export declare function readHandoffCode(search?: string, pathname?: string, hash?: string): string | null;
 export interface ContinueFlowProps {
     apiUrl: string;
@@ -7,6 +8,8 @@ export interface ContinueFlowProps {
     modelsUrl?: string;
     locale?: Locale;
     strings?: StringOverrides;
+    formality?: Formality;
+    colorScheme?: ColorScheme;
     privacyNote?: string | null;
     source?: "camera" | "demo";
     debug?: boolean;
@@ -16,7 +19,7 @@ export interface ContinueFlowProps {
         reason: string | null;
     }) => void;
 }
-export declare function ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, privacyNote, source, debug, onEvent, onDone, }: ContinueFlowProps): import("react").JSX.Element;
+export declare function ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, formality, colorScheme, privacyNote, source, debug, onEvent, onDone, }: ContinueFlowProps): import("react").JSX.Element;
 export declare function ContinueConfirmView({ t, tenant, codeHint, onContinue }: {
     t: Strings;
     tenant: string;