@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/faceCaptureSetup-Cd-04W_X.esm.js

@@ -1,863 +0,0 @@
-import { r as getToken } from "./api-Bx3gKW_y.esm.js";
-import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
-import { c as sendLabelInspectionEvent, f as stopStream, l as startDetection, o as initializeCamera, s as initializeDeepsightSession } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-DQKaRise.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KINpmKtI.esm.js";
-import { t as flagFaceManualReview } from "./manualReviewService-D4IkipnN.esm.js";
-import { n as preloadOpenViduProvider, t as createRecordingService } from "./recordingService-3NSENVwp.esm.js";
-//#region src/internal/avatar/concealment.ts
-/**
-* Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
-* — and any absent or unknown value, for forward-compat safety — yields the live
-* video (no avatar). The other three map 1:1 onto the shipped avatar catalog:
-*  - `OPTION_3D`         → `avatar-3d` (3D VRM)
-*  - `OPTION_2D`         → `avatar-2d` (stylized 2D face)
-*  - `OPTION_SILHOUETTE` → `privacy-lens` (WebGL frosted-glass conceal)
-*/
-function concealmentToAvatar(option) {
-	switch (option) {
-		case "OPTION_3D": return {
-			obfuscateWithAvatar: true,
-			avatarVariant: "avatar-3d"
-		};
-		case "OPTION_2D": return {
-			obfuscateWithAvatar: true,
-			avatarVariant: "avatar-2d"
-		};
-		case "OPTION_SILHOUETTE": return {
-			obfuscateWithAvatar: true,
-			avatarVariant: "privacy-lens"
-		};
-		default: return {
-			obfuscateWithAvatar: false,
-			avatarVariant: void 0
-		};
-	}
-}
-//#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 invokeRequestPermissionActor(input);
-		}),
-		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
-				}),
-				onSuccess: (canvas, faceCoordinates) => sendBack({
-					type: "DETECTION_SUCCESS",
-					canvas,
-					faceCoordinates
-				}),
-				provider: input.provider
-			});
-			sendBack({
-				type: "DETECTION_RESET_READY",
-				reset
-			});
-			return cleanup;
-		}),
-		runAvatar: fromCallback(({ input, sendBack }) => {
-			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(input.config.selfieConcealmentOption);
-			if (!obfuscateWithAvatar || !input.stream) return () => {};
-			const stream = input.stream;
-			const variant = avatarVariant ?? "avatar-3d";
-			let handle = null;
-			let cancelled = false;
-			(async () => {
-				try {
-					const created = await createFaceAvatar({
-						variant,
-						stream,
-						assets: input.config.avatarAssets
-					});
-					if (cancelled) {
-						created.stop();
-						return;
-					}
-					handle = created;
-					sendBack({
-						type: "AVATAR_READY",
-						canvas: created.canvas
-					});
-				} catch (err) {
-					console.warn("[face-avatar] failed to start avatar overlay", err);
-				}
-			})();
-			return () => {
-				cancelled = true;
-				handle?.stop();
-			};
-		}),
-		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,
-				avatarCanvas: void 0,
-				usingBackCamera: false
-			};
-		}),
-		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);
-			},
-			usingBackCamera: ({ event }) => {
-				if ("output" in event) return event.output.usingBackCamera;
-				return false;
-			}
-		}),
-		trackTutorial: () => void 0,
-		trackContinue: () => {},
-		resetContext: assign(({ context }) => ({
-			stream: void 0,
-			provider: void 0,
-			frameCapturer: void 0,
-			usingBackCamera: false,
-			error: void 0,
-			detectionStatus: "idle",
-			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,
-			avatarCanvas: 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,
-				avatarCanvas: void 0,
-				usingBackCamera: false
-			};
-		}),
-		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";
-		} }),
-		setAvatarCanvas: assign({ avatarCanvas: ({ event }) => event.canvas }),
-		clearAvatarCanvas: assign({ avatarCanvas: () => void 0 }),
-		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();
-		},
-		warmAvatarProvider: ({ context }) => {
-			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(context.config.selfieConcealmentOption);
-			if (!obfuscateWithAvatar || !avatarVariant) return;
-			warmFaceAvatar({
-				variant: avatarVariant,
-				assets: context.config.avatarAssets
-			});
-		},
-		releaseAvatarWarmup: () => {
-			releaseFaceAvatarWarmup();
-		},
-		noOp: () => void 0
-	},
-	guards: {
-		hasShowTutorial: ({ context }) => context.config.showTutorial,
-		hasAgeAssurance: ({ context }) => context.config.ageAssurance === true,
-		isPermissionGranted: ({ event }) => {
-			if ("output" in event) return event.output === "granted";
-			return false;
-		},
-		isReadyForCapture: ({ context, event }) => {
-			return isReadyForCaptureFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
-		},
-		needsMotionPrimeOnly: ({ context, event }) => {
-			return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
-		},
-		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,
-		usingBackCamera: false,
-		error: void 0,
-		detectionStatus: "idle",
-		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,
-		avatarCanvas: void 0,
-		faceFeed: void 0
-	}),
-	on: { QUIT: { target: "#faceCapture.closed" } },
-	states: {
-		idle: { on: { LOAD: [
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial"
-			},
-			{
-				target: "tutorial",
-				guard: "hasAgeAssurance"
-			},
-			{ target: "loading" }
-		] } },
-		loading: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
-			invoke: [{
-				id: "checkPermissionLoading",
-				src: "checkPermission",
-				onDone: [{
-					target: "capture",
-					guard: "isReadyForCapture",
-					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",
-				"warmAvatarProvider"
-			],
-			states: {
-				checkingPermission: { invoke: {
-					id: "checkPermissionTutorial",
-					src: "checkPermission",
-					onDone: [{
-						target: "initializingCamera",
-						guard: "isReadyForCapture",
-						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: "isReadyForCapture",
-							actions: "setPermissionResultFromEvent"
-						},
-						{
-							target: "#faceCapture.permissions.requesting",
-							guard: "needsMotionPrimeOnly",
-							actions: "setPermissionResultFromEvent"
-						},
-						{
-							target: "#faceCapture.permissions",
-							actions: "setPermissionResultFromEvent"
-						}
-					]
-				} }
-			}
-		},
-		permissions: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
-			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: "isReadyForCapture",
-								actions: "setPermissionResultFromEvent"
-							},
-							{
-								target: "denied",
-								guard: ({ event }) => event.output === "denied",
-								actions: "setPermissionResultFromEvent"
-							},
-							{
-								target: "motionOnly",
-								guard: "needsMotionPrimeOnly",
-								actions: "setPermissionResultFromEvent"
-							},
-							{
-								target: "waitingForUser",
-								actions: "setPermissionResultFromEvent"
-							}
-						],
-						onError: {
-							target: "waitingForUser",
-							actions: assign({ permissionResult: () => "prompt" })
-						}
-					},
-					on: {
-						REQUEST_PERMISSION: "requesting",
-						GO_TO_LEARN_MORE: "learnMore"
-					}
-				},
-				waitingForUser: { on: {
-					REQUEST_PERMISSION: "requesting",
-					GO_TO_LEARN_MORE: "learnMore"
-				} },
-				motionOnly: { on: { REQUEST_PERMISSION: "requesting" } },
-				learnMore: { on: {
-					BACK: "idle",
-					REQUEST_PERMISSION: "requesting"
-				} },
-				requesting: { invoke: {
-					id: "requestPermission",
-					src: "requestPermission",
-					input: ({ context }) => ({
-						permissionResult: context.permissionResult === "refresh" ? void 0 : context.permissionResult,
-						requestMotionPermission: context.config.ds === true
-					}),
-					onDone: [
-						{
-							target: "#faceCapture.capture",
-							guard: "isReadyForCapture",
-							actions: "setPermissionResultFromEvent"
-						},
-						{
-							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: "setPermissionResultFromEvent"
-						},
-						{
-							target: "waitingForUser",
-							actions: "setPermissionResultFromEvent"
-						}
-					],
-					onError: { target: "denied" }
-				} },
-				denied: { entry: "setPermissionRefresh" }
-			}
-		},
-		capture: {
-			entry: ["preloadRecordingProvider", "warmAvatarProvider"],
-			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,
-								faceFeed: context.faceFeed
-							})
-						},
-						{
-							id: "runAvatar",
-							src: "runAvatar",
-							input: ({ context }) => ({
-								stream: context.stream,
-								config: context.config,
-								faceFeed: context.faceFeed
-							})
-						}
-					],
-					exit: ["clearAvatarCanvas"],
-					on: {
-						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
-						AVATAR_READY: { actions: "setAvatarCanvas" },
-						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", "releaseAvatarWarmup"],
-			type: "final"
-		},
-		closed: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
-			type: "final"
-		},
-		error: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
-			on: { RESET: {
-				target: "idle",
-				actions: "resetContext"
-			} }
-		}
-	}
-});
-//#endregion
-export { concealmentToAvatar as n, faceCaptureMachine as t };