@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/manualReviewService-D4IkipnN.esm.js

@@ -1,15 +0,0 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-//#region src/internal/manualReview/manualReviewService.ts
-async function flagFaceManualReview() {
-	try {
-		await api.put(endpoints.updateSession, { manualSelfieCheckNeeded: true });
-	} catch {}
-}
-async function flagIdManualReview() {
-	try {
-		await api.put(endpoints.updateSession, { manualIdCheckNeeded: true });
-	} catch {}
-}
-//#endregion
-export { flagIdManualReview as n, flagFaceManualReview as t };

package/dist/mediaRecorderOptions-dALSV8af.esm.js

@@ -1,40 +0,0 @@
-import { i as isIOS } from "./platform-BJrm5nzZ.esm.js";
-//#region ../infra/src/media/mediaRecorderOptions.ts
-/**
-* Picks a `MediaRecorder` mime type the current browser actually supports,
-* preferring mp4 on iOS and webm elsewhere. Returns '' when none match.
-*/
-function getSupportedMediaRecorderMimeType() {
-	const possibleTypes = isIOS() ? [
-		"video/mp4",
-		"video/webm",
-		"video/webm;codecs=vp9",
-		"video/webm;codecs=vp8"
-	] : [
-		"video/webm",
-		"video/webm;codecs=vp9",
-		"video/webm;codecs=vp8",
-		"video/mp4"
-	];
-	for (const type of possibleTypes) if (MediaRecorder.isTypeSupported(type)) return type;
-	return "";
-}
-/**
-* `MediaRecorder` options tuned per platform — a higher bitrate on iOS, lower
-* elsewhere — paired with the supported mime type.
-*/
-function getAdaptiveMediaRecorderOptions() {
-	const mimeType = getSupportedMediaRecorderMimeType();
-	if (isIOS()) return {
-		mimeType,
-		videoBitsPerSecond: 1e6,
-		bitsPerSecond: 1e6
-	};
-	return {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		bitsPerSecond: 5e5
-	};
-}
-//#endregion
-export { getSupportedMediaRecorderMimeType as n, getAdaptiveMediaRecorderOptions as t };

package/dist/onDeviceFaceResults-CUHwyZT4.esm.js

