@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/{types-Bdf8_LYB2.d.ts → types-byBHOzCG2.d.ts}

@@ -1,15 +1,177 @@
-import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { n as IRecordingCapability, o as IncodeCanvas, r as RecordingConnection, t as IStorageCapability } from "./IStorageCapability-ORkQfK3F.js";
-import { a as RegulationTypes, n as Flow, o as TutorialIdConfig } from "./types-KPvmag_B.js";
+import { y as IncodeCanvas } from "./createFaceAvatar-BlcTYgJv.js";
+import { a as RegulationTypes, n as Flow, o as TutorialIdConfig } from "./types-Do5rEXij.js";
+import { i as IStorageCapability } from "./IWasmUtilCapability-CNWRl7jr.js";
 import { t as PermissionResult } from "./types-BEwVKkLJ.js";
-import { n as StreamCanvasCapture, t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
-import { i as Pdf417DecodeResult, n as IIdCaptureCapability, r as IdCaptureSettings, t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
+import { n as DeepsightService, t as StreamCanvasCapture } from "./StreamCanvasCapture-_8gdW5Lk.js";
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { i as Pdf417DecodeResult, n as IIdCaptureCapability, r as IdCaptureSettings, t as DetectionOrientation } from "./IIdCaptureCapability-RNiFhvXR.js";
+//#region ../infra/src/capabilities/IDigitalCredentialsCapability.d.ts
+/**
+ * Digital Credentials capability — wraps the W3C Digital Credentials API
+ * (`navigator.credentials.get()` with a `digital` request) used to pull a
+ * verified credential (e.g. an mDL) from an OS wallet such as Apple Wallet
+ * (web) or Google Wallet.
+ *
+ * The request payloads are built entirely by the Incode backend and are
+ * opaque to the SDK; the wallet's response is likewise an opaque string that
+ * is forwarded to the backend for decryption.
+ */
+/** Wallet protocols the SDK requests credentials with. */
+type DigitalCredentialProtocol = 'org-iso-mdoc' | 'openid4vp-v1-unsigned';
+/** One entry of the Digital Credentials API `digital.requests` array. */
+type DigitalCredentialRequest = {
+  protocol: DigitalCredentialProtocol;
+  /**
+   * Opaque protocol payload, built by the backend.
+   * Apple (`org-iso-mdoc`): `{ deviceRequest, encryptionInfo }` base64 strings.
+   * Google (`openid4vp-v1-unsigned`): the whole OIDC4VP/DCQL request object.
+   */
+  data: unknown;
+};
+type DigitalCredentialResult = {
+  /**
+   * Opaque wallet response (Apple: encrypted deviceResponse; Google: a JWE).
+   * `undefined` when the OS sheet completed without producing a credential
+   * (user dismissed, or no eligible digital ID on the device) — that outcome
+   * is data, not an error.
+   */
+  response: string | undefined;
+};
+interface IDigitalCredentialsCapability {
+  /**
+   * Whether the environment exposes Digital Credentials, not just the generic
+   * Credentials API used by passwords/WebAuthn.
+   */
+  isAvailable(): boolean;
+  /**
+   * Presents the OS wallet sheet for the given request and resolves with the
+   * wallet's opaque response. Must be reached from a user gesture — iOS
+   * Safari requires transient user activation for `navigator.credentials.get()`.
+   * Rejects when the underlying API rejects (blocked, aborted, protocol error).
+   */
+  get(request: DigitalCredentialRequest, options?: {
+    signal?: AbortSignal;
+  }): Promise<DigitalCredentialResult>;
+}
+//#endregion
+//#region src/modules/digital-id-redirect/types.d.ts
+/**
+ * Trinsic web-redirect Digital ID — module contracts.
+ *
+ * DRAFT (P1 core scaffolding) — shape for review before implementation.
+ * Ticket: Phase 1 "Integrate with Trinsic for Digital IDs - Web Redirect" (1509).
+ * API: "Digital ID Verification API — Frozen Definition v2.0"
+ *   base /omni/v2/digital-id, auth x-api-key + X-Incode-Hardware-Id.
+ */
+/** Catalog-driven provider id (open set), e.g. `trinsic_netherlands_idin`. */
+type DigitalIdProviderId = string;
+type FlowType = 'REDIRECT' | 'DEEPLINK' | 'QR' | 'NATIVE_CHALLENGE' | 'PUSH';
+/** Mapped from Trinsic `failCode` by the backend (Phase 1 §4.1). */
+type FailureReason = 'USER_CANCELED' | 'AUTHENTICATION_FAILED' | 'SESSION_EXPIRED' | 'VERIFICATION_FAILED' | 'PROVIDER_INTERNAL_ERROR' | 'RESULTS_EXCHANGE_FAILED' | 'RP_CANCELED' | 'INVALID_REDIRECT_RESULT' | 'SESSION_TOKEN_EXPIRED';
+/** Query params the provider appends to the return URL (open list — read these three, ignore the rest). */
+type RedirectReturnParams = {
+  success: boolean;
+  sessionId: string;
+  resultsAccessKey: string;
+};
+//#endregion
+//#region src/modules/id/digitalIdRegistry.d.ts
+/**
+ * True when a digital-ID method uses a full-page web-redirect flow (Trinsic
+ * iDIN/FTN). Accepts both the module `FlowType` value (`REDIRECT`) and the
+ * backend value (`WEB_REDIRECT`). (Lives here rather than in
+ * `idCaptureHelpers` to keep the registry free of circular imports; the
+ * helpers re-export it.)
+ */
+declare function isRedirectFlowType(flowType: string): boolean;
+/** Digital-ID document schemes the SDK knows how to verify. */
+type DigitalIdDocumentType = 'mDL' | 'iDIN' | 'FTN';
+/** One way to fulfil a `DigitalIdDocumentType`, in funnel priority order. */
+type DigitalIdFunnelEntry = {
+  /** Incode-native device-wallet handshake (Apple Wallet web / Google Wallet). */
+  kind: 'incodeWallet';
+  /** Chooser tile this entry surfaces as. */
+  documentType: Extract<IdDocumentType, 'digitalId'>;
+  /** Config flag that activates this entry. */
+  configFlag: 'deviceWallet';
+} | {
+  /** Trinsic web-redirect flow (existing `digitalIdRedirect` child). */
+  kind: 'trinsicRedirect';
+  documentType: Extract<IdDocumentType, 'digitalIdRedirect'>;
+  /** Catalog provider id passed to the `digitalIdRedirectMachine`. */
+  providerId: DigitalIdProviderId;
+  /**
+   * Persisted backend method name in `config.digitalIds.methods[]` that
+   * activates this entry (e.g. `IDIN`).
+   */
+  method: string;
+};
+declare const DIGITAL_ID_REGISTRY: Record<DigitalIdDocumentType, readonly DigitalIdFunnelEntry[]>;
+declare const DIGITAL_ID_DOCUMENT_TYPES: DigitalIdDocumentType[];
+/** What the chooser routing actually launches for a document type. */
+type ResolvedDigitalIdRoute = {
+  kind: 'incodeWallet';
+} | {
+  kind: 'trinsicRedirect';
+  providerId: DigitalIdProviderId;
+  method?: IdCaptureDigitalIdMethod;
+};
+/** Platform capabilities consulted by the funnel. */
+type DigitalIdPlatformSupport = {
+  /** `IDigitalCredentialsCapability.isAvailable()`. */
+  credentialsAvailable: boolean;
+};
+/**
+ * Resolves the implementation that should fulfil a digital-ID document type:
+ * the first funnel entry that is active under the given config and platform.
+ * `undefined` when nothing can run it (the chooser then shows no tile for it).
+ */
+declare function resolveDigitalIdImplementation(docType: DigitalIdDocumentType, config: Pick<IdCaptureConfig, 'deviceWallet' | 'digitalIds'>, platform: DigitalIdPlatformSupport): ResolvedDigitalIdRoute | undefined;
+//#endregion
+//#region src/modules/id/deviceWallet/types.d.ts
+/** Which wallet backend the handshake talks to. */
+type DeviceWalletPlatform = 'ios' | 'android';
+/** Explicit provider override, mirroring V1's `DigitalIdWalletProvider`. */
+type DeviceWalletProvider = 'apple_web' | 'google';
+type DeviceWalletDecision = 'ACCEPTED' | 'REJECTED';
+/**
+ * Failure classification.
+ * - `UNSUPPORTED_PLATFORM` — no Credentials API. The digital-ID funnel
+ *   resolves this away before the machine is invoked; kept for the defensive
+ *   path when the machine is started on an unsupported environment anyway.
+ * - `NO_CREDENTIAL` — the wallet sheet completed without a credential (user
+ *   dismissed, or no eligible digital ID on the device).
+ * - `WALLET_ERROR` — anything else (request/decrypt HTTP failure, the
+ *   Credentials API rejecting, missing activation, protocol errors).
+ */
+type DeviceWalletFailReason = 'UNSUPPORTED_PLATFORM' | 'NO_CREDENTIAL' | 'WALLET_ERROR';
+/** Response of both decrypt endpoints. Attributes are not inline (see above). */
+type DeviceWalletDecryptResponse = {
+  success: boolean;
+  decision?: DeviceWalletDecision;
+  [key: string]: unknown;
+};
+/**
+ * Terminal machine output read by the ID-Capture parent (`onDone`).
+ * Projected by the machine's ROOT `output` — a top-level final node's own
+ * `output` does not propagate in this XState version.
+ */
+type DeviceWalletOutput = {
+  result: 'success';
+  decision: DeviceWalletDecision | undefined;
+  response: DeviceWalletDecryptResponse;
+} | {
+  result: 'dismissed';
+};
+//#endregion
 //#region src/modules/id/manualUpload/types.d.ts
 type ManualUploadTab = 'id' | 'passport';
 type ManualUploadSide = 'front' | 'back' | 'passport';
 type ManualUploadContext = {
   /** Passed from parent machine input — used by guards and actor inputs. */
   onlyFront: boolean;
+  /** Back-only takes precedence when both side-only flags are supplied. */
+  onlyBack: boolean;
   isSecondId: boolean;
   /** Retry budget for this manual upload (sourced from `config.captureAttempts`). */
   captureAttempts: number;
@@ -45,11 +207,13 @@ interface IAnalyticsCapability {
 //#region src/modules/id/types.d.ts
 type IdCaptureMode = 'front' | 'back' | 'passport';
 /**
- * Document type options for the ID capture chooser (ID, passport, manual ID upload, digital ID upload, digital ID from device wallet).
+ * Document type options for the ID capture chooser (ID, passport, manual ID
+ * upload, digital ID upload (PDF), digital ID from device wallet, digital ID
+ * web-redirect (Trinsic iDIN/FTN)).
  * Used for selection and for the list of available options derived from config.
  */
-type IdDocumentType = 'id' | 'passport' | 'manualIdUpload' | 'digitalIdUpload' | 'digitalId';
-type IdFlowStep = 'chooser' | 'ageVerification' | 'tutorial' | 'permissions' | 'capture' | 'mandatoryConsent' | 'frontFinished' | 'backFinished' | 'success' | 'processing' | 'expired' | 'finished' | 'error' | 'closed' | 'manualIdUpload' | 'digitalIdUpload';
+type IdDocumentType = 'id' | 'passport' | 'manualIdUpload' | 'digitalIdUpload' | 'digitalId' | 'digitalIdRedirect';
+type IdFlowStep = 'chooser' | 'ageVerification' | 'tutorial' | 'permissions' | 'capture' | 'mandatoryConsent' | 'frontFinished' | 'backFinished' | 'success' | 'processing' | 'expired' | 'finished' | 'error' | 'closed' | 'manualIdUpload' | 'digitalIdUpload' | 'digitalIdRedirect';
 type DetectionStatus = 'idle' | 'detecting' | 'farAway' | 'blur' | 'glare' | 'wrongSide' | 'capturing' | 'manualCapture' | 'idNotDetected' | 'offline';
 /**
  * Represents the detection area dimensions in pixels.
@@ -86,10 +250,32 @@ type IdCaptureThresholds = {
   idDetectedTimeout: number;
   autocaptureTimeout: number;
 };
+/**
+ * Flow shape a digital-ID method uses. iDIN/FTN are `WEB_REDIRECT` (the backend
+ * value) / `REDIRECT` (the digital-id-redirect module's `FlowType`). Only the
+ * redirect variants are handled by the ID-Capture `digitalIdRedirect` child;
+ * the other shapes are declared for forward-compatibility with the catalog.
+ */
+type IdCaptureDigitalIdFlowType = FlowType | 'WEB_REDIRECT';
+/**
+ * One digital-ID verification method offered inside ID-Capture, threaded from
+ * the backend flow node's `configuration.digitalIds` (unified path — same rails
+ * as Apple/Google Wallet). A `REDIRECT`/`WEB_REDIRECT` method surfaces the
+ * `digitalIdRedirect` chooser option and drives the `digitalIdRedirectMachine`
+ * child. iDIN-only for now (FTN is BE-blocked).
+ */
+type IdCaptureDigitalIdMethod = {
+  /** Persisted method name, e.g. `IDIN` / `FTN`. */
+  method?: string;
+  /** Catalog provider id passed to the child, e.g. `trinsic_netherlands_idin`. */
+  provider: DigitalIdProviderId;
+  /** Redirect vs. other flow shapes. Only the redirect variants are handled. */
+  flowType: IdCaptureDigitalIdFlowType;
+  /** ISO alpha-2 to bias provider ordering / prefill. */
+  country?: string;
+  displayName?: string;
+};
 type IdCaptureConfig = TutorialIdConfig & {
-  recording?: {
-    capability?: IRecordingCapability;
-  };
   ageAssurance?: boolean;
   mergeSessionRecordings?: boolean;
   isDeepsightEnabled?: boolean;
@@ -127,6 +313,30 @@ type IdCaptureConfig = TutorialIdConfig & {
    * parameter-store read, no Statsig exposure, and no assignment event.
    */
   supportsOptimizingStatus?: boolean;
+  /**
+   * Digital-ID methods offered inside ID-Capture (from the backend flow node's
+   * `configuration.digitalIds`). A `REDIRECT`/`WEB_REDIRECT` method surfaces the
+   * `digitalIdRedirect` chooser option and drives the `digitalIdRedirectMachine`
+   * child (Trinsic iDIN/FTN). Absent / empty → no redirect option shown.
+   */
+  digitalIds?: IdCaptureDigitalIdMethod[];
+  /**
+   * https page the identity provider redirects back to on the digital-ID
+   * web-redirect return leg. The host onboarding app owns this route and passes
+   * it here; forwarded to the `digitalIdRedirectMachine` as its `returnUrl`.
+   */
+  digitalIdReturnUrl?: string;
+  /**
+   * Digital-ID web-redirect RETURN leg. When present, ID-Capture skips the
+   * chooser and resumes straight into the `digitalIdRedirect` child in resume
+   * mode: the persisted `verificationId` is recovered from storage and the
+   * host-parsed `returnParams` are submitted. Set by the host on the return
+   * route (mirrors the old top-level `FlowConfig.digitalIdReturn`, re-targeted
+   * to the ID-Capture module).
+   */
+  digitalIdReturn?: {
+    returnParams: RedirectReturnParams;
+  };
 };
 /**
  * Public ID capture configuration for the captureOnly flow.
@@ -152,6 +362,23 @@ type IdError = {
   message: string;
   messageDescription?: string;
 };
+/**
+ * Document types the backend is known to report in
+ * `UploadIdResponse.acceptedDocuments` (`add-front-id-v2`: the list of document
+ * types accepted for the detected country when `failReason` is
+ * `ID_TYPE_UNACCEPTABLE`).
+ *
+ * The wire format is `array[string]`, so this union documents the known values
+ * rather than constraining them — see `AcceptedDocument`, which is what the
+ * response is actually typed as. Consumers must handle unknown values.
+ */
+type AcceptedDocumentType = 'IdentificationCard' | 'Passport' | 'DriversLicense' | 'ResidenceDocument' | 'BirthCertificate' | 'TravelDocument' | 'WeaponLicense' | 'MedicalCard' | 'TribalIdentification' | 'Currency' | 'VehicleRegistration' | 'TaxIdentification' | 'Visa' | 'Permit' | 'Military' | 'VoterIdentification' | 'FederalID' | 'Unknown' | 'Other';
+/**
+ * A single entry of `UploadIdResponse.acceptedDocuments`. Widened to `string`
+ * so that a document type the backend adds later still type-checks, while
+ * `AcceptedDocumentType` keeps autocomplete for the known values.
+ */
+type AcceptedDocument = AcceptedDocumentType | (string & {});
 type UploadIdResponse = {
   sharpness: number;
   correctSharpness: boolean;
@@ -171,10 +398,11 @@ type UploadIdResponse = {
   skipGlareFront?: boolean;
   skipGlareBack?: boolean;
   documentIsOnTheEdge?: boolean;
-  acceptedDocuments?: Array<{
-    type: string;
-    name: string;
-  }>;
+  /**
+   * List of document types accepted for the detected country when
+   * `failReason` is `ID_TYPE_UNACCEPTABLE`. BE-documented as `array[string]`.
+   */
+  acceptedDocuments?: Array<AcceptedDocument>;
   forceFrontIdCapture?: boolean;
   /**
    * US Smart Capture: when `true`, the backend has already validated the ID
@@ -248,14 +476,6 @@ type CaptureOnlyResponse = {
   frontImage: IdCapturedImageData;
   backImage: IdCapturedImageData | undefined;
 };
-type RecordingSession = {
-  token: string;
-  sessionId: string;
-  videoRecordingId: string;
-  connection: RecordingConnection;
-  resolution?: string;
-  hasAudio: boolean;
-};
 declare const ID_ERROR_CODES: {
   readonly UPLOAD_ERROR: "UPLOAD_ERROR";
   readonly CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED";
@@ -339,7 +559,8 @@ type IdCaptureContext = {
    * best-frame / front `success` shows its real captured image as usual).
    */
   barcodeFastPathCaptured: boolean;
-  recordingSession: RecordingSession | undefined;
+  /** Opaque SDK-owned handle for the active multipart ID recording. */
+  recordingSession: object | undefined;
   attemptsRemaining: number;
   /**
    * Number of consecutive `isDocumentExpired === true` upload responses for
@@ -377,6 +598,35 @@ type IdCaptureContext = {
    * for the workflow orchestrator.
    */
   isDigitalUpload: boolean;
+  /**
+   * `true` once a Digital ID web-redirect (Trinsic iDIN/FTN) has COMPLETED for
+   * this session. Like a digital upload, it is single-side (no back capture).
+   * Combined with `portraitPresent` it drives the downstream Face Match skip
+   * (iDIN returns no portrait → nothing to match) via `computeIdCaptureOutput`.
+   */
+  isDigitalIdRedirect: boolean;
+  /**
+   * Whether the completed digital-ID web-redirect scheme returned a portrait.
+   * iDIN/FTN → `false`. When `false`, the ID has no face → the downstream Face
+   * Match step is skipped (`computeIdCaptureOutput.skipFaceMatch`).
+   */
+  portraitPresent: boolean;
+  /**
+   * The digital-ID implementation resolved by the funnel when the user picked
+   * the Digital ID chooser tile (`resolveDigitalIdImplementation`). Stored so
+   * the `digitalIdRouting` state can branch on it and the Trinsic fallback can
+   * preset its provider on the `digitalIdRedirect` child input.
+   */
+  digitalIdRoute: ResolvedDigitalIdRoute | undefined;
+  /**
+   * `true` once a device-wallet (mDL) handshake has completed for this
+   * session. Wallet credentials are single-side and carry no client-side
+   * image; the mDL portrait lands in the session server-side, so the
+   * downstream Face Match is NOT skipped (unlike a portrait-less redirect).
+   */
+  isDeviceWallet: boolean;
+  /** Backend decision of the completed device-wallet handshake. */
+  deviceWalletDecision: DeviceWalletDecision | undefined;
   /**
    * Set when `expiredExhausted` was reached via the per-upload (camera)
    * exhaustion path. Used by `CONTINUE_EXHAUSTED` to decide whether to run
@@ -467,6 +717,18 @@ type IdCaptureContext = {
   captureResolution?: string;
   /** Android camera access fallback level that succeeded */
   cameraFallbackLevel?: number;
+  /**
+   * Digital-ID web-redirect RETURN leg (recovered on start from
+   * `config.digitalIdReturn`). Present only when re-mounting after the provider
+   * redirect; drives the direct route into the `digitalIdRedirect` child in
+   * resume mode. `verificationId`/`providerId` are read back from storage
+   * (persisted before the redirect); `returnParams` come from the host.
+   */
+  digitalIdReturnParams: RedirectReturnParams | undefined;
+  digitalIdResumeVerificationId: string | undefined;
+  digitalIdResumeProviderId: DigitalIdProviderId | undefined;
+  /** Whether the live `stream` is genuinely the rear camera. */
+  usingBackCamera?: boolean;
 };
 type IdCaptureEvent = {
   type: 'LOAD';
@@ -596,9 +858,27 @@ type IdCaptureEvent = {
   type: 'DIGITAL_UPLOAD_SCAN_INSTEAD';
 } | {
   type: 'DIGITAL_UPLOAD_CHOOSE_ANOTHER';
+} | {
+  type: 'DIGITAL_ID_REDIRECT_RETRY';
+} | {
+  type: 'DIGITAL_ID_REDIRECT_USE_ANOTHER_METHOD';
+} | {
+  type: 'DIGITAL_ID_REDIRECT_CONTINUE';
+} | {
+  type: 'DIGITAL_ID_REDIRECT_REFRESH';
+} | {
+  type: 'DEVICE_WALLET_RETRY';
+} | {
+  type: 'DEVICE_WALLET_USE_ANOTHER_METHOD';
 };
 type IdCaptureDependencies = {
   storage: IStorageCapability;
+  /**
+   * W3C Digital Credentials API access for the device-wallet (mDL) child.
+   * Optional for backward compatibility; defaults to
+   * `BrowserDigitalCredentialsProvider` at the composition points.
+   */
+  credentials?: IDigitalCredentialsCapability;
   trackCaptureAttemptFinished?: (payload: {
     logs: string;
     resolution?: string;
@@ -642,4 +922,4 @@ type IdCaptureOutput = {
   skipFaceMatch: boolean;
 } | undefined;
 //#endregion
-export { ManualUploadSide as A, RecordingSession as C, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as D, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as E, MANUAL_UPLOAD_MAX_RETRIES as O, IdFlowStep as S, IAnalyticsCapability as T, IdCaptureThresholds as _, DetectionArea as a, IdError as b, IdCaptureConfig as c, IdCaptureEvent as d, IdCaptureGeometry as f, IdCaptureOutput as g, IdCaptureOnlyConfig as h, CapturedImage as i, ManualUploadTab as j, ManualUploadContext as k, IdCaptureContext as l, IdCaptureMode as m, CaptureIdResponse as n, DetectionStatus as o, IdCaptureInput as p, CaptureOnlyResponse as r, ID_ERROR_CODES as s, AddBarcodeV3Response as t, IdCaptureDependencies as u, IdCapturedImageData as v, UploadIdResponse as w, IdErrorCode as x, IdDocumentType as y };
+export { MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as A, DeviceWalletProvider as B, IdDocumentType as C, UploadIdResponse as D, IdFlowStep as E, DeviceWalletDecision as F, DigitalIdPlatformSupport as G, DIGITAL_ID_REGISTRY as H, DeviceWalletDecryptResponse as I, resolveDigitalIdImplementation as J, ResolvedDigitalIdRoute as K, DeviceWalletFailReason as L, ManualUploadContext as M, ManualUploadSide as N, IAnalyticsCapability as O, ManualUploadTab as P, DeviceWalletOutput as R, IdCapturedImageData as S, IdErrorCode as T, DigitalIdDocumentType as U, DIGITAL_ID_DOCUMENT_TYPES as V, DigitalIdFunnelEntry as W, FailureReason as X, DigitalIdProviderId as Y, RedirectReturnParams as Z, IdCaptureInput as _, CaptureOnlyResponse as a, IdCaptureOutput as b, DetectionStatus as c, IdCaptureContext as d, IdCaptureDependencies as f, IdCaptureGeometry as g, IdCaptureEvent as h, CaptureIdResponse as i, MANUAL_UPLOAD_MAX_RETRIES as j, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as k, ID_ERROR_CODES as l, IdCaptureDigitalIdMethod as m, AcceptedDocumentType as n, CapturedImage as o, IdCaptureDigitalIdFlowType as p, isRedirectFlowType as q, AddBarcodeV3Response as r, DetectionArea as s, AcceptedDocument as t, IdCaptureConfig as u, IdCaptureMode as v, IdError as w, IdCaptureThresholds as x, IdCaptureOnlyConfig as y, DeviceWalletPlatform as z };

package/dist/video-selfie.d.ts

@@ -1,10 +1,24 @@
-import { n as WasmPipeline } from "./warmup-Dv2alr2-.js";
+import { c as WasmPipeline } from "./warmup-Cis2p6O0.js";
 import { A as StateMachine, _ as MachineContext, c as AnyEventObject, p as EventObject, v as MetaObject, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
 import "./StateMachine-EDpYWy0i.js";
 import "./Actor-iTq7YY48.js";
+import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
-import { a as FacingMode, i as CameraCompositor, n as VideoSelfieDetectionStatus, o as VideoSelfieConfig, r as VideoSelfieValidationFailure, s as VideoSelfieStep, t as StepDetector } from "./videoSelfieStepDetector-D3oo2ofo.js";
+import { t as DetectionOrientation } from "./IIdCaptureCapability-RNiFhvXR.js";
+import { a as FacingMode, i as CameraCompositor, n as VideoSelfieDetectionStatus, o as VideoSelfieConfig, r as VideoSelfieValidationFailure, s as VideoSelfieStep, t as StepDetector } from "./videoSelfieStepDetector-Co0Gu2k2.js";
+//#region ../infra/src/capabilities/ITimerCapability.d.ts
+type TimerHandle = ReturnType<typeof setTimeout>;
+type ITimerCapability = {
+  setTimeout(callback: () => void, delayMs: number): TimerHandle;
+  setInterval(callback: () => void, delayMs: number): TimerHandle;
+  clearTimeout(handle: TimerHandle): void;
+  clearInterval(handle: TimerHandle): void;
+};
+//#endregion
+//#region src/internal/recordings/videoSelfieUploadService.d.ts
+/** What the multipart upload records. Must be sent on every protocol call. */
+type VideoUploadScope = 'videoselfie' | 'selfie' | 'frontId' | 'backId';
+//#endregion
 //#region src/internal/recordings/multipartRecordingService.d.ts
 type MultipartRecordingResult = {
   /**
@@ -19,12 +33,10 @@ type MultipartRecordingResult = {
  * captured, using the video-selfie-service multipart upload protocol
  * (`/v1/video-upload/*`).
  *
- * This is the Video Selfie module's client-side recorder and is deliberately
- * independent of the face-capture recording services (`LocalRecordingService`
- * / `OpenViduRecordingService`) — it is the replacement for server-side
- * (OpenVidu) recording, not a sibling of it.
+ * This is the client-side recorder for Video Selfie and for scoped regular
+ * Selfie and ID recordings. It replaces the former server-side recording path.
  *
- * Every ~1 s recorder blob uploads as its own chunk, concurrently with
+ * Every ~0.5 s recorder blob uploads as its own chunk, concurrently with
  * recording, through {@link VideoSelfieChunkUploader} (keep-until-ack +
  * retry with backoff — see its doc for the full policy). The service stages
  * sub-5 MiB chunks and combines them server-side, so `stop()` only drains
@@ -33,14 +45,23 @@ type MultipartRecordingResult = {
  * (S3 SSE-AES-256).
  */
 declare class MultipartRecordingService {
+  private readonly scope;
   private recorder;
   private timer;
   private session;
   private uploader;
   private chunksEmitted;
+  private stopPromise;
+  private abandonRequested;
+  constructor(scope?: VideoUploadScope);
   get isRecording(): boolean;
   start(stream: MediaStream): Promise<void>;
+  /** Pause the current media container without finalizing its upload. */
+  pause(): boolean;
+  /** Resume the same media container after its video source has recovered. */
+  resume(): boolean;
   stop(): Promise<MultipartRecordingResult>;
+  private finalizeRecording;
   cleanup(): void;
   /**
    * `complete` is idempotent server-side ("safe to repeat if the response
@@ -66,21 +87,31 @@ type VideoSelfieRecordingDependencies = {
   acquireCamera?: (facingMode: FacingMode, withAudio: boolean) => Promise<CameraStream>;
   /** Runs WASM detection + backend validation per step; resolves to advance. */
   detect?: StepDetector;
+  /** Timer used by the whole-session maximum recording duration. */
+  timer?: ITimerCapability;
+  /**
+   * Overrides the page-visibility source used to pause capture. The manager
+   * promotes this dependency to the machine's required top-level input.
+   */
+  visibilityObserver?: IVisibilityObserverCapability;
   /** Minimum time to hold the switching-camera screen before resuming capture. */
   switchingCameraMinDwellMs?: number;
 };
 /**
  * Why the module errored: `connection` means a transport-level failure the
  * user can fix by getting back online (the UI shows the connection-error
- * copy); `technical` is everything else (raw detail stays in `error` for
- * diagnostics/hosts, the UI shows its generic fallback).
+ * copy); `technical` is every other recoverable failure (raw detail stays in
+ * `error` for diagnostics/hosts, the UI shows its generic fallback);
+ * `maxVideoLengthReached` is the configured recording limit; and
+ * `validationAttemptsExhausted` terminates the module after the last allowed
+ * ID or selfie validation failure.
  */
-type VideoSelfieErrorKind = 'connection' | 'technical';
+type VideoSelfieErrorKind = 'connection' | 'technical' | 'maxVideoLengthReached' | 'validationAttemptsExhausted';
 //#endregion
 //#region src/modules/video-selfie/videoSelfieRecordingActor.d.ts
 type CreateVideoSelfieRecordingActorOptions = {
-  /** Module config; its flags determine the active capture steps + validations. */
   config?: VideoSelfieConfig;
+  steps?: VideoSelfieStep[];
   dependencies?: VideoSelfieRecordingDependencies;
 };
 //#endregion
@@ -116,12 +147,19 @@ type VideoSelfieRecordingState = {
   attemptsRemaining: number;
   /** The completed upload id, available during `success` and `finished`. */
   recordingId: string | null;
-  /** Failure detail, set when `status === 'error'`. */
+  /**
+   * Failure detail for diagnostics, or the stable
+   * `maxVideoLengthReached` reason when the configured limit expires.
+   * Set when `status === 'error'`.
+   */
   error: string | undefined;
   /**
    * Why the module errored: `connection` (transport failure — the UI shows
    * the connection-error copy; raw detail stays in `error` for diagnostics)
-   * or `technical` (everything else). Set when `status === 'error'`.
+   * or `technical` (recoverable technical failures), or
+   * `maxVideoLengthReached` (the configured recording limit), or
+   * `validationAttemptsExhausted` (terminal ID/selfie validation failure).
+   * Set when `status === 'error'`.
    */
   errorKind: VideoSelfieErrorKind | undefined;
 };
@@ -172,27 +210,10 @@ declare function facingModeForStep(step: VideoSelfieStep): 'user' | 'environment
  * the first well-framed frame.
  */
 declare function resolveVideoSelfieSteps(config: VideoSelfieConfig): VideoSelfieStep[];
-/**
- * The WASM pipelines a Video Selfie session loads. The selfie step always runs
- * face detection (`videoSelfie`); the ID steps run the simplified ID-capture
- * pipeline (`videoSelfieId`), gated by `checkIdScan`. Used both for the
- * flow-level eager warmup ({@link getRequiredWasmPipelines}) and the
- * tutorial-time lazy warmup (`warmupVideoSelfieWasm`).
- */
-declare function videoSelfieWasmPipelines(config: VideoSelfieConfig): WasmPipeline[];
+declare function videoSelfieWasmPipelines(config: VideoSelfieConfig, steps?: VideoSelfieStep[]): WasmPipeline[];
 //#endregion
 //#region src/modules/video-selfie/videoSelfieWasm.d.ts
-/**
- * Warms the WASM pipelines the Video Selfie flow needs (face detection, plus the
- * ID-capture pipeline when `checkIdScan` is on), reusing the WASM config stored
- * by `setup({ wasm })`.
- *
- * Idempotent and safe to call eagerly — the UI invokes it when the tutorial
- * mounts so the models finish loading while the user reads the instructions, and
- * detection is ready the instant recording starts (mirrors how the selfie and ID
- * modules warm up during their tutorials). No-op when WASM was not configured.
- */
-declare function warmupVideoSelfieWasm(config: VideoSelfieConfig): Promise<void>;
+declare function warmupVideoSelfieWasm(config: VideoSelfieConfig, steps?: VideoSelfieStep[]): Promise<void>;
 //#endregion
 //#region src/modules/video-selfie/videoSelfieCameraWarmer.d.ts
 /**
@@ -230,7 +251,7 @@ type VideoSelfieCameraWarmer = {
  * camera (and whether it needs audio) is derived from the resolved step order —
  * the same first acquire the recording machine performs on `START`.
  */
-declare function createVideoSelfieCameraWarmer(config: VideoSelfieConfig): VideoSelfieCameraWarmer;
+declare function createVideoSelfieCameraWarmer(config: VideoSelfieConfig, steps?: VideoSelfieStep[]): VideoSelfieCameraWarmer;
 //#endregion
 //#region src/modules/video-selfie/videoSelfieSpeechService.d.ts
 /** A single random question (and its expected answer) for the challenge step. */
@@ -304,4 +325,7 @@ declare const videoSelfieFlowModuleMachine: StateMachine<MachineContext, AnyEven
   };
 }>;
 //#endregion
-export { type ConsentRecorder, type CreateVideoSelfieRecordingActorOptions, type VideoSelfieCameraWarmer, type VideoSelfieConfig, type VideoSelfieQuestion, type VideoSelfieRecordingManager, type VideoSelfieRecordingState, type VideoSelfieRecordingStatus, type VideoSelfieStep, createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };
+//#region src/internal/orchestration/advanceableErrors.d.ts
+declare const VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE = "VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED";
+//#endregion
+export { type ConsentRecorder, type CreateVideoSelfieRecordingActorOptions, VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE, type VideoSelfieCameraWarmer, type VideoSelfieConfig, type VideoSelfieQuestion, type VideoSelfieRecordingManager, type VideoSelfieRecordingState, type VideoSelfieRecordingStatus, type VideoSelfieStep, createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };