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

package/dist/faceCaptureSetup-B3faSpYA.esm.js

@@ -0,0 +1,873 @@
+import { r as getToken } from "./api-CESGtpbH.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as sleep } from "./ITimerCapability-C67ZRskg.esm.js";
+import { a as StreamCanvasCapture, c as initializeDeepsightSession, d as stopStream, l as sendLabelInspectionEvent, m as FACE_ERROR_CODES, n as preloadOpenViduProvider, o as encryptSelfieImage, r as flagFaceManualReview, s as initializeCamera, t as createRecordingService, u as startDetection } from "./recordingService-Ig2UgbLv.esm.js";
+import { n as requestPermission, t as checkPermission } from "./permissionServices-D_i6nzEw.esm.js";
+
+//#region ../infra/src/scheduling/yieldUntilNextPaint.ts
+/**
+* Resolves after the browser has had a chance to commit and paint a queued
+* render.
+*
+* Strategy:
+* - `requestAnimationFrame` callbacks fire BEFORE the paint of the frame
+*   they belong to (per the HTML5 "update the rendering" step). If we
+*   resolve the promise inside a rAF callback, the await-continuation
+*   runs as a microtask immediately after the callback returns — still
+*   before the paint phase of that frame. A caller that then blocks the
+*   main thread (e.g. synchronous WASM `processPhoto`) starves the paint.
+* - We therefore chain rAF → setTimeout: the rAF fires before frame N's
+*   paint, the setTimeout runs as a macrotask scheduled after frame N's
+*   "update the rendering" step, which the browser will only get to once
+*   the paint actually lands. By the time setTimeout fires, the paint
+*   for the queued render is on screen.
+* - In environments where rAF never ticks (jsdom, happy-dom, backgrounded
+*   tabs), a parallel `setTimeout` fallback at 100 ms resolves instead.
+*   100 ms is comfortably longer than two real-browser frames so rAF +
+*   setTimeout wins reliably in any foregrounded browser. (An earlier
+*   implementation raced rAF against a `MessageChannel` macrotask, but
+*   MessageChannel drains immediately after the current task's
+*   microtasks — before the next paint — so it resolved the promise too
+*   early and defeated the whole point of the helper.)
+*
+* Lives in infra because it touches browser APIs (`requestAnimationFrame`,
+* `setTimeout`) that the architecture rules forbid from core. Core modules
+* that need to yield to the browser render loop should import this helper
+* directly via its file path.
+*/
+function yieldUntilNextPaint() {
+	return new Promise((resolve) => {
+		let resolved = false;
+		const done = () => {
+			if (resolved) return;
+			resolved = true;
+			resolve();
+		};
+		if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				setTimeout(done, 0);
+			});
+		});
+		setTimeout(done, 100);
+	});
+}
+
+//#endregion
+//#region src/internal/faceCapture/onDeviceFaceResults.ts
+/**
+* On-device face-results submission helpers.
+*
+* When a SELFIE or AUTHENTICATION module has
+* `onDeviceFaceResultsSubmissionEnabled: true`, face analysis runs entirely
+* inside the WASM `OnDeviceSelfieWorkflow` pipeline. Captured images are
+* never uploaded — only the staged face-results JSON is POSTed via the WASM
+* `WebApi` to `/omni/add/face-results`. The C++ side encrypts that JSON via
+* `SessionEncryptor`, so this path does NOT require WebClient E2EE.
+*
+* These helpers are deliberately variant-agnostic: both the selfie and auth
+* state machine variants delegate their `prepareFaceUpload`, `uploadFace`,
+* and `processFace` actors here to share behavior. See the "Runtime modes
+* within a module" section of `docs/patterns/XSTATE.md` for the broader
+* pattern.
+*/
+const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
+/**
+* The default (non-on-device) prepare-upload body shared by selfie and auth.
+* Stops any active recording, runs deepsight virtual-camera + frame checks,
+* tracks the capture attempt, and encrypts the captured image.
+*
+* Lifted out of `faceCaptureSetup.ts`'s base `prepareFaceUpload` actor so the
+* default path can be reused by both variants while leaving room for an
+* on-device branch alongside it.
+*/
+async function defaultPrepareFaceUpload(ctx) {
+	const sessionToken = getToken();
+	const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
+	try {
+		if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
+	} catch (error) {}
+	const logs = ctx.deepsightService?.getPipelineState() ?? "";
+	ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
+	return {
+		encryptedBase64Image: await encryptSelfieImage({
+			canvas: ctx.capturedImage,
+			dependencies: ctx.dependencies
+		}),
+		recordingId
+	};
+}
+/**
+* On-device prepare-upload. No recording to stop (the recording service is
+* never created when the flag is on), no image encryption needed.
+*
+* Behavior depends on which capture path got us here:
+*
+* - **Auto-capture path**: the WASM `OnDeviceSelfiePipeline` has been
+*   consuming every video frame via `processFrame()` and aggregating
+*   results across them. When it picks a best-shot, the C++
+*   `OnDeviceSelfieWorkflow::createOnCaptureHandler` calls
+*   `WebApi::setFaceResults(...)` automatically — staging strong,
+*   aggregated `BestShotData` for the subsequent `postFaceResults` call.
+*   We must NOT call `processPhoto` here: `applyFaceResults` would
+*   overwrite that staged state with a weaker single-frame analysis of a
+*   post-capture snapshot (camera state has already changed: autocapture
+*   freeze, stream pause, post-detection latency), and the server then
+*   rejects the submission as "image quality too low".
+*
+* - **Manual-capture path**: the auto-capture timer expired without a
+*   successful best-shot, so the C++ pipeline has nothing staged. We
+*   need to run a single-frame analysis on the manually captured canvas
+*   via `processPhoto`, which itself calls
+*   `OnDeviceSelfieWorkflow::applyFaceResults` → `WebApi::setFaceResults`
+*   to stage results. Mirrors V1 (`packages/incode-welcome/src/camera/useSelfie.ts`)
+*   where `processPhoto` is only invoked from `handleManualCapture`.
+*
+* Returns sentinel values for `encryptedBase64Image` and `recordingId` so
+* the existing FaceCaptureContext shape remains stable; downstream actors
+* for the on-device path simply ignore them.
+*/
+async function prepareOnDeviceFaceUpload(ctx) {
+	if (!ctx.capturedImage) throw new Error("On-device capture requires a captured image canvas");
+	if (!ctx.provider) throw new Error("On-device capture requires the FaceDetectionProvider to be initialized");
+	if (ctx.manualCaptureTriggered) {
+		await yieldUntilNextPaint();
+		await sleep(350);
+		ctx.provider.processPhoto(ctx.capturedImage.canvas);
+	}
+	return {
+		encryptedBase64Image: "",
+		recordingId: null
+	};
+}
+/**
+* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
+* through the WASM `WebApi`. Used as the `uploadFace` actor body for both
+* selfie and auth variants when on-device mode is enabled.
+*
+* The C++ `WebApi` handles `SessionEncryptor` encryption and the actual
+* HTTP via the WASM `WebClient` — so callers don't need to thread the
+* session-encryption details through JS.
+*/
+async function postOnDeviceFaceResults(ctx, signal) {
+	const provider = ctx.provider;
+	if (!provider) throw new Error("On-device upload requires the FaceDetectionProvider to be initialized");
+	const sessionToken = getToken();
+	return await provider.postFaceResults({
+		headers: sessionToken ? { "X-Incode-Hardware-Id": sessionToken } : void 0,
+		timeout: 3e4
+	}) ?? {};
+}
+
+//#endregion
+//#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 ({ input }) => {
+			return requestPermission({ requestMotion: input.requestMotionPermission });
+		}),
+		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 () => {
+			throw new Error("prepareFaceUpload must be provided by variant");
+		}),
+		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,
+			captureOnlyResult: 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(({ 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,
+		captureOnlyResult: void 0
+	}),
+	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",
+					input: ({ context }) => ({ requestMotionPermission: context.config.ds === true }),
+					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.terminalProcessing",
+						actions: ["flagFaceManualReview"]
+					}
+				] } },
+				success: {
+					entry: "cleanup",
+					after: { 3e3: { target: "#faceCapture.processing" } }
+				}
+			}
+		},
+		processing: { invoke: {
+			id: "processFace",
+			src: "processFace",
+			input: ({ context }) => context,
+			onDone: {
+				target: "finished",
+				actions: "setProcessResponseFromEvent"
+			},
+			onError: { target: "finished" }
+		} },
+		terminalProcessing: {
+			entry: "cleanup",
+			invoke: {
+				id: "processFace",
+				src: "processFace",
+				input: ({ context }) => context,
+				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 { prepareOnDeviceFaceUpload as a, postOnDeviceFaceResults as i, defaultPrepareFaceUpload as n, isOnDeviceMode as r, faceCaptureMachine as t };