@@ -1,646 +0,0 @@
-import { c as mlWasmJSApi_default, i as BaseWasmProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService---iW2KKJ.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import "./trueSight-B_icM8r2.esm.js";
-import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
-import { o as isIPhone14OrHigher, r as isDesktop } from "./platform-BJrm5nzZ.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 hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-CUeYm5eu.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 ../infra/src/providers/wasm/FaceDetectionProvider.ts
-/**
-* Best-effort `delete()` for Emscripten `embind`-bound handles. Plain
-* JS values lack a `.delete` method and are skipped; proxy objects
-* have it and need it called once to free the underlying C++ memory.
-* Swallows errors because this runs at 15–30 Hz on the detection hot
-* path — a throwing cleanup must never abort frame processing.
-*/
-function tryDeleteEmbindHandle(value) {
-	const maybeDelete = value?.delete;
-	if (typeof maybeDelete !== "function") return;
-	try {
-		maybeDelete.call(value);
-	} catch {}
-}
-var FaceDetectionProvider = class extends BaseWasmProvider {
-	constructor() {
-		super(4);
-		this.defaultThresholds = {
-			frameMinX: 0,
-			frameMinY: 0,
-			frameMaxX: 1,
-			frameMaxY: 1,
-			brightnessThreshold: 50,
-			blurrinessThreshold: 50,
-			tiltRotationAngleThreshold: 15,
-			minMagicCropSize: 200,
-			headwearThreshold: .86,
-			lensesThreshold: .95,
-			closedEyesThreshold: .9,
-			maskThreshold: .85,
-			minFaceQualityScore: .63,
-			faceOcclusionThreshold: .3,
-			getReadyDelay: 2e3,
-			framesAggregationInterval: 2e3,
-			minFramesWithFace: 3
-		};
-		this.currentFrame = null;
-	}
-	async processFrame(image) {
-		this.currentFrame = image;
-		const result = await this.processFrameWasm(image);
-		if (this.onFaceDataCallback && result?.faces) {
-			let face;
-			try {
-				if ((typeof result.faces.size === "function" ? result.faces.size() : 0) > 0) {
-					face = typeof result.faces.get === "function" ? result.faces.get(0) : void 0;
-					if (face) this.onFaceDataCallback(face, {
-						width: image.width,
-						height: image.height
-					});
-				}
-			} catch {} finally {
-				tryDeleteEmbindHandle(face);
-				tryDeleteEmbindHandle(result.faces);
-				tryDeleteEmbindHandle(result);
-			}
-		}
-	}
-	async initialize(config) {
-		if (config.videoSelfie === true) {
-			this.pipelineType = 3;
-			await this.initializeBase(config, "videoSelfie");
-		} else if (config.useOnDeviceWorkflow === true) {
-			this.pipelineType = 5;
-			await this.initializeBase(config, "onDeviceSelfie");
-		} else await this.initializeBase(config, "selfie");
-		this.applyDefaults(config.autocaptureInterval ?? 0);
-		if (config.videoSelfie === true) this.setVideoSelfieMode(true);
-	}
-	processPhoto(canvas) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.processPhoto(canvas);
-	}
-	async postFaceResults(config) {
-		this.ensureInitialized();
-		return mlWasmJSApi_default.postFaceResults(config);
-	}
-	setCallbacks(callbacks) {
-		this.ensureInitialized();
-		this.onFaceDataCallback = callbacks.onFaceData;
-		const onCaptureWrapper = (wasmCanvas, face) => {
-			if (!wasmCanvas) return;
-			const frameCanvas = new IncodeCanvas(wasmCanvas);
-			frameCanvas.updateBase64Image();
-			frameCanvas.updateBlob();
-			const faceCoordinates = face ? this.formatFaceCoordinates(face) : this.createDefaultFaceCoordinates(frameCanvas);
-			callbacks.onCapture?.(frameCanvas, faceCoordinates);
-		};
-		this.currentOnCaptureWrapper = onCaptureWrapper;
-		mlWasmJSApi_default.setFaceDetectionCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onTooClose ?? (() => {}), callbacks.onTooManyFaces ?? (() => {}), callbacks.onNoFace ?? (() => {}), onCaptureWrapper, callbacks.onGetReady ?? (() => {}), callbacks.onGetReadyFinished ?? (() => {}), callbacks.onCenterFace ?? (() => {}), callbacks.onDark ?? (() => {}), callbacks.onBlur ?? (() => {}), callbacks.onFaceAngle ?? (() => {}), callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
-	}
-	setPositionConstraints(constraints) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFacePositionConstraints(this.getPipelineType(), constraints.minX, constraints.minY, constraints.maxX, constraints.maxY);
-	}
-	applyDefaults(autocaptureInterval = 0) {
-		this.ensureInitialized();
-		this.setThresholds({
-			brightnessThreshold: this.defaultThresholds.brightnessThreshold,
-			blurrinessThreshold: this.defaultThresholds.blurrinessThreshold,
-			tiltRotationAngleThreshold: this.defaultThresholds.tiltRotationAngleThreshold,
-			minMagicCropSize: this.defaultThresholds.minMagicCropSize,
-			autocaptureInterval,
-			minFaceQualityScore: this.defaultThresholds.minFaceQualityScore,
-			faceOcclusionThreshold: this.defaultThresholds.faceOcclusionThreshold,
-			getReadyDelay: this.defaultThresholds.getReadyDelay,
-			framesAggregationInterval: this.defaultThresholds.framesAggregationInterval,
-			minFramesWithFace: this.defaultThresholds.minFramesWithFace
-		});
-		this.setPositionConstraints({
-			minX: this.defaultThresholds.frameMinX,
-			minY: this.defaultThresholds.frameMinY,
-			maxX: this.defaultThresholds.frameMaxX,
-			maxY: this.defaultThresholds.frameMaxY
-		});
-		this.setAttributesThresholds({
-			headwearThreshold: this.defaultThresholds.headwearThreshold,
-			lensesThreshold: this.defaultThresholds.lensesThreshold,
-			closedEyesThreshold: this.defaultThresholds.closedEyesThreshold,
-			maskThreshold: this.defaultThresholds.maskThreshold
-		});
-	}
-	setAutocaptureInterval(interval) {
-		this.ensureInitialized();
-		if (!this.currentThresholds) {
-			this.applyDefaults(interval);
-			return;
-		}
-		this.setThresholds({
-			...this.currentThresholds,
-			autocaptureInterval: interval
-		});
-	}
-	setThresholds(thresholds) {
-		this.ensureInitialized();
-		this.currentThresholds = { ...thresholds };
-		mlWasmJSApi_default.setFaceDetectionThresholds(this.getPipelineType(), thresholds.brightnessThreshold, thresholds.blurrinessThreshold, thresholds.tiltRotationAngleThreshold, thresholds.minMagicCropSize, thresholds.autocaptureInterval, thresholds.minFaceQualityScore, thresholds.faceOcclusionThreshold, thresholds.getReadyDelay, thresholds.framesAggregationInterval, thresholds.minFramesWithFace);
-	}
-	setAttributesThresholds(thresholds) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceAttributesThresholds(this.getPipelineType(), thresholds.headwearThreshold, thresholds.lensesThreshold, thresholds.closedEyesThreshold, thresholds.maskThreshold);
-	}
-	setChecksEnabled(config) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceChecksEnabled(this.getPipelineType(), config.lenses, config.mask, config.closedEyes, config.headWear, config.occlusion);
-	}
-	setVideoSelfieMode(enabled) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceDetectionMode(this.getPipelineType(), enabled);
-	}
-	forceCapture() {
-		if (!this.currentFrame || !this.currentOnCaptureWrapper) return;
-		const frame = IncodeCanvas.fromImageData(this.currentFrame);
-		this.currentOnCaptureWrapper(frame.canvas);
-	}
-	reset() {
-		super.reset();
-		this.currentFrame = null;
-		this.onFaceDataCallback = void 0;
-		this.currentOnCaptureWrapper = void 0;
-	}
-	createDefaultFaceCoordinates(canvas) {
-		return {
-			rightEyeX: 0,
-			rightEyeY: 0,
-			leftEyeX: 0,
-			leftEyeY: 0,
-			noseTipX: 0,
-			noseTipY: 0,
-			rightMouthX: 0,
-			rightMouthY: 0,
-			mouthX: 0,
-			mouthY: 0,
-			x: 0,
-			y: 0,
-			width: canvas.width() ?? 0,
-			height: canvas.height() ?? 0
-		};
-	}
-	formatFaceCoordinates(face) {
-		return {
-			rightEyeX: face.rightEye.x,
-			rightEyeY: face.rightEye.y,
-			leftEyeX: face.leftEye.x,
-			leftEyeY: face.leftEye.y,
-			noseTipX: face.noseTip.x,
-			noseTipY: face.noseTip.y,
-			rightMouthX: face.rightMouthCorner.x,
-			rightMouthY: face.rightMouthCorner.y,
-			mouthX: face.leftMouthCorner.x,
-			mouthY: face.leftMouthCorner.y,
-			x: face.rect.x,
-			y: face.rect.y,
-			width: face.rect.width,
-			height: face.rect.height
-		};
-	}
-};
-//#endregion
-//#region ../infra/src/media/StreamCanvasProcessingSession.ts
-var StreamCanvasProcessingSession = class {
-	/**
-	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
-	* and drives a provider's `processFrame()` method with backpressure.
-	*/
-	constructor(params) {
-		this.disposed = false;
-		this.isProcessing = false;
-		this.onFrameEvent = () => {
-			if (this.disposed || this.isProcessing) return;
-			const frame = this.capturer.getLatestFrame();
-			if (!frame) return;
-			this.onFrame?.(frame);
-			this.isProcessing = true;
-			this.provider.processFrame(frame).catch(() => {}).finally(() => {
-				this.isProcessing = false;
-			});
-		};
-		this.capturer = params.capturer;
-		this.provider = params.provider;
-		this.onFrame = params.onFrame;
-		this.capturer.addEventListener("frame", this.onFrameEvent);
-	}
-	/**
-	* Unsubscribes from frame events and resets the provider.
-	*/
-	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.capturer.removeEventListener("frame", this.onFrameEvent);
-		this.provider.reset();
-	}
-	/**
-	* Returns whether the session has been disposed.
-	*/
-	isDisposed() {
-		return this.disposed;
-	}
-};
-//#endregion
-//#region src/internal/recordings/recordingsRepository.ts
-async function createRecordingSession(type) {
-	return (await api.post(endpoints.recordingCreateSessionV2, { type })).data;
-}
-async function startRecording(params) {
-	return (await api.post(endpoints.recordingStartV2, {
-		videoRecordingId: params.videoRecordingId,
-		frameRate: 30,
-		outputMode: "COMPOSED",
-		resolution: params.resolution,
-		type: params.type,
-		hasAudio: params.hasAudio ?? false
-	})).data;
-}
-async function stopRecording$1(videoRecordingId) {
-	return (await api.post(endpoints.recordingStopV2, { videoRecordingId })).data;
-}
-async function uploadDeepsightVideo(encryptedVideo, token) {
-	try {
-		return (await api.post(endpoints.deepsightVideoImport, {
-			video: encryptedVideo,
-			type: "selfie"
-		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
-	} catch {
-		return "";
-	}
-}
-//#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);
-	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 createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-Du98qevC.esm.js");
-	return new OpenViduRecordingProvider();
-}
-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 ?? await createOpenViduRecordingProvider();
-	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--wMKWECS.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.
-* 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) {
-		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 { StreamCanvasProcessingSession as _, encryptSelfieImage as a, sendLabelInspectionEvent as c, stopRecording as d, stopStream as f, uploadDeepsightVideo as g, stopRecording$1 as h, prepareOnDeviceFaceUpload as i, startDetection as l, startRecording as m, isOnDeviceMode as n, initializeCamera as o, createRecordingSession as p, postOnDeviceFaceResults as r, initializeDeepsightSession as s, defaultPrepareFaceUpload as t, startRecordingSession as u, FaceDetectionProvider as v };