@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/{idCaptureStateMachine-DZ2ZTSxu.esm.js → idCaptureStateMachine-CRwQh8jc.esm.js}

@@ -1,24 +1,28 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { r as getToken, t as api } from "./api-DsbUi7TO.esm.js";
-import { C as revokeObjectURL } from "./events-1wxZ97yf.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { t as addDeviceStats } from "./stats-BVy52wLy.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-Dj7-aJaP.esm.js";
-import { n as isDesktop } from "./platform-0Ot-bF_a.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-nY3M5UYm.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { _ as stopRecording$1, g as startRecording, h as createRecordingSession, y as StreamCanvasProcessingSession } from "./onDeviceFaceResults-DILtthks.esm.js";
-import { t as IncodeCanvas } from "./canvas-Pi10hG_l.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-ChrMTJv-.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-C-Dg6IsJ.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-DIjnTPjR.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CAqUdVkM.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BNOe4Tnu.esm.js";
-import { i as flagIdManualReview, n as preloadOpenViduProvider } from "./recordingService-CxaYkITO.esm.js";
-import { i as IdCaptureProvider, n as DEFAULT_ID_CAPTURE_MODEL_VERSION, r as DEFAULT_ID_CAPTURE_THRESHOLDS } from "./idCaptureDefaults-CZajItdO.esm.js";
-
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { s as exposeExperimentOnce } from "./feature-management-DS_Nj5Gg.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-6dTpiaTh.esm.js";
+import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-CxfNJVZW.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-CV6Rj_dn.esm.js";
+import "./trueSight-B8G85W4z.esm.js";
+import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
+import { t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
+import "./session-CX2H3tmI.esm.js";
+import { a as and, n as sendTo, r as assign, s as not, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-f81FVdQs.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 { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, g as getIdCameraStream, h as CAPTURE_RESULT_PREVIEW, 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-CFDwqTtQ.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
-const TERMINAL_FAIL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+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";
 }
@@ -48,7 +52,6 @@ function classifyNetworkError(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";
@@ -68,13 +71,8 @@ async function uploadDigitalIdFile(params) {
 		uploadDurationMs: 0
 	};
 }
-
-//#endregion
-//#region src/modules/id/digitalUpload/types.ts
-const DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 const DIGITAL_UPLOAD_HOLDING_TIMEOUT_MS = 8e3;
 const DIGITAL_UPLOAD_ALLOWED_MIME_TYPES = ["application/pdf"];
-
 //#endregion
 //#region src/modules/id/digitalUpload/digitalUploadStateMachine.ts
 const uploadDigitalIdActor = fromPromise(async ({ input, signal }) => {
@@ -89,7 +87,7 @@ const getUploadResponseFromEvent$1 = (event) => {
 	if (!("output" in event)) return;
 	return event.output;
 };
-const _digitalUploadMachine = setup({
+const digitalUploadMachine = setup({
 	types: {
 		context: {},
 		events: {},
@@ -146,7 +144,7 @@ const _digitalUploadMachine = setup({
 		decrementAttemptOnFailure: assign(({ context }) => ({ attemptsRemaining: Math.max(0, context.attemptsRemaining - 1) }))
 	},
 	guards: {
-		isSelectedFileTooLarge: ({ event }) => event.type === "FILE_PICKED" && event.file.size > DIGITAL_UPLOAD_MAX_FILE_SIZE_BYTES,
+		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,
@@ -155,7 +153,7 @@ const _digitalUploadMachine = setup({
 			return isTerminalDigitalIdFailReason(getUploadResponseFromEvent$1(event));
 		},
 		isCurrentFailReasonTerminal: ({ context }) => {
-			const terminalReasons = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
+			const terminalReasons = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 			return context.failReason !== null && terminalReasons.has(context.failReason);
 		}
 	}
@@ -308,43 +306,6 @@ const _digitalUploadMachine = setup({
 		}
 	}
 });
-const digitalUploadMachine = _digitalUploadMachine;
-
-//#endregion
-//#region src/modules/id/digitalUpload/instrumentation.ts
-const TERMINAL_REASONS = new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
-function isHoldingState(value) {
-	if (value === "holding") return true;
-	if (typeof value !== "object" || value === null) return false;
-	const uploadingState = value.uploading;
-	if (uploadingState === "holding") return true;
-	if (typeof uploadingState === "object" && uploadingState !== null) return Object.prototype.hasOwnProperty.call(uploadingState, "holding");
-	return false;
-}
-/**
-* 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";
-	if (value === "uploading" || isHoldingState(value)) return "uploadDigitalid.analyzing.default";
-	if (value === "success") return "uploadDigitalid.success.default";
-	if (value === "fileTooLarge") return "uploadDigitalid.error.filetoolarge";
-	if (value === "error") {
-		if (failReason !== null && TERMINAL_REASONS.has(failReason)) return "uploadDigitalid.error.notaccepted";
-		return "uploadDigitalid.error.default";
-	}
-	return "uploadDigitalid.review.default";
-}
-
 //#endregion
 //#region src/modules/id/manualUpload/manualUploadErrors.ts
 /**
@@ -389,7 +350,6 @@ function mapFailReasonToErrorKey(response, expectedTab) {
 	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";
@@ -444,315 +404,11 @@ const imageFileToDataUrl = async (file, options = {}) => {
 		return readFileAsDataUrl(file);
 	}
 };
-
-//#endregion
-//#region src/modules/id/idCameraStream.ts
-async function getIdCameraStream(deviceId) {
-	return getBackCameraStream(deviceId);
-}
-
 //#endregion
 //#region src/modules/id/manualUpload/types.ts
 const MANUAL_UPLOAD_MAX_RETRIES = 3;
 const MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 const MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS = 5e3;
-
-//#endregion
-//#region src/modules/id/types.ts
-const ID_ERROR_CODES = {
-	UPLOAD_ERROR: "UPLOAD_ERROR",
-	CLASSIFICATION_FAILED: "CLASSIFICATION_FAILED",
-	LOW_SHARPNESS: "LOW_SHARPNESS",
-	GLARE_DETECTED: "GLARE_DETECTED",
-	WRONG_DOCUMENT_SIDE: "WRONG_DOCUMENT_SIDE",
-	ID_TYPE_UNACCEPTABLE: "ID_TYPE_UNACCEPTABLE",
-	READABILITY_ISSUE: "READABILITY_ISSUE",
-	RETRY_EXHAUSTED_CONTINUE_TO_BACK: "RETRY_EXHAUSTED_CONTINUE_TO_BACK",
-	RETRY_EXHAUSTED_SKIP_BACK: "RETRY_EXHAUSTED_SKIP_BACK",
-	NO_MORE_TRIES: "NO_MORE_TRIES",
-	UNEXPECTED_ERROR: "UNEXPECTED_ERROR",
-	NO_TOKEN: "NO_TOKEN",
-	PERMISSION_DENIED: "PERMISSION_DENIED",
-	USER_CANCELLED: "USER_CANCELLED",
-	SERVER: "SERVER_ERROR"
-};
-
-//#endregion
-//#region src/modules/id/idCaptureServices.ts
-/**
-* Camera constraints used for PRC warmup before ID capture.
-* Uses environment-facing camera on mobile devices (for back camera ID capture)
-* and user-facing camera on desktop.
-*/
-function getPrcCameraConstraints() {
-	if (isDesktop()) return { video: {
-		facingMode: "user",
-		height: { ideal: 480 },
-		width: { ideal: 640 }
-	} };
-	return { video: {
-		facingMode: "environment",
-		height: { ideal: 720 }
-	} };
-}
-function getUploadEndpoint(type, isSecondId) {
-	if (isSecondId) return type === "front" ? endpoints.frontSecondId : endpoints.backSecondId;
-	return type === "front" ? endpoints.frontId : endpoints.backId;
-}
-const SHARPNESS_THRESHOLD = 10;
-const GLARE_THRESHOLD = 10;
-const DEFAULT_ID_CAPTURE_THRESHOLDS$1 = {
-	blurThreshold: .2,
-	blurChangeThreshold: .2,
-	glareThreshold: .3,
-	clsThreshold: .98,
-	sideThreshold: .8,
-	iouThreshold: .8,
-	framesAggregationInterval: 3e3
-};
-const DEFAULT_ID_CAPTURE_SETTINGS = {
-	isFixedMask: false,
-	isIPhone14OrHigher: false,
-	idType: "",
-	blurCheckEnabled: false,
-	glareCheckEnabled: false,
-	faceQualityCheckEnabled: true,
-	iouCheckEnabled: true,
-	fpsLimitEnabled: false
-};
-async function initializeIdCapture(params) {
-	const { config, deepsightService } = params;
-	const provider = new IdCaptureProvider();
-	await provider.initialize({});
-	provider.setThresholds({
-		...DEFAULT_ID_CAPTURE_THRESHOLDS$1,
-		...config.thresholds,
-		idDetectedTimeout: config.thresholds?.idDetectedTimeout ?? config.deviceIdleTimeout * 1e3,
-		autocaptureTimeout: config.thresholds?.autocaptureTimeout ?? config.autoCaptureTimeout * 1e3
-	});
-	if (config.settings) provider.setSettings({
-		...DEFAULT_ID_CAPTURE_SETTINGS,
-		...config.settings
-	});
-	if (deepsightService) try {
-		await deepsightService.performPrcCheck({ constraints: getPrcCameraConstraints() });
-	} catch {}
-	const { stream, fallbackLevel } = await getIdCameraStream();
-	const videoTrack = stream.getVideoTracks()[0];
-	let captureResolution;
-	if (videoTrack) {
-		const settings = videoTrack.getSettings();
-		if (typeof settings.width === "number" && typeof settings.height === "number") captureResolution = `${settings.width}x${settings.height}`;
-	}
-	if (deepsightService && videoTrack) deepsightService.metadata.updateCameraInfo(videoTrack);
-	return {
-		stream,
-		provider,
-		captureResolution,
-		cameraFallbackLevel: fallbackLevel
-	};
-}
-function stopStream(stream) {
-	for (const track of stream.getTracks()) track.stop();
-}
-function validateUploadResponse(response, sessionState) {
-	if (response.failReason === "ID_TYPE_UNACCEPTABLE") return {
-		error: true,
-		message: "ID type is not acceptable",
-		messageDescription: "Please use a valid ID type",
-		errorKey: ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE
-	};
-	if (response.failReason === "WRONG_DOCUMENT_SIDE") return {
-		error: true,
-		message: "Wrong side of document",
-		messageDescription: response.side === "back" ? "Please show the back side of your ID" : "Please show the front side of your ID",
-		errorKey: ID_ERROR_CODES.WRONG_DOCUMENT_SIDE
-	};
-	if (!response.classification) return {
-		error: true,
-		message: "ID classification failed",
-		errorKey: ID_ERROR_CODES.CLASSIFICATION_FAILED
-	};
-	const sharpnessThreshold = getDeviceClass() === "desktop" ? -1 : SHARPNESS_THRESHOLD;
-	if (response.sharpness !== void 0 && sharpnessThreshold >= 0 && response.sharpness < sharpnessThreshold) return {
-		error: true,
-		message: "Image is not sharp enough",
-		messageDescription: "Please ensure the image is clear and well-focused",
-		errorKey: ID_ERROR_CODES.LOW_SHARPNESS
-	};
-	if (response.glare !== void 0 && response.glare < GLARE_THRESHOLD && !sessionState?.skipGlareFront && !sessionState?.skipGlareBack) return {
-		error: true,
-		message: "Glare detected on ID",
-		messageDescription: "Please avoid bright reflections on your ID",
-		errorKey: ID_ERROR_CODES.GLARE_DETECTED
-	};
-}
-async function getExtraImages(params) {
-	const extraImages = params.ageAssurance ? [params.type === "back" ? "croppedBackID" : "croppedFrontID"] : [];
-	try {
-		const res = await api.post(endpoints.getImages, { images: ["croppedIDFace", ...extraImages] }, { signal: params.signal });
-		if (!res.ok) throw new Error(`Failed to get extra images: ${res.status}`);
-		return res.data ?? {
-			croppedIDFace: "",
-			croppedFrontID: "",
-			croppedBackID: ""
-		};
-	} catch {
-		return {
-			croppedIDFace: "",
-			croppedFrontID: "",
-			croppedBackID: ""
-		};
-	}
-}
-const getRealQualityValue = (value) => (1 - value) * 100;
-async function uploadIdImage(params) {
-	const { type, image, onProgress, signal, metadata, ageAssurance, glare, sharpness, shouldSkipGlareBack, analyticsProvider, imageData, isSecondId, onlyFront, extractIdFace } = params;
-	let finalMetadata = metadata;
-	if (analyticsProvider && imageData) try {
-		await analyticsProvider.analyzeFrame(imageData);
-		analyticsProvider.update();
-		finalMetadata = analyticsProvider.getMetadata();
-	} catch (error) {
-		console.warn("[IdCapture] Analytics failed:", error);
-	}
-	const endpoint = getUploadEndpoint(type, isSecondId);
-	const body = {
-		base64Image: image,
-		metadata: finalMetadata
-	};
-	const queryParams = { imageType: "id" };
-	if (onlyFront && type === "front") queryParams.onlyFront = true;
-	if (shouldSkipGlareBack && type === "back") queryParams.glare = 0;
-	else if (glare !== void 0) queryParams.glare = getRealQualityValue(glare);
-	if (sharpness !== void 0) queryParams.sharpness = getRealQualityValue(sharpness);
-	if (extractIdFace === false && type === "front") queryParams.extractIdFace = false;
-	try {
-		const res = await api.post(endpoint, body, {
-			signal,
-			query: queryParams,
-			onUploadProgress: onProgress
-		});
-		if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
-		const response = res.data;
-		const extraImages = await getExtraImages({
-			type,
-			ageAssurance,
-			signal
-		});
-		const fullResponse = {
-			...response,
-			originalImage: image,
-			frontIdImage: type === "front" ? image : void 0,
-			backIdImage: extraImages.croppedBackID,
-			...extraImages
-		};
-		onProgress?.(100);
-		return fullResponse;
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : "Unknown error";
-		throw new Error(`${ID_ERROR_CODES.UPLOAD_ERROR}: ${errorMessage}`);
-	}
-}
-function buildStandardResolution(width, height) {
-	return height > width ? {
-		width: 1080,
-		height: 1920
-	} : {
-		width: 1920,
-		height: 1080
-	};
-}
-function buildResolutionFromStream(stream) {
-	const track = stream.getVideoTracks()[0];
-	if (!track) return "1080x1920";
-	const settings = track.getSettings();
-	const width = settings.width;
-	const height = settings.height;
-	if (typeof width === "number" && typeof height === "number") {
-		const standard = buildStandardResolution(width, height);
-		return `${standard.width}x${standard.height}`;
-	}
-	return "1080x1920";
-}
-function preloadIdRecordingProvider(config) {
-	if (config.enableIdRecording !== true) return;
-	preloadOpenViduProvider();
-}
-async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-CK6A5kiU.esm.js");
-	return new OpenViduRecordingProvider();
-}
-async function startRecordingSession(params) {
-	if (params.config.enableIdRecording !== true) return;
-	if (params.existing) return params.existing;
-	const provider = params.config.recording?.capability ?? await createOpenViduRecordingProvider();
-	const clonedStream = params.stream.clone();
-	const hasAudio = clonedStream.getAudioTracks().length > 0;
-	const resolution = buildResolutionFromStream(clonedStream);
-	const session = await createRecordingSession(params.type);
-	const connection = await provider.connect({
-		sessionToken: session.token,
-		stream: clonedStream,
-		events: {}
-	});
-	await startRecording({
-		videoRecordingId: session.videoRecordingId,
-		type: params.type,
-		resolution,
-		hasAudio
-	});
-	return {
-		token: session.token,
-		sessionId: session.sessionId,
-		videoRecordingId: session.videoRecordingId,
-		connection,
-		resolution,
-		hasAudio
-	};
-}
-function stopRecording(session) {
-	(async () => {
-		try {
-			await stopRecording$1(session.videoRecordingId);
-		} finally {
-			await session.connection.disconnect();
-		}
-	})();
-}
-async function processId(isSecondId = false, queueName = "", signal) {
-	const endpoint = isSecondId ? endpoints.processSecondId : endpoints.processId;
-	const url = queueName ? `${endpoint}?queueName=${queueName}` : endpoint;
-	return { isDocumentExpired: (await api.post(url, {}, { signal })).data?.isDocumentExpired ?? false };
-}
-/**
-* Upload a user-selected image as front / back / passport ID.
-*
-* Uses the same request shape as the live-camera path (`uploadIdImage`):
-* JSON body `{ base64Image }` with default application/json Content-Type,
-* `captureType=UPLOAD` query param, `retry=true` when retrying.
-* Back is POSTed to `/omni/add/back-id/v2` (or `/omni/add/back-second-id/v2`
-* when `isSecondId`); front and passport go to `/omni/add/front-id/v2` (or
-* `/omni/add/front-second-id/v2` when `isSecondId`).
-*
-* The v2 endpoints reject raw `image/jpeg` bodies with 415, so the caller
-* must convert the File to base64 before calling this service.
-*/
-async function uploadManualIdFile(params) {
-	const { side, base64Image, retry, onlyFront, signal, isSecondId, extractIdFace } = params;
-	const endpoint = getUploadEndpoint(side === "back" ? "back" : "front", isSecondId);
-	const queryParams = { captureType: "UPLOAD" };
-	if (retry) queryParams.retry = true;
-	if (onlyFront && side === "front") queryParams.onlyFront = true;
-	if (extractIdFace === false && side !== "back") queryParams.extractIdFace = false;
-	const res = await api.post(endpoint, { base64Image }, {
-		signal,
-		query: queryParams
-	});
-	if (!res.ok) throw new Error(`POST ${endpoint} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-
 //#endregion
 //#region src/modules/id/manualUpload/manualUploadServices.ts
 const stripDataUrlPrefix = (dataUrl) => {
@@ -768,14 +424,14 @@ const getBase64PayloadByteLength = (payload) => {
 };
 const isBase64PayloadWithinSize = (payload, maxBytes) => getBase64PayloadByteLength(payload) <= maxBytes;
 const fileToBase64Payload = async (file) => {
-	return stripDataUrlPrefix(await imageFileToDataUrl(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, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES)) return { type: "fileTooLarge" };
+	if (!isBase64PayloadWithinSize(base64Image, 5242880)) return { type: "fileTooLarge" };
 	return {
 		type: "uploaded",
 		response: await uploadManualIdFile({
@@ -796,7 +452,7 @@ const getUploadResponseFromEvent = (event) => {
 	const output = getUploadOutputFromEvent(event);
 	return output?.type === "uploaded" ? output.response : void 0;
 };
-const _manualUploadMachine = setup({
+const manualUploadMachine = setup({
 	types: {
 		context: {},
 		events: {},
@@ -1102,84 +758,25 @@ const _manualUploadMachine = setup({
 		}
 	}
 });
-const manualUploadMachine = _manualUploadMachine;
-
-//#endregion
-//#region src/modules/id/manualUpload/instrumentation.ts
-/**
-* 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.
-*/
-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
+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 }) => {
-	if ("output" in event) return event.output === "granted";
-	return false;
+	return getPermissionOutput(event) === "granted";
 };
 const isReadyForCaptureGuard = ({ context, event }) => {
-	return isReadyForCaptureFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
+	return isReadyForCaptureFromPermission(resolveStoredPermissionResult(getPermissionOutput(event), context.permissionResult), context.config.ds);
 };
 const needsMotionPrimeOnlyGuard = ({ context, event }) => {
-	return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult("output" in event ? event.output : void 0, context.permissionResult), context.config.ds);
+	return needsMotionPrimeOnlyFromPermission(resolveStoredPermissionResult(getPermissionOutput(event), context.permissionResult), context.config.ds);
 };
 const isPermissionDeniedErrorGuard = ({ event }) => {
 	if ("error" in event) {
@@ -1189,6 +786,7 @@ const isPermissionDeniedErrorGuard = ({ event }) => {
 	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;
@@ -1202,15 +800,31 @@ const hasUploadValidationErrorGuard = ({ context }) => {
 };
 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.
+* 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 isOnlyFrontGuard = (_args) => false;
 const shouldContinueToBackGuard = ({ context }) => {
 	if (context.currentMode !== "front" && context.currentMode !== "passport") return false;
 	if (context.config.onlyBack) return false;
@@ -1220,6 +834,17 @@ const shouldContinueToBackGuard = ({ context }) => {
 };
 const shouldContinueToFrontGuard = ({ context }) => context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
 const hasMandatoryConsentGuard = ({ context }) => context.uploadResponse?.showMandatoryConsent === true;
+/**
+* Capture-result-preview feedback mode, resolved once per session by
+* `resolveCaptureResultPreviewTreatment` at actor creation.
+*/
+const isCaptureResultPreviewModeGuard = ({ context }) => context.captureFeedbackMode === "result-preview";
+/**
+* Whether the rendering layer opted into handling `resultPreview` and
+* advancing it with `manager.nextStep()`. Headless consumers that omit this
+* capability retain the direct capture-to-upload path.
+*/
+const supportsCaptureResultPreviewGuard = ({ context }) => context.config.supportsCaptureResultPreview === 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;
@@ -1230,30 +855,6 @@ const isManualIdUploadSelectedGuard = ({ event }) => event.type === "SELECT_DOCU
 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`:
@@ -1261,7 +862,7 @@ const MAX_EXPIRED_FIRST_SIDE_ATTEMPTS = 3;
 * - 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 isExpiredAttemptsExhaustedGuard = ({ context }) => context.expiredAttempts + 1 >= 3;
 const isNotPassportModeGuard = ({ context }) => context.currentMode !== "passport";
 /**
 * V1 parity for `shouldApplyAlwaysCaptureBackOverride` — force-redirects to
@@ -1276,6 +877,22 @@ const shouldForceBackOnExpiredGuard = ({ context }) => context.currentMode === "
 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
@@ -1316,7 +933,6 @@ const isBackModeInMultiSideFlowGuard = ({ context }) => context.currentMode ===
 * max-attempts/OCR cap (ENG-46592 / re-respects ENG-45666).
 */
 const wasExpiredRedirectedGuard = ({ context }) => context.expiredRedirected === true;
-
 //#endregion
 //#region src/modules/id/idCaptureHelpers.ts
 /**
@@ -1357,14 +973,55 @@ function getManualUploadTabs(config) {
 		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 invokeRequestPermissionActor(input);
+	return requestIdCapturePermission(input);
 });
 const initializeCameraActor = fromPromise(async ({ input }) => {
 	return initializeIdCapture(input);
@@ -1407,6 +1064,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		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
@@ -1457,14 +1115,8 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		iouCheckEnabled: input.config.settings?.iouCheckEnabled ?? true,
 		fpsLimitEnabled: input.config.settings?.fpsLimitEnabled ?? false
 	});
-	const thresholds = {
-		...DEFAULT_ID_CAPTURE_THRESHOLDS,
-		...input.config.thresholds,
-		idDetectedTimeout: (input.config.deviceIdleTimeout ?? 10) * 1e3,
-		autocaptureTimeout: (input.config.autoCaptureTimeout ?? 5) * 1e3
-	};
-	provider.setThresholds(thresholds);
-	const modelType = input.config.modelVersion ?? DEFAULT_ID_CAPTURE_MODEL_VERSION;
+	provider.setThresholds(resolveIdCaptureThresholds(input.config));
+	const modelType = input.config.modelVersion ?? "v2";
 	provider.setModelType(modelType);
 	provider.setCallbacks({
 		onFarAway: () => {
@@ -1484,10 +1136,13 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 			if (!isCapturing) sendNotification("glare");
 		},
 		onIdNotDetected: () => {
-			if (!isCapturing) sendBack({
-				type: "DETECTION_UPDATE",
-				status: "idNotDetected"
-			});
+			if (!isCapturing) {
+				trueSightHintTransition("module.id-capture", "idScan", "idNotDetected");
+				sendBack({
+					type: "DETECTION_UPDATE",
+					status: "idNotDetected"
+				});
+			}
 		},
 		onSwitchToManualCapture: () => {
 			isCapturing = false;
@@ -1497,6 +1152,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 			clearNotificationTimeout();
 			lastReportedSide = null;
 			isCapturing = true;
+			trueSightHintTransition("module.id-capture", "idScan", "capturing");
 			sendBack({
 				type: "DETECTION_UPDATE",
 				status: "capturing"
@@ -1528,10 +1184,10 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 				qualityElements: {}
 			});
 		},
-		onIdTypeChange: (idType$1) => {
+		onIdTypeChange: (idType) => {
 			sendBack({
 				type: "ID_TYPE_CHANGE",
-				idType: idType$1
+				idType
 			});
 		},
 		onIdSideChange: (side) => {
@@ -1548,8 +1204,18 @@ const runDetectionActor = fromCallback(({ input, 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"
@@ -1559,10 +1225,6 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		provider: {
 			processFrame: async (frame) => {
 				currentCanvas = IncodeCanvas.fromImageData(frame);
-				sendBack({
-					type: "DETECTION_FRAME",
-					frame
-				});
 				await provider.processFrame(frame);
 			},
 			reset: () => {
@@ -1576,14 +1238,11 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 				storedQualityElements = {};
 				isCapturing = false;
 				lastReportedSide = null;
-				provider.reset();
+				provider.resetDetectionState();
 			}
-		},
-		onFrame: (frame) => sendBack({
-			type: "DETECTION_FRAME",
-			frame
-		})
+		}
 	});
+	noteTrueSightCaptureActivity(true);
 	sendBack({
 		type: "DETECTION_RESET_READY",
 		reset: () => {
@@ -1593,8 +1252,16 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 	return () => {
 		clearNotificationTimeout();
 		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);
@@ -1603,8 +1270,8 @@ const uploadIdImageActor = fromPromise(async ({ input, signal }) => {
 		const sessionToken = getToken();
 		const frameSource = input.type === "back" ? "BACK_ID" : "FRONT_ID";
 		await input.deepsightService.performVirtualCameraCheck(sessionToken, frameSource);
-		const imageData$1 = input.canvas.getImageData();
-		if (imageData$1) await input.deepsightService.analyzeFrame(imageData$1);
+		const 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({
@@ -1620,7 +1287,9 @@ const uploadIdImageActor = fromPromise(async ({ input, signal }) => {
 			motionStatus
 		});
 		metadata = input.deepsightService.getMetadata();
-	} catch {}
+	} 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?.({
@@ -1648,6 +1317,15 @@ const uploadIdImageActor = fromPromise(async ({ input, signal }) => {
 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";
@@ -1660,7 +1338,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CU_tiLMx.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DcWjMC6A.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -1673,7 +1351,6 @@ const checkVirtualCameraActor = fromPromise(async ({ input }) => {
 	if (!videoTrack) return false;
 	return input.deepsightService.checkVirtualCamera(videoTrack);
 });
-
 //#endregion
 //#region src/modules/id/idCaptureActions.ts
 function performStopMediaStream(context) {
@@ -1699,15 +1376,27 @@ function performResetForFrontCapture(context) {
 function performResetDetection(context) {
 	context.resetDetection?.();
 }
-function performTrackTutorialId() {}
-function performTrackContinue() {}
-function performTrackCameraId(context) {}
+function performReportCaptureResultPreviewAssignment(context) {
+	if (context.config.supportsCaptureResultPreview !== true) return;
+	const assignment = exposeExperimentOnce(CAPTURE_RESULT_PREVIEW);
+	if (!assignment) return;
+	recordExperimentAssignmentOnce(eventModuleNames.idCapture, 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;
 }
@@ -1737,6 +1426,9 @@ function getResetContextValues(context) {
 		capturedImages: {},
 		captureOnlyImages: {},
 		uploadResponse: void 0,
+		decodedBarcode: null,
+		barcodeFastPathAttempted: false,
+		barcodeFastPathCaptured: false,
 		recordingSession: void 0,
 		attemptsRemaining: context.config.captureAttempts,
 		expiredAttempts: 0,
@@ -1916,7 +1608,39 @@ function getCurrentModeFromEvent(context, event) {
 	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
 /**
@@ -1930,11 +1654,12 @@ function getIdErrorCodeFromUnknown(error) {
 		return Object.values(ID_ERROR_CODES).find((value) => message.includes(value));
 	}
 }
-const _idCaptureMachine = setup({
+const idCaptureMachine = setup({
 	types: {
 		context: {},
 		events: {},
-		input: {}
+		input: {},
+		output: {}
 	},
 	actors: {
 		checkPermission: checkPermissionActor,
@@ -1942,7 +1667,9 @@ const _idCaptureMachine = setup({
 		initializeCamera: initializeCameraActor,
 		runDetection: runDetectionActor,
 		uploadIdImage: uploadIdImageActor,
+		uploadProgressTicker: uploadProgressTickerActor,
 		processId: processIdActor,
+		submitBarcode: submitBarcodeActor,
 		startRecording: startRecordingActor,
 		initializeDeepsightSession: initializeDeepsightSessionActor,
 		checkVirtualCamera: checkVirtualCameraActor,
@@ -1977,9 +1704,13 @@ const _idCaptureMachine = setup({
 				resetDetection: void 0,
 				idType: void 0,
 				qualityElements: void 0,
-				debugFrame: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
+				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,
@@ -2002,9 +1733,13 @@ const _idCaptureMachine = setup({
 				resetDetection: void 0,
 				idType: void 0,
 				qualityElements: void 0,
-				debugFrame: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
+				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,
@@ -2016,6 +1751,7 @@ const _idCaptureMachine = setup({
 				cameraFallbackLevel: void 0
 			};
 		}),
+		clearFlipPreview: assign({ flipPreview: void 0 }),
 		prepareForBackCapture: assign(({ context }) => {
 			context.provider?.reset();
 			return {
@@ -2025,7 +1761,6 @@ const _idCaptureMachine = setup({
 				resetDetection: void 0,
 				idType: void 0,
 				qualityElements: void 0,
-				debugFrame: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
 				uploadProgress: void 0,
@@ -2040,14 +1775,16 @@ const _idCaptureMachine = setup({
 			captureResolution: ({ event }) => getCaptureResolutionFromEvent(event),
 			cameraFallbackLevel: ({ event }) => getCameraFallbackLevelFromEvent(event)
 		}),
-		trackTutorialId: () => {
-			/* @__PURE__ */ performTrackTutorialId();
-		},
-		trackContinue: () => {
-			/* @__PURE__ */ performTrackContinue();
-		},
-		trackCameraId: ({ context }) => {
-			/* @__PURE__ */ performTrackCameraId(context);
+		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 }) => {},
+		reportCaptureResultPreviewAssignment: ({ context }) => {
+			performReportCaptureResultPreviewAssignment(context);
 		},
 		preloadRecordingProvider: ({ context }) => {
 			preloadIdRecordingProvider(context.config);
@@ -2088,6 +1825,14 @@ const _idCaptureMachine = setup({
 		} }),
 		setCurrentMode: assign({ currentMode: ({ event, context }) => getCurrentModeFromEvent(context, event) }),
 		storeCapturedImage: assign(({ context, event }) => getStoreCapturedImageValues(context, event)),
+		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;
@@ -2106,6 +1851,18 @@ const _idCaptureMachine = setup({
 			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 };
@@ -2132,14 +1889,16 @@ const _idCaptureMachine = setup({
 		needsMotionPrimeOnly: needsMotionPrimeOnlyGuard,
 		isPermissionDeniedError: isPermissionDeniedErrorGuard,
 		hasStream: hasStreamGuard,
+		hasInitializedCamera: hasInitializedCameraGuard,
 		hasAttemptsRemaining: hasAttemptsRemainingGuard,
 		hasCapturedImage: hasCapturedImageGuard,
 		hasUploadValidationError: hasUploadValidationErrorGuard,
 		isFrontMode: isFrontModeGuard,
-		isOnlyFront: isOnlyFrontGuard,
 		shouldContinueToBack: shouldContinueToBackGuard,
 		shouldContinueToFront: shouldContinueToFrontGuard,
 		hasMandatoryConsent: hasMandatoryConsentGuard,
+		isCaptureResultPreviewMode: isCaptureResultPreviewModeGuard,
+		supportsCaptureResultPreview: supportsCaptureResultPreviewGuard,
 		isDeepsightEnabled: isDeepsightEnabledGuard,
 		isDeepsightReady: isDeepsightReadyGuard,
 		needsDeepsightInit: needsDeepsightInitGuard,
@@ -2153,6 +1912,8 @@ const _idCaptureMachine = setup({
 		shouldForceBackOnExpired: shouldForceBackOnExpiredGuard,
 		wasExpiredFromUpload: wasExpiredFromUploadGuard,
 		shouldSkipProcessId: shouldSkipProcessIdGuard,
+		shouldSubmitBarcode: shouldSubmitBarcodeGuard,
+		canRunBarcodeFastPath: canRunBarcodeFastPathGuard,
 		isProcessingExpiredExhausted: isProcessingExpiredExhaustedGuard,
 		shouldProcessAfterExhaustion: shouldProcessAfterExhaustionGuard,
 		forceFinishAfterProcessing: forceFinishAfterProcessingGuard,
@@ -2165,10 +1926,12 @@ const _idCaptureMachine = setup({
 }).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",
 			currentMode,
 			selectedDocumentType: void 0,
 			stream: void 0,
@@ -2181,6 +1944,9 @@ const _idCaptureMachine = setup({
 			capturedImages: {},
 			captureOnlyImages: {},
 			uploadResponse: void 0,
+			decodedBarcode: null,
+			barcodeFastPathAttempted: false,
+			barcodeFastPathCaptured: false,
 			recordingSession: void 0,
 			attemptsRemaining: input.config.captureAttempts,
 			expiredAttempts: 0,
@@ -2196,7 +1962,6 @@ const _idCaptureMachine = setup({
 			resetDetection: void 0,
 			idType: void 0,
 			qualityElements: void 0,
-			debugFrame: void 0,
 			frameRect: void 0,
 			detectionArea: void 0,
 			previewImageUrl: void 0,
@@ -2500,16 +2265,16 @@ const _idCaptureMachine = setup({
 						{
 							target: "#idCapture.capture",
 							guard: "isReadyForCapture",
-							actions: assign({ permissionResult: ({ event }) => event.output })
+							actions: "setPermissionResultAndStream"
 						},
 						{
 							target: "denied",
-							guard: ({ event }) => event.output === "denied",
-							actions: assign({ permissionResult: ({ event }) => event.output })
+							guard: ({ event }) => getPermissionResultFromEvent(event) === "denied",
+							actions: "setPermissionResultAndStream"
 						},
 						{
 							target: "waitingForUser",
-							actions: assign({ permissionResult: ({ event }) => event.output })
+							actions: "setPermissionResultAndStream"
 						}
 					],
 					onError: { target: "denied" }
@@ -2530,7 +2295,7 @@ const _idCaptureMachine = setup({
 					},
 					{
 						target: "detecting",
-						guard: "hasStream"
+						guard: "hasInitializedCamera"
 					},
 					{ target: "initializing" }
 				] },
@@ -2559,7 +2324,9 @@ const _idCaptureMachine = setup({
 					src: "initializeCamera",
 					input: ({ context }) => ({
 						config: context.config,
-						deepsightService: context.deepsightService
+						deepsightService: context.deepsightService,
+						stream: context.stream,
+						cameraFallbackLevel: context.cameraFallbackLevel
 					}),
 					onDone: {
 						target: "detecting",
@@ -2580,7 +2347,7 @@ const _idCaptureMachine = setup({
 						guard: ({ context }) => context.manualCaptureTriggered,
 						actions: assign({ detectionStatus: () => "manualCapture" })
 					}],
-					entry: [assign({ detectionStatus: () => "detecting" })],
+					entry: [assign({ detectionStatus: () => "detecting" }), "reportCaptureResultPreviewAssignment"],
 					invoke: [{
 						id: "startRecording",
 						src: "startRecording",
@@ -2607,12 +2374,16 @@ const _idCaptureMachine = setup({
 					}],
 					on: {
 						DETECTION_UPDATE: { actions: "setDetectionStatus" },
-						DETECTION_FRAME: { actions: assign({ debugFrame: ({ event }) => event.frame }) },
 						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
 						DETECTION_SUCCESS: {
 							target: "capturing",
 							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
 						},
+						BARCODE_DECODED: [{
+							target: "capturingBarcode",
+							guard: "canRunBarcodeFastPath",
+							actions: ["storeDecodedBarcode", "setBarcodeFastPathAttempted"]
+						}, { actions: "storeDecodedBarcode" }],
 						MANUAL_CAPTURE: { target: "capturingManual" },
 						SWITCH_TO_MANUAL_CAPTURE: {
 							target: "manualCaptureWaiting",
@@ -2634,45 +2405,113 @@ const _idCaptureMachine = setup({
 						"storeCapturedCanvasInProvider",
 						"storeCapturedImage"
 					],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
+					always: [
+						{
+							target: "submittingBarcode",
+							guard: and(["hasCapturedImage", "shouldSubmitBarcode"])
+						},
+						{
+							target: "resultPreview",
+							guard: and([
+								"hasCapturedImage",
+								"isCaptureResultPreviewMode",
+								"supportsCaptureResultPreview"
+							])
+						},
+						{
+							target: "uploading",
+							guard: "hasCapturedImage"
+						},
+						{
+							target: "uploadError",
+							actions: assign(({ context }) => ({
+								uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
+								attemptsRemaining: context.attemptsRemaining - 1
+							}))
+						}
+					]
+				},
+				resultPreview: { on: { RESULT_PREVIEW_COMPLETE: { target: "uploading" } } },
+				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: "detecting" }
+				} },
 				capturingManual: {
 					entry: [
 						"captureLatestFrame",
 						"storeCapturedCanvasInProvider",
 						"storeCapturedImage"
 					],
-					always: [{
-						target: "uploading",
-						guard: "hasCapturedImage"
-					}, {
-						target: "uploadError",
-						actions: assign(({ context }) => ({
-							uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
-							attemptsRemaining: context.attemptsRemaining - 1
-						}))
-					}]
+					always: [
+						{
+							target: "resultPreview",
+							guard: and([
+								"hasCapturedImage",
+								"isCaptureResultPreviewMode",
+								"supportsCaptureResultPreview"
+							])
+						},
+						{
+							target: "uploading",
+							guard: "hasCapturedImage"
+						},
+						{
+							target: "uploadError",
+							actions: assign(({ context }) => ({
+								uploadError: ID_ERROR_CODES.UPLOAD_ERROR,
+								attemptsRemaining: context.attemptsRemaining - 1
+							}))
+						}
+					]
 				},
 				uploading: {
 					entry: assign({ uploadProgress: () => 0 }),
-					invoke: {
+					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: context.currentMode === "back" ? "back" : "front",
+								type,
 								qualityElements: context.qualityElements,
 								onProgress: (progress) => {
 									self.send({
@@ -2683,7 +2522,7 @@ const _idCaptureMachine = setup({
 								deepsightService: context.deepsightService,
 								stream: context.stream,
 								isSecondId: context.config.isSecondId ?? false,
-								onlyFront: false,
+								onlyFront: type === "front" && (context.config.onlyFront ?? false),
 								ageAssurance: context.config.ageAssurance,
 								dependencies: context.dependencies,
 								captureResolution: context.captureResolution,
@@ -2693,10 +2532,11 @@ const _idCaptureMachine = setup({
 							};
 						},
 						onDone: {
-							target: "validatingUpload",
+							target: "uploadCompleted",
 							actions: [assign({
 								uploadResponse: ({ event }) => event.output,
-								uploadProgress: () => 100
+								uploadProgress: () => 100,
+								skipProcessId: ({ context, event }) => event.output.idValidationCompleted === true || context.skipProcessId
 							}), "storeCapturedImage"]
 						},
 						onError: {
@@ -2706,9 +2546,13 @@ const _idCaptureMachine = setup({
 								attemptsRemaining: context.attemptsRemaining - 1
 							}))
 						}
-					},
-					on: { UPLOAD_PROGRESS: { actions: assign({ uploadProgress: ({ event }) => event.progress }) } }
+					}],
+					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",
@@ -2769,21 +2613,24 @@ const _idCaptureMachine = setup({
 						actions: ["flagIdManualReview"]
 					}
 				] } },
-				success: { on: { NEXT_STEP: [
-					{
-						target: "#idCapture.mandatoryConsent",
-						guard: "hasMandatoryConsent"
-					},
-					{
-						target: "#idCapture.frontFinished",
-						guard: "shouldContinueToBack"
-					},
-					{
-						target: "#idCapture.backFinished",
-						guard: "shouldContinueToFront"
-					},
-					{ target: "#idCapture.processing" }
-				] } }
+				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: {
@@ -2845,8 +2692,12 @@ const _idCaptureMachine = setup({
 			},
 			onDone: [{
 				target: "#idCapture.capture.detecting",
-				guard: "hasStream"
-			}, { target: "#idCapture.capture" }]
+				guard: "hasStream",
+				actions: "clearFlipPreview"
+			}, {
+				target: "#idCapture.capture",
+				actions: "clearFlipPreview"
+			}]
 		},
 		backFinished: {
 			entry: ["stopMediaRecording", "resetForFrontCapture"],
@@ -2893,8 +2744,12 @@ const _idCaptureMachine = setup({
 			},
 			onDone: [{
 				target: "#idCapture.capture.detecting",
-				guard: "hasStream"
-			}, { target: "#idCapture.capture" }]
+				guard: "hasStream",
+				actions: "clearFlipPreview"
+			}, {
+				target: "#idCapture.capture",
+				actions: "clearFlipPreview"
+			}]
 		},
 		processing: {
 			entry: "stopMediaStream",
@@ -3023,7 +2878,7 @@ const _idCaptureMachine = setup({
 				src: "manualUploadMachine",
 				input: ({ context }) => ({
 					isSecondId: context.config.isSecondId ?? false,
-					onlyFront: false,
+					onlyFront: context.config.onlyFront ?? false,
 					captureAttempts: context.config.captureAttempts,
 					extractIdFace: context.config.extractIdFace
 				}),
@@ -3092,7 +2947,5 @@ const _idCaptureMachine = setup({
 		}
 	}
 });
-const idCaptureMachine = _idCaptureMachine;
-
 //#endregion
-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 };
+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 };