@baas-id/react 0.3.5 → 0.3.7

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/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/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;

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

@@ -0,0 +1,37 @@
+import type { GuideKey } from "../i18n";
+import type { FingerBox, FingerPixels, Slot } from "./detector";
+export interface FingertipStats {
+    sharpness: number;
+    luma: number;
+    contrast: number;
+    glare: number;
+    ridge: number;
+    widthPx: number;
+}
+export type FingerGuideId = Extract<GuideKey, "no_hand" | "fingers_closer" | "fingers_back" | "fingers_together" | "hold_fingers_still" | "finger_glare" | "finger_blurry" | "show_left_hand" | "show_right_hand" | "too_dark" | "perfect">;
+export interface FingerFloors {
+    widthPxMin: number;
+    slotFracMax: number;
+    glareMax: number;
+    lumaMin: number;
+    lumaMax: number;
+    ridgeMin: number;
+    sharpnessMin: number | null;
+}
+export declare const FINGER_FLOORS: FingerFloors;
+export declare const RIDGE_W = 192;
+export declare function ridgeScore(g: Float32Array, w: number, h: number): number;
+export declare function fingertipStats(px: FingerPixels, box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): FingertipStats;
+export interface FingerReading {
+    slots: readonly Slot[];
+    boxes: readonly FingerBox[];
+    stats: ReadonlyArray<FingertipStats | null>;
+    hand?: "left" | "right";
+}
+export declare function fingertipPasses(st: FingertipStats | null, f?: FingerFloors): boolean;
+export declare function fingerGate(r: FingerReading, f?: FingerFloors): FingerGuideId;

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

@@ -0,0 +1,77 @@
+import type { FingerBox, FingerDetector, FingerGroup, FingerPixels } from "./detector";
+import { type FingerFloors, type FingerGuideId, type FingertipStats } from "./qualityGate";
+export declare const FINGER_TICK_MS = 90;
+export declare const PRESENT_FRAMES = 3;
+export declare const HOLD_FRAMES = 5;
+export declare const STILL_MAX = 0.02;
+export declare const FINGER_TIMEOUT_MS = 25000;
+export declare const TORCH_SETTLE_MS = 350;
+export interface FingerFrame<F> {
+    px: FingerPixels;
+    frame: F;
+    w: number;
+    h: number;
+}
+export interface FingerIo<F> {
+    alive(): boolean;
+    wait(ms: number): Promise<void>;
+    now(): number;
+    read(): Promise<FingerFrame<F> | null>;
+    detector: FingerDetector;
+    region(frame: F, box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): FingerPixels | null;
+    keep?(frame: F): F;
+    encode(frame: F): Promise<Blob>;
+    crop(frame: F, box: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }): Promise<Blob>;
+    torch?: {
+        supported: boolean;
+        on: boolean;
+        set(on: boolean): Promise<boolean>;
+    };
+}
+export type SlotState = "empty" | "found" | "good";
+export interface FingerUi {
+    guide(k: FingerGuideId): void;
+    slots(states: SlotState[]): void;
+    hold(p: number): void;
+    stage(s: "searching" | "holding" | "torch" | "done"): void;
+    reading?(r: {
+        boxes: FingerBox[];
+        stats: Array<FingertipStats | null>;
+        guide: FingerGuideId;
+    }): void;
+}
+export interface FingerCaptureOutput {
+    file: Blob;
+    crops: Blob[];
+    boxes: Array<[number, number, number, number]>;
+    stats: FingertipStats[];
+    torch: {
+        supported: boolean;
+        response: number | null;
+    };
+}
+export type FingerRunResult = {
+    k: "captured";
+    out: FingerCaptureOutput;
+} | {
+    k: "failed";
+    reason: "FINGER_NOT_FOUND" | "FINGER_QUALITY_LOW";
+} | {
+    k: "aborted";
+};
+export declare function runFingerCapture<F>(group: FingerGroup, io: FingerIo<F>, ui: FingerUi, opts?: {
+    torch?: boolean;
+    floors?: FingerFloors;
+    timeoutMs?: number;
+    tickMs?: number;
+}): Promise<FingerRunResult>;

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

@@ -0,0 +1,10 @@
+import { type DeviceSignals, type TimelineSummary } from "../capture";
+export declare function fingerEvidence(input: {
+    nonce: string | null | undefined;
+    file: Blob;
+    crops: readonly Blob[];
+    positions: readonly string[];
+    timeline: TimelineSummary;
+    device: DeviceSignals | null;
+    tMs?: number;
+}): Promise<Record<string, unknown> | null>;

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

@@ -0,0 +1,31 @@
+import { type RefObject } from "react";
+import type { FingerCaptureProps } from "../FingerCapture";
+import { type FingerGroup, type Slot } from "./detector";
+import type { FingerGuideId } from "./qualityGate";
+import { type SlotState } from "./runFingerCapture";
+export type FingerPhase = "searching" | "holding" | "torch" | "uploading" | "done" | "error";
+export declare function useFingerCapture(props: FingerCaptureProps): {
+    t: import("../i18n").Strings;
+    source: "camera" | "demo";
+    phase: FingerPhase;
+    guide: FingerGuideId;
+    slotStates: SlotState[];
+    hold: number;
+    group: FingerGroup;
+    groups: FingerGroup[];
+    groupAt: number;
+    slots: Slot[];
+    src: {
+        w: number;
+        h: number;
+    };
+    error: string | null;
+    errorDetail: unknown;
+    retriesLeft: number | null;
+    final: boolean;
+    torchOn: boolean;
+    tele: string;
+    retry: () => void;
+    videoRef: RefObject<HTMLVideoElement | null>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+};

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

