@baas-id/react 0.3.1 → 0.3.7

package/dist/types/continue.d.ts

@@ -1,3 +1,6 @@
 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, type Formality } from "./react/i18n";
+export { nativeChipReader, ChipReadError, type ChipReader, type ChipReadout, type ChipReadInput, type ChipReadProgress, type ChipReaderName, } from "./react/chip/provider";
+export { chipCapability, type ChipCapability } from "./react/chip/capability";
+export type { FingerDetector, FingerBox } from "./react/finger/detector";

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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 { 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, type SessionChip, type SessionFinger, type FingerPosition, type StepId, } 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";
@@ -10,6 +10,15 @@ export { SDK_VERSION } from "./react/version";
 export { DocumentCapture, type DocumentCaptureProps, type SideRetake } from "./react/DocumentCapture";
 export { sideOutcomeOf, type SideOutcome } from "./react/document/sideCheck";
 export { FaceCapture, type FaceCaptureProps } from "./react/FaceCapture";
+export { ChipRead, type ChipReadProps } from "./react/chip/ChipRead";
+export type { ChipOutcome } from "./react/chip/useChipRead";
+export { nativeChipReader, ChipReadError, normalizeChipError, type ChipReader, type ChipReadout, type ChipReadInput, type ChipReadProgress, type ChipReaderName, type ChipReadErrorCode, type ChipMrzKey, } from "./react/chip/provider";
+export { chipCapability, unavailableReason, webNfcAvailable, type ChipCapability, type ChipUnavailableReason, type ChipDevice, } from "./react/chip/capability";
+export { watchChipPresence, type NfcPresence } from "./react/chip/webNfcPresence";
+export { FingerCapture, type FingerCaptureProps } from "./react/FingerCapture";
+export { silhouetteDetector, fingerSlots, fingerGroups, type FingerDetector, type FingerBox, type FingerPixels, type FingerGroup, type Slot as FingerSlot, } from "./react/finger/detector";
+export { fingertipStats, fingerGate, FINGER_FLOORS, type FingertipStats, type FingerFloors, type FingerGuideId, } from "./react/finger/qualityGate";
+export { uploadChip, reportChipUnavailable, uploadFinger, torchSupported, setTorch, type ChipUploadMeta, type FingerUploadMeta, } from "./react/capture";
 export { selfieQualityIssue, faceCropStats, floorsFrom, SELFIE_QUALITY_DEFAULTS, type SelfieQualityFloors, type SelfieQualityReading, type QualityIssue, } from "./react/face/qualityGate";
 export { finalizeSession, uploadCapture, probeDocument, type Quality, type RpidClientConfig, type MrzProbe, } from "./react/capture";
 export { webAttestation, nativeAttestation, requestHash, type AttestationProvider, type AttestationClaim, type AttestationName, type NativeMint, } from "./react/capture";

package/dist/types/native.d.ts

@@ -0,0 +1,38 @@
+import { ChipReadError, type ChipReader, type ChipReadProgress } from "./react/chip/provider";
+export { ChipReadError, type ChipReader, type ChipReadout, type ChipReadInput, type ChipReadProgress, type ChipReaderName, type ChipReadErrorCode, } from "./react/chip/provider";
+export interface BaasNfcReadOptions {
+    mrz?: {
+        documentNumber: string;
+        birthDate: string;
+        expiryDate: string;
+    };
+    can?: string;
+    dataGroups: string[];
+    aaChallenge?: string;
+    chipAuthentication?: boolean;
+    timeoutMs?: number;
+    preferPace?: boolean;
+    sessionMessage?: string;
+}
+export interface BaasNfcReadResult {
+    access: "bac" | "pace";
+    sod: string;
+    dataGroups: Record<string, string>;
+    aaSignature?: string;
+    timings?: Record<string, number>;
+}
+export interface BaasNfcLike {
+    readDocument(options: BaasNfcReadOptions): Promise<BaasNfcReadResult>;
+    cancel(): Promise<void>;
+    addListener(eventName: "progress", listener: (p: ChipReadProgress) => void): Promise<{
+        remove(): Promise<void> | void;
+    }>;
+}
+export interface CapacitorChipReaderOptions {
+    timeoutMs?: number;
+    sessionMessage?: string;
+    chipAuthentication?: boolean;
+    preferPace?: boolean;
+}
+export declare function chipErrorFromPlugin(e: unknown): ChipReadError;
+export declare function capacitorChipReader(plugin: BaasNfcLike, name: "native_android" | "native_ios", options?: CapacitorChipReaderOptions): ChipReader;

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

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

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

