@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/selfie.esm.js

@@ -0,0 +1,978 @@
+import { n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-CVR0Pq38.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-D_pUMaqA.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-1Mi5CEiq.esm.js";
+
+//#region src/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/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/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/recordings/streamingEvents.ts
+const streamingEvents = {
+	strSessionDidConnect: "strSessionDidConnect",
+	strSessionDidDisconnect: "strSessionDidDisconnect",
+	strSessionDidFailWithError: "strSessionDidFailWithError",
+	strStreamVideoCaptureStart: "strStreamVideoCaptureStart",
+	strStreamVideoCaptureStop: "strStreamVideoCaptureStop",
+	strStreamPublisherCreated: "strStreamPublisherCreated",
+	strStreamPublisherDestroyed: "strStreamPublisherDestroyed",
+	strStreamPublisherDidFailWithError: "strStreamPublisherDidFailWithError"
+};
+
+//#endregion
+//#region src/selfie/selfieUploadService.ts
+/**
+* Uploads a selfie image to the backend.
+*/
+async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal }) {
+	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);
+	}
+}
+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/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 }),
+		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.stream.clone();
+	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()
+		}
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+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/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(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.stream) return;
+			return startRecordingSession({
+				config: input.config,
+				stream: input.stream,
+				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,
+			attemptsRemaining: context.config.captureAttempts,
+			uploadError: void 0,
+			permissionResult: void 0,
+			resetDetection: 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
+		}),
+		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 })
+	},
+	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,
+		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",
+				"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" })],
+					invoke: [{
+						id: "startRecording",
+						src: "startRecording",
+						input: ({ context }) => ({
+							config: context.config,
+							stream: context.stream,
+							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"
+			} }
+		}
+	}
+});
+/**
+* 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/selfie/selfieActor.ts
+function createSelfieActor(options) {
+	return createActor(selfieMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/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 }) {
+	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, selfieMachine };