@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/selfie.esm.js

@@ -1,995 +1,146 @@
-import { n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-I6vX6DBy.esm.js";
-import { c as FaceDetectionProvider, d as StreamCanvasProcessingSession, f as StreamCanvasCapture, g as createManager, h as stopCameraStream, m as requestCameraAccess, n as api, s as WasmUtilProvider, t as endpoints, u as OpenViduRecordingProvider } from "./endpoints-BSTFaHYo.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
-import { t as addEvent } from "./addEvent-W0ORK0jT.esm.js";
+import "./BaseWasmProvider-C_DLEI40.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./browserSimulation-gxD8cSpM.esm.js";
+import { a as fromPromise, r as assign, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as createFaceCaptureManagerFromActor } from "./faceCaptureManagerFactory-Dh2PdGlF.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { t as faceCaptureMachine } from "./faceCaptureSetup-B3faSpYA.esm.js";
+import "./ITimerCapability-C67ZRskg.esm.js";
+import "./camera-PA2Ljri3.esm.js";
+import "./deepsightService-O74l4Y__.esm.js";
+import { f as processFace } from "./recordingService-Ig2UgbLv.esm.js";
+import "./platform-CfrjKhmi.esm.js";
+import "./backCameraStream-DMdMeGk2.esm.js";
+import "./getBrowser-BSXUTWXw.esm.js";
+import "./stats-CIfiPzb1.esm.js";
+import "./getDeviceClass-BSntT9_j.esm.js";
+import "./MotionSensorProvider-4v7xkqAp.esm.js";
+import "./permissionServices-D_i6nzEw.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-D76whWEf.esm.js";
+import { t as createSelfieManager } from "./selfieManager-Duisl7qN.esm.js";
+import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-rc6kBHo5.esm.js";
 
-//#region src/modules/selfie/types.ts
-const FACE_ERROR_CODES = {
-	FACE_OCCLUDED: "FACE_OCCLUDED",
-	LIVENESS: "LIVENESS_ERROR",
-	BRIGHTNESS: "BRIGHTNESS_ERROR",
-	LENSES: "LENSES_ERROR",
-	MASK: "MASK_ERROR",
-	CLOSED_EYES: "CLOSED_EYES_ERROR",
-	HEAD_COVER: "HEAD_COVER_ERROR",
-	SERVER: "SERVER_ERROR",
-	FACE_NOT_FOUND: "FACE_NOT_FOUND",
-	MULTIPLE_FACES: "MULTIPLE_FACES",
-	TOO_BLURRY: "TOO_BLURRY_ERROR",
-	TOO_DARK: "TOO_DARK_ERROR",
-	USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED",
-	SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED",
-	FACE_TOO_DARK: "FACE_TOO_DARK",
-	LENSES_DETECTED: "LENSES_DETECTED",
-	FACE_MASK_DETECTED: "FACE_MASK_DETECTED",
-	CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED",
-	HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED",
-	FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED",
-	FACE_TOO_SMALL: "FACE_TOO_SMALL",
-	FACE_TOO_BLURRY: "FACE_TOO_BLURRY",
-	BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY",
-	PROCESSING_ERROR: "PROCESSING_ERROR",
-	BAD_REQUEST: "BAD_REQUEST",
-	NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER",
-	HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED",
-	SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY"
-};
-
-//#endregion
-//#region src/modules/selfie/selfieErrorUtils.ts
-const FACE_ERROR_CODE_VALUES = Object.values(FACE_ERROR_CODES);
-const isFaceErrorCode = (value) => {
-	return FACE_ERROR_CODE_VALUES.includes(value);
-};
-const getFaceErrorCodeFromUnknown = (value) => {
-	if (value instanceof Error && typeof value.message === "string") return isFaceErrorCode(value.message) ? value.message : void 0;
-	if (typeof value === "string") return isFaceErrorCode(value) ? value : void 0;
-};
-const validateUploadResponse = ({ config, response }) => {
-	if (!response) return FACE_ERROR_CODES.SERVER;
-	if (response.confidence !== 0) return FACE_ERROR_CODES.LIVENESS;
-	if (config.validateBrightness && !response.isBright) return FACE_ERROR_CODES.BRIGHTNESS;
-	if (config.validateLenses && response.hasLenses) return FACE_ERROR_CODES.LENSES;
-	if (config.validateFaceMask && response.hasFaceMask) return FACE_ERROR_CODES.MASK;
-	if (config.validateClosedEyes && response.hasClosedEyes) return FACE_ERROR_CODES.CLOSED_EYES;
-	if (config.validateHeadCover && response.hasHeadCover) return FACE_ERROR_CODES.HEAD_COVER;
-};
-
-//#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;
-}
-
-//#endregion
-//#region src/internal/recordings/streamingEvents.ts
-const streamingEvents = {
-	strSessionDidConnect: "strSessionDidConnect",
-	strSessionDidDisconnect: "strSessionDidDisconnect",
-	strSessionDidFailWithError: "strSessionDidFailWithError",
-	strStreamVideoCaptureStart: "strStreamVideoCaptureStart",
-	strStreamVideoCaptureStop: "strStreamVideoCaptureStop",
-	strStreamPublisherCreated: "strStreamPublisherCreated",
-	strStreamPublisherDestroyed: "strStreamPublisherDestroyed",
-	strStreamPublisherDidFailWithError: "strStreamPublisherDidFailWithError"
-};
-
-//#endregion
-//#region src/modules/selfie/selfieUploadService.ts
+//#region src/modules/selfie/selfieCaptureOnlyStateMachine.ts
 /**
-* Uploads a selfie image to the backend.
+* Performs local finalization of a captured face frame: stops local video
+* recording (if any), runs deepsight metadata extraction, and assembles the
+* rich payload delivered to the integrator's `onCapture` callback.
 */