@@ -0,0 +1,20 @@
+import { type RpidClientConfig } from "./capture";
+import { type Locale, type StringOverrides } from "./i18n";
+import type { FingerPosition } from "./flows/types";
+import type { FingerDetector } from "./finger/detector";
+export interface FingerCaptureProps {
+    config: RpidClientConfig;
+    finger: {
+        fingers: FingerPosition[];
+        torch?: boolean;
+    };
+    source?: "camera" | "demo";
+    locale?: Locale;
+    strings?: StringOverrides;
+    debug?: boolean;
+    captureNonce?: string | null;
+    detector?: FingerDetector;
+    onCaptured: (serverResult: unknown) => void;
+    onRejected?: (reason: string, detail?: unknown) => void;
+}
+export declare function FingerCapture(props: FingerCaptureProps): import("react").JSX.Element;

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

@@ -66,3 +66,56 @@ export interface MrzProbe {
 }
 export declare function probeDocumentSignal(cfg: RpidClientConfig, blob: Blob, signal?: AbortSignal): Promise<MrzProbe | null>;
 export declare function probeDocument(cfg: RpidClientConfig, blob: Blob): Promise<MrzProbe | null>;
+export interface ChipFile {
+    name: "sod" | `dg${number}`;
+    bytes: Uint8Array;
+}
+export declare const CHIP_OPTIONAL_GROUPS: readonly [11, 12, 14, 15];
+export declare function chipFiles(readout: {
+    sod: Uint8Array;
+    dataGroups: Record<string, Uint8Array>;
+}): ChipFile[];
+export declare function concatBytes(parts: readonly Uint8Array[]): ArrayBuffer;
+export declare function base64Of(bytes: Uint8Array): string;
+export interface ChipUploadMeta {
+    reader: "native_android" | "native_ios" | "desktop_reader";
+}
+export declare function uploadChipSignal(cfg: RpidClientConfig, readout: {
+    access: "bac" | "pace";
+    sod: Uint8Array;
+    dataGroups: Record<string, Uint8Array>;
+    aaSignature?: Uint8Array;
+    timings?: Record<string, number>;
+}, meta: ChipUploadMeta, { capture, signal }?: {
+    capture?: Record<string, unknown> | null;
+    signal?: AbortSignal;
+}): Promise<any>;
+export declare const uploadChip: typeof uploadChipSignal;
+export declare function reportChipUnavailable(cfg: RpidClientConfig, status: "unavailable" | "skipped", reason: "NO_NATIVE_READER" | "WEB_NFC_NO_ISODEP" | "NFC_OFF" | "USER_SKIPPED" | "TIMEOUT" | "ACCESS_DENIED" | "NO_CHIP", signal?: AbortSignal): Promise<any>;
+export interface FingerStatsOut {
+    sharpness: number;
+    glare: number;
+    ridge: number;
+    luma: number;
+    width_px: number;
+}
+export interface FingerUploadMeta {
+    positions: string[];
+    hand: "left" | "right";
+    boxes: Array<[number, number, number, number]>;
+    stats: FingerStatsOut[];
+    torch: {
+        supported: boolean;
+        response: number | null;
+    };
+}
+export declare function uploadFingerSignal(cfg: RpidClientConfig, upload: {
+    file: Blob;
+    crops: Blob[];
+    meta: FingerUploadMeta;
+}, { capture, signal }?: {
+    capture?: Record<string, unknown> | null;
+    signal?: AbortSignal;
+}): Promise<any>;
+export declare function malformedFingerUpload(e: unknown): string | null;
+export declare const uploadFinger: typeof uploadFingerSignal;

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

