@incodetech/core 0.0.0-dev-20260512-cffbe28 → 0.0.0-dev-20260512-20def2c

package/dist/electronic-signature.d.ts

@@ -1,4 +1,4 @@
 import "./Manager-D9pehGyp.js";
 import "./Actor-YjWTo26u.js";
-import { a as AE_CONSENT_KEYS, c as ConsentKey, d as ElectronicSignatureVariant, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, h as getConsentKeys, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, o as AeConsentKey, p as QeConsentKey, r as createElectronicSignatureManager, s as ConsentChecks, t as ElectronicSignatureManager, u as ElectronicSignatureDocument } from "./index-BRdxM5zm.js";
+import { a as AE_CONSENT_KEYS, c as ConsentKey, d as ElectronicSignatureVariant, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, h as getConsentKeys, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, o as AeConsentKey, p as QeConsentKey, r as createElectronicSignatureManager, s as ConsentChecks, t as ElectronicSignatureManager, u as ElectronicSignatureDocument } from "./index-DXB9aRs0.js";
 export { AE_CONSENT_KEYS, AeConsentKey, ConsentChecks, ConsentKey, ElectronicSignatureConfig, ElectronicSignatureDocument, ElectronicSignatureManager, ElectronicSignatureState, ElectronicSignatureVariant, QE_CONSENT_KEYS, QeConsentKey, areAllConsented, createElectronicSignatureManager, electronicSignatureMachine, getConsentKeys, getDefaultConsentChecks };

package/dist/extensibility.d.ts

@@ -1,17 +1,17 @@
-import "./warmup-DHGg8wQZ.js";
+import "./warmup-C6O7yhfX.js";
 import "./Manager-D9pehGyp.js";
 import { n as createActor } from "./Actor-YjWTo26u.js";
 import { r as fromPromise } from "./StateMachine-CJG7thvx.js";
-import { c as FaceCaptureEvent, f as SendFaceImageResponse, l as FaceCaptureInput, n as FaceCaptureManagerState, p as BaseWasmProvider, s as FaceCaptureContext, t as FaceCaptureManager, u as faceCaptureMachine } from "./faceCaptureManagerFactory-FX5Lw2Q5.js";
+import { c as FaceCaptureEvent, f as SendFaceImageResponse, l as FaceCaptureInput, n as FaceCaptureManagerState, p as BaseWasmProvider, s as FaceCaptureContext, t as FaceCaptureManager, u as faceCaptureMachine } from "./faceCaptureManagerFactory-DmHbKbyC.js";
 import "./camera-B6UAKpM1.js";
 import "./types-DJSt3Ovt.js";
-import "./types-BA181GDD.js";
-import { a as IWasmUtilCapability, o as VirtualCameraCheckOutput, s as WasmUtilConfig, u as IStorageCapability } from "./deepsightService-CGSDjjBz.js";
+import "./types-DkXZpS0R.js";
+import { a as IWasmUtilCapability, o as VirtualCameraCheckOutput, s as WasmUtilConfig, u as IStorageCapability } from "./deepsightService-Kuw9roIJ.js";
 import "./types-CarMMtoz.js";
-import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, t as SelfieManager } from "./selfieManager-DPQzO4ua.js";
-import { i as createAuthenticationManagerFromActor, n as AuthenticationState, t as AuthenticationManager } from "./authenticationManager-BuChl5GH.js";
+import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, t as SelfieManager } from "./selfieManager-CQtRqcjI.js";
+import { i as createAuthenticationManagerFromActor, n as AuthenticationState, t as AuthenticationManager } from "./authenticationManager-BnltMEfq.js";
 import { i as createEmailManagerFromActor, n as EmailState, t as EmailManager } from "./emailManager-DsYl45qf.js";
-import { T as CaptureIdResponse, i as createIdCaptureManagerFromActor, n as IdCaptureState, t as IdCaptureManager } from "./idCaptureManager-DiFBYm7h.js";
+import { T as CaptureIdResponse, i as createIdCaptureManagerFromActor, n as IdCaptureState, t as IdCaptureManager } from "./idCaptureManager-Bg2va24b.js";
 import { i as createPhoneManagerFromActor, n as PhoneState, t as PhoneManager } from "./phoneManager-CeAs-QB1.js";
 
 //#region src/modules/authentication/authenticationUploadService.d.ts

