@incodetech/core 2.3.2 → 2.4.0-rc.1

package/dist/{faceCaptureSetup-DU1mjRr6.esm.js → faceCaptureSetup-CYbdKNlI.esm.js}

@@ -1,21 +1,19 @@
-import { l as trueSightLog, m as isTrueSightTesting } from "./trueSightService-M5VpCo96.esm.js";
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import "./sessionInitializer-CnhAkMUN.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
-import { t as isAndroid } from "./platform-DkcRc9JV.esm.js";
-import { i as assign, n as enqueueActions, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-EY3_Vx6c.esm.js";
-import { a as sendLabelInspectionEvent, i as initializeDeepsightSession, r as initializeCamera, s as stopStream, t as FaceDetectionProvider } from "./FaceDetectionProvider-DtmtCKa9.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { a as flagFaceManualReview, i as imageFileToDataUrl, n as runProtectedAttempt, r as cameraCycleProvider, s as PROTECTED_CAPTURE_TARGET, t as createCameraCycleOwnership } from "./createCameraCycleOwnership-DnwTl1ad.esm.js";
+import { r as getToken, t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { l as trueSightHintTransition, r as noteTrueSightCaptureActivity, u as trueSightLog, y as isTrueSightTesting } from "./trueSightService-BzLdXpmJ.esm.js";
+import "./sessionInitializer-DVWMJh25.esm.js";
+import { t as addDeviceStats } from "./stats-BEvexnKC.esm.js";
+import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
+import { i as assign, n as enqueueActions, r as sendTo, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-Ca-tSNhT.esm.js";
+import { a as sendLabelInspectionEvent, d as FACE_ERROR_CODES, i as initializeDeepsightSession, r as initializeCamera, s as stopStream, t as FaceDetectionProvider, u as getFaceUploadErrorCode } from "./FaceDetectionProvider-BIImDZrc.esm.js";
+import { i as flagFaceManualReview, n as runProtectedAttempt, o as PROTECTED_CAPTURE_TARGET, r as cameraCycleProvider, t as createCameraCycleOwnership } from "./createCameraCycleOwnership-Dj_LHUvN.esm.js";
 import { n as releaseFaceAvatarWarmup, r as warmFaceAvatar, t as createFaceAvatar } from "./createFaceAvatar-BNHdeFj8.esm.js";
 import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-D6TfVop2.esm.js";
-import { a as getAdaptiveMediaRecorderOptions, i as createRecordingCompositor, n as WorkerEncoderRecordingProvider, t as MultipartRecordingService } from "./multipartRecordingService-mwKFTlhR.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-gcy3U0SL.esm.js";
+import { a as getAdaptiveMediaRecorderOptions, i as createRecordingCompositor, n as WorkerEncoderRecordingProvider, t as MultipartRecordingService } from "./multipartRecordingService-CLwrF5wD.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-bsWdEDxP.esm.js";
 //#region src/internal/avatar/concealment.ts
 /**
 * Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
@@ -46,234 +44,6 @@ function concealmentToAvatar(option) {
 	}
 }
 //#endregion
-//#region src/internal/faceCapture/manualUpload/errors.ts
-/**
-* Reuses the `notifications.*` copy that `errorModal.tsx` shows for the same
-* codes on the camera path, plus the ID manual-upload keys. Only the `title`
-* half of each notification pair is used — the inline error is one line.
-*/
-const MANUAL_FACE_UPLOAD_ERROR_KEYS = {
-	/** The one new string; ID accepts any image type so there was none to reuse. */
-	typeError: "selfiev2.manualUpload.typeError",
-	fileTooBig: "manualIdUpload.fileTooBig",
-	generic: "manualIdUpload.generic",
-	faceNotFound: "notifications.faceNotFound",
-	multipleFaces: "notifications.multiple",
-	lowQualityImage: "notifications.lowQualityImage",
-	brightness: "notifications.brightness",
-	lenses: "notifications.lenses",
-	mask: "notifications.mask",
-	removeHeadwear: "notifications.removeHeadwear",
-	closedEyes: "notifications.closedEyes",
-	spoof: "notifications.spoof",
-	accessDenied: "notifications.accessDenied",
-	nonexistentCustomer: "notifications.nonexistentCustomer",
-	hintNotProvided: "notifications.hintNotProvided",
-	selfieImageLowQuality: "notifications.selfieImageLowQuality"
-};
-/** Mirrors `errorContent` in `errorModal.tsx`; omissions resolve to `generic`. */
-const ERROR_KEY_BY_FACE_ERROR_CODE = {
-	[FACE_ERROR_CODES.FACE_NOT_FOUND]: MANUAL_FACE_UPLOAD_ERROR_KEYS.faceNotFound,
-	[FACE_ERROR_CODES.MULTIPLE_FACES]: MANUAL_FACE_UPLOAD_ERROR_KEYS.multipleFaces,
-	[FACE_ERROR_CODES.BAD_PHOTO_QUALITY]: MANUAL_FACE_UPLOAD_ERROR_KEYS.lowQualityImage,
-	[FACE_ERROR_CODES.SELFIE_IMAGE_LOW_QUALITY]: MANUAL_FACE_UPLOAD_ERROR_KEYS.selfieImageLowQuality,
-	[FACE_ERROR_CODES.BRIGHTNESS]: MANUAL_FACE_UPLOAD_ERROR_KEYS.brightness,
-	[FACE_ERROR_CODES.FACE_TOO_DARK]: MANUAL_FACE_UPLOAD_ERROR_KEYS.brightness,
-	[FACE_ERROR_CODES.LENSES]: MANUAL_FACE_UPLOAD_ERROR_KEYS.lenses,
-	[FACE_ERROR_CODES.LENSES_DETECTED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.lenses,
-	[FACE_ERROR_CODES.MASK]: MANUAL_FACE_UPLOAD_ERROR_KEYS.mask,
-	[FACE_ERROR_CODES.FACE_MASK_DETECTED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.mask,
-	[FACE_ERROR_CODES.HEAD_COVER]: MANUAL_FACE_UPLOAD_ERROR_KEYS.removeHeadwear,
-	[FACE_ERROR_CODES.HEAD_COVER_DETECTED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.removeHeadwear,
-	[FACE_ERROR_CODES.CLOSED_EYES]: MANUAL_FACE_UPLOAD_ERROR_KEYS.closedEyes,
-	[FACE_ERROR_CODES.CLOSED_EYES_DETECTED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.closedEyes,
-	[FACE_ERROR_CODES.LIVENESS]: MANUAL_FACE_UPLOAD_ERROR_KEYS.spoof,
-	[FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.spoof,
-	[FACE_ERROR_CODES.FACE_TOO_BLURRY]: MANUAL_FACE_UPLOAD_ERROR_KEYS.spoof,
-	[FACE_ERROR_CODES.USER_IS_NOT_RECOGNIZED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.accessDenied,
-	[FACE_ERROR_CODES.NONEXISTENT_CUSTOMER]: MANUAL_FACE_UPLOAD_ERROR_KEYS.nonexistentCustomer,
-	[FACE_ERROR_CODES.HINT_NOT_PROVIDED]: MANUAL_FACE_UPLOAD_ERROR_KEYS.hintNotProvided
-};
-function mapFaceErrorCodeToErrorKey(code) {
-	if (!code) return MANUAL_FACE_UPLOAD_ERROR_KEYS.generic;
-	return ERROR_KEY_BY_FACE_ERROR_CODE[code] ?? MANUAL_FACE_UPLOAD_ERROR_KEYS.generic;
-}
-/** Enforced in core because the picker's `accept` filter is bypassable. */
-const MANUAL_FACE_UPLOAD_ACCEPTED_MIME_TYPES = ["image/png", "image/jpeg"];
-//#endregion
-//#region src/internal/faceCapture/manualUpload/prepareFile.ts
-const isAcceptedMimeType = (type) => MANUAL_FACE_UPLOAD_ACCEPTED_MIME_TYPES.includes(type);
-const stripDataUrlPrefix = (dataUrl) => {
-	const commaIndex = dataUrl.indexOf(",");
-	return commaIndex === -1 ? dataUrl : dataUrl.slice(commaIndex + 1);
-};
-/** Duplicated from the ID manual upload; consolidate if a third caller appears. */
-const getBase64PayloadByteLength = (payload) => {
-	const normalized = payload.replace(/\s/g, "");
-	let padding = 0;
-	if (normalized.endsWith("==")) padding = 2;
-	else if (normalized.endsWith("=")) padding = 1;
-	return Math.max(0, Math.floor(normalized.length * 3 / 4) - padding);
-};
-/**
-* Every client-side check, run before any network call so a rejection here
-* never costs the user a retry.
-*/
-async function prepareManualFaceUpload(file) {
-	if (!isAcceptedMimeType(file.type)) return {
-		ok: false,
-		errorKey: MANUAL_FACE_UPLOAD_ERROR_KEYS.typeError
-	};
-	if (file.size > 5242880) return {
-		ok: false,
-		errorKey: MANUAL_FACE_UPLOAD_ERROR_KEYS.fileTooBig
-	};
-	const base64Image = stripDataUrlPrefix(await imageFileToDataUrl(file));
-	if (getBase64PayloadByteLength(base64Image) > 5242880) return {
-		ok: false,
-		errorKey: MANUAL_FACE_UPLOAD_ERROR_KEYS.fileTooBig
-	};
-	return {
-		ok: true,
-		base64Image
-	};
-}
-//#endregion
-//#region src/internal/faceCapture/manualUpload/manualFaceUploadStateMachine.ts
-const prepareFileActor = fromPromise(async ({ input }) => prepareManualFaceUpload(input.file));
-const getPreparedFromEvent = (event) => "output" in event ? event.output : void 0;
-const getErrorMessageFromEvent = (event) => {
-	const { error } = event;
-	if (error instanceof Error) return error.message;
-	return typeof error === "string" ? error : "";
-};
-const manualFaceUploadMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {},
-		output: {}
-	},
-	actors: {
-		prepareFile: prepareFileActor,
-		uploadFile: fromPromise(async () => {
-			throw new Error("uploadFile must be provided by variant");
-		})
-	},
-	actions: {
-		storeSelectedFile: assign(({ event }) => {
-			if (event.type !== "MANUAL_UPLOAD_FILE_SELECTED") return {};
-			return {
-				file: event.file,
-				errorKey: null,
-				uploaded: false
-			};
-		}),
-		storePreparedImage: assign(({ event }) => {
-			const prepared = getPreparedFromEvent(event);
-			return prepared?.ok ? { base64Image: prepared.base64Image } : {};
-		}),
-		setErrorFromPrepare: assign(({ event }) => {
-			const prepared = getPreparedFromEvent(event);
-			return { errorKey: prepared && !prepared.ok ? prepared.errorKey : MANUAL_FACE_UPLOAD_ERROR_KEYS.generic };
-		}),
-		setGenericError: assign(() => ({ errorKey: MANUAL_FACE_UPLOAD_ERROR_KEYS.generic })),
-		setErrorFromUploadFailure: assign(({ event }) => ({ errorKey: mapFaceErrorCodeToErrorKey(getErrorMessageFromEvent(event)) })),
-		markUploaded: assign(() => ({
-			uploaded: true,
-			errorKey: null
-		})),
-		decrementRetries: assign(({ context }) => ({ retriesLeft: Math.max(0, context.retriesLeft - 1) })),
-		reset: assign(({ context }) => ({
-			file: null,
-			base64Image: null,
-			uploaded: false,
-			errorKey: null,
-			retriesLeft: context.captureAttempts
-		})),
-		markSucceeded: assign(() => ({ outcome: "success" })),
-		markExhausted: assign(() => ({ outcome: "exhausted" }))
-	},
-	guards: {
-		isPrepareRejected: ({ event }) => getPreparedFromEvent(event)?.ok === false,
-		retriesExhausted: ({ context }) => context.retriesLeft <= 0,
-		canContinue: ({ context }) => context.uploaded
-	}
-}).createMachine({
-	id: "manualFaceUpload",
-	initial: "selecting",
-	context: ({ input }) => ({
-		config: input.config,
-		dependencies: input.dependencies,
-		captureAttempts: input.captureAttempts,
-		retriesLeft: input.captureAttempts,
-		file: null,
-		base64Image: null,
-		uploaded: false,
-		errorKey: null,
-		outcome: null
-	}),
-	output: ({ context }) => ({ result: context.outcome === "success" ? "success" : "exhausted" }),
-	on: { MANUAL_UPLOAD_RESET: {
-		target: ".selecting",
-		actions: ["reset"]
-	} },
-	states: {
-		selecting: { on: {
-			MANUAL_UPLOAD_FILE_SELECTED: {
-				target: "preparing",
-				actions: ["storeSelectedFile"]
-			},
-			MANUAL_UPLOAD_CONTINUE: {
-				guard: "canContinue",
-				target: "finished",
-				actions: ["markSucceeded"]
-			}
-		} },
-		preparing: { invoke: {
-			id: "prepareFile",
-			src: "prepareFile",
-			input: ({ context }) => ({ file: context.file }),
-			onDone: [{
-				guard: "isPrepareRejected",
-				target: "selecting",
-				actions: ["setErrorFromPrepare"]
-			}, {
-				target: "uploading",
-				actions: ["storePreparedImage"]
-			}],
-			onError: {
-				target: "selecting",
-				actions: ["setGenericError"]
-			}
-		} },
-		uploading: { invoke: {
-			id: "uploadFile",
-			src: "uploadFile",
-			input: ({ context }) => ({
-				base64Image: context.base64Image,
-				config: context.config,
-				dependencies: context.dependencies
-			}),
-			onDone: {
-				target: "selecting",
-				actions: ["markUploaded"]
-			},
-			onError: {
-				target: "checkRetries",
-				actions: ["decrementRetries", "setErrorFromUploadFailure"]
-			}
-		} },
-		checkRetries: { always: [{
-			guard: "retriesExhausted",
-			target: "exhausted",
-			actions: ["markExhausted"]
-		}, { target: "selecting" }] },
-		exhausted: { type: "final" },
-		finished: { type: "final" }
-	}
-});
-//#endregion
 //#region ../infra/src/providers/wasm/createProtectedFaceCaptureCapabilities.ts
 /**
 * Infrastructure composition boundary for one protected still-face attempt.
@@ -300,111 +70,40 @@ function logFaceCameraDiagnostic(event, fields) {
 }
 //#endregion
 //#region ../infra/src/media/VideoTrimmer.ts
-async function getDurationBySeek(videoBlob) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.src = URL.createObjectURL(videoBlob);
-	try {
-		if (!Number.isFinite(video.duration)) {
-			video.currentTime = Number.MAX_SAFE_INTEGER;
-			await new Promise((resolve) => {
-				const onDurationChange = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("durationchange", onDurationChange);
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						resolve(video.duration);
-					}
-				};
-				const onTimeUpdate = () => {
-					if (Number.isFinite(video.duration)) {
-						video.removeEventListener("timeupdate", onTimeUpdate);
-						video.removeEventListener("durationchange", onDurationChange);
-						resolve(video.duration);
-					}
-				};
-				video.addEventListener("durationchange", onDurationChange);
-				video.addEventListener("timeupdate", onTimeUpdate);
-			});
-		}
-		const duration = video.duration;
-		return Number.isFinite(duration) ? duration : null;
-	} finally {
-		URL.revokeObjectURL(video.src);
-		video.src = "";
-	}
+/** A trim that runs longer than this uploads the full recording instead. */
+const TRIM_TIMEOUT_MS = 1e4;
+const trimmer = BrowserLazyImportProvider.getInstance().create(() => import("./videoTrimByCopy-BFfAiNpv.esm.js").then((module) => module.trimLastNSecondsByCopy), {
+	label: "Video liveness",
+	moduleName: "mediabunny",
+	timeoutMs: 1e4,
+	disabledMessage: "the full recording will be uploaded untrimmed."
+});
+/** Starts loading the trimmer, e.g. when a recording that will be trimmed starts. */
+function preloadVideoTrimmer() {
+	trimmer.load();
 }
-async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
-	const video = document.createElement("video");
-	video.preload = "metadata";
-	video.playsInline = true;
-	video.muted = true;
-	const videoURL = URL.createObjectURL(videoBlob);
-	video.src = videoURL;
-	const duration = await getDurationBySeek(videoBlob);
-	if (!duration || duration < seconds) {
-		URL.revokeObjectURL(videoURL);
+/**
+* Keeps about the last `seconds` of a recording. Never rejects and never
+* hangs: when the trimmer cannot load, fails, or takes longer than
+* {@link TRIM_TIMEOUT_MS}, it resolves the untrimmed recording.
+*/
+async function trimLastNSeconds(videoBlob, seconds) {
+	const trim = await trimmer.load();
+	if (!trim) return videoBlob;
+	let timeout;
+	try {
+		return await Promise.race([trim(videoBlob, seconds), new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				console.warn("[Video liveness] Trimming timed out; the full recording will be uploaded untrimmed.");
+				resolve(videoBlob);
+			}, TRIM_TIMEOUT_MS);
+		})]);
+	} catch (error) {
+		console.warn("[Video liveness] Trimming failed; the full recording will be uploaded untrimmed.", error);
 		return videoBlob;
+	} finally {
+		clearTimeout(timeout);
 	}
-	const startTime = Math.max(0, Math.floor(duration) - seconds);
-	await new Promise((resolve) => {
-		if (video.readyState >= 2) resolve();
-		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
-	});
-	const canvas = document.createElement("canvas");
-	canvas.width = 230;
-	canvas.height = 320;
-	const captureFps = isAndroid() ? 15 : 24;
-	const stream = canvas.captureStream(captureFps);
-	const ctx = canvas.getContext("2d");
-	video.currentTime = startTime;
-	await new Promise((resolve) => {
-		video.addEventListener("seeked", () => resolve(), { once: true });
-	});
-	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
-	const mediaRecorder = new MediaRecorder(stream.clone(), {
-		mimeType,
-		videoBitsPerSecond: 5e5,
-		bitsPerSecond: 5e5
-	});
-	const chunks = [];
-	mediaRecorder.ondataavailable = (event) => {
-		if (event.data.size > 0) chunks.push(event.data);
-	};
-	const recordingPromise = new Promise((resolve) => {
-		mediaRecorder.onstop = () => {
-			const trimmedBlob = new Blob(chunks, { type: mimeType });
-			URL.revokeObjectURL(videoURL);
-			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
-			stream.getTracks().forEach((track) => track.stop());
-			video.src = "";
-			resolve(trimmedBlob);
-		};
-	});
-	video.addEventListener("play", () => {
-		function drawVideo() {
-			if (video.currentTime >= duration) {
-				mediaRecorder.stop();
-				video.pause();
-				return;
-			}
-			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-			requestAnimationFrame(drawVideo);
-		}
-		drawVideo();
-		setTimeout(() => {
-			mediaRecorder.start(100);
-		}, 500);
-	});
-	video.play().catch(() => {
-		URL.revokeObjectURL(videoURL);
-	});
-	const trimmedBlob = await recordingPromise;
-	console.timeEnd("trimLastNSecondsUsingPlayback");
-	return trimmedBlob;
-}
-async function trimLastNSeconds(videoBlob, seconds) {
-	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
 }
 //#endregion
 //#region ../infra/src/providers/browser/LocalRecordingProvider.ts
@@ -419,6 +118,8 @@ function toBase64(videoBlob) {
 		reader.readAsDataURL(videoBlob);
 	});
 }
+/** `MediaRecorderOptions.videoKeyFrameIntervalDuration`, see `startRecording`. */
+const KEYFRAME_INTERVAL_MS = 1e3;
 var LocalRecordingProvider = class {
 	constructor() {
 		this.mediaRecorder = null;
@@ -440,12 +141,16 @@ var LocalRecordingProvider = class {
 	}
 	startRecording(stream) {
 		this.reset();
+		preloadVideoTrimmer();
 		this.registerEventListeners();
 		this.stream = stream;
 		try {
 			const options = getAdaptiveMediaRecorderOptions();
 			this.mimeType = options.mimeType;
-			const recorder = new MediaRecorder(stream.clone(), options);
+			const recorder = new MediaRecorder(stream.clone(), {
+				...options,
+				videoKeyFrameIntervalDuration: KEYFRAME_INTERVAL_MS
+			});
 			recorder.onerror = (event) => {
 				this._error = `Recording error: ${event}`;
 				this._isRecording = false;
@@ -925,7 +630,8 @@ var ProtectedFaceAttemptRuntime = class ProtectedFaceAttemptRuntime {
 			faceResults: this.provider
 		};
 	}
-	createUploadCommand(recordingId) {
+	/** `captureType` goes on the selfie upload only, never on authentication or face-results. */
+	createUploadCommand(recordingId, captureType) {
 		const token = getToken();
 		const config = {
 			headers: token ? { "X-Incode-Hardware-Id": token } : void 0,
@@ -957,6 +663,7 @@ var ProtectedFaceAttemptRuntime = class ProtectedFaceAttemptRuntime {
 					...config,
 					params: {
 						imageType: "selfie",
+						captureType,
 						...validRecordingId ? { recordingId: validRecordingId } : {}
 					}
 				}
@@ -1137,6 +844,7 @@ function createProtectedFaceControllerActor(options) {
 		let lifecycleCleanup;
 		let sendLifecycle;
 		let committedPreview;
+		let manualCommitted = false;
 		let pendingAutoPreview;
 		let recording = {};
 		let stepRecording;
@@ -1225,6 +933,7 @@ function createProtectedFaceControllerActor(options) {
 		};
 		const releaseCurrent = (reason) => {
 			logDiagnostic("attempt-release", { releaseReason: reason });
+			noteTrueSightCaptureActivity(false);
 			diagnosticStartedAt = void 0;
 			generation += 1;
 			signalCleanup?.();
@@ -1328,10 +1037,12 @@ function createProtectedFaceControllerActor(options) {
 				case "PROTECTED_MANUAL_COMMITTED":
 					logDiagnostic("capture-selected", { captureKind: event.type === "PROTECTED_AUTO_COMMITTED" ? "auto" : "manual" });
 					committedPreview = event.preview;
+					manualCommitted ||= event.type === "PROTECTED_MANUAL_COMMITTED";
 					sendBack(event);
 					return;
 				case "PROTECTED_ATTEMPT_FINALIZED":
 					logDiagnostic("attempt-finalized");
+					noteTrueSightCaptureActivity(false);
 					recording = event.recording;
 					sendBack(event);
 					return;
@@ -1359,6 +1070,7 @@ function createProtectedFaceControllerActor(options) {
 						failureStage: event.failure.stage,
 						failureCode: event.failure.code
 					});
+					noteTrueSightCaptureActivity(false);
 					sendBack(event);
 					return;
 				default: sendBack(event);
@@ -1373,10 +1085,12 @@ function createProtectedFaceControllerActor(options) {
 			diagnosticAttempt += 1;
 			diagnosticStartedAt = getTimestamp();
 			logDiagnostic("attempt-start");
+			noteTrueSightCaptureActivity(true);
 			const ownerGeneration = generation;
 			signalCleanup = owner.subscribeSignals((signal) => {
 				if (!active || runtime !== owner || generation !== ownerGeneration) return;
 				if (signal.type === "detection") {
+					trueSightHintTransition("module.face-capture", "faceScan", signal.status);
 					sendBack({
 						type: "DETECTION_UPDATE",
 						status: signal.status
@@ -1443,7 +1157,7 @@ function createProtectedFaceControllerActor(options) {
 					if (!owner) return;
 					logDiagnostic("upload-start");
 					if (options.delivery === "protected") {
-						sendLifecycle?.(owner.createUploadCommand(recording.recordingId));
+						sendLifecycle?.(owner.createUploadCommand(recording.recordingId, manualCommitted ? "MANUAL" : "AUTO"));
 						return;
 					}
 					finalizeLocalCapture(owner, generation).catch(() => {
@@ -1559,7 +1273,6 @@ const faceCaptureMachine = setup({
 				handle?.stop();
 			};
 		}),
-		manualUploadMachine: manualFaceUploadMachine,
 		prepareFaceUpload: fromPromise(async () => {
 			throw new Error("prepareFaceUpload must be provided by variant");
 		}),
@@ -1602,6 +1315,7 @@ const faceCaptureMachine = setup({
 				permissionResult: void 0,
 				deepsightReady: false,
 				manualCaptureTriggered: false,
+				retainManualMode: false,
 				captureOnlyResult: void 0,
 				avatarCanvas: void 0
 			};
@@ -1630,7 +1344,12 @@ const faceCaptureMachine = setup({
 		setDeepsightNotReady: assign({ deepsightReady: () => false }),
 		setErrorFromEvent: assign({ error: ({ event }) => String(event.error) }),
 		setDetectionStatusDetecting: assign({ detectionStatus: ({ context }) => context.manualCaptureTriggered ? "manualCapture" : "detecting" }),
-		setDetectionStatusFromEvent: assign({ detectionStatus: ({ event }) => event.status }),
+		setDetectionStatusFromEvent: assign({ detectionStatus: ({ context, event }) => {
+			const status = event.status;
+			if (context.retainManualMode && status !== "offline") return "manualCapture";
+			return status;
+		} }),
+		retainManualModeForRetry: assign({ retainManualMode: ({ context }) => context.manualCaptureTriggered && context.config.onDeviceFaceResultsSubmissionEnabled !== true }),
 		setManualCaptureTriggered: assign({ manualCaptureTriggered: ({ context, event }) => {
 			const status = event.status;
 			return context.manualCaptureTriggered || status === "manualCapture";
@@ -1664,10 +1383,13 @@ const faceCaptureMachine = setup({
 		}),
 		setUploadResponseFromEvent: assign({ uploadResponse: ({ event }) => event.output }),
 		setProcessResponseFromEvent: assign({ processResponse: ({ event }) => event.output }),
-		setServerErrorAndDecrement: assign(({ context }) => ({
-			uploadError: FACE_ERROR_CODES.SERVER,
-			attemptsRemaining: context.attemptsRemaining - 1
-		})),
+		setUploadFailureAndDecrement: assign(({ context, event }) => {
+			const { httpStatus, responseStatus } = event.failure;
+			return {
+				uploadError: httpStatus === void 0 ? FACE_ERROR_CODES.SERVER : getFaceUploadErrorCode(httpStatus, responseStatus),
+				attemptsRemaining: context.attemptsRemaining - 1
+			};
+		}),
 		sendLabelInspection: () => {
 			sendLabelInspectionEvent();
 		},
@@ -1686,7 +1408,6 @@ const faceCaptureMachine = setup({
 			releaseFaceAvatarWarmup();
 		},
 		noOp: () => void 0,
-		forwardToManualUpload: sendTo("manualUpload", ({ event }) => event),
 		sendProtectedPreAcquire: enqueueActions(({ enqueue, self }) => {
 			if (!isProtectedFaceControllerRunning(self)) return;
 			enqueue.sendTo("protectedFaceController", { type: "PRE_ACQUIRE" });
@@ -1744,8 +1465,6 @@ const faceCaptureMachine = setup({
 	guards: {
 		hasShowTutorial: ({ context }) => context.config.showTutorial,
 		hasAgeAssurance: ({ context }) => context.config.ageAssurance === true,
-		hasManualUploadEnabled: () => false,
-		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted",
 		isPermissionGranted: ({ event }) => {
 			if ("output" in event) return event.output === "granted";
 			return false;
@@ -1767,6 +1486,7 @@ const faceCaptureMachine = setup({
 		isCameraAndDeepsightReady: ({ context }) => context.stream !== void 0 && context.deepsightReady,
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 0,
 		hasCapturedImage: ({ context }) => context.capturedImage !== void 0,
+		isAutoCaptureAllowed: ({ context }) => !context.retainManualMode,
 		canCommitProtectedManual: ({ context }) => context.manualCaptureTriggered && context.config.onDeviceFaceResultsSubmissionEnabled !== true,
 		isProtectedManualRefusal: ({ event }) => event.failure.stage === "manualCommit",
 		isProtectedUploadFailure: ({ event }) => event.failure.stage === "upload",
@@ -1797,6 +1517,7 @@ const faceCaptureMachine = setup({
 		encryptedBase64Image: void 0,
 		uploadRecordingId: void 0,
 		manualCaptureTriggered: false,
+		retainManualMode: false,
 		captureOnlyResult: void 0,
 		avatarCanvas: void 0,
 		faceFeed: void 0,
@@ -1842,10 +1563,6 @@ const faceCaptureMachine = setup({
 		tutorial: {
 			initial: "checkingPermission",
 			entry: ["trackTutorial", "warmAvatarProvider"],
-			on: { GO_TO_MANUAL_UPLOAD: {
-				guard: "hasManualUploadEnabled",
-				target: "#faceCapture.manualUpload"
-			} },
 			states: {
 				checkingPermission: { invoke: {
 					id: "checkPermissionTutorial",
@@ -1928,9 +1645,23 @@ const faceCaptureMachine = setup({
 								PROTECTED_DEEPSIGHT_FAILED: {
 									target: "readyForNext",
 									actions: "setDeepsightNotReady"
+								},
+								NEXT_STEP: {
+									target: "continuing",
+									actions: "trackContinue"
 								}
 							}
 						},
+						continuing: { on: {
+							PROTECTED_DEEPSIGHT_READY: {
+								target: "#faceCapture.tutorial.waitingForPermission",
+								actions: "setDeepsightReady"
+							},
+							PROTECTED_DEEPSIGHT_FAILED: {
+								target: "#faceCapture.tutorial.waitingForPermission",
+								actions: "setDeepsightNotReady"
+							}
+						} },
 						readyForNext: { on: { NEXT_STEP: {
 							target: "#faceCapture.tutorial.waitingForPermission",
 							actions: "trackContinue"
@@ -2076,7 +1807,7 @@ const faceCaptureMachine = setup({
 					{
 						target: ".uploadError",
 						guard: "isProtectedUploadFailure",
-						actions: "setServerErrorAndDecrement"
+						actions: "setUploadFailureAndDecrement"
 					},
 					{
 						target: "#faceCapture.error",
@@ -2098,8 +1829,11 @@ const faceCaptureMachine = setup({
 							actions: "setDeepsightReady"
 						},
 						PROTECTED_DEEPSIGHT_FAILED: {
-							target: "#faceCapture.permissions",
-							actions: "setDeepsightNotReady"
+							target: "#faceCapture.error",
+							actions: assign({
+								deepsightReady: () => false,
+								error: () => "Deepsight initialization failed"
+							})
 						}
 					}
 				},
@@ -2123,7 +1857,10 @@ const faceCaptureMachine = setup({
 					on: {
 						DETECTION_UPDATE: { actions: ["setDetectionStatusFromEvent", "setManualCaptureTriggered"] },
 						AVATAR_READY: { actions: "setAvatarCanvas" },
-						PROTECTED_NATIVE_AUTO_CAPTURE: { actions: "sendProtectedAutoCapture" },
+						PROTECTED_NATIVE_AUTO_CAPTURE: {
+							guard: "isAutoCaptureAllowed",
+							actions: "sendProtectedAutoCapture"
+						},
 						PROTECTED_AUTO_COMMITTED: {
 							target: "capturing",
 							actions: "setProtectedCommittedPreview"
@@ -2182,6 +1919,7 @@ const faceCaptureMachine = setup({
 						reenter: true,
 						guard: "hasAttemptsRemaining",
 						actions: [
+							"retainManualModeForRetry",
 							"clearUploadFailure",
 							"setDeepsightNotReady",
 							"resetProtectedController",
@@ -2204,36 +1942,6 @@ const faceCaptureMachine = setup({
 				}
 			}
 		},
-		manualUpload: {
-			entry: [
-				"releaseProtectedAttempt",
-				"stopMediaStream",
-				"releaseAvatarWarmup"
-			],
-			invoke: {
-				id: "manualUpload",
-				src: "manualUploadMachine",
-				input: ({ context }) => ({
-					config: context.config,
-					dependencies: context.dependencies,
-					captureAttempts: getAttemptsFromConfig(context.config)
-				}),
-				onSnapshot: { actions: "noOp" },
-				onDone: [{
-					guard: "isManualUploadExhausted",
-					target: "terminalProcessing"
-				}, { target: "processing" }],
-				onError: {
-					target: "error",
-					actions: "setErrorFromEvent"
-				}
-			},
-			on: {
-				MANUAL_UPLOAD_FILE_SELECTED: { actions: "forwardToManualUpload" },
-				MANUAL_UPLOAD_CONTINUE: { actions: "forwardToManualUpload" },
-				MANUAL_UPLOAD_RESET: { actions: "forwardToManualUpload" }
-			}
-		},
 		processing: { invoke: {
 			id: "processFace",
 			src: "processFace",
@@ -2287,4 +1995,4 @@ const faceCaptureMachine = setup({
 	}
 });
 //#endregion
-export { concealmentToAvatar as i, createDefaultProtectedFaceControllerActor as n, manualFaceUploadMachine as r, faceCaptureMachine as t };
+export { createDefaultProtectedFaceControllerActor as n, concealmentToAvatar as r, faceCaptureMachine as t };