@incodetech/core 0.0.0-dev-20260126-4504c5b

package/dist/selfie.esm.js

@@ -0,0 +1,1221 @@
+import { d as addEvent, n as eventModuleNames } from "./events-B8ZkhAZo.esm.js";
+import { C as createManager, S as stopCameraStream, a as FaceDetectionProvider, c as OpenViduRecordingProvider, f as BrowserStorageProvider, h as StreamCanvasCapture, m as StreamCanvasProcessingSession, r as WasmUtilProvider, u as LocalRecordingProvider, x as requestCameraAccess } from "./src-DYtpbFY5.esm.js";
+import "./getDeviceClass-DkfbtsIJ.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { a as uploadDeepsightVideo, c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-CfEJv3xH.esm.js";
+import { r as getToken, t as api } from "./api-DfRLAneb.esm.js";
+import "./deepsightService-j5zMt6wf.esm.js";
+import { t as addDeviceStats } from "./stats-DnU4uUFv.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/modules/selfie/selfieUploadService.ts
+/**
+* Uploads a selfie image to the backend.
+*/
+async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
+	try {
+		const payload = {
+			base64Image: encryptedBase64Image,
+			faceCoordinates: faceCoordinates ?? void 0,
+			encrypted: true,
+			clientInfo: { deviceClass: getDeviceClass() },
+			metadata: metadata ?? void 0
+		};
+		const query = { imageType: "selfie" };
+		if (recordingId) query.recordingId = recordingId;
+		const res = await api.post(endpoints.selfie, payload, {
+			signal,
+			query
+		});
+		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);
+	}
+}
+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;
+};
+async function processFace(imageType = "selfie", signal) {
+	return (await api.post(endpoints.processFace, {}, {
+		query: { imageType },
+		signal
+	})).data;
+}
+
+//#endregion
+//#region src/modules/selfie/selfieServices.ts
+function sendLabelInspectionEvent() {
+	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
+}
+const CAMERA_CONSTRAINTS = {
+	video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	},
+	audio: false
+};
+function stopStream(stream) {
+	stopCameraStream(stream);
+}
+async function initializeCamera(params) {
+	const { config, dependencies } = params;
+	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
+	});
+	console.log("performPrcCheck init");
+	const timerName = `performPrcCheck ${Math.random()}`;
+	console.time(timerName);
+	await params.deepsightService.performPrcCheck({
+		constraints: { video: CAMERA_CONSTRAINTS.video },
+		ds: config.ds,
+		storage: dependencies.storage
+	});
+	console.timeEnd(timerName);
+	console.log("performPrcCheck end");
+	return {
+		stream: await requestCameraAccess({
+			video: CAMERA_CONSTRAINTS.video,
+			audio: false
+		}),
+		provider
+	};
+}
+/**
+* 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;
+		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.deepsightLiveness === "VIDEOLIVENESS") return;
+	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,
+					module: eventModuleNames.selfie,
+					payload: {
+						message: "Recording session connected",
+						sessionId
+					}
+				});
+			},
+			onSessionDisconnected: (sessionId) => {
+				addEvent({
+					code: streamingEvents.strSessionDidDisconnect,
+					module: eventModuleNames.selfie,
+					payload: {
+						message: "Recording session disconnected",
+						sessionId
+					}
+				});
+			},
+			onSessionException: (event) => {
+				addEvent({
+					code: streamingEvents.strSessionDidFailWithError,
+					module: eventModuleNames.selfie,
+					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,
+					module: eventModuleNames.selfie,
+					payload: {
+						message: "Recording publisher created",
+						sessionId: p.sessionId,
+						streamId: p.streamId
+					}
+				});
+			},
+			onPublisherError: (p) => {
+				addEvent({
+					code: streamingEvents.strStreamPublisherDidFailWithError,
+					module: eventModuleNames.selfie,
+					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,
+		module: eventModuleNames.selfie,
+		payload: {
+			message: "Recording capture started",
+			resolution,
+			videoRecordingId: session.videoRecordingId,
+			sessionId: session.sessionId,
+			streamId: connection.publisher.getStreamId()
+		}
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+function stopRecording(session) {
+	(async () => {
+		try {
+			addEvent({
+				code: streamingEvents.strStreamVideoCaptureStop,
+				module: eventModuleNames.selfie,
+				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,
+				module: eventModuleNames.selfie,
+				payload: {
+					message: "Recording publisher destroyed",
+					sessionId: session.sessionId,
+					streamId: session.connection.publisher.getStreamId()
+				}
+			});
+		} finally {
+			await session.connection.disconnect();
+			addEvent({
+				code: streamingEvents.strSessionDidDisconnect,
+				module: eventModuleNames.selfie,
+				payload: {
+					message: "Recording session disconnected",
+					sessionId: session.sessionId
+				}
+			});
+		}
+	})();
+}
+async function initializeDeepsightSession() {
+	const { loadDeepsightSession } = await import("./deepsightLoader-BMT0FSg6.esm.js");
+	return loadDeepsightSession();
+}
+
+//#endregion
+//#region src/modules/selfie/recordingService.ts
+/**
+* Records on-device and uploads encrypted video for liveness.
+*/
+var LocalRecordingService = class {
+	constructor(wasmUtil, sessionToken) {
+		this.recorder = new LocalRecordingProvider();
+		this.sessionToken = sessionToken;
+		this.wasmUtil = wasmUtil;
+	}
+	async start(stream) {
+		this.recorder.startRecording(stream);
+	}
+	async stop() {
+		if (!this.recorder.isRecording) return { recordingId: null };
+		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
+		if (!this.sessionToken) return { recordingId: null };
+		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+/**
+* Records through OpenVidu and manages the session lifecycle.
+*/
+var OpenViduRecordingService = class {
+	constructor(config) {
+		this.provider = new OpenViduRecordingProvider();
+		this.config = config;
+	}
+	async start(stream) {
+		this.session = await startRecordingSession({
+			config: {
+				...this.config,
+				recording: { capability: this.provider }
+			},
+			clonedStream: stream.clone(),
+			existing: this.session
+		});
+	}
+	async stop() {
+		if (this.session) {
+			stopRecording(this.session);
+			this.session = void 0;
+		}
+		return { recordingId: null };
+	}
+	cleanup() {
+		if (this.session) stopRecording(this.session);
+	}
+};
+/**
+* Creates the recording service for the current configuration.
+*/
+function createRecordingService(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
+	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
+}
+
+//#endregion
+//#region src/modules/selfie/selfieStateMachine.ts
+const _selfieMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		checkPermission: fromPromise(async () => {
+			return checkPermission();
+		}),
+		requestPermission: fromPromise(async () => {
+			return requestPermission();
+		}),
+		initializeCamera: fromPromise(async ({ input }) => {
+			return initializeCamera({
+				config: input.config,
+				dependencies: input.dependencies,
+				deepsightService: input.deepsightService
+			});
+		}),
+		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;
+		}),
+		initializeDeepsightSession: fromPromise(async () => {
+			return await initializeDeepsightSession();
+		}),
+		startRecording: fromPromise(async ({ input }) => {
+			if (!input.stream) return input.recordingService;
+			const wasmUtil = await input.dependencies.getWasmUtil();
+			const sessionToken = getToken();
+			const service = input.recordingService ?? createRecordingService({
+				config: input.config,
+				wasmUtil,
+				sessionToken
+			});
+			if (service) await service.start(input.stream);
+			return service;
+		}),
+		checkVirtualCamera: fromPromise(async ({ input }) => {
+			if (!input.deepsightService || !input.stream) return false;
+			const videoTrack = input.stream.getVideoTracks()[0];
+			if (!videoTrack) return false;
+			return input.deepsightService.checkVirtualCamera(videoTrack);
+		}),
+		uploadSelfie: fromPromise(async ({ input, signal }) => {
+			let recordingId = null;
+			const sessionToken = getToken();
+			try {
+				if (input.deepsightService) {
+					const [_, recordingServiceStopResult] = await Promise.all([
+						input.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"),
+						input.recordingService?.stop(),
+						input.deepsightService.analyzeFrame(input.canvas.getImageData())
+					]);
+					recordingId = recordingServiceStopResult?.recordingId ?? null;
+				}
+			} catch (error) {}
+			return uploadSelfie({
+				encryptedBase64Image: await encryptSelfieImage({
+					canvas: input.canvas,
+					dependencies: input.dependencies
+				}),
+				faceCoordinates: input.faceCoordinates,
+				metadata: input.deepsightService?.getMetadata(),
+				recordingId,
+				signal
+			});
+		}),
+		processFace: fromPromise(async ({ signal }) => {
+			return processFace("selfie", signal);
+		})
+	},
+	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",
+				module: eventModuleNames.selfie,
+				payload: { tutorialSelfie: true }
+			});
+		},
+		trackContinue: () => {
+			addEvent({
+				code: "continue",
+				module: eventModuleNames.selfie
+			});
+		},
+		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,
+			processResponse: void 0,
+			recordingService: void 0,
+			attemptsRemaining: context.config.captureAttempts,
+			uploadError: void 0,
+			permissionResult: void 0,
+			resetDetection: void 0,
+			deepsightService: void 0
+		})),
+		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
+		}),
+		clearStreamForRetry: assign({
+			stream: () => void 0,
+			provider: () => void 0,
+			frameCapturer: () => void 0
+		}),
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => validateUploadResponse({
+			config: context.config,
+			response: context.uploadResponse
+		}) ?? FACE_ERROR_CODES.SERVER }),
+		clearRecordingService: assign({ recordingService: () => void 0 }),
+		cleanup: ({ context }) => {
+			context.deepsightService?.cleanup();
+			context.recordingService?.cleanup();
+		}
+	},
+	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,
+		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightService !== 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,
+		dependencies: input.dependencies,
+		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,
+		processResponse: void 0,
+		recordingService: void 0,
+		attemptsRemaining: input.config.captureAttempts,
+		uploadError: void 0,
+		permissionResult: void 0,
+		resetDetection: void 0,
+		deepsightService: 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 })
+			}]
+		}, {
+			id: "loadingInitDeepsight",
+			src: "initializeDeepsightSession",
+			onDone: { actions: assign({ deepsightService: ({ event }) => event.output }) },
+			onError: { actions: () => void 0 }
+		}] },
+		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: {
+					type: "parallel",
+					states: {
+						cameraInit: {
+							initial: "initializingDeepsight",
+							states: {
+								initializingDeepsight: { invoke: {
+									id: "tutorialInitDeepsight",
+									src: "initializeDeepsightSession",
+									onDone: {
+										target: "initializingStream",
+										actions: assign({ deepsightService: ({ event }) => event.output })
+									},
+									onError: { target: "#selfie.tutorial.ready" }
+								} },
+								initializingStream: { invoke: {
+									id: "tutorialInitCamera",
+									src: "initializeCamera",
+									input: ({ context }) => ({
+										config: context.config,
+										dependencies: context.dependencies,
+										deepsightService: context.deepsightService
+									}),
+									onDone: {
+										target: "ready",
+										actions: "setStreamAndCapturer"
+									},
+									onError: [{
+										target: "#selfie.tutorial.ready",
+										guard: "isPermissionDeniedError",
+										actions: assign({ permissionResult: () => "denied" })
+									}, {
+										target: "#selfie.tutorial.ready",
+										actions: assign({ error: ({ event }) => String(event.error) })
+									}]
+								} },
+								ready: { type: "final" }
+							}
+						},
+						userIntent: {
+							initial: "waiting",
+							states: {
+								waiting: { on: { NEXT_STEP: {
+									target: "clicked",
+									actions: "trackContinue"
+								} } },
+								clicked: { type: "final" }
+							}
+						}
+					},
+					onDone: { target: "#selfie.capture" }
+				},
+				ready: {
+					initial: "idle",
+					states: {
+						idle: { always: [{
+							target: "initializingDeepsight",
+							guard: ({ context }) => context.deepsightService === void 0
+						}, { target: "readyForNext" }] },
+						initializingDeepsight: { invoke: {
+							id: "initializeDeepsightTutorial",
+							src: "initializeDeepsightSession",
+							onDone: {
+								target: "readyForNext",
+								actions: assign({ deepsightService: ({ event }) => event.output })
+							},
+							onError: { target: "readyForNext" }
+						} },
+						readyForNext: { on: { NEXT_STEP: {
+							target: "#selfie.tutorial.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: "checkingDeepsight",
+			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => context.deepsightService === void 0
+				}, { target: "idle" }] },
+				initializingDeepsight: { invoke: {
+					id: "initializeDeepsightPerms",
+					src: "initializeDeepsightSession",
+					onDone: {
+						target: "idle",
+						actions: assign({ deepsightService: ({ event }) => event.output })
+					},
+					onError: { target: "idle" }
+				} },
+				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: "checkingDeepsight",
+			exit: [
+				"stopMediaStream",
+				"cleanup",
+				"clearRecordingService"
+			],
+			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => context.deepsightService === void 0
+				}, { target: "checkingStream" }] },
+				initializingDeepsight: { invoke: {
+					id: "initializeDeepsightCapture",
+					src: "initializeDeepsightSession",
+					onDone: {
+						target: "checkingStream",
+						actions: [assign({ deepsightService: ({ event }) => event.output })]
+					},
+					onError: { target: "#selfie.permissions" }
+				} },
+				checkingStream: { always: [
+					{
+						target: "initializingDeepsight",
+						guard: ({ context }) => context.deepsightService === void 0
+					},
+					{
+						target: "detecting",
+						guard: "hasStream"
+					},
+					{ target: "initializing" }
+				] },
+				initializing: { invoke: {
+					id: "initializeCamera",
+					src: "initializeCamera",
+					input: ({ context }) => ({
+						config: context.config,
+						dependencies: context.dependencies,
+						deepsightService: context.deepsightService
+					}),
+					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" })],
+					invoke: [
+						{
+							id: "checkVirtualCamera",
+							src: "checkVirtualCamera",
+							input: ({ context }) => ({
+								stream: context.stream,
+								deepsightService: context.deepsightService
+							}),
+							onDone: [{
+								target: "#selfie.processing",
+								guard: ({ event }) => event.output === true,
+								actions: () => {
+									sendLabelInspectionEvent();
+								}
+							}],
+							onError: { actions: () => void 0 }
+						},
+						{
+							id: "startRecording",
+							src: "startRecording",
+							input: ({ context }) => ({
+								config: context.config,
+								dependencies: context.dependencies,
+								recordingService: context.recordingService,
+								stream: context.stream
+							}),
+							onDone: { actions: assign({ recordingService: ({ context, event }) => {
+								return event.output ?? context.recordingService;
+							} }) },
+							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,
+							deepsightService: context.deepsightService,
+							dependencies: context.dependencies,
+							recordingService: context.recordingService
+						};
+					},
+					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: "checkingStream",
+					guard: "hasAttemptsRemaining",
+					actions: [
+						"resetDetection",
+						"clearUploadFailure",
+						"clearStreamForRetry"
+					]
+				} } },
+				success: {
+					entry: "cleanup",
+					after: { 3e3: { target: "#selfie.processing" } }
+				}
+			}
+		},
+		processing: { invoke: {
+			id: "processFace",
+			src: "processFace",
+			onDone: {
+				target: "finished",
+				actions: assign({ processResponse: ({ event }) => event.output })
+			},
+			onError: { target: "finished" }
+		} },
+		finished: {
+			entry: "stopMediaStream",
+			type: "final"
+		},
+		closed: {
+			entry: "stopMediaStream",
+			type: "final"
+		},
+		error: {
+			entry: "stopMediaStream",
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		}
+	}
+});
+/**
+* The selfie capture state machine.
+*
+* Note: Uses AnyStateMachine type for declaration file portability.
+* Type safety is ensured via the machine configuration.
+*/
+const selfieMachine = _selfieMachine;
+
+//#endregion
+//#region src/modules/selfie/selfieActor.ts
+function createSelfieActor(options) {
+	const dependencies = options.dependencies ?? {
+		storage: new BrowserStorageProvider(),
+		getWasmUtil: () => WasmUtilProvider.getInstance()
+	};
+	return createActor(selfieMachine, { 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("processing")) return { status: "processing" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		processResponse: context.processResponse
+	};
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	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" });
+		}
+	};
+}
+/**
+* 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);
+*   }
+* });
+*
+* selfieManager.load();
+* ```
+*/
+function createSelfieManager(options) {
+	return createManager({
+		actor: createSelfieActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { createSelfieManager, processFace, selfieMachine };