@@ -1,4 +1,4 @@
-export type CameraProfile = "default" | "document";
+export type CameraProfile = "default" | "document" | "finger";
 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>;

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

@@ -1,2 +1,12 @@
 export declare function demoDocumentFrame(canvas: HTMLCanvasElement, side: "front" | "back", settled: number): void;
 export declare function demoFaceFrame(canvas: HTMLCanvasElement, settled: number): void;
+export declare function demoFingerPixels(width: number, height: number, slots: ReadonlyArray<{
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}>, settled: number): {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+};

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

@@ -1,7 +1,8 @@
-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 { uploadCapture, finalizeSession, probeDocument, uploadCaptureSignal, finalizeSessionSignal, probeDocumentSignal, errorCode, isAbort, rejectionOf, authenticityOf, apiHeaders, langHeaders, withLanguage, uploadChipSignal, uploadChip, malformedFingerUpload, reportChipUnavailable, uploadFingerSignal, uploadFinger, chipFiles, concatBytes, base64Of, type RpidClientConfig, type MrzProbe, type MrzLayout, type CaptureUpload, type Rejection, type DocumentAuthenticity, type ChipFile, type ChipUploadMeta, type FingerUploadMeta, type FingerStatsOut, } from "./api";
 export { openCamera, parkCamera, stopStream, cameraConstraints, type CameraProfile } from "./camera";
+export { torchSupported, setTorch, torchControl, type TorchControl } from "./torch";
 export { analyzeFrame, moireProbe, grabFrame, canvasToJpeg, thumbnailOf, readPixels, haptic, type Quality, type ProbeRegion, } from "./frames";
-export { demoDocumentFrame, demoFaceFrame } from "./demo";
+export { demoDocumentFrame, demoFaceFrame, demoFingerPixels } from "./demo";
 export { createCaptureRun, frameLoop, nextFrame, type CaptureRun, type TickResult } from "./run";
 export { useCaptureRun, useLatest } from "./useCaptureRun";
 export { CaptureViewport, Guide, RetryButton, Telemetry } from "./chrome";

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

@@ -11,9 +11,16 @@ export declare function keyframeSize(w: number, h: number, maxSide?: number): {
     h: number;
 };
 export declare function admit(tags: readonly string[], tag: string, max?: number): boolean;
+type Frame = HTMLVideoElement | HTMLCanvasElement;
 export declare class KeyframeRecorder {
     private pending;
     private tags;
-    grab(video: HTMLVideoElement | null, tag: string, tMs: number): void;
+    private best;
+    private copy;
+    private encode;
+    offer(src: Frame | null, tag: string, tMs: number, score: number): void;
+    commit(tag: string, fallback: Frame | null, tMs: number): void;
+    grab(frame: Frame | null, tag: string, tMs: number): void;
     collect(): Promise<Keyframe[]>;
 }
+export {};

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

@@ -0,0 +1,14 @@
+import type { CaptureRun } from "./run";
+type TrackLike = Pick<MediaStreamTrack, "applyConstraints"> & {
+    getCapabilities?: () => unknown;
+    readyState?: string;
+};
+export declare function torchSupported(track: TrackLike | null | undefined): boolean;
+export declare function setTorch(track: TrackLike | null | undefined, on: boolean): Promise<boolean>;
+export interface TorchControl {
+    readonly supported: boolean;
+    readonly on: boolean;
+    set(on: boolean): Promise<boolean>;
+}
+export declare function torchControl(run: CaptureRun, track: TrackLike | null | undefined): TorchControl;
+export {};

package/dist/types/react/chip/ChipRead.d.ts