package/dist/extensibility.esm.js

@@ -1,35 +1,35 @@
-import "./BaseWasmProvider-IiHnsP8E.esm.js";
-import { t as WasmUtilProvider } from "./WasmUtilProvider-BrEYcdhY.esm.js";
+import "./BaseWasmProvider-CVktpSfA.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-BEQWy5_K.esm.js";
 import "./BrowserTimerProvider-BZGH3sYJ.esm.js";
 import "./api-eqRXuVG-.esm.js";
 import "./events-Bt1azl2B.esm.js";
 import "./endpoints-B3V1U9Dg.esm.js";
-import { a as FingerprintProvider, o as getDeviceFingerprintInfo, t as getDisableIpify } from "./session-DAspZUCj.esm.js";
+import { a as FingerprintProvider, o as getDeviceFingerprintInfo, t as getDisableIpify } from "./session-BxtuBDwz.esm.js";
 import { t as IpifyProvider } from "./IpifyProvider-ByL6JYxg.esm.js";
 import "./browserSimulation-CAH-V_iE.esm.js";
 import { a as fromPromise, o as createActor } from "./xstate.esm-7GmmAwg6.esm.js";
-import "./faceCaptureManagerFactory-ByAGjOLF.esm.js";
+import "./faceCaptureManagerFactory-fu-9hWf5.esm.js";
 import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CoUfuy0u.esm.js";
-import "./recordingService-DMaVUhWY.esm.js";
-import "./deepsightService-IxmrmdKl.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-D607PhdL.esm.js";
+import "./ITimerCapability-3xSd36bT.esm.js";
 import "./camera-Bm3wb89Z.esm.js";
-import "./getBrowser-Y88tNVud.esm.js";
-import "./stats-Bqq9IKre.esm.js";
-import "./MotionSensorProvider-DJMsPght.esm.js";
-import "./permissionServices-ACBX6sNZ.esm.js";
-import "./platform-Dpzd9p3X.esm.js";
-import "./ITimerCapability-2pw-S97e.esm.js";
-import "./backCameraStream-DWZ1cNVA.esm.js";
-import "./getDeviceClass-DmoqR7G2.esm.js";
-import { t as faceCaptureMachine } from "./faceCaptureSetup-CUzqUwkP.esm.js";
-import "./authenticationStateMachine-BNs4VCxh.esm.js";
-import { n as createAuthenticationManagerFromActor } from "./authenticationManager-CKDxnLtG.esm.js";
+import "./deepsightService-Dv6kvzph.esm.js";
+import "./recordingService-Dp-3nA-h.esm.js";
+import "./platform-CDh4uv5Y.esm.js";
+import "./backCameraStream-BKC7QXRJ.esm.js";
+import "./getBrowser-Bl0PlyDu.esm.js";
+import "./stats-qUsejORa.esm.js";
+import "./getDeviceClass-C1ZS2XJL.esm.js";
+import "./MotionSensorProvider-Dt_lF3Z8.esm.js";
+import "./permissionServices-Cdxqlwqz.esm.js";
+import "./authenticationStateMachine-B4FQ52zK.esm.js";
+import { n as createAuthenticationManagerFromActor } from "./authenticationManager-DsauZR1g.esm.js";
 import "./emailStateMachine-BW4tiYqt.esm.js";
 import { n as createEmailManagerFromActor } from "./emailManager-CJAgi4be.esm.js";
-import "./selfieStateMachine-DvOTE42w.esm.js";
-import { n as createSelfieManagerFromActor } from "./selfieManager-DC9hKgt7.esm.js";
-import "./idCaptureStateMachine-BuX1-VlB.esm.js";
-import { n as createIdCaptureManagerFromActor } from "./idCaptureManager-ZtfBOR6V.esm.js";
+import "./selfieStateMachine-D0rrAFIs.esm.js";
+import { n as createSelfieManagerFromActor } from "./selfieManager-5AG9bMT1.esm.js";
+import "./idCaptureStateMachine-g5cYnHGD.esm.js";
+import { n as createIdCaptureManagerFromActor } from "./idCaptureManager-DbP4E8PO.esm.js";
 import "./phoneStateMachine-dDqWuk_Q.esm.js";
 import { n as createPhoneManagerFromActor } from "./phoneManager-BgAfR0DQ.esm.js";
 

