@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/idCaptureStateMachine-Bq0fVZXl.esm.js

@@ -1,2954 +0,0 @@
-import { l as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider, u as IdCaptureModelType } from "./BaseWasmProvider-C_DLEI40.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { r as getToken, t as api } from "./api-CESGtpbH.esm.js";
-import { S as revokeObjectURL } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { t as getDisableIpify } from "./session-BS-d_vuE.esm.js";
-import { a as fromPromise, i as fromCallback, n as sendTo, o as and, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { n as IncodeCanvas } from "./deepsightService-O74l4Y__.esm.js";
-import { _ as stopRecording$1, a as StreamCanvasCapture, g as startRecording, h as createRecordingSession, i as flagIdManualReview, n as preloadOpenViduProvider, v as StreamCanvasProcessingSession } from "./recordingService-Ig2UgbLv.esm.js";
-import { n as isDesktop } from "./platform-CfrjKhmi.esm.js";
-import { t as getBackCameraStream } from "./backCameraStream-DMdMeGk2.esm.js";
-import { r as getWindowDimensions } from "./getBrowser-BSXUTWXw.esm.js";
-import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
-import { n as requestPermission, t as checkPermission } from "./permissionServices-D_i6nzEw.esm.js";
-
-//#region src/modules/id/digitalUpload/digitalUploadErrors.ts
-const TERMINAL_FAIL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
-function isKnownFailReason(reason) {
-	return reason === "DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED" || reason === "ID_TYPE_UNACCEPTABLE" || reason === "FILE_CHANGED_ERROR" || reason === "NETWORK_ERROR" || reason === "GENERIC";
-}
-function mapDigitalIdFailReason(response) {
-	const failReason = response?.failReason;
-	if (typeof failReason !== "string" || failReason.length === 0) return null;
-	if (isKnownFailReason(failReason)) return failReason;
-	return "GENERIC";
-}
-function isTerminalDigitalIdFailReason(response) {
-	return typeof response?.failReason === "string" && TERMINAL_FAIL_REASONS.has(response.failReason);
-}
-function classifyNetworkError(err) {
-	const message = err instanceof Error ? err.message : String(err);
-	if (message.includes("ERR_UPLOAD_FILE_CHANGED") || message.includes("file changed") || message.includes("FILE_CHANGED")) return "FILE_CHANGED_ERROR";
-	return "NETWORK_ERROR";
-}
-
-//#endregion
-//#region src/modules/id/digitalUpload/digitalUploadServices.ts
-const DIGITAL_ID_UPLOAD_PATH = "/omni/add/front-id";
-async function uploadDigitalIdFile(params) {
-	const { file, signal, onProgress } = params;
-	const response = await api.post(DIGITAL_ID_UPLOAD_PATH, file, {
-		query: { idType: "DigitalId" },
-		headers: { "Content-Type": file.type || "application/pdf" },
-		onUploadProgress: onProgress,
-		signal
-	});
-	if (!response.ok) throw new Error(`POST ${DIGITAL_ID_UPLOAD_PATH} failed: ${response.status}`);
-	return {
-		...response.data,
-		uploadDurationMs: 0
-	};
-}
-
-//#endregion
-//#region src/modules/id/digitalUpload/types.ts
-const DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
-const DIGITAL_UPLOAD_HOLDING_TIMEOUT_MS = 8e3;
-const DIGITAL_UPLOAD_ALLOWED_MIME_TYPES = ["application/pdf"];
-
-//#endregion
-//#region src/modules/id/digitalUpload/digitalUploadStateMachine.ts
-const uploadDigitalIdActor = fromPromise(async ({ input, signal }) => {
-	return uploadDigitalIdFile({
-		file: input.file,
-		signal: input.signal ?? signal,
-		onProgress: input.onProgress
-	});
-});
-const getUploadResponseFromEvent$1 = (event) => {
-	if (!("output" in event)) return;
-	return event.output;
-};
-const _digitalUploadMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {},
-		output: {}
-	},
-	actors: { uploadDigitalId: uploadDigitalIdActor },
-	actions: {
-		requestPickerIfPending: assign(({ context }) => {
-			if (!context.pendingPickerAutoOpen) return {};
-			return {
-				pickerRequestId: context.pickerRequestId + 1,
-				pendingPickerAutoOpen: false
-			};
-		}),
-		setPendingPickerAutoOpen: assign(() => ({ pendingPickerAutoOpen: true })),
-		storeSelectedFile: assign(({ event }) => {
-			if (event.type !== "FILE_PICKED") return {};
-			return {
-				file: event.file,
-				failReason: null
-			};
-		}),
-		clearSelectedFile: assign(() => ({
-			file: null,
-			uploadProgress: 0,
-			failReason: null,
-			response: void 0,
-			uploadDurationMs: void 0
-		})),
-		setInvalidFileTypeError: assign(() => ({ failReason: "INVALID_FILE_TYPE" })),
-		setUploadProgressCapped: assign(({ event }) => {
-			if (event.type !== "UPLOAD_PROGRESS") return {};
-			return { uploadProgress: Math.min(90, Math.max(0, event.progress)) };
-		}),
-		setUploadProgressCompleted: assign(() => ({ uploadProgress: 100 })),
-		storeUploadResponse: assign(({ event }) => {
-			if (!("output" in event)) return {};
-			const output = event;
-			return {
-				response: output.output,
-				uploadDurationMs: output.output.uploadDurationMs
-			};
-		}),
-		setFailReasonFromResponse: assign(({ event }) => {
-			if (!("output" in event)) return {};
-			const response = event.output;
-			return { failReason: mapDigitalIdFailReason(response) ?? "GENERIC" };
-		}),
-		setFailReasonFromNetworkError: assign(({ event }) => {
-			if (!("error" in event)) return {};
-			return { failReason: classifyNetworkError(event.error) };
-		}),
-		decrementAttemptOnRetry: assign(({ context }) => {
-			if (!(context.failReason !== "INVALID_FILE_TYPE" && context.failReason !== null && context.failReason !== "DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED" && context.failReason !== "ID_TYPE_UNACCEPTABLE")) return {};
-			return { attemptsRemaining: Math.max(0, context.attemptsRemaining - 1) };
-		})
-	},
-	guards: {
-		isSelectedFileTooLarge: ({ event }) => event.type === "FILE_PICKED" && event.file.size > DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES,
-		isSelectedFileMimeInvalid: ({ event }) => event.type === "FILE_PICKED" && !DIGITAL_UPLOAD_ALLOWED_MIME_TYPES.includes(event.file.type),
-		hasSelectedFile: ({ context }) => context.file !== null,
-		responseHasFailReason: ({ event }) => mapDigitalIdFailReason(getUploadResponseFromEvent$1(event)) !== null,
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
-		isTerminalFailReason: ({ event }) => {
-			return isTerminalDigitalIdFailReason(getUploadResponseFromEvent$1(event));
-		},
-		isCurrentFailReasonTerminal: ({ context }) => {
-			const terminalReasons = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
-			return context.failReason !== null && terminalReasons.has(context.failReason);
-		}
-	}
-}).createMachine({
-	id: "digitalUpload",
-	initial: "decideStart",
-	context: ({ input }) => ({
-		showTutorial: input.showTutorial,
-		file: null,
-		uploadProgress: 0,
-		attemptsRemaining: input.captureAttempts,
-		failReason: null,
-		response: void 0,
-		uploadDurationMs: void 0,
-		pickerRequestId: 0,
-		pendingPickerAutoOpen: !input.showTutorial,
-		resultType: null
-	}),
-	output: ({ context }) => ({ result: context.resultType ?? "exhausted" }),
-	states: {
-		decideStart: { always: [{
-			guard: ({ context }) => context.showTutorial,
-			target: "tutorial"
-		}, { target: "selecting" }] },
-		tutorial: { on: { NEXT_STEP: {
-			target: "selecting",
-			actions: ["setPendingPickerAutoOpen"]
-		} } },
-		selecting: {
-			entry: ["requestPickerIfPending"],
-			on: { FILE_PICKED: [
-				{
-					guard: "isSelectedFileTooLarge",
-					target: "fileTooLarge",
-					actions: ["clearSelectedFile"]
-				},
-				{
-					guard: "isSelectedFileMimeInvalid",
-					target: "error",
-					actions: ["setInvalidFileTypeError"]
-				},
-				{
-					target: "reviewing",
-					actions: ["storeSelectedFile"]
-				}
-			] }
-		},
-		fileTooLarge: { on: { CHOOSE_ANOTHER: {
-			target: "selecting",
-			actions: ["clearSelectedFile", "setPendingPickerAutoOpen"]
-		} } },
-		reviewing: { on: {
-			CONFIRM: {
-				target: "uploading",
-				guard: "hasSelectedFile"
-			},
-			REPLACE: {
-				target: "selecting",
-				actions: ["setPendingPickerAutoOpen"]
-			}
-		} },
-		uploading: {
-			invoke: {
-				id: "uploadDigitalId",
-				src: "uploadDigitalId",
-				input: ({ context, self }) => ({
-					file: context.file,
-					onProgress: (progress) => {
-						self.send({
-							type: "UPLOAD_PROGRESS",
-							progress
-						});
-					}
-				}),
-				onDone: [
-					{
-						guard: "isTerminalFailReason",
-						target: "retriesExhausted",
-						actions: ["storeUploadResponse", "setFailReasonFromResponse"]
-					},
-					{
-						guard: "responseHasFailReason",
-						target: "checkRetries",
-						actions: ["storeUploadResponse", "setFailReasonFromResponse"]
-					},
-					{
-						target: "success",
-						actions: ["storeUploadResponse", "setUploadProgressCompleted"]
-					}
-				],
-				onError: {
-					target: "checkRetries",
-					actions: ["setFailReasonFromNetworkError"]
-				}
-			},
-			initial: "analyzing",
-			states: {
-				analyzing: { after: { [DIGITAL_UPLOAD_HOLDING_TIMEOUT_MS]: { target: "holding" } } },
-				holding: {}
-			},
-			on: { UPLOAD_PROGRESS: { actions: ["setUploadProgressCapped"] } }
-		},
-		checkRetries: { always: [
-			{
-				guard: "isCurrentFailReasonTerminal",
-				target: "retriesExhausted"
-			},
-			{
-				guard: "hasAttemptsRemaining",
-				target: "error"
-			},
-			{ target: "retriesExhausted" }
-		] },
-		error: { on: {
-			RETRY: {
-				target: "selecting",
-				actions: [
-					"decrementAttemptOnRetry",
-					"setPendingPickerAutoOpen",
-					"clearSelectedFile"
-				]
-			},
-			SCAN_INSTEAD: { target: "closed" }
-		} },
-		retriesExhausted: {
-			type: "final",
-			entry: assign({ resultType: "exhausted" })
-		},
-		closed: {
-			type: "final",
-			entry: assign({ resultType: "closed" })
-		},
-		success: { on: { NEXT_STEP: { target: "completed" } } },
-		completed: {
-			type: "final",
-			entry: assign({ resultType: "success" })
-		}
-	}
-});
-const digitalUploadMachine = _digitalUploadMachine;
-
-//#endregion
-//#region src/modules/id/digitalUpload/instrumentation.ts
-const TERMINAL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
-function isHoldingState(value) {
-	if (value === "holding") return true;
-	if (typeof value !== "object" || value === null) return false;
-	const uploadingState = value.uploading;
-	if (uploadingState === "holding") return true;
-	if (typeof uploadingState === "object" && uploadingState !== null) return Object.prototype.hasOwnProperty.call(uploadingState, "holding");
-	return false;
-}
-function mapDigitalIdScreenName(value, failReason) {
-	if (value === "tutorial") return "uploadDigitalid.tutorial.default";
-	if (value === "selecting" || value === "reviewing") return "uploadDigitalid.review.default";
-	if (value === "uploading" || isHoldingState(value)) return "uploadDigitalid.analyzing.default";
-	if (value === "success") return "uploadDigitalid.success.default";
-	if (value === "fileTooLarge") return "uploadDigitalid.error.filetoolarge";
-	if (value === "error") {
-		if (failReason !== null && TERMINAL_REASONS.has(failReason)) return "uploadDigitalid.error.notaccepted";
-		return "uploadDigitalid.error.default";
-	}
-	return "uploadDigitalid.review.default";
-}
-
-//#endregion
-//#region src/modules/id/idCaptureHelpers.ts
-/**
-* Map of config properties received from the backend to adjusted, internal document types.
-*/
-const DOCUMENT_TYPES_CONFIG_TO_ADJUSTED_MAP = [
-	["enableId", "id"],
-	["enablePassport", "passport"],
-	["manualUploadIdCapture", "manualIdUpload"],
-	["digitalIdsUpload", "digitalIdUpload"],
-	["deviceWallet", "digitalId"]
-];
-/**
-* Returns the list of document types enabled by config for the chooser screen, in display order.
-* Used to populate chooser state so UI and headless consumers can render the correct options.
-*
-* @param config - ID capture configuration (from flow or init)
-* @returns Array of IdDocumentType values that should be shown in the document type chooser
-*/
-function getAvailableDocumentTypes(config) {
-	const adjustedDocumentTypes = [];
-	for (const [configProperty, adjustedType] of DOCUMENT_TYPES_CONFIG_TO_ADJUSTED_MAP) if (config[configProperty]) adjustedDocumentTypes.push(adjustedType);
-	return adjustedDocumentTypes;
-}
-
-//#endregion
-//#region ../infra/src/providers/wasm/IdCaptureProvider.ts
-var IdCaptureProvider = class extends BaseWasmProvider {
-	constructor() {
-		super(WasmPipelineType.IdBlurGlarePipeline);
-		this.lastProcessResult = null;
-		this.capturedCanvas = null;
-		this.originalCapturedCanvas = null;
-	}
-	async initialize(config) {
-		await this.initializeBase(config, "idCapture");
-	}
-	setCallbacks(callbacks) {
-		this.ensureInitialized();
-		const onCaptureWrapper = () => {
-			callbacks.onCapture?.();
-		};
-		mlWasmJSApi_default.setIdCaptureCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onDetectionStarted ?? (() => {}), callbacks.onMaskChange ? (show, mask, top, orientation) => callbacks.onMaskChange?.(show, mask, top, orientation) : () => {}, callbacks.onBlur ?? (() => {}), callbacks.onGlare ?? (() => {}), callbacks.onCapturing ?? (() => {}), callbacks.onCapture ? onCaptureWrapper : () => {}, callbacks.onBestFrame ? (blur, glare, orientation) => callbacks.onBestFrame?.(blur, glare, orientation) : () => {}, callbacks.onIdNotDetected ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onIdTypeChange ? (idType) => callbacks.onIdTypeChange?.(idType) : () => {}, callbacks.onIdSideChange ? (side) => callbacks.onIdSideChange?.(side) : () => {}, callbacks.onCapturingCounterValueChange ? (value) => callbacks.onCapturingCounterValueChange?.(value) : () => {});
-	}
-	setThresholds(thresholds) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureThresholds(this.getPipelineType(), thresholds.blurThreshold, thresholds.blurChangeThreshold, thresholds.glareThreshold, thresholds.clsThreshold, thresholds.sideThreshold, thresholds.iouThreshold, thresholds.idDetectedTimeout, thresholds.autocaptureTimeout, thresholds.framesAggregationInterval);
-	}
-	setGeometry(geometry) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureGeometryParams(this.getPipelineType(), geometry.areaDown, geometry.areaUp, geometry.areaIOSPassportUp, geometry.areaIOSPassportDown, geometry.widthIOSUp, geometry.widthIOSDown, geometry.widthDown, geometry.widthUp, geometry.windowOuterWidth, geometry.windowOuterHeight, geometry.windowInnerWidth, geometry.windowInnerHeight);
-	}
-	setSettings(settings) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureConfigParams(this.getPipelineType(), settings.isFixedMask, settings.isIPhone14OrHigher, settings.idType, settings.blurCheckEnabled, settings.glareCheckEnabled, settings.faceQualityCheckEnabled, settings.iouCheckEnabled, settings.fpsLimitEnabled);
-	}
-	setModelType(modelType) {
-		this.ensureInitialized();
-		let wasmModelType;
-		switch (modelType) {
-			case "v1":
-				wasmModelType = IdCaptureModelType.IdCaptureV1x;
-				break;
-			case "v2":
-				wasmModelType = IdCaptureModelType.IdCaptureV2x;
-				break;
-			case "v3":
-				wasmModelType = IdCaptureModelType.IdCaptureV3x;
-				break;
-			default: throw new Error(`Unknown model type: ${modelType}`);
-		}
-		mlWasmJSApi_default.setIdCaptureModelType(this.getPipelineType(), wasmModelType);
-	}
-	/**
-	* Processes a frame through the WASM pipeline and stores the result.
-	*/
-	async processFrame(image) {
-		const result = await this.processFrameWasm(image);
-		const pipelineType = this.getPipelineType();
-		if (result && pipelineType === WasmPipelineType.IdBlurGlarePipeline) this.lastProcessResult = result;
-		else this.lastProcessResult = null;
-	}
-	/**
-	* Gets the last process result from the most recent frame processing.
-	* @returns The last process result with quad coordinates, or null if not available
-	*/
-	getLastProcessResult() {
-		return this.lastProcessResult;
-	}
-	transformPerspective(canvas, frameRect) {
-		this.ensureInitialized();
-		const originalWidth = canvas.width();
-		const originalHeight = canvas.height();
-		try {
-			const imageData = canvas.getImageData();
-			if (!imageData) return canvas;
-			const transformedCanvas = mlWasmJSApi_default.IdPerspectiveTransform(imageData, frameRect);
-			if (transformedCanvas) {
-				const wrappedCanvas = new IncodeCanvas(transformedCanvas);
-				const wrappedWidth = wrappedCanvas.width();
-				const wrappedHeight = wrappedCanvas.height();
-				if (wrappedWidth === originalWidth && wrappedHeight === originalHeight) {
-					const croppedCanvas = this.cropCanvasToRect(wrappedCanvas, {
-						x: Math.round(frameRect.x),
-						y: Math.round(frameRect.y),
-						w: Math.round(frameRect.w),
-						h: Math.round(frameRect.h)
-					});
-					if (croppedCanvas) return croppedCanvas;
-				}
-				return wrappedCanvas;
-			}
-			return canvas;
-		} catch (_error) {
-			return canvas;
-		}
-	}
-	/**
-	* Crops a canvas to the specified rectangle region.
-	* @param canvas - The canvas to crop
-	* @param rect - The rectangle to crop to (x, y, w, h)
-	* @returns A new IncodeCanvas with the cropped region, or null if cropping fails
-	*/
-	cropCanvasToRect(canvas, rect) {
-		const canvasWidth = canvas.width();
-		const canvasHeight = canvas.height();
-		if (!canvasWidth || !canvasHeight) return null;
-		const x = Math.max(0, Math.min(rect.x, canvasWidth));
-		const y = Math.max(0, Math.min(rect.y, canvasHeight));
-		const w = Math.max(1, Math.min(rect.w, canvasWidth - x));
-		const h = Math.max(1, Math.min(rect.h, canvasHeight - y));
-		const croppedCanvasElement = document.createElement("canvas");
-		croppedCanvasElement.width = w;
-		croppedCanvasElement.height = h;
-		const ctx = croppedCanvasElement.getContext("2d");
-		if (!ctx) return null;
-		ctx.drawImage(canvas.canvas, x, y, w, h, 0, 0, w, h);
-		return new IncodeCanvas(croppedCanvasElement);
-	}
-	/**
-	* Gets the captured canvas (transformed for preview).
-	* @returns The captured canvas, or null if not available
-	*/
-	getCapturedCanvas() {
-		return this.capturedCanvas;
-	}
-	/**
-	* Gets the original captured canvas (full frame for upload).
-	* @returns The original captured canvas, or null if not available
-	*/
-	getOriginalCapturedCanvas() {
-		return this.originalCapturedCanvas;
-	}
-	/**
-	* Sets the captured canvases (original and transformed).
-	* @param original - The original full-frame canvas (for upload)
-	* @param transformed - The transformed canvas (for preview)
-	*/
-	setCapturedCanvases(original, transformed) {
-		this.originalCapturedCanvas = original;
-		this.capturedCanvas = transformed;
-	}
-	reset() {
-		super.reset();
-		this.lastProcessResult = null;
-		this.capturedCanvas = null;
-		this.originalCapturedCanvas = null;
-	}
-};
-
-//#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
-async function getIdCameraStream(deviceId) {
-	return getBackCameraStream(deviceId);
-}
-
-//#endregion
-//#region src/modules/id/manualUpload/types.ts
-const MANUAL_UPLOAD_MAX_RETRIES = 3;
-const MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
-const MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS = 5e3;
-
-//#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
-/**
-* 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 }
-	} };
-}
-function getUploadEndpoint(type, isSecondId) {
-	if (isSecondId) return type === "front" ? endpoints.frontSecondId : endpoints.backSecondId;
-	return type === "front" ? endpoints.frontId : endpoints.backId;
-}
-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
-};
-const DEFAULT_ID_CAPTURE_SETTINGS = {
-	isFixedMask: false,
-	isIPhone14OrHigher: false,
-	idType: "",
-	blurCheckEnabled: false,
-	glareCheckEnabled: false,
-	faceQualityCheckEnabled: true,
-	iouCheckEnabled: true,
-	fpsLimitEnabled: false
-};
-async function initializeIdCapture(params) {
-	const { config, deepsightService } = params;
-	const provider = new IdCaptureProvider();
-	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 {}
-	const { stream, fallbackLevel } = await getIdCameraStream();
-	const videoTrack = stream.getVideoTracks()[0];
-	let captureResolution;
-	if (videoTrack) {
-		const settings = videoTrack.getSettings();
-		if (typeof settings.width === "number" && typeof settings.height === "number") captureResolution = `${settings.width}x${settings.height}`;
-	}
-	if (deepsightService && videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
-	return {
-		stream,
-		provider,
-		captureResolution,
-		cameraFallbackLevel: fallbackLevel
-	};
-}
-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, isSecondId, onlyFront } = params;
-	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 = getUploadEndpoint(type, isSecondId);
-	const body = {
-		base64Image: image,
-		metadata: finalMetadata
-	};
-	const queryParams = { imageType: "id" };
-	if (onlyFront && type === "front") queryParams.onlyFront = true;
-	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";
-}
-function preloadIdRecordingProvider(config) {
-	if (config.enableIdRecording !== true) return;
-	preloadOpenViduProvider();
-}
-async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-CMu6XVdc.esm.js");
-	return new OpenViduRecordingProvider();
-}
-async function startRecordingSession(params) {
-	if (params.config.enableIdRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
-	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: {}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: params.type,
-		resolution,
-		hasAudio
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
-}
-function stopRecording(session) {
-	(async () => {
-		try {
-			await stopRecording$1(session.videoRecordingId);
-		} finally {
-			await session.connection.disconnect();
-		}
-	})();
-}
-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 };
-}
-/**
-* Upload a user-selected image as front / back / passport ID.
-*
-* Uses the same request shape as the live-camera path (`uploadIdImage`):
-* JSON body `{ base64Image }` with default application/json Content-Type,
-* `captureType=UPLOAD` query param, `retry=true` when retrying.
-* Back is POSTed to `/omni/add/back-id/v2` (or `/omni/add/back-second-id/v2`
-* when `isSecondId`); front and passport go to `/omni/add/front-id/v2` (or
-* `/omni/add/front-second-id/v2` when `isSecondId`).
-*
-* The v2 endpoints reject raw `image/jpeg` bodies with 415, so the caller
-* must convert the File to base64 before calling this service.
-*/
-async function uploadManualIdFile(params) {
-	const { side, base64Image, retry, onlyFront, signal, isSecondId } = params;
-	const endpoint = getUploadEndpoint(side === "back" ? "back" : "front", isSecondId);
-	const queryParams = { captureType: "UPLOAD" };
-	if (retry) queryParams.retry = true;
-	if (onlyFront && side === "front") queryParams.onlyFront = true;
-	const res = await api.post(endpoint, { base64Image }, {
-		signal,
-		query: queryParams
-	});
-	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
-//#endregion
-//#region src/modules/id/manualUpload/manualUploadErrors.ts
-/**
-* i18n keys for manual-upload user-facing error copy.
-* Keep in sync with `packages/ui/src/i18n/**.json` under the `manualIdUpload.*` namespace.
-*/
-const MANUAL_UPLOAD_ERROR_KEYS = {
-	wrongSide: "manualIdUpload.wrongSide",
-	wrongDocument: "manualIdUpload.wrongDocument",
-	fileTooBig: "manualIdUpload.fileTooBig",
-	generic: "manualIdUpload.generic",
-	lowSharpness: "manualIdUpload.lowSharpness",
-	glareDetected: "manualIdUpload.glareDetected",
-	readabilityIssue: "manualIdUpload.readabilityIssue",
-	qualityRejected: "manualIdUpload.qualityRejected"
-};
-/**
-* Map the server's `failReason` (plus client-side passport/ID tab mismatch and
-* per-image quality flags) onto an i18n key. Mirrors v1's `shouldUploadAgain`
-* branch logic in
-* `ms-incodesmile-web/packages/incode-welcome/src/manualIdUpload/manuaIdUpload.tsx`,
-* extended to also reject responses where the backend flagged a per-image
-* quality issue (`correctSharpness`, `correctGlare`, `readability`, or
-* `idQualityAttemptApproved` set to `false`).
-*
-* Quality flags are checked with `=== false` so missing/undefined values
-* (older backends, partial payloads) keep the legacy "trust the server"
-* behaviour and do not produce false positives.
-*
-* Returns `null` when the response represents a successful upload — the caller
-* should treat `null` as "no error, advance to next slot".
-*/
-function mapFailReasonToErrorKey(response, expectedTab) {
-	const failReason = response.failReason;
-	if (failReason === "WRONG_DOCUMENT_SIDE") return MANUAL_UPLOAD_ERROR_KEYS.wrongSide;
-	if (failReason === "WRONG_ONE_SIDED_DOCUMENT" || failReason === "UNKNOWN_DOCUMENT_TYPE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (failReason === "ID_TYPE_UNACCEPTABLE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (expectedTab === "passport" && response.typeOfId && response.typeOfId.toLowerCase() !== "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (expectedTab === "id" && response.typeOfId?.toLowerCase() === "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (response.correctSharpness === false) return MANUAL_UPLOAD_ERROR_KEYS.lowSharpness;
-	if (response.correctGlare === false) return MANUAL_UPLOAD_ERROR_KEYS.glareDetected;
-	if (response.readability === false) return MANUAL_UPLOAD_ERROR_KEYS.readabilityIssue;
-	if (response.idQualityAttemptApproved === false) return MANUAL_UPLOAD_ERROR_KEYS.qualityRejected;
-	return null;
-}
-
-//#endregion
-//#region src/modules/id/manualUpload/manualUploadServices.ts
-/**
-* Read a File's bytes and return the raw base64 payload (the portion after
-* `data:<mime>;base64,`). The backend's `/omni/add/*-id/v2` endpoints reject
-* full data-URLs with `IllegalArgumentException: Illegal base64 character 3a`,
-* so the prefix must be stripped before posting. Mirrors the live-camera
-* path in `packages/infra/src/media/canvas.ts:getBase64Image()`.
-*/
-function fileToBase64Payload(file) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onload = () => {
-			const result = reader.result;
-			if (typeof result !== "string") {
-				reject(/* @__PURE__ */ new Error("FileReader produced non-string result"));
-				return;
-			}
-			const commaIndex = result.indexOf(",");
-			resolve(commaIndex === -1 ? result : result.slice(commaIndex + 1));
-		};
-		reader.onerror = () => {
-			reject(reader.error ?? /* @__PURE__ */ new Error("FileReader failed"));
-		};
-		reader.readAsDataURL(file);
-	});
-}
-
-//#endregion
-//#region src/modules/id/manualUpload/manualUploadStateMachine.ts
-const uploadManualFileActor = fromPromise(async ({ input, signal }) => {
-	const base64Image = await fileToBase64Payload(input.file);
-	return uploadManualIdFile({
-		side: input.side,
-		base64Image,
-		retry: input.retry,
-		onlyFront: input.onlyFront,
-		isSecondId: input.isSecondId,
-		signal
-	});
-});
-const getUploadResponseFromEvent = (event) => {
-	if ("output" in event) return event.output;
-};
-const _manualUploadMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {},
-		output: {}
-	},
-	actors: { uploadManualFile: uploadManualFileActor },
-	actions: {
-		setManualUploadActiveTab: assign(({ context, event }) => {
-			if (event.type !== "MANUAL_UPLOAD_TAB_CHANGED") return {};
-			return {
-				activeTab: event.tab,
-				frontFile: null,
-				backFile: null,
-				passportFile: null,
-				frontUploaded: false,
-				backUploaded: false,
-				passportUploaded: false,
-				skipBackFromServer: false,
-				errorMessage: null,
-				retriesLeft: context.captureAttempts
-			};
-		}),
-		resetManualUpload: assign(({ context }) => ({
-			frontFile: null,
-			backFile: null,
-			passportFile: null,
-			frontUploaded: false,
-			backUploaded: false,
-			passportUploaded: false,
-			skipBackFromServer: false,
-			errorMessage: null,
-			retriesLeft: context.captureAttempts
-		})),
-		storeSelectedFile: assign(({ event }) => {
-			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return {};
-			const updated = { errorMessage: null };
-			if (event.side === "front") updated.frontFile = event.file;
-			else if (event.side === "back") updated.backFile = event.file;
-			else updated.passportFile = event.file;
-			return updated;
-		}),
-		markFrontUploaded: assign(() => ({
-			frontUploaded: true,
-			errorMessage: null
-		})),
-		markBackUploaded: assign(() => ({
-			backUploaded: true,
-			errorMessage: null
-		})),
-		markPassportUploaded: assign(() => ({
-			passportUploaded: true,
-			errorMessage: null
-		})),
-		recordSkipBackFromResponse: assign(({ event }) => {
-			if (!("output" in event)) return {};
-			if (!event.output.skipBackIdCapture) return {};
-			return { skipBackFromServer: true };
-		}),
-		decrementManualUploadRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
-		setManualUploadErrorFromResponse: assign(({ context, event }) => {
-			if (!("output" in event)) return {};
-			const response = event.output;
-			return { errorMessage: mapFailReasonToErrorKey(response, context.activeTab) ?? "manualIdUpload.generic" };
-		}),
-		setManualUploadGenericError: assign(() => ({ errorMessage: "manualIdUpload.generic" })),
-		setManualUploadFileTooLargeError: assign(() => ({ errorMessage: "manualIdUpload.fileTooBig" })),
-		clearManualUploadError: assign(() => ({ errorMessage: null }))
-	},
-	guards: {
-		isSelectedFileTooLarge: ({ event }) => {
-			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return false;
-			return event.file.size > MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES;
-		},
-		isFrontFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "front",
-		isBackFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "back",
-		isPassportFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "passport",
-		manualUploadRetriesExhausted: ({ context }) => context.retriesLeft <= 0,
-		canContinueFromIdTab: ({ context }) => {
-			if (context.activeTab !== "id") return false;
-			if (!context.frontUploaded) return false;
-			if (context.onlyFront) return true;
-			if (context.skipBackFromServer) return true;
-			return context.backUploaded;
-		},
-		canContinueFromPassportTab: ({ context }) => context.activeTab === "passport" && context.passportUploaded,
-		manualUploadResponseHasError: ({ context, event }) => {
-			const response = getUploadResponseFromEvent(event);
-			if (!response) return false;
-			return mapFailReasonToErrorKey(response, context.activeTab) !== null;
-		}
-	}
-}).createMachine({
-	id: "manualUpload",
-	initial: "selecting",
-	context: ({ input }) => ({
-		onlyFront: input.onlyFront,
-		isSecondId: input.isSecondId,
-		captureAttempts: input.captureAttempts,
-		frontFile: null,
-		backFile: null,
-		passportFile: null,
-		activeTab: "id",
-		retriesLeft: input.captureAttempts,
-		errorMessage: null,
-		skipBackFromServer: false,
-		frontUploaded: false,
-		backUploaded: false,
-		passportUploaded: false
-	}),
-	on: {
-		MANUAL_UPLOAD_TAB_CHANGED: {
-			target: ".selecting",
-			actions: ["setManualUploadActiveTab"]
-		},
-		MANUAL_UPLOAD_RESET: {
-			target: ".selecting",
-			actions: ["resetManualUpload"]
-		}
-	},
-	states: {
-		selecting: { on: {
-			MANUAL_UPLOAD_FILE_SELECTED: [
-				{
-					guard: "isSelectedFileTooLarge",
-					actions: ["setManualUploadFileTooLargeError"]
-				},
-				{
-					guard: "isFrontFileSelection",
-					target: "uploadingFront",
-					actions: ["storeSelectedFile"]
-				},
-				{
-					guard: "isBackFileSelection",
-					target: "uploadingBack",
-					actions: ["storeSelectedFile"]
-				},
-				{
-					guard: "isPassportFileSelection",
-					target: "uploadingPassport",
-					actions: ["storeSelectedFile"]
-				}
-			],
-			MANUAL_UPLOAD_CONTINUE: [{
-				guard: "canContinueFromIdTab",
-				target: "finished"
-			}, {
-				guard: "canContinueFromPassportTab",
-				target: "finished"
-			}]
-		} },
-		uploadingFront: { invoke: {
-			id: "uploadManualFile",
-			src: "uploadManualFile",
-			input: ({ context }) => ({
-				side: "front",
-				file: context.frontFile,
-				retry: context.retriesLeft < context.captureAttempts,
-				onlyFront: context.onlyFront,
-				isSecondId: context.isSecondId
-			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-			}, {
-				target: "selecting",
-				actions: [
-					"markFrontUploaded",
-					"recordSkipBackFromResponse",
-					"clearManualUploadError"
-				]
-			}],
-			onError: {
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-			}
-		} },
-		uploadingBack: { invoke: {
-			id: "uploadManualFile",
-			src: "uploadManualFile",
-			input: ({ context }) => ({
-				side: "back",
-				file: context.backFile,
-				retry: context.retriesLeft < context.captureAttempts,
-				onlyFront: false,
-				isSecondId: context.isSecondId
-			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-			}, {
-				target: "selecting",
-				actions: ["markBackUploaded", "clearManualUploadError"]
-			}],
-			onError: {
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-			}
-		} },
-		uploadingPassport: { invoke: {
-			id: "uploadManualFile",
-			src: "uploadManualFile",
-			input: ({ context }) => ({
-				side: "passport",
-				file: context.passportFile,
-				retry: context.retriesLeft < context.captureAttempts,
-				onlyFront: false,
-				isSecondId: context.isSecondId
-			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-			}, {
-				target: "selecting",
-				actions: ["markPassportUploaded", "clearManualUploadError"]
-			}],
-			onError: {
-				target: "checkRetries",
-				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-			}
-		} },
-		checkRetries: { always: [{
-			guard: "manualUploadRetriesExhausted",
-			target: "retriesExhausted"
-		}, { target: "selecting" }] },
-		retriesExhausted: { after: { [MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS]: { target: "exhausted" } } },
-		exhausted: {
-			type: "final",
-			output: { result: "exhausted" }
-		},
-		finished: {
-			type: "final",
-			output: { result: "success" }
-		}
-	}
-});
-const manualUploadMachine = _manualUploadMachine;
-
-//#endregion
-//#region ../infra/src/wasm/idCaptureDefaults.ts
-/**
-* Default WASM thresholds for ID capture quality checks.
-* Based on legacy pipelinesConfig.ts values.
-*/
-const DEFAULT_ID_CAPTURE_THRESHOLDS = {
-	blurThreshold: .2,
-	blurChangeThreshold: .2,
-	glareThreshold: .3,
-	clsThreshold: .98,
-	sideThreshold: .8,
-	iouThreshold: .8,
-	idDetectedTimeout: 1e4,
-	autocaptureTimeout: 5e3,
-	framesAggregationInterval: 3e3
-};
-/**
-* Default model version for ID capture.
-*/
-const DEFAULT_ID_CAPTURE_MODEL_VERSION = "v2";
-
-//#endregion
-//#region src/modules/id/idCaptureActors.ts
-const checkPermissionActor = fromPromise(async () => {
-	return checkPermission();
-});
-const requestPermissionActor = fromPromise(async ({ input }) => {
-	return requestPermission({ requestMotion: input.requestMotionPermission });
-});
-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;
-	let lastReportedSide = null;
-	const NOTIFICATION_DURATION_MS = 500;
-	const isReportedSideWrong = () => {
-		if (!lastReportedSide) return false;
-		const detectedSide = lastReportedSide.toLowerCase();
-		if (detectedSide === "wrong") return true;
-		const isBackDetected = detectedSide.includes("back") && !detectedSide.includes("front");
-		const isFrontDetected = detectedSide.includes("front") && !detectedSide.includes("back");
-		return input.currentMode === "front" && isBackDetected || input.currentMode === "back" && isFrontDetected;
-	};
-	const clearNotificationTimeout = () => {
-		if (notificationTimeout) {
-			timer.clearTimeout(notificationTimeout);
-			notificationTimeout = null;
-			currentNotificationStatus = null;
-		}
-	};
-	const sendNotification = (status) => {
-		if (isReportedSideWrong()) return;
-		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" ? "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,
-		fpsLimitEnabled: input.config.settings?.fpsLimitEnabled ?? false
-	});
-	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: "SWITCH_TO_MANUAL_CAPTURE" });
-		},
-		onCapturing: () => {
-			clearNotificationTimeout();
-			lastReportedSide = null;
-			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;
-			lastReportedSide = side;
-			if (isReportedSideWrong()) clearNotificationTimeout();
-			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;
-				lastReportedSide = null;
-				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;
-	const logs = input.deepsightService?.getPipelineState() ?? "";
-	input.dependencies?.trackCaptureAttemptFinished?.({
-		logs,
-		resolution: input.captureResolution,
-		fallbackLevel: input.cameraFallbackLevel
-	});
-	return uploadIdImage({
-		image,
-		type: input.type,
-		sendBase64: true,
-		glare: input.qualityElements?.glare,
-		sharpness: input.qualityElements?.sharpness,
-		ageAssurance: input.ageAssurance,
-		signal,
-		onProgress: input.onProgress,
-		metadata,
-		analyticsProvider: input.analyticsProvider,
-		imageData,
-		isSecondId: input.isSecondId,
-		onlyFront: input.onlyFront
-	});
-});
-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-Cm4JIT_z.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 performResetForFrontCapture(context) {
-	context.frameCapturer?.dispose();
-	if (context.stream) stopStream(context.stream);
-	context.provider?.reset();
-}
-function performResetDetection(context) {
-	context.resetDetection?.();
-}
-function performTrackTutorialId() {}
-function performTrackContinue() {}
-function performTrackCameraId(context) {}
-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 getCaptureResolutionFromEvent(event) {
-	if ("output" in event) return event.output.captureResolution;
-}
-function getCameraFallbackLevelFromEvent(event) {
-	if ("output" in event) return event.output.cameraFallbackLevel;
-}
-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" : context.config.usSmartCapture ? "back" : "front";
-	return {
-		stream: void 0,
-		provider: context.provider,
-		frameCapturer: void 0,
-		error: void 0,
-		detectionStatus: "idle",
-		counterValue: 0,
-		orientation: void 0,
-		capturedImages: {},
-		captureOnlyImages: {},
-		uploadResponse: void 0,
-		recordingSession: void 0,
-		attemptsRemaining: context.config.captureAttempts,
-		expiredAttempts: 0,
-		skipProcessId: false,
-		expiredFromUpload: false,
-		isDigitalUpload: false,
-		exhaustedFromUpload: false,
-		forceFinishAfterProcessing: false,
-		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,
-		captureResolution: void 0,
-		cameraFallbackLevel: void 0
-	};
-}
-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 (currentStatus === "wrongSide") {
-			if (!(newStatus === "capturing" || newStatus === "manualCapture" || newStatus === "offline")) return currentStatus;
-			return newStatus;
-		}
-		if ((newStatus === "blur" || newStatus === "glare") && 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 context.config.usSmartCapture ? "back" : "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 hasAgeAssuranceGuard = ({ context }) => context.config.ageAssurance === true;
-const hasShowDocumentChooserGuard = ({ context }) => !context.config.onlyBack && (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";
-/**
-* `config.onlyFront` from the orchestrated flow JSON is intentionally not
-* read here: the flow value cannot account for per-document overrides, so the
-* backend resolves the real policy per document at upload time
-* (via `skipBackIdCapture` on the upload response). Standalone
-* `idCaptureManager` consumers that pass `onlyFront: true` directly will
-* therefore also be ignored — re-wire this guard if that capability is needed
-* again.
-*/
-const isOnlyFrontGuard = (_args) => false;
-const shouldContinueToBackGuard = ({ context }) => {
-	if (context.currentMode !== "front" && context.currentMode !== "passport") return false;
-	if (context.config.onlyBack) return false;
-	if (context.config.usSmartCapture) return false;
-	if (context.uploadResponse?.skipBackIdCapture) {
-		if (!(context.config.alwaysCaptureBackOfId === true && context.currentMode !== "passport")) return false;
-	}
-	return true;
-};
-const shouldContinueToFrontGuard = ({ context }) => context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
-const hasMandatoryConsentGuard = ({ context }) => context.uploadResponse?.showMandatoryConsent === 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;
-const hasOnlyManualUploadAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 1 && context.availableDocumentTypes[0] === "manualIdUpload";
-const isManualIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "manualIdUpload";
-const isDigitalIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "digitalIdUpload";
-const isUploadExpiredGuard = ({ context }) => context.uploadResponse?.isDocumentExpired === true;
-/**
-* True when *this* expired upload will exhaust the budget. Compares the
-* post-increment count, so the exhaustion branch can be picked in the same
-* tick that runs `incrementExpiredAttempts`. With `captureAttempts=3`:
-* - attempt 1 → 0+1=1 (not exhausted)
-* - attempt 2 → 1+1=2 (not exhausted)
-* - attempt 3 → 2+1=3 (exhausted, force-back / finish)
-*/
-const isExpiredAttemptsExhaustedGuard = ({ context }) => context.expiredAttempts + 1 >= context.config.captureAttempts;
-const isNotPassportModeGuard = ({ context }) => context.currentMode !== "passport";
-/**
-* V1 parity for `shouldApplyAlwaysCaptureBackOverride` — force-redirects to
-* back capture after expired-front-attempts exhaust, but only when:
-* - we're on the front side
-* - `alwaysCaptureBackOfId` is set
-* - the flow isn't single-side (onlyBack / usSmartCapture)
-* - the session isn't a Digital ID upload (digital IDs are PDFs — no back
-*   side exists, so the override never applies regardless of config)
-*/
-const shouldForceBackOnExpiredGuard = ({ context }) => context.currentMode === "front" && context.config.alwaysCaptureBackOfId === true && !context.config.onlyBack && !context.config.usSmartCapture && !context.isDigitalUpload;
-const wasExpiredFromUploadGuard = ({ context }) => context.expiredFromUpload === true;
-const shouldSkipProcessIdGuard = ({ context }) => context.skipProcessId === true;
-/**
-* Bug 4 fix: when `expiredExhausted` is reached via the per-upload-expired
-* exhaustion path with a back side captured (or the entire single-side back
-* flow), we want `processId` to run once on Continue so the backend
-* processes whatever sides were uploaded. Front-only exhaustion (no back to
-* process) and the force-back V1 path keep using `setSkipProcessId` instead.
-*/
-const shouldProcessAfterExhaustionGuard = ({ context }) => context.exhaustedFromUpload === true && context.currentMode === "back";
-/**
-* `processing.onDone` reads this to short-circuit straight to `finished`
-* after the post-exhaustion `processId` call returns — without it, an
-* `isDocumentExpired:true` response would loop back to the Expired screen
-* we just terminated.
-*/
-const forceFinishAfterProcessingGuard = ({ context }) => context.forceFinishAfterProcessing === true;
-/**
-* Cap on the end-of-flow expired path. All capture types (camera, digital,
-* manual) share `config.captureAttempts` for consistency — the user-visible
-* "X attempts remaining" counter is the same regardless of how the document
-* was submitted.
-*/
-const isProcessingExpiredExhaustedGuard = ({ context }) => context.processingExpiredAttempts + 1 >= context.config.captureAttempts;
-
-//#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,
-		manualUploadMachine,
-		digitalUploadMachine
-	},
-	actions: {
-		stopMediaStream: assign(({ context }) => {
-			performStopMediaStream(context);
-			return {
-				stream: void 0,
-				frameCapturer: void 0
-			};
-		}),
-		disposeProvider: ({ context }) => {
-			performDisposeProvider(context);
-		},
-		cleanupDeepsight: ({ context }) => {
-			performCleanupDeepsight(context);
-		},
-		flagIdManualReview: () => {
-			flagIdManualReview();
-		},
-		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,
-				attemptsRemaining: context.config.captureAttempts,
-				expiredAttempts: 0,
-				expiredFromUpload: false,
-				exhaustedFromUpload: false,
-				forceFinishAfterProcessing: false,
-				captureResolution: void 0,
-				cameraFallbackLevel: void 0
-			};
-		}),
-		resetForFrontCapture: assign(({ context }) => {
-			performResetForFrontCapture(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,
-				attemptsRemaining: context.config.captureAttempts,
-				expiredAttempts: 0,
-				expiredFromUpload: false,
-				exhaustedFromUpload: false,
-				forceFinishAfterProcessing: false,
-				captureResolution: void 0,
-				cameraFallbackLevel: void 0
-			};
-		}),
-		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,
-				attemptsRemaining: context.config.captureAttempts
-			};
-		}),
-		setStreamAndCapturer: assign({
-			stream: ({ event }) => getStreamFromEvent(event),
-			provider: ({ event }) => getProviderFromEvent(event),
-			frameCapturer: ({ event }) => getFrameCapturerFromEvent(event),
-			captureResolution: ({ event }) => getCaptureResolutionFromEvent(event),
-			cameraFallbackLevel: ({ event }) => getCameraFallbackLevelFromEvent(event)
-		}),
-		trackTutorialId: () => {
-			/* @__PURE__ */ performTrackTutorialId();
-		},
-		trackContinue: () => {
-			/* @__PURE__ */ performTrackContinue();
-		},
-		trackCameraId: ({ context }) => {
-			/* @__PURE__ */ performTrackCameraId(context);
-		},
-		preloadRecordingProvider: ({ context }) => {
-			preloadIdRecordingProvider(context.config);
-		},
-		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)),
-		clearStreamForRetry: assign(({ context }) => {
-			performStopMediaStream(context);
-			performDisposeProvider(context);
-			return {
-				stream: void 0,
-				provider: void 0,
-				frameCapturer: void 0,
-				captureResolution: void 0,
-				cameraFallbackLevel: void 0
-			};
-		}),
-		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;
-		} }),
-		incrementExpiredAttempts: assign(({ context }) => ({ expiredAttempts: context.expiredAttempts + 1 })),
-		storeDigitalUploadResponse: assign(({ self }) => {
-			const response = ((self.getSnapshot().children?.["digitalIdUpload"]?.getSnapshot())?.context)?.response;
-			if (!response) return { isDigitalUpload: true };
-			return {
-				uploadResponse: response,
-				isDigitalUpload: true
-			};
-		}),
-		incrementProcessingExpiredAttempts: assign(({ context }) => ({ processingExpiredAttempts: context.processingExpiredAttempts + 1 })),
-		setSkipProcessId: assign({ skipProcessId: () => true }),
-		setExpiredFromUpload: assign({ expiredFromUpload: () => true }),
-		setExhaustedFromUpload: assign({ exhaustedFromUpload: () => true }),
-		setForceFinishAfterProcessing: assign({ forceFinishAfterProcessing: () => true }),
-		clearExpiredFromUpload: assign({ expiredFromUpload: () => false })
-	},
-	guards: {
-		hasShowTutorial: hasShowTutorialGuard,
-		hasAgeAssurance: hasAgeAssuranceGuard,
-		hasShowDocumentChooser: hasShowDocumentChooserGuard,
-		isPermissionGranted: isPermissionGrantedGuard,
-		isPermissionDeniedError: isPermissionDeniedErrorGuard,
-		hasStream: hasStreamGuard,
-		hasAttemptsRemaining: hasAttemptsRemainingGuard,
-		hasCapturedImage: hasCapturedImageGuard,
-		hasUploadValidationError: hasUploadValidationErrorGuard,
-		isFrontMode: isFrontModeGuard,
-		isOnlyFront: isOnlyFrontGuard,
-		shouldContinueToBack: shouldContinueToBackGuard,
-		shouldContinueToFront: shouldContinueToFrontGuard,
-		hasMandatoryConsent: hasMandatoryConsentGuard,
-		isDeepsightEnabled: isDeepsightEnabledGuard,
-		isDeepsightReady: isDeepsightReadyGuard,
-		needsDeepsightInit: needsDeepsightInitGuard,
-		hasOnlyManualUploadAvailable: hasOnlyManualUploadAvailableGuard,
-		isManualIdUploadSelected: isManualIdUploadSelectedGuard,
-		isDigitalIdUploadSelected: isDigitalIdUploadSelectedGuard,
-		isUploadExpired: isUploadExpiredGuard,
-		isExpiredAttemptsExhausted: isExpiredAttemptsExhaustedGuard,
-		isNotPassportMode: isNotPassportModeGuard,
-		shouldForceBackOnExpired: shouldForceBackOnExpiredGuard,
-		wasExpiredFromUpload: wasExpiredFromUploadGuard,
-		shouldSkipProcessId: shouldSkipProcessIdGuard,
-		isProcessingExpiredExhausted: isProcessingExpiredExhaustedGuard,
-		shouldProcessAfterExhaustion: shouldProcessAfterExhaustionGuard,
-		forceFinishAfterProcessing: forceFinishAfterProcessingGuard,
-		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted",
-		isDigitalUploadExhausted: ({ event }) => event.output?.result === "exhausted",
-		isDigitalUploadClosed: ({ event }) => event.output?.result === "closed",
-		isDigitalUploadSuccessful: ({ event }) => event.output?.result === "success"
-	}
-}).createMachine({
-	id: "idCapture",
-	initial: "idle",
-	context: ({ input }) => {
-		const currentMode = input.config.onlyBack ? "back" : !input.config.enableId && input.config.enablePassport ? "passport" : input.config.usSmartCapture ? "back" : "front";
-		return {
-			config: input.config,
-			currentMode,
-			selectedDocumentType: void 0,
-			stream: void 0,
-			provider: void 0,
-			frameCapturer: void 0,
-			error: void 0,
-			detectionStatus: "idle",
-			counterValue: 0,
-			orientation: void 0,
-			capturedImages: {},
-			captureOnlyImages: {},
-			uploadResponse: void 0,
-			recordingSession: void 0,
-			attemptsRemaining: input.config.captureAttempts,
-			expiredAttempts: 0,
-			processingExpiredAttempts: 0,
-			skipProcessId: input.config.skipProcessId === true,
-			expiredFromUpload: false,
-			isDigitalUpload: false,
-			exhaustedFromUpload: false,
-			forceFinishAfterProcessing: false,
-			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,
-			availableDocumentTypes: getAvailableDocumentTypes(input.config),
-			captureResolution: void 0,
-			cameraFallbackLevel: void 0
-		};
-	},
-	on: {
-		QUIT: { target: "#idCapture.closed" },
-		UPDATE_DETECTION_AREA: { actions: "setDetectionArea" }
-	},
-	states: {
-		idle: { on: { LOAD: [
-			{
-				target: "manualIdUpload",
-				guard: "hasOnlyManualUploadAvailable"
-			},
-			{
-				target: "chooser",
-				guard: "hasShowDocumentChooser"
-			},
-			{
-				target: "ageVerification",
-				guard: "hasAgeAssurance"
-			},
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial"
-			},
-			{ target: "loading" }
-		] } },
-		chooser: { on: { SELECT_DOCUMENT: [
-			{
-				target: "digitalIdUpload",
-				guard: "isDigitalIdUploadSelected",
-				actions: ["setSelectedDocument"]
-			},
-			{
-				target: "manualIdUpload",
-				guard: "isManualIdUploadSelected",
-				actions: ["setSelectedDocument"]
-			},
-			{
-				target: "ageVerification",
-				guard: "hasAgeAssurance",
-				actions: ["setSelectedDocument", "setCurrentMode"]
-			},
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial",
-				actions: ["setSelectedDocument", "setCurrentMode"]
-			},
-			{
-				target: "loading",
-				actions: ["setSelectedDocument", "setCurrentMode"]
-			}
-		] } },
-		ageVerification: { on: { NEXT_STEP: [{
-			target: "tutorial",
-			guard: "hasShowTutorial",
-			actions: "trackContinue"
-		}, {
-			target: "loading",
-			actions: "trackContinue"
-		}] } },
-		loading: {
-			entry: "preloadRecordingProvider",
-			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", "preloadRecordingProvider"],
-			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: "#idCapture.capture",
-						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 }) => ({
-										config: context.config,
-										deepsightService: context.deepsightService
-									}),
-									onDone: {
-										target: "ready",
-										actions: "setStreamAndCapturer"
-									},
-									onError: [{
-										target: "#idCapture.tutorial.ready",
-										guard: "isPermissionDeniedError",
-										actions: assign({ permissionResult: () => {
-											return "denied";
-										} })
-									}, {
-										target: "#idCapture.tutorial.ready",
-										actions: assign({ error: ({ event }) => String(event.error) })
-									}]
-								} },
-								ready: { type: "final" }
-							}
-						},
-						userIntent: {
-							initial: "booting",
-							states: {
-								booting: { on: { NEXT_STEP: {
-									target: "clicked",
-									actions: "trackContinue"
-								} } },
-								clicked: { type: "final" }
-							}
-						}
-					},
-					onDone: { target: "#idCapture.capture" }
-				},
-				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: {
-			entry: "preloadRecordingProvider",
-			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",
-					input: ({ context }) => ({ requestMotionPermission: context.config.ds === true }),
-					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",
-			entry: ["trackCameraId", "preloadRecordingProvider"],
-			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 }) => ({
-						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,
-								isSecondId: context.config.isSecondId ?? false,
-								onlyFront: false,
-								ageAssurance: context.config.ageAssurance,
-								dependencies: context.dependencies,
-								captureResolution: context.captureResolution,
-								cameraFallbackLevel: context.cameraFallbackLevel,
-								croppedCanvas: context.provider?.getCapturedCanvas() ?? null
-							};
-						},
-						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: "#idCapture.finished",
-						guard: and(["shouldSkipProcessId", "isUploadExpired"])
-					},
-					{
-						target: "#idCapture.expiredExhausted",
-						guard: and([
-							"isNotPassportMode",
-							"isUploadExpired",
-							"isExpiredAttemptsExhausted"
-						]),
-						actions: ["incrementExpiredAttempts", "setExhaustedFromUpload"]
-					},
-					{
-						target: "#idCapture.expired",
-						guard: and(["isNotPassportMode", "isUploadExpired"]),
-						actions: ["incrementExpiredAttempts", "setExpiredFromUpload"]
-					},
-					{ target: "success" }
-				] },
-				uploadError: { on: { CONTINUE_FROM_ERROR: [
-					{
-						target: "checkingStream",
-						guard: "hasAttemptsRemaining",
-						actions: [
-							"resetDetection",
-							"clearUploadFailure",
-							"clearStreamForRetry"
-						]
-					},
-					{
-						target: "#idCapture.frontFinished",
-						guard: "shouldContinueToBack",
-						actions: ["flagIdManualReview"]
-					},
-					{
-						target: "#idCapture.backFinished",
-						guard: "shouldContinueToFront",
-						actions: ["flagIdManualReview"]
-					},
-					{
-						target: "#idCapture.processing",
-						actions: ["flagIdManualReview"]
-					}
-				] } },
-				success: { on: { NEXT_STEP: [
-					{
-						target: "#idCapture.mandatoryConsent",
-						guard: "hasMandatoryConsent"
-					},
-					{
-						target: "#idCapture.frontFinished",
-						guard: "shouldContinueToBack"
-					},
-					{
-						target: "#idCapture.backFinished",
-						guard: "shouldContinueToFront"
-					},
-					{ target: "#idCapture.processing" }
-				] } }
-			}
-		},
-		mandatoryConsent: { on: {
-			CONSENT_ACCEPT: [
-				{
-					target: "frontFinished",
-					guard: "shouldContinueToBack"
-				},
-				{
-					target: "backFinished",
-					guard: "shouldContinueToFront"
-				},
-				{ target: "processing" }
-			],
-			CONSENT_CANCEL: { target: "closed" }
-		} },
-		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 }) => ({
-								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" }]
-		},
-		backFinished: {
-			entry: ["stopMediaRecording", "resetForFrontCapture"],
-			type: "parallel",
-			states: {
-				cameraInit: {
-					initial: "checking",
-					states: {
-						checking: { always: [{
-							target: "ready",
-							guard: "hasStream"
-						}, { target: "initializingStream" }] },
-						initializingStream: { invoke: {
-							id: "backFinishedInitCamera",
-							src: "initializeCamera",
-							input: ({ context }) => ({
-								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_FRONT: {
-							target: "clicked",
-							actions: assign({ currentMode: () => "front" })
-						} } },
-						clicked: { type: "final" }
-					}
-				}
-			},
-			onDone: [{
-				target: "#idCapture.capture.detecting",
-				guard: "hasStream"
-			}, { target: "#idCapture.capture" }]
-		},
-		processing: {
-			entry: "stopMediaStream",
-			always: [{
-				target: "finished",
-				guard: "shouldSkipProcessId"
-			}],
-			invoke: {
-				id: "processId",
-				src: "processId",
-				input: ({ context }) => ({ isSecondId: context.config.isSecondId ?? false }),
-				onDone: [
-					{
-						target: "finished",
-						guard: "forceFinishAfterProcessing"
-					},
-					{
-						target: "expiredExhausted",
-						guard: and([({ event }) => event.output.isDocumentExpired, "isProcessingExpiredExhausted"]),
-						actions: ["incrementProcessingExpiredAttempts"]
-					},
-					{
-						target: "expired",
-						guard: ({ event }) => event.output.isDocumentExpired,
-						actions: ["incrementProcessingExpiredAttempts", "clearExpiredFromUpload"]
-					},
-					{ target: "finished" }
-				],
-				onError: { target: "finished" }
-			}
-		},
-		expired: { on: { RETRY_CAPTURE: [
-			{
-				target: "#idCapture.capture",
-				guard: "wasExpiredFromUpload",
-				actions: [
-					"resetDetection",
-					"clearExpiredFromUpload",
-					"clearUploadFailure"
-				]
-			},
-			{
-				target: "chooser",
-				guard: "hasShowDocumentChooser",
-				actions: ["resetContext"]
-			},
-			{
-				target: "ageVerification",
-				guard: "hasAgeAssurance",
-				actions: "resetContext"
-			},
-			{
-				target: "tutorial",
-				guard: "hasShowTutorial",
-				actions: "resetContext"
-			},
-			{
-				target: "loading",
-				actions: "resetContext"
-			}
-		] } },
-		expiredExhausted: { on: { CONTINUE_EXHAUSTED: [
-			{
-				target: "#idCapture.frontFinished",
-				guard: "shouldForceBackOnExpired",
-				actions: ["setSkipProcessId"]
-			},
-			{
-				target: "#idCapture.processing",
-				guard: "shouldProcessAfterExhaustion",
-				actions: ["setForceFinishAfterProcessing"]
-			},
-			{
-				target: "#idCapture.finished",
-				actions: ["setSkipProcessId"]
-			}
-		] } },
-		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: {
-			invoke: {
-				id: "manualIdUpload",
-				src: "manualUploadMachine",
-				input: ({ context }) => ({
-					isSecondId: context.config.isSecondId ?? false,
-					onlyFront: false,
-					captureAttempts: context.config.captureAttempts
-				}),
-				onSnapshot: { actions: () => {} },
-				onDone: [{
-					guard: "isManualUploadExhausted",
-					target: "#idCapture.finished"
-				}, { target: "#idCapture.processing" }],
-				onError: {
-					target: "#idCapture.error",
-					actions: assign({ error: ({ event }) => String(event.error) })
-				}
-			},
-			on: {
-				QUIT: { target: "closed" },
-				MANUAL_UPLOAD_TAB_CHANGED: { actions: sendTo("manualIdUpload", ({ event }) => event) },
-				MANUAL_UPLOAD_FILE_SELECTED: { actions: sendTo("manualIdUpload", ({ event }) => event) },
-				MANUAL_UPLOAD_CONTINUE: { actions: sendTo("manualIdUpload", ({ event }) => event) },
-				MANUAL_UPLOAD_RESET: { actions: sendTo("manualIdUpload", ({ event }) => event) }
-			}
-		},
-		digitalIdUpload: {
-			invoke: {
-				id: "digitalIdUpload",
-				src: "digitalUploadMachine",
-				input: ({ context }) => ({
-					showTutorial: context.config.showTutorial,
-					captureAttempts: context.config.captureAttempts
-				}),
-				onSnapshot: { actions: () => {} },
-				onDone: [
-					{
-						guard: "isDigitalUploadExhausted",
-						target: "#idCapture.finished"
-					},
-					{
-						guard: "isDigitalUploadClosed",
-						target: "#idCapture.chooser"
-					},
-					{
-						guard: "isDigitalUploadSuccessful",
-						target: "#idCapture.processing",
-						actions: ["storeDigitalUploadResponse"]
-					},
-					{
-						target: "#idCapture.error",
-						actions: assign({ error: () => "Digital upload finished without output" })
-					}
-				],
-				onError: {
-					target: "#idCapture.error",
-					actions: assign({ error: ({ event }) => String(event.error) })
-				}
-			},
-			on: {
-				QUIT: { target: "closed" },
-				DIGITAL_UPLOAD_NEXT_STEP: { actions: sendTo("digitalIdUpload", { type: "NEXT_STEP" }) },
-				DIGITAL_UPLOAD_FILE_PICKED: { actions: sendTo("digitalIdUpload", ({ event }) => ({
-					type: "FILE_PICKED",
-					file: event.file
-				})) },
-				DIGITAL_UPLOAD_CONFIRM: { actions: sendTo("digitalIdUpload", { type: "CONFIRM" }) },
-				DIGITAL_UPLOAD_REPLACE: { actions: sendTo("digitalIdUpload", { type: "REPLACE" }) },
-				DIGITAL_UPLOAD_RETRY: { actions: sendTo("digitalIdUpload", { type: "RETRY" }) },
-				DIGITAL_UPLOAD_SCAN_INSTEAD: { actions: sendTo("digitalIdUpload", { type: "SCAN_INSTEAD" }) },
-				DIGITAL_UPLOAD_CHOOSE_ANOTHER: { actions: sendTo("digitalIdUpload", { type: "CHOOSE_ANOTHER" }) }
-			}
-		}
-	}
-});
-const idCaptureMachine = _idCaptureMachine;
-
-//#endregion
-export { startRecordingSession as a, uploadIdImage as c, ID_ERROR_CODES as d, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as f, mapDigitalIdScreenName as h, processId as i, uploadManualIdFile as l, MANUAL_UPLOAD_MAX_RETRIES as m, initializeIdCapture as n, stopRecording as o, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as p, preloadIdRecordingProvider as r, stopStream as s, idCaptureMachine as t, validateUploadResponse as u };