@@ -0,0 +1,21 @@
+import { type Locale, type StringOverrides } from "../i18n";
+import type { RpidClientConfig } from "../capture";
+import type { SessionChip } from "../flows/types";
+import type { ChipMrzKey, ChipReader } from "./provider";
+import { type ChipOutcome } from "./useChipRead";
+export interface ChipReadProps {
+    config: RpidClientConfig;
+    chip: SessionChip;
+    access?: ChipMrzKey | null;
+    can?: string;
+    reader?: ChipReader;
+    captureNonce?: string | null;
+    device?: "mobile" | "tablet" | "desktop";
+    onHandoff?: () => void;
+    locale?: Locale;
+    strings?: StringOverrides;
+    debug?: boolean;
+    onDone: (outcome: ChipOutcome) => void;
+    onRejected?: (reason: string, detail?: unknown) => void;
+}
+export declare function ChipRead(props: ChipReadProps): import("react").JSX.Element;

package/dist/types/react/chip/capability.d.ts

@@ -0,0 +1,11 @@
+import type { ChipReader } from "./provider";
+export type ChipCapability = "native" | "web_nfc_presence_only" | "handoff" | "unavailable";
+export type ChipUnavailableReason = "NO_NATIVE_READER" | "WEB_NFC_NO_ISODEP" | "NFC_OFF" | "USER_SKIPPED" | "TIMEOUT" | "ACCESS_DENIED" | "NO_CHIP";
+export interface ChipDevice {
+    kind?: "mobile" | "tablet" | "desktop";
+    handoff?: boolean;
+    webNfc?: boolean;
+}
+export declare function webNfcAvailable(): boolean;
+export declare function chipCapability(reader?: ChipReader | null, device?: ChipDevice): ChipCapability;
+export declare function unavailableReason(cap: ChipCapability): ChipUnavailableReason;

package/dist/types/react/chip/evidence.d.ts

@@ -0,0 +1,9 @@
+import { type DeviceSignals, type TimelineSummary } from "../capture";
+import type { ChipReadout } from "./provider";
+export declare function chipEvidence(input: {
+    nonce: string | null | undefined;
+    readout: ChipReadout;
+    timeline: TimelineSummary;
+    device: DeviceSignals | null;
+    readAt?: Record<string, number>;
+}): Promise<Record<string, unknown> | null>;

package/dist/types/react/chip/provider.d.ts

@@ -0,0 +1,42 @@
+export interface ChipMrzKey {
+    documentNumber: string;
+    birthDate: string;
+    expiryDate: string;
+}
+export interface ChipReadProgress {
+    stage: "waiting" | "connected" | "auth" | "reading" | "done";
+    dg?: string;
+    fraction?: number;
+}
+export interface ChipReadInput {
+    mrz: {
+        documentNumber: string;
+        birthDate: string;
+        expiryDate: string;
+    } | null;
+    can?: string;
+    aaChallenge?: string;
+    dataGroups: string[];
+    signal: AbortSignal;
+    onProgress?(p: ChipReadProgress): void;
+}
+export interface ChipReadout {
+    access: "bac" | "pace";
+    dataGroups: Record<string, Uint8Array>;
+    sod: Uint8Array;
+    aaSignature?: Uint8Array;
+    timings?: Record<string, number>;
+}
+export type ChipReaderName = "native_android" | "native_ios" | "desktop_reader";
+export interface ChipReader {
+    readonly name: ChipReaderName;
+    read(input: ChipReadInput): Promise<ChipReadout>;
+}
+export type ChipReadErrorCode = "ACCESS_DENIED" | "TIMEOUT" | "NFC_OFF" | "NO_CHIP" | "READ_FAILED";
+export declare class ChipReadError extends Error {
+    readonly code: ChipReadErrorCode;
+    constructor(code: ChipReadErrorCode, message?: string);
+}
+export declare function normalizeChipError(e: unknown): ChipReadError | DOMException | Error;
+export declare function toBytes(v: unknown): Uint8Array | null;
+export declare function nativeChipReader(name: ChipReaderName, bridge: (input: ChipReadInput) => Promise<ChipReadout>): ChipReader;

