@incodetech/core 2.4.1-agentic → 2.4.1-agentic.1

package/dist/{phoneManager-C6jut_pz.esm.js → phoneManager-Dy5tODCU.esm.js}

@@ -1,8 +1,8 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CQteqXfy.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { n as loadPhoneValidation, t as getPhoneValidation } from "./phoneValidation-OggtfjRt.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as isOtpComplete } from "./otp-D2k3PeSL.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-T1-drWfG.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-DnlPhnw7.esm.js";
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {
 	return createActor(phoneMachine, { input: { config: options.config } }).start();

package/dist/phoneServices-DJgyOzU2.esm.js

@@ -0,0 +1,77 @@
+import { r as getToken, t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+//#region src/modules/phone/phoneServices.ts
+function getPhoneServerFailureReason(error, invalidStatus) {
+	if (error.status === invalidStatus) return "invalidPhone";
+	return "serverError";
+}
+async function fetchPhone(signal) {
+	const res = await api.get(endpoints.getPhone, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.getPhone} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+async function requestStartInfo(signal) {
+	const res = await api.get(endpoints.startInfo, { signal });
+	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+let prefetchedStartInfo;
+/**
+* Starts the start-info request before the phone step runs (the flow calls
+* it when the step is first), so the step's first screen does not wait for
+* that round trip. The step's own `fetchStartInfo` uses the answer once.
+*/
+function prefetchStartInfo() {
+	const token = getToken();
+	if (!token || prefetchedStartInfo?.token === token) return;
+	const promise = requestStartInfo();
+	promise.catch(() => void 0);
+	prefetchedStartInfo = {
+		token,
+		promise
+	};
+}
+async function fetchStartInfo(signal) {
+	const prefetched = prefetchedStartInfo;
+	prefetchedStartInfo = void 0;
+	if (prefetched?.token === getToken()) {
+		const info = await prefetched.promise.catch(() => void 0);
+		if (info) return info;
+	}
+	return requestStartInfo(signal);
+}
+async function addPhone(params, signal) {
+	try {
+		return (await api.post(endpoints.phone, {
+			phone: params.phone,
+			optInGranted: params.optInGranted
+		}, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error, 400));
+	}
+}
+async function addPhoneInstantVerify(params, signal) {
+	try {
+		return (await api.post(endpoints.phoneInstant, {
+			phone: params.phone,
+			optInGranted: params.optInGranted
+		}, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error, 400));
+	}
+}
+async function sendOtp(signal) {
+	try {
+		await api.get(`${endpoints.sendSmsOtp}?communicationchannel=SMS`, { signal });
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error));
+	}
+}
+async function verifyOtp(code, signal) {
+	try {
+		return (await api.get(`${endpoints.compareOtp}?code=${code}&channel=SMS`, { signal })).data;
+	} catch (error) {
+		throw new Error(getPhoneServerFailureReason(error));
+	}
+}
+//#endregion
+export { prefetchStartInfo as a, fetchStartInfo as i, addPhoneInstantVerify as n, sendOtp as o, fetchPhone as r, verifyOtp as s, addPhone as t };

package/dist/{phoneStateMachine-T1-drWfG.esm.js → phoneStateMachine-DnlPhnw7.esm.js}

@@ -1,60 +1,10 @@
-import { t as api, u as endpoints } from "./api-BO8JA7Pf.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { n as loadPhoneValidation } from "./phoneValidation-OggtfjRt.esm.js";
+import { i as fetchStartInfo, n as addPhoneInstantVerify, o as sendOtp, r as fetchPhone, s as verifyOtp, t as addPhone } from "./phoneServices-DJgyOzU2.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-import { t as carryAttempts } from "./attemptCarry-BjTJ6bMQ.esm.js";
-import { n as loadPhoneValidation } from "./phoneValidation-OggtfjRt.esm.js";
+import { t as carryAttempts } from "./attemptCarry-WOkfvFMw.esm.js";
 import { n as isOtpComplete, t as computeOtpValidationErrors } from "./otp-D2k3PeSL.esm.js";
-//#region src/modules/phone/phoneServices.ts
-function getPhoneServerFailureReason(error, invalidStatus) {
-	if (error.status === invalidStatus) return "invalidPhone";
-	return "serverError";
-}
-async function fetchPhone(signal) {
-	const res = await api.get(endpoints.getPhone, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.getPhone} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function fetchStartInfo(signal) {
-	const res = await api.get(endpoints.startInfo, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.startInfo} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function addPhone(params, signal) {
-	try {
-		return (await api.post(endpoints.phone, {
-			phone: params.phone,
-			optInGranted: params.optInGranted
-		}, { signal })).data;
-	} catch (error) {
-		throw new Error(getPhoneServerFailureReason(error, 400));
-	}
-}
-async function addPhoneInstantVerify(params, signal) {
-	try {
-		return (await api.post(endpoints.phoneInstant, {
-			phone: params.phone,
-			optInGranted: params.optInGranted
-		}, { signal })).data;
-	} catch (error) {
-		throw new Error(getPhoneServerFailureReason(error, 400));
-	}
-}
-async function sendOtp(signal) {
-	try {
-		await api.get(`${endpoints.sendSmsOtp}?communicationchannel=SMS`, { signal });
-	} catch (error) {
-		throw new Error(getPhoneServerFailureReason(error));
-	}
-}
-async function verifyOtp(code, signal) {
-	try {
-		return (await api.get(`${endpoints.compareOtp}?code=${code}&channel=SMS`, { signal })).data;
-	} catch (error) {
-		throw new Error(getPhoneServerFailureReason(error));
-	}
-}
-//#endregion
 //#region src/modules/phone/phoneStateMachine.ts
 const RESEND_TIMER_SECONDS = 30;
 function getErrorMessage(error) {
@@ -149,6 +99,7 @@ const phoneMachine = setup({
 		setOptInGranted: assign(({ event }) => ({ optInGranted: event.granted })),
 		setError: assign(({ event }) => ({ error: getErrorMessage(event.error) })),
 		clearError: assign({ error: () => void 0 }),
+		settleLoad: assign({ pendingLoads: ({ context }) => context.pendingLoads - 1 }),
 		clearPhoneError: assign({ phoneError: () => void 0 }),
 		setOtpCode: assign(({ event }) => ({
 			otpCode: event.code,
@@ -191,6 +142,7 @@ const phoneMachine = setup({
 			prefilledPhone: void 0,
 			optInGranted: false,
 			startInfo: void 0,
+			pendingLoads: 0,
 			error: void 0,
 			otpCode: "",
 			otpError: void 0,
@@ -202,6 +154,7 @@ const phoneMachine = setup({
 	},
 	guards: {
 		hasPrefill: ({ context }) => context.config.prefill,
+		areLoadsSettled: ({ context }) => context.pendingLoads === 0,
 		hasOtpVerification: ({ context }) => context.config.otpVerification,
 		hasNoValidationErrors: ({ context }) => !context.validationErrors || Object.keys(context.validationErrors).length === 0,
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 1,
@@ -224,6 +177,7 @@ const phoneMachine = setup({
 			prefilledPhone: void 0,
 			optInGranted: false,
 			startInfo: void 0,
+			pendingLoads: 0,
 			error: void 0,
 			otpCode: "",
 			otpError: void 0,
@@ -247,15 +201,21 @@ const phoneMachine = setup({
 			{ target: "loadingStartInfo" }
 		] } },
 		loadingPrefill: {
-			entry: "startLoadingPhoneRules",
-			invoke: {
+			entry: ["startLoadingPhoneRules", assign({ pendingLoads: () => 2 })],
+			invoke: [{
 				id: "fetchPhone",
 				src: "fetchPhone",
-				onDone: {
-					target: "loadingStartInfo",
-					actions: "setPrefilledPhone"
-				},
-				onError: { target: "loadingStartInfo" }
+				onDone: { actions: ["setPrefilledPhone", "settleLoad"] },
+				onError: { actions: "settleLoad" }
+			}, {
+				id: "fetchStartInfo",
+				src: "fetchStartInfo",
+				onDone: { actions: ["setStartInfo", "settleLoad"] },
+				onError: { actions: "settleLoad" }
+			}],
+			always: {
+				target: "loadingPhoneRules",
+				guard: "areLoadsSettled"
 			}
 		},
 		loadingStartInfo: {

package/dist/{processFaceMatch-BWme3kVV.esm.js → processFaceMatch-Bst83HaS.esm.js}

@@ -1,4 +1,4 @@
-import { r as getToken } from "./api-BO8JA7Pf.esm.js";
+import { r as getToken } from "./api-CpP4PS4S.esm.js";
 //#region src/internal/session/processFaceMatch.ts
 let saved = null;
 /**

package/dist/qe-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-C7pqXsRm.esm.js";
+import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-BCE3uA3z.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/recordingService-CTko6Cjn.esm.js

@@ -0,0 +1,397 @@
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
+import { r as createRecordingCompositor } from "./CameraCompositor-DN7NkJzV.esm.js";
+import { t as getAdaptiveMediaRecorderOptions } from "./mediaRecorderOptions-B9-IEVtV.esm.js";
+import { t as WorkerEncoderRecordingProvider } from "./WorkerEncoderRecordingProvider-B1ODYtgN.esm.js";
+import { t as MultipartRecordingService } from "./multipartRecordingService-BTqkHGG9.esm.js";
+//#region ../infra/src/media/VideoTrimmer.ts
+/** A trim that runs longer than this uploads the full recording instead. */
+const TRIM_TIMEOUT_MS = 1e4;
+const trimmer = BrowserLazyImportProvider.getInstance().create(() => import("./videoTrimByCopy-BFfAiNpv.esm.js").then((module) => module.trimLastNSecondsByCopy), {
+	label: "Video liveness",
+	moduleName: "mediabunny",
+	timeoutMs: 1e4,
+	disabledMessage: "the full recording will be uploaded untrimmed."
+});
+/** Starts loading the trimmer, e.g. when a recording that will be trimmed starts. */
+function preloadVideoTrimmer() {
+	trimmer.load();
+}
+/**
+* Keeps about the last `seconds` of a recording. Never rejects and never
+* hangs: when the trimmer cannot load, fails, or takes longer than
+* {@link TRIM_TIMEOUT_MS}, it resolves the untrimmed recording.
+*/
+async function trimLastNSeconds(videoBlob, seconds) {
+	const trim = await trimmer.load();
+	if (!trim) return videoBlob;
+	let timeout;
+	try {
+		return await Promise.race([trim(videoBlob, seconds), new Promise((resolve) => {
+			timeout = setTimeout(() => {
+				console.warn("[Video liveness] Trimming timed out; the full recording will be uploaded untrimmed.");
+				resolve(videoBlob);
+			}, TRIM_TIMEOUT_MS);
+		})]);
+	} catch (error) {
+		console.warn("[Video liveness] Trimming failed; the full recording will be uploaded untrimmed.", error);
+		return videoBlob;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
+function toBase64(videoBlob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const base64 = reader.result.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
+		reader.readAsDataURL(videoBlob);
+	});
+}
+/** `MediaRecorderOptions.videoKeyFrameIntervalDuration`, see `startRecording`. */
+const KEYFRAME_INTERVAL_MS = 1e3;
+var LocalRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.stream = null;
+		this.pauseRecordingBound = this.pauseRecording.bind(this);
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream) {
+		this.reset();
+		preloadVideoTrimmer();
+		this.registerEventListeners();
+		this.stream = stream;
+		try {
+			const options = getAdaptiveMediaRecorderOptions();
+			this.mimeType = options.mimeType;
+			const recorder = new MediaRecorder(stream.clone(), {
+				...options,
+				videoKeyFrameIntervalDuration: KEYFRAME_INTERVAL_MS
+			});
+			recorder.onerror = (event) => {
+				this._error = `Recording error: ${event}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start();
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			this._error = `Failed to start recording: ${err}`;
+			this._hasError = true;
+		}
+	}
+	async stopRecording(trimSeconds, encrypt, generateChecksum) {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve, reject) => {
+			this.removeEventListeners();
+			if (recorder && this._isRecording) {
+				const chunks = [];
+				recorder.ondataavailable = (event) => {
+					if (event.data.size > 0) chunks.push(event.data);
+				};
+				recorder.onstop = async () => {
+					try {
+						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
+						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
+						generateChecksum(await trimmedVideo.arrayBuffer());
+						this._isRecording = false;
+						resolve({
+							trimmedBlob: trimmedVideo,
+							encryptedVideo: encryptedVideoBase64
+						});
+					} catch (error) {
+						this._isRecording = false;
+						this._error = `Recording stop failed: ${error}`;
+						this._hasError = true;
+						reject(error);
+					}
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve({
+				trimmedBlob: new Blob([], { type: this.mimeType }),
+				encryptedVideo: ""
+			});
+			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;
+	}
+	pauseRecording() {
+		if (!this._isRecording) return;
+		if (this.mediaRecorder?.state === "recording") try {
+			this.mediaRecorder.pause();
+		} catch {}
+	}
+	registerEventListeners() {
+		document.addEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+	removeEventListeners() {
+		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+};
+//#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.
+*/
+var LocalRecordingService = class {
+	constructor(wasmUtil, sessionToken) {
+		this.recorder = new LocalRecordingProvider();
+		this.sessionToken = sessionToken;
+		this.wasmUtil = wasmUtil;
+	}
+	async start(stream) {
+		this.recorder.startRecording(stream);
+		this.wasmUtil.osv();
+	}
+	async stop() {
+		if (!this.recorder.isRecording) return { recordingId: null };
+		this.wasmUtil.oev();
+		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
+		if (!this.sessionToken) return { recordingId: null };
+		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
+	}
+	prepareUpload() {
+		return this.stop();
+	}
+	async stopAndGetVideo() {
+		if (!this.recorder.isRecording) return { videoBase64: void 0 };
+		try {
+			this.wasmUtil.oev();
+			const videoBase64 = (await this.recorder.stopRecording(10, (base64) => base64, () => {})).encryptedVideo;
+			return { videoBase64: videoBase64 ? videoBase64 : void 0 };
+		} catch {
+			return { videoBase64: void 0 };
+		}
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+/**
+* Records a regular Selfie capture locally and streams it through the scoped
+* video-selfie-service multipart protocol. The recording is associated with
+* 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.recordingCompositor = createRecordingCompositor();
+		this.service = new MultipartRecordingService("selfie", new WorkerEncoderRecordingProvider(this.recordingCompositor));
+		this.audioSource = [];
+		this.needsVideoSourceReplacement = false;
+		this.pausedForAttempt = false;
+		this.startInFlight = false;
+		this.suspendRequested = false;
+		this.stopping = false;
+	}
+	async start(stream) {
+		if (this.stopping) throw new Error("Face recording already completed");
+		if (this.compositor) {
+			await this.resume(stream);
+			return;
+		}
+		const recordingSource = stream.clone();
+		const compositor = this.recordingCompositor;
+		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;
+		}
+		if (!this.pausedForAttempt) this.pausedForAttempt = this.service.pause();
+		this.releaseCameraClone({ keepAudio: true });
+		this.needsVideoSourceReplacement = true;
+	}
+	async prepareUpload() {
+		this.suspend();
+		return { recordingId: null };
+	}
+	async stop() {
+		await this.complete();
+		return { recordingId: null };
+	}
+	pauseForBackground() {
+		this.suspend();
+	}
+	async resumeFromBackground(stream) {
+		if (!this.compositor || this.stopping) return;
+		await this.resume(stream);
+	}
+	async stopAndGetVideo() {
+		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();
+	}
+	/** 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}`);
+		}
+		if (this.pausedForAttempt && !this.service.resume()) throw new Error("Face recording did not resume");
+		this.pausedForAttempt = false;
+	}
+	/**
+	* 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;
+		}
+	}
+	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 {}
+	}
+};
+/**
+* Creates the recording service for the current configuration.
+*
+* Order of precedence:
+* 1. `onDeviceFaceResultsSubmissionEnabled === true` → no recording. The
+*    on-device workflow never uploads media, only the staged face-results
+*    JSON via `WebApi.postFaceResults`. Mirrors V1's
+*    `FaceFlowManager.setRecorders()` early return.
+* 2. `deepsightLiveness === 'VIDEOLIVENESS'` → local Deepsight recorder.
+* 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 new MultipartFaceRecordingService();
+}
+//#endregion
+export { createRecordingService };

package/dist/redirect-to-mobile.esm.js

@@ -1,3 +1,3 @@
-import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-BBMAc2Gb.esm.js";
-import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-BJXC6Kx9.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-CbhN8uVN.esm.js";
+import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-CgGaT2NP.esm.js";
 export { createRedirectToMobileManager, createRedirectToMobileManagerFromActor, defaultRedirectToMobileServices, redirectToMobileMachine };

package/dist/{redirectToMobileManager-BJXC6Kx9.esm.js → redirectToMobileManager-CgGaT2NP.esm.js}

@@ -1,8 +1,8 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CQteqXfy.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-BBMAc2Gb.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-CbhN8uVN.esm.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
 const POLL_INTERVAL_MS = 5e3;
 const QR_REFRESH_INTERVAL_MS = 5e3;
@@ -58,7 +58,7 @@ function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
 	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("generatingUrl") || typedSnapshot.matches("loadingStartInfo")) return { status: "loading" };
+	if (typedSnapshot.matches("generatingUrl")) return { status: "loading" };
 	if (typedSnapshot.matches("showingQr")) return {
 		status: "redirecting",
 		redirectUrl: context.redirectUrl,