@incodetech/core 0.0.0-dev-20260508-a05aa65 → 0.0.0-dev-20260508-4bd5e49

package/dist/{idCaptureStateMachine-CjhFzer8.esm.js → idCaptureStateMachine-Em0doWas.esm.js}

@@ -3,8 +3,8 @@ import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BZGH3sYJ.esm.j
 import { r as getToken, t as api } from "./api-eqRXuVG-.esm.js";
 import { S as revokeObjectURL } from "./events-Bt1azl2B.esm.js";
 import { t as endpoints } from "./endpoints-B3V1U9Dg.esm.js";
-import { t as getDisableIpify } from "./session-f758tX1l.esm.js";
-import { i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-C19_S3_9.esm.js";
+import { t as getDisableIpify } from "./session-CSrf0jcz.esm.js";
+import { a as fromPromise, i as fromCallback, n as sendTo, r as assign, t as setup } from "./xstate.esm-7GmmAwg6.esm.js";
 import { _ as StreamCanvasCapture, d as createRecordingSession, f as startRecording, g as flagIdManualReview, m as StreamCanvasProcessingSession, n as preloadOpenViduProvider, p as stopRecording$1 } from "./recordingService-Dc8qrd2u.esm.js";
 import { n as IncodeCanvas } from "./deepsightService-gNTXZu7Y.esm.js";
 import { n as requestPermission, r as clearCameraPermissionCache, t as checkPermission } from "./permissionServices-DIxFacTA.esm.js";
@@ -197,6 +197,12 @@ async function getIdCameraStream(deviceId) {
 	return getBackCameraStream(deviceId);
 }
 
+//#endregion
+//#region src/modules/id/manualUpload/types.ts
+const MANUAL_UPLOAD_MAX_RETRIES = 3;
+const MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
+const MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS = 5e3;
+
 //#endregion
 //#region src/modules/id/types.ts
 const ID_ERROR_CODES = {
@@ -216,9 +222,6 @@ const ID_ERROR_CODES = {
 	USER_CANCELLED: "USER_CANCELLED",
 	SERVER: "SERVER_ERROR"
 };
-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/idCaptureServices.ts
@@ -501,6 +504,337 @@ 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",
+	qualityRejected: "manualIdUpload.qualityRejected"
+};
+/**
+* Map the server's `failReason` (plus client-side passport/ID tab mismatch and
+* per-image quality flags) onto an i18n key. Mirrors v1's `shouldUploadAgain`
+* branch logic in
+* `ms-incodesmile-web/packages/incode-welcome/src/manualIdUpload/manuaIdUpload.tsx`,
+* extended to also reject responses where the backend flagged a per-image
+* quality issue (`correctSharpness`, `correctGlare`, `readability`, or
+* `idQualityAttemptApproved` set to `false`).
+*
+* Quality flags are checked with `=== false` so missing/undefined values
+* (older backends, partial payloads) keep the legacy "trust the server"
+* behaviour and do not produce false positives.
+*
+* Returns `null` when the response represents a successful upload — the caller
+* should treat `null` as "no error, advance to next slot".
+*/
+function mapFailReasonToErrorKey(response, expectedTab) {
+	const failReason = response.failReason;
+	if (failReason === "WRONG_DOCUMENT_SIDE") return MANUAL_UPLOAD_ERROR_KEYS.wrongSide;
+	if (failReason === "WRONG_ONE_SIDED_DOCUMENT" || failReason === "UNKNOWN_DOCUMENT_TYPE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
+	if (failReason === "ID_TYPE_UNACCEPTABLE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
+	if (expectedTab === "passport" && response.typeOfId && response.typeOfId.toLowerCase() !== "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
+	if (expectedTab === "id" && response.typeOfId?.toLowerCase() === "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
+	if (response.correctSharpness === false) return MANUAL_UPLOAD_ERROR_KEYS.lowSharpness;
+	if (response.correctGlare === false) return MANUAL_UPLOAD_ERROR_KEYS.glareDetected;
+	if (response.readability === false) return MANUAL_UPLOAD_ERROR_KEYS.readabilityIssue;
+	if (response.idQualityAttemptApproved === false) return MANUAL_UPLOAD_ERROR_KEYS.qualityRejected;
+	return null;
+}
+
+//#endregion
+//#region src/modules/id/manualUpload/manualUploadServices.ts
+/**
+* Read a File's bytes and return the raw base64 payload (the portion after
+* `data:<mime>;base64,`). The backend's `/omni/add/*-id/v2` endpoints reject
+* full data-URLs with `IllegalArgumentException: Illegal base64 character 3a`,
+* so the prefix must be stripped before posting. Mirrors the live-camera
+* path in `packages/infra/src/media/canvas.ts:getBase64Image()`.
+*/
+function fileToBase64Payload(file) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => {
+			const result = reader.result;
+			if (typeof result !== "string") {
+				reject(/* @__PURE__ */ new Error("FileReader produced non-string result"));
+				return;
+			}
+			const commaIndex = result.indexOf(",");
+			resolve(commaIndex === -1 ? result : result.slice(commaIndex + 1));
+		};
+		reader.onerror = () => {
+			reject(reader.error ?? /* @__PURE__ */ new Error("FileReader failed"));
+		};
+		reader.readAsDataURL(file);
+	});
+}
+
+//#endregion
+//#region src/modules/id/manualUpload/manualUploadStateMachine.ts
+const uploadManualFileActor = fromPromise(async ({ input, signal }) => {
+	const base64Image = await fileToBase64Payload(input.file);
+	return uploadManualIdFile({
+		side: input.side,
+		base64Image,
+		retry: input.retry,
+		onlyFront: input.onlyFront,
+		isSecondId: input.isSecondId,
+		signal
+	});
+});
+const getUploadResponseFromEvent = (event) => {
+	if ("output" in event) return event.output;
+};
+const _manualUploadMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {},
+		output: {}
+	},
+	actors: { uploadManualFile: uploadManualFileActor },
+	actions: {
+		setManualUploadActiveTab: assign(({ event }) => {
+			if (event.type !== "MANUAL_UPLOAD_TAB_CHANGED") return {};
+			return {
+				activeTab: event.tab,
+				frontFile: null,
+				backFile: null,
+				passportFile: null,
+				frontUploaded: false,
+				backUploaded: false,
+				passportUploaded: false,
+				skipBackFromServer: false,
+				errorMessage: null,
+				retriesLeft: MANUAL_UPLOAD_MAX_RETRIES
+			};
+		}),
+		resetManualUpload: assign(() => ({
+			frontFile: null,
+			backFile: null,
+			passportFile: null,
+			frontUploaded: false,
+			backUploaded: false,
+			passportUploaded: false,
+			skipBackFromServer: false,
+			errorMessage: null,
+			retriesLeft: MANUAL_UPLOAD_MAX_RETRIES
+		})),
+		storeSelectedFile: assign(({ event }) => {
+			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return {};
+			const updated = { errorMessage: null };
+			if (event.side === "front") updated.frontFile = event.file;
+			else if (event.side === "back") updated.backFile = event.file;
+			else updated.passportFile = event.file;
+			return updated;
+		}),
+		markFrontUploaded: assign(() => ({
+			frontUploaded: true,
+			errorMessage: null
+		})),
+		markBackUploaded: assign(() => ({
+			backUploaded: true,
+			errorMessage: null
+		})),
+		markPassportUploaded: assign(() => ({
+			passportUploaded: true,
+			errorMessage: null
+		})),
+		recordSkipBackFromResponse: assign(({ event }) => {
+			if (!("output" in event)) return {};
+			if (!event.output.skipBackIdCapture) return {};
+			return { skipBackFromServer: true };
+		}),
+		decrementManualUploadRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
+		setManualUploadErrorFromResponse: assign(({ context, event }) => {
+			if (!("output" in event)) return {};
+			const response = event.output;
+			return { errorMessage: mapFailReasonToErrorKey(response, context.activeTab) ?? "manualIdUpload.generic" };
+		}),
+		setManualUploadGenericError: assign(() => ({ errorMessage: "manualIdUpload.generic" })),
+		setManualUploadFileTooLargeError: assign(() => ({ errorMessage: "manualIdUpload.fileTooBig" })),
+		clearManualUploadError: assign(() => ({ errorMessage: null }))
+	},
+	guards: {
+		isSelectedFileTooLarge: ({ event }) => {
+			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return false;
+			return event.file.size > MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES;
+		},
+		isFrontFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "front",
+		isBackFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "back",
+		isPassportFileSelection: ({ event }) => event.type === "MANUAL_UPLOAD_FILE_SELECTED" && event.side === "passport",
+		manualUploadRetriesExhausted: ({ context }) => context.retriesLeft <= 0,
+		canContinueFromIdTab: ({ context }) => {
+			if (context.activeTab !== "id") return false;
+			if (!context.frontUploaded) return false;
+			if (context.onlyFront) return true;
+			if (context.skipBackFromServer) return true;
+			return context.backUploaded;
+		},
+		canContinueFromPassportTab: ({ context }) => context.activeTab === "passport" && context.passportUploaded,
+		manualUploadResponseHasError: ({ context, event }) => {
+			const response = getUploadResponseFromEvent(event);
+			if (!response) return false;
+			return mapFailReasonToErrorKey(response, context.activeTab) !== null;
+		}
+	}
+}).createMachine({
+	id: "manualUpload",
+	initial: "selecting",
+	context: ({ input }) => ({
+		onlyFront: input.onlyFront,
+		isSecondId: input.isSecondId,
+		frontFile: null,
+		backFile: null,
+		passportFile: null,
+		activeTab: "id",
+		retriesLeft: MANUAL_UPLOAD_MAX_RETRIES,
+		errorMessage: null,
+		skipBackFromServer: false,
+		frontUploaded: false,
+		backUploaded: false,
+		passportUploaded: false
+	}),
+	on: {
+		MANUAL_UPLOAD_TAB_CHANGED: {
+			target: ".selecting",
+			actions: ["setManualUploadActiveTab"]
+		},
+		MANUAL_UPLOAD_RESET: {
+			target: ".selecting",
+			actions: ["resetManualUpload"]
+		}
+	},
+	states: {
+		selecting: { on: {
+			MANUAL_UPLOAD_FILE_SELECTED: [
+				{
+					guard: "isSelectedFileTooLarge",
+					actions: ["setManualUploadFileTooLargeError"]
+				},
+				{
+					guard: "isFrontFileSelection",
+					target: "uploadingFront",
+					actions: ["storeSelectedFile"]
+				},
+				{
+					guard: "isBackFileSelection",
+					target: "uploadingBack",
+					actions: ["storeSelectedFile"]
+				},
+				{
+					guard: "isPassportFileSelection",
+					target: "uploadingPassport",
+					actions: ["storeSelectedFile"]
+				}
+			],
+			MANUAL_UPLOAD_CONTINUE: [{
+				guard: "canContinueFromIdTab",
+				target: "finished"
+			}, {
+				guard: "canContinueFromPassportTab",
+				target: "finished"
+			}]
+		} },
+		uploadingFront: { invoke: {
+			id: "uploadManualFile",
+			src: "uploadManualFile",
+			input: ({ context }) => ({
+				side: "front",
+				file: context.frontFile,
+				retry: context.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
+				onlyFront: context.onlyFront,
+				isSecondId: context.isSecondId
+			}),
+			onDone: [{
+				guard: "manualUploadResponseHasError",
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
+			}, {
+				target: "selecting",
+				actions: [
+					"markFrontUploaded",
+					"recordSkipBackFromResponse",
+					"clearManualUploadError"
+				]
+			}],
+			onError: {
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
+			}
+		} },
+		uploadingBack: { invoke: {
+			id: "uploadManualFile",
+			src: "uploadManualFile",
+			input: ({ context }) => ({
+				side: "back",
+				file: context.backFile,
+				retry: context.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
+				onlyFront: false,
+				isSecondId: context.isSecondId
+			}),
+			onDone: [{
+				guard: "manualUploadResponseHasError",
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
+			}, {
+				target: "selecting",
+				actions: ["markBackUploaded", "clearManualUploadError"]
+			}],
+			onError: {
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
+			}
+		} },
+		uploadingPassport: { invoke: {
+			id: "uploadManualFile",
+			src: "uploadManualFile",
+			input: ({ context }) => ({
+				side: "passport",
+				file: context.passportFile,
+				retry: context.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
+				onlyFront: false,
+				isSecondId: context.isSecondId
+			}),
+			onDone: [{
+				guard: "manualUploadResponseHasError",
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
+			}, {
+				target: "selecting",
+				actions: ["markPassportUploaded", "clearManualUploadError"]
+			}],
+			onError: {
+				target: "checkRetries",
+				actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
+			}
+		} },
+		checkRetries: { always: [{
+			guard: "manualUploadRetriesExhausted",
+			target: "retriesExhausted"
+		}, { target: "selecting" }] },
+		retriesExhausted: { after: { [MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS]: { target: "exhausted" } } },
+		exhausted: {
+			type: "final",
+			output: { result: "exhausted" }
+		},
+		finished: {
+			type: "final",
+			output: { result: "success" }
+		}
+	}
+});
+const manualUploadMachine = _manualUploadMachine;
+
 //#endregion
 //#region ../infra/src/wasm/idCaptureDefaults.ts
 /**
@@ -611,7 +945,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		windowInnerWidth: windowDimensions.innerWidth,
 		windowInnerHeight: windowDimensions.innerHeight
 	});
-	const idType = input.currentMode === "back" ? "BackId" : input.currentMode === "passport" || input.currentMode === "front" && input.config.onlyFront ? "Passport" : "FrontId";
+	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,
@@ -854,88 +1188,6 @@ const checkVirtualCameraActor = fromPromise(async ({ input }) => {
 	if (!videoTrack) return false;
 	return input.deepsightService.checkVirtualCamera(videoTrack);
 });
-/**
-* 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 uploadManualFileActor = fromPromise(async ({ input, signal }) => {
-	const base64Image = await fileToBase64Payload(input.file);
-	return uploadManualIdFile({
-		side: input.side,
-		base64Image,
-		retry: input.retry,
-		onlyFront: input.onlyFront,
-		isSecondId: input.isSecondId,
-		signal
-	});
-});
-
-//#endregion
-//#region src/modules/id/manualUploadErrors.ts
-/**
-* i18n keys for manual-upload user-facing error copy.
-* Keep in sync with `packages/ui/src/i18n/**.json` under the `manualIdUpload.*` namespace.
-*/
-const MANUAL_UPLOAD_ERROR_KEYS = {
-	wrongSide: "manualIdUpload.wrongSide",
-	wrongDocument: "manualIdUpload.wrongDocument",
-	fileTooBig: "manualIdUpload.fileTooBig",
-	generic: "manualIdUpload.generic",
-	lowSharpness: "manualIdUpload.lowSharpness",
-	glareDetected: "manualIdUpload.glareDetected",
-	readabilityIssue: "manualIdUpload.readabilityIssue",
-	qualityRejected: "manualIdUpload.qualityRejected"
-};
-/**
-* Map the server's `failReason` (plus client-side passport/ID tab mismatch and
-* per-image quality flags) onto an i18n key. Mirrors v1's `shouldUploadAgain`
-* branch logic in
-* `ms-incodesmile-web/packages/incode-welcome/src/manualIdUpload/manuaIdUpload.tsx`,
-* extended to also reject responses where the backend flagged a per-image
-* quality issue (`correctSharpness`, `correctGlare`, `readability`, or
-* `idQualityAttemptApproved` set to `false`).
-*
-* Quality flags are checked with `=== false` so missing/undefined values
-* (older backends, partial payloads) keep the legacy "trust the server"
-* behaviour and do not produce false positives.
-*
-* Returns `null` when the response represents a successful upload — the caller
-* should treat `null` as "no error, advance to next slot".
-*/
-function mapFailReasonToErrorKey(response, expectedTab) {
-	const failReason = response.failReason;
-	if (failReason === "WRONG_DOCUMENT_SIDE") return MANUAL_UPLOAD_ERROR_KEYS.wrongSide;
-	if (failReason === "WRONG_ONE_SIDED_DOCUMENT" || failReason === "UNKNOWN_DOCUMENT_TYPE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (failReason === "ID_TYPE_UNACCEPTABLE") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (expectedTab === "passport" && response.typeOfId && response.typeOfId.toLowerCase() !== "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (expectedTab === "id" && response.typeOfId?.toLowerCase() === "passport") return MANUAL_UPLOAD_ERROR_KEYS.wrongDocument;
-	if (response.correctSharpness === false) return MANUAL_UPLOAD_ERROR_KEYS.lowSharpness;
-	if (response.correctGlare === false) return MANUAL_UPLOAD_ERROR_KEYS.glareDetected;
-	if (response.readability === false) return MANUAL_UPLOAD_ERROR_KEYS.readabilityIssue;
-	if (response.idQualityAttemptApproved === false) return MANUAL_UPLOAD_ERROR_KEYS.qualityRejected;
-	return null;
-}
 
 //#endregion
 //#region src/modules/id/idCaptureActions.ts
@@ -1202,10 +1454,18 @@ const hasUploadValidationErrorGuard = ({ context }) => {
 	}) !== void 0;
 };
 const isFrontModeGuard = ({ context }) => context.currentMode === "front" || context.currentMode === "passport";
