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

package/dist/faceCaptureSetup-DbXgtcp7.esm.js

@@ -1,1561 +0,0 @@
-import { a as isIPhone14OrHigher, n as isDesktop, r as isIOS, t as isAndroid } from "./platform-DdhkonXk.esm.js";
-import { i as IncodeCanvas, l as mlWasmJSApi_default, t as BaseWasmProvider, u as WasmPipelineType } from "./BaseWasmProvider--AzPfwOm.esm.js";
-import { a as uploadDeepsightVideo, c as requestPermission, i as stopRecording$1, l as StreamCanvasProcessingSession, n as createRecordingSession, o as OpenViduRecordingProvider, p as getDeviceClass, r as startRecording, s as checkPermission, t as StreamCanvasCapture, u as flagFaceManualReview } from "./StreamCanvasCapture-DkpkIgyL.esm.js";
-import { r as getToken, t as api } from "./api-C2uzxrpN.esm.js";
-import { S as fromPromise, b as assign, s as createManagerInstrumentation, t as createManager, x as fromCallback, y as setup } from "./Manager-C6AGXEq_.esm.js";
-import { t as endpoints } from "./endpoints-CI5-28jT.esm.js";
-import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DAuRUvnp.esm.js";
-import { t as addDeviceStats } from "./stats-BVigf5Rn.esm.js";
-import { n as getDesktopCameraStream, t as getBackCameraStream } from "./backCameraStream-DF_d7hTz.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/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 ../infra/src/providers/wasm/FaceDetectionProvider.ts
-var FaceDetectionProvider = class extends BaseWasmProvider {
-	constructor() {
-		super(WasmPipelineType.SelfieWithQualityMetrics);
-		this.defaultThresholds = {
-			frameMinX: 0,
-			frameMinY: 0,
-			frameMaxX: 1,
-			frameMaxY: 1,
-			brightnessThreshold: 50,
-			blurrinessThreshold: 50,
-			tiltRotationAngleThreshold: 15,
-			minMagicCropSize: 200,
-			headwearThreshold: .86,
-			lensesThreshold: .95,
-			closedEyesThreshold: .9,
-			maskThreshold: .85,
-			minFaceQualityScore: .63,
-			faceOcclusionThreshold: .3
-		};
-		this.currentFrame = null;
-		this.bestCanvas = null;
-		this.bestFace = null;
-	}
-	async processFrame(image) {
-		this.currentFrame = image;
-		await this.processFrameWasm(image);
-	}
-	async initialize(config) {
-		await this.initializeBase(config, "selfie");
-		this.applyDefaults(config.autocaptureInterval ?? 0);
-	}
-	setCallbacks(callbacks) {
-		this.ensureInitialized();
-		const onBestShotWrapper = (face) => {
-			this.bestFace = face;
-			if (this.currentFrame) {
-				const frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
-				this.bestCanvas = frameCanvas.clone() ?? frameCanvas;
-			}
-			callbacks.onBestShot?.(face);
-		};
-		const onCaptureWrapper = () => {
-			let frameCanvas = this.bestCanvas;
-			if (!frameCanvas && this.currentFrame) frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
-			if (!frameCanvas) return;
-			const faceCoordinates = this.bestFace ? this.formatFaceCoordinates(this.bestFace) : this.createDefaultFaceCoordinates(frameCanvas);
-			try {
-				frameCanvas.updateBase64Image();
-				frameCanvas.updateBlob();
-			} catch {}
-			callbacks.onCapture?.(frameCanvas, faceCoordinates);
-			this.bestCanvas = null;
-			this.bestFace = null;
-		};
-		mlWasmJSApi_default.setFaceDetectionCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onTooClose ?? (() => {}), callbacks.onTooManyFaces ?? (() => {}), callbacks.onNoFace ?? (() => {}), onCaptureWrapper, callbacks.onGetReady ?? (() => {}), callbacks.onGetReadyFinished ?? (() => {}), callbacks.onCenterFace ?? (() => {}), callbacks.onDark ?? (() => {}), callbacks.onBlur ?? (() => {}), callbacks.onFaceAngle ?? (() => {}), onBestShotWrapper, callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
-	}
-	setPositionConstraints(constraints) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFacePositionConstraints(this.getPipelineType(), constraints.minX, constraints.minY, constraints.maxX, constraints.maxY);
-	}
-	applyDefaults(autocaptureInterval = 0) {
-		this.ensureInitialized();
-		this.setThresholds({
-			brightnessThreshold: this.defaultThresholds.brightnessThreshold,
-			blurrinessThreshold: this.defaultThresholds.blurrinessThreshold,
-			tiltRotationAngleThreshold: this.defaultThresholds.tiltRotationAngleThreshold,
-			minMagicCropSize: this.defaultThresholds.minMagicCropSize,
-			autocaptureInterval,
-			minFaceQualityScore: this.defaultThresholds.minFaceQualityScore,
-			faceOcclusionThreshold: this.defaultThresholds.faceOcclusionThreshold
-		});
-		this.setPositionConstraints({
-			minX: this.defaultThresholds.frameMinX,
-			minY: this.defaultThresholds.frameMinY,
-			maxX: this.defaultThresholds.frameMaxX,
-			maxY: this.defaultThresholds.frameMaxY
-		});
-		this.setAttributesThresholds({
-			headwearThreshold: this.defaultThresholds.headwearThreshold,
-			lensesThreshold: this.defaultThresholds.lensesThreshold,
-			closedEyesThreshold: this.defaultThresholds.closedEyesThreshold,
-			maskThreshold: this.defaultThresholds.maskThreshold
-		});
-	}
-	setAutocaptureInterval(interval) {
-		this.ensureInitialized();
-		if (!this.currentThresholds) {
-			this.applyDefaults(interval);
-			return;
-		}
-		this.setThresholds({
-			...this.currentThresholds,
-			autocaptureInterval: interval
-		});
-	}
-	setThresholds(thresholds) {
-		this.ensureInitialized();
-		this.currentThresholds = { ...thresholds };
-		mlWasmJSApi_default.setFaceDetectionThresholds(this.getPipelineType(), thresholds.brightnessThreshold, thresholds.blurrinessThreshold, thresholds.tiltRotationAngleThreshold, thresholds.minMagicCropSize, thresholds.autocaptureInterval, thresholds.minFaceQualityScore, thresholds.faceOcclusionThreshold);
-	}
-	setAttributesThresholds(thresholds) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceAttributesThresholds(this.getPipelineType(), thresholds.headwearThreshold, thresholds.lensesThreshold, thresholds.closedEyesThreshold, thresholds.maskThreshold);
-	}
-	setChecksEnabled(config) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceChecksEnabled(this.getPipelineType(), config.lenses, config.mask, config.closedEyes, config.headWear, config.occlusion);
-	}
-	setVideoSelfieMode(enabled) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setFaceDetectionMode(this.getPipelineType(), enabled);
-	}
-	reset() {
-		super.reset();
-		this.currentFrame = null;
-		this.bestCanvas = null;
-		this.bestFace = null;
-	}
-	createDefaultFaceCoordinates(canvas) {
-		return {
-			rightEyeX: 0,
-			rightEyeY: 0,
-			leftEyeX: 0,
-			leftEyeY: 0,
-			noseTipX: 0,
-			noseTipY: 0,
-			rightMouthX: 0,
-			rightMouthY: 0,
-			mouthX: 0,
-			mouthY: 0,
-			x: 0,
-			y: 0,
-			width: canvas.width() ?? 0,
-			height: canvas.height() ?? 0
-		};
-	}
-	formatFaceCoordinates(face) {
-		return {
-			rightEyeX: face.rightEye.x,
-			rightEyeY: face.rightEye.y,
-			leftEyeX: face.leftEye.x,
-			leftEyeY: face.leftEye.y,
-			noseTipX: face.noseTip.x,
-			noseTipY: face.noseTip.y,
-			rightMouthX: face.rightMouthCorner.x,
-			rightMouthY: face.rightMouthCorner.y,
-			mouthX: face.leftMouthCorner.x,
-			mouthY: face.leftMouthCorner.y,
-			x: face.rect.x,
-			y: face.rect.y,
-			width: face.rect.width,
-			height: face.rect.height
-		};
-	}
-};
-
-//#endregion
-//#region src/modules/selfie/selfieUploadService.ts
-/**
-* Uploads a selfie image to the backend.
-*/
-async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
-	try {
-		const payload = {
-			base64Image: encryptedBase64Image,
-			faceCoordinates: faceCoordinates ?? void 0,
-			encrypted: true,
-			clientInfo: { deviceClass: getDeviceClass() },
-			metadata: metadata ?? void 0
-		};
-		const query = { imageType: "selfie" };
-		if (recordingId) query.recordingId = recordingId;
-		const res = await api.post(endpoints.selfie, payload, {
-			signal,
-			query
-		});
-		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
-		return res.data;
-	} catch (error) {
-		const errorCode = getFaceErrorCodeFromHttpError(error);
-		if (errorCode) throw new Error(errorCode);
-		throw new Error(FACE_ERROR_CODES.SERVER);
-	}
-}
-const getFaceErrorCodeFromHttpError = (error) => {
-	const err = error;
-	if (err.ok !== false || typeof err.status !== "number") return;
-	if (err.status !== 400) return FACE_ERROR_CODES.SERVER;
-	if (typeof err.data?.status !== "number") return FACE_ERROR_CODES.BAD_REQUEST;
-	return {
-		3004: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3005: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		3006: FACE_ERROR_CODES.TOO_BLURRY,
-		3007: FACE_ERROR_CODES.TOO_DARK,
-		4010: FACE_ERROR_CODES.MULTIPLE_FACES,
-		4019: FACE_ERROR_CODES.FACE_NOT_FOUND,
-		4077: FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-		4078: FACE_ERROR_CODES.FACE_OCCLUDED
-	}[err.data.status] ?? FACE_ERROR_CODES.BAD_REQUEST;
-};
-async function processFace(imageType = "selfie", signal) {
-	return (await api.post(endpoints.processFace, {}, {
-		query: { imageType },
-		signal
-	})).data;
-}
-
-//#endregion
-//#region src/internal/faceCapture/faceCaptureServices.ts
-function sendLabelInspectionEvent() {
-	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
-}
-const MOBILE_SELFIE_CONSTRAINTS = {
-	video: {
-		facingMode: "user",
-		height: { ideal: 480 },
-		width: { ideal: 640 }
-	},
-	audio: false
-};
-const IPHONE14_SELFIE_CONSTRAINTS = {
-	video: { height: { ideal: 1080 } },
-	audio: false
-};
-function buildCameraConstraints(resolution) {
-	if (resolution) return {
-		video: {
-			facingMode: "user",
-			height: resolution.height ? { ideal: resolution.height } : void 0,
-			width: resolution.width ? { ideal: resolution.width } : void 0
-		},
-		audio: false
-	};
-	if (isIPhone14OrHigher()) return IPHONE14_SELFIE_CONSTRAINTS;
-	return MOBILE_SELFIE_CONSTRAINTS;
-}
-function stopStream(stream) {
-	stopCameraStream(stream);
-}
-async function getFrontCameraStream(resolution) {
-	if (resolution) return requestCameraAccess(buildCameraConstraints(resolution));
-	if (isDesktop()) return getDesktopCameraStream({});
-	return requestCameraAccess(buildCameraConstraints());
-}
-async function initializeCamera(params) {
-	const { config } = params;
-	const prcConstraints = buildCameraConstraints(config.cameraResolution);
-	const provider = new FaceDetectionProvider();
-	await provider.initialize({ autocaptureInterval: config.autoCaptureTimeout * 1e3 });
-	provider.setChecksEnabled({
-		lenses: config.validateLenses ?? false,
-		mask: config.validateFaceMask ?? false,
-		closedEyes: config.validateClosedEyes ?? false,
-		headWear: config.validateHeadCover ?? false,
-		occlusion: false
-	});
-	await params.deepsightService.performPrcCheck({ constraints: { video: prcConstraints.video } });
-	return {
-		stream: config.assistedOnboarding ? (await getBackCameraStream()).stream : await getFrontCameraStream(config.cameraResolution),
-		provider
-	};
-}
-/**
-* Encrypts the provided selfie image using WASM.
-*/
-async function encryptSelfieImage({ canvas, dependencies }) {
-	const base64Image = canvas.getBase64Image();
-	if (!base64Image) throw new Error("Canvas image is empty or null");
-	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
-}
-function startDetection(params) {
-	let lastStatus;
-	let session;
-	const { provider } = params;
-	const setStatus = (status) => {
-		if (session?.isDisposed() === true) return;
-		if (lastStatus === status) return;
-		lastStatus = status;
-		params.onUpdate(status);
-	};
-	const stopDetectionLoop = () => {
-		session?.dispose();
-	};
-	const reset = () => {
-		provider.reset();
-	};
-	const cleanup = () => {
-		stopDetectionLoop();
-	};
-	(async () => {
-		try {
-			provider.setCallbacks({
-				onFarAway: () => setStatus("tooFar"),
-				onTooClose: () => setStatus("tooClose"),
-				onTooManyFaces: () => setStatus("tooManyFaces"),
-				onNoFace: () => setStatus("idle"),
-				onCenterFace: () => setStatus("centerFace"),
-				onGetReady: () => setStatus("getReady"),
-				onGetReadyFinished: () => setStatus("getReadyFinished"),
-				onDark: () => {
-					if (params.config.validateBrightness) setStatus("dark");
-				},
-				onBlur: () => setStatus("blur"),
-				onFaceAngle: () => setStatus("faceAngle"),
-				onLenses: () => {
-					if (params.config.validateLenses) setStatus("lenses");
-				},
-				onMask: () => {
-					if (params.config.validateFaceMask) setStatus("faceMask");
-				},
-				onEyesClosed: () => {
-					if (params.config.validateClosedEyes) setStatus("eyesClosed");
-				},
-				onHeadWear: () => {
-					if (params.config.validateHeadCover) setStatus("headWear");
-				},
-				onFaceOccluded: () => {},
-				onSwitchToManualCapture: () => {
-					setStatus("manualCapture");
-					stopDetectionLoop();
-				},
-				onCapture: (canvas, faceCoordinates) => {
-					setStatus("success");
-					params.onSuccess(canvas, faceCoordinates);
-					cleanup();
-				}
-			});
-			setStatus("detecting");
-			session = new StreamCanvasProcessingSession({
-				capturer: params.capturer,
-				provider,
-				onFrame: params.onFrame
-			});
-		} catch {
-			setStatus("error");
-			cleanup();
-		}
-	})();
-	return {
-		cleanup,
-		reset
-	};
-}
-function buildResolutionFromStream(stream) {
-	const track = stream.getVideoTracks()[0];
-	if (!track) return;
-	const settings = track.getSettings();
-	const width = settings.width;
-	const height = settings.height;
-	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
-}
-async function startRecordingSession(params) {
-	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
-	if (params.config.enableFaceRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
-	const clonedStream = params.clonedStream;
-	const hasAudio = clonedStream.getAudioTracks().length > 0;
-	const resolution = buildResolutionFromStream(clonedStream);
-	const session = await createRecordingSession("selfie");
-	const connection = await provider.connect({
-		sessionToken: session.token,
-		stream: clonedStream,
-		events: {}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: "selfie",
-		resolution,
-		hasAudio
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
-}
-async function stopRecording(session) {
-	try {
-		await stopRecording$1(session.videoRecordingId);
-	} finally {
-		await session.connection.disconnect();
-	}
-}
-async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-DKgEdLIS.esm.js");
-	return loadDeepsightSession({
-		ds: options.ds,
-		storage: options.storage
-	});
-}
-
-//#endregion
-//#region ../infra/src/media/VideoTrimmer.ts
-async function getDurationBySeek(videoBlob) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.src = URL.createObjectURL(videoBlob);
-	try {
-		if (!Number.isFinite(video.duration)) {
-			video.currentTime = Number.MAX_SAFE_INTEGER;
-			await new Promise((resolve) => {
-				const onDurationChange = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("durationchange", onDurationChange);
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						resolve(video.duration);
-					}
-				};
-				const onTimeUpdate = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						video.removeEventListener("durationchange", onDurationChange);
-						resolve(video.duration);
-					}
-				};
-				video.addEventListener("durationchange", onDurationChange);
-				video.addEventListener("timeupdate", onTimeUpdate);
-			});
-		}
-		const duration = video.duration;
-		return Number.isFinite(duration) ? duration : null;
-	} finally {
-		URL.revokeObjectURL(video.src);
-		video.src = "";
-	}
-}
-async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.playsInline = true;
-	video.muted = true;
-	const videoURL = URL.createObjectURL(videoBlob);
-	video.src = videoURL;
-	const duration = await getDurationBySeek(videoBlob);
-	if (!duration || duration < seconds) {
-		URL.revokeObjectURL(videoURL);
-		return videoBlob;
-	}
-	const startTime = Math.max(0, Math.floor(duration) - seconds);
-	await new Promise((resolve) => {
-		if (video.readyState >= 2) resolve();
-		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
-	});
-	const canvas = document.createElement("canvas");
-	canvas.width = 230;
-	canvas.height = 320;
-	const captureFps = isAndroid() ? 15 : 24;
-	const stream = canvas.captureStream(captureFps);
-	const ctx = canvas.getContext("2d");
-	video.currentTime = startTime;
-	await new Promise((resolve) => {
-		video.addEventListener("seeked", () => resolve(), { once: true });
-	});
-	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
-	const mediaRecorder = new MediaRecorder(stream.clone(), {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		bitsPerSecond: 5e5
-	});
-	const chunks = [];
-	mediaRecorder.ondataavailable = (event) => {
-		if (event.data.size > 0) chunks.push(event.data);
-	};
-	const recordingPromise = new Promise((resolve) => {
-		mediaRecorder.onstop = () => {
-			const trimmedBlob$1 = new Blob(chunks, { type: mimeType });
-			URL.revokeObjectURL(videoURL);
-			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
-			stream.getTracks().forEach((track) => track.stop());
-			video.src = "";
-			resolve(trimmedBlob$1);
-		};
-	});
-	video.addEventListener("play", () => {
-		function drawVideo() {
-			if (video.currentTime >= duration) {
-				mediaRecorder.stop();
-				video.pause();
-				return;
-			}
-			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-			requestAnimationFrame(drawVideo);
-		}
-		drawVideo();
-		setTimeout(() => {
-			mediaRecorder.start(100);
-		}, 500);
-	});
-	video.play().catch(() => {
-		URL.revokeObjectURL(videoURL);
-	});
-	const trimmedBlob = await recordingPromise;
-	console.timeEnd("trimLastNSecondsUsingPlayback");
-	return trimmedBlob;
-}
-async function trimLastNSeconds(videoBlob, seconds) {
-	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
-}
-
-//#endregion
-//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
-function toBase64(videoBlob) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onloadend = () => {
-			const base64 = reader.result.split(",")[1];
-			resolve(base64);
-		};
-		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
-		reader.readAsDataURL(videoBlob);
-	});
-}
-function getSupportedMediaRecorderMimeType() {
-	const possibleTypes = isIOS() ? [
-		"video/mp4",
-		"video/webm",
-		"video/webm;codecs=vp9",
-		"video/webm;codecs=vp8"
-	] : [
-		"video/webm",
-		"video/webm;codecs=vp9",
-		"video/webm;codecs=vp8",
-		"video/mp4"
-	];
-	for (const type of possibleTypes) if (MediaRecorder.isTypeSupported(type)) return type;
-	return "";
-}
-function getAdaptiveMediaRecorderOptions() {
-	const mimeType = getSupportedMediaRecorderMimeType();
-	if (isIOS()) return {
-		mimeType,
-		videoBitsPerSecond: 1e6,
-		bitsPerSecond: 1e6
-	};
-	return {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		bitsPerSecond: 5e5
-	};
-}
-var LocalRecordingProvider = class {
-	constructor() {
-		this.mediaRecorder = null;
-		this._isRecording = false;
-		this._hasError = false;
-		this._error = null;
-		this.mimeType = "";
-		this.stream = null;
-		this.pauseRecordingBound = this.pauseRecording.bind(this);
-	}
-	get isRecording() {
-		return this._isRecording;
-	}
-	get hasError() {
-		return this._hasError;
-	}
-	get error() {
-		return this._error;
-	}
-	startRecording(stream) {
-		this.reset();
-		this.registerEventListeners();
-		this.stream = stream;
-		try {
-			const options = getAdaptiveMediaRecorderOptions();
-			this.mimeType = options.mimeType;
-			const recorder = new MediaRecorder(stream.clone(), options);
-			recorder.onerror = (event) => {
-				this._error = `Recording error: ${event}`;
-				this._isRecording = false;
-				this._hasError = true;
-			};
-			recorder.start();
-			this.mediaRecorder = recorder;
-			this._isRecording = true;
-			this._error = null;
-			this._hasError = false;
-		} catch (err) {
-			this._error = `Failed to start recording: ${err}`;
-			this._hasError = true;
-		}
-	}
-	async stopRecording(trimSeconds, encrypt, generateChecksum) {
-		const recorder = this.mediaRecorder;
-		return new Promise((resolve, reject) => {
-			this.removeEventListeners();
-			if (recorder && this._isRecording) {
-				const chunks = [];
-				recorder.ondataavailable = (event) => {
-					if (event.data.size > 0) chunks.push(event.data);
-				};
-				recorder.onstop = async () => {
-					try {
-						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
-						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
-						generateChecksum(await trimmedVideo.arrayBuffer());
-						this._isRecording = false;
-						resolve({
-							trimmedBlob: trimmedVideo,
-							encryptedVideo: encryptedVideoBase64
-						});
-					} catch (error) {
-						this._isRecording = false;
-						this._error = `Recording stop failed: ${error}`;
-						this._hasError = true;
-						reject(error);
-					}
-				};
-				recorder.stop();
-				this._isRecording = false;
-			} else resolve({
-				trimmedBlob: new Blob([], { type: this.mimeType }),
-				encryptedVideo: ""
-			});
-			recorder?.stream?.getTracks().forEach((track) => track.stop());
-		});
-	}
-	reset() {
-		this._isRecording = false;
-		this._error = null;
-		this._hasError = false;
-	}
-	pauseRecording() {
-		if (!this._isRecording) return;
-		if (this.mediaRecorder?.state === "recording") try {
-			this.mediaRecorder.pause();
-		} catch {}
-	}
-	registerEventListeners() {
-		document.addEventListener("visibilitychange", this.pauseRecordingBound);
-	}
-	removeEventListeners() {
-		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
-	}
-};
-
-//#endregion
-//#region src/internal/faceCapture/recordingService.ts
-/**
-* Records on-device and uploads encrypted video for liveness.
-*/
-var LocalRecordingService = class {
-	constructor(wasmUtil, sessionToken) {
-		this.recorder = new LocalRecordingProvider();
-		this.sessionToken = sessionToken;
-		this.wasmUtil = wasmUtil;
-	}
-	async start(stream) {
-		this.recorder.startRecording(stream);
-	}
-	async stop() {
-		if (!this.recorder.isRecording) return { recordingId: null };
-		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
-		if (!this.sessionToken) return { recordingId: null };
-		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
-	}
-	cleanup() {
-		this.recorder.reset();
-	}
-};
-/**
-* Records through OpenVidu and manages the session lifecycle.
-*/
-var OpenViduRecordingService = class {
-	constructor(config) {
-		this.provider = new OpenViduRecordingProvider();
-		this.config = config;
-	}
-	async start(stream) {
-		this.session = await startRecordingSession({
-			config: {
-				...this.config,
-				recording: { capability: this.provider }
-			},
-			clonedStream: stream.clone(),
-			existing: this.session
-		});
-	}
-	async stop() {
-		if (this.session) {
-			stopRecording(this.session);
-			this.session = void 0;
-		}
-		return { recordingId: null };
-	}
-	cleanup() {
-		if (this.session) stopRecording(this.session);
-	}
-};
-/**
-* Creates the recording service for the current configuration.
-*/
-function createRecordingService(params) {
-	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
-	if (params.config.enableFaceRecording === true) return new OpenViduRecordingService(params.config);
-}
-
-//#endregion
-//#region src/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();
-		},
-		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: { 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",
-			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: {
-			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: {
-			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 a, FACE_ERROR_CODES as i, processFace as n, uploadSelfie as r, faceCaptureMachine as t };