@incodetech/core 0.0.0-dev-20260126-4504c5b

package/dist/id-r1mw9zBM.esm.js

@@ -0,0 +1,1827 @@
+import { d as addEvent, m as revokeObjectURL, n as eventModuleNames } from "./events-B8ZkhAZo.esm.js";
+import { C as createManager, D as isIOS, E as isDesktop, O as isIPhone14OrHigher, S as stopCameraStream, T as isAndroid, b as enumerateVideoDevices, c as OpenViduRecordingProvider, d as BrowserTimerProvider, h as StreamCanvasCapture, k as isSafari, m as StreamCanvasProcessingSession, n as DEFAULT_ID_CAPTURE_THRESHOLDS, t as DEFAULT_ID_CAPTURE_MODEL_VERSION, v as IncodeCanvas, x as requestCameraAccess, y as applyTrackConstraints } from "./src-DYtpbFY5.esm.js";
+import { n as getWindowDimensions } from "./getDeviceClass-DkfbtsIJ.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { c as getDeviceClass, i as stopRecording$1, n as createRecordingSession, o as checkPermission, r as startRecording, s as requestPermission, t as streamingEvents } from "./streamingEvents-CfEJv3xH.esm.js";
+import { t as api } from "./api-DfRLAneb.esm.js";
+
+//#region ../infra/src/capabilities/ITimerCapability.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/modules/id/idCameraStream.ts
+const BACK_CAMERA_KEYWORDS = [
+	"rear",
+	"back",
+	"rück",
+	"arrière",
+	"trasera",
+	"trás",
+	"traseira",
+	"posteriore",
+	"后面",
+	"後面",
+	"背面",
+	"后置",
+	"後置",
+	"背置",
+	"задней",
+	"الخلفية",
+	"후",
+	"arka",
+	"achterzijde",
+	"หลัง",
+	"baksidan",
+	"bagside",
+	"sau",
+	"bak",
+	"tylny",
+	"takakamera",
+	"belakang",
+	"אחורית",
+	"πίσω",
+	"spate",
+	"hátsó",
+	"zadní",
+	"darrere",
+	"zadná",
+	"задня",
+	"stražnja",
+	"बैक"
+];
+function isBackCameraLabel(label) {
+	const lowercaseLabel = label.toLowerCase();
+	return BACK_CAMERA_KEYWORDS.some((keyword) => lowercaseLabel.includes(keyword));
+}
+function classifyCamera(device, index, totalDevices) {
+	let cameraType;
+	if (device.label === "") cameraType = totalDevices === 1 || index + 1 <= totalDevices / 2 ? "front" : "back";
+	else cameraType = isBackCameraLabel(device.label) ? "back" : "front";
+	return {
+		deviceId: device.deviceId,
+		label: device.label,
+		cameraType
+	};
+}
+async function getCameras() {
+	const videoDevices = await enumerateVideoDevices();
+	const cameras = videoDevices.map((d, i) => classifyCamera(d, i, videoDevices.length));
+	if (cameras.length > 1 && !cameras.some((c) => c.cameraType === "back")) {
+		const resolutions = cameras.map((c) => {
+			const match = c.label.match(/\b([0-9]+)MP?\b/i);
+			return match ? parseInt(match[1], 10) : NaN;
+		});
+		let backCameraIndex = cameras.length - 1;
+		if (!resolutions.some(isNaN)) backCameraIndex = resolutions.lastIndexOf(Math.max(...resolutions));
+		cameras[backCameraIndex].cameraType = "back";
+	}
+	return cameras;
+}
+function selectMainCameraFromStream(track, cameras) {
+	const settings = track.getSettings();
+	const activeCamera = cameras.find((c) => c.deviceId === settings.deviceId || c.label !== "" && c.label === track.label);
+	if (!activeCamera) return void 0;
+	if ((settings.facingMode === "environment" || isBackCameraLabel(track.label)) && cameras.length > 1) {
+		cameras.forEach((camera) => {
+			if (camera.deviceId === activeCamera.deviceId) camera.cameraType = "back";
+			else if (!isBackCameraLabel(camera.label)) camera.cameraType = "front";
+		});
+		return cameras.filter((c) => c.cameraType === "back").sort((a, b) => a.label.localeCompare(b.label))[0];
+	}
+	if (cameras.length === 1) return activeCamera;
+}
+function getAndroidVideoConstraints(level) {
+	const base = {
+		resizeMode: "none",
+		facingMode: "environment"
+	};
+	switch (level) {
+		case 0: return {
+			...base,
+			height: { ideal: 720 },
+			aspectRatio: { ideal: 19.5 / 9 }
+		};
+		case 1: return {
+			...base,
+			width: {
+				min: 3200,
+				ideal: 3840,
+				max: 4096
+			},
+			height: {
+				min: 1800,
+				ideal: 2160,
+				max: 2400
+			}
+		};
+		case 2: return {
+			...base,
+			width: {
+				min: 1400,
+				ideal: 1920,
+				max: 2160
+			},
+			height: {
+				min: 900,
+				ideal: 1080,
+				max: 1440
+			}
+		};
+		case 3: return {
+			...base,
+			width: {
+				min: 640,
+				ideal: 640,
+				max: 800
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 600
+			}
+		};
+		case 4: return {
+			...base,
+			width: {
+				min: 640,
+				ideal: 800,
+				max: 960
+			},
+			height: {
+				min: 480,
+				ideal: 480,
+				max: 480
+			}
+		};
+		default: return {};
+	}
+}
+async function getAndroidBackCameraStream(fallbackLevel = 0) {
+	if (fallbackLevel > 4) throw new Error("Failed to get camera after all fallback attempts");
+	try {
+		const initialStream = await requestCameraAccess({ video: getAndroidVideoConstraints(fallbackLevel) });
+		const track = initialStream.getVideoTracks()[0];
+		const mainCamera = selectMainCameraFromStream(track, await getCameras());
+		stopCameraStream(initialStream);
+		if (!mainCamera) throw new Error("Could not identify main camera");
+		let idealWidth = 1280;
+		let idealHeight = 720;
+		if (fallbackLevel > 1) {
+			const constraints = getAndroidVideoConstraints(fallbackLevel);
+			const width = constraints.width;
+			const height = constraints.height;
+			idealWidth = width?.ideal ?? 1280;
+			idealHeight = height?.ideal ?? 720;
+		}
+		return await requestCameraAccess({ video: {
+			deviceId: { exact: mainCamera.deviceId },
+			width: { ideal: idealWidth },
+			height: { ideal: idealHeight }
+		} });
+	} catch (error) {
+		const errorName = error instanceof Error ? error.name : "UnknownError";
+		const nextLevel = Math.min(fallbackLevel + 1, 4);
+		if (errorName === "NotReadableError") {
+			await sleep(300);
+			return getAndroidBackCameraStream(nextLevel);
+		}
+		if (errorName === "AbortError") {
+			await sleep(300);
+			return getAndroidBackCameraStream(fallbackLevel);
+		}
+		return getAndroidBackCameraStream(nextLevel);
+	}
+}
+async function applyIOSFocusHack(stream) {
+	const videoTrack = stream.getVideoTracks()[0];
+	try {
+		await applyTrackConstraints(videoTrack, { advanced: [{ focusDistance: 1 }] });
+	} catch {}
+}
+function getIOSConstraints() {
+	return {
+		audio: false,
+		video: {
+			resizeMode: "none",
+			facingMode: "environment",
+			height: { ideal: isIPhone14OrHigher() ? 1080 : 720 },
+			aspectRatio: { ideal: 19.5 / 9 }
+		}
+	};
+}
+async function getIOSCameraStream() {
+	const stream = await requestCameraAccess(getIOSConstraints());
+	await applyIOSFocusHack(stream);
+	return stream;
+}
+function getDesktopConstraints(options) {
+	const { deviceId } = options;
+	return {
+		audio: isSafari(),
+		video: {
+			facingMode: "user",
+			deviceId: deviceId ? { exact: deviceId } : void 0,
+			height: { ideal: 1080 },
+			width: { ideal: 1920 }
+		}
+	};
+}
+async function getDesktopCameraStream(options) {
+	return requestCameraAccess(getDesktopConstraints(options));
+}
+async function getIdCameraStream(deviceId) {
+	if (isIOS()) return getIOSCameraStream();
+	if (isAndroid()) return getAndroidBackCameraStream(0);
+	if (isDesktop()) return getDesktopCameraStream({ deviceId });
+	return getDesktopCameraStream({ deviceId });
+}
+
+//#endregion
+//#region src/modules/id/types.ts
+const ID_ERROR_CODES = {
+	UPLOAD_ERROR: "UPLOAD_ERROR",
+	CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED",
+	LOW_SHARPNESS: "LOW_SHARPNESS",
+	GLARE_DETECTED: "GLARE_DETECTED",
+	WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE",
+	ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE",
+	READABILITY_ISSUE: "READABILITY_ISSUE",
+	RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK",
+	RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK",
+	NO_MORE_TRIES: "NO_MORE_TRIES",
+	UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
+	NO_TOKEN: "NO_TOKEN",
+	PERMISSION_DENIED: "PERMISSION_DENIED",
+	USER_CANCELLED: "USER_CANCELLED",
+	SERVER: "SERVER_ERROR"
+};
+
+//#endregion
+//#region src/modules/id/idCaptureServices.ts
+const SHARPNESS_THRESHOLD = 10;
+const GLARE_THRESHOLD = 10;
+const DEFAULT_ID_CAPTURE_THRESHOLDS$1 = {
+	blurThreshold: .2,
+	blurChangeThreshold: .2,
+	glareThreshold: .3,
+	clsThreshold: .98,
+	sideThreshold: .8,
+	iouThreshold: .8,
+	framesAggregationInterval: 3e3,
+	minFaceIdQualityScore: .62
+};
+const DEFAULT_ID_CAPTURE_SETTINGS = {
+	isFixedMask: false,
+	isIPhone14OrHigher: false,
+	idType: "",
+	blurCheckEnabled: false,
+	glareCheckEnabled: false,
+	faceQualityCheckEnabled: true,
+	iouCheckEnabled: true
+};
+async function initializeIdCapture(provider, config) {
+	await provider.initialize({});
+	provider.setThresholds({
+		...DEFAULT_ID_CAPTURE_THRESHOLDS$1,
+		...config.thresholds,
+		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? config.deviceIdleTimeout * 1e3,
+		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? config.autoCaptureTimeout * 1e3
+	});
+	if (config.settings) provider.setSettings({
+		...DEFAULT_ID_CAPTURE_SETTINGS,
+		...config.settings
+	});
+	return {
+		stream: await getIdCameraStream(),
+		provider
+	};
+}
+function stopStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+function validateUploadResponse(response, sessionState) {
+	if (response.failReason === "ID_TYPE_UNACCEPTABLE") return {
+		error: true,
+		message: "ID type is not acceptable",
+		messageDescription: "Please use a valid ID type",
+		errorKey: ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE
+	};
+	if (response.failReason === "WRONG_DOCUMENT_SIDE") return {
+		error: true,
+		message: "Wrong side of document",
+		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
+		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
+	};
+	if (!response.classification) return {
+		error: true,
+		message: "ID classification failed",
+		errorKey: ID_ERROR_CODES.CLASSIFICATION_FAILED
+	};
+	const sharpnessThreshold = getDeviceClass() === "desktop" ? -1 : SHARPNESS_THRESHOLD;
+	if (response.sharpness !== void 0 && sharpnessThreshold >= 0 && response.sharpness < sharpnessThreshold) return {
+		error: true,
+		message: "Image is not sharp enough",
+		messageDescription: "Please ensure the image is clear and well-focused",
+		errorKey: ID_ERROR_CODES.LOW_SHARPNESS
+	};
+	if (response.glare !== void 0 && response.glare < GLARE_THRESHOLD && !sessionState?.skipGlareFront && !sessionState?.skipGlareBack) return {
+		error: true,
+		message: "Glare detected on ID",
+		messageDescription: "Please avoid bright reflections on your ID",
+		errorKey: ID_ERROR_CODES.GLARE_DETECTED
+	};
+}
+async function getExtraImages(params) {
+	const extraImages = params.ageAssurance ? [params.type === "back" ? "croppedBackID" : "croppedFrontID"] : [];
+	try {
+		const res = await api.post(endpoints.getImages, { images: ["croppedIDFace", ...extraImages] }, { signal: params.signal });
+		if (!res.ok) throw new Error(`Failed to get extra images: ${res.status}`);
+		return res.data ?? {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	} catch {
+		return {
+			croppedIDFace: "",
+			croppedFrontID: "",
+			croppedBackID: ""
+		};
+	}
+}
+const getRealQualityValue = (value) => (1 - value) * 100;
+async function uploadIdImage(params) {
+	const { type, image, onProgress, signal, metadata, ageAssurance, glare, sharpness, shouldSkipGlareBack } = params;
+	addEvent({
+		code: "captureAttemptFinished",
+		module: eventModuleNames.id,
+		payload: { logs: [] }
+	});
+	const endpoint = type === "front" ? endpoints.frontId : endpoints.backId;
+	const body = {
+		base64Image: image,
+		metadata,
+		clientInfo: { deviceClass: getDeviceClass() }
+	};
+	const queryParams = { imageType: "id" };
+	if (shouldSkipGlareBack && type === "back") queryParams.glare = 0;
+	else if (glare !== void 0) queryParams.glare = getRealQualityValue(glare);
+	if (sharpness !== void 0) queryParams.sharpness = getRealQualityValue(sharpness);
+	try {
+		const res = await api.post(endpoint, body, {
+			signal,
+			query: queryParams,
+			onUploadProgress: onProgress
+		});
+		if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
+		const response = res.data;
+		const extraImages = await getExtraImages({
+			type,
+			ageAssurance,
+			signal
+		});
+		const fullResponse = {
+			...response,
+			originalImage: image,
+			frontIdImage: type === "front" ? image : void 0,
+			backIdImage: extraImages.croppedBackID,
+			...extraImages
+		};
+		onProgress?.(100);
+		return fullResponse;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
+	}
+}
+function buildStandardResolution(width, height) {
+	return height > width ? {
+		width: 1080,
+		height: 1920
+	} : {
+		width: 1920,
+		height: 1080
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return "1080x1920";
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") {
+		const standard = buildStandardResolution(width, height);
+		return `${standard.width}x${standard.height}`;
+	}
+	return "1080x1920";
+}
+async function startRecordingSession(params) {
+	if (params.config.enableIdRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability ?? new OpenViduRecordingProvider();
+	const clonedStream = params.stream.clone();
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession(params.type);
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {
+			onSessionConnected: (sessionId) => {
+				addEvent({
+					code: streamingEvents.strSessionDidConnect,
+					module: eventModuleNames.id,
+					payload: {
+						message: "Recording session connected",
+						sessionId
+					}
+				});
+			},
+			onSessionDisconnected: (sessionId) => {
+				addEvent({
+					code: streamingEvents.strSessionDidDisconnect,
+					module: eventModuleNames.id,
+					payload: {
+						message: "Recording session disconnected",
+						sessionId
+					}
+				});
+			},
+			onSessionException: (event) => {
+				addEvent({
+					code: streamingEvents.strSessionDidFailWithError,
+					module: eventModuleNames.id,
+					payload: {
+						message: "Recording session failed due to an error",
+						eventName: event.name,
+						type: "OpenViduException",
+						errorMessage: event.message,
+						sessionId: event.sessionId
+					}
+				});
+			},
+			onPublisherCreated: (p) => {
+				addEvent({
+					code: streamingEvents.strStreamPublisherCreated,
+					module: eventModuleNames.id,
+					payload: {
+						message: "Recording publisher created",
+						sessionId: p.sessionId,
+						streamId: p.streamId
+					}
+				});
+			},
+			onPublisherError: (p) => {
+				addEvent({
+					code: streamingEvents.strStreamPublisherDidFailWithError,
+					module: eventModuleNames.id,
+					payload: {
+						message: "Recording publisher failed due to an error",
+						sessionId: p.sessionId,
+						streamId: p.streamId,
+						error: { message: p.message ?? "Unknown error" }
+					}
+				});
+			}
+		}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: params.type,
+		resolution,
+		hasAudio
+	});
+	addEvent({
+		code: streamingEvents.strStreamVideoCaptureStart,
+		module: eventModuleNames.id,
+		payload: {
+			message: "Recording capture started",
+			resolution,
+			videoRecordingId: session.videoRecordingId,
+			sessionId: session.sessionId,
+			streamId: connection.publisher.getStreamId()
+		}
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+function stopRecording(session) {
+	(async () => {
+		try {
+			addEvent({
+				code: streamingEvents.strStreamVideoCaptureStop,
+				module: eventModuleNames.id,
+				payload: {
+					message: "Recording capture stopped",
+					videoRecordingId: session.videoRecordingId,
+					sessionId: session.sessionId,
+					streamId: session.connection.publisher.getStreamId()
+				}
+			});
+			await stopRecording$1(session.videoRecordingId);
+			addEvent({
+				code: streamingEvents.strStreamPublisherDestroyed,
+				module: eventModuleNames.id,
+				payload: {
+					message: "Recording publisher destroyed",
+					sessionId: session.sessionId,
+					streamId: session.connection.publisher.getStreamId()
+				}
+			});
+		} finally {
+			await session.connection.disconnect();
+			addEvent({
+				code: streamingEvents.strSessionDidDisconnect,
+				module: eventModuleNames.id,
+				payload: {
+					message: "Recording session disconnected",
+					sessionId: session.sessionId
+				}
+			});
+		}
+	})();
+}
+async function processId(isSecondId = false, queueName = "", signal) {
+	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
+	const url = queueName ? `${endpoint}?queueName=${queueName}` : endpoint;
+	return { isDocumentExpired: (await api.post(url, {}, { signal })).data?.isDocumentExpired ?? false };
+}
+
+//#endregion
+//#region src/modules/id/idCaptureStateMachine.ts
+function getIdErrorCodeFromUnknown(error) {
+	if (error instanceof Error) {
+		const message = error.message;
+		return Object.values(ID_ERROR_CODES).find((value) => message.includes(value));
+	}
+}
+const _idCaptureMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		checkPermission: fromPromise(async () => {
+			return checkPermission();
+		}),
+		requestPermission: fromPromise(async () => {
+			return requestPermission();
+		}),
+		initializeCamera: fromPromise(async ({ input }) => {
+			return initializeIdCapture(input.provider, input.config);
+		}),
+		runDetection: fromCallback(({ input, sendBack }) => {
+			if (!input.frameCapturer || !input.provider) {
+				sendBack({
+					type: "DETECTION_UPDATE",
+					status: "error"
+				});
+				return () => {};
+			}
+			const provider = input.provider;
+			let session;
+			let currentCanvas = null;
+			let bestCanvas = null;
+			let storedQualityElements = {};
+			let isCapturing = false;
+			const timer = BrowserTimerProvider.getInstance();
+			let notificationTimeout = null;
+			let currentNotificationStatus = null;
+			const NOTIFICATION_DURATION_MS = 500;
+			const clearNotificationTimeout = () => {
+				if (notificationTimeout) {
+					timer.clearTimeout(notificationTimeout);
+					notificationTimeout = null;
+					currentNotificationStatus = null;
+				}
+			};
+			const sendNotification = (status) => {
+				if (notificationTimeout && currentNotificationStatus !== status) return;
+				if (notificationTimeout && currentNotificationStatus === status) timer.clearTimeout(notificationTimeout);
+				currentNotificationStatus = status;
+				sendBack({
+					type: "DETECTION_UPDATE",
+					status
+				});
+				notificationTimeout = timer.setTimeout(() => {
+					notificationTimeout = null;
+					currentNotificationStatus = null;
+					sendBack({
+						type: "DETECTION_UPDATE",
+						status: "detecting"
+					});
+				}, NOTIFICATION_DURATION_MS);
+			};
+			const canvas = input.frameCapturer.getLatestCanvas();
+			const windowDimensions = getWindowDimensions(canvas?.width() ?? 1280, canvas?.height() ?? 720);
+			const DEFAULT_GEOMETRY = {
+				areaDown: 25e3,
+				areaUp: 55e3,
+				areaIOSPassportUp: 3e4,
+				areaIOSPassportDown: 2e4,
+				widthIOSUp: 160,
+				widthIOSDown: 85,
+				widthDown: 110,
+				widthUp: 205
+			};
+			if (input.config.geometry) provider.setGeometry({
+				...input.config.geometry,
+				windowOuterWidth: windowDimensions.outerWidth,
+				windowOuterHeight: windowDimensions.outerHeight,
+				windowInnerWidth: windowDimensions.innerWidth,
+				windowInnerHeight: windowDimensions.innerHeight
+			});
+			else provider.setGeometry({
+				...DEFAULT_GEOMETRY,
+				windowOuterWidth: windowDimensions.outerWidth,
+				windowOuterHeight: windowDimensions.outerHeight,
+				windowInnerWidth: windowDimensions.innerWidth,
+				windowInnerHeight: windowDimensions.innerHeight
+			});
+			const idType = input.currentMode === "back" ? "BackId" : input.currentMode === "passport" || input.currentMode === "front" && input.config.onlyFront ? "Passport" : "FrontId";
+			provider.setSettings({
+				isFixedMask: input.config.settings?.isFixedMask ?? false,
+				isIPhone14OrHigher: input.config.settings?.isIPhone14OrHigher ?? false,
+				idType,
+				blurCheckEnabled: input.config.settings?.blurCheckEnabled ?? false,
+				glareCheckEnabled: input.config.settings?.glareCheckEnabled ?? false,
+				faceQualityCheckEnabled: input.config.settings?.faceQualityCheckEnabled ?? true,
+				iouCheckEnabled: input.config.settings?.iouCheckEnabled ?? true
+			});
+			const thresholds = {
+				...DEFAULT_ID_CAPTURE_THRESHOLDS,
+				...input.config.thresholds,
+				idDetectedTimeout: (input.config.deviceIdleTimeout ?? 10) * 1e3,
+				autocaptureTimeout: (input.config.autoCaptureTimeout ?? 5) * 1e3
+			};
+			provider.setThresholds(thresholds);
+			const modelType = input.config.modelVersion ?? DEFAULT_ID_CAPTURE_MODEL_VERSION;
+			provider.setModelType(modelType);
+			provider.setCallbacks({
+				onFarAway: () => {
+					if (!isCapturing) sendNotification("farAway");
+				},
+				onDetectionStarted: () => {},
+				onMaskChange: (_show, _mask, _top, orientation) => {
+					sendBack({
+						type: "ORIENTATION_CHANGE",
+						orientation
+					});
+				},
+				onBlur: () => {
+					if (!isCapturing) sendNotification("blur");
+				},
+				onGlare: () => {
+					if (!isCapturing) sendNotification("glare");
+				},
+				onIdNotDetected: () => {
+					if (!isCapturing) sendBack({
+						type: "DETECTION_UPDATE",
+						status: "idNotDetected"
+					});
+				},
+				onSwitchToManualCapture: () => {
+					isCapturing = false;
+					sendBack({
+						type: "DETECTION_UPDATE",
+						status: "manualCapture"
+					});
+				},
+				onCapturing: () => {
+					clearNotificationTimeout();
+					isCapturing = true;
+					sendBack({
+						type: "DETECTION_UPDATE",
+						status: "capturing"
+					});
+				},
+				onBestFrame: (blur, glare, orientation) => {
+					if (currentCanvas) {
+						bestCanvas = currentCanvas.clone();
+						storedQualityElements = {
+							glare,
+							sharpness: blur
+						};
+					}
+					if (orientation === "horizontal" || orientation === "vertical") sendBack({
+						type: "ORIENTATION_CHANGE",
+						orientation
+					});
+				},
+				onCapture: () => {
+					isCapturing = false;
+					if (bestCanvas) sendBack({
+						type: "DETECTION_SUCCESS",
+						canvas: bestCanvas,
+						qualityElements: storedQualityElements
+					});
+					else if (currentCanvas) sendBack({
+						type: "DETECTION_SUCCESS",
+						canvas: currentCanvas.clone(),
+						qualityElements: {}
+					});
+				},
+				onIdTypeChange: (idType$1) => {
+					sendBack({
+						type: "ID_TYPE_CHANGE",
+						idType: idType$1
+					});
+				},
+				onIdSideChange: (side) => {
+					if (isCapturing) return;
+					sendBack({
+						type: "ID_SIDE_CHANGE",
+						side
+					});
+				},
+				onCapturingCounterValueChange: (value) => {
+					sendBack({
+						type: "COUNTER_VALUE_CHANGE",
+						value
+					});
+				}
+			});
+			sendBack({
+				type: "DETECTION_UPDATE",
+				status: "detecting"
+			});
+			session = new StreamCanvasProcessingSession({
+				capturer: input.frameCapturer,
+				provider: {
+					processFrame: async (frame) => {
+						currentCanvas = IncodeCanvas.fromImageData(frame);
+						sendBack({
+							type: "DETECTION_FRAME",
+							frame
+						});
+						await provider.processFrame(frame);
+					},
+					reset: () => {
+						if (notificationTimeout) {
+							timer.clearTimeout(notificationTimeout);
+							notificationTimeout = null;
+							currentNotificationStatus = null;
+						}
+						currentCanvas = null;
+						bestCanvas = null;
+						storedQualityElements = {};
+						isCapturing = false;
+						provider.reset();
+					}
+				},
+				onFrame: (frame) => sendBack({
+					type: "DETECTION_FRAME",
+					frame
+				})
+			});
+			sendBack({
+				type: "DETECTION_RESET_READY",
+				reset: () => {
+					provider.reset();
+				}
+			});
+			return () => {
+				clearNotificationTimeout();
+				session?.dispose();
+			};
+		}),
+		uploadIdImage: fromPromise(async ({ input, signal }) => {
+			const image = input.canvas.getBase64Image();
+			if (!image) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
+			return uploadIdImage({
+				image,
+				type: input.type,
+				sendBase64: true,
+				glare: input.qualityElements?.glare,
+				sharpness: input.qualityElements?.sharpness,
+				ageAssurance: false,
+				signal,
+				onProgress: input.onProgress
+			});
+		}),
+		processId: fromPromise(async ({ input, signal }) => {
+			return processId(input.isSecondId, "", signal);
+		}),
+		startRecording: fromPromise(async ({ input }) => {
+			if (!input.stream) return;
+			const type = input.currentMode === "back" ? "backId" : "frontId";
+			return startRecordingSession({
+				config: input.config,
+				stream: input.stream,
+				existing: input.existing,
+				type
+			});
+		}),
+		checkMotionSensor: fromCallback(({ input, sendBack }) => {
+			if (!input.motionProvider) {
+				sendBack({
+					type: "MOTION_STATUS",
+					status: "UNCLEAR"
+				});
+				return () => {};
+			}
+			const timer = BrowserTimerProvider.getInstance();
+			const interval = timer.setInterval(() => {
+				sendBack({
+					type: "MOTION_STATUS",
+					status: input.motionProvider.check()
+				});
+			}, 500);
+			return () => timer.clearInterval(interval);
+		})
+	},
+	actions: {
+		stopMediaStream: assign(({ context }) => {
+			context.frameCapturer?.dispose();
+			if (context.stream) stopStream(context.stream);
+			return {
+				stream: void 0,
+				frameCapturer: void 0
+			};
+		}),
+		disposeProvider: ({ context }) => {
+			context.provider?.dispose?.();
+		},
+		resetForBackCapture: assign(({ context }) => {
+			context.frameCapturer?.dispose();
+			if (context.stream) stopStream(context.stream);
+			context.provider?.reset();
+			return {
+				stream: void 0,
+				frameCapturer: void 0,
+				detectionStatus: "idle",
+				counterValue: 0,
+				orientation: void 0,
+				resetDetection: void 0,
+				idType: void 0,
+				qualityElements: void 0,
+				debugFrame: void 0,
+				frameRect: void 0,
+				previewImageUrl: void 0,
+				uploadProgress: void 0,
+				manualCaptureTriggered: false
+			};
+		}),
+		prepareForBackCapture: assign(({ context }) => {
+			context.provider?.reset();
+			return {
+				detectionStatus: "idle",
+				counterValue: 0,
+				orientation: void 0,
+				resetDetection: void 0,
+				idType: void 0,
+				qualityElements: void 0,
+				debugFrame: void 0,
+				frameRect: void 0,
+				previewImageUrl: void 0,
+				uploadProgress: void 0,
+				manualCaptureTriggered: 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) {
+					const output = event.output;
+					if (output.stream) return new StreamCanvasCapture(output.stream);
+				}
+			}
+		}),
+		trackTutorialId: () => {
+			addEvent({
+				code: "tutorialVideoStarted",
+				module: eventModuleNames.id,
+				payload: { tutorialFrontID: true }
+			});
+		},
+		trackContinue: () => {},
+		resetContext: assign(({ context }) => {
+			context.provider?.reset();
+			return {
+				stream: void 0,
+				provider: context.provider,
+				frameCapturer: void 0,
+				error: void 0,
+				detectionStatus: "idle",
+				counterValue: 0,
+				orientation: void 0,
+				capturedImages: {},
+				uploadResponse: void 0,
+				recordingSession: void 0,
+				attemptsRemaining: context.config.captureAttempts,
+				uploadError: void 0,
+				permissionResult: void 0,
+				resetDetection: void 0,
+				idType: void 0,
+				qualityElements: void 0,
+				previewImageUrl: void 0,
+				uploadProgress: void 0,
+				currentMode: context.config.onlyBack ? "back" : !context.config.enableId && context.config.enablePassport ? "passport" : "front",
+				selectedDocumentType: void 0,
+				manualCaptureTriggered: false
+			};
+		}),
+		resetDetection: ({ context }) => {
+			context.resetDetection?.();
+		},
+		captureImage: assign({ qualityElements: ({ event }) => {
+			if ("qualityElements" in event) return event.qualityElements;
+		} }),
+		storeCapturedCanvasInProvider: ({ context, event }) => {
+			let canvas = null;
+			if ("canvas" in event && event.canvas) canvas = event.canvas;
+			else canvas = context.frameCapturer?.getLatestCanvas() ?? null;
+			if (!canvas || !context.provider) return;
+			const canvasWidth = canvas.width();
+			const canvasHeight = canvas.height();
+			if (!canvasWidth || !canvasHeight) return;
+			const originalCanvas = canvas;
+			let frameRect;
+			const { innerWidth: viewportWidth, innerHeight: viewportHeight } = getWindowDimensions();
+			if (context.detectionArea) {
+				const scaleX = viewportWidth / canvasWidth;
+				const scaleY = viewportHeight / canvasHeight;
+				const scale = Math.max(scaleX, scaleY);
+				const displayedWidth = canvasWidth * scale;
+				const displayedHeight = canvasHeight * scale;
+				const offsetX = (viewportWidth - displayedWidth) / 2;
+				const offsetY = (viewportHeight - displayedHeight) / 2;
+				frameRect = {
+					x: (context.detectionArea.x - offsetX) / scale,
+					y: (context.detectionArea.y - offsetY) / scale,
+					w: context.detectionArea.width / scale,
+					h: context.detectionArea.height / scale
+				};
+			} else if (context.frameRect) {
+				const scaleX = viewportWidth / canvasWidth;
+				const scaleY = viewportHeight / canvasHeight;
+				const scale = Math.max(scaleX, scaleY);
+				const displayedWidth = canvasWidth * scale;
+				const displayedHeight = canvasHeight * scale;
+				const offsetX = (viewportWidth - displayedWidth) / 2;
+				const offsetY = (viewportHeight - displayedHeight) / 2;
+				frameRect = {
+					x: (context.frameRect.x - offsetX) / scale,
+					y: (context.frameRect.y - offsetY) / scale,
+					w: context.frameRect.w / scale,
+					h: context.frameRect.h / scale
+				};
+			} else {
+				const quadValue = (context.provider.getLastProcessResult?.())?.quad;
+				const hasQuad = !!quadValue;
+				const quadSize = quadValue?.size ? quadValue.size() : quadValue?.length ?? 0;
+				if (hasQuad && quadSize >= 4 && quadValue.get) {
+					const p0 = quadValue.get(0);
+					const p1 = quadValue.get(1);
+					const p2 = quadValue.get(2);
+					const p3 = quadValue.get(3);
+					const minX = Math.min(p0.x, p1.x, p2.x, p3.x);
+					const maxX = Math.max(p0.x, p1.x, p2.x, p3.x);
+					const minY = Math.min(p0.y, p1.y, p2.y, p3.y);
+					const maxY = Math.max(p0.y, p1.y, p2.y, p3.y);
+					frameRect = {
+						x: minX,
+						y: minY,
+						w: maxX - minX,
+						h: maxY - minY
+					};
+				} else {
+					const frameViewportWidth = Math.min(387, viewportWidth * .9);
+					const frameViewportHeight = frameViewportWidth / (35 / 22);
+					const frameViewportX = (viewportWidth - frameViewportWidth) / 2;
+					const frameViewportY = (viewportHeight - frameViewportHeight) / 2;
+					frameRect = {
+						x: canvasWidth * frameViewportX / viewportWidth,
+						y: canvasHeight * frameViewportY / viewportHeight,
+						w: canvasWidth * frameViewportWidth / viewportWidth,
+						h: canvasHeight * frameViewportHeight / viewportHeight
+					};
+				}
+			}
+			const transformedCanvas = context.provider.transformPerspective(originalCanvas, frameRect);
+			context.provider.setCapturedCanvases(originalCanvas, transformedCanvas);
+		},
+		captureLatestFrame: ({ context }) => {
+			context.frameCapturer?.getLatestCanvas();
+		},
+		clearUploadFailure: assign({
+			uploadError: () => void 0,
+			detectionStatus: () => "idle",
+			previewImageUrl: ({ context }) => {
+				if (context.previewImageUrl) revokeObjectURL(context.previewImageUrl);
+			},
+			uploadProgress: () => void 0
+		}),
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => {
+			if (!context.uploadResponse) return ID_ERROR_CODES.SERVER;
+			return validateUploadResponse(context.uploadResponse, {
+				skipGlareFront: context.uploadResponse.skipGlareFront,
+				skipGlareBack: context.uploadResponse.skipGlareBack
+			})?.errorKey ?? ID_ERROR_CODES.SERVER;
+		} }),
+		stopMediaRecording: ({ context }) => {
+			if (context.recordingSession) stopRecording(context.recordingSession);
+		},
+		clearRecordingSession: assign({ recordingSession: () => void 0 }),
+		setSelectedDocument: assign({ selectedDocumentType: ({ event }) => {
+			if ("documentType" in event) return event.documentType;
+		} }),
+		setCurrentMode: assign({ currentMode: ({ event, context }) => {
+			if ("documentType" in event) {
+				if (event.documentType === "passport") return "passport";
+				return "front";
+			}
+			if (event.type === "FRONT_COMPLETE") return "back";
+			return context.currentMode;
+		} }),
+		storeCapturedImage: assign({
+			capturedImages: ({ context, event }) => {
+				if (!context.currentMode) return context.capturedImages;
+				const transformedImage = (context.provider?.getCapturedCanvas())?.getBase64Image(1, true);
+				let fallbackImage = "";
+				if ("output" in event) fallbackImage = event.output.originalImage ?? "";
+				const imageData = { imageBase64: transformedImage ?? fallbackImage };
+				if (context.currentMode === "front" || context.currentMode === "passport") return {
+					...context.capturedImages,
+					front: imageData
+				};
+				return {
+					...context.capturedImages,
+					back: imageData
+				};
+			},
+			previewImageUrl: ({ context, event }) => {
+				const transformedCanvas = context.provider?.getCapturedCanvas();
+				if (transformedCanvas) {
+					transformedCanvas.updateBlob();
+					const blobData = transformedCanvas.getBlobData();
+					if (blobData?.url) return blobData.url;
+				}
+				if ("canvas" in event && event.canvas) {
+					const canvas = event.canvas;
+					canvas.updateBlob();
+					const blobData = canvas.getBlobData();
+					if (blobData?.url) return blobData.url;
+				}
+				return context.previewImageUrl;
+			}
+		}),
+		setDetectionStatus: assign({ detectionStatus: ({ event, context }) => {
+			if (event.type === "DETECTION_UPDATE") {
+				const newStatus = event.status;
+				const currentStatus = context.detectionStatus;
+				if ((newStatus === "blur" || newStatus === "glare") && (currentStatus === "wrongSide" || currentStatus === "farAway")) return currentStatus;
+				if ((newStatus === "wrongSide" || newStatus === "farAway") && (currentStatus === "blur" || currentStatus === "glare")) return newStatus;
+				return newStatus;
+			}
+			return "idle";
+		} }),
+		setCounterValue: assign({ counterValue: ({ event }) => {
+			if ("value" in event) return event.value;
+			return 0;
+		} }),
+		setIdType: assign({ idType: ({ event }) => {
+			if ("idType" in event) return event.idType;
+		} }),
+		setOrientation: assign({ orientation: ({ event }) => {
+			if ("orientation" in event) return event.orientation;
+		} }),
+		setFrameRect: assign({ frameRect: ({ event }) => {
+			if ("frameRect" in event) return event.frameRect;
+		} }),
+		setDetectionArea: assign({ detectionArea: ({ event }) => {
+			if ("detectionArea" in event) return event.detectionArea;
+		} }),
+		setMotionStatus: assign({ motionStatus: ({ event }) => {
+			if ("status" in event && event.type === "MOTION_STATUS") return event.status;
+		} })
+	},
+	guards: {
+		hasShowTutorial: ({ context }) => context.config.showTutorial,
+		hasShowDocumentChooser: ({ context }) => context.config.showDocumentChooserScreen ?? false,
+		isPermissionGranted: ({ event }) => {
+			if ("output" in event) return event.output === "granted";
+			return false;
+		},
+		isPermissionDeniedError: ({ event }) => {
+			if ("error" in event) {
+				const error = event.error;
+				return error?.name === "NotAllowedError" || error?.name === "PermissionDeniedError";
+			}
+			return false;
+		},
+		hasStream: ({ context }) => context.stream !== void 0,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
+		hasCapturedImage: ({ context }) => {
+			return context.provider?.getCapturedCanvas() !== null;
+		},
+		hasUploadValidationError: ({ context }) => {
+			if (!context.uploadResponse) return false;
+			return validateUploadResponse(context.uploadResponse, {
+				skipGlareFront: context.uploadResponse.skipGlareFront,
+				skipGlareBack: context.uploadResponse.skipGlareBack
+			}) !== void 0;
+		},
+		isFrontMode: ({ context }) => context.currentMode === "front" || context.currentMode === "passport",
+		isOnlyFront: ({ context }) => context.config.onlyFront,
+		shouldContinueToBack: ({ context }) => {
+			if (context.currentMode === "passport") return false;
+			if (context.currentMode !== "front") return false;
+			if (context.config.onlyFront) return false;
+			if (context.config.onlyBack) return false;
+			if (!context.config.enableId && context.config.enablePassport) return false;
+			if (context.uploadResponse?.skipBackIdCapture) return false;
+			return true;
+		}
+	}
+}).createMachine({
+	id: "idCapture",
+	initial: "idle",
+	context: ({ input }) => {
+		const currentMode = input.config.onlyBack ? "back" : !input.config.enableId && input.config.enablePassport ? "passport" : "front";
+		return {
+			config: input.config,
+			currentMode,
+			selectedDocumentType: void 0,
+			stream: void 0,
+			provider: input.provider,
+			frameCapturer: void 0,
+			error: void 0,
+			detectionStatus: "idle",
+			counterValue: 0,
+			orientation: void 0,
+			capturedImages: {},
+			uploadResponse: void 0,
+			recordingSession: void 0,
+			attemptsRemaining: input.config.captureAttempts,
+			uploadError: void 0,
+			permissionResult: void 0,
+			resetDetection: void 0,
+			idType: void 0,
+			qualityElements: void 0,
+			debugFrame: void 0,
+			frameRect: void 0,
+			detectionArea: void 0,
+			previewImageUrl: void 0,
+			uploadProgress: void 0,
+			motionStatus: void 0,
+			manualCaptureTriggered: false
+		};
+	},
+	on: {
+		QUIT: { target: "#idCapture.closed" },
+		UPDATE_DETECTION_AREA: { actions: "setDetectionArea" }
+	},
+	states: {
+		idle: { on: { LOAD: [
+			{
+				target: "chooser",
+				guard: "hasShowDocumentChooser"
+			},
+			{
+				target: "tutorial",
+				guard: "hasShowTutorial"
+			},
+			{ target: "loading" }
+		] } },
+		chooser: { on: { SELECT_DOCUMENT: [{
+			target: "tutorial",
+			guard: "hasShowTutorial",
+			actions: ["setSelectedDocument", "setCurrentMode"]
+		}, {
+			target: "loading",
+			actions: ["setSelectedDocument", "setCurrentMode"]
+		}] } },
+		loading: { invoke: {
+			id: "checkPermissionLoading",
+			src: "checkPermission",
+			onDone: [{
+				target: "capture",
+				guard: "isPermissionGranted",
+				actions: assign({ permissionResult: ({ event }) => event.output })
+			}, {
+				target: "permissions",
+				actions: assign({ permissionResult: ({ event }) => event.output })
+			}],
+			onError: {
+				target: "permissions",
+				actions: assign({ permissionResult: () => "prompt" })
+			}
+		} },
+		tutorial: {
+			initial: "checkingPermission",
+			entry: "trackTutorialId",
+			states: {
+				checkingPermission: {
+					invoke: {
+						id: "checkPermissionTutorial",
+						src: "checkPermission",
+						onDone: [{
+							target: "initializingCamera",
+							guard: "isPermissionGranted",
+							actions: assign({ permissionResult: ({ event }) => event.output })
+						}, {
+							target: "ready",
+							actions: assign({ permissionResult: ({ event }) => event.output })
+						}]
+					},
+					on: { NEXT_STEP: {
+						target: "initializingCamera",
+						actions: "trackContinue"
+					} }
+				},
+				initializingCamera: {
+					initial: "booting",
+					invoke: {
+						id: "tutorialInitCamera",
+						src: "initializeCamera",
+						input: ({ context }) => {
+							if (!context.provider) throw new Error("Provider is required");
+							return {
+								provider: context.provider,
+								config: context.config
+							};
+						},
+						onDone: { actions: "setStreamAndCapturer" },
+						onError: [{
+							target: "ready",
+							guard: "isPermissionDeniedError",
+							actions: assign({ permissionResult: () => "denied" })
+						}, {
+							target: "ready",
+							actions: assign({ error: ({ event }) => String(event.error) })
+						}]
+					},
+					states: {
+						booting: {
+							always: [{
+								target: "#tutorialCameraReady",
+								guard: "hasStream"
+							}],
+							on: { NEXT_STEP: {
+								target: "waitingForStream",
+								actions: "trackContinue"
+							} }
+						},
+						waitingForStream: { always: [{
+							target: "#idCapture.capture",
+							guard: "hasStream"
+						}] }
+					}
+				},
+				cameraReady: {
+					id: "tutorialCameraReady",
+					on: { NEXT_STEP: {
+						target: "#idCapture.capture",
+						actions: "trackContinue"
+					} }
+				},
+				ready: { on: { NEXT_STEP: {
+					target: "waitingForPermission",
+					actions: "trackContinue"
+				} } },
+				waitingForPermission: { invoke: {
+					id: "checkPermissionWaiting",
+					src: "checkPermission",
+					onDone: [{
+						target: "#idCapture.capture",
+						guard: "isPermissionGranted",
+						actions: assign({ permissionResult: ({ event }) => event.output })
+					}, {
+						target: "#idCapture.permissions",
+						actions: assign({ permissionResult: ({ event }) => event.output })
+					}]
+				} }
+			}
+		},
+		permissions: {
+			initial: "idle",
+			states: {
+				idle: {
+					invoke: {
+						id: "checkPermissionIdle",
+						src: "checkPermission",
+						onDone: [
+							{
+								target: "#idCapture.capture",
+								guard: "isPermissionGranted",
+								actions: assign({ permissionResult: ({ event }) => event.output })
+							},
+							{
+								target: "denied",
+								guard: ({ event }) => event.output === "denied",
+								actions: assign({ permissionResult: ({ event }) => event.output })
+							},
+							{
+								target: "waitingForUser",
+								actions: assign({ permissionResult: ({ event }) => event.output })
+							}
+						],
+						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"
+				} },
+				learnMore: { on: {
+					BACK: "idle",
+					REQUEST_PERMISSION: "requesting"
+				} },
+				requesting: { invoke: {
+					id: "requestPermission",
+					src: "requestPermission",
+					onDone: [
+						{
+							target: "#idCapture.capture",
+							guard: "isPermissionGranted",
+							actions: assign({ permissionResult: ({ event }) => event.output })
+						},
+						{
+							target: "denied",
+							guard: ({ event }) => event.output === "denied",
+							actions: assign({ permissionResult: ({ event }) => event.output })
+						},
+						{
+							target: "idle",
+							actions: assign({ permissionResult: ({ event }) => event.output })
+						}
+					],
+					onError: { target: "denied" }
+				} },
+				denied: { entry: assign({ permissionResult: () => "refresh" }) }
+			}
+		},
+		capture: {
+			initial: "checkingStream",
+			exit: ["stopMediaRecording", "clearRecordingSession"],
+			on: { SET_FRAME_RECT: { actions: "setFrameRect" } },
+			states: {
+				checkingStream: { always: [{
+					target: "detecting",
+					guard: "hasStream"
+				}, { target: "initializing" }] },
+				initializing: { invoke: {
+					id: "initializeCamera",
+					src: "initializeCamera",
+					input: ({ context }) => {
+						if (!context.provider) throw new Error("Provider is required");
+						return {
+							provider: context.provider,
+							config: context.config
+						};
+					},
+					onDone: {
+						target: "detecting",
+						actions: "setStreamAndCapturer"
+					},
+					onError: [{
+						target: "#idCapture.permissions",
+						guard: "isPermissionDeniedError",
+						actions: assign({ permissionResult: () => "denied" })
+					}, {
+						target: "#idCapture.error",
+						actions: assign({ error: ({ event }) => String(event.error) })
+					}]
+				} },
+				detecting: {
+					always: [{
+						target: "manualCaptureWaiting",
+						guard: ({ context }) => context.manualCaptureTriggered,
+						actions: assign({ detectionStatus: () => "manualCapture" })
+					}],
+					entry: [assign({ detectionStatus: () => "detecting" })],
+					invoke: [{
+						id: "startRecording",
+						src: "startRecording",
+						input: ({ context }) => ({
+							config: context.config,
+							stream: context.stream,
+							existing: context.recordingSession,
+							currentMode: context.currentMode
+						}),
+						onDone: { actions: assign({ recordingSession: ({ context, event }) => {
+							return event.output ?? context.recordingSession;
+						} }) },
+						onError: { actions: () => void 0 }
+					}, {
+						id: "runDetection",
+						src: "runDetection",
+						input: ({ context }) => ({
+							frameCapturer: context.frameCapturer,
+							provider: context.provider,
+							config: context.config,
+							currentMode: context.currentMode,
+							detectionArea: context.detectionArea ?? context.config.detectionArea
+						})
+					}],
+					on: {
+						DETECTION_UPDATE: { actions: "setDetectionStatus" },
+						DETECTION_FRAME: { actions: assign({ debugFrame: ({ event }) => event.frame }) },
+						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
+						DETECTION_SUCCESS: {
+							target: "capturing",
+							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
+						},
+						MANUAL_CAPTURE: { target: "capturingManual" },
+						SWITCH_TO_MANUAL_CAPTURE: {
+							target: "manualCaptureWaiting",
+							actions: assign({
+								detectionStatus: () => "manualCapture",
+								manualCaptureTriggered: () => true
+							})
+						},
+						COUNTER_VALUE_CHANGE: { actions: "setCounterValue" },
+						ID_TYPE_CHANGE: { actions: "setIdType" },
+						ID_SIDE_CHANGE: { actions: assign({ detectionStatus: ({ event, context }) => {
+							const detectedSide = event.side?.toLowerCase() || "";
+							const currentMode = context.currentMode;
+							if (detectedSide === "wrong") return "wrongSide";
+							const isBackDetected = detectedSide.includes("back") && !detectedSide.includes("front");
+							const isFrontDetected = detectedSide.includes("front") && !detectedSide.includes("back");
+							if (currentMode === "front" && isBackDetected || currentMode === "back" && isFrontDetected) return "wrongSide";
+							if (currentMode === "front" && isFrontDetected || currentMode === "back" && isBackDetected || currentMode === "passport") return "detecting";
+							return "detecting";
+						} }) },
+						ORIENTATION_CHANGE: { actions: "setOrientation" }
+					}
+				},
+				manualCaptureWaiting: { on: { MANUAL_CAPTURE: { target: "capturingManual" } } },
+				capturing: {
+					entry: [
+						"captureImage",
+						"storeCapturedCanvasInProvider",
+						"storeCapturedImage"
+					],
+					always: [{
+						target: "uploading",
+						guard: "hasCapturedImage"
+					}, {
+						target: "uploadError",
+						actions: assign(({ context }) => ({
+							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
+							attemptsRemaining: context.attemptsRemaining - 1
+						}))
+					}]
+				},
+				capturingManual: {
+					entry: [
+						"captureLatestFrame",
+						"storeCapturedCanvasInProvider",
+						"storeCapturedImage"
+					],
+					always: [{
+						target: "uploading",
+						guard: "hasCapturedImage"
+					}, {
+						target: "uploadError",
+						actions: assign(({ context }) => ({
+							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
+							attemptsRemaining: context.attemptsRemaining - 1
+						}))
+					}]
+				},
+				uploading: {
+					entry: assign({ uploadProgress: () => 0 }),
+					invoke: {
+						id: "uploadIdImage",
+						src: "uploadIdImage",
+						input: ({ context, self }) => {
+							const canvas = context.provider?.getOriginalCapturedCanvas();
+							if (!canvas) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
+							return {
+								canvas,
+								type: context.currentMode === "back" ? "back" : "front",
+								qualityElements: context.qualityElements,
+								onProgress: (progress) => {
+									self.send({
+										type: "UPLOAD_PROGRESS",
+										progress
+									});
+								}
+							};
+						},
+						onDone: {
+							target: "validatingUpload",
+							actions: [assign({
+								uploadResponse: ({ event }) => event.output,
+								uploadProgress: () => 100
+							}), "storeCapturedImage"]
+						},
+						onError: {
+							target: "uploadError",
+							actions: assign(({ context, event }) => ({
+								uploadError: getIdErrorCodeFromUnknown(event.error) ?? ID_ERROR_CODES.UPLOAD_ERROR,
+								attemptsRemaining: context.attemptsRemaining - 1
+							}))
+						}
+					},
+					on: { UPLOAD_PROGRESS: { actions: assign({ uploadProgress: ({ event }) => event.progress }) } }
+				},
+				validatingUpload: { always: [{
+					target: "uploadError",
+					guard: "hasUploadValidationError",
+					actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
+				}, { target: "success" }] },
+				uploadError: { on: { CONTINUE_FROM_ERROR: [
+					{
+						target: "detecting",
+						guard: "hasAttemptsRemaining",
+						actions: [
+							"resetDetection",
+							"clearUploadFailure",
+							assign({ manualCaptureTriggered: () => false })
+						]
+					},
+					{
+						target: "#idCapture.frontFinished",
+						guard: "shouldContinueToBack"
+					},
+					{ target: "#idCapture.finished" }
+				] } },
+				success: { on: { NEXT_STEP: [{
+					target: "#idCapture.frontFinished",
+					guard: "shouldContinueToBack"
+				}, { target: "#idCapture.processing" }] } }
+			}
+		},
+		frontFinished: {
+			entry: ["stopMediaRecording", "prepareForBackCapture"],
+			on: { CONTINUE_TO_BACK: {
+				target: "capture",
+				actions: assign({ currentMode: () => "back" })
+			} }
+		},
+		processing: {
+			entry: "stopMediaStream",
+			invoke: {
+				id: "processId",
+				src: "processId",
+				input: ({ context }) => ({ isSecondId: context.config.isSecondId ?? false }),
+				onDone: [{
+					target: "expired",
+					guard: ({ event }) => event.output.isDocumentExpired
+				}, { target: "finished" }],
+				onError: { target: "finished" }
+			}
+		},
+		expired: { on: { RETRY_CAPTURE: [
+			{
+				target: "chooser",
+				guard: "hasShowDocumentChooser",
+				actions: ["resetContext"]
+			},
+			{
+				target: "tutorial",
+				guard: "hasShowTutorial",
+				actions: "resetContext"
+			},
+			{
+				target: "loading",
+				actions: "resetContext"
+			}
+		] } },
+		finished: {
+			entry: [
+				"stopMediaRecording",
+				"stopMediaStream",
+				"disposeProvider"
+			],
+			type: "final"
+		},
+		closed: {
+			entry: ["stopMediaStream", "disposeProvider"],
+			type: "final"
+		},
+		error: {
+			entry: ["stopMediaStream", "disposeProvider"],
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		manualIdUpload: { on: { QUIT: { target: "closed" } } },
+		digitalIdUpload: { on: { QUIT: { target: "closed" } } }
+	}
+});
+const idCaptureMachine = _idCaptureMachine;
+
+//#endregion
+//#region src/modules/id/idCaptureActor.ts
+function createIdCaptureActor(options) {
+	return createActor(idCaptureMachine, { input: {
+		config: options.config,
+		provider: options.provider
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/id/idCaptureManager.ts
+function getPermissionStatus(snapshot) {
+	if (!snapshot.matches("permissions")) return;
+	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "waitingForUser" })) 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) {
+	const matches = {
+		initializing: snapshot.matches({ capture: "initializing" }),
+		detecting: snapshot.matches({ capture: "detecting" }),
+		manualCaptureWaiting: snapshot.matches({ capture: "manualCaptureWaiting" }),
+		capturing: snapshot.matches({ capture: "capturing" }),
+		capturingManual: snapshot.matches({ capture: "capturingManual" }),
+		uploading: snapshot.matches({ capture: "uploading" }),
+		uploadError: snapshot.matches({ capture: "uploadError" }),
+		success: snapshot.matches({ capture: "success" })
+	};
+	if (matches.initializing) return "initializing";
+	if (matches.detecting || matches.manualCaptureWaiting) return "detecting";
+	if (matches.capturing || matches.capturingManual) return "capturing";
+	if (matches.uploading) return "uploading";
+	if (matches.uploadError) return "uploadError";
+	if (matches.success) return "success";
+}
+function getErrorMessage(errorCode) {
+	if (!errorCode) return void 0;
+	return {
+		UPLOAD_ERROR: "Upload failed",
+		CLASSIFICATION_FAILED: "ID classification failed",
+		LOW_SHARPNESS: "Image is not sharp enough",
+		GLARE_DETECTED: "Glare detected on ID",
+		WRONG_DOCUMENT_SIDE: "Wrong side of document",
+		ID_TYPE_UNACCEPTABLE: "ID type is not acceptable",
+		READABILITY_ISSUE: "ID readability issue",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Retry exhausted",
+		RETRY_EXHAUSTED_SKIP_BACK: "Retry exhausted",
+		NO_MORE_TRIES: "No more tries remaining",
+		UNEXPECTED_ERROR: "An unexpected error occurred",
+		NO_TOKEN: "No token available",
+		PERMISSION_DENIED: "Permission denied",
+		USER_CANCELLED: "User cancelled",
+		SERVER_ERROR: "Server error"
+	}[errorCode];
+}
+function getErrorDescription(errorCode, uploadResponse) {
+	if (!errorCode) return void 0;
+	return {
+		UPLOAD_ERROR: "Please try again",
+		CLASSIFICATION_FAILED: "Please ensure your ID is clearly visible",
+		LOW_SHARPNESS: "Please ensure the image is clear and well-focused",
+		GLARE_DETECTED: "Please avoid bright reflections on your ID",
+		WRONG_DOCUMENT_SIDE: uploadResponse?.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
+		ID_TYPE_UNACCEPTABLE: "Please use a valid ID type",
+		READABILITY_ISSUE: "Please ensure all text is clearly visible",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "Continuing to back side capture",
+		RETRY_EXHAUSTED_SKIP_BACK: "Skipping back side capture",
+		NO_MORE_TRIES: "Maximum attempts reached",
+		UNEXPECTED_ERROR: "Please try again later",
+		NO_TOKEN: "Session expired",
+		PERMISSION_DENIED: "Camera permission is required",
+		USER_CANCELLED: "Capture was cancelled",
+		SERVER_ERROR: "Please try again later"
+	}[errorCode];
+}
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (snapshot.matches("chooser")) return { status: "chooser" };
+	if (snapshot.matches("loading")) return { status: "loading" };
+	if (snapshot.matches("tutorial")) return {
+		status: "tutorial",
+		selectedDocumentType: context.selectedDocumentType
+	};
+	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")) {
+		const captureStatus = getCaptureStatus(snapshot);
+		const needsBackCapture = context.currentMode === "front" && !context.config.onlyFront && !context.config.onlyBack;
+		return {
+			status: "capture",
+			captureStatus: captureStatus ?? "initializing",
+			stream: context.stream,
+			detectionStatus: context.detectionStatus,
+			debugFrame: void 0,
+			attemptsRemaining: context.attemptsRemaining,
+			uploadError: context.uploadError,
+			currentMode: context.currentMode,
+			counterValue: context.counterValue,
+			orientation: context.orientation,
+			idType: context.idType,
+			previewImageUrl: context.previewImageUrl,
+			uploadProgress: context.uploadProgress ?? 0,
+			uploadErrorMessage: context.uploadError ? getErrorMessage(context.uploadError) : void 0,
+			uploadErrorDescription: context.uploadError ? getErrorDescription(context.uploadError, context.uploadResponse) : void 0,
+			needsBackCapture,
+			showCaptureButtonInAuto: context.config.showCaptureButtonInAuto ?? false,
+			canRetry: context.attemptsRemaining > 0
+		};
+	}
+	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("expired")) return { status: "expired" };
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		selectDocument(documentType) {
+			actor.send({
+				type: "SELECT_DOCUMENT",
+				documentType
+			});
+		},
+		nextStep() {
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		continueFromError() {
+			actor.send({ type: "CONTINUE_FROM_ERROR" });
+		},
+		capture() {
+			actor.send({ type: "MANUAL_CAPTURE" });
+		},
+		switchToManualCapture() {
+			actor.send({ type: "SWITCH_TO_MANUAL_CAPTURE" });
+		},
+		continueToBack() {
+			actor.send({ type: "CONTINUE_TO_BACK" });
+		},
+		skipBack() {
+			actor.send({ type: "SKIP_BACK" });
+		},
+		updateDetectionArea(detectionArea) {
+			actor.send({
+				type: "UPDATE_DETECTION_AREA",
+				detectionArea
+			});
+		}
+	};
+}
+function createIdCaptureManager(options) {
+	return createManager({
+		actor: createIdCaptureActor(options),
+		mapState,
+		createApi
+	});
+}
+
+//#endregion
+export { processId as a, stopStream as c, ID_ERROR_CODES as d, initializeIdCapture as i, uploadIdImage as l, createIdCaptureActor as n, startRecordingSession as o, idCaptureMachine as r, stopRecording as s, createIdCaptureManager as t, validateUploadResponse as u };