package/dist/{faceCaptureManagerFactory-FX5Lw2Q5.d.ts → faceCaptureManagerFactory-DmHbKbyC.d.ts}

@@ -1,10 +1,10 @@
-import { n as WasmPipeline } from "./warmup-DHGg8wQZ.js";
+import { n as WasmPipeline } from "./warmup-C6O7yhfX.js";
 import { t as Manager } from "./Manager-D9pehGyp.js";
 import { t as ActorRefFrom } from "./Actor-YjWTo26u.js";
 import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-CJG7thvx.js";
 import { t as CameraStream } from "./camera-B6UAKpM1.js";
-import { i as FlowModuleConfig, n as Flow } from "./types-BA181GDD.js";
-import { a as IWasmUtilCapability, c as IMLProviderCapability, d as IRecordingCapability, i as IncodeCanvas, l as MLProviderConfig, r as StreamCanvasCapture, t as DeepsightService, u as IStorageCapability } from "./deepsightService-CGSDjjBz.js";
+import { i as FlowModuleConfig, n as Flow } from "./types-DkXZpS0R.js";
+import { a as IWasmUtilCapability, c as IMLProviderCapability, d as IRecordingCapability, i as IncodeCanvas, l as MLProviderConfig, r as StreamCanvasCapture, t as DeepsightService, u as IStorageCapability } from "./deepsightService-Kuw9roIJ.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-CarMMtoz.js";
 
 //#region src/modules/authentication/authenticationStateMachine.d.ts
@@ -37,6 +37,13 @@ type BaseFaceCaptureConfig = {
     capability?: IRecordingCapability;
   };
   ds?: Flow['ds'];
