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

package/dist/{faceCaptureSetup-BSextack.esm.js → faceCaptureSetup-CGQDK97m.esm.js}

@@ -1,21 +1,21 @@
+import { l as trueSightLog, m as isTrueSightTesting } from "./trueSightService-D8yZwF3G.esm.js";
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { r as getToken } from "./api-Bx3gKW_y.esm.js";
-import { l as trueSightLog, m as isTrueSightTesting } from "./trueSightService-CKrrfV0Q.esm.js";
-import "./sessionInitializer-BLoK7SP9.esm.js";
-import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
+import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
+import "./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 { 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-Bj_fyWtv.esm.js";
-import { a as sendLabelInspectionEvent, c as stopRecording, i as initializeDeepsightSession, l as stopStream, r as initializeCamera, s as startRecordingSession, t as FaceDetectionProvider } from "./FaceDetectionProvider-DTetAE8H.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-BZYHujqz.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-DQ5-F2oW.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 { 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-uYZYFu4J.esm.js";
-import { i as uploadDeepsightVideo } from "./recordingsRepository-CCWy13M-.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-D6TfVop2.esm.js";
+import { n as CameraCompositor, r as getAdaptiveMediaRecorderOptions, t as MultipartRecordingService } from "./multipartRecordingService-YKu0Bd7S.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-5NYZg9s6.esm.js";
-import { n as getAdaptiveMediaRecorderOptions, t as MultipartRecordingService } from "./multipartRecordingService-B3C_zlev.esm.js";
 //#region src/internal/avatar/concealment.ts
 /**
 * Maps a backend concealment option to the internal avatar flags. `OPTION_NONE`
@@ -496,7 +496,28 @@ var LocalRecordingProvider = class {
 			recorder?.stream?.getTracks().forEach((track) => track.stop());
 		});
 	}
+	/**
+	* Discards the in-progress recording without producing a result: detaches
+	* the recorder's handlers, stops it, releases its cloned tracks and clears
+	* the flags. Idempotent, and safe after `stopRecording` or when never
+	* started. Mirrors `MultipartRecordingProvider.reset()` so an attempt that is
+	* released before finalization cannot leave a live camera clone behind
+	* (ENG-56648).
+	*/
 	reset() {
+		this.removeEventListeners();
+		const recorder = this.mediaRecorder;
+		if (recorder) {
+			recorder.ondataavailable = null;
+			recorder.onerror = null;
+			recorder.onstop = null;
+			if (recorder.state !== "inactive") try {
+				recorder.stop();
+			} catch {}
+			recorder.stream?.getTracks().forEach((track) => track.stop());
+			this.mediaRecorder = null;
+		}
+		this.stream = null;
 		this._isRecording = false;
 		this._error = null;
 		this._hasError = false;
@@ -515,6 +536,18 @@ var LocalRecordingProvider = class {
 	}
 };
 //#endregion
