@incodetech/core 2.1.0-rc.1 → 2.1.0-rc.3

package/dist/{idCaptureStateMachine-B3AiDIsT.esm.js → idCaptureStateMachine-BeDidMLU.esm.js}

@@ -1,20 +1,21 @@
-import { d as IdCaptureModelType, i as mlWasmJSApi_default, n as BaseWasmProvider, u as WasmPipelineType } from "./WasmUtilProvider-BKWm8rSA.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { r as getToken, t as api } from "./api-CESGtpbH.esm.js";
-import { S as revokeObjectURL } from "./events-Dvvriq9l.esm.js";
-import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
-import { t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-DRB-hgbV.esm.js";
-import { n as isDesktop } from "./platform-SKvEfCBh.esm.js";
-import { a as fromPromise, i as fromCallback, n as sendTo, o as and, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-Doec4X5L.esm.js";
-import { _ as startRecording, g as createRecordingSession, i as flagIdManualReview, n as preloadOpenViduProvider, v as stopRecording$1, y as StreamCanvasProcessingSession } from "./recordingService-yRw7hfzU.esm.js";
-import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-D7Wo4Nbx.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-C0olyNFS.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-C8Do2qYu.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-ImiDQdVA.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-D0wGddy7.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { r as getToken, t as api } from "./api-DsbUi7TO.esm.js";
+import { v as revokeObjectURL } from "./events-CqGY1yMq.esm.js";
+import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { t as addDeviceStats } from "./stats-CYcScXcO.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-C_TYIgyk.esm.js";
+import { n as isDesktop } from "./platform-uIVQUnJP.esm.js";
+import { a as fromPromise, c as not, i as fromCallback, n as sendTo, o as and, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-BJhGL13R.esm.js";
+import { _ as stopRecording$1, g as startRecording, h as createRecordingSession, y as StreamCanvasProcessingSession } from "./onDeviceFaceResults-DVBggeq8.esm.js";
+import { t as IncodeCanvas } from "./canvas-_I95hkPg.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-ZyqrFyjO.esm.js";
+import { n as getWindowDimensions } from "./getDeviceClass-DavNdcxh.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-DGGzzfqm.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-Bz17q4FP.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BR2oN573.esm.js";
+import { i as flagIdManualReview, n as preloadOpenViduProvider } from "./recordingService-m_1xCthr.esm.js";
+import { i as IdCaptureProvider, n as DEFAULT_ID_CAPTURE_MODEL_VERSION, r as DEFAULT_ID_CAPTURE_THRESHOLDS } from "./idCaptureDefaults-DNJON8Xo.esm.js";
 
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
@@ -320,6 +321,17 @@ function isHoldingState(value) {
 	if (typeof uploadingState === "object" && uploadingState !== null) return Object.prototype.hasOwnProperty.call(uploadingState, "holding");
 	return false;
 }
+/**
+* Maps a Digital ID Upload child-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: Upload Digital ID Figma file
+* (`https://www.figma.com/design/wxFsHRvllern4VnjRqM4JO/Upload-Digital-ID---Latest-Design?node-id=25911-4095`).
+*
+* Family is `uploadDigitalid.*` — emitted cross-family under the parent
+* `idCapture` module token. Returns Figma-verbatim strings which the
+* adapter emits as-is on `event.screen` (e.g.
+* `uploadDigitalid.<section>.<state>`). See
+* `docs/patterns/INSTRUMENTATION.md`.
+*/
 function mapDigitalIdScreenName(value, failReason) {
 	if (value === "tutorial") return "uploadDigitalid.tutorial.default";
 	if (value === "selecting" || value === "reviewing") return "uploadDigitalid.review.default";
@@ -334,172 +346,102 @@ function mapDigitalIdScreenName(value, failReason) {
 }
 
 //#endregion
-//#region src/modules/id/idCaptureHelpers.ts
+//#region src/modules/id/manualUpload/manualUploadErrors.ts
 /**
-* Map of config properties received from the backend to adjusted, internal document types.
+* i18n keys for manual-upload user-facing error copy.
+* Keep in sync with `packages/ui/src/i18n/**.json` under the `manualIdUpload.*` namespace.
 */
-const DOCUMENT_TYPES_CONFIG_TO_ADJUSTED_MAP = [
-	["enableId", "id"],
-	["enablePassport", "passport"],
-	["manualUploadIdCapture", "manualIdUpload"],
-	["digitalIdsUpload", "digitalIdUpload"],
-	["deviceWallet", "digitalId"]
-];
+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"
+};
 /**
-* 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.
+* 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.
 *
-* @param config - ID capture configuration (from flow or init)
-* @returns Array of IdDocumentType values that should be shown in the document type chooser
+* 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 getAvailableDocumentTypes(config) {
-	const adjustedDocumentTypes = [];
-	for (const [configProperty, adjustedType] of DOCUMENT_TYPES_CONFIG_TO_ADJUSTED_MAP) if (config[configProperty]) adjustedDocumentTypes.push(adjustedType);
-	return adjustedDocumentTypes;
+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/providers/wasm/IdCaptureProvider.ts
-var IdCaptureProvider = class extends BaseWasmProvider {
-	constructor() {
-		super(WasmPipelineType.IdBlurGlarePipeline);
-		this.lastProcessResult = null;
-		this.capturedCanvas = null;
-		this.originalCapturedCanvas = null;
-	}
-	async initialize(config) {
-		await this.initializeBase(config, "idCapture");
-	}
-	setCallbacks(callbacks) {
-		this.ensureInitialized();
-		const onCaptureWrapper = () => {
-			callbacks.onCapture?.();
-		};
-		mlWasmJSApi_default.setIdCaptureCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onDetectionStarted ?? (() => {}), callbacks.onMaskChange ? (show, mask, top, orientation) => callbacks.onMaskChange?.(show, mask, top, orientation) : () => {}, callbacks.onBlur ?? (() => {}), callbacks.onGlare ?? (() => {}), callbacks.onCapturing ?? (() => {}), callbacks.onCapture ? onCaptureWrapper : () => {}, callbacks.onBestFrame ? (blur, glare, orientation) => callbacks.onBestFrame?.(blur, glare, orientation) : () => {}, callbacks.onIdNotDetected ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onIdTypeChange ? (idType) => callbacks.onIdTypeChange?.(idType) : () => {}, callbacks.onIdSideChange ? (side) => callbacks.onIdSideChange?.(side) : () => {}, callbacks.onCapturingCounterValueChange ? (value) => callbacks.onCapturingCounterValueChange?.(value) : () => {});
-	}
-	setThresholds(thresholds) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureThresholds(this.getPipelineType(), thresholds.blurThreshold, thresholds.blurChangeThreshold, thresholds.glareThreshold, thresholds.clsThreshold, thresholds.sideThreshold, thresholds.iouThreshold, thresholds.idDetectedTimeout, thresholds.autocaptureTimeout, thresholds.framesAggregationInterval);
-	}
-	setGeometry(geometry) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureGeometryParams(this.getPipelineType(), geometry.areaDown, geometry.areaUp, geometry.areaIOSPassportUp, geometry.areaIOSPassportDown, geometry.widthIOSUp, geometry.widthIOSDown, geometry.widthDown, geometry.widthUp, geometry.windowOuterWidth, geometry.windowOuterHeight, geometry.windowInnerWidth, geometry.windowInnerHeight);
-	}
-	setSettings(settings) {
-		this.ensureInitialized();
-		mlWasmJSApi_default.setIdCaptureConfigParams(this.getPipelineType(), settings.isFixedMask, settings.isIPhone14OrHigher, settings.idType, settings.blurCheckEnabled, settings.glareCheckEnabled, settings.faceQualityCheckEnabled, settings.iouCheckEnabled, settings.fpsLimitEnabled);
-	}
-	setModelType(modelType) {
-		this.ensureInitialized();
-		let wasmModelType;
-		switch (modelType) {
-			case "v1":
-				wasmModelType = IdCaptureModelType.IdCaptureV1x;
-				break;
-			case "v2":
-				wasmModelType = IdCaptureModelType.IdCaptureV2x;
-				break;
-			case "v3":
-				wasmModelType = IdCaptureModelType.IdCaptureV3x;
-				break;
-			default: throw new Error(`Unknown model type: ${modelType}`);
-		}
-		mlWasmJSApi_default.setIdCaptureModelType(this.getPipelineType(), wasmModelType);
-	}
-	/**
-	* Processes a frame through the WASM pipeline and stores the result.
-	*/
-	async processFrame(image) {
-		const result = await this.processFrameWasm(image);
-		const pipelineType = this.getPipelineType();
-		if (result && pipelineType === WasmPipelineType.IdBlurGlarePipeline) this.lastProcessResult = result;
-		else this.lastProcessResult = null;
-	}
-	/**
-	* Gets the last process result from the most recent frame processing.
-	* @returns The last process result with quad coordinates, or null if not available
-	*/
-	getLastProcessResult() {
-		return this.lastProcessResult;
-	}
-	transformPerspective(canvas, frameRect) {
-		this.ensureInitialized();
-		const originalWidth = canvas.width();
-		const originalHeight = canvas.height();
-		try {
-			const imageData = canvas.getImageData();
-			if (!imageData) return canvas;
-			const transformedCanvas = mlWasmJSApi_default.IdPerspectiveTransform(imageData, frameRect);
-			if (transformedCanvas) {
-				const wrappedCanvas = new IncodeCanvas(transformedCanvas);
-				const wrappedWidth = wrappedCanvas.width();
-				const wrappedHeight = wrappedCanvas.height();
-				if (wrappedWidth === originalWidth && wrappedHeight === originalHeight) {
-					const croppedCanvas = this.cropCanvasToRect(wrappedCanvas, {
-						x: Math.round(frameRect.x),
-						y: Math.round(frameRect.y),
-						w: Math.round(frameRect.w),
-						h: Math.round(frameRect.h)
-					});
-					if (croppedCanvas) return croppedCanvas;
-				}
-				return wrappedCanvas;
-			}
-			return canvas;
-		} catch (_error) {
-			return canvas;
+//#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);
 	}
-	/**
-	* Crops a canvas to the specified rectangle region.
-	* @param canvas - The canvas to crop
-	* @param rect - The rectangle to crop to (x, y, w, h)
-	* @returns A new IncodeCanvas with the cropped region, or null if cropping fails
-	*/
-	cropCanvasToRect(canvas, rect) {
-		const canvasWidth = canvas.width();
-		const canvasHeight = canvas.height();
-		if (!canvasWidth || !canvasHeight) return null;
-		const x = Math.max(0, Math.min(rect.x, canvasWidth));
-		const y = Math.max(0, Math.min(rect.y, canvasHeight));
-		const w = Math.max(1, Math.min(rect.w, canvasWidth - x));
-		const h = Math.max(1, Math.min(rect.h, canvasHeight - y));
-		const croppedCanvasElement = document.createElement("canvas");
-		croppedCanvasElement.width = w;
-		croppedCanvasElement.height = h;
-		const ctx = croppedCanvasElement.getContext("2d");
-		if (!ctx) return null;
-		ctx.drawImage(canvas.canvas, x, y, w, h, 0, 0, w, h);
-		return new IncodeCanvas(croppedCanvasElement);
-	}
-	/**
-	* Gets the captured canvas (transformed for preview).
-	* @returns The captured canvas, or null if not available
-	*/
-	getCapturedCanvas() {
-		return this.capturedCanvas;
-	}
-	/**
-	* Gets the original captured canvas (full frame for upload).
-	* @returns The original captured canvas, or null if not available
-	*/
-	getOriginalCapturedCanvas() {
-		return this.originalCapturedCanvas;
-	}
-	/**
-	* Sets the captured canvases (original and transformed).
-	* @param original - The original full-frame canvas (for upload)
-	* @param transformed - The transformed canvas (for preview)
-	*/
-	setCapturedCanvases(original, transformed) {
-		this.originalCapturedCanvas = original;
-		this.capturedCanvas = transformed;
-	}
-	reset() {
-		super.reset();
-		this.lastProcessResult = null;
-		this.capturedCanvas = null;
-		this.originalCapturedCanvas = null;
+};
+const imageFileToDataUrl = async (file, options = {}) => {
+	if (!canNormalizeImageFile(file)) return readFileAsDataUrl(file);
+	try {
+		return await fileToCanvasDataUrl(file, options);
+	} catch {
+		return readFileAsDataUrl(file);
 	}
 };
 
@@ -738,7 +680,7 @@ function preloadIdRecordingProvider(config) {
 	preloadOpenViduProvider();
 }
 async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-O4GjBseO.esm.js");
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-B_0GKkzc.esm.js");
 	return new OpenViduRecordingProvider();
 }
 async function startRecordingSession(params) {
@@ -811,96 +753,49 @@ async function uploadManualIdFile(params) {
 	return res.data;
 }
 
-//#endregion
-//#region src/modules/id/manualUpload/manualUploadErrors.ts
-/**
-* i18n keys for manual-upload user-facing error copy.
-* Keep in sync with `packages/ui/src/i18n/**.json` under the `manualIdUpload.*` namespace.
-*/
-const MANUAL_UPLOAD_ERROR_KEYS = {
-	wrongSide: "manualIdUpload.wrongSide",
-	wrongDocument: "manualIdUpload.wrongDocument",
-	fileTooBig: "manualIdUpload.fileTooBig",
-	generic: "manualIdUpload.generic",
-	lowSharpness: "manualIdUpload.lowSharpness",
-	glareDetected: "manualIdUpload.glareDetected",
-	readabilityIssue: "manualIdUpload.readabilityIssue"
-};
-/**
-* 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 src/modules/id/manualUpload/manualUploadServices.ts
-/**
-* Read a File's bytes and return the raw base64 payload (the portion after
-* `data:<mime>;base64,`). The backend's `/omni/add/*-id/v2` endpoints reject
-* full data-URLs with `IllegalArgumentException: Illegal base64 character 3a`,
-* so the prefix must be stripped before posting. Mirrors the live-camera
-* path in `packages/infra/src/media/canvas.ts:getBase64Image()`.
-*/
-function fileToBase64Payload(file) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onload = () => {
-			const result = reader.result;
-			if (typeof result !== "string") {
-				reject(/* @__PURE__ */ new Error("FileReader produced non-string result"));
-				return;
-			}
-			const commaIndex = result.indexOf(",");
-			resolve(commaIndex === -1 ? result : result.slice(commaIndex + 1));
-		};
-		reader.onerror = () => {
-			reject(reader.error ?? /* @__PURE__ */ new Error("FileReader failed"));
-		};
-		reader.readAsDataURL(file);
-	});
-}
+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) => {
+	return stripDataUrlPrefix(await imageFileToDataUrl(file));
+};
 
 //#endregion
 //#region src/modules/id/manualUpload/manualUploadStateMachine.ts
 const uploadManualFileActor = fromPromise(async ({ input, signal }) => {
 	const base64Image = await fileToBase64Payload(input.file);
-	return uploadManualIdFile({
-		side: input.side,
-		base64Image,
-		retry: input.retry,
-		onlyFront: input.onlyFront,
-		isSecondId: input.isSecondId,
-		extractIdFace: input.extractIdFace,
-		signal
-	});
+	if (!isBase64PayloadWithinSize(base64Image, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES)) 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 getUploadResponseFromEvent = (event) => {
+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: {},
@@ -958,14 +853,15 @@ const _manualUploadMachine = setup({
 			errorSide: null
 		})),
 		recordSkipBackFromResponse: assign(({ event }) => {
-			if (!("output" in event)) return {};
-			if (!event.output.skipBackIdCapture) return {};
+			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 }) => {
-			if (!("output" in event)) return {};
-			const response = event.output;
+			const response = getUploadResponseFromEvent(event);
+			if (!response) return {};
 			return { errorMessage: mapFailReasonToErrorKey(response, context.activeTab) ?? "manualIdUpload.generic" };
 		}),
 		setManualUploadGenericError: assign(() => ({ errorMessage: "manualIdUpload.generic" })),
@@ -1004,7 +900,8 @@ const _manualUploadMachine = setup({
 			const response = getUploadResponseFromEvent(event);
 			if (!response) return false;
 			return mapFailReasonToErrorKey(response, context.activeTab) !== null;
-		}
+		},
+		manualUploadPayloadTooLarge: ({ event }) => getUploadOutputFromEvent(event)?.type === "fileTooLarge"
 	}
 }).createMachine({
 	id: "manualUpload",
@@ -1078,22 +975,30 @@ const _manualUploadMachine = setup({
 				isSecondId: context.isSecondId,
 				extractIdFace: context.extractIdFace
 			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadErrorFromResponse",
-					"markErrorSideFront"
-				]
-			}, {
-				target: "selecting",
-				actions: [
-					"markFrontUploaded",
-					"recordSkipBackFromResponse",
-					"clearManualUploadError"
-				]
-			}],
+			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: [
@@ -1113,18 +1018,26 @@ const _manualUploadMachine = setup({
 				onlyFront: false,
 				isSecondId: context.isSecondId
 			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadErrorFromResponse",
-					"markErrorSideBack"
-				]
-			}, {
-				target: "selecting",
-				actions: ["markBackUploaded", "clearManualUploadError"]
-			}],
+			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: [
@@ -1145,18 +1058,26 @@ const _manualUploadMachine = setup({
 				isSecondId: context.isSecondId,
 				extractIdFace: context.extractIdFace
 			}),
-			onDone: [{
-				guard: "manualUploadResponseHasError",
-				target: "checkRetries",
-				actions: [
-					"decrementManualUploadRetries",
-					"setManualUploadErrorFromResponse",
-					"markErrorSidePassport"
-				]
-			}, {
-				target: "selecting",
-				actions: ["markPassportUploaded", "clearManualUploadError"]
-			}],
+			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: [
@@ -1184,26 +1105,258 @@ const _manualUploadMachine = setup({
 const manualUploadMachine = _manualUploadMachine;
 
 //#endregion
-//#region ../infra/src/wasm/idCaptureDefaults.ts
+//#region src/modules/id/manualUpload/instrumentation.ts
 /**
-* Default WASM thresholds for ID capture quality checks.
-* Based on legacy pipelinesConfig.ts values.
+* Maps an ID Manual Upload child-machine snapshot to the exact Figma
+* "Tracked Events" screen name. Source: ID Manual Upload Figma file
+* (`https://www.figma.com/design/WCx6d4zXG5nu946mu0KZNO/ID-Manual-Upload---Latest-Design?node-id=2462-18986`).
+*
+* Family is `IDmanual.*` — emitted cross-family under the parent
+* `idCapture` module token (same precedent as `uploadDigitalid.*` from
+* the digital-upload sub-flow). Manual upload has no standalone manager
+* or module token of its own.
+*
+* The mapper returns Figma-verbatim strings (e.g.
+* `'IDmanual.upload.uploadedFrontandBack'`) which the adapter emits as-is
+* on `event.screen`. See `docs/patterns/INSTRUMENTATION.md`.
+*
+* In-scope Figma screens (driven from child SM state + context):
+*
+* - `IDmanual.upload.default` — selecting, ID tab, no front file yet
+* - `IDmanual.upload.uploadedFront` — selecting, ID tab, front uploaded,
+*   back still needed
+* - `IDmanual.upload.uploadedFrontandBack` — selecting, ID tab, both
+*   sides uploaded (or `onlyFront`/`skipBackFromServer` short-circuit)
+* - `IDmanual.upload.passport` — selecting, passport tab, no file
+* - `IDmanual.upload.uploadedPassport` — selecting, passport tab,
+*   passport uploaded
+* - `IDmanual.error.document` — selecting, with a populated
+*   `errorMessage`
+*
+* Figma screens intentionally NOT mapped here (parent-level surfaces or
+* shared with other families):
+*
+* - `IDmanual.documentchooser.default` / `IDmanual.howtoverify` —
+*   the chooser and the "how to verify" tutorial are PARENT-LEVEL
+*   `idCapture` surfaces (one shared React component, fired BEFORE the
+*   user picks manual-vs-digital). The Upload Digital ID canvas
+*   describes the same physical pixels under its own family name.
+*   Decision (Option A, recorded in `.cursor/commands/sync-events.md`):
+*   keep emitting the neutral parent names `idCapture.documentchooser`
+*   and `idCapture.tutorial.{front,back,passport}` and treat the
+*   per-canvas Figma names as design-side aliases. Per-flow attribution
+*   would require a `selectedDocumentType`-aware override at the parent
+*   dispatcher — explicitly NOT shipped here.
+* - `digitalID.success.default` — appears on the canvas for reference,
+*   but the actual success surface is emitted by `mapDigitalIdScreenName`
+*   as `uploadDigitalid.success.default`. Manual upload has no dedicated
+*   success screen; `finished` returns control to the parent SM.
+*
+* Returns `undefined` for transient (`uploadingFront`/`uploadingBack`/
+* `uploadingPassport`/`checkRetries`) and terminal (`retriesExhausted`/
+* `exhausted`/`finished`) states — the parent dispatcher falls back to
+* its existing default (`idCapture.manualIdUpload`) for those beats.
 */
-const DEFAULT_ID_CAPTURE_THRESHOLDS = {
-	blurThreshold: .2,
-	blurChangeThreshold: .2,
-	glareThreshold: .3,
-	clsThreshold: .98,
-	sideThreshold: .8,
-	iouThreshold: .8,
-	idDetectedTimeout: 1e4,
-	autocaptureTimeout: 5e3,
-	framesAggregationInterval: 3e3
+function mapIdManualUploadScreenName(value, context) {
+	if (value !== "selecting" || context === void 0) return;
+	if (context.errorMessage !== null) return "IDmanual.error.document";
+	if (context.activeTab === "passport") return context.passportUploaded ? "IDmanual.upload.uploadedPassport" : "IDmanual.upload.passport";
+	if (!context.frontUploaded) return "IDmanual.upload.default";
+	if (context.backUploaded || context.skipBackFromServer || context.onlyFront) return "IDmanual.upload.uploadedFrontandBack";
+	return "IDmanual.upload.uploadedFront";
+}
+
+//#endregion
+//#region src/modules/id/idCaptureGuards.ts
+const hasShowTutorialGuard = ({ context }) => context.config.showTutorial;
+const hasAgeAssuranceGuard = ({ context }) => context.config.ageAssurance === true;
+const hasShowDocumentChooserGuard = ({ context }) => !context.config.onlyBack && (context.config.showDocumentChooserScreen ?? false);
+const isPermissionGrantedGuard = ({ event }) => {
+	if ("output" in event) return event.output === "granted";
+	return false;
+};
+const isReadyForCaptureGuard = ({ context, event }) => {
+	return isReadyForCaptureFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
+};
+const needsMotionPrimeOnlyGuard = ({ context, event }) => {
+	return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, 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 hasAttemptsRemainingGuard = ({ context }) => context.attemptsRemaining > 0;
+const hasCapturedImageGuard = ({ context }) => {
+	return context.provider?.getCapturedCanvas() !== null;
+};
+const hasUploadValidationErrorGuard = ({ context }) => {
+	if (!context.uploadResponse) return false;
+	return validateUploadResponse(context.uploadResponse, {
+		skipGlareFront: context.uploadResponse.skipGlareFront,
+		skipGlareBack: context.uploadResponse.skipGlareBack
+	}) !== void 0;
+};
+const isFrontModeGuard = ({ context }) => context.currentMode === "front" || context.currentMode === "passport";
+/**
+* `config.onlyFront` from the orchestrated flow JSON is intentionally not
+* read here: the flow value cannot account for per-document overrides, so the
+* backend resolves the real policy per document at upload time
+* (via `skipBackIdCapture` on the upload response). Standalone
+* `idCaptureManager` consumers that pass `onlyFront: true` directly will
+* therefore also be ignored — re-wire this guard if that capability is needed
+* again.
+*/
+const isOnlyFrontGuard = (_args) => false;
+const shouldContinueToBackGuard = ({ context }) => {
+	if (context.currentMode !== "front" && context.currentMode !== "passport") return false;
+	if (context.config.onlyBack) return false;
+	if (context.config.usSmartCapture) return false;
+	if (context.uploadResponse?.skipBackIdCapture) return false;
+	return true;
+};
+const shouldContinueToFrontGuard = ({ context }) => context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
+const hasMandatoryConsentGuard = ({ context }) => context.uploadResponse?.showMandatoryConsent === true;
+const isDeepsightEnabledGuard = ({ context }) => context.dependencies !== void 0;
+const isDeepsightReadyGuard = ({ context }) => context.deepsightService !== void 0;
+const needsDeepsightInitGuard = ({ context }) => context.dependencies !== void 0 && context.deepsightService === void 0 && !context.deepsightInitAttempted;
+const hasOnlyManualUploadAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 1 && context.availableDocumentTypes[0] === "manualIdUpload";
+/** 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;
+/**
+* Fixed cap on same-side expired retries, intentionally decoupled from the
+* dashboard-configurable `captureAttempts`.
+*
+* Business decision: the expired-ID retry policy is a fixed UX limit ("let the
+* user try a different ID a bounded number of times"), separate from the
+* generic capture-quality retry budget. The value `3` and this separation are
+* prescribed by the ENG-41643 spec — "[WEB] Document FE - Handle Expired ID
+* Errors on Front and Back ID Capture"
+* (https://app.notion.com/p/3264c3caef498080a44adf5ab62fcb77): *"Add
+* `MAX_EXPIRED_FIRST_SIDE_ATTEMPTS = 3` constant"* / *"Allow up to 3 attempts
+* when expired ID is detected on first side capture"*. SDK V1 implements it as
+* exactly this hardcoded constant (incode-welcome `Capture.tsx`), independent
+* of the configured capture-attempts; this restores that parity for ENG-46592
+* (https://app.notion.com/p/36b4c3caef4980f58f3ee3b1b4e234f2).
+*
+* NOTE: ENG-45666's acceptance text says the cap should follow "a specified
+* number of times if differently set on dashboard/SDK level". That wording
+* conflicts with the ENG-41643 spec + V1 for the *expired* path specifically;
+* V1 parity was chosen as source of truth here (see changeset
+* `eng-46592-r2-expired-id-v1-parity`). The configurable `captureAttempts`
+* still governs generic (non-expired) capture retries.
+*/
+const MAX_EXPIRED_FIRST_SIDE_ATTEMPTS = 3;
+/**
+* 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 >= MAX_EXPIRED_FIRST_SIDE_ATTEMPTS;
+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;
 /**
-* Default model version for ID capture.
+* 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 DEFAULT_ID_CAPTURE_MODEL_VERSION = "v2";
+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;
+
+//#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
+	};
+}
 
 //#endregion
 //#region src/modules/id/idCaptureActors.ts
@@ -1507,7 +1660,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-8tnddNx-.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DHSVD776.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -1765,115 +1918,12 @@ function getCurrentModeFromEvent(context, event) {
 }
 
 //#endregion
-//#region src/modules/id/idCaptureGuards.ts
-const hasShowTutorialGuard = ({ context }) => context.config.showTutorial;
-const hasAgeAssuranceGuard = ({ context }) => context.config.ageAssurance === true;
-const hasShowDocumentChooserGuard = ({ context }) => !context.config.onlyBack && (context.config.showDocumentChooserScreen ?? false);
-const isPermissionGrantedGuard = ({ event }) => {
-	if ("output" in event) return event.output === "granted";
-	return false;
-};
-const isReadyForCaptureGuard = ({ context, event }) => {
-	return isReadyForCaptureFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
-};
-const needsMotionPrimeOnlyGuard = ({ context, event }) => {
-	return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, 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 hasAttemptsRemainingGuard = ({ context }) => context.attemptsRemaining > 0;
-const hasCapturedImageGuard = ({ context }) => {
-	return context.provider?.getCapturedCanvas() !== null;
-};
-const hasUploadValidationErrorGuard = ({ context }) => {
-	if (!context.uploadResponse) return false;
-	return validateUploadResponse(context.uploadResponse, {
-		skipGlareFront: context.uploadResponse.skipGlareFront,
-		skipGlareBack: context.uploadResponse.skipGlareBack
-	}) !== void 0;
-};
-const isFrontModeGuard = ({ context }) => context.currentMode === "front" || context.currentMode === "passport";
-/**
-* `config.onlyFront` from the orchestrated flow JSON is intentionally not
-* read here: the flow value cannot account for per-document overrides, so the
-* backend resolves the real policy per document at upload time
-* (via `skipBackIdCapture` on the upload response). Standalone
-* `idCaptureManager` consumers that pass `onlyFront: true` directly will
-* therefore also be ignored — re-wire this guard if that capability is needed
-* again.
-*/
-const isOnlyFrontGuard = (_args) => false;
-const shouldContinueToBackGuard = ({ context }) => {
-	if (context.currentMode !== "front" && context.currentMode !== "passport") return false;
-	if (context.config.onlyBack) return false;
-	if (context.config.usSmartCapture) return false;
-	if (context.uploadResponse?.skipBackIdCapture) {
-		if (!(context.config.alwaysCaptureBackOfId === true && context.currentMode !== "passport")) return false;
-	}
-	return true;
-};
-const shouldContinueToFrontGuard = ({ context }) => context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
-const hasMandatoryConsentGuard = ({ context }) => context.uploadResponse?.showMandatoryConsent === true;
-const isDeepsightEnabledGuard = ({ context }) => context.dependencies !== void 0;
-const isDeepsightReadyGuard = ({ context }) => context.deepsightService !== void 0;
-const needsDeepsightInitGuard = ({ context }) => context.dependencies !== void 0 && context.deepsightService === void 0 && !context.deepsightInitAttempted;
-const hasOnlyManualUploadAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 1 && context.availableDocumentTypes[0] === "manualIdUpload";
-const isManualIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "manualIdUpload";
-const isDigitalIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "digitalIdUpload";
-const isUploadExpiredGuard = ({ context }) => context.uploadResponse?.isDocumentExpired === true;
-/**
-* True when *this* expired upload will exhaust the budget. Compares the
-* post-increment count, so the exhaustion branch can be picked in the same
-* tick that runs `incrementExpiredAttempts`. With `captureAttempts=3`:
-* - attempt 1 → 0+1=1 (not exhausted)
-* - attempt 2 → 1+1=2 (not exhausted)
-* - attempt 3 → 2+1=3 (exhausted, force-back / finish)
-*/
-const isExpiredAttemptsExhaustedGuard = ({ context }) => context.expiredAttempts + 1 >= context.config.captureAttempts;
-const isNotPassportModeGuard = ({ context }) => context.currentMode !== "passport";
-/**
-* V1 parity for `shouldApplyAlwaysCaptureBackOverride` — force-redirects to
-* back capture after expired-front-attempts exhaust, but only when:
-* - we're on the front side
-* - `alwaysCaptureBackOfId` is set
-* - the flow isn't single-side (onlyBack / usSmartCapture)
-* - the session isn't a Digital ID upload (digital IDs are PDFs — no back
-*   side exists, so the override never applies regardless of config)
-*/
-const shouldForceBackOnExpiredGuard = ({ context }) => context.currentMode === "front" && context.config.alwaysCaptureBackOfId === true && !context.config.onlyBack && !context.config.usSmartCapture && !context.isDigitalUpload;
-const wasExpiredFromUploadGuard = ({ context }) => context.expiredFromUpload === true;
-const shouldSkipProcessIdGuard = ({ context }) => context.skipProcessId === true;
-/**
-* Bug 4 fix: when `expiredExhausted` is reached via the per-upload-expired
-* exhaustion path with a back side captured (or the entire single-side back
-* flow), we want `processId` to run once on Continue so the backend
-* processes whatever sides were uploaded. Front-only exhaustion (no back to
-* process) and the force-back V1 path keep using `setSkipProcessId` instead.
-*/
-const shouldProcessAfterExhaustionGuard = ({ context }) => context.exhaustedFromUpload === true && context.currentMode === "back";
-/**
-* `processing.onDone` reads this to short-circuit straight to `finished`
-* after the post-exhaustion `processId` call returns — without it, an
-* `isDocumentExpired:true` response would loop back to the Expired screen
-* we just terminated.
-*/
-const forceFinishAfterProcessingGuard = ({ context }) => context.forceFinishAfterProcessing === true;
+//#region src/modules/id/idCaptureStateMachine.ts
 /**
-* Cap on the end-of-flow expired path. All capture types (camera, digital,
-* manual) share `config.captureAttempts` for consistency — the user-visible
-* "X attempts remaining" counter is the same regardless of how the document
-* was submitted.
+* 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 isProcessingExpiredExhaustedGuard = ({ context }) => context.processingExpiredAttempts + 1 >= context.config.captureAttempts;
-
-//#endregion
-//#region src/modules/id/idCaptureStateMachine.ts
+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;
@@ -2069,6 +2119,7 @@ const _idCaptureMachine = setup({
 		setSkipProcessId: assign({ skipProcessId: () => true }),
 		setExpiredFromUpload: assign({ expiredFromUpload: () => true }),
 		setExhaustedFromUpload: assign({ exhaustedFromUpload: () => true }),
+		setExpiredRedirected: assign({ expiredRedirected: () => true }),
 		setForceFinishAfterProcessing: assign({ forceFinishAfterProcessing: () => true }),
 		clearExpiredFromUpload: assign({ expiredFromUpload: () => false })
 	},
@@ -2093,6 +2144,7 @@ const _idCaptureMachine = setup({
 		isDeepsightReady: isDeepsightReadyGuard,
 		needsDeepsightInit: needsDeepsightInitGuard,
 		hasOnlyManualUploadAvailable: hasOnlyManualUploadAvailableGuard,
+		hasNoDocumentTypesAvailable: hasNoDocumentTypesAvailableGuard,
 		isManualIdUploadSelected: isManualIdUploadSelectedGuard,
 		isDigitalIdUploadSelected: isDigitalIdUploadSelectedGuard,
 		isUploadExpired: isUploadExpiredGuard,
@@ -2104,6 +2156,8 @@ const _idCaptureMachine = setup({
 		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"
@@ -2130,6 +2184,7 @@ const _idCaptureMachine = setup({
 			recordingSession: void 0,
 			attemptsRemaining: input.config.captureAttempts,
 			expiredAttempts: 0,
+			expiredRedirected: false,
 			processingExpiredAttempts: 0,
 			skipProcessId: input.config.skipProcessId === true,
 			expiredFromUpload: false,
@@ -2163,6 +2218,11 @@ const _idCaptureMachine = setup({
 	},
 	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"
@@ -2659,6 +2719,15 @@ const _idCaptureMachine = setup({
 						target: "#idCapture.finished",
 						guard: and(["shouldSkipProcessId", "isUploadExpired"])
 					},
+					{
+						target: "#idCapture.expiredExhausted",
+						guard: and([
+							"isNotPassportMode",
+							"isUploadExpired",
+							"wasExpiredRedirected"
+						]),
+						actions: ["setExhaustedFromUpload"]
+					},
 					{
 						target: "#idCapture.expiredExhausted",
 						guard: and([
@@ -2858,6 +2927,20 @@ const _idCaptureMachine = setup({
 			}
 		},
 		expired: { on: { RETRY_CAPTURE: [
+			{
+				target: "#idCapture.backFinished",
+				guard: and([
+					"wasExpiredFromUpload",
+					"isBackModeInMultiSideFlow",
+					not("wasExpiredRedirected")
+				]),
+				actions: [
+					"resetDetection",
+					"clearExpiredFromUpload",
+					"clearUploadFailure",
+					"setExpiredRedirected"
+				]
+			},
 			{
 				target: "#idCapture.capture",
 				guard: "wasExpiredFromUpload",
@@ -2887,22 +2970,25 @@ const _idCaptureMachine = setup({
 				actions: "resetContext"
 			}
 		] } },
-		expiredExhausted: { on: { CONTINUE_EXHAUSTED: [
-			{
-				target: "#idCapture.frontFinished",
-				guard: "shouldForceBackOnExpired",
-				actions: ["setSkipProcessId"]
-			},
-			{
-				target: "#idCapture.processing",
-				guard: "shouldProcessAfterExhaustion",
-				actions: ["setForceFinishAfterProcessing"]
-			},
-			{
-				target: "#idCapture.finished",
-				actions: ["setSkipProcessId"]
-			}
-		] } },
+		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",
@@ -3009,4 +3095,4 @@ const _idCaptureMachine = setup({
 const idCaptureMachine = _idCaptureMachine;
 
 //#endregion
-export { startRecordingSession as a, uploadIdImage as c, ID_ERROR_CODES as d, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as f, mapDigitalIdScreenName as h, processId as i, uploadManualIdFile as l, MANUAL_UPLOAD_MAX_RETRIES as m, initializeIdCapture as n, stopRecording as o, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as p, preloadIdRecordingProvider as r, stopStream as s, idCaptureMachine as t, validateUploadResponse as u };
+export { MANUAL_UPLOAD_MAX_RETRIES as _, initializeIdCapture as a, startRecordingSession as c, uploadIdImage as d, uploadManualIdFile as f, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES as g, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS as h, mapIdManualUploadScreenName as i, stopRecording as l, ID_ERROR_CODES as m, getManualUploadTabs as n, preloadIdRecordingProvider as o, validateUploadResponse as p, MAX_EXPIRED_FIRST_SIDE_ATTEMPTS as r, processId as s, idCaptureMachine as t, stopStream as u, mapDigitalIdScreenName as v };