@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/idCaptureStateMachine-kZ5OpdfM.esm.js

@@ -1,3342 +0,0 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { s as exposeExperimentOnce } from "./feature-management-CPQ4qv3F.esm.js";
-import { n as revokeObjectURL } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService---iW2KKJ.esm.js";
-import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-DYiyoSlx.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-dlfDehHk.esm.js";
-import "./trueSight-B_icM8r2.esm.js";
-import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
-import { t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
-import "./session-BFdLgN4i.esm.js";
-import { c as not, i as assign, l as raise, n as enqueueActions, o as and, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
-import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
-import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
-import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
-import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-KINpmKtI.esm.js";
-import { n as flagIdManualReview } from "./manualReviewService-D4IkipnN.esm.js";
-import { _ as getIdCameraStream, a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, g as OPTIMIZING_WATCHDOG_MARGIN_MS, h as CAPTURE_OPTIMIZING, i as preloadIdRecordingProvider, l as uploadIdImage, m as resolveIdCaptureThresholds, o as startRecordingSession, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-44kwQItl.esm.js";
-//#region src/modules/id/digitalUpload/digitalUploadErrors.ts
-const TERMINAL_FAIL_REASONS = /* @__PURE__ */ 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, extractIdFace } = params;
-	const query = { idType: "DigitalId" };
-	if (extractIdFace === false) query.extractIdFace = false;
-	const response = await api.post(DIGITAL_ID_UPLOAD_PATH, file, {
-		query,
-		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
-	};
-}
-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,
-		extractIdFace: input.extractIdFace
-	});
-});
-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 > 5242880,
-		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 = /* @__PURE__ */ 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.attemptsRemaining,
-		failReason: null,
-		response: void 0,
-		uploadDurationMs: void 0,
-		pickerRequestId: 0,
-		pendingPickerAutoOpen: !input.showTutorial,
-		resultType: null,
-		extractIdFace: input.extractIdFace
-	}),
-	output: ({ context }) => ({
-		result: context.resultType ?? "exhausted",
-		attemptsRemaining: context.attemptsRemaining
-	}),
-	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
-						});
-					},
-					extractIdFace: context.extractIdFace
-				}),
-				onDone: [
-					{
-						guard: "isTerminalFailReason",
-						target: "terminalError",
-						actions: [
-							"storeUploadResponse",
-							"setFailReasonFromResponse",
-							"decrementAttemptOnFailure"
-						]
-					},
-					{
-						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: "terminalError"
-			},
-			{
-				guard: "hasAttemptsRemaining",
-				target: "error"
-			},
-			{ target: "terminalError" }
-		] },
-		error: { on: {
-			RETRY: {
-				target: "selecting",
-				actions: ["setPendingPickerAutoOpen", "clearSelectedFile"]
-			},
-			SCAN_INSTEAD: {
-				target: "tutorial",
-				actions: ["clearSelectedFile"]
-			}
-		} },
-		terminalError: { on: { SCAN_INSTEAD: [{
-			guard: "hasAttemptsRemaining",
-			target: "tutorial",
-			actions: ["clearSelectedFile"]
-		}, { target: "exhausted" }] } },
-		exhausted: {
-			type: "final",
-			entry: assign({ resultType: "exhausted" })
-		},
-		success: { on: { NEXT_STEP: { target: "completed" } } },
-		completed: {
-			type: "final",
-			entry: assign({ resultType: "success" })
-		}
-	}
-});
-//#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"
-};
-/**
-* 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`, or `readability`).
-* `idQualityAttemptApproved` is intentionally ignored — v1 did not treat it
-* as a manual-upload rejection signal.
-*
-* 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;
-	return null;
-}
-//#endregion
-//#region ../infra/src/media/imageFile.ts
-const DEFAULT_IMAGE_MIME_TYPE = "image/jpeg";
-const DEFAULT_IMAGE_QUALITY = .92;
-const canNormalizeImageFile = (file) => file.type.startsWith("image/") && typeof document !== "undefined" && typeof Image !== "undefined" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function";
-const readFileAsDataUrl = (file) => new Promise((resolve, reject) => {
-	const reader = new FileReader();
-	reader.onload = () => {
-		const result = reader.result;
-		if (typeof result === "string") {
-			resolve(result);
-			return;
-		}
-		reject(/* @__PURE__ */ new Error("FileReader produced non-string result"));
-	};
-	reader.onerror = () => {
-		reject(reader.error ?? /* @__PURE__ */ new Error("FileReader failed"));
-	};
-	reader.readAsDataURL(file);
-});
-const loadImage = (url) => new Promise((resolve, reject) => {
-	const image = new Image();
-	image.onload = () => resolve(image);
-	image.onerror = () => reject(/* @__PURE__ */ new Error("Image decoding failed"));
-	image.src = url;
-});
-const fileToCanvasDataUrl = async (file, options) => {
-	const objectUrl = URL.createObjectURL(file);
-	try {
-		const image = await loadImage(objectUrl);
-		const width = image.naturalWidth || image.width;
-		const height = image.naturalHeight || image.height;
-		if (width <= 0 || height <= 0) return readFileAsDataUrl(file);
-		const canvas = document.createElement("canvas");
-		canvas.width = width;
-		canvas.height = height;
-		const context = canvas.getContext("2d");
-		if (!context) return readFileAsDataUrl(file);
-		context.fillStyle = "#fff";
-		context.fillRect(0, 0, width, height);
-		context.drawImage(image, 0, 0, width, height);
-		return canvas.toDataURL(options.mimeType ?? DEFAULT_IMAGE_MIME_TYPE, options.quality ?? DEFAULT_IMAGE_QUALITY);
-	} finally {
-		URL.revokeObjectURL(objectUrl);
-	}
-};
-const imageFileToDataUrl = async (file, options = {}) => {
-	if (!canNormalizeImageFile(file)) return readFileAsDataUrl(file);
-	try {
-		return await fileToCanvasDataUrl(file, options);
-	} catch {
-		return readFileAsDataUrl(file);
-	}
-};
-//#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/manualUpload/manualUploadServices.ts
-const stripDataUrlPrefix = (dataUrl) => {
-	const commaIndex = dataUrl.indexOf(",");
-	return commaIndex === -1 ? dataUrl : dataUrl.slice(commaIndex + 1);
-};
-const getBase64PayloadByteLength = (payload) => {
-	const normalized = payload.replace(/\s/g, "");
-	let padding = 0;
-	if (normalized.endsWith("==")) padding = 2;
-	else if (normalized.endsWith("=")) padding = 1;
-	return Math.max(0, Math.floor(normalized.length * 3 / 4) - padding);
-};
-const isBase64PayloadWithinSize = (payload, maxBytes) => getBase64PayloadByteLength(payload) <= maxBytes;
-const fileToBase64Payload = async (file) => {
-	const dataUrl = await imageFileToDataUrl(file);
-	return stripDataUrlPrefix(dataUrl);
-};
-//#endregion
-//#region src/modules/id/manualUpload/manualUploadStateMachine.ts
-const uploadManualFileActor = fromPromise(async ({ input, signal }) => {
-	const base64Image = await fileToBase64Payload(input.file);
-	if (!isBase64PayloadWithinSize(base64Image, 5242880)) return { type: "fileTooLarge" };
-	return {
-		type: "uploaded",
-		response: await uploadManualIdFile({
-			side: input.side,
-			base64Image,
-			retry: input.retry,
-			onlyFront: input.onlyFront,
-			isSecondId: input.isSecondId,
-			extractIdFace: input.extractIdFace,
-			signal
-		})
-	};
-});
-const getUploadOutputFromEvent = (event) => {
-	if ("output" in event) return event.output;
-};
-const getUploadResponseFromEvent = (event) => {
-	const output = getUploadOutputFromEvent(event);
-	return output?.type === "uploaded" ? output.response : void 0;
-};
-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,
-				errorMessage: null,
-				errorSide: null,
-				retriesLeft: context.captureAttempts
-			};
-		}),
-		resetManualUpload: assign(({ context }) => ({
-			frontFile: null,
-			backFile: null,
-			passportFile: null,
-			frontUploaded: false,
-			backUploaded: false,
-			passportUploaded: false,
-			skipBackFromServer: false,
-			errorMessage: null,
-			errorSide: null,
-			retriesLeft: context.captureAttempts
-		})),
-		storeSelectedFile: assign(({ event }) => {
-			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return {};
-			const updated = {
-				errorMessage: null,
-				errorSide: 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,
-			errorSide: null
-		})),
-		markBackUploaded: assign(() => ({
-			backUploaded: true,
-			errorMessage: null,
-			errorSide: null
-		})),
-		markPassportUploaded: assign(() => ({
-			passportUploaded: true,
-			errorMessage: null,
-			errorSide: null
-		})),
-		recordSkipBackFromResponse: assign(({ event }) => {
-			const response = getUploadResponseFromEvent(event);
-			if (!response) return {};
-			if (!response.skipBackIdCapture) return {};
-			return { skipBackFromServer: true };
-		}),
-		decrementManualUploadRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
-		setManualUploadErrorFromResponse: assign(({ context, event }) => {
-			const response = getUploadResponseFromEvent(event);
-			if (!response) return {};
-			return { errorMessage: mapFailReasonToErrorKey(response, context.activeTab) ?? "manualIdUpload.generic" };
-		}),
-		setManualUploadGenericError: assign(() => ({ errorMessage: "manualIdUpload.generic" })),
-		setManualUploadFileTooLargeError: assign(({ event }) => {
-			return {
-				errorMessage: "manualIdUpload.fileTooBig",
-				errorSide: event.type === "MANUAL_UPLOAD_FILE_SELECTED" ? event.side : null
-			};
-		}),
-		markErrorSideFront: assign(() => ({ errorSide: "front" })),
-		markErrorSideBack: assign(() => ({ errorSide: "back" })),
-		markErrorSidePassport: assign(() => ({ errorSide: "passport" })),
-		clearManualUploadError: assign(() => ({
-			errorMessage: null,
-			errorSide: 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;
-		},
-		manualUploadPayloadTooLarge: ({ event }) => getUploadOutputFromEvent(event)?.type === "fileTooLarge"
-	}
-}).createMachine({
-	id: "manualUpload",
-	initial: "selecting",
-	context: ({ input }) => ({
-		onlyFront: input.onlyFront,
-		isSecondId: input.isSecondId,
-		captureAttempts: input.captureAttempts,
-		extractIdFace: input.extractIdFace,
-		frontFile: null,
-		backFile: null,
-		passportFile: null,
-		activeTab: "id",
-		retriesLeft: input.captureAttempts,
-		errorMessage: null,
-		errorSide: 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,
-				extractIdFace: context.extractIdFace
-			}),
-			onDone: [
-				{
-					guard: "manualUploadPayloadTooLarge",
-					target: "selecting",
-					actions: ["setManualUploadFileTooLargeError", "markErrorSideFront"]
-				},
-				{
-					guard: "manualUploadResponseHasError",
-					target: "checkRetries",
-					actions: [
-						"decrementManualUploadRetries",
-						"setManualUploadErrorFromResponse",
-						"markErrorSideFront"
-					]
-				},
-				{
-					target: "selecting",
-					actions: [
-						"markFrontUploaded",
-						"recordSkipBackFromResponse",
-						"clearManualUploadError"
-					]
-				}
-			],
-			onError: {
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadGenericError",
-					"markErrorSideFront"
-				]
-			}
-		} },
-		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: "manualUploadPayloadTooLarge",
-					target: "selecting",
-					actions: ["setManualUploadFileTooLargeError", "markErrorSideBack"]
-				},
-				{
-					guard: "manualUploadResponseHasError",
-					target: "checkRetries",
-					actions: [
-						"decrementManualUploadRetries",
-						"setManualUploadErrorFromResponse",
-						"markErrorSideBack"
-					]
-				},
-				{
-					target: "selecting",
-					actions: ["markBackUploaded", "clearManualUploadError"]
-				}
-			],
-			onError: {
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadGenericError",
-					"markErrorSideBack"
-				]
-			}
-		} },
-		uploadingPassport: { invoke: {
-			id: "uploadManualFile",
-			src: "uploadManualFile",
-			input: ({ context }) => ({
-				side: "passport",
-				file: context.passportFile,
-				retry: context.retriesLeft < context.captureAttempts,
-				onlyFront: false,
-				isSecondId: context.isSecondId,
-				extractIdFace: context.extractIdFace
-			}),
-			onDone: [
-				{
-					guard: "manualUploadPayloadTooLarge",
-					target: "selecting",
-					actions: ["setManualUploadFileTooLargeError", "markErrorSidePassport"]
-				},
-				{
-					guard: "manualUploadResponseHasError",
-					target: "checkRetries",
-					actions: [
-						"decrementManualUploadRetries",
-						"setManualUploadErrorFromResponse",
-						"markErrorSidePassport"
-					]
-				},
-				{
-					target: "selecting",
-					actions: ["markPassportUploaded", "clearManualUploadError"]
-				}
-			],
-			onError: {
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadGenericError",
-					"markErrorSidePassport"
-				]
-			}
-		} },
-		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" }
-		}
-	}
-});
-//#endregion
-//#region src/modules/id/idCaptureGuards.ts
-function getPermissionOutput(event) {
-	if (!("output" in event)) return;
-	const { output } = event;
-	if (typeof output === "object" && output !== null && "permissionResult" in output) return output.permissionResult;
-	return output;
-}
-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 }) => {
-	return getPermissionOutput(event) === "granted";
-};
-const isReadyForCaptureGuard = ({ context, event }) => {
-	return isReadyForCaptureFromPermission(resolveStoredPermissionResult(getPermissionOutput(event), context.permissionResult), context.config.ds);
-};
-const needsMotionPrimeOnlyGuard = ({ context, event }) => {
-	return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult(getPermissionOutput(event), context.permissionResult), context.config.ds);
-};
-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 hasInitializedCameraGuard = ({ context }) => context.stream !== void 0 && context.provider !== void 0;
-const hasAttemptsRemainingGuard = ({ context }) => context.attemptsRemaining > 0;
-const hasCapturedImageGuard = ({ context }) => {
-	return context.provider?.getCapturedCanvas() !== null;
-};
-const hasCandidateFrameGuard = ({ event }) => {
-	return event.type === "DETECTION_OPTIMIZING" && Boolean(event.candidateCanvas);
-};
-/**
-* IDC-05: whether WASM's commit arrived while the optimizing phase was still
-* spending its dwell, and is therefore parked in `optimizing.holding` waiting
-* for the release.
-*
-* Gates the phase's own `SWITCH_TO_MANUAL_CAPTURE` / `MANUAL_CAPTURE` handlers:
-* while a commit is parked those escapes end the dwell early instead of leaving
-* the phase, so WASM's committed frame is honored rather than dropped on the way
-* out. False leaves both events to the arm parent, the documented escape hatch.
-*/
-const hasStashedCommitGuard = ({ context }) => context.stashedCommit !== void 0;
-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";
-/**
-* Single client-side authority on whether a back side is needed.
-*
-* `config.onlyFront` is deliberately NOT read here. The flag is forwarded to
-* the backend as `?onlyFront=true` on the front upload
-* (`idCaptureStateMachine` → `uploadIdImage`), and the backend answers with
-* `skipBackIdCapture` after resolving the real per-document policy — which the
-* flow-level flag cannot account for (`perCountryPerDocOverrides`). Honoring
-* `onlyFront` client-side here was the ENG-45236 bug (PR #413): it skipped the
-* back for documents that genuinely need both sides.
-*
-* Note `currentMode === 'passport'` is allowed through: passports are not
-* implicitly single-side and can require a back (PR #269).
-*
-* The rule for when a client-side read IS legitimate (see
-* `docs/features/ID_CAPTURE_FLOWS.md`):
-*   1. read `config.onlyFront` only where the decision must be made before a
-*      server answer exists, and
-*   2. where you do, still self-correct once the answer arrives.
-*
-* Two variants qualify under (1): the captureOnly machine
-* (`idCaptureOnlyStateMachine` — no upload, so no answer ever exists) and the
-* manual-upload sub-machine (slot visibility precedes any upload, and it ORs
-* `skipBackFromServer` afterwards to satisfy (2)). This guard is on neither
-* path — the answer is already in hand by the time it runs.
-*/
-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) 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;
-/**
-* IDC-05 arm, as resolved once per session by
-* `resolveCaptureOptimizingTreatment` at actor creation.
-*/
-const isCaptureOptimizingModeGuard = ({ context }) => context.captureFeedbackMode === "optimizing";
-/**
-* IDC-05 rendering-layer capability: whether the consumer opted into rendering
-* `captureStatus === 'optimizing'`. Consumers that omit it retain the direct
-* capture-to-upload path. Nothing is advanced by the host — core owns the phase's
-* timing on both paths (WASM's commit on auto capture, `optimizingDwell` on
-* manual), so there is no acknowledgement call.
-*
-* Paired with `isCaptureOptimizingModeGuard` at both branch sites
-* (`choosingDetectionStrategy`, `capturingManual`). Through
-* `createIdCaptureActor` the two can never disagree — that path derives
-* `captureFeedbackMode` from `resolveCaptureOptimizingTreatment`, which
-* already requires this capability — so the pairing looks redundant, and for
-* SDK-built sessions it is.
-*
-* It is NOT redundant on the public surface: `idCaptureMachine` is exported from
-* `@incodetech/core/id` and its `input.captureFeedbackMode` is settable, so a
-* host wiring the machine up directly could otherwise reach the phase without
-* declaring the capability. This guard is what makes the documented opt-in true
-* for every route into the machine, not just the factory.
-*/
-const supportsOptimizingStatusGuard = ({ context }) => context.config.supportsOptimizingStatus === 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";
-/** No capture option is enabled — the ID module is misconfigured. */
-const hasNoDocumentTypesAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 0;
-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 same-side expired budget.
-* Compares the post-increment count, so the exhaustion branch can be picked in
-* the same tick that runs `incrementExpiredAttempts`:
-* - 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 >= 3;
-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;
-/**
-* US Smart Capture: after the back best-frame is captured, submit the decoded
-* PDF417 barcode (instead of uploading the full frame) when one was decoded on
-* the back side. Gated exactly as SDK 1 (`usSmartCapture && isBackId`), plus a
-* non-empty decoded payload.
-*/
-const shouldSubmitBarcodeGuard = ({ context }) => context.currentMode === "back" && context.config.usSmartCapture === true && !!context.decodedBarcode?.text;
-/**
-* US Smart Capture pre-capture fast path: submit the decoded PDF417 barcode the
-* instant it is decoded, before the best-frame auto-capture completes. Reads the
-* barcode from the EVENT — the guard runs before the store action, so
-* `context.decodedBarcode` isn't populated yet. One-shot per attempt via
-* `barcodeFastPathAttempted` (a later best-frame decode falls through to the
-* regular `shouldSubmitBarcode` path).
-*/
-const canRunBarcodeFastPathGuard = ({ context, event }) => context.currentMode === "back" && context.config.usSmartCapture === true && !context.barcodeFastPathAttempted && !!event.decoded?.text;
-/**
-* 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" && (context.config.onlyBack === true || context.config.usSmartCapture === true);
-/**
-* `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 (`processId`) expired path — digital uploads and the
-* multi-side post-capture process step. This path intentionally still keys off
-* the dashboard-configurable `config.captureAttempts`, unlike the per-upload
-* (camera) same-side expired path, which uses the fixed
-* `MAX_EXPIRED_FIRST_SIDE_ATTEMPTS` (decoupled for V1 parity — see ENG-46592).
-* The two expired caps are therefore different by design.
-*/
-const isProcessingExpiredExhaustedGuard = ({ context }) => context.processingExpiredAttempts + 1 >= context.config.captureAttempts;
-/**
-* True when capturing the back side of a two-sided (front+back) ID flow.
-* Used to redirect an expired-back capture to front rather than retrying
-* the same back side (Figma Story #2.1).
-* Excludes onlyBack and usSmartCapture — those are single-side back flows
-* with no front to redirect to.
-*/
-const isBackModeInMultiSideFlowGuard = ({ context }) => context.currentMode === "back" && !context.config.onlyBack && !context.config.usSmartCapture;
-/**
-* True once the user has already been redirected from an expired second-side
-* (back) capture to the first side (front) for their one extra attempt
-* (V1's `expiredRedirected`). Used to make the expired-back→front redirect a
-* one-shot: any subsequent expired upload routes to `expiredExhausted` instead
-* of redirecting again, so total captures stay within the backend's
-* max-attempts/OCR cap (ENG-46592 / re-respects ENG-45666).
-*/
-const wasExpiredRedirectedGuard = ({ context }) => context.expiredRedirected === true;
-const hasManualCaptureTriggeredGuard = ({ context }) => context.manualCaptureTriggered;
-//#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;
-}
-/**
-* Which manual-upload tabs to show. Falls back to both tabs when neither
-* `enableId` nor `enablePassport` is set (no accepted documents).
-*/
-function getManualUploadTabs(config) {
-	const showIdTab = !!config.enableId;
-	const showPassportTab = !!config.enablePassport;
-	if (!showIdTab && !showPassportTab) return {
-		showIdTab: true,
-		showPassportTab: true
-	};
-	return {
-		showIdTab,
-		showPassportTab
-	};
-}
-/**
-* Computes `idCaptureMachine`'s terminal output — the downstream module-skip
-* signal read by the Flow orchestrator (via `runChildModule`'s `MODULE_COMPLETE`).
-*
-* `skipFaceMatch` is set ONLY for the US Smart Capture *camera back-only* path:
-* a back image was captured on-device (`capturedImages.back`) and no front was
-* (`!capturedImages.front`) — "no front, no ID face, no match".
-*
-* Requiring a captured back is deliberate and load-bearing: the manual-upload
-* and digital-ID-upload paths submit a full ID (front face present) but do NOT
-* populate `capturedImages` (only the camera path does). Gating on a captured
-* back excludes those upload paths so a real ID-vs-selfie match is never
-* silently skipped. `capturedImages.front`/`forceFrontIdCapture` alone are not
-* enough (a later front upload clears the request; uploads set neither field).
-*
-* Always `false` outside US Smart Capture. The selfie/face capture itself is
-* unaffected — only the ID-vs-selfie match is skipped.
-*/
-function computeIdCaptureOutput(context) {
-	const frontIdCaptured = Boolean(context.capturedImages.front);
-	const backIdCaptured = Boolean(context.capturedImages.back);
-	return {
-		frontIdCaptured,
-		skipFaceMatch: context.config.usSmartCapture === true && backIdCaptured && !frontIdCaptured
-	};
-}
-//#endregion
-//#region src/modules/id/idCaptureActors.ts
-const checkPermissionActor = fromPromise(async () => {
-	return checkPermission();
-});
-async function requestIdCapturePermission(input) {
-	if (!isAndroid() || getBrowser() !== "firefox") return invokeRequestPermissionActor(input);
-	if (input.requestMotionPermission) {
-		const motionResult = await invokeRequestPermissionActor({
-			...input,
-			permissionResult: "granted"
-		});
-		if (motionResult !== "granted") return motionResult;
-	}
-	const { stream, fallbackLevel } = await getIdCameraStream();
-	return {
-		permissionResult: "granted",
-		stream,
-		cameraFallbackLevel: fallbackLevel
-	};
-}
-const requestPermissionActor = fromPromise(async ({ input }) => {
-	return requestIdCapturePermission(input);
-});
-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 optimizingBoundaryTimeout = null;
-	/**
-	* IDC-05 latch for the boundary clock: whether a boundary is currently
-	* pending. `onCapturing` is WASM's "aggregation window opened" callback and is
-	* the clock's only T0; nothing in WASM enforces that it fires once per window.
-	*/
-	let isOptimizingBoundaryArmed = false;
-	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 clearOptimizingBoundary = () => {
-		if (optimizingBoundaryTimeout) {
-			timer.clearTimeout(optimizingBoundaryTimeout);
-			optimizingBoundaryTimeout = null;
-		}
-		isOptimizingBoundaryArmed = false;
-	};
-	/**
-	* IDC-05 boundary clock — the actor's *only* timer, and the only piece of the
-	* optimizing phase it owns. WASM's `CapturingManager` opens the
-	* frames-aggregation window at `onCapturing` and closes it with `onCapture` at
-	* `T0 + framesAggregationInterval` (already resolved to
-	* `captureWindowMs + optimizingDwellMs`). The phase begins at
-	* `T0 + captureWindowMs`, so it is timed from the very callback that defines
-	* T0; how long it then lasts is the machine's business.
-	*
-	* No best frame yet at that point means the session simply behaves like the
-	* countdown arm — no event, no phase — which mirrors iOS's "auto capture with
-	* no best crop yet" fallback.
-	*
-	* At most one boundary pending at a time — see `isOptimizingBoundaryArmed`.
-	*/
-	const scheduleOptimizingBoundary = () => {
-		if (input.optimizingAfterMs == null || isOptimizingBoundaryArmed) return;
-		isOptimizingBoundaryArmed = true;
-		optimizingBoundaryTimeout = timer.setTimeout(() => {
-			optimizingBoundaryTimeout = null;
-			isOptimizingBoundaryArmed = false;
-			enterOptimizing();
-		}, input.optimizingAfterMs);
-	};
-	/**
-	* Reports the boundary with the candidate frame to freeze. Silent when there
-	* is no candidate — no event means no phase, and the session behaves like the
-	* countdown arm (see `scheduleOptimizingBoundary`).
-	*/
-	const enterOptimizing = () => {
-		const candidateCanvas = bestCanvas?.clone();
-		if (!candidateCanvas) return;
-		sendBack({
-			type: "DETECTION_OPTIMIZING",
-			candidateCanvas
-		});
-	};
-	const sendNotification = (status) => {
-		if (isReportedSideWrong()) return;
-		if (notificationTimeout && currentNotificationStatus !== status) return;
-		if (notificationTimeout && currentNotificationStatus === status) timer.clearTimeout(notificationTimeout);
-		currentNotificationStatus = status;
-		trueSightHintTransition("module.id-capture", "idScan", 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
-	});
-	provider.setThresholds(resolveIdCaptureThresholds(input.config));
-	const modelType = input.config.modelVersion ?? "v2";
-	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) {
-				trueSightHintTransition("module.id-capture", "idScan", "idNotDetected");
-				sendBack({
-					type: "DETECTION_UPDATE",
-					status: "idNotDetected"
-				});
-			}
-		},
-		onSwitchToManualCapture: () => {
-			isCapturing = false;
-			clearOptimizingBoundary();
-			sendBack({ type: "SWITCH_TO_MANUAL_CAPTURE" });
-		},
-		onCapturing: () => {
-			clearNotificationTimeout();
-			lastReportedSide = null;
-			isCapturing = true;
-			trueSightHintTransition("module.id-capture", "idScan", "capturing");
-			sendBack({
-				type: "DETECTION_UPDATE",
-				status: "capturing"
-			});
-			scheduleOptimizingBoundary();
-		},
-		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 (isOptimizingBoundaryArmed) {
-				clearOptimizingBoundary();
-				enterOptimizing();
-			}
-			if (!bestCanvas) {
-				const clonedCanvas = currentCanvas?.clone();
-				if (clonedCanvas) sendBack({
-					type: "DETECTION_SUCCESS",
-					canvas: clonedCanvas,
-					qualityElements: {}
-				});
-				return;
-			}
-			sendBack({
-				type: "DETECTION_SUCCESS",
-				canvas: bestCanvas,
-				qualityElements: storedQualityElements
-			});
-		},
-		onIdTypeChange: (idType) => {
-			sendBack({
-				type: "ID_TYPE_CHANGE",
-				idType
-			});
-		},
-		onIdSideChange: (side) => {
-			if (isCapturing) return;
-			lastReportedSide = side;
-			if (isReportedSideWrong()) clearNotificationTimeout();
-			sendBack({
-				type: "ID_SIDE_CHANGE",
-				side
-			});
-		},
-		onCapturingCounterValueChange: (value) => {
-			sendBack({
-				type: "COUNTER_VALUE_CHANGE",
-				value
-			});
-		},
-		onBarcodeDecoded: (decoded) => {
-			sendBack({
-				type: "BARCODE_DECODED",
-				decoded
-			});
-		}
-	});
-	const barcodeCaptureEnabled = input.config.usSmartCapture === true && input.currentMode === "back";
-	provider.setBarcodeCaptureEnabled(barcodeCaptureEnabled);
-	provider.setBarcodeAutoCaptureOnDecode(false);
-	if (barcodeCaptureEnabled) provider.setBarcodeEnhancementModel().catch(() => {});
-	sendBack({
-		type: "DETECTION_UPDATE",
-		status: "detecting"
-	});
-	const session = new StreamCanvasProcessingSession({
-		capturer: input.frameCapturer,
-		provider: {
-			processFrame: async (frame) => {
-				currentCanvas = IncodeCanvas.fromImageData(frame);
-				await provider.processFrame(frame);
-			},
-			reset: () => {
-				if (notificationTimeout) {
-					timer.clearTimeout(notificationTimeout);
-					notificationTimeout = null;
-					currentNotificationStatus = null;
-				}
-				clearOptimizingBoundary();
-				currentCanvas = null;
-				bestCanvas = null;
-				storedQualityElements = {};
-				isCapturing = false;
-				lastReportedSide = null;
-				provider.resetDetectionState();
-			}
-		}
-	});
-	noteTrueSightCaptureActivity(true);
-	sendBack({
-		type: "DETECTION_RESET_READY",
-		reset: () => {
-			provider.reset();
-		}
-	});
-	return () => {
-		clearNotificationTimeout();
-		clearOptimizingBoundary();
-		session?.dispose();
-		noteTrueSightCaptureActivity(false);
-	};
-});
-const uploadProgressTickerActor = fromCallback(({ sendBack }) => {
-	const timer = BrowserTimerProvider.getInstance();
-	const interval = timer.setInterval(() => {
-		sendBack({ type: "UPLOAD_PROGRESS_TICK" });
-	}, 400);
-	return () => timer.clearInterval(interval);
-});
-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 = input.canvas.getImageData();
-		if (imageData) await input.deepsightService.analyzeFrame(imageData);
-		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 (error) {
-		trueSightLog("warning", "deepsight", "idScan", `deepsight id analysis failed error=${String(error)}`);
-	}
-	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,
-		extractIdFace: input.extractIdFace
-	});
-});
-const processIdActor = fromPromise(async ({ input, signal }) => {
-	return processId(input.isSecondId, "", signal);
-});
-const submitBarcodeActor = fromPromise(async ({ input, signal }) => {
-	const [response] = await Promise.all([addBarcode({
-		rawBarcode: input.rawBarcode,
-		metrics: input.metrics,
-		processId: input.processId,
-		signal
-	}), input.minDurationMs ? sleep(input.minDurationMs) : Promise.resolve()]);
-	return response;
-});
-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 initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
-	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader--wMKWECS.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 performReportCaptureOptimizingAssignment(context) {
-	if (context.config.supportsOptimizingStatus !== true) return;
-	const assignment = exposeExperimentOnce(CAPTURE_OPTIMIZING);
-	if (!assignment) return;
-	recordExperimentAssignmentOnce(eventModuleNames.idCapture, CAPTURE_OPTIMIZING.storeParam, assignment);
-}
-function performStopMediaRecording(context) {
-	if (context.recordingSession) stopRecording(context.recordingSession);
-}
-function getStreamFromEvent(event) {
-	if ("output" in event) return event.output.stream;
-}
-function getPermissionResultFromEvent(event) {
-	if (!("output" in event)) return;
-	const { output } = event;
-	if (output === "granted" || output === "denied" || output === "prompt") return output;
-	if (typeof output === "object" && output !== null && "permissionResult" in output) {
-		const result = output.permissionResult;
-		if (result === "granted" || result === "denied" || result === "prompt") return result;
-	}
-}
-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,
-		decodedBarcode: null,
-		barcodeFastPathAttempted: false,
-		barcodeFastPathCaptured: false,
-		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,
-		...getClearOptimizingValues(context),
-		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,
-		...getClearOptimizingValues(context),
-		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;
-	const frameRect = resolveCaptureFrameRect(context, canvasWidth, canvasHeight);
-	const transformedCanvas = context.provider.transformPerspective(originalCanvas, frameRect);
-	context.provider.setCapturedCanvases(originalCanvas, transformedCanvas);
-}
-/**
-* JPEG quality for the IDC-05 optimizing phase's display-only still.
-*
-* `updateBlob()` is synchronous and expensive: `toDataURL` → `atob` → a per-byte
-* loop building the blob (`IncodeCanvas.base64ToBlob`). At the default quality of
-* 1.0 on a 1080p frame that is tens of milliseconds of main-thread work — and on
-* this path it runs inside an `assign`, in the same tick that starts the phase
-* animation, with the 30fps WASM detection loop still live. Both halves of the
-* cost scale with the encoded byte count, so dropping quality cuts the encode and
-* the byte loop together.
-*
-* Treatment-arm only, deliberately: the committed frame keeps quality 1.0, since
-* it is what uploads (`getStoreCapturedImageValues` → `getBase64Image(1.0)`) and
-* its encode happens on the analyzing screen with no animation to jank. This
-* still is on screen for one dwell at roughly card size and never leaves the
-* device.
-*/
-const CANDIDATE_FRAME_JPEG_QUALITY = .8;
-/**
-* The document's rectangle within a camera frame, in canvas coordinates —
-* the input to `transformPerspective`.
-*
-* Shared by the commit path (`storeCapturedCanvasInProviderLogic`) and the
-* IDC-05 optimizing phase (`getCandidateFrameValues`) so the still shown
-* mid-capture is cropped and warped exactly like the frame that later uploads.
-* Deriving it twice is what made the phase show an uncropped full frame that then
-* visibly jumped to a cropped one on the analyzing screen.
-*/
-function resolveCaptureFrameRect(context, canvasWidth, canvasHeight) {
-	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
-			};
-		}
-	}
-	return frameRect;
-}
-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,
-		...getClearOptimizingValues(context)
-	};
-}
-/**
-* IDC-05: freezes WASM's best-scoring frame *so far* for the optimizing phase.
-* Display-only — the committed frame arrives later, from `onCapture`, and
-* `storeCapturedImage` puts that one on `previewImageUrl` while clearing this
-* one in the same assign, so the rendering layer's
-* `candidateImageUrl ?? previewImageUrl` falls through to the frame that
-* actually uploads for the crossfade.
-*
-* Revokes any previous URL rather than leaking one per retry.
-*/
-function getCandidateFrameValues(context, event) {
-	if (event.type !== "DETECTION_OPTIMIZING" || !event.candidateCanvas) return { candidateImageUrl: context.candidateImageUrl };
-	const candidateCanvas = event.candidateCanvas;
-	const canvas = cropCanvasForPreview(context, candidateCanvas);
-	canvas.updateBlob(CANDIDATE_FRAME_JPEG_QUALITY);
-	const url = canvas.getBlobData()?.url;
-	if (!url) {
-		releasePreviewCanvases(candidateCanvas, canvas, { shouldReleasePreview: true });
-		return { candidateImageUrl: context.candidateImageUrl };
-	}
-	releasePreviewCanvases(candidateCanvas, canvas, { shouldReleasePreview: false });
-	if (context.candidateImageUrl) revokeObjectURL(context.candidateImageUrl);
-	return { candidateImageUrl: url };
-}
-/**
-* Reclaims the full-frame canvases the phase allocated. At 1080p each is ~8MB of
-* backing store, and `release()` frees it now instead of at the next GC — which
-* is what matters on iOS Safari, where canvas memory is its own budget.
-*
-* `source` — the clone the detection actor snapshotted — is always dead by the
-* time this runs: its pixels live on in `preview`'s blob.
-*
-* `preview` is the caller's decision, because `release()` also revokes
-* `blobData.url`. On the success path that URL is the very thing being handed to
-* the machine as `candidateImageUrl`, so releasing it would blank the phase's
-* own still; pass `shouldReleasePreview: true` only where no URL survives. Either way
-* the identity guard covers `transformPerspective` returning the canvas it was
-* given (no provider, or a WASM failure), so the aliased canvas is never
-* released twice or released out from under a live URL.
-*/
-function releasePreviewCanvases(source, preview, { shouldReleasePreview }) {
-	if (preview === source) {
-		if (shouldReleasePreview) source.release();
-		return;
-	}
-	if (shouldReleasePreview) preview.release();
-	source.release();
-}
-function cropCanvasForPreview(context, canvas) {
-	const canvasWidth = canvas.width();
-	const canvasHeight = canvas.height();
-	if (!context.provider || !canvasWidth || !canvasHeight) return canvas;
-	const frameRect = resolveCaptureFrameRect(context, canvasWidth, canvasHeight);
-	return context.provider.transformPerspective(canvas, frameRect);
-}
-/**
-* Drops the IDC-05 best-so-far still at every attempt/side boundary. Unlike
-* `previewImageUrl` it is never preserved into `flipPreview` (it was never a
-* committed frame), so it can always be revoked outright.
-*
-* Clears `stashedCommit` alongside it: a commit parked for the phase's dwell is
-* only meaningful inside that phase, and holding the canvas reference past it
-* would keep a full-res frame alive for the rest of the attempt.
-*/
-function getClearOptimizingValues(context) {
-	if (context.candidateImageUrl) revokeObjectURL(context.candidateImageUrl);
-	return {
-		candidateImageUrl: void 0,
-		stashedCommit: void 0
-	};
-}
-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;
-}
-/**
-* Maps an `AddBarcodeV3Response` (US Smart Capture) into a synthetic
-* `uploadResponse` so the barcode submit path composes with the existing
-* downstream logic: `shouldContinueToFront` reads `forceFrontIdCapture`, and
-* `skipProcessId` is derived from `idValidationCompleted`. `classification` /
-* `readability` are forced `true` (the barcode response carries no image-quality
-* fields); the barcode path lands on `success` directly, bypassing upload
-* validation. Only ever *sets* the skip — an existing skip is preserved.
-*/
-function getBarcodeResponseValues(context, event) {
-	const output = event.output;
-	return {
-		uploadResponse: {
-			sharpness: 0,
-			correctSharpness: true,
-			glare: 0,
-			correctGlare: true,
-			horizontalResolution: 0,
-			classification: true,
-			readability: true,
-			typeOfId: "",
-			issueYear: 0,
-			issueName: "",
-			sessionStatus: output?.sessionStatus ?? "",
-			countryCode: output?.countryCode ?? "",
-			forceFrontIdCapture: output?.forceFrontIdCapture,
-			idValidationCompleted: output?.idValidationCompleted,
-			isDocumentExpired: output?.isDocumentExpired,
-			success: output?.success
-		},
-		skipProcessId: output?.idValidationCompleted === true || context.skipProcessId
-	};
-}
-//#endregion
-//#region src/modules/id/idCaptureStateMachine.ts
-/**
-* Shown/logged when an ID capture module has no accepted documents and no
-* other capture option enabled — there is nothing to capture (ENG-43983).
-*/
-const ID_CAPTURE_NO_DOCUMENT_TYPES_ERROR = "ID capture module has no accepted documents and no capture option enabled";
-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: {},
-		output: {}
-	},
-	actors: {
-		checkPermission: checkPermissionActor,
-		requestPermission: requestPermissionActor,
-		initializeCamera: initializeCameraActor,
-		runDetection: runDetectionActor,
-		uploadIdImage: uploadIdImageActor,
-		uploadProgressTicker: uploadProgressTickerActor,
-		processId: processIdActor,
-		submitBarcode: submitBarcodeActor,
-		startRecording: startRecordingActor,
-		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,
-				frameRect: void 0,
-				previewImageUrl: void 0,
-				...getClearOptimizingValues(context),
-				flipPreview: context.previewImageUrl ? {
-					url: context.previewImageUrl,
-					orientation: context.orientation,
-					mode: context.currentMode === "passport" ? "passport" : "id"
-				} : context.flipPreview,
-				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,
-				frameRect: void 0,
-				previewImageUrl: void 0,
-				...getClearOptimizingValues(context),
-				flipPreview: context.previewImageUrl ? {
-					url: context.previewImageUrl,
-					orientation: context.orientation,
-					mode: context.currentMode === "passport" ? "passport" : "id"
-				} : context.flipPreview,
-				uploadProgress: void 0,
-				manualCaptureTriggered: false,
-				attemptsRemaining: context.config.captureAttempts,
-				expiredAttempts: 0,
-				expiredFromUpload: false,
-				exhaustedFromUpload: false,
-				forceFinishAfterProcessing: false,
-				captureResolution: void 0,
-				cameraFallbackLevel: void 0
-			};
-		}),
-		clearFlipPreview: assign({ flipPreview: 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,
-				frameRect: void 0,
-				previewImageUrl: void 0,
-				...getClearOptimizingValues(context),
-				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)
-		}),
-		setPermissionResultAndStream: assign({
-			permissionResult: ({ context, event }) => getPermissionResultFromEvent(event) ?? context.permissionResult,
-			stream: ({ context, event }) => getStreamFromEvent(event) ?? context.stream,
-			cameraFallbackLevel: ({ context, event }) => getCameraFallbackLevelFromEvent(event) ?? context.cameraFallbackLevel
-		}),
-		trackTutorialId: () => {},
-		trackContinue: () => {},
-		trackCameraId: ({ context }) => {},
-		reportCaptureOptimizingAssignment: ({ context }) => {
-			performReportCaptureOptimizingAssignment(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)),
-		setCandidateFrame: assign(({ context, event }) => getCandidateFrameValues(context, event)),
-		/**
-		* IDC-05: parks WASM's commit while the optimizing phase spends the rest of
-		* its dwell. The frame travels in context only for that stretch —
-		* `releaseStashedCommit` re-raises it and `getClearOptimizingValues` drops it
-		* on every other exit from the phase.
-		*/
-		stashCommittedFrame: assign({ stashedCommit: ({ event }) => {
-			const commit = event;
-			return {
-				canvas: commit.canvas,
-				qualityElements: commit.qualityElements
-			};
-		} }),
-		/**
-		* IDC-05: hands a parked commit back to the machine as the very event that
-		* would have carried it, so `capturing`'s entry actions stay event-driven.
-		* Re-raised rather than read from context by `capturing` because
-		* `storeCapturedCanvasInProvider` falls back to the *live* frame when the
-		* entering event has no canvas — a timer transition into `capturing` would
-		* stage a live frame for upload instead of the one WASM committed.
-		*/
-		releaseStashedCommit: enqueueActions(({ context, enqueue }) => {
-			const stashed = context.stashedCommit;
-			if (!stashed) return;
-			enqueue(raise({
-				type: "DETECTION_SUCCESS",
-				canvas: stashed.canvas,
-				qualityElements: stashed.qualityElements
-			}));
-		}),
-		/**
-		* IDC-05: releases everything the optimizing phase allocated — the parked
-		* commit AND the frozen still's blob URL. Bound to `optimizing.exit`, so it
-		* covers every route out of the phase, not just the two that already clear
-		* up after themselves (`getStoreCapturedImageValues` on the commit,
-		* `optimizingGrace`'s own action on the abandon path). Before this it
-		* cleared only `stashedCommit`, and an exit through the manual-capture
-		* escape leaked the URL until the next attempt/side boundary.
-		*
-		* Safe to revoke here on the commit path: exit and `capturing`'s entry run
-		* in the same macrostep, and `capturing`'s eventless `always` means the UI
-		* only ever observes the resulting `uploading` snapshot — by which point
-		* `previewImageUrl` is set, so `candidateImageUrl ?? previewImageUrl` never
-		* resolves to nothing (see `getStoreCapturedImageValues`).
-		*/
-		clearOptimizingPhase: assign(({ context }) => getClearOptimizingValues(context)),
-		storeBarcodeResponse: assign(({ context, event }) => getBarcodeResponseValues(context, event)),
-		storeDecodedBarcode: assign({ decodedBarcode: ({ event }) => event.decoded }),
-		setBarcodeFastPathAttempted: assign({ barcodeFastPathAttempted: true }),
-		markBarcodeFastPathCaptured: assign({
-			barcodeFastPathCaptured: true,
-			previewImageUrl: void 0
-		}),
-		clearBarcodeFastPathCaptured: assign({ barcodeFastPathCaptured: false }),
-		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;
-		} }),
-		incrementExpiredAttempts: assign(({ context }) => ({ expiredAttempts: context.expiredAttempts + 1 })),
-		/**
-		* Mirrors the child's successful upload response onto parent context so
-		* the manager mapper (and the workflow orchestrator) can read fields
-		* like `skipBackIdCapture` and `typeOfId`. Also marks the session as a
-		* digital upload so back capture is suppressed regardless of
-		* `alwaysCaptureBackOfId` (digital IDs are single-side, like passports).
-		*
-		* The child machine's `output` is intentionally narrow (`{ result }`);
-		* to avoid breaking the established invoke→onDone contract, we read the
-		* upload response from the child snapshot's context instead of widening
-		* the output shape.
-		*/
-		storeDigitalUploadResponse: assign(({ self }) => {
-			const response = ((self.getSnapshot().children?.["digitalIdUpload"]?.getSnapshot())?.context)?.response;
-			if (!response) return { isDigitalUpload: true };
-			return {
-				uploadResponse: response,
-				isDigitalUpload: true
-			};
-		}),
-		syncAttemptsFromDigitalUpload: assign({ attemptsRemaining: ({ event }) => event.output?.attemptsRemaining ?? 0 }),
-		incrementProcessingExpiredAttempts: assign(({ context }) => ({ processingExpiredAttempts: context.processingExpiredAttempts + 1 })),
-		setSkipProcessId: assign({ skipProcessId: () => true }),
-		setExpiredFromUpload: assign({ expiredFromUpload: () => true }),
-		setExhaustedFromUpload: assign({ exhaustedFromUpload: () => true }),
-		setExpiredRedirected: assign({ expiredRedirected: () => true }),
-		setForceFinishAfterProcessing: assign({ forceFinishAfterProcessing: () => true }),
-		clearExpiredFromUpload: assign({ expiredFromUpload: () => false })
-	},
-	guards: {
-		hasShowTutorial: hasShowTutorialGuard,
-		hasAgeAssurance: hasAgeAssuranceGuard,
-		hasShowDocumentChooser: hasShowDocumentChooserGuard,
-		isPermissionGranted: isPermissionGrantedGuard,
-		isReadyForCapture: isReadyForCaptureGuard,
-		needsMotionPrimeOnly: needsMotionPrimeOnlyGuard,
-		isPermissionDeniedError: isPermissionDeniedErrorGuard,
-		hasStream: hasStreamGuard,
-		hasInitializedCamera: hasInitializedCameraGuard,
-		hasAttemptsRemaining: hasAttemptsRemainingGuard,
-		hasCapturedImage: hasCapturedImageGuard,
-		hasCandidateFrame: hasCandidateFrameGuard,
-		hasStashedCommit: hasStashedCommitGuard,
-		hasUploadValidationError: hasUploadValidationErrorGuard,
-		isFrontMode: isFrontModeGuard,
-		shouldContinueToBack: shouldContinueToBackGuard,
-		shouldContinueToFront: shouldContinueToFrontGuard,
-		hasMandatoryConsent: hasMandatoryConsentGuard,
-		isCaptureOptimizingMode: isCaptureOptimizingModeGuard,
-		supportsOptimizingStatus: supportsOptimizingStatusGuard,
-		isDeepsightEnabled: isDeepsightEnabledGuard,
-		isDeepsightReady: isDeepsightReadyGuard,
-		needsDeepsightInit: needsDeepsightInitGuard,
-		hasOnlyManualUploadAvailable: hasOnlyManualUploadAvailableGuard,
-		hasNoDocumentTypesAvailable: hasNoDocumentTypesAvailableGuard,
-		isManualIdUploadSelected: isManualIdUploadSelectedGuard,
-		isDigitalIdUploadSelected: isDigitalIdUploadSelectedGuard,
-		isUploadExpired: isUploadExpiredGuard,
-		isExpiredAttemptsExhausted: isExpiredAttemptsExhaustedGuard,
-		isNotPassportMode: isNotPassportModeGuard,
-		shouldForceBackOnExpired: shouldForceBackOnExpiredGuard,
-		wasExpiredFromUpload: wasExpiredFromUploadGuard,
-		shouldSkipProcessId: shouldSkipProcessIdGuard,
-		shouldSubmitBarcode: shouldSubmitBarcodeGuard,
-		canRunBarcodeFastPath: canRunBarcodeFastPathGuard,
-		hasManualCaptureTriggered: hasManualCaptureTriggeredGuard,
-		isProcessingExpiredExhausted: isProcessingExpiredExhaustedGuard,
-		shouldProcessAfterExhaustion: shouldProcessAfterExhaustionGuard,
-		forceFinishAfterProcessing: forceFinishAfterProcessingGuard,
-		isBackModeInMultiSideFlow: isBackModeInMultiSideFlowGuard,
-		wasExpiredRedirected: wasExpiredRedirectedGuard,
-		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted",
-		isDigitalUploadExhausted: ({ event }) => event.output?.result === "exhausted",
-		isDigitalUploadSuccessful: ({ event }) => event.output?.result === "success"
-	},
-	delays: {
-		/**
-		* IDC-05: how long the optimizing phase lasts, on BOTH paths — the auto
-		* path's `optimizing.holding` and the manual path's `optimizingHold`. One
-		* value, read from context rather than hardcoded, so the experiment payload
-		* governs the phase wherever it is played.
-		*
-		* `?? 0` rather than the default dwell, deliberately: neither state is
-		* reachable outside the treatment arm, and the treatment arm is the only
-		* thing that populates `optimizingDwellMs`
-		* (`resolveCaptureOptimizingTreatment` always sets it on its `optimizing`
-		* branch). An absent value here therefore means the wiring between the two
-		* broke, and falling back to the default would silently add a dwell to a
-		* capture that was never supposed to have one. Zero makes that failure a
-		* pass-through instead of a 1.5s regression.
-		*/
-		optimizingDwell: ({ context }) => context.optimizingDwellMs ?? 0,
-		/**
-		* IDC-05: how much longer the machine waits for WASM's commit once the phase
-		* has had its full dwell (`optimizing.released`). Past this, `onCapture` —
-		* the phase's normal exit — is not coming for the window this still belongs
-		* to, and the phase is abandoned.
-		*
-		* A constant, not `dwell + margin`: the dwell has already been spent in
-		* `holding` by the time this arms, so the total from phase entry is
-		* unchanged. It also means the timer stays armed on a partially-resolved
-		* payload, where `optimizingDwell` above collapses to zero.
-		*/
-		optimizingGrace: OPTIMIZING_WATCHDOG_MARGIN_MS
-	}
-}).createMachine({
-	id: "idCapture",
-	initial: "idle",
-	output: ({ context }) => computeIdCaptureOutput(context),
-	context: ({ input }) => {
-		const currentMode = input.config.onlyBack ? "back" : !input.config.enableId && input.config.enablePassport ? "passport" : input.config.usSmartCapture ? "back" : "front";
-		return {
-			config: input.config,
-			captureFeedbackMode: input.captureFeedbackMode ?? "countdown",
-			captureWindowMs: input.captureWindowMs,
-			optimizingDwellMs: input.optimizingDwellMs,
-			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,
-			decodedBarcode: null,
-			barcodeFastPathAttempted: false,
-			barcodeFastPathCaptured: false,
-			recordingSession: void 0,
-			attemptsRemaining: input.config.captureAttempts,
-			expiredAttempts: 0,
-			expiredRedirected: false,
-			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,
-			frameRect: void 0,
-			detectionArea: void 0,
-			previewImageUrl: void 0,
-			candidateImageUrl: void 0,
-			uploadProgress: 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: "error",
-				guard: "hasNoDocumentTypesAvailable",
-				actions: [() => console.error(ID_CAPTURE_NO_DOCUMENT_TYPES_ERROR), assign({ error: () => ID_CAPTURE_NO_DOCUMENT_TYPES_ERROR })]
-			},
-			{
-				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: "isReadyForCapture"
-			}, { target: "permissions" }]
-		},
-		tutorial: {
-			initial: "checkingPermission",
-			entry: ["trackTutorialId", "preloadRecordingProvider"],
-			states: {
-				checkingPermission: {
-					invoke: {
-						id: "checkPermissionTutorial",
-						src: "checkPermission",
-						onDone: [{
-							target: "initializingCamera",
-							guard: "isReadyForCapture",
-							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: "isReadyForCapture",
-							actions: assign({ permissionResult: ({ event }) => event.output })
-						},
-						{
-							target: "#idCapture.permissions.requesting",
-							guard: "needsMotionPrimeOnly",
-							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: "isReadyForCapture",
-								actions: assign({ permissionResult: ({ event }) => event.output })
-							},
-							{
-								target: "denied",
-								guard: ({ event }) => event.output === "denied",
-								actions: assign({ permissionResult: ({ event }) => event.output })
-							},
-							{
-								target: "motionOnly",
-								guard: "needsMotionPrimeOnly",
-								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"
-				} },
-				motionOnly: { on: { REQUEST_PERMISSION: "requesting" } },
-				learnMore: { on: {
-					BACK: "idle",
-					REQUEST_PERMISSION: "requesting"
-				} },
-				requesting: { invoke: {
-					id: "requestPermission",
-					src: "requestPermission",
-					input: ({ context }) => ({
-						permissionResult: context.permissionResult === "refresh" ? void 0 : context.permissionResult,
-						requestMotionPermission: context.config.ds === true
-					}),
-					onDone: [
-						{
-							target: "#idCapture.capture",
-							guard: "isReadyForCapture",
-							actions: "setPermissionResultAndStream"
-						},
-						{
-							target: "denied",
-							guard: ({ event }) => getPermissionResultFromEvent(event) === "denied",
-							actions: "setPermissionResultAndStream"
-						},
-						{
-							target: "waitingForUser",
-							actions: "setPermissionResultAndStream"
-						}
-					],
-					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: "choosingDetectionStrategy",
-						guard: "hasInitializedCamera"
-					},
-					{ 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,
-						stream: context.stream,
-						cameraFallbackLevel: context.cameraFallbackLevel
-					}),
-					onDone: {
-						target: "choosingDetectionStrategy",
-						actions: "setStreamAndCapturer"
-					},
-					onError: [{
-						target: "#idCapture.permissions",
-						guard: "isPermissionDeniedError",
-						actions: assign({ permissionResult: () => "denied" })
-					}, {
-						target: "#idCapture.error",
-						actions: assign({ error: ({ event }) => String(event.error) })
-					}]
-				} },
-				choosingDetectionStrategy: {
-					entry: ["reportCaptureOptimizingAssignment"],
-					always: [{
-						target: "detectingWithOptimization",
-						guard: and(["isCaptureOptimizingMode", "supportsOptimizingStatus"])
-					}, { target: "detecting" }]
-				},
-				detecting: {
-					always: [{
-						target: "manualCaptureWaiting",
-						guard: "hasManualCaptureTriggered",
-						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_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
-						DETECTION_SUCCESS: {
-							target: "capturing",
-							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
-						},
-						BARCODE_DECODED: [{
-							target: "capturingBarcode",
-							guard: "canRunBarcodeFastPath",
-							actions: ["storeDecodedBarcode", "setBarcodeFastPathAttempted"]
-						}, { actions: "storeDecodedBarcode" }],
-						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" }
-					}
-				},
-				/**
-				* IDC-05 treatment arm: same detection as `detecting` above (kept in sync by
-				* hand — see the comment there), plus the two-phase searching -> optimizing
-				* phase.
-				*
-				* Two *distinct* state nodes (this one and `detecting`) rather than one
-				* compound state, deliberately: `snapshot.matches({ capture: 'detecting' })`
-				* keeps meaning exactly what it always meant. Folding the phase into
-				* `detecting` as a substate would make every such selector silently true
-				* while the user is being told the capture succeeded — a hazard no type or
-				* test would catch.
-				*/
-				detectingWithOptimization: {
-					entry: assign({ detectionStatus: () => "detecting" }),
-					always: [{
-						target: "manualCaptureWaiting",
-						guard: "hasManualCaptureTriggered",
-						actions: assign({ detectionStatus: () => "manualCapture" })
-					}],
-					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,
-							optimizingAfterMs: context.captureWindowMs
-						})
-					}],
-					on: {
-						DETECTION_SUCCESS: {
-							target: "capturing",
-							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
-						},
-						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
-						ID_TYPE_CHANGE: { actions: "setIdType" },
-						ORIENTATION_CHANGE: { actions: "setOrientation" },
-						MANUAL_CAPTURE: { target: "#idCapture.capture.capturingManual" },
-						SWITCH_TO_MANUAL_CAPTURE: {
-							target: "#idCapture.capture.manualCaptureWaiting",
-							actions: assign({
-								detectionStatus: () => "manualCapture",
-								manualCaptureTriggered: () => true
-							})
-						}
-					},
-					initial: "searching",
-					states: {
-						searching: { on: {
-							DETECTION_UPDATE: { actions: "setDetectionStatus" },
-							ID_SIDE_CHANGE: { actions: assign({ detectionStatus: ({ context, event }) => getDetectionStatusFromSideChange(context, event.side) }) },
-							BARCODE_DECODED: [{
-								target: "#idCapture.capture.capturingBarcode",
-								guard: "canRunBarcodeFastPath",
-								actions: ["storeDecodedBarcode", "setBarcodeFastPathAttempted"]
-							}, { actions: "storeDecodedBarcode" }],
-							DETECTION_OPTIMIZING: {
-								target: "optimizing",
-								guard: "hasCandidateFrame",
-								actions: "setCandidateFrame"
-							}
-						} },
-						optimizing: {
-							exit: "clearOptimizingPhase",
-							on: {
-								BARCODE_DECODED: { actions: "storeDecodedBarcode" },
-								SWITCH_TO_MANUAL_CAPTURE: {
-									guard: "hasStashedCommit",
-									target: "#idCapture.capture.detectingWithOptimization.optimizing.released"
-								},
-								MANUAL_CAPTURE: {
-									guard: "hasStashedCommit",
-									target: "#idCapture.capture.detectingWithOptimization.optimizing.released"
-								}
-							},
-							initial: "holding",
-							states: {
-								holding: {
-									after: { optimizingDwell: { target: "released" } },
-									on: { DETECTION_SUCCESS: { actions: "stashCommittedFrame" } }
-								},
-								released: {
-									entry: "releaseStashedCommit",
-									after: { optimizingGrace: {
-										target: "#idCapture.capture.detectingWithOptimization.searching",
-										actions: assign({ detectionStatus: () => "detecting" })
-									} }
-								}
-							}
-						}
-					}
-				},
-				manualCaptureWaiting: { on: { MANUAL_CAPTURE: { target: "capturingManual" } } },
-				capturing: {
-					entry: [
-						"captureImage",
-						"storeCapturedCanvasInProvider",
-						"storeCapturedImage"
-					],
-					always: [
-						{
-							target: "submittingBarcode",
-							guard: and(["hasCapturedImage", "shouldSubmitBarcode"])
-						},
-						{
-							target: "uploading",
-							guard: "hasCapturedImage"
-						},
-						{
-							target: "uploadError",
-							actions: assign(({ context }) => ({
-								uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-								attemptsRemaining: context.attemptsRemaining - 1
-							}))
-						}
-					]
-				},
-				submittingBarcode: { invoke: {
-					id: "submitBarcode",
-					src: "submitBarcode",
-					input: ({ context }) => ({
-						rawBarcode: context.decodedBarcode?.text ?? "",
-						metrics: context.decodedBarcode,
-						processId: context.config.skipProcessId !== true
-					}),
-					onDone: {
-						target: "success",
-						actions: "storeBarcodeResponse"
-					},
-					onError: { target: "uploading" }
-				} },
-				capturingBarcode: {
-					entry: [
-						"captureImage",
-						"storeCapturedCanvasInProvider",
-						"storeCapturedImage"
-					],
-					always: [{ target: "submittingBarcodePreCapture" }]
-				},
-				submittingBarcodePreCapture: { invoke: {
-					id: "submitBarcode",
-					src: "submitBarcode",
-					input: ({ context }) => ({
-						rawBarcode: context.decodedBarcode?.text ?? "",
-						metrics: context.decodedBarcode,
-						processId: context.config.skipProcessId !== true,
-						minDurationMs: 1e3
-					}),
-					onDone: {
-						target: "success",
-						actions: ["storeBarcodeResponse", "markBarcodeFastPathCaptured"]
-					},
-					onError: { target: "choosingDetectionStrategy" }
-				} },
-				capturingManual: {
-					entry: [
-						"captureLatestFrame",
-						"storeCapturedCanvasInProvider",
-						"storeCapturedImage"
-					],
-					always: [
-						{
-							target: "optimizingHold",
-							guard: and([
-								"hasCapturedImage",
-								"isCaptureOptimizingMode",
-								"supportsOptimizingStatus"
-							])
-						},
-						{
-							target: "uploading",
-							guard: "hasCapturedImage"
-						},
-						{
-							target: "uploadError",
-							actions: assign(({ context }) => ({
-								uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-								attemptsRemaining: context.attemptsRemaining - 1
-							}))
-						}
-					]
-				},
-				optimizingHold: { after: { optimizingDwell: { target: "uploading" } } },
-				uploading: {
-					entry: assign({ uploadProgress: () => 0 }),
-					invoke: [{
-						id: "uploadProgressTicker",
-						src: "uploadProgressTicker"
-					}, {
-						id: "uploadIdImage",
-						src: "uploadIdImage",
-						input: ({ context, self }) => {
-							const canvas = context.provider?.getOriginalCapturedCanvas();
-							if (!canvas) throw new Error(ID_ERROR_CODES.UPLOAD_ERROR);
-							const type = context.currentMode === "back" ? "back" : "front";
-							return {
-								canvas,
-								type,
-								qualityElements: context.qualityElements,
-								onProgress: (progress) => {
-									self.send({
-										type: "UPLOAD_PROGRESS",
-										progress
-									});
-								},
-								deepsightService: context.deepsightService,
-								stream: context.stream,
-								isSecondId: context.config.isSecondId ?? false,
-								onlyFront: type === "front" && (context.config.onlyFront ?? false),
-								ageAssurance: context.config.ageAssurance,
-								dependencies: context.dependencies,
-								captureResolution: context.captureResolution,
-								cameraFallbackLevel: context.cameraFallbackLevel,
-								extractIdFace: context.config.extractIdFace,
-								croppedCanvas: context.provider?.getCapturedCanvas() ?? null
-							};
-						},
-						onDone: {
-							target: "uploadCompleted",
-							actions: [assign({
-								uploadResponse: ({ event }) => event.output,
-								uploadProgress: () => 100,
-								skipProcessId: ({ context, event }) => event.output.idValidationCompleted === true || context.skipProcessId
-							}), "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: ({ context, event }) => Math.max(context.uploadProgress ?? 0, Math.round(event.progress / 100 * 80)) }) },
-						UPLOAD_PROGRESS_TICK: { actions: assign({ uploadProgress: ({ context }) => Math.min(95, (context.uploadProgress ?? 0) + 1) }) }
-					}
-				},
-				uploadCompleted: { after: { [800]: { target: "validatingUpload" } } },
-				validatingUpload: { always: [
-					{
-						target: "uploadError",
-						guard: "hasUploadValidationError",
-						actions: ["setUploadErrorFromUploadValidation", "decrementAttemptsRemaining"]
-					},
-					{
-						target: "#idCapture.finished",
-						guard: and(["shouldSkipProcessId", "isUploadExpired"])
-					},
-					{
-						target: "#idCapture.expiredExhausted",
-						guard: and([
-							"isNotPassportMode",
-							"isUploadExpired",
-							"wasExpiredRedirected"
-						]),
-						actions: ["setExhaustedFromUpload"]
-					},
-					{
-						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: {
-					exit: "clearBarcodeFastPathCaptured",
-					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.choosingDetectionStrategy",
-				guard: "hasStream",
-				actions: "clearFlipPreview"
-			}, {
-				target: "#idCapture.capture",
-				actions: "clearFlipPreview"
-			}]
-		},
-		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.choosingDetectionStrategy",
-				guard: "hasStream",
-				actions: "clearFlipPreview"
-			}, {
-				target: "#idCapture.capture",
-				actions: "clearFlipPreview"
-			}]
-		},
-		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.backFinished",
-				guard: and([
-					"wasExpiredFromUpload",
-					"isBackModeInMultiSideFlow",
-					not("wasExpiredRedirected")
-				]),
-				actions: [
-					"resetDetection",
-					"clearExpiredFromUpload",
-					"clearUploadFailure",
-					"setExpiredRedirected"
-				]
-			},
-			{
-				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: {
-			entry: "flagIdManualReview",
-			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: context.config.onlyFront ?? false,
-					captureAttempts: context.config.captureAttempts,
-					extractIdFace: context.config.extractIdFace
-				}),
-				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,
-					attemptsRemaining: context.attemptsRemaining,
-					extractIdFace: context.config.extractIdFace
-				}),
-				onSnapshot: { actions: () => {} },
-				onDone: [
-					{
-						guard: "isDigitalUploadExhausted",
-						target: "#idCapture.finished",
-						actions: ["syncAttemptsFromDigitalUpload"]
-					},
-					{
-						guard: "isDigitalUploadSuccessful",
-						target: "#idCapture.processing",
-						actions: ["syncAttemptsFromDigitalUpload", "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" }) }
-			}
-		}
-	}
-});
-//#endregion
-export { MANUAL_UPLOAD_MAX_RETRIES as a, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as i, getManualUploadTabs as n, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as r, idCaptureMachine as t };