@incodetech/core 2.2.0-rc.6 → 2.2.0

package/dist/{idCaptureStateMachine-3jTqEo76.esm.js → idCaptureStateMachine-kZ5OpdfM.esm.js}

@@ -1,18 +1,18 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { s as exposeExperimentOnce } from "./feature-management-Bo_xbwQa.esm.js";
+import { s as exposeExperimentOnce } from "./feature-management-CPQ4qv3F.esm.js";
 import { n as revokeObjectURL } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-B49-Eq-5.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService---iW2KKJ.esm.js";
 import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-DYiyoSlx.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-BFJAT3u0.esm.js";
-import "./trueSight-CAaztf3O.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-dlfDehHk.esm.js";
+import "./trueSight-B_icM8r2.esm.js";
 import { t as addDeviceStats } from "./stats-B0nFKawG.esm.js";
 import { t as isAndroid } from "./platform-BJrm5nzZ.esm.js";
-import "./session-ChIfu6mP.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 "./session-BFdLgN4i.esm.js";
+import { c as not, i as assign, l as raise, n as enqueueActions, o as and, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
-import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-CTinxa9H.esm.js";
+import { _ as StreamCanvasProcessingSession } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 import { t as getBrowser } from "./getBrowser-DNrQeL4T.esm.js";
@@ -20,7 +20,7 @@ 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-28d5mDGM.esm.js";
+import { _ as getIdCameraStream, a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, g as OPTIMIZING_WATCHDOG_MARGIN_MS, h as CAPTURE_OPTIMIZING, i as preloadIdRecordingProvider, l as uploadIdImage, m as resolveIdCaptureThresholds, o as startRecordingSession, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-44kwQItl.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isKnownFailReason(reason) {
@@ -791,6 +791,20 @@ const hasAttemptsRemainingGuard = ({ context }) => context.attemptsRemaining > 0
 const hasCapturedImageGuard = ({ context }) => {
 	return context.provider?.getCapturedCanvas() !== null;
 };
+const hasCandidateFrameGuard = ({ event }) => {
+	return event.type === "DETECTION_OPTIMIZING" && Boolean(event.candidateCanvas);
+};
+/**
+* IDC-05: whether WASM's commit arrived while the optimizing phase was still
+* spending its dwell, and is therefore parked in `optimizing.holding` waiting
+* for the release.
+*
+* Gates the phase's own `SWITCH_TO_MANUAL_CAPTURE` / `MANUAL_CAPTURE` handlers:
+* while a commit is parked those escapes end the dwell early instead of leaving
+* the phase, so WASM's committed frame is honored rather than dropped on the way
+* out. False leaves both events to the arm parent, the documented escape hatch.
+*/
+const hasStashedCommitGuard = ({ context }) => context.stashedCommit !== void 0;
 const hasUploadValidationErrorGuard = ({ context }) => {
 	if (!context.uploadResponse) return false;
 	return validateUploadResponse(context.uploadResponse, {
@@ -835,16 +849,31 @@ 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.
+* IDC-05 arm, as resolved once per session by
+* `resolveCaptureOptimizingTreatment` at actor creation.
 */
-const isCaptureResultPreviewModeGuard = ({ context }) => context.captureFeedbackMode === "result-preview";
+const isCaptureOptimizingModeGuard = ({ context }) => context.captureFeedbackMode === "optimizing";
 /**
-* 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.
+* IDC-05 rendering-layer capability: whether the consumer opted into rendering
+* `captureStatus === 'optimizing'`. Consumers that omit it retain the direct
+* capture-to-upload path. Nothing is advanced by the host — core owns the phase's
+* timing on both paths (WASM's commit on auto capture, `optimizingDwell` on
+* manual), so there is no acknowledgement call.
+*
+* Paired with `isCaptureOptimizingModeGuard` at both branch sites
+* (`choosingDetectionStrategy`, `capturingManual`). Through
+* `createIdCaptureActor` the two can never disagree — that path derives
+* `captureFeedbackMode` from `resolveCaptureOptimizingTreatment`, which
+* already requires this capability — so the pairing looks redundant, and for
+* SDK-built sessions it is.
+*
+* It is NOT redundant on the public surface: `idCaptureMachine` is exported from
+* `@incodetech/core/id` and its `input.captureFeedbackMode` is settable, so a
+* host wiring the machine up directly could otherwise reach the phase without
+* declaring the capability. This guard is what makes the documented opt-in true
+* for every route into the machine, not just the factory.
 */
-const supportsCaptureResultPreviewGuard = ({ context }) => context.config.supportsCaptureResultPreview === true;
+const supportsOptimizingStatusGuard = ({ context }) => context.config.supportsOptimizingStatus === true;
 const isDeepsightEnabledGuard = ({ context }) => context.dependencies !== void 0;
 const isDeepsightReadyGuard = ({ context }) => context.deepsightService !== void 0;
 const needsDeepsightInitGuard = ({ context }) => context.dependencies !== void 0 && context.deepsightService === void 0 && !context.deepsightInitAttempted;
@@ -933,6 +962,7 @@ const isBackModeInMultiSideFlowGuard = ({ context }) => context.currentMode ===
 * max-attempts/OCR cap (ENG-46592 / re-respects ENG-45666).
 */
 const wasExpiredRedirectedGuard = ({ context }) => context.expiredRedirected === true;
+const hasManualCaptureTriggeredGuard = ({ context }) => context.manualCaptureTriggered;
 //#endregion
 //#region src/modules/id/idCaptureHelpers.ts
 /**
@@ -1041,6 +1071,13 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 	let isCapturing = false;
 	const timer = BrowserTimerProvider.getInstance();
 	let notificationTimeout = null;
+	let optimizingBoundaryTimeout = null;
+	/**
+	* IDC-05 latch for the boundary clock: whether a boundary is currently
+	* pending. `onCapturing` is WASM's "aggregation window opened" callback and is
+	* the clock's only T0; nothing in WASM enforces that it fires once per window.
+	*/
+	let isOptimizingBoundaryArmed = false;
 	let currentNotificationStatus = null;
 	let lastReportedSide = null;
 	const NOTIFICATION_DURATION_MS = 500;
@@ -1059,6 +1096,50 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 			currentNotificationStatus = null;
 		}
 	};
+	const clearOptimizingBoundary = () => {
+		if (optimizingBoundaryTimeout) {
+			timer.clearTimeout(optimizingBoundaryTimeout);
+			optimizingBoundaryTimeout = null;
+		}
+		isOptimizingBoundaryArmed = false;
+	};
+	/**
+	* IDC-05 boundary clock — the actor's *only* timer, and the only piece of the
+	* optimizing phase it owns. WASM's `CapturingManager` opens the
+	* frames-aggregation window at `onCapturing` and closes it with `onCapture` at
+	* `T0 + framesAggregationInterval` (already resolved to
+	* `captureWindowMs + optimizingDwellMs`). The phase begins at
+	* `T0 + captureWindowMs`, so it is timed from the very callback that defines
+	* T0; how long it then lasts is the machine's business.
+	*
+	* No best frame yet at that point means the session simply behaves like the
+	* countdown arm — no event, no phase — which mirrors iOS's "auto capture with
+	* no best crop yet" fallback.
+	*
+	* At most one boundary pending at a time — see `isOptimizingBoundaryArmed`.
+	*/
+	const scheduleOptimizingBoundary = () => {
+		if (input.optimizingAfterMs == null || isOptimizingBoundaryArmed) return;
+		isOptimizingBoundaryArmed = true;
+		optimizingBoundaryTimeout = timer.setTimeout(() => {
+			optimizingBoundaryTimeout = null;
+			isOptimizingBoundaryArmed = false;
+			enterOptimizing();
+		}, input.optimizingAfterMs);
+	};
+	/**
+	* Reports the boundary with the candidate frame to freeze. Silent when there
+	* is no candidate — no event means no phase, and the session behaves like the
+	* countdown arm (see `scheduleOptimizingBoundary`).
+	*/
+	const enterOptimizing = () => {
+		const candidateCanvas = bestCanvas?.clone();
+		if (!candidateCanvas) return;
+		sendBack({
+			type: "DETECTION_OPTIMIZING",
+			candidateCanvas
+		});
+	};
 	const sendNotification = (status) => {
 		if (isReportedSideWrong()) return;
 		if (notificationTimeout && currentNotificationStatus !== status) return;
@@ -1146,6 +1227,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		},
 		onSwitchToManualCapture: () => {
 			isCapturing = false;
+			clearOptimizingBoundary();
 			sendBack({ type: "SWITCH_TO_MANUAL_CAPTURE" });
 		},
 		onCapturing: () => {
@@ -1157,6 +1239,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 				type: "DETECTION_UPDATE",
 				status: "capturing"
 			});
+			scheduleOptimizingBoundary();
 		},
 		onBestFrame: (blur, glare, orientation) => {
 			if (currentCanvas) {
@@ -1173,16 +1256,24 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 		},
 		onCapture: () => {
 			isCapturing = false;
-			if (bestCanvas) sendBack({
+			if (isOptimizingBoundaryArmed) {
+				clearOptimizingBoundary();
+				enterOptimizing();
+			}
+			if (!bestCanvas) {
+				const clonedCanvas = currentCanvas?.clone();
+				if (clonedCanvas) sendBack({
+					type: "DETECTION_SUCCESS",
+					canvas: clonedCanvas,
+					qualityElements: {}
+				});
+				return;
+			}
+			sendBack({
 				type: "DETECTION_SUCCESS",
 				canvas: bestCanvas,
 				qualityElements: storedQualityElements
 			});
-			else if (currentCanvas) sendBack({
-				type: "DETECTION_SUCCESS",
-				canvas: currentCanvas.clone(),
-				qualityElements: {}
-			});
 		},
 		onIdTypeChange: (idType) => {
 			sendBack({
@@ -1233,6 +1324,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 					notificationTimeout = null;
 					currentNotificationStatus = null;
 				}
+				clearOptimizingBoundary();
 				currentCanvas = null;
 				bestCanvas = null;
 				storedQualityElements = {};
@@ -1251,6 +1343,7 @@ const runDetectionActor = fromCallback(({ input, sendBack }) => {
 	});
 	return () => {
 		clearNotificationTimeout();
+		clearOptimizingBoundary();
 		session?.dispose();
 		noteTrueSightCaptureActivity(false);
 	};
@@ -1338,7 +1431,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CraWVfCs.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader--wMKWECS.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -1376,11 +1469,11 @@ function performResetForFrontCapture(context) {
 function performResetDetection(context) {
 	context.resetDetection?.();
 }
-function performReportCaptureResultPreviewAssignment(context) {
-	if (context.config.supportsCaptureResultPreview !== true) return;
-	const assignment = exposeExperimentOnce(CAPTURE_RESULT_PREVIEW);
+function performReportCaptureOptimizingAssignment(context) {
+	if (context.config.supportsOptimizingStatus !== true) return;
+	const assignment = exposeExperimentOnce(CAPTURE_OPTIMIZING);
 	if (!assignment) return;
-	recordExperimentAssignmentOnce(eventModuleNames.idCapture, CAPTURE_RESULT_PREVIEW.storeParam, assignment);
+	recordExperimentAssignmentOnce(eventModuleNames.idCapture, CAPTURE_OPTIMIZING.storeParam, assignment);
 }
 function performStopMediaRecording(context) {
 	if (context.recordingSession) stopRecording(context.recordingSession);
@@ -1443,6 +1536,7 @@ function getResetContextValues(context) {
 		idType: void 0,
 		qualityElements: void 0,
 		previewImageUrl: void 0,
+		...getClearOptimizingValues(context),
 		uploadProgress: void 0,
 		currentMode,
 		selectedDocumentType: void 0,
@@ -1457,6 +1551,7 @@ function getClearUploadFailureValues(context) {
 		uploadError: void 0,
 		detectionStatus: "idle",
 		previewImageUrl: void 0,
+		...getClearOptimizingValues(context),
 		uploadProgress: void 0
 	};
 }
@@ -1476,6 +1571,39 @@ function storeCapturedCanvasInProviderLogic(context, event) {
 	const canvasHeight = canvas.height();
 	if (!canvasWidth || !canvasHeight) return;
 	const originalCanvas = canvas;
+	const frameRect = resolveCaptureFrameRect(context, canvasWidth, canvasHeight);
+	const transformedCanvas = context.provider.transformPerspective(originalCanvas, frameRect);
+	context.provider.setCapturedCanvases(originalCanvas, transformedCanvas);
+}
+/**
+* JPEG quality for the IDC-05 optimizing phase's display-only still.
+*
+* `updateBlob()` is synchronous and expensive: `toDataURL` → `atob` → a per-byte
+* loop building the blob (`IncodeCanvas.base64ToBlob`). At the default quality of
+* 1.0 on a 1080p frame that is tens of milliseconds of main-thread work — and on
+* this path it runs inside an `assign`, in the same tick that starts the phase
+* animation, with the 30fps WASM detection loop still live. Both halves of the
+* cost scale with the encoded byte count, so dropping quality cuts the encode and
+* the byte loop together.
+*
+* Treatment-arm only, deliberately: the committed frame keeps quality 1.0, since
+* it is what uploads (`getStoreCapturedImageValues` → `getBase64Image(1.0)`) and
+* its encode happens on the analyzing screen with no animation to jank. This
+* still is on screen for one dwell at roughly card size and never leaves the
+* device.
+*/
+const CANDIDATE_FRAME_JPEG_QUALITY = .8;
+/**
+* The document's rectangle within a camera frame, in canvas coordinates —
+* the input to `transformPerspective`.
+*
+* Shared by the commit path (`storeCapturedCanvasInProviderLogic`) and the
+* IDC-05 optimizing phase (`getCandidateFrameValues`) so the still shown
+* mid-capture is cropped and warped exactly like the frame that later uploads.
+* Deriving it twice is what made the phase show an uncropped full frame that then
+* visibly jumped to a cropped one on the analyzing screen.
+*/
+function resolveCaptureFrameRect(context, canvasWidth, canvasHeight) {
 	let frameRect;
 	const { innerWidth: viewportWidth, innerHeight: viewportHeight } = getWindowDimensions();
 	if (context.detectionArea) {
@@ -1507,7 +1635,7 @@ function storeCapturedCanvasInProviderLogic(context, event) {
 			h: context.frameRect.h / scale
 		};
 	} else {
-		const quadValue = (context.provider.getLastProcessResult?.())?.quad;
+		const quadValue = (context.provider?.getLastProcessResult?.())?.quad;
 		const hasQuad = !!quadValue;
 		const quadSize = quadValue?.size ? quadValue.size() : quadValue?.length ?? 0;
 		if (hasQuad && quadSize >= 4 && quadValue.get) {
@@ -1538,8 +1666,7 @@ function storeCapturedCanvasInProviderLogic(context, event) {
 			};
 		}
 	}
-	const transformedCanvas = context.provider.transformPerspective(originalCanvas, frameRect);
-	context.provider.setCapturedCanvases(originalCanvas, transformedCanvas);
+	return frameRect;
 }
 function getStoreCapturedImageValues(context, event) {
 	if (!context.currentMode) return {
@@ -1573,7 +1700,79 @@ function getStoreCapturedImageValues(context, event) {
 	}
 	return {
 		capturedImages,
-		previewImageUrl
+		previewImageUrl,
+		...getClearOptimizingValues(context)
+	};
+}
+/**
+* IDC-05: freezes WASM's best-scoring frame *so far* for the optimizing phase.
+* Display-only — the committed frame arrives later, from `onCapture`, and
+* `storeCapturedImage` puts that one on `previewImageUrl` while clearing this
+* one in the same assign, so the rendering layer's
+* `candidateImageUrl ?? previewImageUrl` falls through to the frame that
+* actually uploads for the crossfade.
+*
+* Revokes any previous URL rather than leaking one per retry.
+*/
+function getCandidateFrameValues(context, event) {
+	if (event.type !== "DETECTION_OPTIMIZING" || !event.candidateCanvas) return { candidateImageUrl: context.candidateImageUrl };
+	const candidateCanvas = event.candidateCanvas;
+	const canvas = cropCanvasForPreview(context, candidateCanvas);
+	canvas.updateBlob(CANDIDATE_FRAME_JPEG_QUALITY);
+	const url = canvas.getBlobData()?.url;
+	if (!url) {
+		releasePreviewCanvases(candidateCanvas, canvas, { shouldReleasePreview: true });
+		return { candidateImageUrl: context.candidateImageUrl };
+	}
+	releasePreviewCanvases(candidateCanvas, canvas, { shouldReleasePreview: false });
+	if (context.candidateImageUrl) revokeObjectURL(context.candidateImageUrl);
+	return { candidateImageUrl: url };
+}
+/**
+* Reclaims the full-frame canvases the phase allocated. At 1080p each is ~8MB of
+* backing store, and `release()` frees it now instead of at the next GC — which
+* is what matters on iOS Safari, where canvas memory is its own budget.
+*
+* `source` — the clone the detection actor snapshotted — is always dead by the
+* time this runs: its pixels live on in `preview`'s blob.
+*
+* `preview` is the caller's decision, because `release()` also revokes
+* `blobData.url`. On the success path that URL is the very thing being handed to
+* the machine as `candidateImageUrl`, so releasing it would blank the phase's
+* own still; pass `shouldReleasePreview: true` only where no URL survives. Either way
+* the identity guard covers `transformPerspective` returning the canvas it was
+* given (no provider, or a WASM failure), so the aliased canvas is never
+* released twice or released out from under a live URL.
+*/
+function releasePreviewCanvases(source, preview, { shouldReleasePreview }) {
+	if (preview === source) {
+		if (shouldReleasePreview) source.release();
+		return;
+	}
+	if (shouldReleasePreview) preview.release();
+	source.release();
+}
+function cropCanvasForPreview(context, canvas) {
+	const canvasWidth = canvas.width();
+	const canvasHeight = canvas.height();
+	if (!context.provider || !canvasWidth || !canvasHeight) return canvas;
+	const frameRect = resolveCaptureFrameRect(context, canvasWidth, canvasHeight);
+	return context.provider.transformPerspective(canvas, frameRect);
+}
+/**
+* Drops the IDC-05 best-so-far still at every attempt/side boundary. Unlike
+* `previewImageUrl` it is never preserved into `flipPreview` (it was never a
+* committed frame), so it can always be revoked outright.
+*
+* Clears `stashedCommit` alongside it: a commit parked for the phase's dwell is
+* only meaningful inside that phase, and holding the canvas reference past it
+* would keep a full-res frame alive for the rest of the attempt.
+*/
+function getClearOptimizingValues(context) {
+	if (context.candidateImageUrl) revokeObjectURL(context.candidateImageUrl);
+	return {
+		candidateImageUrl: void 0,
+		stashedCommit: void 0
 	};
 }
 function getDetectionStatusFromUpdate(context, event) {
@@ -1706,6 +1905,7 @@ const idCaptureMachine = setup({
 				qualityElements: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
+				...getClearOptimizingValues(context),
 				flipPreview: context.previewImageUrl ? {
 					url: context.previewImageUrl,
 					orientation: context.orientation,
@@ -1735,6 +1935,7 @@ const idCaptureMachine = setup({
 				qualityElements: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
+				...getClearOptimizingValues(context),
 				flipPreview: context.previewImageUrl ? {
 					url: context.previewImageUrl,
 					orientation: context.orientation,
@@ -1763,6 +1964,7 @@ const idCaptureMachine = setup({
 				qualityElements: void 0,
 				frameRect: void 0,
 				previewImageUrl: void 0,
+				...getClearOptimizingValues(context),
 				uploadProgress: void 0,
 				manualCaptureTriggered: false,
 				attemptsRemaining: context.config.captureAttempts
@@ -1783,8 +1985,8 @@ const idCaptureMachine = setup({
 		trackTutorialId: () => {},
 		trackContinue: () => {},
 		trackCameraId: ({ context }) => {},
-		reportCaptureResultPreviewAssignment: ({ context }) => {
-			performReportCaptureResultPreviewAssignment(context);
+		reportCaptureOptimizingAssignment: ({ context }) => {
+			performReportCaptureOptimizingAssignment(context);
 		},
 		preloadRecordingProvider: ({ context }) => {
 			preloadIdRecordingProvider(context.config);
@@ -1825,6 +2027,53 @@ const idCaptureMachine = setup({
 		} }),
 		setCurrentMode: assign({ currentMode: ({ event, context }) => getCurrentModeFromEvent(context, event) }),
 		storeCapturedImage: assign(({ context, event }) => getStoreCapturedImageValues(context, event)),
+		setCandidateFrame: assign(({ context, event }) => getCandidateFrameValues(context, event)),
+		/**
+		* IDC-05: parks WASM's commit while the optimizing phase spends the rest of
+		* its dwell. The frame travels in context only for that stretch —
+		* `releaseStashedCommit` re-raises it and `getClearOptimizingValues` drops it
+		* on every other exit from the phase.
+		*/
+		stashCommittedFrame: assign({ stashedCommit: ({ event }) => {
+			const commit = event;
+			return {
+				canvas: commit.canvas,
+				qualityElements: commit.qualityElements
+			};
+		} }),
+		/**
+		* IDC-05: hands a parked commit back to the machine as the very event that
+		* would have carried it, so `capturing`'s entry actions stay event-driven.
+		* Re-raised rather than read from context by `capturing` because
+		* `storeCapturedCanvasInProvider` falls back to the *live* frame when the
+		* entering event has no canvas — a timer transition into `capturing` would
+		* stage a live frame for upload instead of the one WASM committed.
+		*/
+		releaseStashedCommit: enqueueActions(({ context, enqueue }) => {
+			const stashed = context.stashedCommit;
+			if (!stashed) return;
+			enqueue(raise({
+				type: "DETECTION_SUCCESS",
+				canvas: stashed.canvas,
+				qualityElements: stashed.qualityElements
+			}));
+		}),
+		/**
+		* IDC-05: releases everything the optimizing phase allocated — the parked
+		* commit AND the frozen still's blob URL. Bound to `optimizing.exit`, so it
+		* covers every route out of the phase, not just the two that already clear
+		* up after themselves (`getStoreCapturedImageValues` on the commit,
+		* `optimizingGrace`'s own action on the abandon path). Before this it
+		* cleared only `stashedCommit`, and an exit through the manual-capture
+		* escape leaked the URL until the next attempt/side boundary.
+		*
+		* Safe to revoke here on the commit path: exit and `capturing`'s entry run
+		* in the same macrostep, and `capturing`'s eventless `always` means the UI
+		* only ever observes the resulting `uploading` snapshot — by which point
+		* `previewImageUrl` is set, so `candidateImageUrl ?? previewImageUrl` never
+		* resolves to nothing (see `getStoreCapturedImageValues`).
+		*/
+		clearOptimizingPhase: assign(({ context }) => getClearOptimizingValues(context)),
 		storeBarcodeResponse: assign(({ context, event }) => getBarcodeResponseValues(context, event)),
 		storeDecodedBarcode: assign({ decodedBarcode: ({ event }) => event.decoded }),
 		setBarcodeFastPathAttempted: assign({ barcodeFastPathAttempted: true }),
@@ -1892,13 +2141,15 @@ const idCaptureMachine = setup({
 		hasInitializedCamera: hasInitializedCameraGuard,
 		hasAttemptsRemaining: hasAttemptsRemainingGuard,
 		hasCapturedImage: hasCapturedImageGuard,
+		hasCandidateFrame: hasCandidateFrameGuard,
+		hasStashedCommit: hasStashedCommitGuard,
 		hasUploadValidationError: hasUploadValidationErrorGuard,
 		isFrontMode: isFrontModeGuard,
 		shouldContinueToBack: shouldContinueToBackGuard,
 		shouldContinueToFront: shouldContinueToFrontGuard,
 		hasMandatoryConsent: hasMandatoryConsentGuard,
-		isCaptureResultPreviewMode: isCaptureResultPreviewModeGuard,
-		supportsCaptureResultPreview: supportsCaptureResultPreviewGuard,
+		isCaptureOptimizingMode: isCaptureOptimizingModeGuard,
+		supportsOptimizingStatus: supportsOptimizingStatusGuard,
 		isDeepsightEnabled: isDeepsightEnabledGuard,
 		isDeepsightReady: isDeepsightReadyGuard,
 		needsDeepsightInit: needsDeepsightInitGuard,
@@ -1914,6 +2165,7 @@ const idCaptureMachine = setup({
 		shouldSkipProcessId: shouldSkipProcessIdGuard,
 		shouldSubmitBarcode: shouldSubmitBarcodeGuard,
 		canRunBarcodeFastPath: canRunBarcodeFastPathGuard,
+		hasManualCaptureTriggered: hasManualCaptureTriggeredGuard,
 		isProcessingExpiredExhausted: isProcessingExpiredExhaustedGuard,
 		shouldProcessAfterExhaustion: shouldProcessAfterExhaustionGuard,
 		forceFinishAfterProcessing: forceFinishAfterProcessingGuard,
@@ -1922,6 +2174,36 @@ const idCaptureMachine = setup({
 		isManualUploadExhausted: ({ event }) => event.output?.result === "exhausted",
 		isDigitalUploadExhausted: ({ event }) => event.output?.result === "exhausted",
 		isDigitalUploadSuccessful: ({ event }) => event.output?.result === "success"
+	},
+	delays: {
+		/**
+		* IDC-05: how long the optimizing phase lasts, on BOTH paths — the auto
+		* path's `optimizing.holding` and the manual path's `optimizingHold`. One
+		* value, read from context rather than hardcoded, so the experiment payload
+		* governs the phase wherever it is played.
+		*
+		* `?? 0` rather than the default dwell, deliberately: neither state is
+		* reachable outside the treatment arm, and the treatment arm is the only
+		* thing that populates `optimizingDwellMs`
+		* (`resolveCaptureOptimizingTreatment` always sets it on its `optimizing`
+		* branch). An absent value here therefore means the wiring between the two
+		* broke, and falling back to the default would silently add a dwell to a
+		* capture that was never supposed to have one. Zero makes that failure a
+		* pass-through instead of a 1.5s regression.
+		*/
+		optimizingDwell: ({ context }) => context.optimizingDwellMs ?? 0,
+		/**
+		* IDC-05: how much longer the machine waits for WASM's commit once the phase
+		* has had its full dwell (`optimizing.released`). Past this, `onCapture` —
+		* the phase's normal exit — is not coming for the window this still belongs
+		* to, and the phase is abandoned.
+		*
+		* A constant, not `dwell + margin`: the dwell has already been spent in
+		* `holding` by the time this arms, so the total from phase entry is
+		* unchanged. It also means the timer stays armed on a partially-resolved
+		* payload, where `optimizingDwell` above collapses to zero.
+		*/
+		optimizingGrace: OPTIMIZING_WATCHDOG_MARGIN_MS
 	}
 }).createMachine({
 	id: "idCapture",
@@ -1932,6 +2214,8 @@ const idCaptureMachine = setup({
 		return {
 			config: input.config,
 			captureFeedbackMode: input.captureFeedbackMode ?? "countdown",
+			captureWindowMs: input.captureWindowMs,
+			optimizingDwellMs: input.optimizingDwellMs,
 			currentMode,
 			selectedDocumentType: void 0,
 			stream: void 0,
@@ -1965,6 +2249,7 @@ const idCaptureMachine = setup({
 			frameRect: void 0,
 			detectionArea: void 0,
 			previewImageUrl: void 0,
+			candidateImageUrl: void 0,
 			uploadProgress: void 0,
 			manualCaptureTriggered: false,
 			deepsightService: void 0,
@@ -2294,7 +2579,7 @@ const idCaptureMachine = setup({
 						guard: "needsDeepsightInit"
 					},
 					{
-						target: "detecting",
+						target: "choosingDetectionStrategy",
 						guard: "hasInitializedCamera"
 					},
 					{ target: "initializing" }
@@ -2329,7 +2614,7 @@ const idCaptureMachine = setup({
 						cameraFallbackLevel: context.cameraFallbackLevel
 					}),
 					onDone: {
-						target: "detecting",
+						target: "choosingDetectionStrategy",
 						actions: "setStreamAndCapturer"
 					},
 					onError: [{
@@ -2341,13 +2626,20 @@ const idCaptureMachine = setup({
 						actions: assign({ error: ({ event }) => String(event.error) })
 					}]
 				} },
+				choosingDetectionStrategy: {
+					entry: ["reportCaptureOptimizingAssignment"],
+					always: [{
+						target: "detectingWithOptimization",
+						guard: and(["isCaptureOptimizingMode", "supportsOptimizingStatus"])
+					}, { target: "detecting" }]
+				},
 				detecting: {
 					always: [{
 						target: "manualCaptureWaiting",
-						guard: ({ context }) => context.manualCaptureTriggered,
+						guard: "hasManualCaptureTriggered",
 						actions: assign({ detectionStatus: () => "manualCapture" })
 					}],
-					entry: [assign({ detectionStatus: () => "detecting" }), "reportCaptureResultPreviewAssignment"],
+					entry: [assign({ detectionStatus: () => "detecting" })],
 					invoke: [{
 						id: "startRecording",
 						src: "startRecording",
@@ -2398,6 +2690,113 @@ const idCaptureMachine = setup({
 						ORIENTATION_CHANGE: { actions: "setOrientation" }
 					}
 				},
+				/**
+				* IDC-05 treatment arm: same detection as `detecting` above (kept in sync by
+				* hand — see the comment there), plus the two-phase searching -> optimizing
+				* phase.
+				*
+				* Two *distinct* state nodes (this one and `detecting`) rather than one
+				* compound state, deliberately: `snapshot.matches({ capture: 'detecting' })`
+				* keeps meaning exactly what it always meant. Folding the phase into
+				* `detecting` as a substate would make every such selector silently true
+				* while the user is being told the capture succeeded — a hazard no type or
+				* test would catch.
+				*/
+				detectingWithOptimization: {
+					entry: assign({ detectionStatus: () => "detecting" }),
+					always: [{
+						target: "manualCaptureWaiting",
+						guard: "hasManualCaptureTriggered",
+						actions: assign({ detectionStatus: () => "manualCapture" })
+					}],
+					invoke: [{
+						id: "startRecording",
+						src: "startRecording",
+						input: ({ context }) => ({
+							config: context.config,
+							stream: context.stream,
+							existing: context.recordingSession,
+							currentMode: context.currentMode
+						}),
+						onDone: { actions: assign({ recordingSession: ({ context, event }) => {
+							return event.output ?? context.recordingSession;
+						} }) },
+						onError: { actions: () => void 0 }
+					}, {
+						id: "runDetection",
+						src: "runDetection",
+						input: ({ context }) => ({
+							frameCapturer: context.frameCapturer,
+							provider: context.provider,
+							config: context.config,
+							currentMode: context.currentMode,
+							detectionArea: context.detectionArea ?? context.config.detectionArea,
+							optimizingAfterMs: context.captureWindowMs
+						})
+					}],
+					on: {
+						DETECTION_SUCCESS: {
+							target: "capturing",
+							actions: assign({ qualityElements: ({ event }) => event.qualityElements })
+						},
+						DETECTION_RESET_READY: { actions: assign({ resetDetection: ({ event }) => event.reset }) },
+						ID_TYPE_CHANGE: { actions: "setIdType" },
+						ORIENTATION_CHANGE: { actions: "setOrientation" },
+						MANUAL_CAPTURE: { target: "#idCapture.capture.capturingManual" },
+						SWITCH_TO_MANUAL_CAPTURE: {
+							target: "#idCapture.capture.manualCaptureWaiting",
+							actions: assign({
+								detectionStatus: () => "manualCapture",
+								manualCaptureTriggered: () => true
+							})
+						}
+					},
+					initial: "searching",
+					states: {
+						searching: { on: {
+							DETECTION_UPDATE: { actions: "setDetectionStatus" },
+							ID_SIDE_CHANGE: { actions: assign({ detectionStatus: ({ context, event }) => getDetectionStatusFromSideChange(context, event.side) }) },
+							BARCODE_DECODED: [{
+								target: "#idCapture.capture.capturingBarcode",
+								guard: "canRunBarcodeFastPath",
+								actions: ["storeDecodedBarcode", "setBarcodeFastPathAttempted"]
+							}, { actions: "storeDecodedBarcode" }],
+							DETECTION_OPTIMIZING: {
+								target: "optimizing",
+								guard: "hasCandidateFrame",
+								actions: "setCandidateFrame"
+							}
+						} },
+						optimizing: {
+							exit: "clearOptimizingPhase",
+							on: {
+								BARCODE_DECODED: { actions: "storeDecodedBarcode" },
+								SWITCH_TO_MANUAL_CAPTURE: {
+									guard: "hasStashedCommit",
+									target: "#idCapture.capture.detectingWithOptimization.optimizing.released"
+								},
+								MANUAL_CAPTURE: {
+									guard: "hasStashedCommit",
+									target: "#idCapture.capture.detectingWithOptimization.optimizing.released"
+								}
+							},
+							initial: "holding",
+							states: {
+								holding: {
+									after: { optimizingDwell: { target: "released" } },
+									on: { DETECTION_SUCCESS: { actions: "stashCommittedFrame" } }
+								},
+								released: {
+									entry: "releaseStashedCommit",
+									after: { optimizingGrace: {
+										target: "#idCapture.capture.detectingWithOptimization.searching",
+										actions: assign({ detectionStatus: () => "detecting" })
+									} }
+								}
+							}
+						}
+					}
+				},
 				manualCaptureWaiting: { on: { MANUAL_CAPTURE: { target: "capturingManual" } } },
 				capturing: {
 					entry: [
@@ -2410,14 +2809,6 @@ const idCaptureMachine = setup({
 							target: "submittingBarcode",
 							guard: and(["hasCapturedImage", "shouldSubmitBarcode"])
 						},
-						{
-							target: "resultPreview",
-							guard: and([
-								"hasCapturedImage",
-								"isCaptureResultPreviewMode",
-								"supportsCaptureResultPreview"
-							])
-						},
 						{
 							target: "uploading",
 							guard: "hasCapturedImage"
@@ -2431,7 +2822,6 @@ const idCaptureMachine = setup({
 						}
 					]
 				},
-				resultPreview: { on: { RESULT_PREVIEW_COMPLETE: { target: "uploading" } } },
 				submittingBarcode: { invoke: {
 					id: "submitBarcode",
 					src: "submitBarcode",
@@ -2467,7 +2857,7 @@ const idCaptureMachine = setup({
 						target: "success",
 						actions: ["storeBarcodeResponse", "markBarcodeFastPathCaptured"]
 					},
-					onError: { target: "detecting" }
+					onError: { target: "choosingDetectionStrategy" }
 				} },
 				capturingManual: {
 					entry: [
@@ -2477,11 +2867,11 @@ const idCaptureMachine = setup({
 					],
 					always: [
 						{
-							target: "resultPreview",
+							target: "optimizingHold",
 							guard: and([
 								"hasCapturedImage",
-								"isCaptureResultPreviewMode",
-								"supportsCaptureResultPreview"
+								"isCaptureOptimizingMode",
+								"supportsOptimizingStatus"
 							])
 						},
 						{
@@ -2497,6 +2887,7 @@ const idCaptureMachine = setup({
 						}
 					]
 				},
+				optimizingHold: { after: { optimizingDwell: { target: "uploading" } } },
 				uploading: {
 					entry: assign({ uploadProgress: () => 0 }),
 					invoke: [{
@@ -2691,7 +3082,7 @@ const idCaptureMachine = setup({
 				}
 			},
 			onDone: [{
-				target: "#idCapture.capture.detecting",
+				target: "#idCapture.capture.choosingDetectionStrategy",
 				guard: "hasStream",
 				actions: "clearFlipPreview"
 			}, {
@@ -2743,7 +3134,7 @@ const idCaptureMachine = setup({
 				}
 			},
 			onDone: [{
-				target: "#idCapture.capture.detecting",
+				target: "#idCapture.capture.choosingDetectionStrategy",
 				guard: "hasStream",
 				actions: "clearFlipPreview"
 			}, {