@incodetech/core 0.0.0-dev-20260911-aec162f0 → 0.0.0-dev-20260914-8aef7789

package/dist/{FaceDetectionProvider-Cn1wS-sA.d.ts → BaseWasmProvider-CO0GfaHM.d.ts}

@@ -1,5 +1,5 @@
-import { c as WasmPipeline } from "./warmup-CXHBgvFC.js";
-import { _ as MLProviderConfig, c as FaceAttributesThresholds, d as FaceDetectionCallbacks, f as FaceDetectionConfig, h as IFaceDetectionCapability, l as FaceChecksConfig, m as FacePositionConstraints, p as FaceDetectionThresholds, v as WebApiHostRequestConfig } from "./createFaceAvatar-pUEkdk4X.js";
+import { c as WasmPipeline } from "./warmup-Cis2p6O0.js";
+import { _ as MLProviderConfig } from "./createFaceAvatar-CTM9aj9Q.js";
 //#region ../infra/src/wasm/WasmPipelineType.d.ts
 declare enum WasmPipelineType {
   IdBlurGlarePipeline = 0,
@@ -7,7 +7,10 @@ declare enum WasmPipelineType {
   IdVideoSelfiePipeline = 2,
   SelfieWithAggregationMetrics = 3,
   SelfieWithQualityMetrics = 4,
-  OnDeviceSelfieWorkflow = 5
+  OnDeviceSelfieWorkflow = 5,
+  IdBlurGlareCoreWorkflow = 6,
+  IdBarcodeAndTextQualityCoreWorkflow = 7,
+  IdFaceQualityCoreWorkflow = 8
 }
 //#endregion
 //#region ../infra/src/providers/wasm/BaseWasmProvider.d.ts
@@ -59,37 +62,4 @@ declare abstract class BaseWasmProvider {
   dispose(): Promise<void>;
 }
 //#endregion
-//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
-declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
-  private defaultThresholds;
-  private currentThresholds;
-  private currentFrame;
-  private onFaceDataCallback;
-  constructor();
-  processFrame(image: ImageData): Promise<void>;
-  initialize(config: FaceDetectionConfig): Promise<void>;
-  /**
-   * Last-registered onCapture callback — captured into a private
-   * field so `forceCapture()` (called from outside the WASM-callback
-   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
-   * this on each invocation, so the field always reflects the
-   * current consumer.
-   */
-  private currentOnCaptureWrapper;
-  processPhoto(canvas: HTMLCanvasElement): void;
-  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
-  setCallbacks(callbacks: FaceDetectionCallbacks): void;
-  setPositionConstraints(constraints: FacePositionConstraints): void;
-  applyDefaults(autocaptureInterval?: number): void;
-  setAutocaptureInterval(interval: number): void;
-  setThresholds(thresholds: FaceDetectionThresholds): void;
-  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
-  setChecksEnabled(config: FaceChecksConfig): void;
-  setVideoSelfieMode(enabled: boolean): void;
-  forceCapture(): void;
-  reset(): void;
-  private createDefaultFaceCoordinates;
-  private formatFaceCoordinates;
-}
-//#endregion
-export { BaseWasmProvider as n, FaceDetectionProvider as t };
+export { BaseWasmProvider as t };

package/dist/{BrowserDiagnosticsCryptoProvider-8sT0QLgq.esm.js → BrowserDiagnosticsCryptoProvider-BoYzmYY5.esm.js}