package/dist/types/react/chip/useChipRead.d.ts

@@ -0,0 +1,32 @@
+import type { ChipReadProps } from "./ChipRead";
+import { type ChipCapability, type ChipUnavailableReason } from "./capability";
+import { type ChipReadErrorCode, type ChipReadProgress } from "./provider";
+export type ChipPhase = "idle" | "waiting" | "reading" | "uploading" | "done" | "unavailable" | "error";
+export declare const UNAVAILABLE_BEAT_MS = 600;
+export type ChipOutcome = {
+    kind: "read";
+    access: "bac" | "pace";
+    dataGroups: string[];
+    activeAuth: boolean;
+    result: unknown;
+} | {
+    kind: "unavailable" | "skipped";
+    reason: ChipUnavailableReason;
+    chipRequired: boolean;
+    result: unknown;
+};
+export declare function chipReadReason(code: ChipReadErrorCode): "CHIP_ACCESS_DENIED" | "CHIP_TIMEOUT" | "NFC_UNAVAILABLE" | "CHIP_READ_FAILED";
+export declare function skipReason(code: ChipReadErrorCode | null): ChipUnavailableReason;
+export declare function useChipRead(props: ChipReadProps): {
+    t: import("../i18n").Strings;
+    capability: ChipCapability;
+    phase: ChipPhase;
+    progress: ChipReadProgress | null;
+    readError: ChipReadErrorCode | null;
+    error: string | null;
+    errorDetail: unknown;
+    retriesLeft: number | null;
+    final: boolean;
+    retry: () => void;
+    skip: () => void;
+};

package/dist/types/react/chip/webNfcPresence.d.ts

@@ -0,0 +1,2 @@
+export type NfcPresence = "tag_suspected" | "ndef_tag" | "none";
+export declare function watchChipPresence(signal: AbortSignal, onHint: (p: NfcPresence) => void): Promise<boolean>;

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

@@ -42,6 +42,7 @@ export declare function MrzStatus({ stage, mrz, t }: {
     mrz: MrzProbe["mrz"] | null;
     t: Strings;
 }): import("react").JSX.Element | null;