-async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal }) {
+async function finalizeFaceCaptureOnly(ctx, signal) {
+	const canvas = ctx.capturedImage;
+	if (!canvas) throw new Error("selfieCaptureOnly: no captured image");
+	let videoBase64;
 	try {
-		const res = await api.post(endpoints.selfie, {
-			base64Image: encryptedBase64Image,
-			faceCoordinates: faceCoordinates ?? void 0,
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() }
-		}, {
-			signal,
-			query: { imageType: "selfie" }
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
-		return res.data;
-	} catch (error) {
-		const errorCode = getFaceErrorCodeFromHttpError(error);
-		if (errorCode) throw new Error(errorCode);
-		throw new Error(FACE_ERROR_CODES.SERVER);
+		videoBase64 = (await ctx.recordingService?.stopAndGetVideo())?.videoBase64;
+	} catch {
+		videoBase64 = void 0;
 	}
-}
-const getFaceErrorCodeFromHttpError = (error) => {
-	const err = error;
-	if (err.ok !== false || typeof err.status !== "number") return;
-	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
-	if (typeof err.data?.status !== "number") return FACE_ERROR_CODES.BAD_REQUEST;
-	return {
-		3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3006: FACE_ERROR_CODES.TOO_BLURRY,
-		3007: FACE_ERROR_CODES.TOO_DARK,
-		4010: FACE_ERROR_CODES.MULTIPLE_FACES,
-		4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-		4078: FACE_ERROR_CODES.FACE_OCCLUDED
-	}[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
-};
-
-//#endregion
-//#region src/modules/selfie/selfieServices.ts
-const CAMERA_CONSTRAINTS = {
-	video: {
-		facingMode: "user",
-		height: { ideal: 480 },
-		width: { ideal: 640 }
-	},
-	audio: false
-};
-function stopStream(stream) {
-	stopCameraStream(stream);
-}
-async function initializeCamera(config) {
-	const provider = new FaceDetectionProvider();
-	await provider.initialize({ autocaptureInterval: config.autoCaptureTimeout * 1e3 });
-	provider.setChecksEnabled({
-		lenses: config.validateLenses,
-		mask: config.validateFaceMask,
-		closedEyes: config.validateClosedEyes,
-		headWear: config.validateHeadCover,
-		occlusion: false
-	});
-	return {
-		stream: await requestCameraAccess({
-			video: CAMERA_CONSTRAINTS.video,
-			audio: false
-		}),
-		provider
-	};
-}
-/**
-* Encrypts the provided selfie image using WASM.
-*/
-async function encryptSelfieImage({ canvas }) {
-	const base64Image = canvas.getBase64Image();
-	if (!base64Image) throw new Error("Canvas image is empty or null");
-	return (await WasmUtilProvider.getInstance()).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;
-		params.onUpdate(status);
-	};
-	const stopDetectionLoop = () => {
-		session?.dispose();
-	};
-	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: () => {},
-				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
-			});
-		} 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.enableFaceRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
-	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: {
-			onSessionConnected: (sessionId) => {
-				addEvent({
-					code: streamingEvents.strSessionDidConnect,
-					payload: {
-						message: "Recording session connected",
-						sessionId
-					}
-				});
-			},
-			onSessionDisconnected: (sessionId) => {
-				addEvent({
-					code: streamingEvents.strSessionDidDisconnect,
-					payload: {
-						message: "Recording session disconnected",
-						sessionId
-					}
-				});
-			},
-			onSessionException: (event) => {
-				addEvent({
-					code: streamingEvents.strSessionDidFailWithError,
-					payload: {
-						message: "Recording session failed due to an error",
-						eventName: event.name,
-						type: "OpenViduException",
-						errorMessage: event.message,
-						sessionId: event.sessionId
-					}
-				});
-			},
-			onPublisherCreated: (p) => {
-				addEvent({
-					code: streamingEvents.strStreamPublisherCreated,
-					payload: {
-						message: "Recording publisher created",
-						sessionId: p.sessionId,
-						streamId: p.streamId
-					}
-				});
-			},
-			onPublisherError: (p) => {
-				addEvent({
-					code: streamingEvents.strStreamPublisherDidFailWithError,
-					payload: {
-						message: "Recording publisher failed due to an error",
-						sessionId: p.sessionId,
-						streamId: p.streamId,
-						error: { message: p.message ?? "Unknown error" }
-					}
-				});
-			}
-		}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: "selfie",
-		resolution,
-		hasAudio
-	});
-	addEvent({
-		code: streamingEvents.strStreamVideoCaptureStart,
-		payload: {
-			message: "Recording capture started",
-			resolution,
-			videoRecordingId: session.videoRecordingId,
-			sessionId: session.sessionId,
-			streamId: connection.publisher.getStreamId()
+	if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+	let metadata = "";
+	try {
+		if (ctx.deepsightService) {
+			const imageData = canvas.getImageData();
+			if (imageData) await ctx.deepsightService.analyzeFrame(imageData);
+			if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+			metadata = ctx.deepsightService.getMetadata();
 		}
-	});
+	} catch (error) {
+		if (error?.name === "AbortError") throw error;
+		metadata = "";
+	}
+	const imageBase64 = canvas.getBase64Image() ?? "";
+	const blobData = canvas.getBlobData();
+	if (!blobData) throw new Error("selfieCaptureOnly: failed to build image blob");
 	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
+		imageBase64,
+		blob: blobData.blob,
+		url: blobData.url,
+		metadata,
+		videoBase64
 	};
 }