@@ -18,7 +18,7 @@ function decodeTruesightKey(s0Base64, s1Base64) {
 */
 function getTruesightKey() {
 	try {
-		const key = decodeTruesightKey("ZR6NEUatEDJgSvRH/Ot5KSD50psNe0TwFEsgOiejsz0=", "i2EzdqTQA8BF3fYvJ8ZeGn+5pgEt3mJR6TgfDtpGD4k=");
+		const key = decodeTruesightKey("otyKosLQyND3E+A5iFHGX1TE2atuG6t36WCf3aVSleQ=", "oN7U9FX22geH2kWrWh68jSat2HWXYRQl1DMvbbqpiHQ=");
 		return key.length === KEY_LENGTH_BYTES ? key : null;
 	} catch {
 		return null;

package/dist/{onDeviceFaceResults-hle2Ci9l.esm.js → FaceDetectionProvider-0bWjPgW5.esm.js}

@@ -1,17 +1,215 @@
-import { t as ensureWasmPipelines } from "./setup-BHJ3-fhX.esm.js";
-import { s as wasmRuntime } from "./warmup-BOM-sD-6.esm.js";
-import { i as BaseWasmProvider } from "./safeStorage-Dp9m6aOh.esm.js";
-import { r as getToken } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-DLzYznkh.esm.js";
-import { v as yieldUntilNextPaint } from "./sessionInitializer-CEycxhm4.esm.js";
+import { t as ensureWasmPipelines } from "./setup-CfNAVG-d.esm.js";
+import { s as wasmRuntime } from "./warmup-CUUnwYxe.esm.js";
+import { i as BaseWasmProvider } from "./safeStorage-1O9k0ulP.esm.js";
+import { c as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-TqmmYye3.esm.js";
+import "./sessionInitializer-CUpgbHzs.esm.js";
 import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { c as isIPhone14OrHigher, i as isDesktop } from "./platform-DkcRc9JV.esm.js";
-import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
-import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
+import { i as requestCameraAccess, o as stopCameraStream, r as getCameraReacquisitionConstraints } from "./camera-sIa9ceW2.esm.js";
+import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
 import { a as StreamCanvasProcessingSession, n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-CCWy13M-.esm.js";
-import { i as hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-DE_5qY04.esm.js";
+import { i as hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
+//#region src/internal/faceCapture/onDeviceFaceResults.ts
+/**
+* On-device still-face capture is owned by the protected camera-cycle actor.
+* Core uses this guard only to select the backwards-compatible validation and
+* processing behavior after the native actor posts completion-only results.
+*/
+const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
+//#endregion
+//#region src/internal/faceCapture/faceCaptureServices.ts
+function sendLabelInspectionEvent() {
+	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
+}
+const MOBILE_SELFIE_CONSTRAINTS = {
+	video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	},
+	audio: false
+};
+const IPHONE14_SELFIE_CONSTRAINTS = {
+	video: { height: { ideal: 1080 } },
+	audio: false
+};
+function buildCameraConstraints(resolution, deviceId) {
+	if (resolution) return {
+		video: {
+			facingMode: "user",
+			deviceId: deviceId ? { exact: deviceId } : void 0,
+			height: resolution.height ? { ideal: resolution.height } : void 0,
+			width: resolution.width ? { ideal: resolution.width } : void 0
+		},
+		audio: false
+	};
+	if (isIPhone14OrHigher()) return IPHONE14_SELFIE_CONSTRAINTS;
+	return MOBILE_SELFIE_CONSTRAINTS;
+}
+function stopStream(stream) {
+	stopCameraStream(stream);
+}
+async function getFrontCameraStream(resolution) {
+	if (isDesktop()) {
+		if (resolution) return ensureFrontCameraStream((deviceId) => requestCameraAccess(buildCameraConstraints(resolution, deviceId)));
+		return ensureFrontCameraStream((deviceId) => getDesktopCameraStream(deviceId ? { deviceId } : {}));
+	}
+	return requestCameraAccess(resolution ? buildCameraConstraints(resolution) : buildCameraConstraints());
+}
+async function initializeCamera(params) {
+	const { config } = params;
+	await ensureWasmPipelines([isOnDeviceMode(config) ? "onDeviceSelfie" : "selfie"]);
+	const usingBackCamera = config.assistedOnboarding === true && await hasBackCamera();
+	const backCamera = usingBackCamera ? await getBackCameraStream() : void 0;
+	const stream = backCamera?.stream ?? await getFrontCameraStream(config.cameraResolution);
+	const constraints = getCameraReacquisitionConstraints(stream.getVideoTracks()[0], backCamera?.constraints);
+	return {
+		stream,
+		provider: params.provider,
+		usingBackCamera,
+		constraints
+	};
+}
+/**
+* Encrypts the provided selfie image using WASM.
+*/
+async function encryptSelfieImage({ canvas, dependencies }) {
+	const base64Image = canvas.getBase64Image();
+	if (!base64Image) throw new Error("Canvas image is empty or null");
+	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
+}
+function startDetection(params) {
+	let lastStatus;
+	let session;
+	const { provider } = params;
+	const setStatus = (status) => {
+		if (session?.isDisposed() === true) return;
+		if (lastStatus === status) return;
+		lastStatus = status;
+		trueSightHintTransition("module.face-capture", "faceScan", status);
+		params.onUpdate(status);
+	};
+	const stopDetectionLoop = () => {
+		session?.dispose();
+		noteTrueSightCaptureActivity(false);
+	};
+	const reset = () => {
+		provider.reset();
+	};
+	const cleanup = () => {
+		stopDetectionLoop();
+	};
+	(async () => {
+		try {
+			provider.setCallbacks({
+				onFarAway: () => setStatus("tooFar"),
+				onTooClose: () => setStatus("tooClose"),
+				onTooManyFaces: () => setStatus("tooManyFaces"),
+				onNoFace: () => setStatus("idle"),
+				onCenterFace: () => setStatus("centerFace"),
+				onGetReady: () => setStatus("getReady"),
+				onGetReadyFinished: () => setStatus("getReadyFinished"),
+				onDark: () => {
+					if (params.config.validateBrightness) setStatus("dark");
+				},
+				onBlur: () => setStatus("blur"),
+				onFaceAngle: () => setStatus("faceAngle"),
+				onLenses: () => {
+					if (params.config.validateLenses) setStatus("lenses");
+				},
+				onMask: () => {
+					if (params.config.validateFaceMask) setStatus("faceMask");
+				},
+				onEyesClosed: () => {
+					if (params.config.validateClosedEyes) setStatus("eyesClosed");
+				},
+				onHeadWear: () => {
+					if (params.config.validateHeadCover) setStatus("headWear");
+				},
+				onFaceOccluded: () => setStatus("faceOcclusion"),
+				onFaceData: params.onPose,
+				onSwitchToManualCapture: () => {
+					setStatus("manualCapture");
+					stopDetectionLoop();
+				},
+				onCapture: (canvas, faceCoordinates) => {
+					setStatus("success");
+					params.onSuccess(canvas, faceCoordinates);
+					cleanup();
+				}
+			});
+			setStatus("detecting");
+			session = new StreamCanvasProcessingSession({
+				capturer: params.capturer,
+				provider,
+				onFrame: params.onFrame
+			});
+			noteTrueSightCaptureActivity(true);
+		} catch {
+			setStatus("error");
+			cleanup();
+		}
+	})();
+	return {
+		cleanup,
+		reset
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return;
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
+}
+async function startRecordingSession(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
+	if (params.config.enableFaceRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability;
+	if (!provider) return;
+	const clonedStream = params.clonedStream;
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession("selfie");
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: "selfie",
+		resolution,
+		hasAudio
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+async function stopRecording(session) {
+	try {
+		await stopRecording$1(session.videoRecordingId);
+	} finally {
+		await session.connection.disconnect();
+	}
+}
+async function initializeDeepsightSession(options) {
+	const { loadDeepsightSession } = await import("./deepsightLoader-Dhz9T_KJ.esm.js");
+	return loadDeepsightSession({
+		ds: options.ds,
+		storage: options.storage
+	});
+}
+//#endregion
 //#region ../infra/src/wasm/faceProcessingWasmApi.ts
+const PROCESS_PHOTO_UNSUPPORTED_ERROR = "[Incode SDK] processPhoto is unsupported by ml-wasm-kit v2.14.49-post1.";
 var FaceProcessingWasmApi = class {
 	constructor(runtime = wasmRuntime) {
 		this.runtime = runtime;
@@ -35,15 +233,12 @@ var FaceProcessingWasmApi = class {
 		this.runtime.requireFaceProcessingApi("Unable to set face detection callbacks, cpp API hasn't been initialized").setFaceProcessingCallbacks(this.runtime.pipelineTypeToWasmEnum(type), onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded);
 	}
 	/**
-	* Synchronous manual-capture entry point for the OnDevice selfie workflow.
-	* Runs face detection + the full on-device quality / liveness / age pipeline
-	* on a single canvas image and stages the results inside the WASM `WebApi`
-	* for the next {@link postFaceResults} call. No polling, no semaphore wrap.
-	*
-	* Mirrors `ml-wasm-kit/WasmApi.processPhoto`.
+	* @deprecated Removed from ml-wasm-kit v2.14.49-post1. The signature stays
+	* available for source compatibility, but the canvas never reaches native
+	* code; protected manual capture is owned by the camera-cycle facade.
 	*/
-	processPhoto(canvas) {
-		this.runtime.requireFaceProcessingApi("Unable to process photo, cpp API hasn't been initialized").processPhoto(canvas);
+	processPhoto(_canvas) {
+		throw new Error(PROCESS_PHOTO_UNSUPPORTED_ERROR);
 	}
 	/**
 	* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
@@ -57,7 +252,7 @@ var FaceProcessingWasmApi = class {
 	* `initialize()`. The C++ `OnDeviceSelfieWorkflow` has already staged the
 	* aggregated best-shot results into that instance via
 	* `WebApi::setFaceResults(...)` during per-frame processing (auto-capture) or
-	* via {@link processPhoto} (manual-capture).
+	* through the protected camera-cycle manual-capture path.
 	*/
 	postFaceResults(config) {
 		return this.runtime.requireWebApi("Unable to post face results, cpp API hasn't been initialized").postFaceResults(config ?? {});
@@ -68,7 +263,10 @@ var FaceProcessingWasmApi = class {
 	*/
 	async runSelfieCapture(image) {
 		const faceProcessingWasmApi = this.runtime.requireFaceProcessingApi("Unable to run Selfie Capture, cpp API hasn't been initialized");
-		this.runtime.writeFrame(image);
+		if (image) {
+			await this.runtime.allocateImageBuffers(image.width, image.height);
+			this.runtime.writeFrame(image);
+		}
 		return faceProcessingWasmApi.runSelfieCapture();
 	}
 };
@@ -145,7 +343,6 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 		if (config.videoSelfie === true) this.setVideoSelfieMode(true);
 	}
 	processPhoto(canvas) {
-		this.ensureInitialized();
 		faceProcessingWasmApi.processPhoto(canvas);
 	}
 	async postFaceResults(config) {
@@ -274,322 +471,4 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 	}
 };
 //#endregion
-//#region src/internal/faceCapture/faceCaptureServices.ts
-const ONDEVICE_AUTOCAPTURE_INTERVAL_MS = 2147483647;
-function sendLabelInspectionEvent() {
-	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
-}
-const MOBILE_SELFIE_CONSTRAINTS = {
-	video: {
-		facingMode: "user",
-		height: { ideal: 480 },
-		width: { ideal: 640 }
-	},
-	audio: false
-};
-const IPHONE14_SELFIE_CONSTRAINTS = {
-	video: { height: { ideal: 1080 } },
-	audio: false
-};
-function buildCameraConstraints(resolution, deviceId) {
-	if (resolution) return {
-		video: {
-			facingMode: "user",
-			deviceId: deviceId ? { exact: deviceId } : void 0,
-			height: resolution.height ? { ideal: resolution.height } : void 0,
-			width: resolution.width ? { ideal: resolution.width } : void 0
-		},
-		audio: false
-	};
-	if (isIPhone14OrHigher()) return IPHONE14_SELFIE_CONSTRAINTS;
-	return MOBILE_SELFIE_CONSTRAINTS;
-}
-function stopStream(stream) {
-	stopCameraStream(stream);
-}
-async function getFrontCameraStream(resolution) {
-	if (isDesktop()) {
-		if (resolution) return ensureFrontCameraStream((deviceId) => requestCameraAccess(buildCameraConstraints(resolution, deviceId)));
-		return ensureFrontCameraStream((deviceId) => getDesktopCameraStream(deviceId ? { deviceId } : {}));
-	}
-	return requestCameraAccess(resolution ? buildCameraConstraints(resolution) : buildCameraConstraints());
-}
-async function initializeCamera(params) {
-	const { config } = params;
-	const prcConstraints = buildCameraConstraints(config.cameraResolution);
-	await ensureWasmPipelines([isOnDeviceMode(config) ? "onDeviceSelfie" : "selfie"]);
-	const provider = new FaceDetectionProvider();
-	await provider.initialize({
-		autocaptureInterval: isOnDeviceMode(config) ? ONDEVICE_AUTOCAPTURE_INTERVAL_MS : config.autoCaptureTimeout * 1e3,
-		useOnDeviceWorkflow: config.onDeviceFaceResultsSubmissionEnabled === true
-	});
-	provider.setChecksEnabled({
-		lenses: config.validateLenses ?? false,
-		mask: config.validateFaceMask ?? false,
-		closedEyes: config.validateClosedEyes ?? false,
-		headWear: config.validateHeadCover ?? false,
-		occlusion: false
-	});
-	await params.deepsightService.performPrcCheck({ constraints: { video: prcConstraints.video } });
-	const usingBackCamera = config.assistedOnboarding === true && await hasBackCamera();
-	return {
-		stream: usingBackCamera ? (await getBackCameraStream()).stream : await getFrontCameraStream(config.cameraResolution),
-		provider,
-		usingBackCamera
-	};
-}
-/**
-* Encrypts the provided selfie image using WASM.
-*/
-async function encryptSelfieImage({ canvas, dependencies }) {
-	const base64Image = canvas.getBase64Image();
-	if (!base64Image) throw new Error("Canvas image is empty or null");
-	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
-}
-function startDetection(params) {
-	let lastStatus;
-	let session;
-	const { provider } = params;
-	const setStatus = (status) => {
-		if (session?.isDisposed() === true) return;
-		if (lastStatus === status) return;
-		lastStatus = status;
-		trueSightHintTransition("module.face-capture", "faceScan", status);
-		params.onUpdate(status);
-	};
-	const stopDetectionLoop = () => {
-		session?.dispose();
-		noteTrueSightCaptureActivity(false);
-	};
-	const reset = () => {
-		provider.reset();
-	};
-	const cleanup = () => {
-		stopDetectionLoop();
-	};
-	(async () => {
-		try {
-			provider.setCallbacks({
-				onFarAway: () => setStatus("tooFar"),
-				onTooClose: () => setStatus("tooClose"),
-				onTooManyFaces: () => setStatus("tooManyFaces"),
-				onNoFace: () => setStatus("idle"),
-				onCenterFace: () => setStatus("centerFace"),
-				onGetReady: () => setStatus("getReady"),
-				onGetReadyFinished: () => setStatus("getReadyFinished"),
-				onDark: () => {
-					if (params.config.validateBrightness) setStatus("dark");
-				},
-				onBlur: () => setStatus("blur"),
-				onFaceAngle: () => setStatus("faceAngle"),
-				onLenses: () => {
-					if (params.config.validateLenses) setStatus("lenses");
-				},
-				onMask: () => {
-					if (params.config.validateFaceMask) setStatus("faceMask");
-				},
-				onEyesClosed: () => {
-					if (params.config.validateClosedEyes) setStatus("eyesClosed");
-				},
-				onHeadWear: () => {
-					if (params.config.validateHeadCover) setStatus("headWear");
-				},
-				onFaceOccluded: () => setStatus("faceOcclusion"),
-				onFaceData: params.onPose,
-				onSwitchToManualCapture: () => {
-					setStatus("manualCapture");
-					stopDetectionLoop();
-				},
-				onCapture: (canvas, faceCoordinates) => {
-					setStatus("success");
-					params.onSuccess(canvas, faceCoordinates);
-					cleanup();
-				}
-			});
-			setStatus("detecting");
-			session = new StreamCanvasProcessingSession({
-				capturer: params.capturer,
-				provider,
-				onFrame: params.onFrame
-			});
-			noteTrueSightCaptureActivity(true);
-		} catch {
-			setStatus("error");
-			cleanup();
-		}
-	})();
-	return {
-		cleanup,
-		reset
-	};
-}
-function buildResolutionFromStream(stream) {
-	const track = stream.getVideoTracks()[0];
-	if (!track) return;
-	const settings = track.getSettings();
-	const width = settings.width;
-	const height = settings.height;
-	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
-}
-async function startRecordingSession(params) {
-	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
-	if (params.config.enableFaceRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability;
-	if (!provider) return;
-	const clonedStream = params.clonedStream;
-	const hasAudio = clonedStream.getAudioTracks().length > 0;
-	const resolution = buildResolutionFromStream(clonedStream);
-	const session = await createRecordingSession("selfie");
-	const connection = await provider.connect({
-		sessionToken: session.token,
-		stream: clonedStream,
-		events: {}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: "selfie",
-		resolution,
-		hasAudio
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
-}
-async function stopRecording(session) {
-	try {
-		await stopRecording$1(session.videoRecordingId);
-	} finally {
-		await session.connection.disconnect();
-	}
-}
-async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-Dwr1zKFa.esm.js");
-	return loadDeepsightSession({
-		ds: options.ds,
-		storage: options.storage
-	});
-}
-//#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 the per-request `createWasmApi` encryption pipeline
-* is not engaged on this path.
-*
-* Note: even though the per-request encryption pipeline is skipped, the
-* on-device endpoint (`/omni/add/face-results`) is only served on the
-* E2EE-provisioned host — callers must still configure `setup()` with the
-* dedicated E2EE `apiURL` and `encryption: true`. See `SetupOptions.encryption`.
-*
-* 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.
-* Prepares any recording metadata required by the image upload, runs deepsight
-* virtual-camera + frame checks, tracks the capture attempt, and encrypts the
-* captured image. Scoped multipart recordings pause while an attempt is being
-* uploaded, resume after a rejection, and are finalized by the state machine
-* after backend acceptance.
-*
-* 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?.prepareUpload())?.recordingId ?? null;
-	try {
-		if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
-	} catch (error) {
-		trueSightLog("warning", "deepsight", "faceScan", `deepsight selfie analysis failed error=${String(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.
-*
-* Behavior depends on which capture path got us here:
-*
-* - **Auto-capture path**: the WASM `OnDeviceSelfiePipeline` has been
-*   consuming every video frame via `processFrame()` and aggregating
-*   results across them. When it picks a best-shot, the C++
-*   `OnDeviceSelfieWorkflow::createOnCaptureHandler` calls
-*   `WebApi::setFaceResults(...)` automatically — staging strong,
-*   aggregated `BestShotData` for the subsequent `postFaceResults` call.
-*   We must NOT call `processPhoto` here: `applyFaceResults` would
-*   overwrite that staged state with a weaker single-frame analysis of a
-*   post-capture snapshot (camera state has already changed: autocapture
-*   freeze, stream pause, post-detection latency), and the server then
-*   rejects the submission as "image quality too low".
-*
-* - **Manual-capture path**: the auto-capture timer expired without a
-*   successful best-shot, so the C++ pipeline has nothing staged. We
-*   need to run a single-frame analysis on the manually captured canvas
-*   via `processPhoto`, which itself calls
-*   `OnDeviceSelfieWorkflow::applyFaceResults` → `WebApi::setFaceResults`
-*   to stage results. Mirrors V1 (`packages/incode-welcome/src/camera/useSelfie.ts`)
-*   where `processPhoto` is only invoked from `handleManualCapture`.
-*
-* 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");
-	if (ctx.manualCaptureTriggered) {
-		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
-export { encryptSelfieImage as a, sendLabelInspectionEvent as c, stopRecording as d, stopStream as f, prepareOnDeviceFaceUpload as i, startDetection as l, isOnDeviceMode as n, initializeCamera as o, FaceDetectionProvider as p, postOnDeviceFaceResults as r, initializeDeepsightSession as s, defaultPrepareFaceUpload as t, startRecordingSession as u };
+export { sendLabelInspectionEvent as a, stopRecording as c, initializeDeepsightSession as i, stopStream as l, encryptSelfieImage as n, startDetection as o, initializeCamera as r, startRecordingSession as s, FaceDetectionProvider as t, isOnDeviceMode as u };