@incodetech/core 0.0.0-dev-20260407-2c382da → 0.0.0-dev-20260407-ebd92aa

package/dist/faceCaptureSetup-DzlTPjT9.esm.js

@@ -0,0 +1,828 @@
+import { r as getToken } from "./api-CyI8qTie.esm.js";
+import { o as createManagerInstrumentation } from "./events-BlVGS-8F.esm.js";
+import { i as fromPromise, n as assign, o as createManager, r as fromCallback, t as setup } from "./xstate.esm-BXrcOcSC.esm.js";
+import { _ as StreamCanvasCapture, a as initializeDeepsightSession, c as stopStream, h as flagFaceManualReview, i as initializeCamera, n as preloadOpenViduProvider, o as sendLabelInspectionEvent, r as encryptSelfieImage, s as startDetection, t as createRecordingService, v as FACE_ERROR_CODES } from "./recordingService-BDx_6XR9.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-CDqkkway.esm.js";
+
+//#region src/internal/faceCapture/faceCaptureManagerFactory.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 ?? "idle",
+		debugFrame: context.debugFrame,
+		attemptsRemaining: context.attemptsRemaining ?? 0,
+		uploadError: context.uploadError,
+		assistedOnboarding: context.config?.assistedOnboarding ?? false
+	};
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("finished")) return {
+		status: "finished",
+		processResponse: context.processResponse
+	};
+	if (snapshot.matches("error")) {
+		const errorValue = context.error;
+		return {
+			status: "error",
+			error: typeof errorValue === "string" ? errorValue : errorValue ? errorValue.message : "Unknown error"
+		};
+	}
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
+	const snapshot = actor.getSnapshot();
+	snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			trackElementClicked?.("retryCapture");
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "MANUAL_CAPTURE" });
+		}
+	};
+}
+function getFaceCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.uploadError;
+	if (typeof errorCode !== "string" || errorCode.length === 0) return;
+	return { errorCode };
+}
+function createFaceCaptureManagerFromActor(actor, moduleName) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(moduleName, { getErrorPayload: getFaceCaptureErrorPayload })
+	});
+}
+
+//#endregion
+//#region src/internal/faceCapture/faceCaptureSetup.ts
+const getAttemptsFromConfig = (config) => {
+	return config.captureAttempts ?? config.numberOfAttempts ?? 3;
+};
+const _faceCaptureMachine = 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,
+				deepsightService: input.deepsightService
+			});
+		}),
+		runDetection: fromCallback(({ input, sendBack }) => {
+			if (!input.frameCapturer || !input.provider) {
+				sendBack({
+					type: "DETECTION_UPDATE",
+					status: "error"
+				});
+				return () => {};
+			}
+			if (input.manualCaptureTriggered) {
+				sendBack({
+					type: "DETECTION_UPDATE",
+					status: "manualCapture"
+				});
+				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 ({ input }) => {
+			return await initializeDeepsightSession({
+				ds: input.ds,
+				storage: input.storage
+			});
+		}),
+		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);
+		}),
+		prepareFaceUpload: fromPromise(async ({ input }) => {
+			const ctx = input;
+			const sessionToken = getToken();
+			const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
+			try {
+				if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
+			} catch (error) {}
+			const logs = ctx.deepsightService?.getPipelineState() ?? "";
+			ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
+			return {
+				encryptedBase64Image: await encryptSelfieImage({
+					canvas: ctx.capturedImage,
+					dependencies: ctx.dependencies
+				}),
+				recordingId
+			};
+		}),
+		uploadFace: fromPromise(async () => {
+			throw new Error("uploadFace must be provided by variant");
+		}),
+		processFace: fromPromise(async () => {
+			throw new Error("processFace must be provided by variant");
+		})
+	},
+	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);
+			}
+		}),
+		trackTutorial: () => void 0,
+		trackContinue: () => {},
+		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: getAttemptsFromConfig(context.config),
+			uploadError: void 0,
+			permissionResult: void 0,
+			resetDetection: void 0,
+			deepsightService: void 0,
+			manualCaptureTriggered: false
+		})),
+		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(({ context }) => {
+			context.frameCapturer?.dispose();
+			if (context.stream) stopStream(context.stream);
+			context.provider?.dispose();
+			return {
+				stream: void 0,
+				provider: void 0,
+				frameCapturer: void 0
+			};
+		}),
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
+		setUploadErrorFromUploadValidation: assign({ uploadError: () => FACE_ERROR_CODES.SERVER }),
+		setTerminalError: assign({ error: () => "Authentication failed" }),
+		clearRecordingService: assign({ recordingService: () => void 0 }),
+		cleanup: ({ context }) => {
+			context.deepsightService?.cleanup();
+			context.recordingService?.cleanup();
+		},
+		setPermissionResultFromEvent: assign({ permissionResult: ({ event }) => event.output }),
+		setPermissionDenied: assign({ permissionResult: () => "denied" }),
+		setPermissionRefresh: assign({ permissionResult: () => "refresh" }),
+		setDeepsightServiceFromEvent: assign({ deepsightService: ({ event }) => event.output }),
+		setErrorFromEvent: assign({ error: ({ event }) => String(event.error) }),
+		setDetectionStatusDetecting: assign({ detectionStatus: ({ context }) => context.manualCaptureTriggered ? "manualCapture" : "detecting" }),
+		setRecordingServiceFromEvent: assign({ recordingService: ({ context, event }) => {
+			return event.output ?? context.recordingService;
+		} }),
+		setDetectionStatusFromEvent: assign({ detectionStatus: ({ event }) => event.status }),
+		setManualCaptureTriggered: assign({ manualCaptureTriggered: ({ context, event }) => {
+			const status = event.status;
+			return context.manualCaptureTriggered || status === "manualCapture";
+		} }),
+		setDebugFrameFromEvent: assign({ debugFrame: ({ event }) => event.frame }),
+		setResetDetectionFromEvent: assign({ resetDetection: ({ event }) => event.reset }),
+		setCapturedImageFromEvent: assign({
+			capturedImage: ({ event }) => event.canvas,
+			faceCoordinates: ({ event }) => event.faceCoordinates
+		}),
+		setUploadPreparationFromEvent: assign({
+			encryptedBase64Image: ({ event }) => event.output.encryptedBase64Image,
+			uploadRecordingId: ({ event }) => event.output.recordingId
+		}),
+		setUploadResponseFromEvent: assign({ uploadResponse: ({ event }) => event.output }),
+		setProcessResponseFromEvent: assign({ processResponse: ({ event }) => event.output }),
+		setServerErrorAndDecrement: assign(({ context }) => ({
+			uploadError: FACE_ERROR_CODES.SERVER,
+			attemptsRemaining: context.attemptsRemaining - 1
+		})),
+		sendLabelInspection: () => {
+			sendLabelInspectionEvent();
+		},
+		flagFaceManualReview: () => {
+			flagFaceManualReview();
+		},
+		preloadRecordingProvider: ({ context }) => {
+			if (context.config.enableFaceRecording === true && context.config.deepsightLiveness !== "VIDEOLIVENESS") preloadOpenViduProvider();
+		},
+		noOp: () => 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,
+		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightService !== void 0,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
+		hasUploadValidationError: () => false,
+		isTerminalUploadError: () => false,
+		isNoAttemptsTerminal: () => false
+	}
+}).createMachine({
+	id: "faceCapture",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		dependencies: input.dependencies,
+		authHint: input.authHint,
+		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: getAttemptsFromConfig(input.config),
+		uploadError: void 0,
+		permissionResult: void 0,
+		resetDetection: void 0,
+		deepsightService: void 0,
+		encryptedBase64Image: void 0,
+		uploadRecordingId: void 0,
+		manualCaptureTriggered: false
+	}),
+	on: { QUIT: { target: "#faceCapture.closed" } },
+	states: {
+		idle: { on: { LOAD: [{
+			target: "tutorial",
+			guard: "hasShowTutorial"
+		}, { target: "loading" }] } },
+		loading: {
+			entry: "preloadRecordingProvider",
+			invoke: [{
+				id: "checkPermissionLoading",
+				src: "checkPermission",
+				onDone: [{
+					target: "capture",
+					guard: "isPermissionGranted",
+					actions: "setPermissionResultFromEvent"
+				}, {
+					target: "permissions",
+					actions: "setPermissionResultFromEvent"
+				}]
+			}, {
+				id: "loadingInitDeepsight",
+				src: "initializeDeepsightSession",
+				input: ({ context }) => ({
+					ds: context.config.ds,
+					storage: context.dependencies.storage
+				}),
+				onDone: { actions: "setDeepsightServiceFromEvent" },
+				onError: { actions: "noOp" }
+			}]
+		},
+		tutorial: {
+			initial: "checkingPermission",
+			entry: ["trackTutorial", "preloadRecordingProvider"],
+			states: {
+				checkingPermission: { invoke: {
+					id: "checkPermissionTutorial",
+					src: "checkPermission",
+					onDone: [{
+						target: "initializingCamera",
+						guard: "isPermissionGranted",
+						actions: "setPermissionResultFromEvent"
+					}, {
+						target: "ready",
+						actions: "setPermissionResultFromEvent"
+					}]
+				} },
+				initializingCamera: {
+					type: "parallel",
+					states: {
+						cameraInit: {
+							initial: "initializingDeepsight",
+							states: {
+								initializingDeepsight: { invoke: {
+									id: "tutorialInitDeepsight",
+									src: "initializeDeepsightSession",
+									input: ({ context }) => ({
+										ds: context.config.ds,
+										storage: context.dependencies.storage
+									}),
+									onDone: {
+										target: "initializingStream",
+										actions: "setDeepsightServiceFromEvent"
+									},
+									onError: { target: "#faceCapture.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: "#faceCapture.tutorial.ready",
+										guard: "isPermissionDeniedError",
+										actions: "setPermissionDenied"
+									}, {
+										target: "#faceCapture.tutorial.ready",
+										actions: "setErrorFromEvent"
+									}]
+								} },
+								ready: { type: "final" }
+							}
+						},
+						userIntent: {
+							initial: "waiting",
+							states: {
+								waiting: { on: { NEXT_STEP: {
+									target: "clicked",
+									actions: "trackContinue"
+								} } },
+								clicked: { type: "final" }
+							}
+						}
+					},
+					onDone: { target: "#faceCapture.capture" }
+				},
+				ready: {
+					initial: "idle",
+					states: {
+						idle: { always: [{
+							target: "initializingDeepsight",
+							guard: ({ context }) => context.deepsightService === void 0
+						}, { target: "readyForNext" }] },
+						initializingDeepsight: { invoke: {
+							id: "initializeDeepsightTutorial",
+							src: "initializeDeepsightSession",
+							input: ({ context }) => ({
+								ds: context.config.ds,
+								storage: context.dependencies.storage
+							}),
+							onDone: {
+								target: "readyForNext",
+								actions: "setDeepsightServiceFromEvent"
+							},
+							onError: { target: "readyForNext" }
+						} },
+						readyForNext: { on: { NEXT_STEP: {
+							target: "#faceCapture.tutorial.waitingForPermission",
+							actions: "trackContinue"
+						} } }
+					}
+				},
+				waitingForPermission: { invoke: {
+					id: "checkPermissionWaiting",
+					src: "checkPermission",
+					onDone: [{
+						target: "#faceCapture.capture",
+						guard: "isPermissionGranted",
+						actions: "setPermissionResultFromEvent"
+					}, {
+						target: "#faceCapture.permissions",
+						actions: "setPermissionResultFromEvent"
+					}]
+				} }
+			}
+		},
+		permissions: {
+			entry: "preloadRecordingProvider",
+			initial: "checkingDeepsight",
+			states: {
+				checkingDeepsight: { always: [{
+					target: "initializingDeepsight",
+					guard: ({ context }) => context.deepsightService === void 0
+				}, { target: "idle" }] },
+				initializingDeepsight: { invoke: {
+					id: "initializeDeepsightPerms",
+					src: "initializeDeepsightSession",
+					input: ({ context }) => ({
+						ds: context.config.ds,
+						storage: context.dependencies.storage
+					}),
+					onDone: {
+						target: "idle",
+						actions: "setDeepsightServiceFromEvent"
+					},
+					onError: { target: "idle" }
+				} },
+				idle: {
+					invoke: {
+						id: "checkPermissionIdle",
+						src: "checkPermission",
+						onDone: [{
+							target: "#faceCapture.capture",
+							guard: "isPermissionGranted",
+							actions: "setPermissionResultFromEvent"
+						}, {
+							target: "denied",
+							guard: ({ event }) => event.output === "denied",
+							actions: "setPermissionResultFromEvent"
+						}]
+					},
+					on: {
+						REQUEST_PERMISSION: "requesting",
+						GO_TO_LEARN_MORE: "learnMore"
+					}
+				},
+				learnMore: { on: {
+					BACK: "idle",
+					REQUEST_PERMISSION: "requesting"
+				} },
+				requesting: { invoke: {
+					id: "requestPermission",
+					src: "requestPermission",
+					onDone: [
+						{
+							target: "#faceCapture.capture",
+							guard: "isPermissionGranted",
+							actions: "setPermissionResultFromEvent"
+						},
+						{
+							target: "denied",
+							guard: ({ event }) => event.output === "denied",
+							actions: "setPermissionResultFromEvent"
+						},
+						{
+							target: "idle",
+							actions: "setPermissionResultFromEvent"
+						}
+					],
+					onError: { target: "denied" }
+				} },
+				denied: { entry: "setPermissionRefresh" }
+			}
+		},
+		capture: {
+			entry: "preloadRecordingProvider",
+			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",
+					input: ({ context }) => ({
+						ds: context.config.ds,
+						storage: context.dependencies.storage
+					}),
+					onDone: {
+						target: "checkingStream",
+						actions: ["setDeepsightServiceFromEvent"]
+					},
+					onError: { target: "#faceCapture.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: "#faceCapture.permissions",
+						guard: "isPermissionDeniedError",
+						actions: "setPermissionDenied"
+					}, {
+						target: "#faceCapture.error",
+						actions: "setErrorFromEvent"
+					}]
+				} },
+				detecting: {
+					entry: ["setDetectionStatusDetecting"],
+					invoke: [
+						{
+							id: "checkVirtualCamera",
+							src: "checkVirtualCamera",
+							input: ({ context }) => ({
+								stream: context.stream,
+								deepsightService: context.deepsightService
+							}),
+							onDone: [{
+								target: "#faceCapture.processing",
+								guard: ({ event }) => event.output === true,
+								actions: "sendLabelInspection"
+							}],
+							onError: { actions: "noOp" }
+						},
+						{
+							id: "startRecording",
+							src: "startRecording",
+							input: ({ context }) => ({
+								config: context.config,
+								dependencies: context.dependencies,
+								recordingService: context.recordingService,
+								stream: context.stream
+							}),
+							onDone: { actions: "setRecordingServiceFromEvent" },
+							onError: { actions: "noOp" }
+						},
+						{
+							id: "runDetection",
+							src: "runDetection",
+							input: ({ context }) => ({
+								frameCapturer: context.frameCapturer,
+								provider: context.provider,
+								config: context.config,
+								manualCaptureTriggered: context.manualCaptureTriggered
+							})
+						}
+					],
+					on: {
+						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
+						DETECTION_FRAME: { actions: "setDebugFrameFromEvent" },
+						DETECTION_RESET_READY: { actions: "setResetDetectionFromEvent" },
+						DETECTION_SUCCESS: {
+							target: "capturing",
+							actions: "setCapturedImageFromEvent"
+						},
+						MANUAL_CAPTURE: { target: "capturingManual" }
+					}
+				},
+				capturing: {
+					entry: ["captureImage"],
+					always: [{
+						target: "preparingUpload",
+						guard: "hasCapturedImage"
+					}, {
+						target: "uploadError",
+						actions: "setServerErrorAndDecrement"
+					}]
+				},
+				capturingManual: {
+					entry: ["captureLatestFrame"],
+					always: [{
+						target: "preparingUpload",
+						guard: "hasCapturedImage"
+					}, {
+						target: "uploadError",
+						actions: "setServerErrorAndDecrement"
+					}]
+				},
+				preparingUpload: { invoke: {
+					id: "prepareFaceUpload",
+					src: "prepareFaceUpload",
+					input: ({ context }) => context,
+					onDone: {
+						target: "uploading",
+						actions: "setUploadPreparationFromEvent"
+					},
+					onError: {
+						target: "uploadError",
+						actions: "setServerErrorAndDecrement"
+					}
+				} },
+				uploading: { invoke: {
+					id: "uploadFace",
+					src: "uploadFace",
+					input: ({ context }) => context,
+					onDone: {
+						target: "validatingUpload",
+						actions: "setUploadResponseFromEvent"
+					},
+					onError: {
+						target: "uploadError",
+						actions: "setServerErrorAndDecrement"
+					}
+				} },
+				validatingUpload: { always: [
+					{
+						target: "#faceCapture.error",
+						guard: "isTerminalUploadError",
+						actions: "setTerminalError"
+					},
+					{
+						target: "uploadError",
+						guard: "hasUploadValidationError",
+						actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
+					},
+					{ target: "success" }
+				] },
+				uploadError: { on: { RETRY_CAPTURE: [
+					{
+						target: "checkingStream",
+						guard: "hasAttemptsRemaining",
+						actions: [
+							"resetDetection",
+							"clearUploadFailure",
+							"clearStreamForRetry"
+						]
+					},
+					{
+						target: "#faceCapture.error",
+						guard: "isNoAttemptsTerminal",
+						actions: ["setTerminalError"]
+					},
+					{
+						target: "#faceCapture.finished",
+						actions: ["flagFaceManualReview"]
+					}
+				] } },
+				success: {
+					entry: "cleanup",
+					after: { 3e3: { target: "#faceCapture.processing" } }
+				}
+			}
+		},
+		processing: { invoke: {
+			id: "processFace",
+			src: "processFace",
+			onDone: {
+				target: "finished",
+				actions: "setProcessResponseFromEvent"
+			},
+			onError: { target: "finished" }
+		} },
+		finished: {
+			entry: "stopMediaStream",
+			type: "final"
+		},
+		closed: {
+			entry: "stopMediaStream",
+			type: "final"
+		},
+		error: {
+			entry: "stopMediaStream",
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		}
+	}
+});
+const faceCaptureMachine = _faceCaptureMachine;
+
+//#endregion
+export { createFaceCaptureManagerFromActor as n, faceCaptureMachine as t };