@@ -10,11 +10,14 @@ export interface TenantInstructions {
     front?: StepInstructions;
     back?: StepInstructions;
     face?: StepInstructions;
+    chip?: StepInstructions;
+    finger?: StepInstructions;
 }
 export interface StepInstructions {
     enabled?: boolean;
     en?: IntroText;
     "es-419"?: IntroText;
+    unreadableHint?: boolean;
 }
 export interface TenantReasonText {
     title?: string;
@@ -26,6 +29,7 @@ export declare function normalizeInstructions(raw: unknown): TenantInstructions
 export declare function normalizeMessages(raw: unknown): TenantMessages | undefined;
 export declare function introEnabled(step: CaptureId, ins?: TenantInstructions | null): boolean;
 export declare function confirmEnabled(ins?: TenantInstructions | null): boolean;
+export declare function unreadableHintEnabled(ins?: TenantInstructions | null): boolean;
 export declare function introFor(step: CaptureId, locale: Locale, t: Strings, ins?: TenantInstructions | null): Required<IntroText>;
 export declare function parseIntroBody(body: string): {
     paragraphs: string[];

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

@@ -3,4 +3,4 @@ export { SignInFlow } from "./SignInFlow";
 export { ReverificationFlow } from "./ReverificationFlow";
 export { IdentifyFlow } from "./IdentifyFlow";
 export { normalizeSession, captureNonceOf } from "./session";
-export type { EnrollmentFlowProps, SignInFlowProps, ReverificationFlowProps, IdentifyFlowProps, VerificationFlowProps, Purpose, IdentifyCandidate, DuplicateCandidate, ModelImprovementPrompt, ConsentChoice, OpenSessionContext, RpidSession, ApiSessionBody, SessionFlow, VerificationResult, VerificationAssessment, RpidFlowEvent, DocumentAuthenticity, ExtractionRecord, ExtractionField, Appearance, TenantInstructions, TenantMessages, SessionHandoff, HandoffOption, } from "./types";
+export type { EnrollmentFlowProps, SignInFlowProps, ReverificationFlowProps, IdentifyFlowProps, VerificationFlowProps, Purpose, IdentifyCandidate, DuplicateCandidate, ModelImprovementPrompt, ConsentChoice, OpenSessionContext, RpidSession, ApiSessionBody, SessionFlow, VerificationResult, VerificationAssessment, RpidFlowEvent, DocumentAuthenticity, ExtractionRecord, ExtractionField, Appearance, TenantInstructions, TenantMessages, SessionHandoff, HandoffOption, SessionChip, SessionFinger, FingerPosition, StepId, } from "./types";

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

@@ -0,0 +1,27 @@
+export declare const DEFAULT_SESSION_TTL_S = 900;
+export declare const RENEW_MARGIN_MS = 60000;
+export declare const MAX_SILENT_RENEWALS = 8;
+export declare const MAX_IDLE_MS: number;
+export type RenewReason = "expiring" | "resume" | "start" | "expired";
+export type RenewOutcome = "renewed" | "failed" | "unsupported" | "aborted" | "skipped";
+export interface SessionLife {
+    openedAt: number;
+    ttlMs: number;
+    silent: number;
+    touchedAt: number;
+}
+export declare function lifeOf(openedAt: number, expiresInS?: number, prev?: SessionLife | null, silent?: boolean): SessionLife;
+export declare const expiresAtOf: (l: SessionLife) => number;
+export declare const marginOf: (l: SessionLife) => number;
+export declare const renewDueAt: (l: SessionLife) => number;
+export declare const needsRenewal: (l: SessionLife, now: number) => boolean;
+export declare const maySilentlyRenew: (l: SessionLife, now: number) => boolean;
+export declare function useKeepFresh({ active, sessionId, life, renew, touch }: {
+    active: boolean;
+    sessionId: string;
+    life: {
+        readonly current: SessionLife | null;
+    };
+    renew: (why: RenewReason) => Promise<RenewOutcome>;
+    touch: () => void;
+}): void;

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

@@ -1,4 +1,8 @@
-import type { RpidSession, SessionFlow } from "./types";
+import type { FingerPosition, RpidSession, SessionChip, SessionFinger, SessionFlow, StepId } from "./types";
+export declare const FINGER_POSITIONS: readonly FingerPosition[];
+export declare function normalizeSteps(raw: unknown): StepId[] | undefined;
+export declare function normalizeChip(raw: unknown): SessionChip | undefined;
+export declare function normalizeFinger(raw: unknown): SessionFinger | undefined;
 export declare function normalizeFlow(raw: unknown): SessionFlow | undefined;
 export declare function normalizeSession(raw: unknown): RpidSession;
 export declare const captureNonceOf: (s: RpidSession | null | undefined) => string | null;