+  /**
+   * When true, face analysis runs on-device via the OnDevice WASM workflow
+   * (6 models) and only the results JSON is submitted to the backend
+   * (`/omni/add/face-results`). Recording is skipped entirely. Used by both
+   * SELFIE and AUTHENTICATION modules.
+   */
+  onDeviceFaceResultsSubmissionEnabled?: boolean;
 };
 type FaceCaptureDependencies = {
   storage: IStorageCapability;
@@ -90,6 +97,20 @@ type CreateAuthenticationActorOptions = {
 type AuthenticationActor = ActorRefFrom<AuthenticationMachine>;
 declare function createAuthenticationActor(options: CreateAuthenticationActorOptions): AuthenticationActor;
 //#endregion
+//#region ../infra/src/wasm/wasmWebClient.d.ts
+
+/**
+ * Configuration shape that the C++ `WebApi` passes when calling `.post(...)`
+ * on its host JS adapter. Mirrors the upstream `ml-wasm-kit/WebClient`
+ * `RequestConfig` for the subset of fields actually set by `WebApi`.
+ */
+type WebApiHostRequestConfig = {
+  ie?: boolean;
+  headers?: Record<string, string>;
+  params?: Record<string, string | number | boolean | undefined>;
+  timeout?: number;
+};
+//#endregion
 //#region ../infra/src/capabilities/IFaceDetectionCapability.d.ts
 /**
  * Configuration for face detection provider.
@@ -97,6 +118,12 @@ declare function createAuthenticationActor(options: CreateAuthenticationActorOpt
  */
 interface FaceDetectionConfig extends MLProviderConfig {
   autocaptureInterval?: number;
+  /**
+   * Load the on-device selfie workflow (6 models including liveness + age
+   * estimation) instead of the default selfie workflow (4 models). Required
+   * when SELFIE/AUTHENTICATION has `onDeviceFaceResultsSubmissionEnabled`.
+   */
+  useOnDeviceWorkflow?: boolean;
 }
 interface FacePositionConstraints {
   minX: number;
@@ -112,6 +139,24 @@ interface FaceDetectionThresholds {
   autocaptureInterval: number;
   minFaceQualityScore: number;
   faceOcclusionThreshold: number;
+  /**
+   * Milliseconds the C++ workflow waits after `onGetReady` fires before
+   * triggering autocapture. Mirrors V1's `getReadyDelay` (2000 ms) — without
+   * it, autocapture can fire on the first quality-passing frame, before the
+   * front camera has finished locking focus, producing blurry captures that
+   * the on-device quality model rejects.
+   */
+  getReadyDelay: number;
+  /**
+   * Milliseconds over which face-detection results are aggregated before the
+   * autocapture decision. Mirrors V1's `framesAggregationInterval` (2000 ms).
+   */
+  framesAggregationInterval: number;
+  /**
+   * Minimum consecutive frames with a detected face required before
+   * autocapture can trigger. Mirrors V1's `minFramesWithFace` (3).
+   */
+  minFramesWithFace: number;
 }
 interface FaceAttributesThresholds {
   headwearThreshold: number;
@@ -196,6 +241,21 @@ interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionCo
    * @param enabled - Whether to enable video selfie mode
    */
   setVideoSelfieMode(enabled: boolean): void;
+  /**
+   * Synchronous manual-capture entry point for the on-device selfie workflow.
+   * Runs the full on-device pipeline on a single canvas image and stages the
+   * results inside WASM for the next {@link postFaceResults} call. No-op for
+   * default (non-on-device) configurations; callers should guard with the
+   * `onDeviceFaceResultsSubmissionEnabled` flag.
+   */
+  processPhoto(canvas: HTMLCanvasElement): void;
+  /**
+   * POSTs the staged on-device face-results JSON to `/omni/add/face-results`.
+   * The C++ side encrypts the body via `SessionEncryptor` and routes through
+   * the WASM `WebClient`, so the SDK's WebClient must be initialized first
+   * (consumers calling this must configure `setup({ apiURL, wasm })`).
+   */
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
 }
 //#endregion
 //#region ../infra/src/wasm/WasmPipelineType.d.ts
@@ -205,6 +265,7 @@ declare enum WasmPipelineType {
   IdVideoSelfiePipeline = 2,
   SelfieWithAggregationMetrics = 3,
   SelfieWithQualityMetrics = 4,
+  OnDeviceSelfieWorkflow = 5,
 }
 //#endregion
 //#region ../infra/src/providers/wasm/BaseWasmProvider.d.ts
@@ -282,6 +343,8 @@ declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDet
   constructor();
   processFrame(image: ImageData): Promise<void>;
   initialize(config: FaceDetectionConfig): Promise<void>;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
   setCallbacks(callbacks: FaceDetectionCallbacks): void;
   setPositionConstraints(constraints: FacePositionConstraints): void;
   applyDefaults(autocaptureInterval?: number): void;

package/dist/{faceCaptureManagerFactory-ByAGjOLF.esm.js → faceCaptureManagerFactory-fu-9hWf5.esm.js}

@@ -14,7 +14,9 @@ function getCaptureStatus(snapshot) {
 	if (snapshot.matches({ capture: "detecting" })) return "detecting";
 	if (snapshot.matches({ capture: "capturing" })) return "capturing";
 	if (snapshot.matches({ capture: "capturingManual" })) return "capturing";
+	if (snapshot.matches({ capture: "preparingUpload" })) return "uploading";
 	if (snapshot.matches({ capture: "uploading" })) return "uploading";
+	if (snapshot.matches({ capture: "validatingUpload" })) return "uploading";
 	if (snapshot.matches({ capture: "uploadError" })) return "uploadError";
 	if (snapshot.matches({ capture: "success" })) return "success";
 }

package/dist/{faceCaptureSetup-CUzqUwkP.esm.js → faceCaptureSetup-D607PhdL.esm.js}

@@ -1,8 +1,143 @@
 import { r as getToken } from "./api-eqRXuVG-.esm.js";
 import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-7GmmAwg6.esm.js";
-import { _ as StreamCanvasCapture, a as initializeDeepsightSession, c as stopStream, h as flagFaceManualReview, i as initializeCamera, n as preloadOpenViduProvider, o as sendLabelInspectionEvent, r as encryptSelfieImage, s as startDetection, t as createRecordingService, v as FACE_ERROR_CODES } from "./recordingService-DMaVUhWY.esm.js";
-import { n as requestPermission, t as checkPermission } from "./permissionServices-ACBX6sNZ.esm.js";
+import { t as sleep } from "./ITimerCapability-3xSd36bT.esm.js";
+import { a as StreamCanvasCapture, c as initializeDeepsightSession, d as stopStream, l as sendLabelInspectionEvent, m as FACE_ERROR_CODES, n as preloadOpenViduProvider, o as encryptSelfieImage, r as flagFaceManualReview, s as initializeCamera, t as createRecordingService, u as startDetection } from "./recordingService-Dp-3nA-h.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-Cdxqlwqz.esm.js";
 
+//#region ../infra/src/scheduling/yieldUntilNextPaint.ts
+/**
+* Resolves after the browser has had a chance to commit and paint a queued
+* render.
+*
+* Strategy:
+* - `requestAnimationFrame` callbacks fire BEFORE the paint of the frame
+*   they belong to (per the HTML5 "update the rendering" step). If we
+*   resolve the promise inside a rAF callback, the await-continuation
+*   runs as a microtask immediately after the callback returns — still
+*   before the paint phase of that frame. A caller that then blocks the
+*   main thread (e.g. synchronous WASM `processPhoto`) starves the paint.
+* - We therefore chain rAF → setTimeout: the rAF fires before frame N's
+*   paint, the setTimeout runs as a macrotask scheduled after frame N's
+*   "update the rendering" step, which the browser will only get to once
+*   the paint actually lands. By the time setTimeout fires, the paint
+*   for the queued render is on screen.
+* - In environments where rAF never ticks (jsdom, happy-dom, backgrounded
+*   tabs), a parallel `setTimeout` fallback at 100 ms resolves instead.
+*   100 ms is comfortably longer than two real-browser frames so rAF +
+*   setTimeout wins reliably in any foregrounded browser. (An earlier
+*   implementation raced rAF against a `MessageChannel` macrotask, but
+*   MessageChannel drains immediately after the current task's
+*   microtasks — before the next paint — so it resolved the promise too
+*   early and defeated the whole point of the helper.)
+*
+* Lives in infra because it touches browser APIs (`requestAnimationFrame`,
+* `setTimeout`) that the architecture rules forbid from core. Core modules
+* that need to yield to the browser render loop should import this helper
+* directly via its file path.
+*/
+function yieldUntilNextPaint() {
+	return new Promise((resolve) => {
+		let resolved = false;
+		const done = () => {
+			if (resolved) return;
+			resolved = true;
+			resolve();
+		};
+		if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				setTimeout(done, 0);
+			});
+		});
+		setTimeout(done, 100);
+	});
+}
+
+//#endregion
+//#region src/internal/faceCapture/onDeviceFaceResults.ts
+/**
+* On-device face-results submission helpers.
+*
+* When a SELFIE or AUTHENTICATION module has
+* `onDeviceFaceResultsSubmissionEnabled: true`, face analysis runs entirely
+* inside the WASM `OnDeviceSelfieWorkflow` pipeline. Captured images are
+* never uploaded — only the staged face-results JSON is POSTed via the WASM
+* `WebApi` to `/omni/add/face-results`. The C++ side encrypts that JSON via
+* `SessionEncryptor`, so this path does NOT require WebClient E2EE.
+*
+* These helpers are deliberately variant-agnostic: both the selfie and auth
+* state machine variants delegate their `prepareFaceUpload`, `uploadFace`,
+* and `processFace` actors here to share behavior. See the "Runtime modes
+* within a module" section of `docs/patterns/XSTATE.md` for the broader
+* pattern.
+*/
+const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
+/**
+* The default (non-on-device) prepare-upload body shared by selfie and auth.
+* Stops any active recording, runs deepsight virtual-camera + frame checks,
+* tracks the capture attempt, and encrypts the captured image.
+*
+* Lifted out of `faceCaptureSetup.ts`'s base `prepareFaceUpload` actor so the
+* default path can be reused by both variants while leaving room for an
+* on-device branch alongside it.
+*/
+async function defaultPrepareFaceUpload(ctx) {
+	const sessionToken = getToken();
+	const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
+	try {
+		if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
+	} catch (error) {}
+	const logs = ctx.deepsightService?.getPipelineState() ?? "";
+	ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
+	return {
+		encryptedBase64Image: await encryptSelfieImage({
+			canvas: ctx.capturedImage,
+			dependencies: ctx.dependencies
+		}),
+		recordingId
+	};
+}
+/**
+* On-device prepare-upload. No recording to stop (the recording service is
+* never created when the flag is on), no image encryption needed — instead,
+* we hand the captured canvas to the WASM provider's `processPhoto` which
+* runs the full on-device pipeline and stages results inside `WebApi` for
+* the subsequent `postFaceResults` call.
+*
+* Returns sentinel values for `encryptedBase64Image` and `recordingId` so
+* the existing FaceCaptureContext shape remains stable; downstream actors
+* for the on-device path simply ignore them.
+*/
+async function prepareOnDeviceFaceUpload(ctx) {
+	if (!ctx.capturedImage) throw new Error("On-device capture requires a captured image canvas");
+	if (!ctx.provider) throw new Error("On-device capture requires the FaceDetectionProvider to be initialized");
+	await yieldUntilNextPaint();
+	await sleep(350);
+	ctx.provider.processPhoto(ctx.capturedImage.canvas);
+	return {
+		encryptedBase64Image: "",
+		recordingId: null
+	};
+}
+/**
+* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
+* through the WASM `WebApi`. Used as the `uploadFace` actor body for both
+* selfie and auth variants when on-device mode is enabled.
+*
+* The C++ `WebApi` handles `SessionEncryptor` encryption and the actual
+* HTTP via the WASM `WebClient` — so callers don't need to thread the
+* session-encryption details through JS.
+*/
+async function postOnDeviceFaceResults(ctx, signal) {
+	const provider = ctx.provider;
+	if (!provider) throw new Error("On-device upload requires the FaceDetectionProvider to be initialized");
+	const sessionToken = getToken();
+	return await provider.postFaceResults({
+		headers: sessionToken ? { "X-Incode-Hardware-Id": sessionToken } : void 0,
+		timeout: 3e4
+	}) ?? {};
+}
+
+//#endregion
 //#region src/internal/faceCapture/faceCaptureSetup.ts
 const getAttemptsFromConfig = (config) => {
 	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
@@ -89,22 +224,8 @@ const _faceCaptureMachine = setup({
 			if (!videoTrack) return false;
 			return input.deepsightService.checkVirtualCamera(videoTrack);
 		}),
-		prepareFaceUpload: fromPromise(async ({ input }) => {
-			const ctx = input;
-			const sessionToken = getToken();
-			const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
-			try {
-				if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
-			} catch (error) {}
-			const logs = ctx.deepsightService?.getPipelineState() ?? "";
-			ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
-			return {
-				encryptedBase64Image: await encryptSelfieImage({
-					canvas: ctx.capturedImage,
-					dependencies: ctx.dependencies
-				}),
-				recordingId
-			};
+		prepareFaceUpload: fromPromise(async () => {
+			throw new Error("prepareFaceUpload must be provided by variant");
 		}),
 		uploadFace: fromPromise(async () => {
 			throw new Error("uploadFace must be provided by variant");
@@ -686,6 +807,7 @@ const _faceCaptureMachine = setup({
 		processing: { invoke: {
 			id: "processFace",
 			src: "processFace",
+			input: ({ context }) => context,
 			onDone: {
 				target: "finished",
 				actions: "setProcessResponseFromEvent"
@@ -712,4 +834,4 @@ const _faceCaptureMachine = setup({
 const faceCaptureMachine = _faceCaptureMachine;
 
 //#endregion
-export { faceCaptureMachine as t };
+export { prepareOnDeviceFaceUpload as a, postOnDeviceFaceResults as i, defaultPrepareFaceUpload as n, isOnDeviceMode as r, faceCaptureMachine as t };

package/dist/flow-events.d.ts

@@ -1,6 +1,6 @@
 import "./camera-B6UAKpM1.js";
 import "./types-DJSt3Ovt.js";
-import "./types-BA181GDD.js";
+import "./types-DkXZpS0R.js";
 import "./flowCompletionService-C376JZwA.js";
-import { a as FlowEventListener, c as FlowModuleStartedEvent, i as FlowEvent, l as FlowReadyEvent, n as FlowCompletedEvent, o as FlowEventSubscribable, r as FlowErrorEvent, s as FlowModuleCompletedEvent, t as FlowClosedEvent, u as FlowStartedEvent } from "./index-CmFkidgy.js";
+import { a as FlowEventListener, c as FlowModuleStartedEvent, i as FlowEvent, l as FlowReadyEvent, n as FlowCompletedEvent, o as FlowEventSubscribable, r as FlowErrorEvent, s as FlowModuleCompletedEvent, t as FlowClosedEvent, u as FlowStartedEvent } from "./index-UH-vOq3x.js";
 export { FlowClosedEvent, FlowCompletedEvent, FlowErrorEvent, FlowEvent, FlowEventListener, FlowEventSubscribable, FlowModuleCompletedEvent, FlowModuleStartedEvent, FlowReadyEvent, FlowStartedEvent };

package/dist/flow.d.ts

@@ -1,11 +1,11 @@
-import { n as WasmPipeline } from "./warmup-DHGg8wQZ.js";
+import { n as WasmPipeline } from "./warmup-C6O7yhfX.js";
 import { t as Manager } from "./Manager-D9pehGyp.js";
 import { t as AnyStateMachine } from "./StateMachine-CJG7thvx.js";
 import "./camera-B6UAKpM1.js";
 import "./types-DJSt3Ovt.js";
-import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-BA181GDD.js";
+import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-DkXZpS0R.js";
 import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-C376JZwA.js";
-import { o as FlowEventSubscribable } from "./index-CmFkidgy.js";
+import { o as FlowEventSubscribable } from "./index-UH-vOq3x.js";
 import { t as ModuleRegistry } from "./types-WKAQ7Ai4.js";
 import * as xstate963 from "xstate";
 
@@ -21,6 +21,10 @@ type FlowForNormalization = Pick<Flow, 'flowId' | 'flowModules' | 'redirectDeskt
  * Analyzes a flow configuration and returns the WASM pipelines needed.
  * Use this to conditionally warmup WASM only when required by the flow.
  *
+ * Modules with `onDeviceFaceResultsSubmissionEnabled: true` (currently SELFIE
+ * and AUTHENTICATION) select the 6-model `'onDeviceSelfie'` bundle instead of
+ * the default 4-model `'selfie'` bundle.
+ *
  * @param flow - The flow configuration from /omni/onboarding/flow
  * @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
  *

package/dist/flow.esm.js

@@ -1,11 +1,11 @@
 import "./api-eqRXuVG-.esm.js";
 import "./events-Bt1azl2B.esm.js";
 import "./endpoints-B3V1U9Dg.esm.js";
-import "./session-DAspZUCj.esm.js";
+import "./session-BxtuBDwz.esm.js";
 import "./IpifyProvider-ByL6JYxg.esm.js";
 import "./browserSimulation-CAH-V_iE.esm.js";
 import { a as fromPromise, o as createActor, r as assign, s as createManager, t as setup } from "./xstate.esm-7GmmAwg6.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-CLo2qihS.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-BVVnH_Fn.esm.js";
 import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-B16ocpd4.esm.js";
 import { t as getFinishStatus } from "./flowCompletionService-BuVIVPT_.esm.js";
 

package/dist/{flowServices-CLo2qihS.esm.js → flowServices-BVVnH_Fn.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-eqRXuVG-.esm.js";
 import { t as endpoints } from "./endpoints-B3V1U9Dg.esm.js";
-import { n as getSessionFingerprintResult, r as initializeSession } from "./session-DAspZUCj.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./session-BxtuBDwz.esm.js";
 
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {
@@ -12,10 +12,19 @@ const WASM_MODULE_PIPELINES = {
 	TUTORIAL_ID: "idCapture",
 	SECOND_ID: "idCapture"
 };
+const FACE_MODULES_WITH_ON_DEVICE_VARIANT = new Set(["SELFIE", "AUTHENTICATION"]);
+function isOnDeviceFaceModule(module) {
+	if (!FACE_MODULES_WITH_ON_DEVICE_VARIANT.has(module.key)) return false;
+	return module.configuration?.onDeviceFaceResultsSubmissionEnabled === true;
+}
 /**
 * Analyzes a flow configuration and returns the WASM pipelines needed.
 * Use this to conditionally warmup WASM only when required by the flow.
 *
+* Modules with `onDeviceFaceResultsSubmissionEnabled: true` (currently SELFIE
+* and AUTHENTICATION) select the 6-model `'onDeviceSelfie'` bundle instead of
+* the default 4-model `'selfie'` bundle.
+*
 * @param flow - The flow configuration from /omni/onboarding/flow
 * @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
 *
@@ -30,6 +39,10 @@ const WASM_MODULE_PIPELINES = {
 function getRequiredWasmPipelines(flow) {
 	const pipelines = /* @__PURE__ */ new Set();
 	for (const module of flow.flowModules) {
+		if (isOnDeviceFaceModule(module)) {
+			pipelines.add("onDeviceSelfie");
+			continue;
+		}
 		const pipeline = WASM_MODULE_PIPELINES[module.key];
 		if (pipeline) pipelines.add(pipeline);
 	}

package/dist/geolocation.esm.js

@@ -2,8 +2,8 @@ import "./api-eqRXuVG-.esm.js";
 import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Bt1azl2B.esm.js";
 import "./endpoints-B3V1U9Dg.esm.js";
 import { o as createActor, s as createManager } from "./xstate.esm-7GmmAwg6.esm.js";
-import "./platform-Dpzd9p3X.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-15aagr2_.esm.js";
+import "./platform-CDh4uv5Y.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-BYWUPbNs.esm.js";
 
 //#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
 var BrowserGeolocationProvider = class {

package/dist/{geolocationStateMachine-15aagr2_.esm.js → geolocationStateMachine-BYWUPbNs.esm.js}

@@ -1,7 +1,7 @@
 import { t as api } from "./api-eqRXuVG-.esm.js";
 import { t as endpoints } from "./endpoints-B3V1U9Dg.esm.js";
 import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-7GmmAwg6.esm.js";
-import { r as isIOS, t as isAndroid } from "./platform-Dpzd9p3X.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-CDh4uv5Y.esm.js";
 
 //#region src/modules/geolocation/geolocationServices.ts
 async function addGeolocation(params, signal) {

package/dist/{getDeviceClass-DmoqR7G2.esm.js → getDeviceClass-C1ZS2XJL.esm.js}

@@ -1,4 +1,4 @@
-import { n as getDeviceInfo } from "./getBrowser-Y88tNVud.esm.js";
+import { n as getDeviceInfo } from "./getBrowser-Bl0PlyDu.esm.js";
 
 //#region src/internal/device/getDeviceClass.ts
 function getDeviceClass() {

package/dist/home.d.ts

@@ -1,8 +1,8 @@
 import { t as Manager } from "./Manager-D9pehGyp.js";
 import "./camera-B6UAKpM1.js";
 import "./types-DJSt3Ovt.js";
-import { t as EmptyConfig } from "./types-BA181GDD.js";
-import * as xstate468 from "xstate";
+import { t as EmptyConfig } from "./types-DkXZpS0R.js";
+import * as xstate726 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -34,41 +34,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate468.StateMachine<HomeContext, {
+declare const homeMachine: xstate726.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate468.NonReducibleUnknown, xstate468.EventObject, xstate468.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate726.NonReducibleUnknown, xstate726.EventObject, xstate726.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate468.ActorRefFromLogic<never>;
-      <TLogic extends xstate468.AnyActorLogic>(src: TLogic, ...[options]: xstate468.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate726.ActorRefFromLogic<never>;
+      <TLogic extends xstate726.AnyActorLogic>(src: TLogic, ...[options]: xstate726.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate468.InputFrom<TLogic> | undefined;
+        input?: xstate726.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate468.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate468.IsNotNever<xstate468.RequiredLogicInput<TLogic>>>): xstate468.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate726.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate726.IsNotNever<xstate726.RequiredLogicInput<TLogic>>>): xstate726.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate468.ActorRef<xstate468.MachineSnapshot<HomeContext, {
+    self: xstate726.ActorRef<xstate726.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate468.AnyActorRef | undefined>, xstate468.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate726.AnyActorRef | undefined>, xstate726.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate468.AnyEventObject>;
+    }, xstate726.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };

package/dist/http.d.ts

@@ -12,6 +12,15 @@ type RequestConfig = {
   parse?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'response';
   onUploadProgress?: (progress: number) => void;
   keepalive?: boolean;
+  /**
+   * Transport-internal flag: the request body has already been inline-
+   * encrypted by C++ `SessionEncryptor` (used only by the on-device face-
+   * results path). When true, `createWasmApi` attaches the SHA-256 OAEP
+   * scheme header so the server can unwrap the embedded AES key, and
+   * forwards the flag to the WASM WebClient so it does not double-encrypt.
+   * Ignored by non-WASM transports.
+   */
+  ie?: boolean;
 };
 type HttpResponse<T = unknown> = {
   ok: boolean;