@incodetech/core 2.3.0-rc.1 → 2.3.0-rc.10

package/dist/{idCaptureServices-i1KxugN7.esm.js → idCaptureServices-DLqls7Xv.esm.js}

@@ -1,15 +1,15 @@
-import { t as ensureWasmPipelines } from "./setup-BWG-hivt.esm.js";
-import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-E0mq0pMs.esm.js";
+import { t as ensureWasmPipelines } from "./setup-D4YCSH31.esm.js";
+import { i as numberParam, n as defineExperimentParams, t as booleanParam, u as resolveExperimentOnce } from "./feature-management-C8OAO_CZ.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as isDesktop } from "./platform-DkcRc9JV.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { s as queryCameraPermission } from "./permissionServices-Bj_fyWtv.esm.js";
-import { a as isBackFacingTrack, n as getBackCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
+import { s as queryCameraPermission } from "./permissionServices-EY3_Vx6c.esm.js";
+import { n as CameraCompositor, t as MultipartRecordingService } from "./multipartRecordingService-YKu0Bd7S.esm.js";
+import { a as isBackFacingTrack, n as getBackCameraStream } from "./backCameraStream-B0-YgP_y.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
-import { t as MultipartRecordingService } from "./multipartRecordingService-OEgIRvqC.esm.js";
-import { i as CameraCompositor, n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-CbPA-Auz.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-sJahGQgV.esm.js";
 //#region src/internal/camera/cameraServices.ts
 function createCameraServices(camera) {
 	return {
@@ -577,6 +577,7 @@ function createMultipartSessionHandle(service, compositor, recordingSource) {
 		needsVideoSourceReplacement: false,
 		recorderPaused: false,
 		recordingSource,
+		audioSource: recordingSource.getAudioTracks(),
 		service
 	});
 	return session;
@@ -620,21 +621,62 @@ function prepareRecordingForCameraRetry(session) {
 	const multipartSession = multipartIdSessions.get(session);
 	if (!multipartSession) return;
 	if (!multipartSession.recorderPaused) multipartSession.recorderPaused = multipartSession.service.pause();
-	multipartSession.compositor.pause();
-	multipartSession.recordingSource.getVideoTracks().forEach((track) => track.stop());
+	releaseCameraClone(multipartSession, { keepAudio: true });
 	multipartSession.needsVideoSourceReplacement = true;
 }
 /**
-* Fully drains an ID recording before the protected camera cycle runs POC.
-* Every recorder clone is stopped before this promise settles.
+* Resumes a recording paused with `pauseRecordingForAttempt` while its camera
+* clone is still attached (no source replacement pending). Returns whether the
+* recorder is recording again.
+*/
+function resumeRecordingAfterPause(session) {
+	const multipartSession = multipartIdSessions.get(session);
+	if (!multipartSession || multipartSession.needsVideoSourceReplacement) return false;
+	if (!multipartSession.recorderPaused) return true;
+	if (!multipartSession.service.resume()) return false;
+	multipartSession.recorderPaused = false;
+	return true;
+}
+/**
+* True only for a live SDK-managed multipart session. A session that has
+* already been finalized or disposed is no longer in the registry, so callers
+* use this to avoid resuming or re-pausing a torn-down recording.
+*/
+function isSuspendableRecordingSession(session) {
+	return multipartIdSessions.has(session);
+}
+/**
+* Ends the compositor's camera clone on the calling thread. The composite
+* stream and its upload stay alive; only the tracks that pin the physical
+* camera end. `keepAudio` preserves the compositor's audio track across a
+* video-source swap. Every release path must call this before any async work
+* so no camera clone can overlap a PRC or POC camera switch (ENG-47407) or pin
+* the device for the next module (ENG-56648).
+*/
+function releaseCameraClone(multipartSession, options) {
+	try {
+		multipartSession.compositor.pause();
+	} catch {}
+	const tracks = options.keepAudio ? multipartSession.recordingSource.getVideoTracks() : /* @__PURE__ */ new Set([...multipartSession.recordingSource.getTracks(), ...multipartSession.audioSource]);
+	for (const track of tracks) try {
+		track.stop();
+	} catch {}
+}
+/**
+* Completes an ID recording: drains the multipart upload and releases the
+* compositor. The camera clone ends synchronously, before this function
+* returns its promise, so a step that ends mid-attempt never pins the camera
+* while the upload finishes (ENG-56648). The composite canvas stays alive until
+* the recorder has emitted its final chunk.
 */
 async function finalizeRecordingSession(session) {
 	const existing = idRecordingFinalizations.get(session);
 	if (existing) return existing;
 	const multipartSession = multipartIdSessions.get(session);
 	if (!multipartSession) return {};
+	multipartIdSessions.delete(session);
+	releaseCameraClone(multipartSession, { keepAudio: false });
 	const finalization = (async () => {
-		multipartIdSessions.delete(session);
 		try {
 			return await multipartSession.service.stop();
 		} finally {
@@ -644,11 +686,16 @@ async function finalizeRecordingSession(session) {
 	idRecordingFinalizations.set(session, finalization);
 	return finalization;
 }
-/** Synchronous teardown used when an attempt is cancelled before finalization. */
+/**
+* Teardown for an attempt released before finalization. The camera clone ends
+* synchronously, before this function returns; the upload completes in the
+* background with whatever was recorded.
+*/
 function disposeRecordingSession(session) {
 	const multipartSession = multipartIdSessions.get(session);
 	if (multipartSession) {
 		multipartIdSessions.delete(session);
+		releaseCameraClone(multipartSession, { keepAudio: false });
 		const finalization = multipartSession.service.stop().finally(() => multipartSession.compositor.stop());
 		idRecordingFinalizations.set(session, finalization);
 		finalization.catch(() => {});
@@ -732,4 +779,4 @@ async function addBarcode(params) {
 	return res.data;
 }
 //#endregion
-export { resolveCaptureOptimizingTreatment as _, getRealQualityValue as a, OPTIMIZING_WATCHDOG_MARGIN_MS as b, prepareRecordingForCameraRetry as c, stopRecording as d, stopStream as f, ID_ERROR_CODES as g, validateUploadResponse as h, finalizeRecordingSession as i, processId as l, uploadManualIdFile as m, barcodeToBase64 as n, initializeIdCapture as o, uploadIdImage as p, disposeRecordingSession as r, pauseRecordingForAttempt as s, addBarcode as t, startRecordingSession as u, resolveIdCaptureThresholds as v, getIdCameraStream as x, CAPTURE_OPTIMIZING as y };
+export { getIdCameraStream as C, OPTIMIZING_WATCHDOG_MARGIN_MS as S, validateUploadResponse as _, getRealQualityValue as a, resolveIdCaptureThresholds as b, pauseRecordingForAttempt as c, resumeRecordingAfterPause as d, startRecordingSession as f, uploadManualIdFile as g, uploadIdImage as h, finalizeRecordingSession as i, prepareRecordingForCameraRetry as l, stopStream as m, barcodeToBase64 as n, initializeIdCapture as o, stopRecording as p, disposeRecordingSession as r, isSuspendableRecordingSession as s, addBarcode as t, processId as u, ID_ERROR_CODES as v, CAPTURE_OPTIMIZING as x, resolveCaptureOptimizingTreatment as y };

package/dist/{idCaptureStateMachine-Ne_PXth_.esm.js → idCaptureStateMachine-CCPGFPRF.esm.js}

@@ -1,31 +1,31 @@
-import { l as BrowserStorageProvider } from "./setup-BWG-hivt.esm.js";
-import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, m as isTrueSightTesting, r as noteTrueSightCaptureActivity } from "./trueSightService-D8yZwF3G.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-BdU9_m2E.esm.js";
+import { l as BrowserStorageProvider } from "./setup-D4YCSH31.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { s as exposeExperimentOnce } from "./feature-management-E0mq0pMs.esm.js";
+import { s as exposeExperimentOnce } from "./feature-management-C8OAO_CZ.esm.js";
 import { n as revokeObjectURL, t as getTimestamp } 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, m as isTrueSightTesting, r as noteTrueSightCaptureActivity } from "./trueSightService-BN-Hzw82.esm.js";
 import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-ijlbX_Wx.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-BFk33E67.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-BK5NjMe0.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
 import { a as isIOS, s as isIPad, t as isAndroid, u as isMacOsSafari } from "./platform-DkcRc9JV.esm.js";
-import "./session-3LmvAU4S.esm.js";
+import "./session-BABCfUhC.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 getUrlSearchParam, t as buildUrlWithSearchParams } from "./urlUtils-D6phjq1-.esm.js";
 import { r as getCameraReacquisitionConstraints } from "./camera-sIa9ceW2.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-Bj_fyWtv.esm.js";
-import { i as imageFileToDataUrl, n as runProtectedAttempt, o as flagIdManualReview, r as cameraCycleProvider, s as PROTECTED_CAPTURE_TARGET, t as createCameraCycleOwnership } from "./createCameraCycleOwnership-CX3hJGKc.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-EY3_Vx6c.esm.js";
+import { i as imageFileToDataUrl, n as runProtectedAttempt, o as flagIdManualReview, r as cameraCycleProvider, s as PROTECTED_CAPTURE_TARGET, t as createCameraCycleOwnership } from "./createCameraCycleOwnership-DnwTl1ad.esm.js";
 import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-uYZYFu4J.esm.js";
-import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-D6TfVop2.esm.js";
+import { i as StreamCanvasProcessingSession } from "./multipartRecordingService-YKu0Bd7S.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
 import { n as runVirtualCameraCheck, t as frameSources } from "./virtualCameraCheck-Cjab7FTI.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-CbPA-Auz.esm.js";
-import { a as getRealQualityValue, b as OPTIMIZING_WATCHDOG_MARGIN_MS, c as prepareRecordingForCameraRetry, d as stopRecording, f as stopStream, g as ID_ERROR_CODES, h as validateUploadResponse, i as finalizeRecordingSession, l as processId, m as uploadManualIdFile, o as initializeIdCapture, p as uploadIdImage, r as disposeRecordingSession, t as addBarcode, u as startRecordingSession, v as resolveIdCaptureThresholds, x as getIdCameraStream, y as CAPTURE_OPTIMIZING } from "./idCaptureServices-i1KxugN7.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider } from "./idCaptureDefaults-sJahGQgV.esm.js";
+import { C as getIdCameraStream, S as OPTIMIZING_WATCHDOG_MARGIN_MS, _ as validateUploadResponse, a as getRealQualityValue, b as resolveIdCaptureThresholds, c as pauseRecordingForAttempt, d as resumeRecordingAfterPause, f as startRecordingSession, g as uploadManualIdFile, h as uploadIdImage, i as finalizeRecordingSession, l as prepareRecordingForCameraRetry, m as stopStream, o as initializeIdCapture, p as stopRecording, r as disposeRecordingSession, s as isSuspendableRecordingSession, t as addBarcode, u as processId, v as ID_ERROR_CODES, x as CAPTURE_OPTIMIZING } from "./idCaptureServices-DLqls7Xv.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.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"]);
@@ -1781,7 +1781,7 @@ fromPromise(async ({ input }) => {
 });
 fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-DDv3vhXU.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-DamOBrBJ.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,
@@ -2224,7 +2224,7 @@ function cleanup(service) {
 		service.cleanup();
 	} catch {}
 }
-function createIdMetadataPreparationCoordinator(load = async (input) => (await import("./deepsightLoader-DDv3vhXU.esm.js")).loadDeepsightSession(input)) {
+function createIdMetadataPreparationCoordinator(load = async (input) => (await import("./deepsightLoader-DamOBrBJ.esm.js")).loadDeepsightSession(input)) {
 	let disposed = false;
 	let preparation;
 	let service;
@@ -2325,6 +2325,16 @@ function createIdProtectedCaptureController(dependencies = {}) {
 	let attemptContext;
 	let attemptSend;
 	let diagnosticAttempt;
+	const stepRecording = { retryPending: false };
+	const recordingScopeFor = (context) => context.currentMode === "back" ? "backId" : "frontId";
+	const completeStepRecording = () => {
+		const session = stepRecording.session;
+		stepRecording.session = void 0;
+		stepRecording.scope = void 0;
+		stepRecording.retryPending = false;
+		if (!session) return;
+		finalizeRecordingSession(session).catch(() => {});
+	};
 	const logDiagnostic = (event, fields = {}) => {
 		if (!diagnosticAttempt) return;
 		logIdCameraDiagnostic(event, {
@@ -2455,6 +2465,7 @@ function createIdProtectedCaptureController(dependencies = {}) {
 		beginAttempt(context, send) {
 			if (disposed) throw new Error("ID protected capture controller is disposed");
 			clearAttempt();
+			if (stepRecording.session && stepRecording.scope !== recordingScopeFor(context)) completeStepRecording();
 			diagnosticAttempt = {
 				attempt: ++protectedIdAttemptSequence,
 				side: context.currentMode === "back" ? "back" : "front",
@@ -2462,7 +2473,7 @@ function createIdProtectedCaptureController(dependencies = {}) {
 			};
 			attemptContext = context;
 			attemptSend = send;
-			provider = (dependencies.createProvider ?? createProtectedIdProvider)(context.config);
+			provider = (dependencies.createProvider ?? createProtectedIdProvider)(context.config, context.currentMode);
 			cycleOwnership = createCameraCycleOwnership(cameraCycleProvider);
 			logDiagnostic("attempt-start", { aggregationMs: context.config?.thresholds?.framesAggregationInterval ?? DEFAULT_ID_CAPTURE_THRESHOLDS.framesAggregationInterval });
 		},
@@ -2492,6 +2503,27 @@ function createIdProtectedCaptureController(dependencies = {}) {
 			metadataCoordinator.dispose();
 			releasePreAcquired();
 			clearAttempt();
+			completeStepRecording();
+		},
+		getStepRecording() {
+			return stepRecording;
+		},
+		keepRecordingForRetry() {
+			stepRecording.retryPending = true;
+		},
+		completeStepRecording,
+		endRecordingStep() {
+			if (stepRecording.retryPending) {
+				stepRecording.retryPending = false;
+				return;
+			}
+			completeStepRecording();
+		},
+		pauseStepRecording() {
+			if (stepRecording.session) pauseRecordingForAttempt(stepRecording.session);
+		},
+		resumeStepRecording() {
+			if (stepRecording.session) resumeRecordingAfterPause(stepRecording.session);
 		},
 		preAcquire,
 		setVisible(nextVisible) {
@@ -2722,7 +2754,8 @@ function createIdCaptureOnlyDeliveryActor(ownedController) {
 	});
 }
 let protectedIdAttemptSequence = 0;
-function resolveProtectedIdWorkflow(config) {
+function resolveProtectedIdWorkflow(config, currentMode) {
+	if (config.usSmartCapture === true && (currentMode === "back" || currentMode === "front" && config.modelVersion !== "v3")) return 0;
 	if (config.modelVersion === "v3" || config.usSmartCapture === true) return 7;
 	if (config.settings?.faceQualityCheckEnabled === true) return 8;
 	if (config.settings?.faceQualityCheckEnabled === false) return 6;
@@ -2734,37 +2767,122 @@ function resolveProtectedIdTarget(config, currentMode) {
 	if (config.isSecondId === true) return back ? PROTECTED_CAPTURE_TARGET.backSecondId : PROTECTED_CAPTURE_TARGET.frontSecondId;
 	return back ? PROTECTED_CAPTURE_TARGET.backId : PROTECTED_CAPTURE_TARGET.frontId;
 }
-function createProtectedIdProvider(config) {
-	const workflow = resolveProtectedIdWorkflow(config);
+function createProtectedIdProvider(config, currentMode) {
+	const workflow = resolveProtectedIdWorkflow(config, currentMode);
 	return workflow === 0 ? new IdCaptureProvider() : new IdCaptureProvider(workflow);
 }
+/**
+* Recorder hooks for one protected ID attempt over a step-scoped recording.
+*
+* The attempt never completes the scoped upload. It starts or resumes the held
+* session after PRC, pauses it and ends its camera clone synchronously when the
+* capture is committed (before POC), and suspends it the same way on release.
+* The controller completes the upload when the backend accepts the capture or
+* when the step ends without a retry (ENG-56648). A session that is no longer
+* live — already finalized or disposed — cannot be paused, so it is dropped and
+* torn down instead.
+*/
 function createProtectedIdRecorderHooks(input) {
-	let session;
+	const holder = input.stepRecording ?? { retryPending: false };
+	const scope = input.currentMode === "back" ? "backId" : "frontId";
 	const enabled = input.enabled !== false && input.config.enableIdRecording === true;
+	let disposed = false;
+	const dropHeldSession = () => {
+		const session = holder.session;
+		holder.session = void 0;
+		holder.scope = void 0;
+		return session;
+	};
+	/**
+	* Ends the camera clone on the calling thread and keeps the paused upload for
+	* the next attempt. Idempotent; never finalizes a multipart session.
+	*/
+	const suspend = () => {
+		const session = holder.session;
+		if (!session) return;
+		if (!isSuspendableRecordingSession(session)) {
+			dropHeldSession();
+			disposeRecordingSession(session);
+			return;
+		}
+		try {
+			prepareRecordingForCameraRetry(session);
+		} catch {}
+	};
+	const warn = (message) => {
+		trueSightLog("warning", "recording", "idScan", message);
+	};
 	return {
 		mode: enabled ? "finalizeBeforePoc" : "none",
 		async start(stream) {
 			if (!enabled) return;
-			session = await startRecordingSession({
-				config: input.config,
-				stream,
-				type: input.currentMode === "back" ? "backId" : "frontId"
-			});
+			if (holder.session && holder.scope !== scope) {
+				const stale = dropHeldSession();
+				if (stale) disposeRecordingSession(stale);
+			}
+			const existing = holder.session;
+			let session;
+			try {
+				session = await startRecordingSession({
+					config: input.config,
+					stream,
+					type: scope,
+					existing
+				});
+			} catch (error) {
+				if (existing) {
+					suspend();
+					warn("ID recording did not resume for this attempt");
+					return;
+				}
+				throw error;
+			}
+			if (disposed) {
+				if (session && session !== existing) disposeRecordingSession(session);
+				else suspend();
+				return;
+			}
+			if (session) {
+				holder.session = session;
+				holder.scope = scope;
+			}
 		},
 		async prepareForPoc() {
+			const session = holder.session;
 			if (!session) return {};
-			const currentSession = session;
-			session = void 0;
-			return finalizeRecordingSession(currentSession);
+			if (!isSuspendableRecordingSession(session)) {
+				dropHeldSession();
+				return finalizeRecordingSession(session);
+			}
+			suspend();
+			return {};
 		},
 		async resumeAfterPoc() {},
-		pauseForBackground() {},
-		async resumeFromBackground() {},
+		pauseForBackground() {
+			suspend();
+		},
+		async resumeFromBackground(stream) {
+			const existing = holder.session;
+			if (!enabled || disposed || !existing || holder.scope !== scope || !isSuspendableRecordingSession(existing)) return;
+			try {
+				await startRecordingSession({
+					config: input.config,
+					stream,
+					type: scope,
+					existing
+				});
+			} catch {
+				suspend();
+				warn("ID recording did not resume after foreground");
+			}
+		},
 		dispose() {
-			input.disposeCaptureCallbacks();
-			if (!session) return;
-			disposeRecordingSession(session);
-			session = void 0;
+			disposed = true;
+			try {
+				input.disposeCaptureCallbacks();
+			} finally {
+				suspend();
+			}
 		}
 	};
 }
@@ -2939,7 +3057,7 @@ function createProtectedIdAttemptInput(input) {
 	const { context, controller } = input;
 	const provider = controller.getProvider();
 	if (!provider) throw new Error("Protected ID provider is unavailable");
-	const workflow = resolveProtectedIdWorkflow(context.config);
+	const workflow = resolveProtectedIdWorkflow(context.config, context.currentMode);
 	const target = resolveProtectedIdTarget(context.config, context.currentMode);
 	const callbackSession = createProtectedIdCallbackSession(input);
 	let wasmUtil;
@@ -2995,7 +3113,8 @@ function createProtectedIdAttemptInput(input) {
 			config: context.config,
 			currentMode: context.currentMode,
 			disposeCaptureCallbacks: callbackSession.dispose,
-			enabled: !captureOnly
+			enabled: !captureOnly,
+			stepRecording: controller.getStepRecording()
 		}),
 		releaseUnadoptedStream: stopStream,
 		beforeAdopt: captureOnly ? void 0 : async (stream) => {
@@ -3788,6 +3907,21 @@ const idCaptureMachine = setup({
 		clearProtectedAttempt: ({ self }) => {
 			getIdProtectedCaptureController(self).clearAttempt();
 		},
+		keepProtectedRecordingForRetry: ({ self }) => {
+			getIdProtectedCaptureController(self).keepRecordingForRetry();
+		},
+		completeProtectedRecording: ({ self }) => {
+			getIdProtectedCaptureController(self).completeStepRecording();
+		},
+		endProtectedRecordingStep: ({ self }) => {
+			getIdProtectedCaptureController(self).endRecordingStep();
+		},
+		pauseProtectedRecording: ({ self }) => {
+			getIdProtectedCaptureController(self).pauseStepRecording();
+		},
+		resumeProtectedRecording: ({ self }) => {
+			getIdProtectedCaptureController(self).resumeStepRecording();
+		},
 		disposeProvider: ({ context }) => {
 			performDisposeProvider(context);
 		},
@@ -4553,6 +4687,7 @@ const idCaptureMachine = setup({
 			exit: [
 				"stopMediaRecording",
 				"clearRecordingSession",
+				"endProtectedRecordingStep",
 				"clearProtectedAttempt"
 			],
 			invoke: {
@@ -4592,7 +4727,7 @@ const idCaptureMachine = setup({
 					always: "#idCapture.closed"
 				},
 				releasingForRetry: {
-					entry: "releaseProtectedForRetry",
+					entry: ["keepProtectedRecordingForRetry", "releaseProtectedForRetry"],
 					always: {
 						target: "#idCapture.capture",
 						reenter: true
@@ -4760,21 +4895,27 @@ const idCaptureMachine = setup({
 					onError: { target: "uploading" }
 				} },
 				capturingBarcode: { 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: "choosingDetectionStrategy" }
-				} },
+				submittingBarcodePreCapture: {
+					entry: "pauseProtectedRecording",
+					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: "choosingDetectionStrategy",
+							actions: "resumeProtectedRecording"
+						}
+					}
+				},
 				capturingManual: {
 					entry: "finalizeProtectedAttempt",
 					on: { PROTECTED_ATTEMPT_FINALIZED_SIGNAL: [
@@ -4888,32 +5029,36 @@ const idCaptureMachine = setup({
 					},
 					{ target: "success" }
 				] },
-				uploadError: { on: { CONTINUE_FROM_ERROR: [
-					{
-						target: "releasingForRetry",
-						guard: "hasAttemptsRemaining",
-						actions: [
-							"resetDetection",
-							"clearUploadFailure",
-							"clearStreamForRetry"
-						]
-					},
-					{
-						target: "#idCapture.frontFinished",
-						guard: "shouldContinueToBack",
-						actions: ["flagIdManualReview"]
-					},
-					{
-						target: "#idCapture.backFinished",
-						guard: "shouldContinueToFront",
-						actions: ["flagIdManualReview"]
-					},
-					{
-						target: "#idCapture.processing",
-						actions: ["flagIdManualReview"]
-					}
-				] } },
+				uploadError: {
+					entry: "pauseProtectedRecording",
+					on: { CONTINUE_FROM_ERROR: [
+						{
+							target: "releasingForRetry",
+							guard: "hasAttemptsRemaining",
+							actions: [
+								"resetDetection",
+								"clearUploadFailure",
+								"clearStreamForRetry"
+							]
+						},
+						{
+							target: "#idCapture.frontFinished",
+							guard: "shouldContinueToBack",
+							actions: ["flagIdManualReview"]
+						},
+						{
+							target: "#idCapture.backFinished",
+							guard: "shouldContinueToFront",
+							actions: ["flagIdManualReview"]
+						},
+						{
+							target: "#idCapture.processing",
+							actions: ["flagIdManualReview"]
+						}
+					] }
+				},
 				success: {
+					entry: "completeProtectedRecording",
 					exit: "clearBarcodeFastPathCaptured",
 					on: { NEXT_STEP: [
 						{

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as isConfigured, l as setup, o as reset, t as SetupOptions } from "./setup-Cv-JM9QC.js";
+import { a as isConfigured, l as setup, o as reset, t as SetupOptions } from "./setup-Cyko6cAn.js";
 export { type SetupOptions, isConfigured, reset, setup };

package/dist/index.esm.js

@@ -1,2 +1,2 @@
-import { i as reset, r as isConfigured, s as setup } from "./setup-BWG-hivt.esm.js";
+import { i as reset, r as isConfigured, s as setup } from "./setup-D4YCSH31.esm.js";
 export { isConfigured, reset, setup };

package/dist/mandatory-consent.d.ts

@@ -1,3 +1,3 @@
 import { r as MandatoryConsentConfig } from "./types-9_esGTPj.js";
-import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-vhv1co_n.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-CJSyhTpi.js";
 export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/{mandatoryConsentManager-vhv1co_n.d.ts → mandatoryConsentManager-CJSyhTpi.d.ts}

@@ -57,6 +57,10 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "setError";
     params: NonReducibleUnknown;
   };
+  toggleSigned: {
+    type: "toggleSigned";
+    params: NonReducibleUnknown;
+  };
   clearError: {
     type: "clearError";
     params: NonReducibleUnknown;
@@ -65,10 +69,6 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "resetContext";
     params: NonReducibleUnknown;
   };
-  toggleSigned: {
-    type: "toggleSigned";
-    params: NonReducibleUnknown;
-  };
 }>, {
   type: "canSubmit";
   params: unknown;