-const isOnlyFrontGuard = ({ context }) => context.config.onlyFront;
+/**
+* `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.onlyFront) return false;
 	if (context.config.onlyBack) return false;
 	if (context.config.usSmartCapture) return false;
 	if (context.uploadResponse?.skipBackIdCapture) {
@@ -1218,45 +1478,6 @@ const hasMandatoryConsentGuard = ({ context }) => context.uploadResponse?.showMa
 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 getFileFromEvent = (event) => {
-	if (event.type === "MANUAL_UPLOAD_FILE_SELECTED") return event.file;
-};
-const getSideFromEvent = (event) => {
-	if (event.type === "MANUAL_UPLOAD_FILE_SELECTED") return event.side;
-};
-const isSelectedFileTooLargeGuard = ({ event }) => {
-	const file = getFileFromEvent(event);
-	return file ? file.size > MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES : false;
-};
-const isFrontFileSelectionGuard = ({ event }) => getSideFromEvent(event) === "front";
-const isBackFileSelectionGuard = ({ event }) => getSideFromEvent(event) === "back";
-const isPassportFileSelectionGuard = ({ event }) => getSideFromEvent(event) === "passport";
-/**
-* True once `retriesLeft` has been decremented to 0 — evaluated from the
-* `checkRetries` state after the decrement action runs.
-*/
-const manualUploadRetriesExhaustedGuard = ({ context }) => context.manualUpload.retriesLeft <= 0;
-const canContinueFromIdTabGuard = ({ context }) => {
-	if (context.manualUpload.activeTab !== "id") return false;
-	if (!context.manualUpload.frontUploaded) return false;
-	if (context.config.onlyFront) return true;
-	if (context.manualUpload.skipBackFromServer) return true;
-	return context.manualUpload.backUploaded;
-};
-const canContinueFromPassportTabGuard = ({ context }) => context.manualUpload.activeTab === "passport" && context.manualUpload.passportUploaded;
-const getUploadResponseFromEvent = (event) => {
-	if ("output" in event) return event.output;
-};
-/**
-* True when the server-side upload response contains a failReason or type
-* mismatch that should be surfaced to the user and counted against retries.
-* Evaluated by the actor's `onDone`, so the response lives on `event.output`.
-*/
-const manualUploadResponseHasErrorGuard = ({ context, event }) => {
-	const response = getUploadResponseFromEvent(event);
-	if (!response) return false;
-	return mapFailReasonToErrorKey(response, context.manualUpload.activeTab) !== null;
-};
 const hasOnlyManualUploadAvailableGuard = ({ context }) => context.availableDocumentTypes.length === 1 && context.availableDocumentTypes[0] === "manualIdUpload";
 const isManualIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCUMENT" && event.documentType === "manualIdUpload";
 
