@baas-id/react 0.2.2

package/dist/types/continue.d.ts

@@ -0,0 +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";

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+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 { 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";
+export { encodeQr, qrPath, type QrMatrix } from "./react/handoff/qr";
+export { detectDevice, collectSnapshot, parseUserAgent, inAppBrowser, type DeviceKind, type DeviceReading } from "./react/telemetry/device";
+export { reportClient, subscribeClient, type ClientEvent, type ClientEventType } from "./react/telemetry/bus";
+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 { 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";
+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";

package/dist/types/preview.d.ts

@@ -0,0 +1,5 @@
+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 { 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";

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

@@ -0,0 +1,27 @@
+import { type Locale, type StringOverrides } from "./i18n";
+import { type RpidClientConfig } from "./capture";
+import type { SideOutcome } from "./document/sideCheck";
+export type SideRetake = Extract<SideOutcome, {
+    kind: "retake";
+}> & {
+    side: "front" | "back";
+    detail: unknown;
+};
+export interface DocumentCaptureProps {
+    config: RpidClientConfig;
+    side: "front" | "back";
+    source?: "camera" | "demo";
+    locale?: Locale;
+    strings?: StringOverrides;
+    modelsUrl?: string;
+    prompt?: string;
+    debug?: boolean;
+    documentFrames?: number;
+    captureNonce?: string | null;
+    confirmCapture?: boolean;
+    detector?: "tiny" | "legacy";
+    onCaptured: (serverResult: unknown, thumbnailDataUrl?: string) => void;
+    onRejected?: (reason: string, detail?: unknown) => void;
+    onRetake?: (retake: SideRetake) => void;
+}
+export declare function DocumentCapture(props: DocumentCaptureProps): import("react").JSX.Element;

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

@@ -0,0 +1,19 @@
+import { type Locale, type StringOverrides } from "./i18n";
+import { type AttestationProvider, type RpidClientConfig } from "./capture";
+import type { SelfieQualityFloors } from "./face/qualityGate";
+export interface FaceCaptureProps {
+    config: RpidClientConfig;
+    challengeScript: string[];
+    source?: "camera" | "demo";
+    locale?: Locale;
+    strings?: StringOverrides;
+    debug?: boolean;
+    modelsUrl?: string;
+    challengeMs?: number;
+    quality?: Partial<Record<keyof SelfieQualityFloors, number | null>> | null;
+    captureNonce?: string | null;
+    attestation?: AttestationProvider;
+    onCaptured: (serverResult: unknown) => void;
+    onRejected?: (reason: string, detail?: unknown) => void;
+}
+export declare function FaceCapture(props: FaceCaptureProps): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import { type Proximity } from "../liveness";
+import type { Strings } from "../i18n";
+export declare function ProximityMeter({ centered, faceW, proximity, found, strings, }: {
+    centered: number;
+    faceW: number;
+    proximity: Proximity;
+    found: boolean;
+    strings: Strings;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import type { Strings } from "../i18n";
+export declare function TurnGauge({ direction, progress, wrongWay, confidence, strings, }: {
+    direction: "left" | "right";
+    progress: number;
+    wrongWay: boolean;
+    confidence?: number;
+    strings: Strings;
+}): import("react").JSX.Element;
+export declare function turnGaugeFrom(yaw: number, direction: "left" | "right"): {
+    progress: number;
+    wrongWay: boolean;
+};

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

@@ -0,0 +1,6 @@
+export declare function YawDial({ yaw, target, reached, confidence, }: {
+    yaw: number;
+    target: number;
+    reached: boolean;
+    confidence?: number;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,50 @@
+export { type DocumentAuthenticity, type Rejection, authenticityOf, errorCode, isAbort, rejectionOf } from "./errors";
+export interface RpidClientConfig {
+    apiUrl: string;
+    sessionId: string;
+    captureToken: string;
+}
+export type Json = Record<string, unknown>;
+export interface CaptureUpload {
+    side?: "front" | "back";
+    meta?: Record<string, unknown>;
+    mrzReadings?: string[];
+    capture?: Record<string, unknown> | null;
+    keyframes?: Blob[];
+    frames?: Blob[];
+    edgeAuthenticity?: Record<string, unknown> | object | null;
+    signal?: AbortSignal;
+}
+export declare function uploadCaptureSignal(cfg: RpidClientConfig, kind: "document" | "face", blob: Blob, { side, meta, mrzReadings, capture, keyframes, frames, edgeAuthenticity, signal }?: CaptureUpload): Promise<any>;
+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 MrzProbe {
+    available: boolean;
+    mrz: {
+        found: boolean;
+        raw_text?: string | null;
+        type?: string | null;
+        valid?: boolean;
+        fields_valid?: boolean;
+        score?: number | null;
+        checks?: Record<string, boolean>;
+        failed?: string[];
+        fields?: Record<string, string | null>;
+    };
+    screen?: {
+        available: boolean;
+        score: number;
+        verdict: string;
+        calibrated?: boolean;
+        mode?: string;
+        signals?: Record<string, number>;
+    };
+    elapsed_ms?: number;
+    retries_left?: number;
+    finalized?: boolean;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    reason?: string;
+}
+export declare function probeDocumentSignal(cfg: RpidClientConfig, blob: Blob, signal?: AbortSignal): Promise<MrzProbe | null>;
+export declare function probeDocument(cfg: RpidClientConfig, blob: Blob): Promise<MrzProbe | null>;

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

@@ -0,0 +1,32 @@
+import { type DeviceSignals } from "./integrity";
+export type AttestationName = "web" | "play_integrity" | "app_attest";
+export type AttestationClaim = {
+    provider: "web";
+    v: 1;
+    device: DeviceSignals;
+} | {
+    provider: "play_integrity";
+    v: 1;
+    request_hash: string;
+    token: string;
+} | {
+    provider: "app_attest";
+    v: 1;
+    request_hash: string;
+    key_id: string;
+    assertion: string;
+    attestation?: string;
+};
+export interface AttestationInput {
+    nonce: string;
+    digest: string;
+    stream: MediaStream | null;
+}
+export interface AttestationProvider {
+    readonly name: AttestationName;
+    claim(input: AttestationInput): Promise<AttestationClaim>;
+}
+export declare function requestHash(nonce: string, digest: string): Promise<string>;
+export declare const webAttestation: AttestationProvider;
+export type NativeMint = (requestHashHex: string) => Promise<Record<string, string>>;
+export declare function nativeAttestation(name: "play_integrity" | "app_attest", mint: NativeMint): AttestationProvider;

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

@@ -0,0 +1,51 @@
+import type { AttestationClaim } from "./attestation";
+import type { DeviceSignals } from "./integrity";
+export interface TimelineSummary {
+    duration_ms: number;
+    frames: number;
+    interval_mean_ms: number;
+    interval_sd_ms: number;
+    interval_min_ms: number;
+    interval_max_ms: number;
+    challenge_ms: number[];
+}
+export declare class FrameTimeline {
+    private first;
+    private last;
+    private n;
+    private sum;
+    private sumSq;
+    private min;
+    private max;
+    private marks;
+    tick(now: number): void;
+    mark(now: number): void;
+    summary(now: number): TimelineSummary;
+}
+export declare function subtleCrypto(): SubtleCrypto | null;
+export declare function sha256Hex(bytes: ArrayBuffer): Promise<string>;
+export declare function hmacSha256Hex(key: string, message: string): Promise<string>;
+export interface KeyframeRef {
+    tag: string;
+    t_ms: number;
+    digest: string;
+}
+export interface CaptureBlock {
+    v: 1 | 2;
+    nonce: string;
+    digest: string;
+    mac: string;
+    timeline: TimelineSummary;
+    device: DeviceSignals | null;
+    keyframes?: KeyframeRef[];
+    attestation?: AttestationClaim | null;
+}
+export declare function macMessage(digest: string, timeline: Pick<TimelineSummary, "duration_ms" | "frames">, keyframeDigests?: readonly string[]): string;
+export declare function captureBlock(nonce: string, bytes: ArrayBuffer, timeline: TimelineSummary, device: DeviceSignals | null, extra?: {
+    keyframes?: {
+        tag: string;
+        t_ms: number;
+        bytes: ArrayBuffer;
+    }[];
+    attestation?: AttestationClaim | null;
+}): Promise<CaptureBlock | null>;

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

@@ -0,0 +1,4 @@
+export type CameraProfile = "default" | "document";
+export declare function cameraConstraints(facing: "environment" | "user", profile: CameraProfile): MediaTrackConstraints;
+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/chrome.d.ts

@@ -0,0 +1,24 @@
+import { type CSSProperties, type ReactNode, type RefObject } from "react";
+export declare function CaptureViewport({ className, source, videoRef, canvasRef, mirror, attrs, style, children, }: {
+    className: string;
+    style?: CSSProperties;
+    source: "camera" | "demo";
+    videoRef: RefObject<HTMLVideoElement | null>;
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+    mirror?: boolean;
+    attrs?: Record<`data-${string}`, string>;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function Guide({ tone, children, marker, }: {
+    tone: "info" | "ok" | "warn";
+    children: ReactNode;
+    marker?: boolean;
+}): import("react").JSX.Element;
+export declare function RetryButton({ label, onRetry }: {
+    label: string;
+    onRetry: () => void;
+}): import("react").JSX.Element;
+export declare function Telemetry({ phase, text }: {
+    phase: string;
+    text: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,2 @@
+export declare function demoDocumentFrame(canvas: HTMLCanvasElement, side: "front" | "back", settled: number): void;
+export declare function demoFaceFrame(canvas: HTMLCanvasElement, settled: number): void;

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

@@ -0,0 +1,18 @@
+import type { Json } from "./api";
+export declare function errorCode(e: unknown, fallback: string): string;
+export interface Rejection {
+    retriesLeft: number | null;
+    finalized: boolean;
+    verdict?: "REJECTED" | "NEEDS_REVIEW";
+    reason?: string;
+    body: Json;
+}
+export declare function rejectionOf(e: unknown): Rejection;
+export interface DocumentAuthenticity {
+    score: number;
+    flags: Array<"screen" | "paper" | "tampering" | "damage" | (string & {})>;
+    signals?: Record<string, number>;
+    model?: string;
+}
+export declare function authenticityOf(e: unknown): DocumentAuthenticity | undefined;
+export declare const isAbort: (e: unknown) => boolean;

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

@@ -0,0 +1,18 @@
+export interface Quality {
+    sharpness: number;
+    glare: number;
+    fill: number;
+}
+export interface ProbeRegion {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare function moireProbe(canvas: HTMLCanvasElement, region?: number | ProbeRegion): number;
+export declare function analyzeFrame(canvas: HTMLCanvasElement): Quality;
+export declare function grabFrame(video: HTMLVideoElement | null, canvas: HTMLCanvasElement, maxLong?: number): boolean;
+export declare function readPixels(canvas: HTMLCanvasElement, region: ProbeRegion): ImageData | null;
+export declare function canvasToJpeg(canvas: HTMLCanvasElement): Promise<Blob>;
+export declare function thumbnailOf(source: HTMLCanvasElement, width?: number): string | undefined;
+export declare function haptic(ms: number): void;

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

@@ -0,0 +1,15 @@
+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 { 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";
+export { useCaptureRun, useLatest } from "./useCaptureRun";
+export { CaptureViewport, Guide, RetryButton, Telemetry } from "./chrome";
+export { EngineLoading, ProcessingOverlay, engineTelemetry } from "./overlays";
+export { ProximityMeter } from "./ProximityMeter";
+export { TurnGauge, turnGaugeFrom } from "./TurnGauge";
+export { YawDial } from "./YawDial";
+export { collectDevice, deviceSignals, virtualCameraFamily, type DeviceSignals, type DeviceInput } from "./integrity";
+export { FrameTimeline, captureBlock, macMessage, sha256Hex, hmacSha256Hex, type CaptureBlock, type KeyframeRef, type TimelineSummary, } from "./binding";
+export { KeyframeRecorder, keyframeSize, admit as admitKeyframe, MAX_KEYFRAMES, KEYFRAME_MAX_SIDE, type Keyframe } from "./keyframes";
+export { webAttestation, nativeAttestation, requestHash, type AttestationProvider, type AttestationClaim, type AttestationName, type NativeMint, } from "./attestation";

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

@@ -0,0 +1,32 @@
+export declare const VIRTUAL_CAMERA_PATTERNS: ReadonlyArray<readonly [string, RegExp]>;
+export interface DeviceInput {
+    label?: string;
+    settings?: {
+        width?: number;
+        height?: number;
+        frameRate?: number;
+        facingMode?: string;
+        resizeMode?: string;
+    };
+    webdriver?: boolean;
+    userAgent?: string;
+    maxTouchPoints?: number;
+    glRenderer?: string | null;
+}
+export interface DeviceSignals {
+    virtual_camera: boolean;
+    label_family: string | null;
+    webdriver: boolean;
+    headless: boolean;
+    emulator: string[];
+    track: {
+        width?: number;
+        height?: number;
+        frameRate?: number;
+        facingMode?: string;
+        resizeMode?: string;
+    };
+}
+export declare function virtualCameraFamily(label: string | undefined): string | null;
+export declare function deviceSignals(input: DeviceInput): DeviceSignals;
+export declare function collectDevice(stream: MediaStream | null): DeviceSignals;

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

@@ -0,0 +1,19 @@
+export declare const MAX_KEYFRAMES = 5;
+export declare const KEYFRAME_MAX_SIDE = 480;
+export declare const KEYFRAME_QUALITY = 0.8;
+export interface Keyframe {
+    tag: string;
+    t_ms: number;
+    blob: Blob;
+}
+export declare function keyframeSize(w: number, h: number, maxSide?: number): {
+    w: number;
+    h: number;
+};
+export declare function admit(tags: readonly string[], tag: string, max?: number): boolean;
+export declare class KeyframeRecorder {
+    private pending;
+    private tags;
+    grab(video: HTMLVideoElement | null, tag: string, tMs: number): void;
+    collect(): Promise<Keyframe[]>;
+}

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

@@ -0,0 +1,10 @@
+import type { Strings } from "../i18n";
+import type { EngineProgress } from "../vision";
+export declare const engineTelemetry: (t: Strings, p: EngineProgress) => string;
+export declare function EngineLoading({ progress, strings, }: {
+    progress: EngineProgress | null;
+    strings: Strings;
+}): import("react").JSX.Element;
+export declare function ProcessingOverlay({ strings }: {
+    strings: Strings;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+export interface CaptureRun {
+    readonly signal: AbortSignal;
+    alive(): boolean;
+    wait(ms: number): Promise<void>;
+    later(ms: number, fn: () => void): void;
+    every(ms: number, fn: () => void): void;
+    hold(stream: MediaStream): MediaStream;
+    defer(fn: () => void): void;
+    dispose(): void;
+}
+export declare function createCaptureRun(): CaptureRun;
+export type TickResult = "stop" | void;
+export declare function frameLoop(run: CaptureRun, intervalMs: number, tick: () => TickResult | Promise<TickResult>): void;
+export declare function nextFrame(run: CaptureRun, maxMs?: number): Promise<void>;

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

@@ -0,0 +1,4 @@
+import { type DependencyList } from "react";
+import { type CaptureRun } from "./run";
+export declare function useCaptureRun(body: (run: CaptureRun) => void | Promise<void>, deps: DependencyList): void;
+export declare function useLatest<T>(value: T): import("react").MutableRefObject<T>;

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

@@ -0,0 +1,10 @@
+import type { Strings } from "../i18n";
+import type { QuadSource } from "./track";
+export type FrameState = "searching" | "tracking" | "holding" | "locked";
+export declare function CardFrame({ source, pct, state, label, t, }: {
+    source: QuadSource | null;
+    pct: number;
+    state: FrameState;
+    label?: string;
+    t?: Strings;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,49 @@
+import type { Strings } from "../i18n";
+import type { MrzProbe } from "../capture";
+import type { Chip } from "./gate";
+import type { MrzStage } from "./mrz";
+import type { CardInset, Review } from "./review";
+import { type SideOutcome } from "./sideCheck";
+export { CardFrame, type FrameState } from "./CardFrame";
+export declare function CardSnapshot({ url, aspect, from, t }: {
+    url: string;
+    aspect: number;
+    from: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    } | null;
+    t: Strings;
+}): import("react").JSX.Element;
+export declare function CaptureReview({ image, aspect, review, t, confirm, outline }: {
+    image: string;
+    aspect: number;
+    review: Review;
+    t: Strings;
+    confirm?: boolean;
+    outline?: CardInset | null;
+}): import("react").JSX.Element;
+export declare function ReviewSheet({ review, t, confirm }: {
+    review: Review;
+    t: Strings;
+    confirm?: boolean;
+}): import("react").JSX.Element;
+export declare function QualityChips({ chips, t }: {
+    chips: Chip[];
+    t: Strings;
+}): import("react").JSX.Element;
+export declare function MrzStatus({ stage, mrz, t }: {
+    stage: MrzStage;
+    mrz: MrzProbe["mrz"] | null;
+    t: Strings;
+}): import("react").JSX.Element | null;
+export declare function RetakePanel({ outcome, side, t, onRetake, onContinue, }: {
+    outcome: Exclude<SideOutcome, {
+        kind: "ok";
+    }>;
+    side: "front" | "back";
+    t: Strings;
+    onRetake: () => void;
+    onContinue: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,47 @@
+import type { AuthenticityCue } from "./gate";
+import type { SpecularSignature } from "../vision/authenticity";
+export type Advisory = "screen" | "paper";
+export declare const HINT_AFTER_TICKS = 3;
+export declare const HINT_MS = 4000;
+export interface AdvisoryReading {
+    cue: AuthenticityCue | null;
+    moire: number;
+    grid: number;
+    texture: number;
+    specular: SpecularSignature;
+    corner: number | null;
+}
+export interface EdgeAuthenticitySummary {
+    v: 1;
+    model: string;
+    ticks: number;
+    raised: {
+        screen: number;
+        paper: number;
+    };
+    advisory: Advisory | null;
+    hinted: boolean;
+    moire_max: number;
+    grid_max: number;
+    texture_max: number;
+    gloss: number | null;
+    static: number | null;
+    specular_frames: number;
+    corner: number | null;
+}
+export declare const EDGE_AUTH_MODEL = "edge-auth-v2-advisory";
+export declare const advisoryOf: (cue: AuthenticityCue | null) => Advisory | null;
+export declare class AdvisoryLog {
+    private ticks;
+    private raised;
+    private run;
+    private persisted;
+    private hinted;
+    private moireMax;
+    private gridMax;
+    private textureMax;
+    private last;
+    record(r: AdvisoryReading): Advisory | null;
+    summary(): EdgeAuthenticitySummary;
+    interrupt(): void;
+}

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

@@ -0,0 +1,18 @@
+export declare const DEFAULT_DOCUMENT_FRAMES = 3;
+export declare const MAX_DOCUMENT_FRAMES = 5;
+export declare function frameScore(detConfidence: number, sideConfidence: number, blurScore: number): number;
+export declare function frameCount(n: number | undefined): number;
+export interface Ranked<T> {
+    item: T;
+    score: number;
+    t: number;
+}
+export declare class BestFrames<T> {
+    private readonly n;
+    private kept;
+    constructor(n: number);
+    wouldAdmit(score: number): boolean;
+    offer(item: T, score: number, t: number): void;
+    ranked(): Ranked<T>[];
+    clear(): void;
+}

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

@@ -0,0 +1,28 @@
+import type { CropQuality } from "../vision";
+import { type SpecularSignature } from "../vision/authenticity";
+import { type GuideId } from "./gate";
+export interface CardReading {
+    side: "front" | "back";
+    areaFrac: number;
+    aspect: number;
+    sideConfidence: number;
+    moire: number;
+    quality: Pick<CropQuality, "isBlurred" | "hasGlare" | "lighting">;
+    grid?: number;
+    specular?: SpecularSignature;
+    corner?: number | null;
+    texture?: number;
+    cardPx?: number;
+    needPx?: number;
+    outline?: {
+        aspect: number;
+        tilt: number;
+    } | null;
+    lowContrast?: boolean;
+}
+export type AuthenticityCue = "moire" | "grid" | "static" | "paper";
+export declare function screenCue(r: Pick<CardReading, "moire" | "grid" | "specular">): AuthenticityCue | null;
+export declare function paperCue(r: Pick<CardReading, "specular" | "corner" | "texture">): boolean;
+export declare function authenticityCue(r: CardReading): AuthenticityCue | null;
+export declare function cardIssue(r: CardReading): GuideId | null;
+export declare const holdFraction: (since: number, now: number, holdMs?: number) => number;

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

@@ -0,0 +1,52 @@
+import { type Box, type Pt, type Quad } from "./overlay";
+export declare const FLOW_W = 160;
+export declare const FLOW_R = 8;
+export declare const FLOW_MIN_CONTRAST = 0.12;
+export interface Gray {
+    data: Uint8Array;
+    w: number;
+    h: number;
+}
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare function lumaOf(rgba: Uint8ClampedArray | Uint8Array, w: number, h: number): Gray;
+export declare function half(g: Gray): Gray;
+export declare function matchShift(prev: Gray, cur: Gray, roi: Rect, R?: number, guess?: {
+    dx: number;
+    dy: number;
+}): {
+    dx: number;
+    dy: number;
+    ok: boolean;
+};
+export declare function flowRoi(b: Box, scale: number, shrink?: number): Rect;
+export declare class FlowTimeline {
+    private ts;
+    private xs;
+    private ys;
+    private ox;
+    private oy;
+    push(t: number, dx: number, dy: number): void;
+    at(t: number): Pt;
+    reset(): void;
+}
+export declare const REANCHOR = 0.12;
+export declare const READING_WEIGHT = 0.6;
+export declare class AnchoredQuad {
+    private readonly flow;
+    private q;
+    private o;
+    private pending;
+    constructor(flow: FlowTimeline);
+    read(q: Quad, t: number, opts?: {
+        force?: boolean;
+        weight?: number;
+    }): void;
+    at(now: number): Quad | null;
+    box(now: number): Box | null;
+    reset(): void;
+}