+//#region src/internal/recordings/recordingsRepository.ts
+async function uploadDeepsightVideo(encryptedVideo, token) {
+	try {
+		return (await api.post(endpoints.deepsightVideoImport, {
+			video: encryptedVideo,
+			type: "selfie"
+		}, { headers: { "X-Incode-Hardware-Id": token } })).data.recordingId ?? "";
+	} catch {
+		return "";
+	}
+}
+//#endregion
 //#region src/internal/faceCapture/recordingService.ts
 /**
 * Records on-device and uploads encrypted video for liveness.
@@ -559,84 +592,146 @@ var LocalRecordingService = class {
 * the interview asynchronously by the backend's `selfie` scope consumer, so
 * its upload id must not be forwarded to `/omni/add/face` as a legacy
 * `recordingId`.
+*
+* The recording is scoped to the capture step (ENG-56648). The recorder
+* records a stable `CameraCompositor` stream instead of a raw camera clone, so
+* every attempt can end its own clone before PRC and POC run and the next
+* attempt swaps a fresh clone into the same multipart upload. The owning
+* controller completes the upload once the backend accepts a capture or the
+* step ends without a retry.
 */
 var MultipartFaceRecordingService = class {
 	constructor() {
 		this.service = new MultipartRecordingService("selfie");
+		this.audioSource = [];
+		this.needsVideoSourceReplacement = false;
 		this.pausedForAttempt = false;
+		this.startInFlight = false;
+		this.suspendRequested = false;
+		this.stopping = false;
 	}
 	async start(stream) {
-		if (this.pausedForAttempt) {
-			if (!this.service.resume()) throw new Error("Face recording did not resume");
-			this.pausedForAttempt = false;
+		if (this.stopping) throw new Error("Face recording already completed");
+		if (this.compositor) {
+			await this.resume(stream);
+			return;
+		}
+		const recordingSource = stream.clone();
+		const compositor = new CameraCompositor({ fps: 30 });
+		this.startInFlight = true;
+		try {
+			const composite = compositor.start(recordingSource);
+			await this.service.start(composite);
+		} catch (error) {
+			compositor.stop();
+			recordingSource.getTracks().forEach((track) => track.stop());
+			this.service.cleanup();
+			throw error;
+		} finally {
+			this.startInFlight = false;
+		}
+		if (this.stopping) {
+			compositor.stop();
+			recordingSource.getTracks().forEach((track) => track.stop());
+			this.service.cleanup();
+			return;
+		}
+		this.compositor = compositor;
+		this.recordingSource = recordingSource;
+		this.audioSource = recordingSource.getAudioTracks();
+		if (this.suspendRequested) {
+			this.suspendRequested = false;
+			this.suspend();
+		}
+	}
+	/**
+	* Pauses the container and ends the camera clone on the calling thread. The
+	* composite stream and the upload stay open for the next attempt.
+	*/
+	suspend() {
+		if (this.stopping) return;
+		if (!this.compositor) {
+			this.suspendRequested = this.startInFlight;
 			return;
 		}
-		await this.service.start(stream);
+		if (!this.pausedForAttempt) this.pausedForAttempt = this.service.pause();
+		this.releaseCameraClone({ keepAudio: true });
+		this.needsVideoSourceReplacement = true;
 	}
 	async prepareUpload() {
-		this.pausedForAttempt = this.service.pause();
+		this.suspend();
 		return { recordingId: null };
 	}
 	async stop() {
-		try {
-			await this.service.stop();
-		} finally {
-			this.pausedForAttempt = false;
-		}
+		await this.complete();
 		return { recordingId: null };
 	}
 	pauseForBackground() {
-		this.service.pause();
+		this.suspend();
 	}
-	async resumeFromBackground() {
-		this.service.resume();
+	async resumeFromBackground(stream) {
+		if (!this.compositor || this.stopping) return;
+		await this.resume(stream);
 	}
 	async stopAndGetVideo() {
-		try {
-			await this.service.stop();
-		} finally {
-			this.pausedForAttempt = false;
-		}
+		await this.complete();
 		return { videoBase64: void 0 };
 	}
 	cleanup() {
+		this.suspendRequested = false;
 		this.pausedForAttempt = false;
+		this.needsVideoSourceReplacement = false;
+		this.releaseCameraClone({ keepAudio: false });
+		this.compositor?.stop();
+		this.compositor = void 0;
+		this.recordingSource = void 0;
+		this.audioSource = [];
 		this.service.cleanup();
 	}
-};
-/**
-* Records through a consumer-injected remote provider and manages its session.
-*/
-var InjectedRecordingService = class {
-	constructor(config) {
-		this.config = config;
-	}
-	async start(stream) {
-		if (this.session) return;
-		this.session = await startRecordingSession({
-			config: this.config,
-			clonedStream: stream.clone()
-		});
-	}
-	async prepareUpload() {
-		return { recordingId: null };
-	}
-	async stop() {
-		if (this.session) {
-			stopRecording(this.session);
-			this.session = void 0;
+	/** Swaps this attempt's camera clone into the composite and resumes. */
+	async resume(stream) {
+		const compositor = this.compositor;
+		if (!compositor) return;
+		if (this.needsVideoSourceReplacement) {
+			const recordingSource = stream.clone();
+			recordingSource.getAudioTracks().forEach((track) => track.stop());
+			compositor.switchVideo(recordingSource);
+			this.needsVideoSourceReplacement = false;
+			this.recordingSource = recordingSource;
+			const result = await compositor.resume();
+			if (result !== "resumed") throw new Error(`Face recording camera did not resume: ${result}`);
 		}
-		return { recordingId: null };
+		if (this.pausedForAttempt && !this.service.resume()) throw new Error("Face recording did not resume");
+		this.pausedForAttempt = false;
 	}
-	async stopAndGetVideo() {
-		if (this.session) {
-			stopRecording(this.session);
-			this.session = void 0;
+	/**
+	* Completes the scoped upload. The camera clone ends synchronously before the
+	* drain so a step that ends mid-attempt never pins the camera; the composite
+	* stays alive until the recorder has emitted its final chunk.
+	*/
+	async complete() {
+		this.stopping = true;
+		this.suspendRequested = false;
+		this.releaseCameraClone({ keepAudio: false });
+		try {
+			await this.service.stop();
+		} finally {
+			this.compositor?.stop();
+			this.compositor = void 0;
+			this.recordingSource = void 0;
+			this.audioSource = [];
+			this.pausedForAttempt = false;
+			this.needsVideoSourceReplacement = false;
 		}
-		return { videoBase64: void 0 };
 	}
-	cleanup() {
-		if (this.session) stopRecording(this.session);
+	releaseCameraClone(options) {
+		try {
+			this.compositor?.pause();
+		} catch {}
+		const tracks = options.keepAudio ? this.recordingSource?.getVideoTracks() ?? [] : /* @__PURE__ */ new Set([...this.recordingSource?.getTracks() ?? [], ...this.audioSource]);
+		for (const track of tracks) try {
+			track.stop();
+		} catch {}
 	}
 };
 /**
@@ -648,65 +743,100 @@ var InjectedRecordingService = class {
 *    JSON via `WebApi.postFaceResults`. Mirrors V1's
 *    `FaceFlowManager.setRecorders()` early return.
 * 2. `deepsightLiveness === 'VIDEOLIVENESS'` → local Deepsight recorder.
-* 3. `enableFaceRecording === true` → scoped multipart recorder. A custom
-*    injected recording capability remains supported for backwards-compatible
-*    dependency injection.
+* 3. `enableFaceRecording === true` → scoped multipart recorder.
 * 4. otherwise → no recording.
 */
 function createRecordingService(params) {
 	if (params.config.onDeviceFaceResultsSubmissionEnabled === true) return;
 	if (params.localDelivery === true) return params.config.enableFaceRecording === true || params.config.deepsightLiveness === "VIDEOLIVENESS" ? new LocalRecordingService(params.wasmUtil, null) : void 0;
 	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return new LocalRecordingService(params.wasmUtil, params.sessionToken);
-	if (params.config.enableFaceRecording === true) return params.config.recording?.capability ? new InjectedRecordingService(params.config) : new MultipartFaceRecordingService();
+	if (params.config.enableFaceRecording === true) return new MultipartFaceRecordingService();
 }
 //#endregion
 //#region src/internal/faceCapture/protectedFaceAttempt.ts
 const ON_DEVICE_MANUAL_CAPTURE_TIMEOUT_MS = 2147483647;
+/**
+* Recorder hooks for one protected face attempt.
+*
+* The recording service comes from the owner of the capture step (the face
+* controller), so a step-scoped service (`suspend` present) is started or
+* resumed by every attempt, paused with its camera clone ended before POC, and
+* suspended again on release; only the controller completes it (ENG-56648).
+* Per-attempt services (local video liveness, capture-only video) keep their
+* stop-before-POC and cleanup-on-release behavior.
+*/
 var ProtectedFaceRecorderHooks = class {
-	constructor(config, dependencies, delivery) {
-		this.config = config;
-		this.dependencies = dependencies;
+	constructor(config, delivery, getRecordingService) {
 		this.delivery = delivery;
+		this.getRecordingService = getRecordingService;
+		this.disposed = false;
 		this.mode = config.onDeviceFaceResultsSubmissionEnabled === true || config.enableFaceRecording !== true && config.deepsightLiveness !== "VIDEOLIVENESS" ? "none" : "finalizeBeforePoc";
 	}
 	async start(unprotectedStream) {
 		if (this.mode === "none") return;
-		const wasmUtil = await this.dependencies.getWasmUtil();
-		this.service = createRecordingService({
-			config: this.config,
-			wasmUtil,
-			sessionToken: getToken(),
-			localDelivery: this.delivery === "local"
-		});
-		await this.service?.start(unprotectedStream);
+		const service = await this.getRecordingService();
+		if (!service) return;
+		this.service = service;
+		if (this.disposed) {
+			this.suspendOrCleanup();
+			return;
+		}
+		try {
+			await service.start(unprotectedStream);
+		} catch (error) {
+			if (service.suspend) {
+				service.suspend();
+				trueSightLog("warning", "recording", "faceScan", "face recording did not resume for this attempt");
+				return;
+			}
+			throw error;
+		}
+		if (this.disposed) this.suspendOrCleanup();
 	}
 	async prepareForPoc() {
-		if (!this.service) return {};
+		const service = this.service;
+		if (!service) return {};
 		if (this.delivery === "local") {
 			try {
-				const result = await this.service.stopAndGetVideo();
+				const result = await service.stopAndGetVideo();
 				this.captureOnlyVideoBase64 = result.videoBase64;
 			} catch {
 				this.captureOnlyVideoBase64 = void 0;
 			}
 			return {};
 		}
-		return this.service.stop();
+		if (service.suspend) return service.prepareUpload();
+		return service.stop();
 	}
 	async resumeAfterPoc() {}
 	pauseForBackground() {
 		this.service?.pauseForBackground?.();
 	}
 	async resumeFromBackground(unprotectedStream) {
-		await this.service?.resumeFromBackground?.(unprotectedStream);
+		const service = this.service;
+		if (!service?.resumeFromBackground || this.disposed) return;
+		try {
+			await service.resumeFromBackground(unprotectedStream);
+		} catch {
+			service.suspend?.();
+			trueSightLog("warning", "recording", "faceScan", "face recording did not resume after foreground");
+		}
 	}
 	dispose() {
+		this.disposed = true;
 		try {
-			this.service?.cleanup();
+			this.suspendOrCleanup();
 		} finally {
 			this.service = void 0;
 		}
 	}
+	/** Step-scoped services suspend (the owner completes them); others clean up. */
+	suspendOrCleanup() {
+		const service = this.service;
+		if (!service) return;
+		if (service.suspend) service.suspend();
+		else service.cleanup();
+	}
 	takeCaptureOnlyVideo() {
 		const video = this.captureOnlyVideoBase64;
 		this.captureOnlyVideoBase64 = void 0;
@@ -730,9 +860,19 @@ var ProtectedFaceAttemptRuntime = class ProtectedFaceAttemptRuntime {
 		this.recorderTransferred = false;
 		this.pendingSignals = [];
 		this.provider = options.faceDetection;
-		this.recorder = new ProtectedFaceRecorderHooks(options.config, options.dependencies, options.delivery);
+		this.recorder = new ProtectedFaceRecorderHooks(options.config, options.delivery, options.getRecordingService ?? (() => this.createAttemptRecordingService()));
 		this.cycleOwnership = createCameraCycleOwnership(options.cycle);
 	}
+	/** Per-attempt fallback when no step owner supplies the recording service. */
+	async createAttemptRecordingService() {
+		const wasmUtil = await this.options.dependencies.getWasmUtil();
+		return createRecordingService({
+			config: this.options.config,
+			wasmUtil,
+			sessionToken: getToken(),
+			localDelivery: this.options.delivery === "local"
+		});
+	}
 	get delivery() {
 		return this.options.delivery;
 	}
@@ -998,6 +1138,8 @@ function createProtectedFaceControllerActor(options) {
 		let committedPreview;
 		let pendingAutoPreview;
 		let recording = {};
+		let stepRecording;
+		let stepRecordingPending;
 		let generation = 0;
 		let active = true;
 		let diagnosticAttempt = 0;
@@ -1016,6 +1158,48 @@ function createProtectedFaceControllerActor(options) {
 			if (!controllerInput) throw new Error("Protected face controller is not bound");
 			return controllerInput;
 		};
+		/**
+		* One recording service per capture step (ENG-56648). Every attempt of the
+		* step starts or resumes it; `completeStepRecording` completes it when the
+		* backend accepts a capture or the step ends without a retry.
+		*/
+		const getStepRecordingService = () => {
+			if (stepRecording) return Promise.resolve(stepRecording);
+			if (stepRecordingPending) return stepRecordingPending;
+			const input = getControllerInput();
+			const pending = (async () => {
+				const wasmUtil = await input.dependencies.getWasmUtil();
+				if (!active) return;
+				stepRecording ??= createRecordingService({
+					config: input.config,
+					wasmUtil,
+					sessionToken: getToken(),
+					localDelivery: options.delivery === "local"
+				});
+				return stepRecording;
+			})();
+			stepRecordingPending = pending;
+			pending.finally(() => {
+				if (stepRecordingPending === pending) stepRecordingPending = void 0;
+			});
+			return pending;
+		};
+		const completeStepRecording = () => {
+			const service = stepRecording;
+			stepRecording = void 0;
+			if (!service) return;
+			if (!service.suspend) {
+				try {
+					service.cleanup();
+				} catch {}
+				return;
+			}
+			service.stop().catch(() => void 0).finally(() => {
+				try {
+					service.cleanup();
+				} catch {}
+			});
+		};
 		const ensureRuntime = () => {
 			if (!runtime) {
 				const input = getControllerInput();
@@ -1031,7 +1215,8 @@ function createProtectedFaceControllerActor(options) {
 					acquireCamera: (provider) => initializeCamera({
 						config: input.config,
 						provider
-					})
+					}),
+					getRecordingService: getStepRecordingService
 				});
 				if (deepsightService) runtime.setDeepsightService(deepsightService);
 			}
@@ -1275,12 +1460,16 @@ function createProtectedFaceControllerActor(options) {
 				case "RESET":
 					releaseCurrent("retry");
 					return;
+				case "COMPLETE_RECORDING":
+					completeStepRecording();
+					return;
 				case "RELEASE": releaseCurrent(command.reason);
 			}
 		});
 		return () => {
 			active = false;
 			releaseCurrent("externalStop");
+			completeStepRecording();
 		};
 	});
 }
@@ -1484,7 +1673,6 @@ const faceCaptureMachine = setup({
 		flagFaceManualReview: () => {
 			flagFaceManualReview();
 		},
-		preloadRecordingProvider: () => void 0,
 		warmAvatarProvider: ({ context }) => {
 			const { obfuscateWithAvatar, avatarVariant } = concealmentToAvatar(context.config.selfieConcealmentOption);
 			if (!obfuscateWithAvatar || !avatarVariant) return;
@@ -1517,6 +1705,10 @@ const faceCaptureMachine = setup({
 			if (!isProtectedFaceControllerRunning(self)) return;
 			enqueue.sendTo("protectedFaceController", { type: "RESET" });
 		}),
+		completeProtectedRecording: enqueueActions(({ enqueue, self }) => {
+			if (!isProtectedFaceControllerRunning(self)) return;
+			enqueue.sendTo("protectedFaceController", { type: "COMPLETE_RECORDING" });
+		}),
 		sendProtectedAutoCapture: enqueueActions(({ enqueue, self, event }) => {
 			if (!isProtectedFaceControllerRunning(self)) return;
 			enqueue.sendTo("protectedFaceController", {
@@ -1632,11 +1824,7 @@ const faceCaptureMachine = setup({
 			{ target: "loading" }
 		] } },
 		loading: {
-			entry: [
-				"preloadRecordingProvider",
-				"warmAvatarProvider",
-				"initializeProtectedDeepsight"
-			],
+			entry: ["warmAvatarProvider", "initializeProtectedDeepsight"],
 			invoke: {
 				id: "checkPermissionLoading",
 				src: "checkPermission",
@@ -1652,11 +1840,7 @@ const faceCaptureMachine = setup({
 		},
 		tutorial: {
 			initial: "checkingPermission",
-			entry: [
-				"trackTutorial",
-				"preloadRecordingProvider",
-				"warmAvatarProvider"
-			],
+			entry: ["trackTutorial", "warmAvatarProvider"],
 			on: { GO_TO_MANUAL_UPLOAD: {
 				guard: "hasManualUploadEnabled",
 				target: "#faceCapture.manualUpload"
@@ -1775,11 +1959,7 @@ const faceCaptureMachine = setup({
 			}
 		},
 		permissions: {
-			entry: [
-				"preloadRecordingProvider",
-				"warmAvatarProvider",
-				"initializeProtectedDeepsight"
-			],
+			entry: ["warmAvatarProvider", "initializeProtectedDeepsight"],
 			initial: "checkingDeepsight",
 			states: {
 				checkingDeepsight: { always: [{
@@ -1873,7 +2053,6 @@ const faceCaptureMachine = setup({
 		},
 		capture: {
 			entry: [
-				"preloadRecordingProvider",
 				"warmAvatarProvider",
 				"initializeProtectedDeepsight",
 				"startProtectedAttempt"
@@ -2019,7 +2198,7 @@ const faceCaptureMachine = setup({
 					}
 				] } },
 				success: {
-					entry: "cleanup",
+					entry: ["completeProtectedRecording", "cleanup"],
 					after: { 3e3: { target: "#faceCapture.processing" } }
 				}
 			}
@@ -2065,7 +2244,7 @@ const faceCaptureMachine = setup({
 			onError: { target: "finished" }
 		} },
 		terminalProcessing: {
-			entry: "cleanup",
+			entry: ["completeProtectedRecording", "cleanup"],
 			invoke: {
 				id: "processFace",
 				src: "processFace",
@@ -2094,7 +2273,11 @@ const faceCaptureMachine = setup({
 			type: "final"
 		},
 		error: {
-			entry: ["stopMediaStream", "releaseAvatarWarmup"],
+			entry: [
+				"completeProtectedRecording",
+				"stopMediaStream",
+				"releaseAvatarWarmup"
+			],
 			on: { RESET: {
 				target: "idle",
 				actions: ["resetProtectedController", "resetContext"]

package/dist/{faceMatchManager-Caal2zyV.esm.js → faceMatchManager-Bmv0HzuY.esm.js}

@@ -1,6 +1,6 @@
 import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as faceMatchMachine } from "./faceMatchStateMachine-BUc5FXYy.esm.js";
+import { t as faceMatchMachine } from "./faceMatchStateMachine-mRIHQ3dA.esm.js";
 //#region src/modules/face-match/faceMatchActor.ts
 function createFaceMatchActor(options) {
 	return createActor(faceMatchMachine, { input: { config: options.config } }).start();

package/dist/{faceMatchStateMachine-BUc5FXYy.esm.js → faceMatchStateMachine-mRIHQ3dA.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.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";
 //#region src/modules/face-match/constants.ts

package/dist/{feature-management-B0sGlozZ.esm.js → feature-management-C8OAO_CZ.esm.js}

@@ -1,5 +1,5 @@
 import { n as __toESM } from "./rolldown-runtime-FDOR9p9I.esm.js";
-import { t as SDK_VERSION } from "./sdkVersion-CLxKvdyz.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-CD9fJC2Y.esm.js";
 import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
 let currentEnvironment;
 /** Effective tier: the explicitly-set value, else the default (see note above). */

package/dist/feature-management.esm.js

@@ -1,2 +1,2 @@
-import { E as updateFeatureManagementUser, T as subscribeFeatureManagement, _ as getIsFeatureManagementInitialized, a as stringParam, d as ONBOARDING_WEB_SDK_PARAMETER_STORE, f as getExperiment, g as getFeatureParameterStore, h as getFeatureManagementVersion, i as numberParam, l as resolveExperiment, m as getFeatureGate, n as defineExperimentParams, o as EXPERIMENT_UNAVAILABLE_SENTINEL, p as getFeatureDynamicConfig, r as enumParam, s as exposeExperimentOnce, t as booleanParam, u as resolveExperimentOnce, x as logEvent, y as getLayer } from "./feature-management-B0sGlozZ.esm.js";
+import { E as updateFeatureManagementUser, T as subscribeFeatureManagement, _ as getIsFeatureManagementInitialized, a as stringParam, d as ONBOARDING_WEB_SDK_PARAMETER_STORE, f as getExperiment, g as getFeatureParameterStore, h as getFeatureManagementVersion, i as numberParam, l as resolveExperiment, m as getFeatureGate, n as defineExperimentParams, o as EXPERIMENT_UNAVAILABLE_SENTINEL, p as getFeatureDynamicConfig, r as enumParam, s as exposeExperimentOnce, t as booleanParam, u as resolveExperimentOnce, x as logEvent, y as getLayer } from "./feature-management-C8OAO_CZ.esm.js";
 export { EXPERIMENT_UNAVAILABLE_SENTINEL, ONBOARDING_WEB_SDK_PARAMETER_STORE, booleanParam, defineExperimentParams, enumParam, exposeExperimentOnce, getExperiment, getFeatureDynamicConfig, getFeatureGate, getFeatureManagementVersion, getFeatureParameterStore, getIsFeatureManagementInitialized, getLayer, logEvent, numberParam, resolveExperiment, resolveExperimentOnce, stringParam, subscribeFeatureManagement, updateFeatureManagementUser };

package/dist/field-comparison.esm.js

@@ -1,2 +1,2 @@
-import { n as createFieldComparisonManagerFromActor, r as fieldComparisonMachine, t as createFieldComparisonManager } from "./fieldComparisonManager-BIs6HPJG.esm.js";
+import { n as createFieldComparisonManagerFromActor, r as fieldComparisonMachine, t as createFieldComparisonManager } from "./fieldComparisonManager-CC-klG0h.esm.js";
 export { createFieldComparisonManager, createFieldComparisonManagerFromActor, fieldComparisonMachine };

package/dist/{fieldComparisonManager-BIs6HPJG.esm.js → fieldComparisonManager-CC-klG0h.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
-import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 //#region src/modules/field-comparison/fieldComparisonServices.ts

package/dist/fiscal-qr.d.ts

@@ -1,2 +1,2 @@
-import { a as FiscalQrActor, i as createFiscalQrManagerFromActor, n as FiscalQrState, o as fiscalQrMachine, r as createFiscalQrManager, s as FiscalQrConfig, t as FiscalQrManager } from "./fiscalQrManager-CHcBJwUM.js";
+import { a as FiscalQrActor, i as createFiscalQrManagerFromActor, n as FiscalQrState, o as fiscalQrMachine, r as createFiscalQrManager, s as FiscalQrConfig, t as FiscalQrManager } from "./fiscalQrManager-B1STmT6z.js";
 export { type FiscalQrActor, type FiscalQrConfig, type FiscalQrManager, type FiscalQrState, createFiscalQrManager, createFiscalQrManagerFromActor, fiscalQrMachine };

package/dist/fiscal-qr.esm.js

@@ -1,2 +1,2 @@
-import { n as createFiscalQrManagerFromActor, r as fiscalQrMachine, t as createFiscalQrManager } from "./fiscalQrManager-Bp_-3LJr.esm.js";
+import { n as createFiscalQrManagerFromActor, r as fiscalQrMachine, t as createFiscalQrManager } from "./fiscalQrManager-DbCVMIBx.esm.js";
 export { createFiscalQrManager, createFiscalQrManagerFromActor, fiscalQrMachine };

package/dist/{fiscalQrManager-CHcBJwUM.d.ts → fiscalQrManager-B1STmT6z.d.ts}

@@ -20,6 +20,9 @@ type FiscalQrActor = ActorRefFrom<FiscalQrMachine>;
 type FiscalQrIdleState = {
   status: 'idle';
 };
+type FiscalQrPermissionDeniedState = {
+  status: 'permissionDenied';
+};
 type FiscalQrScanningState = {
   status: 'scanning';
   stream?: MediaStream;
@@ -48,7 +51,7 @@ type FiscalQrVerifiedState = {
 type FiscalQrFinishedState = {
   status: 'finished';
 };
-type FiscalQrState = FiscalQrIdleState | FiscalQrScanningState | FiscalQrCapturingState | FiscalQrSuccessState | FiscalQrProcessingState | FiscalQrErrorState | FiscalQrVerifiedState | FiscalQrFinishedState;
+type FiscalQrState = FiscalQrIdleState | FiscalQrPermissionDeniedState | FiscalQrScanningState | FiscalQrCapturingState | FiscalQrSuccessState | FiscalQrProcessingState | FiscalQrErrorState | FiscalQrVerifiedState | FiscalQrFinishedState;
 declare function createFiscalQrManager(options: {
   config: FiscalQrConfig;
 }): Manager<FiscalQrState> & {