@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/idCaptureStateMachine-BK0bPHoc.esm.js

@@ -0,0 +1,2963 @@
+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-CGtQJJzB.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";
+}
+/**
+* Maps a digital-upload response to the UI's failure reason, or `null` when
+* the upload is a success.
+*
+* Failure detection is layered so we don't lose backend rejections that V2
+* was previously dropping (V1 parity): explicit `failReason` first, then a
+* "this document isn't accepted" signal (`acceptedDocuments` populated or
+* `classification === false`) which maps to `ID_TYPE_UNACCEPTABLE`, then
+* the bare `success === false` fallback as a generic rejection.
+*/
+function mapDigitalIdFailReason(response) {
+	if (!response) return null;
+	const { failReason } = response;
+	if (typeof failReason === "string" && failReason.length > 0) return isKnownFailReason(failReason) ? failReason : "GENERIC";
+	if (response.acceptedDocuments != null && response.acceptedDocuments.length > 0 || response.classification === false) return "ID_TYPE_UNACCEPTABLE";
+	if (response.success === false) return "GENERIC";
+	return null;
+}
+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) };
+		}),
+		decrementAttemptOnFailure: assign(({ context }) => ({ 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",
+							"decrementAttemptOnFailure"
+						]
+					},
+					{
+						target: "success",
+						actions: ["storeUploadResponse", "setUploadProgressCompleted"]
+					}
+				],
+				onError: {
+					target: "checkRetries",
+					actions: ["setFailReasonFromNetworkError", "decrementAttemptOnFailure"]
+				}
+			},
+			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: ["setPendingPickerAutoOpen", "clearSelectedFile"]
+			},
+			SCAN_INSTEAD: { target: "closed" }
+		} },
+		retriesExhausted: {
+			entry: assign({ resultType: "exhausted" }),
+			on: { SCAN_INSTEAD: { target: "closed" } }
+		},
+		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 };