+export declare const AUTO_CONTINUE_S = 6;
 export declare function RetakePanel({ outcome, side, t, onRetake, onContinue, }: {
     outcome: Exclude<SideOutcome, {
         kind: "ok";

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

@@ -31,6 +31,7 @@ export declare class CornerOrder {
     read(raw: Quad, fromModel: boolean, orient?: readonly number[] | null): Quad;
     private canonLock;
     rotationFor(stable: Quad): number;
+    headRotation(): number | null;
     settle(held: Quad, k: number): number;
     flip(stable: Quad): number;
     orientQuad(q: Quad): Quad;

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

@@ -0,0 +1,26 @@
+import type { Quad } from "./overlay";
+export declare const FOLLOW_TAU_MS = 40;
+export declare const HOLD_MS = 350;
+export declare const JUMP = 0.25;
+export declare const TOUCH_SHIFT = 0.03;
+export declare const TOUCH_SCALE = 1.1;
+export declare const TOUCH_MAX_MS = 500;
+export declare class CardFollower {
+    private meas;
+    private measAt;
+    private shown;
+    private shownAt;
+    private gap;
+    measure(q: Quad, t: number): void;
+    private lastReal;
+    private hold;
+    touch(box: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    }, t: number): boolean;
+    last(t: number, maxAge?: number): Quad | null;
+    at(now: number): Quad | null;
+    reset(): void;
+}

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

@@ -7,6 +7,7 @@ export interface Box {
 export declare const WORK_LONG_SIDE = 1280;
 export declare const UPLOAD_LONG_MAX = 1600;
 export declare const UPLOAD_MARGIN = 0.03;
+export declare const RECT_MARGIN = 0.015;
 export declare const UPLOAD_JPEG_QUALITY = 0.9;
 export declare const EXTRA_JPEG_QUALITY = 0.85;
 export declare const EXTRA_JPEG_QUALITY_LOW = 0.75;

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

@@ -69,7 +69,7 @@ export interface CardInset {
     x: number;
     y: number;
 }
-export declare function cardInset(margin: number, aspect?: number): CardInset;
+export declare function cardInset(margin: number, _aspect?: number): CardInset;
 export interface ReviewView {
     image: string;
     aspect: number;

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

@@ -17,6 +17,7 @@ export type SideOutcome = {
     suggest: "continue" | "retake";
 } & SideCopy);
 export declare function sideOutcomeOf(side: Side, res: unknown): SideOutcome;
+export declare const QUALITY_RETAKE_REASONS: readonly string[];
 export declare function fallbackCopy(o: Exclude<SideOutcome, {
     kind: "ok";
 }>, side: Side, t: Strings): {

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

@@ -82,9 +82,3 @@ export declare class OneEuro {
     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/upright.d.ts

@@ -3,3 +3,4 @@ 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>;
+export declare function uprightAt(crop: HTMLCanvasElement, faces: (c: HTMLCanvasElement) => Promise<FaceDetection[]>, deg: Turn): Promise<boolean>;

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

@@ -4,7 +4,7 @@ import { type Chip, type Guidance, type Phase } from "./gate";
 import { type MrzStage } from "./mrz";
 import { type Advisory } from "./advisory";
 import { type Box, type Quad } from "./overlay";
-import { type QuadSource } from "./track";
+import type { QuadSource } from "./track";
 import { type ReviewView } from "./review";
 export interface SnapshotFrom {
     l: number;
@@ -20,13 +20,34 @@ 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 const TURN_HEAD_MIN = 0.6;
+export declare const CONFIRM_MS = 700;
+export declare const CONFIRM_SHAPE = 0.015;
+export declare function confirmed(q: Quad, prev: {
+    q: Quad;
+    t: number;
+} | null, t: number): boolean;
 export declare function cutUpload(full: HTMLCanvasElement, b: Box): HTMLCanvasElement;
+export declare function poseShape(c: {
+    quad: unknown;
+    aspect: number;
+    tilt: number;
+} | null | undefined): {
+    aspect: number;
+    tilt: number;
+} | null;
+export declare function heldPortrait(q: Quad): boolean;
 export interface UploadCandidate {
     canvas: HTMLCanvasElement;
     quad: Quad | null;
 }
+export declare const AGREE_MAX = 0.006;
+export declare function confirmCorners(c: UploadCandidate, cam: {
+    focal: number;
+    cx: number;
+    cy: number;
+}): UploadCandidate;
 export declare function cutCard(full: HTMLCanvasElement, b: Box, quad?: Quad | null): UploadCandidate;
 export declare function useDocumentCapture(props: DocumentCaptureProps): {
     t: import("../i18n").Strings;

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

@@ -0,0 +1,17 @@
+import type { FaceSignals } from "../liveness";
+export declare const PROBE_YAW_MAX = 0.15;
+export declare const PROBE_YAW_CONFIDENCE_MIN = 0.45;
+export declare const PROBE_FILL_MIN = 0.6;
+export declare const PROBE_SHARP_REF = 300;
+export interface ProbeStats {
+    sharpness: number;
+    luma: number;
+}
+export declare function probeScore(sig: FaceSignals, stats: ProbeStats | null): number;
+export declare class BestFrame {
+    private canvas;
+    score: number;
+    offered: number;
+    offer(frame: HTMLCanvasElement | null, score: number): boolean;
+    get frame(): HTMLCanvasElement | null;
+}

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

@@ -6,6 +6,7 @@ export interface Ellipse {
     rx: number;
     ry: number;
 }
+export declare const FACE_LANDSCAPE_AR: number;
 export declare const faceViewMap: (srcW: number, srcH: number, viewW: number, viewH: number) => ViewMap;
 export declare function ovalToView(o: Ellipse, m: ViewMap): Ellipse;
 export declare function trackPoints(g: FaceGeometry): Pt[];
@@ -16,6 +17,8 @@ export interface FaceMark {
     mouth?: Pt;
     ears?: [Pt, Pt];
 }
+export declare const FACE_W_H_MIN = 0.72;
+export declare const FACE_W_H_MAX = 0.8;
 export declare function faceMarkToView(pts: readonly Pt[], srcW: number, srcH: number, m: ViewMap): FaceMark | null;
 export declare const ovalFill: (faceW: number, oval: Ellipse) => number;
 export declare function ellipsePath(e: Ellipse): string;

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

@@ -13,6 +13,7 @@ export interface LivenessIo {
     strings(): Strings;
     now(): number;
     keyframe?(tag: string): void;
+    keyframeOffer?(tag: string, score: number): void;
 }
 export interface LivenessUi {
     locked(): void;
@@ -34,4 +35,5 @@ export type LivenessResult = {
 } | {
     k: "aborted";
 };
+export declare function movementScore(kind: ChallengeKind, sig: FaceSignals): number;
 export declare function runLiveness(script: ChallengeKind[], tracker: LivenessTracker, io: LivenessIo, ui: LivenessUi): Promise<LivenessResult>;

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

@@ -6,6 +6,7 @@ import type { FaceCaptureProps } from "../FaceCapture";
 import { PointsMotion } from "../document/track";
 import { type Framing } from "./runLiveness";
 export type FacePhase = "searching" | "locked" | "uploading" | "error";
+export declare const FACE_CLIENT_RETRIES = 2;
 export declare function useFaceCapture(props: FaceCaptureProps): {
     t: import("../i18n").Strings;
     source: "camera" | "demo";
@@ -27,6 +28,11 @@ export declare function useFaceCapture(props: FaceCaptureProps): {
     };
     retry: () => void;
     retriesLeft: number | null;
+    retrying: {
+        code: string;
+        n: number;
+        total: number;
+    } | null;
     final: boolean;
     src: {
         w: number;

package/dist/types/react/finger/FingerGuide.d.ts

@@ -0,0 +1,14 @@
+import type { Strings } from "../i18n";
+import type { Slot } from "./detector";
+import type { SlotState } from "./runFingerCapture";
+export declare function FingerGuide({ src, slots, states, hold, t, done, }: {
+    src: {
+        w: number;
+        h: number;
+    };
+    slots: readonly Slot[];
+    states: readonly SlotState[];
+    hold: number;
+    t: Strings;
+    done?: boolean;
+}): import("react").JSX.Element | null;

package/dist/types/react/finger/detector.d.ts

@@ -0,0 +1,39 @@
+import type { FingerPosition } from "../flows/types";
+export interface FingerPixels {
+    data: ArrayLike<number>;
+    width: number;
+    height: number;
+}
+export interface Slot {
+    position: FingerPosition;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface FingerBox {
+    position: FingerPosition;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    score: number;
+}
+export interface FingerDetector {
+    detect(px: FingerPixels, slots: Slot[]): FingerBox[] | Promise<FingerBox[]>;
+}
+export interface FingerGroup {
+    hand: "left" | "right";
+    positions: FingerPosition[];
+}
+export declare function fingerGroups(fingers: readonly FingerPosition[]): FingerGroup[];
+export declare function fingerSlots(positions: readonly FingerPosition[], aspect: number): Slot[];
+export declare function isSkin(r: number, g: number, b: number): boolean;
+export declare const PRESENCE_MIN = 0.35;
+export declare const silhouetteDetector: FingerDetector;
+export declare function cropPixels(px: FingerPixels, b: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): FingerPixels | null;