@baas-id/react 0.3.0 → 0.3.5

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/document/CardFrame.d.ts

@@ -1,6 +1,17 @@
 import type { Strings } from "../i18n";
+import { type Quad } from "./overlay";
 import type { QuadSource } from "./track";
 export type FrameState = "searching" | "tracking" | "holding" | "locked";
+export interface OutlinePath {
+    d: string;
+    length: number;
+    corners: Array<[number, number]>;
+    sides: number[];
+}
+export declare function outlinePath(q: Quad, radius: number): OutlinePath;
+export type Dash = readonly [string, string];
+export declare function dashOnly(from: number, to: number, length: number): Dash;
+export declare function dashProgress(o: OutlinePath, pct: number): Dash;
 export declare function CardFrame({ source, pct, state, label, t, }: {
     source: QuadSource | null;
     pct: number;

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/stats.d.ts

@@ -10,7 +10,7 @@ export declare class CaptureStats {
     private coach;
     private mode;
     constructor(t0: number);
-    frame(found: boolean, confidence: number, veto?: "geometry" | "edges" | "content"): void;
+    frame(found: boolean, confidence: number, veto?: "geometry" | "edges" | "content" | "face", relaxed?: "held" | "stable"): 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;

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/flows/FlowShell.d.ts

@@ -23,6 +23,8 @@ export declare function StepRail({ step, t, plan, retakes, }: {
     plan?: readonly CaptureId[];
     retakes?: Partial<Record<Side, RetakeNotice>>;
 }): import("react").JSX.Element;
+export declare function watchModality(): () => void;
+export declare function focusTitle(el: HTMLElement): void;
 export declare function RetakeNoticeLine({ notice, side, t }: {
     notice: RetakeNotice;
     side: Side;

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

@@ -229,6 +229,7 @@ export interface ConsentChoice {
 }
 export interface OpenSessionContext {
     consent?: ConsentChoice;
+    previousSessionId?: string;
 }
 export interface VerificationFlowProps {
     apiUrl: string;

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

@@ -2,6 +2,11 @@ import { type Formality, type Locale, type StringOverrides, type Strings } from
 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 declare function readLastLook(now?: number): {
+    locale?: string;
+    formality?: Formality;
+} | null;
+export declare const CONTINUE_DEFAULT_LOCALE: Locale;
 export interface ContinueFlowProps {
     apiUrl: string;
     code: string | null;
@@ -18,14 +23,22 @@ export interface ContinueFlowProps {
         verdict: string;
         reason: string | null;
     }) => void;
+    onLanguage?: (language: {
+        locale: Locale;
+        formality: Formality;
+    }) => void;
 }
-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 ContinueFlow({ apiUrl, code, modelsUrl, locale: hostLocale, strings, formality, colorScheme, privacyNote, source, debug, onEvent, onDone, onLanguage, }: ContinueFlowProps): import("react").JSX.Element;
 export declare function ContinueConfirmView({ t, tenant, codeHint, onContinue }: {
     t: Strings;
     tenant: string;
     codeHint: string;
     onContinue?: () => void;
 }): import("react").JSX.Element;
-export declare function ContinueDoneView({ t }: {
+export type DoneStep = "front" | "back" | "face";
+export declare function ContinueDoneView({ t, tenant, codeHint, steps }: {
     t: Strings;
+    tenant?: string | null;
+    codeHint?: string | null;
+    steps?: readonly DoneStep[];
 }): import("react").JSX.Element;

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

@@ -11,6 +11,11 @@ export interface HandoffCopy {
     body?: string;
 }
 export declare const POLL_MS = 2000;
+export declare function linkOnce(config: RpidClientConfig, previous: {
+    sessionId: string;
+    captureToken: string;
+}): void;
+export declare function resetLinkedPairs(): void;
 export interface HandoffPanelProps {
     config: RpidClientConfig;
     t: Strings;
@@ -23,6 +28,16 @@ export interface HandoffPanelProps {
     onEvent?: (e: RpidFlowEvent) => void;
     pollMs?: number;
 }
+export declare const FOLLOW_KEY = "rpid.handoff.follow";
+interface FollowRecord {
+    apiUrl: string;
+    sessionId: string;
+    captureToken: string;
+    at: number;
+}
+export declare function rememberFollow(cfg: RpidClientConfig): void;
+export declare function forgetFollow(sessionId?: string): void;
+export declare function readFollow(): FollowRecord | null;
 export declare function HandoffPanel({ config, t, mode, copy, onResult, onContinueHere, onError, onFailed, onEvent, pollMs, }: HandoffPanelProps): import("react").JSX.Element;
 export interface HandoffViewProps {
     t: Strings;
@@ -50,8 +65,10 @@ export interface HandoffViewProps {
         final: boolean;
     } | null;
     onAgain?: () => void;
+    retrying?: boolean;
+    resumed?: boolean;
 }
-export declare function HandoffView({ t, mode, copy, link, leftMs, expired, failed, phase, device, copied, linkId, onCopy, onNewCode, onContinueHere, stopped, onAgain, }: HandoffViewProps): import("react").JSX.Element;
+export declare function HandoffView({ t, mode, copy, link, leftMs, expired, failed, phase, device, copied, linkId, onCopy, onNewCode, onContinueHere, stopped, onAgain, retrying, resumed, }: HandoffViewProps): import("react").JSX.Element;
 export declare function CodeChip({ t, code, instruction }: {
     t: Strings;
     code: string;
@@ -74,3 +91,4 @@ export interface ContinueOnPhoneProps {
     colorScheme?: ColorScheme;
 }
 export declare function ContinueOnPhone(props: ContinueOnPhoneProps): import("react").JSX.Element;
+export {};

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

@@ -28,6 +28,10 @@ export interface HandoffStatus {
 export declare function createHandoff(cfg: RpidClientConfig, device?: string, signal?: AbortSignal): Promise<HandoffCode>;
 export declare function handoffStatus(cfg: RpidClientConfig, signal?: AbortSignal): Promise<HandoffStatus>;
 export declare function revokeHandoff(cfg: RpidClientConfig, reason: "continue_here" | "cancel"): Promise<void>;
+export declare function linkSession(cfg: RpidClientConfig, previous: {
+    sessionId: string;
+    captureToken: string;
+}): Promise<boolean>;
 export interface HandoffPeek {
     tenant: string;
     codeHint: string;
@@ -43,6 +47,7 @@ export interface CallLanguage {
     formality?: "formal" | "informal";
 }
 export declare function peekHandoff(apiUrl: string, code: string, signal?: AbortSignal, lang?: CallLanguage): Promise<HandoffPeek>;
+export declare function refusalLanguage(e: unknown): CallLanguage | null;
 export declare function claimHandoff(apiUrl: string, code: string, device?: string, signal?: AbortSignal, lang?: CallLanguage): Promise<Json>;
 export declare function reportProgress(cfg: RpidClientConfig, step: "front" | "back" | "face"): Promise<void>;
 export declare function reportPhone(cfg: RpidClientConfig, event: "heartbeat" | "failed" | "abandoned", info?: {

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

@@ -138,6 +138,8 @@ export interface Strings {
         notBackBody: string;
         noPortraitTitle: string;
         noPortraitBody: string;
+        qualityTitle: string;
+        qualityBody: string;
         backMismatchTitle: string;
         backMismatchBody: string;
         frontMismatchTitle: string;
@@ -206,6 +208,16 @@ export interface Strings {
         phoneClosedBody: string;
         resumeOnPhone: string;
         continueHereShort: string;
+        phoneRetryWait: string;
+        retrying: string;
+        resumed: string;
+        doneHeading: string;
+        doneSent: string;
+        doneOnComputer: string;
+        doneFor: string;
+        doneCode: string;
+        doneClose: string;
+        doneCloseHint: string;
         stepWaiting: string;
         stepConnected: string;
         stepCapturing: string;

package/dist/types/react/theme/scheme.d.ts

@@ -19,5 +19,22 @@ export declare function darkPalette(a?: Appearance | null): {
 };
 export declare function darkGroups(a?: Appearance | null): Array<Record<string, string>>;
 export declare const DARK_DERIVED: Record<string, string>;
+export declare function parseCssColor(c: string | null | undefined): [number, number, number, number] | null;
+export declare function relLuminance([r, g, b]: readonly number[]): number;
+export declare const ratioOf: (a: readonly number[], b: readonly number[]) => number;
+export type SchemeSource = "prop" | "page" | "color-scheme" | "device";
+export declare function effectiveBackground(from: Element | null): [number, number, number] | null;
+export declare function hostScheme(from: Element | null): {
+    scheme: "light" | "dark";
+    from: SchemeSource;
+} | null;
+export declare function useSchemeOf(pref: ColorScheme | undefined, ref?: {
+    current: Element | null;
+}): {
+    scheme: "light" | "dark";
+    from: SchemeSource;
+    rev: number;
+};
 export declare function useColorScheme(pref: ColorScheme | undefined): "light" | "dark";
+export declare function guardInk(ink: readonly number[] | null, grounds: ReadonlyArray<readonly number[]>): string | null;
 export declare const isColorScheme: (v: unknown) => v is ColorScheme;

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

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.3.0";
+export declare const SDK_VERSION = "0.3.5";

package/dist/types/react/vision/corners.d.ts

@@ -34,7 +34,7 @@ export interface CornerResult {
     aspect: number;
     contrast: number;
     reason: CornerReason | null;
-    via: "edges" | "hint" | "model" | null;
+    via: "edges" | "hint" | "model" | "refined" | null;
     orient?: [number, number, number, number];
 }
 export interface CornerOptions {

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

@@ -6,12 +6,25 @@ type Oval = {
     rx: number;
     ry: number;
 };
+export declare const SQUARE_SIDE = 384;
+export declare function letterboxSquare(W: number, H: number, side: number): {
+    k: number;
+    x: number;
+    y: number;
+};
+export declare function fromSquare(f: FaceDetection, lb: {
+    k: number;
+    x: number;
+    y: number;
+}): FaceDetection;
 export interface FaceDetection {
     topLeft: [number, number];
     bottomRight: [number, number];
     landmarks: Array<[number, number]>;
 }
 export declare function signalsFromDetection(f: FaceDetection | null, W: number, H: number, brightness: number, oval: Oval): FaceSignals;
+export declare const FACE_W_PER_IOD = 2.03;
+export declare function faceWidthFrom(landmarks: Array<[number, number]>, x1: number, x2: number, W: number, H: number): number;
 export declare function ovalContainment(pts: Array<[number, number]>, oval: Oval): number;
 export declare const loadFaceEngine: (modelsUrl: string, onProgress?: ProgressFn) => Promise<FaceEngine>;
 export {};

package/dist/types/react/vision/quality.d.ts

@@ -1,7 +1,10 @@
 import type { CropQuality } from "./types";
-export declare function cropQuality(crop: HTMLCanvasElement): CropQuality;
+export declare function cropQuality(crop: HTMLCanvasElement, card?: ReadonlyArray<{
+    x: number;
+    y: number;
+}> | null): CropQuality;
 export declare function lightingOf(brightness: number): "good" | "too_dark" | "too_bright";
-export declare function frameLuma(video: HTMLVideoElement): number;
+export declare function frameLuma(video: HTMLVideoElement | HTMLCanvasElement): number;
 export declare function cropCanvas(source: HTMLCanvasElement, box: {
     left: number;
     top: number;

package/dist/types/react/vision/refine.d.ts

@@ -0,0 +1,71 @@
+import { type Quad } from "./corners";
+export interface Luma {
+    data: Float32Array;
+    width: number;
+    height: number;
+}
+export interface Refined {
+    quad: Quad | null;
+    ok: boolean;
+    support: [number, number, number, number];
+    aspect: number;
+    tilt: number;
+    score: number;
+    reason: "ok" | "no_lines" | "no_card_shape" | "small";
+}
+export declare const BAND_OUT = 0.08;
+export declare const BAND_IN = 0.24;
+export declare const VALLEY = 2;
+export declare const NEAR = 0.035;
+export declare const SCANS = 28;
+export declare const SIDE_SUPPORT_MIN = 0.45;
+export declare const MEAN_SUPPORT_MIN = 0.6;
+export declare const REFINE_TILT_MAX = 50;
+export declare const MAX_SHIFT = 0.2;
+export declare const refineAspectTol: (tilt: number) => number;
+interface Pt {
+    x: number;
+    y: number;
+    t: number;
+    sign: number;
+    mag: number;
+}
+interface Line {
+    px: number;
+    py: number;
+    dx: number;
+    dy: number;
+    support: number;
+    mag: number;
+    sign: number;
+    span: number;
+}
+export declare function sidePoints(g: Luma, a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}, cen: {
+    x: number;
+    y: number;
+}, size: number, band?: {
+    out: number;
+    inn: number;
+}): Pt[];
+export declare function sideLines(pts: Pt[], ux: number, uy: number, max?: number): Line[];
+export declare function refineQuad(g: Luma, coarse: Quad, cam: {
+    focal: number;
+    cx: number;
+    cy: number;
+}, debug?: (x: unknown) => void, opts?: {
+    search?: boolean;
+}): Refined;
+export declare function trackQuad(g: Luma, hint: Quad, cam: {
+    focal: number;
+    cx: number;
+    cy: number;
+}): Refined;
+export declare const TRACK_BAND = 0.05;
+export declare function lumaOfRegion(rgba: Uint8ClampedArray, width: number, height: number): Luma;
+export {};

package/dist/types/react/vision/tinyDetector.d.ts

@@ -1,11 +1,17 @@
 import { type Quad } from "./corners";
 import type { CardDetection, DocumentEngine, ProgressFn } from "./types";
 export declare const TINY_FOLDERS: readonly ["card-tinydet-r6", "card-tinydet-r4"];
+export declare const RELAX_STREAK = 3;
+export declare const RELAX_MOTION = 0.04;
+export declare const RELAX_DETAIL = 0.25;
+export declare const RELAX_SIDES = 2;
+export declare const FACE_FILL_MAX = 0.2;
 export declare const ORIENT_VOTE_MIN = 0.6;
 export declare const TINY_INPUT = 224;
 export declare const TINY_GRID = 28;
 export declare const FOUND_PEAK = 0.03;
 export declare const LOCK_PEAK = 0.05;
+export declare const RESCUE_PEAK: number;
 export declare const MIN_AREA_FRAC = 0.02;
 export declare const EDGE_PRESENT = 0.25;
 export interface Letterbox {

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

@@ -13,7 +13,8 @@ export interface CardDetection {
     };
     weak?: boolean;
     corners?: FrameCorners;
-    veto?: "geometry" | "edges" | "content";
+    veto?: "geometry" | "edges" | "content" | "face";
+    relaxed?: "held" | "stable";
 }
 export interface SideResult {
     isFront: boolean;
@@ -43,16 +44,22 @@ export interface DocumentEngine {
     cropTurn?(card: HTMLCanvasElement): Promise<{
         upsideDown: boolean;
         margin: number;
+        probs?: [number, number, number, number];
     } | null>;
 }
 export interface DetectOptions {
     corners?: {
         ks: number;
         hint?: Quad | null;
+        recent?: Quad | null;
+        faces?: (source: HTMLCanvasElement) => Promise<Array<{
+            topLeft: [number, number];
+            bottomRight: [number, number];
+        }>>;
     };
 }
 export interface FaceEngine {
-    signals(video: HTMLVideoElement, oval: {
+    signals(video: HTMLVideoElement | HTMLCanvasElement, oval: {
         cx: number;
         cy: number;
         rx: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baas-id/react",
-  "version": "0.3.0",
+  "version": "0.3.5",
   "description": "BaaS identity verification for React: guided ID and face capture with on-device quality gating, server-side verdicts, phone handoff. Requires a BaaS account.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "BaaS, S.A.",