-function stopRecording(session) {
-	(async () => {
-		try {
-			addEvent({
-				code: streamingEvents.strStreamVideoCaptureStop,
-				payload: {
-					message: "Recording capture stopped",
-					videoRecordingId: session.videoRecordingId,
-					sessionId: session.sessionId,
-					streamId: session.connection.publisher.getStreamId()
-				}
-			});
-			await stopRecording$1(session.videoRecordingId);
-			addEvent({
-				code: streamingEvents.strStreamPublisherDestroyed,
-				payload: {
-					message: "Recording publisher destroyed",
-					sessionId: session.sessionId,
-					streamId: session.connection.publisher.getStreamId()
-				}
-			});
-		} finally {
-			await session.connection.disconnect();
-			addEvent({
-				code: streamingEvents.strSessionDidDisconnect,
-				payload: {
-					message: "Recording session disconnected",
-					sessionId: session.sessionId
-				}
-			});
-		}
-	})();
-}
-
-//#endregion
-//#region src/modules/selfie/selfieStateMachine.ts
-const _selfieMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
+const _selfieCaptureOnlyMachine = faceCaptureMachine.provide({
 	actors: {
-		checkPermission: fromPromise(async () => {
-			return checkPermission();
-		}),
-		requestPermission: fromPromise(async () => {
-			return requestPermission();
-		}),
-		initializeCamera: fromPromise(async ({ input }) => {
-			return initializeCamera(input);
-		}),
-		runDetection: fromCallback(({ input, sendBack }) => {
-			if (!input.frameCapturer || !input.provider) {
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status: "error"
-				});
-				return () => {};
-			}
-			const { cleanup, reset } = startDetection({
-				config: input.config,
-				capturer: input.frameCapturer,
-				onUpdate: (status) => sendBack({
-					type: "DETECTION_UPDATE",
-					status
-				}),
-				onFrame: (frame) => sendBack({
-					type: "DETECTION_FRAME",
-					frame
-				}),
-				onSuccess: (canvas, faceCoordinates) => sendBack({
-					type: "DETECTION_SUCCESS",
-					canvas,
-					faceCoordinates
-				}),
-				provider: input.provider
-			});
-			sendBack({
-				type: "DETECTION_RESET_READY",
-				reset
-			});
-			return cleanup;
-		}),
-		uploadSelfie: fromPromise(async ({ input, signal }) => {
-			return uploadSelfie({
-				encryptedBase64Image: await encryptSelfieImage({ canvas: input.canvas }),
-				faceCoordinates: input.faceCoordinates,
-				signal
-			});
-		}),
-		startRecording: fromPromise(async ({ input }) => {
-			if (!input.clonedStream) return;
-			return startRecordingSession({
-				config: input.config,
-				clonedStream: input.clonedStream,
-				existing: input.existing
-			});
-		})
-	},
-	actions: {
-		stopMediaStream: assign(({ context }) => {
-			context.frameCapturer?.dispose();
-			if (context.stream) stopStream(context.stream);
-			context.provider?.dispose();
-			return {
-				stream: void 0,
-				provider: void 0,
-				frameCapturer: void 0
-			};
-		}),
-		setStreamAndCapturer: assign({
-			stream: ({ event }) => {
-				if ("output" in event) return event.output.stream;
-			},
-			provider: ({ event }) => {
-				if ("output" in event) return event.output.provider;
-			},
-			frameCapturer: ({ event }) => {
-				if ("output" in event) return new StreamCanvasCapture(event.output.stream);
-			}
-		}),
-		trackTutorialSelfie: () => {
-			addEvent({
-				code: "tutorialSelfie",
-				payload: { tutorialSelfie: true }
-			});
-		},
-		trackContinue: () => {
-			addEvent({ code: "continue" });
-		},
-		resetContext: assign(({ context }) => ({
-			stream: void 0,
-			provider: void 0,
-			frameCapturer: void 0,
-			error: void 0,
-			detectionStatus: "idle",
-			debugFrame: void 0,
-			capturedImage: void 0,
-			faceCoordinates: void 0,
-			uploadResponse: void 0,
-			recordingSession: void 0,
-			recordingStream: void 0,
-			attemptsRemaining: context.config.captureAttempts,
-			uploadError: void 0,
-			permissionResult: void 0,
-			resetDetection: void 0
+		prepareFaceUpload: fromPromise(async () => ({
+			encryptedBase64Image: "",
+			recordingId: null
 		})),
-		resetDetection: ({ context }) => {
-			context.resetDetection?.();
-		},
-		captureImage: assign({ capturedImage: ({ context }) => {
-			if (context.capturedImage) return context.capturedImage;
-			return context.frameCapturer?.getLatestCanvas() ?? void 0;
-		} }),
-		captureLatestFrame: assign({ capturedImage: ({ context }) => {
-			return context.frameCapturer?.getLatestCanvas() ?? void 0;
-		} }),
-		clearUploadFailure: assign({
-			uploadError: () => void 0,
-			detectionStatus: () => "idle",
-			capturedImage: () => void 0
-		}),
-		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
-		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => validateUploadResponse({
-			config: context.config,
-			response: context.uploadResponse
-		}) ?? FACE_ERROR_CODES.SERVER }),
-		stopMediaRecording: ({ context }) => {
-			if (context.recordingSession) stopRecording(context.recordingSession);
-		},
-		clearRecordingSession: assign({
-			recordingSession: () => void 0,
-			recordingStream: () => void 0
+		uploadFace: fromPromise(async ({ input, signal }) => {
+			return await finalizeFaceCaptureOnly(input, signal);
 		}),
-		createRecordingStream: assign({ recordingStream: ({ context }) => {
-			if (!context.config.enableFaceRecording) return;
-			if (context.recordingStream) return context.recordingStream;
-			return context.stream?.clone();
-		} }),
-		stopRecordingStream: ({ context }) => {
-			if (context.recordingStream) stopStream(context.recordingStream);
-		}
+		processFace: fromPromise(async () => ({}))
 	},
+	actions: { setUploadResponseFromEvent: assign({ captureOnlyResult: ({ event }) => event.output }) },
 	guards: {
-		hasShowTutorial: ({ context }) => context.config.showTutorial,
-		isPermissionGranted: ({ event }) => {
-			if ("output" in event) return event.output === "granted";
-			return false;
-		},
-		isPermissionDeniedError: ({ event }) => {
-			if ("error" in event) {
-				const error = event.error;
-				return error?.name === "NotAllowedError" || error?.name === "PermissionDeniedError";
-			}
-			return false;
-		},
-		hasStream: ({ context }) => context.stream !== void 0,
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
-		hasUploadValidationError: ({ context }) => validateUploadResponse({
-			config: context.config,
-			response: context.uploadResponse
-		}) !== void 0
-	}
-}).createMachine({
-	id: "selfie",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		stream: void 0,
-		provider: void 0,
-		frameCapturer: void 0,
-		error: void 0,
-		detectionStatus: "idle",
-		debugFrame: void 0,
-		capturedImage: void 0,
-		faceCoordinates: void 0,
-		uploadResponse: void 0,
-		recordingSession: void 0,
-		recordingStream: void 0,
-		attemptsRemaining: input.config.captureAttempts,
-		uploadError: void 0,
-		permissionResult: void 0,
-		resetDetection: void 0
-	}),
-	on: { QUIT: { target: "#selfie.closed" } },
-	states: {
-		idle: { on: { LOAD: [{
-			target: "tutorial",
-			guard: "hasShowTutorial"
-		}, { target: "loading" }] } },
-		loading: { invoke: {
-			id: "checkPermissionLoading",
-			src: "checkPermission",
-			onDone: [{
-				target: "capture",
-				guard: "isPermissionGranted",
-				actions: assign({ permissionResult: ({ event }) => event.output })
-			}, {
-				target: "permissions",
-				actions: assign({ permissionResult: ({ event }) => event.output })
-			}]
-		} },
-		tutorial: {
-			initial: "checkingPermission",
-			entry: "trackTutorialSelfie",
-			states: {
-				checkingPermission: { invoke: {
-					id: "checkPermissionTutorial",
-					src: "checkPermission",
-					onDone: [{
-						target: "initializingCamera",
-						guard: "isPermissionGranted",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}, {
-						target: "ready",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}]
-				} },
-				initializingCamera: {
-					initial: "booting",
-					invoke: {
-						id: "tutorialInitCamera",
-						src: "initializeCamera",
-						input: ({ context }) => context.config,
-						onDone: { actions: "setStreamAndCapturer" },
-						onError: [{
-							target: "ready",
-							guard: "isPermissionDeniedError",
-							actions: assign({ permissionResult: () => "denied" })
-						}, {
-							target: "ready",
-							actions: assign({ error: ({ event }) => String(event.error) })
-						}]
-					},
-					states: {
-						booting: {
-							always: [{
-								target: "#tutorialCameraReady",
-								guard: "hasStream"
-							}],
-							on: { NEXT_STEP: {
-								target: "waitingForStream",
-								actions: "trackContinue"
-							} }
-						},
-						waitingForStream: { always: [{
-							target: "#selfie.capture",
-							guard: "hasStream"
-						}] }
-					}
-				},
-				cameraReady: {
-					id: "tutorialCameraReady",
-					on: { NEXT_STEP: {
-						target: "#selfie.capture",
-						actions: "trackContinue"
-					} }
-				},
-				ready: { on: { NEXT_STEP: {
-					target: "waitingForPermission",
-					actions: "trackContinue"
-				} } },
-				waitingForPermission: { invoke: {
-					id: "checkPermissionWaiting",
-					src: "checkPermission",
-					onDone: [{
-						target: "#selfie.capture",
-						guard: "isPermissionGranted",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}, {
-						target: "#selfie.permissions",
-						actions: assign({ permissionResult: ({ event }) => event.output })
-					}]
-				} }
-			}
-		},
-		permissions: {
-			initial: "idle",
-			states: {
-				idle: {
-					invoke: {
-						id: "checkPermissionIdle",
-						src: "checkPermission",
-						onDone: [{
-							target: "#selfie.capture",
-							guard: "isPermissionGranted",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}, {
-							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}]
-					},
-					on: {
-						REQUEST_PERMISSION: "requesting",
-						GO_TO_LEARN_MORE: "learnMore"
-					}
-				},
-				learnMore: { on: {
-					BACK: "idle",
-					REQUEST_PERMISSION: "requesting"
-				} },
-				requesting: { invoke: {
-					id: "requestPermission",
-					src: "requestPermission",
-					onDone: [
-						{
-							target: "#selfie.capture",
-							guard: "isPermissionGranted",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						},
-						{
-							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						},
-						{
-							target: "idle",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						}
-					],
-					onError: { target: "denied" }
-				} },
-				denied: { entry: assign({ permissionResult: () => "refresh" }) }
-			}
-		},
-		capture: {
-			initial: "checkingStream",
-			exit: [
-				"stopMediaRecording",
-				"stopRecordingStream",
-				"clearRecordingSession",
-				"stopMediaStream"
-			],
-			states: {
-				checkingStream: { always: [{
-					target: "detecting",
-					guard: "hasStream"
-				}, { target: "initializing" }] },
-				initializing: { invoke: {
-					id: "initializeCamera",
-					src: "initializeCamera",
-					input: ({ context }) => context.config,
-					onDone: {
-						target: "detecting",
-						actions: "setStreamAndCapturer"
-					},
-					onError: [{
-						target: "#selfie.permissions",
-						guard: "isPermissionDeniedError",
-						actions: assign({ permissionResult: () => "denied" })
-					}, {
-						target: "#selfie.error",
-						actions: assign({ error: ({ event }) => String(event.error) })
-					}]
-				} },
-				detecting: {
-					entry: [assign({ detectionStatus: () => "detecting" }), "createRecordingStream"],
-					invoke: [{
-						id: "startRecording",
-						src: "startRecording",
-						input: ({ context }) => ({
-							config: context.config,
-							clonedStream: context.recordingStream,
-							existing: context.recordingSession
-						}),
-						onDone: { actions: assign({ recordingSession: ({ context, event }) => {
-							return event.output ?? context.recordingSession;
-						} }) },
-						onError: { actions: () => void 0 }
-					}, {
-						id: "runDetection",
-						src: "runDetection",
-						input: ({ context }) => ({
-							frameCapturer: context.frameCapturer,
-							provider: context.provider,
-							config: context.config
-						})
-					}],
-					on: {
-						DETECTION_UPDATE: { actions: assign({ detectionStatus: ({ event }) => event.status }) },
-						DETECTION_FRAME: { actions: assign({ debugFrame: ({ event }) => event.frame }) },
-						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
-						DETECTION_SUCCESS: {
-							target: "capturing",
-							actions: assign({
-								capturedImage: ({ event }) => event.canvas,
-								faceCoordinates: ({ event }) => event.faceCoordinates
-							})
-						},
-						MANUAL_CAPTURE: { target: "capturingManual" }
-					}
-				},
-				capturing: {
-					entry: ["captureImage"],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: FACE_ERROR_CODES.SERVER,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
-				},
-				capturingManual: {
-					entry: ["captureLatestFrame"],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: FACE_ERROR_CODES.SERVER,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
-				},
-				uploading: { invoke: {
-					id: "uploadSelfie",
-					src: "uploadSelfie",
-					input: ({ context }) => {
-						const canvas = context.capturedImage;
-						if (!canvas) throw new Error(FACE_ERROR_CODES.SERVER);
-						return {
-							canvas,
-							faceCoordinates: context.faceCoordinates
-						};
-					},
-					onDone: {
-						target: "validatingUpload",
-						actions: assign({ uploadResponse: ({ event }) => event.output })
-					},
-					onError: {
-						target: "uploadError",
-						actions: assign(({ context, event }) => ({
-							uploadError: getFaceErrorCodeFromUnknown(event.error) ?? FACE_ERROR_CODES.SERVER,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}
-				} },
-				validatingUpload: { always: [{
-					target: "uploadError",
-					guard: "hasUploadValidationError",
-					actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
-				}, { target: "success" }] },
-				uploadError: { on: { RETRY_CAPTURE: {
-					target: "detecting",
-					guard: "hasAttemptsRemaining",
-					actions: ["resetDetection", "clearUploadFailure"]
-				} } },
-				success: {
-					entry: "stopMediaRecording",
-					after: { 3e3: { target: "#selfie.finished" } }
-				}
-			}
-		},
-		finished: {
-			entry: "stopMediaStream",
-			on: { RESET: {
-				target: "idle",
-				actions: "resetContext"
-			} }
-		},
-		closed: {
-			entry: "stopMediaStream",
-			type: "final"
-		},
-		error: {
-			entry: "stopMediaStream",
-			on: { RESET: {
-				target: "idle",
-				actions: "resetContext"
-			} }
-		}
+		hasUploadValidationError: () => false,
+		isTerminalUploadError: () => false
 	}
 });
 /**
-* The selfie capture state machine.
-*
-* Note: Uses AnyStateMachine type for declaration file portability.
-* Type safety is ensured via the machine configuration.
+* Selfie state machine variant for the captureOnly flow. Shares the full base
+* face-capture state tree; only the upload/process step is local instead of
+* remote.
 */
-const selfieMachine = _selfieMachine;
+const selfieCaptureOnlyMachine = _selfieCaptureOnlyMachine;
 
 //#endregion
-//#region src/modules/selfie/selfieActor.ts
-function createSelfieActor(options) {
-	return createActor(selfieMachine, { input: { config: options.config } }).start();
+//#region src/modules/selfie/selfieCaptureOnlyActor.ts
+function createSelfieCaptureOnlyActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieCaptureOnlyMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
 }
 
 //#endregion
-//#region src/modules/selfie/selfieManager.ts
-function getPermissionStatus(snapshot) {
-	if (!snapshot.matches("permissions")) return;
-	if (snapshot.matches({ permissions: "idle" })) return "idle";
-	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
-	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
-	if (snapshot.matches({ permissions: "denied" })) return "denied";
-}
-function getCaptureStatus(snapshot) {
-	if (snapshot.matches({ capture: "initializing" })) return "initializing";
-	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: "uploading" })) return "uploading";
-	if (snapshot.matches({ capture: "uploadError" })) return "uploadError";
-	if (snapshot.matches({ capture: "success" })) return "success";
-}
-function mapState(snapshot) {
-	const { context } = snapshot;
-	if (snapshot.matches("idle")) return { status: "idle" };
-	if (snapshot.matches("loading")) return { status: "loading" };
-	if (snapshot.matches("tutorial")) return { status: "tutorial" };
-	if (snapshot.matches("closed")) return { status: "closed" };
-	if (snapshot.matches("permissions")) {
-		const permissionStatus = getPermissionStatus(snapshot);
-		if (permissionStatus === void 0) return {
-			status: "permissions",
-			permissionStatus: "idle"
-		};
-		return {
-			status: "permissions",
-			permissionStatus
-		};
-	}
-	if (snapshot.matches("capture")) return {
-		status: "capture",
-		captureStatus: getCaptureStatus(snapshot) ?? "initializing",
-		stream: context.stream,
-		detectionStatus: context.detectionStatus,
-		debugFrame: context.debugFrame,
-		attemptsRemaining: context.attemptsRemaining,
-		uploadError: context.uploadError
-	};
-	if (snapshot.matches("finished")) return { status: "finished" };
-	if (snapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Unknown error"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor }) {
+//#region src/modules/selfie/selfieCaptureOnlyManager.ts
+/**
+* Wraps a selfie captureOnly actor with a manager that fires `onCapture`
+* exactly once when the actor reaches the `finished` final state. XState's
+* `complete` lifecycle fires for both `finished` and `closed` (both are
+* `type: 'final'` per the SDK terminal-state convention) — gating on
+* `finished` prevents a user-quit mid-capture from delivering a partial
+* payload.
+*/
+function attachOnCaptureFiring(actor, config) {
+	const subscription = actor.subscribe({ complete: () => {
+		const snapshot = actor.getSnapshot();
+		if (!snapshot.matches("finished")) return;
+		const payload = snapshot.context.captureOnlyResult;
+		if (!payload) return;
+		const response = { image: payload };
+		invokeOnCaptureCallback(config.onCapture, response, eventModuleNames.selfie);
+	} });
+	return () => subscription.unsubscribe();
+}
+function createSelfieCaptureOnlyManagerFromActor(actor, config) {
+	const unsubscribe = attachOnCaptureFiring(actor, config);
+	const manager = createFaceCaptureManagerFromActor(actor, eventModuleNames.selfie);
 	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		nextStep() {
-			actor.send({ type: "NEXT_STEP" });
-		},
-		requestPermission() {
-			actor.send({ type: "REQUEST_PERMISSION" });
-		},
-		goToLearnMore() {
-			actor.send({ type: "GO_TO_LEARN_MORE" });
-		},
-		back() {
-			actor.send({ type: "BACK" });
-		},
-		close() {
-			actor.send({ type: "QUIT" });
-		},
-		reset() {
-			actor.send({ type: "RESET" });
-		},
-		retryCapture() {
-			actor.send({ type: "RETRY_CAPTURE" });
-		},
-		capture() {
-			actor.send({ type: "MANUAL_CAPTURE" });
+		...manager,
+		stop: () => {
+			unsubscribe();
+			manager.stop();
 		}
 	};
 }
 /**
-* Creates a selfie manager instance for handling selfie capture flow.
-*
-* The selfie manager provides:
-* - State management with statuses: `idle`, `loading`, `tutorial`, `permissions`, `capture`, `finished`, `closed`, `error`
-* - Permission handling with nested states: `idle`, `requesting`, `denied`, `learnMore`
-* - Capture handling with nested states: `initializing`, `startingRecorder`, `recordingActive`, `detecting`, `capturing`, `uploading`, `uploadError`, `success`
-* - Camera stream access when in `capture` state
-* - Detection status feedback during face detection
-* - Attempt tracking with `attemptsRemaining`
-*
-* @param options - Configuration for the selfie actor
-* @param options.config - The selfie module configuration from the flow
-* @returns A manager instance with state subscription, API methods, and lifecycle controls
-*
-* @example
-* ```ts
-* const selfieManager = createSelfieManager({ config: selfieConfig });
-*
-* selfieManager.subscribe((state) => {
-*   if (state.status === 'capture') {
-*     console.log('Camera ready:', state.stream);
-*     console.log('Detection status:', state.detectionStatus);
-*   }
-* });
+* Creates a captureOnly selfie manager.
 *
-* selfieManager.load();
-* ```
+* Unlike {@link createSelfieManager}, the captured face image is delivered
+* locally to the integrator's `onCapture` callback instead of being uploaded
+* to the Incode backend. `onCapture` is required.
 */
-function createSelfieManager(options) {
-	return createManager({
-		actor: createSelfieActor(options),
-		mapState,
-		createApi
-	});
+function createSelfieCaptureOnlyManager(options) {
+	return createSelfieCaptureOnlyManagerFromActor(createSelfieCaptureOnlyActor(options), options.config);
 }
 
 //#endregion
-export { createSelfieManager, selfieMachine };
+export { createSelfieCaptureOnlyManager, createSelfieCaptureOnlyManagerFromActor, createSelfieManager, processFace, selfieCaptureOnlyMachine, selfieMachine };