@@ -1285,7 +1506,7 @@ const _idCaptureMachine = setup({
 		checkMotionSensor: checkMotionSensorActor,
 		initializeDeepsightSession: initializeDeepsightSessionActor,
 		checkVirtualCamera: checkVirtualCameraActor,
-		uploadManualFile: uploadManualFileActor
+		manualUploadMachine
 	},
 	actions: {
 		stopMediaStream: assign(({ context }) => {
@@ -1437,94 +1658,7 @@ const _idCaptureMachine = setup({
 		} }),
 		setMotionStatus: assign({ motionStatus: ({ event }) => {
 			if ("status" in event && event.type === "MOTION_STATUS") return event.status;
-		} }),
-		setManualUploadActiveTab: assign(({ context, event }) => {
-			if (event.type !== "MANUAL_UPLOAD_TAB_CHANGED") return {};
-			return { manualUpload: {
-				...context.manualUpload,
-				activeTab: event.tab,
-				frontFile: null,
-				backFile: null,
-				passportFile: null,
-				frontUploaded: false,
-				backUploaded: false,
-				passportUploaded: false,
-				skipBackFromServer: false,
-				errorMessage: null,
-				retriesLeft: MANUAL_UPLOAD_MAX_RETRIES
-			} };
-		}),
-		resetManualUpload: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			frontFile: null,
-			backFile: null,
-			passportFile: null,
-			frontUploaded: false,
-			backUploaded: false,
-			passportUploaded: false,
-			skipBackFromServer: false,
-			errorMessage: null,
-			retriesLeft: MANUAL_UPLOAD_MAX_RETRIES
-		} })),
-		storeSelectedFile: assign(({ context, event }) => {
-			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return {};
-			const updated = {
-				...context.manualUpload,
-				errorMessage: null
-			};
-			if (event.side === "front") updated.frontFile = event.file;
-			else if (event.side === "back") updated.backFile = event.file;
-			else updated.passportFile = event.file;
-			return { manualUpload: updated };
-		}),
-		markFrontUploaded: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			frontUploaded: true,
-			errorMessage: null
-		} })),
-		markBackUploaded: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			backUploaded: true,
-			errorMessage: null
-		} })),
-		markPassportUploaded: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			passportUploaded: true,
-			errorMessage: null
-		} })),
-		recordSkipBackFromResponse: assign(({ context, event }) => {
-			if (!("output" in event)) return {};
-			if (!event.output.skipBackIdCapture) return {};
-			return { manualUpload: {
-				...context.manualUpload,
-				skipBackFromServer: true
-			} };
-		}),
-		decrementManualUploadRetries: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			retriesLeft: Math.max(0, context.manualUpload.retriesLeft - 1)
-		} })),
-		setManualUploadErrorFromResponse: assign(({ context, event }) => {
-			if (!("output" in event)) return {};
-			const response = event.output;
-			const errorKey = mapFailReasonToErrorKey(response, context.manualUpload.activeTab);
-			return { manualUpload: {
-				...context.manualUpload,
-				errorMessage: errorKey ?? "manualIdUpload.generic"
-			} };
-		}),
-		setManualUploadGenericError: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			errorMessage: "manualIdUpload.generic"
-		} })),
-		setManualUploadFileTooLargeError: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			errorMessage: "manualIdUpload.fileTooBig"
-		} })),
-		clearManualUploadError: assign(({ context }) => ({ manualUpload: {
-			...context.manualUpload,
-			errorMessage: null
-		} }))
+		} })
 	},
 	guards: {
 		hasShowTutorial: hasShowTutorialGuard,
@@ -1544,16 +1678,9 @@ const _idCaptureMachine = setup({
 		isDeepsightEnabled: isDeepsightEnabledGuard,
 		isDeepsightReady: isDeepsightReadyGuard,
 		needsDeepsightInit: needsDeepsightInitGuard,
-		isSelectedFileTooLarge: isSelectedFileTooLargeGuard,
-		isFrontFileSelection: isFrontFileSelectionGuard,
-		isBackFileSelection: isBackFileSelectionGuard,
-		isPassportFileSelection: isPassportFileSelectionGuard,
-		manualUploadRetriesExhausted: manualUploadRetriesExhaustedGuard,
-		canContinueFromIdTab: canContinueFromIdTabGuard,
-		canContinueFromPassportTab: canContinueFromPassportTabGuard,
-		manualUploadResponseHasError: manualUploadResponseHasErrorGuard,
 		hasOnlyManualUploadAvailable: hasOnlyManualUploadAvailableGuard,
-		isManualIdUploadSelected: isManualIdUploadSelectedGuard
+		isManualIdUploadSelected: isManualIdUploadSelectedGuard,
+		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted"
 	}
 }).createMachine({
 	id: "idCapture",
@@ -1594,19 +1721,7 @@ const _idCaptureMachine = setup({
 			deepsightInitAttempted: false,
 			availableDocumentTypes: getAvailableDocumentTypes(input.config),
 			captureResolution: void 0,
-			cameraFallbackLevel: void 0,
-			manualUpload: {
-				frontFile: null,
-				backFile: null,
-				passportFile: null,
-				activeTab: "id",
-				retriesLeft: MANUAL_UPLOAD_MAX_RETRIES,
-				errorMessage: null,
-				skipBackFromServer: false,
-				frontUploaded: false,
-				backUploaded: false,
-				passportUploaded: false
-			}
+			cameraFallbackLevel: void 0
 		};
 	},
 	on: {
@@ -2057,7 +2172,7 @@ const _idCaptureMachine = setup({
 								deepsightService: context.deepsightService,
 								stream: context.stream,
 								isSecondId: context.config.isSecondId ?? false,
-								onlyFront: context.config.onlyFront,
+								onlyFront: false,
 								ageAssurance: context.config.ageAssurance,
 								dependencies: context.dependencies,
 								captureResolution: context.captureResolution,
@@ -2301,127 +2416,29 @@ const _idCaptureMachine = setup({
 			} }
 		},
 		manualIdUpload: {
-			initial: "selecting",
-			on: {
-				QUIT: { target: "closed" },
-				MANUAL_UPLOAD_TAB_CHANGED: {
-					target: ".selecting",
-					actions: ["setManualUploadActiveTab"]
-				},
-				MANUAL_UPLOAD_RESET: {
-					target: ".selecting",
-					actions: ["resetManualUpload"]
+			invoke: {
+				id: "manualIdUpload",
+				src: "manualUploadMachine",
+				input: ({ context }) => ({
+					isSecondId: context.config.isSecondId ?? false,
+					onlyFront: false
+				}),
+				onSnapshot: { actions: () => {} },
+				onDone: [{
+					guard: "isManualUploadExhausted",
+					target: "#idCapture.finished"
+				}, { target: "#idCapture.processing" }],
+				onError: {
+					target: "#idCapture.error",
+					actions: assign({ error: ({ event }) => String(event.error) })
 				}
 			},
-			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: "#idCapture.processing"
-					}, {
-						guard: "canContinueFromPassportTab",
-						target: "#idCapture.processing"
-					}]
-				} },
-				uploadingFront: { invoke: {
-					id: "uploadManualFile",
-					src: "uploadManualFile",
-					input: ({ context }) => ({
-						side: "front",
-						file: context.manualUpload.frontFile,
-						retry: context.manualUpload.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
-						onlyFront: context.config.onlyFront ?? false,
-						isSecondId: context.config.isSecondId ?? false
-					}),
-					onDone: [{
-						guard: "manualUploadResponseHasError",
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-					}, {
-						target: "selecting",
-						actions: [
-							"markFrontUploaded",
-							"recordSkipBackFromResponse",
-							"clearManualUploadError"
-						]
-					}],
-					onError: {
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-					}
-				} },
-				uploadingBack: { invoke: {
-					id: "uploadManualFile",
-					src: "uploadManualFile",
-					input: ({ context }) => ({
-						side: "back",
-						file: context.manualUpload.backFile,
-						retry: context.manualUpload.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
-						onlyFront: false,
-						isSecondId: context.config.isSecondId ?? false
-					}),
-					onDone: [{
-						guard: "manualUploadResponseHasError",
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-					}, {
-						target: "selecting",
-						actions: ["markBackUploaded", "clearManualUploadError"]
-					}],
-					onError: {
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-					}
-				} },
-				uploadingPassport: { invoke: {
-					id: "uploadManualFile",
-					src: "uploadManualFile",
-					input: ({ context }) => ({
-						side: "passport",
-						file: context.manualUpload.passportFile,
-						retry: context.manualUpload.retriesLeft < MANUAL_UPLOAD_MAX_RETRIES,
-						onlyFront: false,
-						isSecondId: context.config.isSecondId ?? false
-					}),
-					onDone: [{
-						guard: "manualUploadResponseHasError",
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadErrorFromResponse"]
-					}, {
-						target: "selecting",
-						actions: ["markPassportUploaded", "clearManualUploadError"]
-					}],
-					onError: {
-						target: "checkRetries",
-						actions: ["decrementManualUploadRetries", "setManualUploadGenericError"]
-					}
-				} },
-				checkRetries: { always: [{
-					guard: "manualUploadRetriesExhausted",
-					target: "retriesExhausted"
-				}, { target: "selecting" }] },
-				retriesExhausted: { after: { [MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS]: { target: "#idCapture.finished" } } }
+			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: { on: { QUIT: { target: "closed" } } }