@incodetech/core 0.0.0-dev-20260127-938ff95 → 0.0.0-dev-20260130-5bb04b9

package/dist/id-DE76bgjS.esm.js

@@ -0,0 +1,2498 @@
+import { d as addEvent, m as revokeObjectURL, n as eventModuleNames } from "./events-CLVaKe2J.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, f as BrowserStorageProvider, h as StreamCanvasCapture, k as isSafari, m as StreamCanvasProcessingSession, n as DEFAULT_ID_CAPTURE_THRESHOLDS, p as BrowserEnvironmentProvider, t as DEFAULT_ID_CAPTURE_MODEL_VERSION, v as IncodeCanvas, x as requestCameraAccess, y as applyTrackConstraints } from "./src-BEaVRVtC.esm.js";
+import { i as getUserAgent, n as getDeviceInfo, r as getWindowDimensions } from "./deepsightService-BqN04Xvz.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-CmGlc9UG.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-EcGvh3bl.esm.js";
+import { n as getApi, r as getToken, t as api } from "./api-DfRLAneb.esm.js";
+import { t as addDeviceStats } from "./stats-onWUN0tY.esm.js";
+
+//#region ../infra/src/capabilities/ITimerCapability.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/internal/session/sessionService.ts
+/**
+* Creates a new onboarding session.
+*
+* @param apiKey - The API key from the Incode dashboard
+* @param options - Session creation options
+* @param signal - Optional AbortSignal for request cancellation
+* @returns The created session with token
+*
+* @example
+* ```ts
+* const session = await createSession('your-api-key', {
+*   configurationId: 'your-flow-id',
+*   language: 'en-US',
+* });
+* console.log(session.token); // Use this token for subsequent API calls
+* ```
+*/
+async function createSession(apiKey, options, signal) {
+	const res = await getApi().post(endpoints.createSession, {
+		configurationId: options.configurationId,
+		externalId: options.externalId,
+		externalCustomerId: options.externalCustomerId,
+		language: options.language ?? "en-US",
+		customFields: options.customFields,
+		uuid: options.uuid ?? null,
+		interviewId: options.interviewId ?? null
+	}, {
+		headers: {
+			"x-api-key": apiKey,
+			"api-version": "1.0"
+		},
+		signal
+	});
+	if (!res.ok) throw new Error(`POST ${endpoints.createSession} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/internal/featureConfig/featureConfigService.ts
+let cachedFeatures$1 = null;
+/**
+* Checks if a feature is enabled in the feature config.
+*/
+function isFeatureEnabled(feature, features) {
+	return features?.find((f) => f.feature === feature)?.enabled ?? false;
+}
+/**
+* Fetches feature configuration from the backend.
+* Results are cached for the session lifetime.
+*/
+async function fetchFeatureConfig(signal) {
+	if (cachedFeatures$1) return cachedFeatures$1;
+	const response = await api.get(endpoints.featureConfig, { signal });
+	if (!response.ok) throw new Error(`Failed to fetch feature config: ${response.status} ${response.statusText}`);
+	cachedFeatures$1 = response.data;
+	return cachedFeatures$1;
+}
+/**
+* Resets the cached feature config (useful for testing).
+*/
+function resetFeatureConfigCache() {
+	cachedFeatures$1 = null;
+}
+
+//#endregion
+//#region src/internal/fingerprint/fingerprintService.ts
+const IP_PROVIDER_URL = "https://api.ipify.org?format=json";
+const AUTOMATION_MARKERS = {
+	window: [
+		"callPhantom",
+		"_phantom",
+		"phantom",
+		"__nightmare",
+		"domAutomation",
+		"domAutomationController"
+	],
+	navigator: ["webdriver"]
+};
+function isBrowserSimulation(browserEnv) {
+	for (const prop of AUTOMATION_MARKERS.window) if (browserEnv.getWindowProperty(prop)) return true;
+	for (const prop of AUTOMATION_MARKERS.navigator) if (browserEnv.getNavigatorProperty(prop)) return true;
+	return false;
+}
+async function fetchPublicIp(browserEnv) {
+	try {
+		return (await browserEnv.fetchJson(IP_PROVIDER_URL, 3e3))?.ip || "";
+	} catch {
+		return "";
+	}
+}
+function parseBrowserInfo(ua) {
+	const uaLower = ua.toLowerCase();
+	if (uaLower.includes("edg/")) {
+		const match = ua.match(/edg\/(\d+)/i);
+		return {
+			name: "Edge",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	if (uaLower.includes("chrome/") && !uaLower.includes("edg/")) {
+		const match = ua.match(/chrome\/(\d+)/i);
+		return {
+			name: "Chrome",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	if (uaLower.includes("firefox/")) {
+		const match = ua.match(/firefox\/(\d+)/i);
+		return {
+			name: "Firefox",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	if (uaLower.includes("safari/") && !uaLower.includes("chrome/")) {
+		const match = ua.match(/version\/(\d+)/i);
+		return {
+			name: "Safari",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	return {
+		name: "Unknown",
+		version: "Unknown"
+	};
+}
+function parseOSInfo(ua, platform) {
+	if (/iphone|ipad|ipod/i.test(ua)) {
+		const match = ua.match(/os (\d+)[._](\d+)/i);
+		if (match) return {
+			name: "iOS",
+			version: `${match[1]}.${match[2]}`
+		};
+		return {
+			name: "iOS",
+			version: "Unknown"
+		};
+	}
+	if (/android/i.test(ua)) {
+		const match = ua.match(/android (\d+(?:\.\d+)?)/i);
+		return {
+			name: "Android",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	if (/windows/i.test(ua)) {
+		const match = ua.match(/windows nt (\d+\.\d+)/i);
+		return {
+			name: "Windows",
+			version: match ? match[1] : "Unknown"
+		};
+	}
+	if (/macintosh|mac os x/i.test(ua)) {
+		const match = ua.match(/mac os x (\d+)[._](\d+)/i);
+		if (match) return {
+			name: "macOS",
+			version: `${match[1]}.${match[2]}`
+		};
+		return {
+			name: "macOS",
+			version: "Unknown"
+		};
+	}
+	if (/linux/i.test(ua)) return {
+		name: "Linux",
+		version: "Unknown"
+	};
+	return {
+		name: platform || "Unknown",
+		version: "Unknown"
+	};
+}
+function isWebview(ua) {
+	const uaLower = ua.toLowerCase();
+	return uaLower.includes("wv") || uaLower.includes("webview") || uaLower.includes("android") && !uaLower.includes("chrome");
+}
+function getDeviceModel(ua, platform) {
+	if (/iphone/i.test(ua)) {
+		const match = ua.match(/iphone\s*(\w+)/i);
+		return match ? `iPhone ${match[1]}` : "iPhone";
+	}
+	if (/ipad/i.test(ua)) return ua.match(/ipad/i) ? "iPad" : "iPad";
+	if (/android/i.test(ua)) {
+		const match = ua.match(/android.*;\s*([^)]+)\)/i);
+		return match ? match[1].trim() : "Android Device";
+	}
+	return platform || "Unknown";
+}
+/**
+* Collects device fingerprint data and submits it to the backend.
+*/
+async function submitDeviceFingerprint(options) {
+	const { browserEnv, sdkVersion, disableIpify = false, hostingApp, signal } = options;
+	const ua = getUserAgent();
+	const deviceInfo = getDeviceInfo();
+	const hash = browserEnv.generateCanvasFingerprint();
+	const ip = disableIpify ? "" : await fetchPublicIp(browserEnv);
+	const browserInfo = parseBrowserInfo(ua);
+	const osInfo = parseOSInfo(ua, deviceInfo.platform);
+	const deviceModel = getDeviceModel(ua, deviceInfo.platform);
+	const browserString = isWebview(ua) ? "webview" : `${browserInfo.name} ${browserInfo.version}`;
+	const fingerprintData = {
+		hash,
+		ip,
+		deviceType: "WEBAPP",
+		data: JSON.stringify({
+			visitorId: hash,
+			ip
+		}),
+		osVersion: `${osInfo.name} ${osInfo.version}`,
+		deviceModel,
+		browser: browserString,
+		sdkVersion,
+		hasLiedBrowser: isBrowserSimulation(browserEnv),
+		hostingApp
+	};
+	const response = await api.post(endpoints.deviceFingerprint, {
+		hash: fingerprintData.hash,
+		ip: fingerprintData.ip,
+		deviceType: fingerprintData.deviceType,
+		data: fingerprintData.data,
+		osVersion: fingerprintData.osVersion,
+		deviceModel: fingerprintData.deviceModel,
+		browser: fingerprintData.browser,
+		hasLiedBrowser: fingerprintData.hasLiedBrowser,
+		sdkVersion: fingerprintData.sdkVersion,
+		hostingApp: fingerprintData.hostingApp,
+		ipLocation: fingerprintData.ipLocation
+	}, { signal });
+	if (!response.ok) throw new Error(`Failed to submit device fingerprint: ${response.status} ${response.statusText}`);
+	return response.data;
+}
+
+//#endregion
+//#region src/internal/session/sessionInitializer.ts
+const SDK_VERSION = "2.0.0";
+let sessionInitialized = false;
+let cachedFeatures = null;
+let cachedDisableIpify = false;
+/**
+* Initializes session-level services after the token is set.
+* This should be called once after createSession() or setToken().
+*
+* Performs:
+* 1. Fetches feature configuration from backend
+* 2. Submits device fingerprint
+*
+* Results are cached for the session lifetime.
+*
+* @param options - Optional configuration
+* @returns Session initialization result with feature config
+*
+* @example
+* ```ts
+* // After creating a session
+* const session = await createSession('api-key', options);
+* setup({ apiURL, token: session.token });
+* const { features } = await initializeSession();
+*
+* // Check feature flags
+* if (isFeatureEnabled('DISABLE_IPIFY', features.features)) {
+*   // Handle disabled ipify
+* }
+* ```
+*/
+async function initializeSession(options = {}) {
+	const { hostingApp, signal } = options;
+	if (sessionInitialized && cachedFeatures) return {
+		features: cachedFeatures,
+		disableIpify: cachedDisableIpify,
+		fingerprintSuccess: true
+	};
+	let features;
+	let disableIpify = false;
+	try {
+		features = await fetchFeatureConfig(signal);
+		disableIpify = isFeatureEnabled("DISABLE_IPIFY", features.features);
+	} catch (error) {
+		console.warn("Failed to fetch feature config:", error);
+		features = { sessionIdentifier: "" };
+	}
+	let fingerprintSuccess = false;
+	try {
+		await submitDeviceFingerprint({
+			browserEnv: new BrowserEnvironmentProvider(),
+			sdkVersion: SDK_VERSION,
+			disableIpify,
+			hostingApp,
+			signal
+		});
+		fingerprintSuccess = true;
+	} catch (error) {
+		console.warn("Failed to submit device fingerprint:", error);
+	}
+	sessionInitialized = true;
+	cachedFeatures = features;
+	cachedDisableIpify = disableIpify;
+	return {
+		features,
+		disableIpify,
+		fingerprintSuccess
+	};
+}
+/**
+* Gets the cached feature configuration.
+* Returns undefined if session hasn't been initialized.
+*/
+function getSessionFeatures() {
+	return cachedFeatures ?? void 0;
+}
+/**
+* Gets the cached disableIpify flag.
+* Returns false if session hasn't been initialized.
+*/
+function getDisableIpify() {
+	return cachedDisableIpify;
+}
+/**
+* Checks if the session has been initialized.
+*/
+function isSessionInitialized() {
+	return sessionInitialized;
+}
+/**
+* Resets session initialization state.
+* Useful for testing or when starting a new session.
+*/
+function resetSessionInit() {
+	sessionInitialized = false;
+	cachedFeatures = null;
+	cachedDisableIpify = false;
+	resetFeatureConfigCache();
+}
+
+//#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/internal/analytics/deviceStats.ts
+async function postDeviceStats(stats) {
+	try {
+		await api.post(endpoints.deviceStats, stats);
+	} catch {}
+}
+
+//#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/idCaptureServices.ts
+/**
+* Camera constraints used for PRC warmup before ID capture.
+* Uses environment-facing camera on mobile devices (for back camera ID capture)
+* and user-facing camera on desktop.
+*/
+function getPrcCameraConstraints() {
+	if (isDesktop()) return { video: {
+		facingMode: "user",
+		height: { ideal: 480 },
+		width: { ideal: 640 }
+	} };
+	return { video: {
+		facingMode: "environment",
+		height: { ideal: 720 }
+	} };
+}
+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(params) {
+	const { provider, config, deepsightService } = params;
+	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
+	});
+	if (deepsightService) try {
+		await deepsightService.performPrcCheck({ constraints: getPrcCameraConstraints() });
+	} catch (error) {
+		console.warn("PRC check failed during ID capture initialization:", error);
+	}
+	const stream = await getIdCameraStream();
+	if (deepsightService) {
+		const videoTrack = stream.getVideoTracks()[0];
+		if (videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
+	}
+	return {
+		stream,
+		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, analyticsProvider, imageData } = params;
+	addEvent({
+		code: "captureAttemptFinished",
+		module: eventModuleNames.id,
+		payload: { logs: [] }
+	});
+	let finalMetadata = metadata;
+	if (analyticsProvider && imageData) try {
+		await analyticsProvider.analyzeFrame(imageData);
+		analyticsProvider.update();
+		const analysisStatus = analyticsProvider.getAnalysisStatus();
+		const motionStatus = analyticsProvider.getMotionStatus();
+		await postDeviceStats({
+			frontIdStatsAnalysisStatus: type === "front" ? analysisStatus : void 0,
+			backIdStatsAnalysisStatus: type === "back" ? analysisStatus : void 0,
+			motionStatus
+		});
+		finalMetadata = analyticsProvider.getMetadata();
+	} catch (error) {
+		console.warn("[IdCapture] Analytics failed:", error);
+	}
+	const endpoint = type === "front" ? endpoints.frontId : endpoints.backId;
+	const body = {
+		base64Image: image,
+		metadata: finalMetadata
+	};
+	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/idCaptureActors.ts
+const checkPermissionActor = fromPromise(async () => {
+	return checkPermission();
+});
+const requestPermissionActor = fromPromise(async () => {
+	return requestPermission();
+});
+const initializeCameraActor = fromPromise(async ({ input }) => {
+	return initializeIdCapture(input);
+});
+const runDetectionActor = fromCallback(({ input, sendBack }) => {
+	if (!input.frameCapturer || !input.provider) {
+		sendBack({
+			type: "DETECTION_UPDATE",
+			status: "error"
+		});
+		return () => {};
+	}
+	const provider = input.provider;
+	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"
+	});
+	const 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();
+	};
+});
+const uploadIdImageActor = fromPromise(async ({ input, signal }) => {
+	const image = input.canvas.getBase64Image();
+	if (!image) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
+	let metadata;
+	if (input.deepsightService) try {
+		const sessionToken = getToken();
+		const frameSource = input.type === "back" ? "BACK_ID" : "FRONT_ID";
+		await input.deepsightService.performVirtualCameraCheck(sessionToken, frameSource);
+		const imageData$1 = input.canvas.getImageData();
+		if (imageData$1) await input.deepsightService.analyzeFrame(imageData$1);
+		const analysisStatus = input.deepsightService.getAnalysisStatus();
+		const motionStatus = input.deepsightService.getMotionStatus();
+		if (input.type === "front") await addDeviceStats({
+			frontIdStatsAnalysisStatus: analysisStatus,
+			backIdStatsAnalysisStatus: "",
+			selfieStatsAnalysisStatus: "",
+			motionStatus
+		});
+		else await addDeviceStats({
+			frontIdStatsAnalysisStatus: "",
+			backIdStatsAnalysisStatus: analysisStatus,
+			selfieStatsAnalysisStatus: "",
+			motionStatus
+		});
+		metadata = input.deepsightService.getMetadata();
+	} catch {}
+	const imageData = input.canvas?.getImageData() ?? void 0;
+	return uploadIdImage({
+		image,
+		type: input.type,
+		sendBase64: true,
+		glare: input.qualityElements?.glare,
+		sharpness: input.qualityElements?.sharpness,
+		ageAssurance: false,
+		signal,
+		onProgress: input.onProgress,
+		metadata,
+		analyticsProvider: input.analyticsProvider,
+		imageData
+	});
+});
+const processIdActor = fromPromise(async ({ input, signal }) => {
+	return processId(input.isSecondId, "", signal);
+});
+const startRecordingActor = 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
+	});
+});
+const checkMotionSensorActor = 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);
+});
+const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
+	if (!input.dependencies) return;
+	const { loadDeepsightSession } = await import("./deepsightLoader-CGdK3U_s.esm.js");
+	return loadDeepsightSession({
+		ds: input.ds,
+		storage: input.dependencies.storage,
+		disableIpify: input.disableIpify
+	});
+});
+const checkVirtualCameraActor = 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);
+});
+
+//#endregion
+//#region src/modules/id/idCaptureActions.ts
+function performStopMediaStream(context) {
+	context.frameCapturer?.dispose();
+	if (context.stream) stopStream(context.stream);
+}
+function performDisposeProvider(context) {
+	context.provider?.dispose?.();
+}
+function performCleanupDeepsight(context) {
+	context.deepsightService?.cleanup();
+}
+function performResetForBackCapture(context) {
+	context.frameCapturer?.dispose();
+	if (context.stream) stopStream(context.stream);
+	context.provider?.reset();
+}
+function performResetDetection(context) {
+	context.resetDetection?.();
+}
+function performTrackTutorialId() {
+	addEvent({
+		code: "tutorialVideoStarted",
+		module: eventModuleNames.id,
+		payload: { tutorialFrontID: true }
+	});
+}
+function performTrackContinue() {}
+function performStopMediaRecording(context) {
+	if (context.recordingSession) stopRecording(context.recordingSession);
+}
+function getStreamFromEvent(event) {
+	if ("output" in event) return event.output.stream;
+}
+function getProviderFromEvent(event) {
+	if ("output" in event) return event.output.provider;
+}
+function getFrameCapturerFromEvent(event) {
+	if ("output" in event) {
+		const output = event.output;
+		if (output.stream) return new StreamCanvasCapture(output.stream);
+	}
+}
+function getResetContextValues(context) {
+	context.provider?.reset();
+	const currentMode = context.config.onlyBack ? "back" : !context.config.enableId && context.config.enablePassport ? "passport" : "front";
+	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,
+		selectedDocumentType: void 0,
+		manualCaptureTriggered: false
+	};
+}
+function getClearUploadFailureValues(context) {
+	if (context.previewImageUrl) revokeObjectURL(context.previewImageUrl);
+	return {
+		uploadError: void 0,
+		detectionStatus: "idle",
+		previewImageUrl: void 0,
+		uploadProgress: void 0
+	};
+}
+function getUploadValidationError(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;
+}
+function storeCapturedCanvasInProviderLogic(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);
+}
+function getStoreCapturedImageValues(context, event) {
+	if (!context.currentMode) return {
+		capturedImages: context.capturedImages,
+		previewImageUrl: context.previewImageUrl
+	};
+	const transformedCanvas = context.provider?.getCapturedCanvas();
+	const transformedImage = transformedCanvas?.getBase64Image(1, true);
+	let fallbackImage = "";
+	if ("output" in event) fallbackImage = event.output.originalImage ?? "";
+	const imageData = { imageBase64: transformedImage ?? fallbackImage };
+	let capturedImages = context.capturedImages;
+	if (context.currentMode === "front" || context.currentMode === "passport") capturedImages = {
+		...context.capturedImages,
+		front: imageData
+	};
+	else capturedImages = {
+		...context.capturedImages,
+		back: imageData
+	};
+	let previewImageUrl = context.previewImageUrl;
+	if (transformedCanvas) {
+		transformedCanvas.updateBlob();
+		const blobData = transformedCanvas.getBlobData();
+		if (blobData?.url) previewImageUrl = blobData.url;
+	} else if ("canvas" in event && event.canvas) {
+		const canvas = event.canvas;
+		canvas.updateBlob();
+		const blobData = canvas.getBlobData();
+		if (blobData?.url) previewImageUrl = blobData.url;
+	}
+	return {
+		capturedImages,
+		previewImageUrl
+	};
+}
+function getDetectionStatusFromUpdate(context, event) {
+	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";
+}
+function getDetectionStatusFromSideChange(context, side) {
+	const detectedSide = 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";
+}
+function getCurrentModeFromEvent(context, event) {
+	if ("documentType" in event) {
+		if (event.documentType === "passport") return "passport";
+		return "front";
+	}
+	if (event.type === "FRONT_COMPLETE") return "back";
+	return context.currentMode;
+}
+
+//#endregion
+//#region src/modules/id/idCaptureGuards.ts
+const hasShowTutorialGuard = ({ context }) => context.config.showTutorial;
+const hasShowDocumentChooserGuard = ({ context }) => context.config.showDocumentChooserScreen ?? false;
+const isPermissionGrantedGuard = ({ event }) => {
+	if ("output" in event) return event.output === "granted";
+	return false;
+};
+const isPermissionDeniedErrorGuard = ({ event }) => {
+	if ("error" in event) {
+		const error = event.error;
+		return error?.name === "NotAllowedError" || error?.name === "PermissionDeniedError";
+	}
+	return false;
+};
+const hasStreamGuard = ({ context }) => context.stream !== void 0;
+const hasAttemptsRemainingGuard = ({ context }) => context.attemptsRemaining > 0;
+const hasCapturedImageGuard = ({ context }) => {
+	return context.provider?.getCapturedCanvas() !== null;
+};
+const hasUploadValidationErrorGuard = ({ context }) => {
+	if (!context.uploadResponse) return false;
+	return validateUploadResponse(context.uploadResponse, {
+		skipGlareFront: context.uploadResponse.skipGlareFront,
+		skipGlareBack: context.uploadResponse.skipGlareBack
+	}) !== void 0;
+};
+const isFrontModeGuard = ({ context }) => context.currentMode === "front" || context.currentMode === "passport";
+const isOnlyFrontGuard = ({ context }) => context.config.onlyFront;
+const shouldContinueToBackGuard = ({ 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;
+};
+const isDeepsightEnabledGuard = ({ context }) => context.dependencies !== void 0;
+const isDeepsightReadyGuard = ({ context }) => context.deepsightService !== void 0;
+const needsDeepsightInitGuard = ({ context }) => context.dependencies !== void 0 && context.deepsightService === void 0 && !context.deepsightInitAttempted;
+
+//#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: checkPermissionActor,
+		requestPermission: requestPermissionActor,
+		initializeCamera: initializeCameraActor,
+		runDetection: runDetectionActor,
+		uploadIdImage: uploadIdImageActor,
+		processId: processIdActor,
+		startRecording: startRecordingActor,
+		checkMotionSensor: checkMotionSensorActor,
+		initializeDeepsightSession: initializeDeepsightSessionActor,
+		checkVirtualCamera: checkVirtualCameraActor
+	},
+	actions: {
+		stopMediaStream: assign(({ context }) => {
+			performStopMediaStream(context);
+			return {
+				stream: void 0,
+				frameCapturer: void 0
+			};
+		}),
+		disposeProvider: ({ context }) => {
+			performDisposeProvider(context);
+		},
+		cleanupDeepsight: ({ context }) => {
+			performCleanupDeepsight(context);
+		},
+		resetForBackCapture: assign(({ context }) => {
+			performResetForBackCapture(context);
+			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 }) => getStreamFromEvent(event),
+			provider: ({ event }) => getProviderFromEvent(event),
+			frameCapturer: ({ event }) => getFrameCapturerFromEvent(event)
+		}),
+		trackTutorialId: () => {
+			performTrackTutorialId();
+		},
+		trackContinue: () => {
+			/* @__PURE__ */ performTrackContinue();
+		},
+		resetContext: assign(({ context }) => getResetContextValues(context)),
+		resetDetection: ({ context }) => {
+			performResetDetection(context);
+		},
+		captureImage: assign({ qualityElements: ({ event }) => {
+			if ("qualityElements" in event) return event.qualityElements;
+		} }),
+		storeCapturedCanvasInProvider: ({ context, event }) => {
+			storeCapturedCanvasInProviderLogic(context, event);
+		},
+		captureLatestFrame: ({ context }) => {
+			context.frameCapturer?.getLatestCanvas();
+		},
+		clearUploadFailure: assign(({ context }) => getClearUploadFailureValues(context)),
+		decrementAttemptsRemaining: assign(({ context }) => ({ attemptsRemaining: context.attemptsRemaining - 1 })),
+		setUploadErrorFromUploadValidation: assign({ uploadError: ({ context }) => getUploadValidationError(context) }),
+		stopMediaRecording: ({ context }) => {
+			performStopMediaRecording(context);
+		},
+		clearRecordingSession: assign({ recordingSession: () => void 0 }),
+		setSelectedDocument: assign({ selectedDocumentType: ({ event }) => {
+			if ("documentType" in event) return event.documentType;
+		} }),
+		setCurrentMode: assign({ currentMode: ({ event, context }) => getCurrentModeFromEvent(context, event) }),
+		storeCapturedImage: assign(({ context, event }) => getStoreCapturedImageValues(context, event)),
+		setDetectionStatus: assign({ detectionStatus: ({ event, context }) => getDetectionStatusFromUpdate(context, event) }),
+		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: hasShowTutorialGuard,
+		hasShowDocumentChooser: hasShowDocumentChooserGuard,
+		isPermissionGranted: isPermissionGrantedGuard,
+		isPermissionDeniedError: isPermissionDeniedErrorGuard,
+		hasStream: hasStreamGuard,
+		hasAttemptsRemaining: hasAttemptsRemainingGuard,
+		hasCapturedImage: hasCapturedImageGuard,
+		hasUploadValidationError: hasUploadValidationErrorGuard,
+		isFrontMode: isFrontModeGuard,
+		isOnlyFront: isOnlyFrontGuard,
+		shouldContinueToBack: shouldContinueToBackGuard,
+		isDeepsightEnabled: isDeepsightEnabledGuard,
+		isDeepsightReady: isDeepsightReadyGuard,
+		needsDeepsightInit: needsDeepsightInitGuard
+	}
+}).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,
+			deepsightService: void 0,
+			analyticsProvider: input.analyticsProvider,
+			dependencies: input.dependencies,
+			disableIpify: getDisableIpify(),
+			deepsightInitAttempted: 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: {
+			type: "parallel",
+			states: {
+				permissionCheck: {
+					initial: "checking",
+					states: {
+						checking: { invoke: {
+							id: "checkPermissionLoading",
+							src: "checkPermission",
+							onDone: {
+								target: "done",
+								actions: assign({ permissionResult: ({ event }) => event.output })
+							},
+							onError: {
+								target: "done",
+								actions: assign({ permissionResult: () => "prompt" })
+							}
+						} },
+						done: { type: "final" }
+					}
+				},
+				deepsightInit: {
+					initial: "initializing",
+					states: {
+						initializing: { invoke: {
+							id: "initDeepsightLoading",
+							src: "initializeDeepsightSession",
+							input: ({ context }) => ({
+								ds: context.config.ds,
+								dependencies: context.dependencies,
+								disableIpify: context.disableIpify
+							}),
+							onDone: {
+								target: "done",
+								actions: assign({
+									deepsightService: ({ event }) => event.output,
+									deepsightInitAttempted: () => true
+								})
+							},
+							onError: {
+								target: "done",
+								actions: [assign({ deepsightInitAttempted: () => true }), () => console.warn("Deepsight initialization failed")]
+							}
+						} },
+						done: { type: "final" }
+					}
+				}
+			},
+			onDone: [{
+				target: "capture",
+				guard: "isPermissionGranted"
+			}, { target: "permissions" }]
+		},
+		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: {
+					type: "parallel",
+					states: {
+						cameraInit: {
+							initial: "initializingDeepsight",
+							states: {
+								initializingDeepsight: { invoke: {
+									id: "tutorialInitDeepsight",
+									src: "initializeDeepsightSession",
+									input: ({ context }) => ({
+										ds: context.config.ds,
+										dependencies: context.dependencies,
+										disableIpify: context.disableIpify
+									}),
+									onDone: {
+										target: "initializingStream",
+										actions: assign({
+											deepsightService: ({ event }) => event.output,
+											deepsightInitAttempted: () => true
+										})
+									},
+									onError: {
+										target: "initializingStream",
+										actions: [assign({ deepsightInitAttempted: () => true }), () => console.warn("Deepsight initialization failed in tutorial")]
+									}
+								} },
+								initializingStream: { invoke: {
+									id: "tutorialInitCamera",
+									src: "initializeCamera",
+									input: ({ context }) => {
+										if (!context.provider) throw new Error("Provider is required");
+										return {
+											provider: context.provider,
+											config: context.config,
+											deepsightService: context.deepsightService
+										};
+									},
+									onDone: {
+										target: "ready",
+										actions: "setStreamAndCapturer"
+									},
+									onError: [{
+										target: "#idCapture.tutorial.ready",
+										guard: "isPermissionDeniedError",
+										actions: assign({ permissionResult: () => "denied" })
+									}, {
+										target: "#idCapture.tutorial.ready",
+										actions: assign({ error: ({ event }) => String(event.error) })
+									}]
+								} },
+								ready: { type: "final" }
+							}
+						},
+						userIntent: {
+							initial: "booting",
+							states: {
+								booting: {
+									always: [{
+										target: "clicked",
+										guard: "hasStream"
+									}],
+									on: { NEXT_STEP: {
+										target: "clicked",
+										actions: "trackContinue"
+									} }
+								},
+								clicked: { type: "final" }
+							}
+						}
+					},
+					onDone: [{
+						target: "#tutorialCameraReady",
+						guard: "hasStream"
+					}, { target: "#idCapture.capture" }]
+				},
+				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: "initializingDeepsight",
+						guard: "needsDeepsightInit"
+					},
+					{
+						target: "detecting",
+						guard: "hasStream"
+					},
+					{ target: "initializing" }
+				] },
+				initializingDeepsight: { invoke: {
+					id: "initDeepsightCapture",
+					src: "initializeDeepsightSession",
+					input: ({ context }) => ({
+						ds: context.config.ds,
+						dependencies: context.dependencies,
+						disableIpify: context.disableIpify
+					}),
+					onDone: {
+						target: "checkingStream",
+						actions: assign({
+							deepsightService: ({ event }) => event.output,
+							deepsightInitAttempted: () => true
+						})
+					},
+					onError: {
+						target: "checkingStream",
+						actions: [assign({ deepsightInitAttempted: () => true }), () => console.warn("Deepsight initialization failed in capture")]
+					}
+				} },
+				initializing: { invoke: {
+					id: "initializeCamera",
+					src: "initializeCamera",
+					input: ({ context }) => {
+						if (!context.provider) throw new Error("Provider is required");
+						return {
+							provider: context.provider,
+							config: context.config,
+							deepsightService: context.deepsightService
+						};
+					},
+					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 }) => getDetectionStatusFromSideChange(context, event.side) }) },
+						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
+									});
+								},
+								deepsightService: context.deepsightService,
+								stream: context.stream
+							};
+						},
+						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", "resetForBackCapture"],
+			type: "parallel",
+			states: {
+				cameraInit: {
+					initial: "checking",
+					states: {
+						checking: { always: [{
+							target: "ready",
+							guard: "hasStream"
+						}, { target: "initializingStream" }] },
+						initializingStream: { invoke: {
+							id: "frontFinishedInitCamera",
+							src: "initializeCamera",
+							input: ({ context }) => {
+								if (!context.provider) throw new Error("Provider is required");
+								return {
+									provider: context.provider,
+									config: context.config,
+									deepsightService: context.deepsightService
+								};
+							},
+							onDone: {
+								target: "ready",
+								actions: "setStreamAndCapturer"
+							},
+							onError: {
+								target: "ready",
+								actions: () => {
+									console.warn("Camera initialization failed during flip transition");
+								}
+							}
+						} },
+						ready: { type: "final" }
+					}
+				},
+				userIntent: {
+					initial: "waiting",
+					states: {
+						waiting: { on: { CONTINUE_TO_BACK: {
+							target: "clicked",
+							actions: assign({ currentMode: () => "back" })
+						} } },
+						clicked: { type: "final" }
+					}
+				}
+			},
+			onDone: [{
+				target: "#idCapture.capture.detecting",
+				guard: "hasStream"
+			}, { target: "#idCapture.capture" }]
+		},
+		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",
+				"cleanupDeepsight"
+			],
+			type: "final"
+		},
+		closed: {
+			entry: [
+				"stopMediaStream",
+				"disposeProvider",
+				"cleanupDeepsight"
+			],
+			type: "final"
+		},
+		error: {
+			entry: [
+				"stopMediaStream",
+				"disposeProvider",
+				"cleanupDeepsight"
+			],
+			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) {
+	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	return createActor(idCaptureMachine, { input: {
+		config: options.config,
+		provider: options.provider,
+		dependencies
+	} }).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 { createSession as _, processId as a, stopStream as c, ID_ERROR_CODES as d, getDisableIpify as f, resetSessionInit as g, isSessionInitialized as h, initializeIdCapture as i, uploadIdImage as l, initializeSession as m, createIdCaptureActor as n, startRecordingSession as o, getSessionFeatures as p, idCaptureMachine as r, stopRecording as s, createIdCaptureManager as t, validateUploadResponse as u };