@incodetech/core 2.3.2-rc.4 → 2.4.0-rc.0

package/dist/video-selfie.esm.js

@@ -1,1389 +1,1431 @@
-import { r as WasmUtilProvider } from "./safeStorage-BdU9_m2E.esm.js";
-import { t as ensureWasmPipelines } from "./setup-DmB0JHAB.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-CIdnE7Fx.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { d as facingModeForStep, f as resolveVideoSelfieSteps, p as videoSelfieWasmPipelines } from "./flowServices-JW6uRaUt.esm.js";
-import { i as assign, r as sendTo, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
+import { t as ensureWasmPipelines } from "./setup-C38QkrSP.esm.js";
+import { t as endpoints } from "./endpoints-DHzlkQNe.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { t as BrowserLazyImportProvider } from "./BrowserLazyImportProvider-BhoA957O.esm.js";
+import { d as facingModeForStep, f as resolveVideoSelfieSteps, p as videoSelfieWasmPipelines } from "./flowServices-DA64AEZC.esm.js";
+import { i as assign, r as sendTo, s as createActor, t as setup, 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 { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BrJN1B8A.esm.js";
-import { i as createRecordingCompositor, n as WorkerEncoderRecordingProvider, t as MultipartRecordingService } from "./multipartRecordingService-mwKFTlhR.esm.js";
-import { t as VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE } from "./advanceableErrors-CpF2cBy6.esm.js";
-import { a as isConnectionError, n as defaultAcquireCamera, r as createDefaultStepDetector, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-D_4NwYM-.esm.js";
-import { t as videoSelfieFlowModuleMachine } from "./videoSelfieFlowModuleMachine-BUe2uACW.esm.js";
-//#region src/modules/video-selfie/videoSelfieWasm.ts
-function warmupVideoSelfieWasm(config, steps = resolveVideoSelfieSteps(config)) {
-	return ensureWasmPipelines(videoSelfieWasmPipelines(config, steps));
-}
+import { i as createRecordingCompositor, n as WorkerEncoderRecordingProvider, t as MultipartRecordingService } from "./multipartRecordingService-DbeQpXdU.esm.js";
+import { t as VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE } from "./advanceableErrors-q_pfU3Cn.esm.js";
+import { a as isConnectionError, n as defaultAcquireCamera, r as createDefaultStepDetector, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-C366RKqu.esm.js";
+import { t as videoSelfieFlowModuleMachine } from "./videoSelfieFlowModuleMachine-BCFVHBQ1.esm.js";
+//#region ../../node_modules/.pnpm/audio-recorder-polyfill@0.4.1/node_modules/audio-recorder-polyfill/wave-encoder/index.js
+var wave_encoder_default = () => {
+	let BYTES_PER_SAMPLE = 2;
+	let recorded = [];
+	function encode(buffer) {
+		let length = buffer.length;
+		let data = new Uint8Array(length * BYTES_PER_SAMPLE);
+		for (let i = 0; i < length; i++) {
+			let index = i * BYTES_PER_SAMPLE;
+			let sample = buffer[i];
+			if (sample > 1) sample = 1;
+			else if (sample < -1) sample = -1;
+			sample = sample * 32768;
+			data[index] = sample;
+			data[index + 1] = sample >> 8;
+		}
+		recorded.push(data);
+	}
+	function dump(sampleRate) {
+		let bufferLength = recorded.length ? recorded[0].length : 0;
+		let length = recorded.length * bufferLength;
+		let wav = new Uint8Array(44 + length);
+		let view = new DataView(wav.buffer);
+		view.setUint32(0, 1380533830, false);
+		view.setUint32(4, 36 + length, true);
+		view.setUint32(8, 1463899717, false);
+		view.setUint32(12, 1718449184, false);
+		view.setUint32(16, 16, true);
+		view.setUint16(20, 1, true);
+		view.setUint16(22, 1, true);
+		view.setUint32(24, sampleRate, true);
+		view.setUint32(28, sampleRate * BYTES_PER_SAMPLE, true);
+		view.setUint16(32, BYTES_PER_SAMPLE, true);
+		view.setUint16(34, 8 * BYTES_PER_SAMPLE, true);
+		view.setUint32(36, 1684108385, false);
+		view.setUint32(40, length, true);
+		for (let i = 0; i < recorded.length; i++) wav.set(recorded[i], i * bufferLength + 44);
+		recorded = [];
+		postMessage(wav.buffer, [wav.buffer]);
+	}
+	onmessage = (e) => {
+		if (e.data[0] === "encode") encode(e.data[1]);
+		else if (e.data[0] === "dump") dump(e.data[1]);
+	};
+};
 //#endregion
-//#region src/modules/video-selfie/videoSelfieRecordingMachine.ts
-/** A detector that never settles — used when a step has no auto-capture yet. */
-const manualStepDetector = () => new Promise(() => {});
-function eventOutputStream(event) {
-	return event.output;
-}
-function recordingIdFromEvent(event) {
-	return event.output.recordingId;
-}
-function errorFromEvent(event) {
-	return String(event.error);
-}
-/**
-* Chromium reports a camera the device cannot open right now as
-* `NotReadableError` ("Could not start video source") or `AbortError`
-* ("Starting videoinput failed") — the same pair the rear-camera acquire
-* retries on. Anything else (permission, no device) will not clear by
-* releasing our own camera.
-*/
-function isCameraBusyError(error) {
-	const name = typeof error === "object" && error !== null && "name" in error ? error.name : void 0;
-	return name === "NotReadableError" || name === "AbortError";
-}
-function detectionStatusFromEvent(event) {
-	return event.status;
-}
-function detectionErrorFromEvent(event) {
-	return event.error;
-}
-function validationFailureFromEvent(event) {
-	return event.failure;
-}
-function errorKindFromEvent(event) {
-	return event.kind;
-}
-function retryableFailureFromEvent(event) {
-	return event.failure;
-}
-function orientationFromEvent(event) {
-	return event.orientation;
-}
-const SWITCHING_CAMERA_MIN_DWELL_MS = 3e3;
-/**
-* How long a just-stopped camera gets to release before another one is
-* opened (see `releasingCamera`). Same settle the rear-camera acquire uses
-* on a busy device; a hardware knob, not a protocol value.
-*/
-const CAMERA_RELEASE_SETTLE_MS = 300;
-const ID_FLIP_DWELL_MS = 4e3;
-const FINAL_SUCCESS_DWELL_MS = 3e3;
-const MAX_VIDEO_LENGTH_ERROR_DWELL_MS = 3e3;
-const VALIDATION_FEEDBACK_DWELL_MS = 3e3;
-const DEFAULT_ATTEMPTS_PER_STEP = 3;
-const DEFAULT_MAX_VIDEO_LENGTH_SECONDS = 300;
-const UNLIMITED_ATTEMPTS = -1;
-function normalizeAttempts(attempts) {
-	if (attempts === UNLIMITED_ATTEMPTS) return UNLIMITED_ATTEMPTS;
-	if (typeof attempts === "number" && attempts > 0) return attempts;
-	return DEFAULT_ATTEMPTS_PER_STEP;
-}
-function normalizeMaxVideoLength(seconds) {
-	if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0) return seconds;
-	return DEFAULT_MAX_VIDEO_LENGTH_SECONDS;
-}
-function waitForDwell(ms, signal) {
-	const timerProvider = BrowserTimerProvider.getInstance();
-	return new Promise((resolve) => {
-		const onAbort = () => {
-			timerProvider.clearTimeout(timer);
-			resolve(false);
-		};
-		const timer = timerProvider.setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve(true);
-		}, ms);
-		signal.addEventListener("abort", onAbort, { once: true });
-		if (signal.aborted) onAbort();
-	});
-}
+//#region ../../node_modules/.pnpm/audio-recorder-polyfill@0.4.1/node_modules/audio-recorder-polyfill/index.js
+let AudioContext = window.AudioContext || window.webkitAudioContext;
+let createWorker = (fn) => {
+	let js = fn.toString().replace(/^(\(\)\s*=>|function\s*\(\))\s*{/, "").replace(/}$/, "");
+	let blob = new Blob([js]);
+	return new Worker(URL.createObjectURL(blob));
+};
+let error = (method) => {
+	let event = new Event("error");
+	event.data = /* @__PURE__ */ new Error("Wrong state for " + method);
+	return event;
+};
+let context;
 /**
-* Orchestrates a multi-step Video Selfie session as ONE continuous recording
-* that follows the camera between steps AND auto-advances per step:
-*
-*   idle ─START▶ [preparingWasm ─▶] acquiringCamera ─▶ starting
-*                                                        │
-*                                                        ▼
-*                              recording ⇄ switchingCamera
-*                                  │            │ busy camera (ENG-57332)
-*                                  │            ▼
-*                                  │      releasingCamera ─settle▶ retry once
-*                                  │ (capture validated → DETECTION_DONE,
-*                                  │  or manual NEXT_STEP)
-*                         last step ─▶ finalizing ─▶ finished
-*
-* While `recording`, a per-step detector runs WASM auto-capture + backend
-* validation; success advances the step (switching the camera when the next
-* step's facing differs), and the final step finalizes the multipart upload.
+* Audio Recorder with MediaRecorder API.
 *
-* Teardown: `ABORT` is accepted from ANY non-final state and every settled
-* path runs `cleanup`, so no path leaves camera or mic tracks running.
-* XState v5 executes NO exit actions on an external
-* `actor.stop()`, so the manager sends `ABORT` before stopping the actor —
-* never stop this actor directly without aborting first.
+* @example
+* navigator.mediaDevices.getUserMedia({ audio: true }).then(stream => {
+*   let recorder = new MediaRecorder(stream)
+* })
 */
-const videoSelfieRecordingSetup = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	delays: {
-		ID_FLIP_DWELL: ID_FLIP_DWELL_MS,
-		FINAL_SUCCESS_DWELL: FINAL_SUCCESS_DWELL_MS,
-		MAX_VIDEO_LENGTH_ERROR_DWELL: MAX_VIDEO_LENGTH_ERROR_DWELL_MS,
-		VALIDATION_FEEDBACK_DWELL: VALIDATION_FEEDBACK_DWELL_MS,
-		CAMERA_RELEASE_SETTLE: CAMERA_RELEASE_SETTLE_MS
-	},
-	actors: {
-		prepareWasm: fromPromise(async ({ input }) => input.ensure()),
-		visibilityChanges: fromCallback(({ input, sendBack }) => input.visibilityObserver.onVisibilityChange((visible) => {
-			sendBack({ type: visible ? "FOREGROUND" : "BACKGROUND" });
-		})),
-		executionTimer: fromCallback(({ input, sendBack, receive }) => {
-			let handle;
-			const cancel = () => {
-				if (handle !== void 0) {
-					input.timer.clearTimeout(handle);
-					handle = void 0;
-				}
-			};
-			receive((event) => {
-				cancel();
-				if (event.type === "ARM") handle = input.timer.setTimeout(() => {
-					handle = void 0;
-					sendBack({ type: "MAX_VIDEO_LENGTH_REACHED" });
-				}, event.durationMs);
-			});
-			return cancel;
-		}),
-		acquireCamera: fromPromise(async ({ input, signal }) => {
-			const stream = await input.acquire(input.facingMode, input.withAudio);
-			if (signal.aborted) {
-				stream.getTracks().forEach((track) => track.stop());
-				throw new Error("Camera acquire cancelled");
-			}
-			return stream;
-		}),
-		switchCamera: fromPromise(async ({ input, signal }) => {
-			const dwellCompleted = waitForDwell(input.minDwellMs, signal);
-			const stream = await input.acquire(input.facingMode, false);
-			if (signal.aborted) {
-				stream.getTracks().forEach((track) => track.stop());
-				throw new Error("Camera switch cancelled");
-			}
-			if (!await dwellCompleted) {
-				stream.getTracks().forEach((track) => track.stop());
-				throw new Error("Camera switch cancelled");
-			}
-			if (signal.aborted) {
-				stream.getTracks().forEach((track) => track.stop());
-				throw new Error("Camera switch cancelled");
-			}
-			return stream;
-		}),
-		startRecording: fromPromise(async ({ input }) => {
-			await input.service.start(input.stream);
-		}),
-		finalizeRecording: fromPromise(async ({ input }) => input.service.stop()),
-		pauseCapture: fromPromise(async ({ input }) => {
-			const paused = input.service.pause();
-			input.compositor.pause();
-			return paused;
-		}),
-		resumeCompositor: fromPromise(async ({ input, signal }) => input.compositor.resume(signal)),
-		resumeRecorder: fromPromise(async ({ input }) => input.service.resume()),
-		detectStep: fromCallback(({ input, sendBack }) => {
-			const controller = new AbortController();
-			input.detect({
-				step: input.step,
-				stream: input.stream,
-				signal: controller.signal,
-				onStatus: (status) => sendBack({
-					type: "DETECTION_STATUS",
-					status
-				}),
-				onOrientation: (orientation) => sendBack({
-					type: "ORIENTATION",
-					orientation
-				})
-			}).then((result) => {
-				if (result.outcome === "retryableFailure") {
-					sendBack({
-						type: "RETRYABLE_FAILURE",
-						failure: result.failure
-					});
-					return;
-				}
-				if (result.outcome === "validationFailed") {
-					sendBack({
-						type: "VALIDATION_FAILED",
-						failure: result.failure
-					});
-					return;
-				}
-				sendBack({ type: "DETECTION_DONE" });
-			}).catch((err) => {
-				if (!controller.signal.aborted) sendBack({
-					type: "DETECTION_FAILED",
-					error: String(err),
-					kind: isConnectionError(err) ? "connection" : "technical"
-				});
-			});
-			return () => controller.abort();
-		})
-	},
-	actions: {
-		armExecutionTimer: sendTo("executionTimer", ({ context }) => ({
-			type: "ARM",
-			durationMs: context.maxVideoLengthSeconds * 1e3
-		})),
-		cancelExecutionTimer: sendTo("executionTimer", { type: "CANCEL" }),
-		advanceStep: assign({
-			stepIndex: ({ context }) => context.stepIndex + 1,
-			attemptsRemaining: ({ context }) => context.attemptsPerStep,
-			validationFailure: () => void 0,
-			cameraSwitchRetried: () => false
-		}),
-		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
-		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(event) }),
-		setDetectionError: assign({ detectionError: ({ event }) => detectionErrorFromEvent(event) }),
-		setValidationFailure: assign(({ context, event }) => ({
-			attemptsRemaining: context.attemptsRemaining === UNLIMITED_ATTEMPTS ? UNLIMITED_ATTEMPTS : Math.max(0, context.attemptsRemaining - 1),
-			validationFailure: validationFailureFromEvent(event),
-			detectionStatus: "error"
-		})),
-		setUncountedRetryableFailure: assign(({ event }) => ({
-			validationFailure: retryableFailureFromEvent(event),
-			detectionStatus: "error"
-		})),
-		setErrorFromDetection: assign({
-			error: ({ event }) => detectionErrorFromEvent(event),
-			errorKind: ({ event }) => errorKindFromEvent(event)
-		}),
-		clearDetectionFeedback: assign({
-			detectionStatus: () => void 0,
-			detectionError: () => void 0,
-			validationFailure: () => void 0,
-			orientation: () => void 0
-		}),
-		markPageHidden: assign({ isPageVisible: () => false }),
-		markPageVisible: assign({ isPageVisible: () => true }),
-		prepareRecordingSuspension: assign({
-			isPageVisible: () => false,
-			resumeState: () => "recording"
-		}),
-		setUploadFailedError: assign({
-			error: () => "Video upload failed",
-			errorKind: () => "connection"
-		}),
-		setMaxVideoLengthReached: assign({
-			error: () => "maxVideoLengthReached",
-			errorKind: () => "maxVideoLengthReached"
-		}),
-		setValidationAttemptsExhausted: assign({
-			error: () => "Video selfie validation attempts exhausted",
-			errorKind: () => "validationAttemptsExhausted"
-		}),
-		resetSession: assign(({ context }) => ({
-			stepIndex: 0,
-			cameraSwitchRetried: false,
-			stream: void 0,
-			composite: void 0,
-			detectionStatus: void 0,
-			orientation: void 0,
-			detectionError: void 0,
-			validationFailure: void 0,
-			attemptsRemaining: context.attemptsPerStep,
-			recordingId: null,
-			error: void 0,
-			errorKind: void 0,
-			resumeState: "recording"
-		})),
-		cleanup: ({ context }) => {
-			context.service.cleanup();
-			context.compositor.stop();
-			context.stream?.getTracks().forEach((track) => track.stop());
-		},
-		setTechnicalActorError: assign({
-			error: ({ event }) => errorFromEvent(event),
-			errorKind: () => "technical"
-		}),
-		setAudioEndedError: assign({
-			error: () => "Audio track ended while the app was backgrounded",
-			errorKind: () => "technical"
-		}),
-		setCameraResumeError: assign({
-			error: () => "Camera did not produce a fresh frame after foregrounding",
-			errorKind: () => "technical"
-		}),
-		setRecorderResumeError: assign({
-			error: () => "Recording could not resume after foregrounding",
-			errorKind: () => "technical"
-		}),
-		setPauseError: assign({
-			error: () => "Recording could not be paused before backgrounding",
-			errorKind: () => "technical"
-		}),
-		releaseCurrentVideo: ({ context }) => {
-			context.stream?.getVideoTracks().forEach((track) => track.stop());
-		}
-	},
-	guards: {
-		shouldEnterWasmGate: ({ context }) => context.ensureWasmReady !== void 0 && context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
-		isLastStep: ({ context }) => context.stepIndex >= context.steps.length - 1,
-		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining === UNLIMITED_ATTEMPTS || context.attemptsRemaining > 0,
-		nextStepFlipsId: ({ context }) => context.steps[context.stepIndex] === "frontId" && context.steps[context.stepIndex + 1] === "backId",
-		nextStepFlipsCamera: ({ context }) => facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[context.stepIndex + 1]),
-		uploadReturnedNoRecordingId: ({ event }) => recordingIdFromEvent(event) === null,
-		maxVideoLengthWasReached: ({ context }) => context.errorKind === "maxVideoLengthReached",
-		validationAttemptsWereExhausted: ({ context }) => context.errorKind === "validationAttemptsExhausted",
-		errorIsRetryable: ({ context }) => context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
-		canRetryCameraSwitchAfterRelease: ({ context, event }) => !context.cameraSwitchRetried && isCameraBusyError(event.error),
-		pageIsHidden: ({ context }) => !context.isPageVisible,
-		pauseFailed: ({ event }) => !event.output,
-		pauseSucceededWhileVisible: ({ context, event }) => context.isPageVisible && event.output,
-		compositorAudioEnded: ({ event }) => event.output === "audio-ended",
-		compositorDidNotResume: ({ event }) => event.output !== "resumed",
-		forceVideoRecovery: ({ context }) => context.resumeState === "switchingCamera",
-		recorderResumeFailed: ({ event }) => !event.output,
-		resumeValidationFeedback: ({ context }) => context.resumeState === "validationFeedback",
-		resumeFlippingId: ({ context }) => context.resumeState === "flippingId"
-	}
-});
-const ADVANCE_TRANSITIONS = [
-	{
-		target: "finalizing",
-		guard: "isLastStep"
-	},
-	{
-		target: "flippingId",
-		guard: "nextStepFlipsId"
-	},
-	{
-		target: "switchingCamera",
-		guard: "nextStepFlipsCamera",
-		actions: "advanceStep"
-	},
-	{
-		target: "recording",
-		reenter: true,
-		actions: "advanceStep"
+var MediaRecorder = class MediaRecorder {
+	/**
+	* @param {MediaStream} stream The audio stream to record.
+	*/
+	constructor(stream, config = null) {
+		/**
+		* The `MediaStream` passed into the constructor.
+		* @type {MediaStream}
+		*/
+		this.stream = stream;
+		this.config = config;
+		/**
+		* The current state of recording process.
+		* @type {"inactive"|"recording"|"paused"}
+		*/
+		this.state = "inactive";
+		this.em = document.createDocumentFragment();
+		this.encoder = createWorker(MediaRecorder.encoder);
+		let recorder = this;
+		this.encoder.addEventListener("message", (e) => {
+			let event = new Event("dataavailable");
+			event.data = new Blob([e.data], { type: recorder.mimeType });
+			recorder.em.dispatchEvent(event);
+			if (recorder.state === "inactive") recorder.em.dispatchEvent(new Event("stop"));
+		});
 	}
-];
-const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
-	id: "videoSelfieRecording",
-	initial: "idle",
-	context: ({ input }) => {
-		const visibilityObserver = input.visibilityObserver;
-		const compositor = input.dependencies?.createCompositor?.() ?? createRecordingCompositor();
-		return {
-			service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService("videoselfie", new WorkerEncoderRecordingProvider(compositor)),
-			compositor,
-			acquireCamera: input.dependencies?.acquireCamera ?? defaultAcquireCamera,
-			ensureWasmReady: input.ensureWasmReady,
-			detect: input.dependencies?.detect ?? manualStepDetector,
-			timer: input.dependencies?.timer ?? BrowserTimerProvider.getInstance(),
-			visibilityObserver,
-			isPageVisible: visibilityObserver.isVisible(),
-			resumeState: "recording",
-			steps: input.steps && input.steps.length > 0 ? input.steps : ["selfie"],
-			stepIndex: 0,
-			stream: void 0,
-			composite: void 0,
-			detectionStatus: void 0,
-			orientation: void 0,
-			detectionError: void 0,
-			validationFailure: void 0,
-			attemptsPerStep: normalizeAttempts(input.attemptsPerStep),
-			attemptsRemaining: normalizeAttempts(input.attemptsPerStep),
-			maxVideoLengthSeconds: normalizeMaxVideoLength(input.maxVideoLengthSeconds),
-			recordingId: null,
-			error: void 0,
-			errorKind: void 0,
-			switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS,
-			cameraSwitchRetried: false
+	/**
+	* Begins recording media.
+	*
+	* @param {number} [timeslice] The milliseconds to record into each `Blob`.
+	*                             If this parameter isn’t included, single `Blob`
+	*                             will be recorded.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* recordButton.addEventListener('click', () => {
+	*   recorder.start()
+	* })
+	*/
+	start(timeslice) {
+		if (this.state !== "inactive") return this.em.dispatchEvent(error("start"));
+		this.state = "recording";
+		if (!context) context = new AudioContext(this.config);
+		this.clone = this.stream.clone();
+		this.input = context.createMediaStreamSource(this.clone);
+		this.processor = context.createScriptProcessor(2048, 1, 1);
+		this.encoder.postMessage(["init", context.sampleRate]);
+		this.processor.onaudioprocess = (e) => {
+			if (this.state === "recording") this.encoder.postMessage(["encode", e.inputBuffer.getChannelData(0)]);
 		};
-	},
-	invoke: [{
-		id: "executionTimer",
-		src: "executionTimer",
-		input: ({ context }) => ({ timer: context.timer })
-	}, {
-		id: "visibilityChanges",
-		src: "visibilityChanges",
-		input: ({ context }) => ({ visibilityObserver: context.visibilityObserver })
-	}],
-	on: {
-		ABORT: { target: ".aborted" },
-		BACKGROUND: { actions: "markPageHidden" },
-		FOREGROUND: { actions: "markPageVisible" }
-	},
-	states: {
-		idle: { on: { START: [{
-			target: "preparingWasm",
-			guard: "shouldEnterWasmGate"
-		}, { target: "acquiringCamera" }] } },
-		preparingWasm: { invoke: {
-			src: "prepareWasm",
-			input: ({ context }) => ({ ensure: context.ensureWasmReady }),
-			onDone: { target: "acquiringCamera" },
-			onError: {
-				target: "error",
-				actions: "setTechnicalActorError"
-			}
-		} },
-		acquiringCamera: { invoke: {
-			src: "acquireCamera",
-			input: ({ context }) => ({
-				acquire: context.acquireCamera,
-				facingMode: facingModeForStep(context.steps[context.stepIndex]),
-				withAudio: true
-			}),
-			onDone: {
-				target: "starting",
-				actions: [({ context, event }) => {
-					context.compositor.start(eventOutputStream(event));
-				}, assign({
-					stream: ({ event }) => eventOutputStream(event),
-					composite: ({ context }) => context.compositor.stream
-				})]
-			},
-			onError: {
-				target: "error",
-				actions: assign({ error: ({ event }) => errorFromEvent(event) })
-			}
-		} },
-		starting: { invoke: {
-			src: "startRecording",
-			input: ({ context }) => ({
-				service: context.service,
-				stream: context.composite
-			}),
-			onDone: [{
-				target: "pausing",
-				guard: "pageIsHidden",
-				actions: ["armExecutionTimer", "prepareRecordingSuspension"]
-			}, {
-				target: "recording",
-				actions: "armExecutionTimer"
-			}],
-			onError: {
-				target: "error",
-				actions: assign({ error: ({ event }) => errorFromEvent(event) })
-			}
-		} },
-		recording: {
-			entry: "clearDetectionFeedback",
-			invoke: {
-				src: "detectStep",
-				input: ({ context }) => ({
-					detect: context.detect,
-					step: context.steps[context.stepIndex],
-					stream: context.stream
-				})
-			},
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: "prepareRecordingSuspension"
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				},
-				DETECTION_STATUS: { actions: "setDetectionStatus" },
-				ORIENTATION: { actions: "setOrientation" },
-				DETECTION_DONE: ADVANCE_TRANSITIONS,
-				NEXT_STEP: ADVANCE_TRANSITIONS,
-				VALIDATION_FAILED: {
-					target: "validationFeedback",
-					actions: "setValidationFailure"
-				},
-				RETRYABLE_FAILURE: {
-					target: "validationFeedback",
-					actions: "setUncountedRetryableFailure"
-				},
-				DETECTION_FAILED: {
-					target: "error",
-					actions: "setErrorFromDetection"
-				}
+		this.input.connect(this.processor);
+		this.processor.connect(context.destination);
+		this.em.dispatchEvent(new Event("start"));
+		if (timeslice) this.slicing = setInterval(() => {
+			if (this.state === "recording") this.requestData();
+		}, timeslice);
+	}
+	/**
+	* Stop media capture and raise `dataavailable` event with recorded data.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* finishButton.addEventListener('click', () => {
+	*   recorder.stop()
+	* })
+	*/
+	stop() {
+		if (this.state === "inactive") return this.em.dispatchEvent(error("stop"));
+		this.requestData();
+		this.state = "inactive";
+		this.clone.getTracks().forEach((track) => {
+			track.stop();
+		});
+		this.processor.disconnect();
+		this.input.disconnect();
+		return clearInterval(this.slicing);
+	}
+	/**
+	* Pauses recording of media streams.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* pauseButton.addEventListener('click', () => {
+	*   recorder.pause()
+	* })
+	*/
+	pause() {
+		if (this.state !== "recording") return this.em.dispatchEvent(error("pause"));
+		this.state = "paused";
+		return this.em.dispatchEvent(new Event("pause"));
+	}
+	/**
+	* Resumes media recording when it has been previously paused.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* resumeButton.addEventListener('click', () => {
+	*   recorder.resume()
+	* })
+	*/
+	resume() {
+		if (this.state !== "paused") return this.em.dispatchEvent(error("resume"));
+		this.state = "recording";
+		return this.em.dispatchEvent(new Event("resume"));
+	}
+	/**
+	* Raise a `dataavailable` event containing the captured media.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* this.on('nextData', () => {
+	*   recorder.requestData()
+	* })
+	*/
+	requestData() {
+		if (this.state === "inactive") return this.em.dispatchEvent(error("requestData"));
+		return this.encoder.postMessage(["dump", context.sampleRate]);
+	}
+	/**
+	* Add listener for specified event type.
+	*
+	* @param {"start"|"stop"|"pause"|"resume"|"dataavailable"|"error"}
+	* type Event type.
+	* @param {function} listener The listener function.
+	*
+	* @return {undefined}
+	*
+	* @example
+	* recorder.addEventListener('dataavailable', e => {
+	*   audio.src = URL.createObjectURL(e.data)
+	* })
+	*/
+	addEventListener(...args) {
+		this.em.addEventListener(...args);
+	}
+	/**
+	* Remove event listener.
+	*
+	* @param {"start"|"stop"|"pause"|"resume"|"dataavailable"|"error"}
+	* type Event type.
+	* @param {function} listener The same function used in `addEventListener`.
+	*
+	* @return {undefined}
+	*/
+	removeEventListener(...args) {
+		this.em.removeEventListener(...args);
+	}
+	/**
+	* Calls each of the listeners registered for a given event.
+	*
+	* @param {Event} event The event object.
+	*
+	* @return {boolean} Is event was no canceled by any listener.
+	*/
+	dispatchEvent(...args) {
+		this.em.dispatchEvent(...args);
+	}
+};
+/**
+* The MIME type that is being used for recording.
+* @type {string}
+*/
+MediaRecorder.prototype.mimeType = "audio/wav";
+/**
+* Returns `true` if the MIME type specified is one the polyfill can record.
+*
+* This polyfill supports `audio/wav` and `audio/mpeg`.
+*
+* @param {string} mimeType The mimeType to check.
+*
+* @return {boolean} `true` on `audio/wav` and `audio/mpeg` MIME type.
+*/
+MediaRecorder.isTypeSupported = (mimeType) => {
+	return MediaRecorder.prototype.mimeType === mimeType;
+};
+/**
+* `true` if MediaRecorder can not be polyfilled in the current browser.
+* @type {boolean}
+*
+* @example
+* if (MediaRecorder.notSupported) {
+*   showWarning('Audio recording is not supported in this browser')
+* }
+*/
+MediaRecorder.notSupported = !navigator.mediaDevices || !AudioContext;
+/**
+* Converts RAW audio buffer to compressed audio files.
+* It will be loaded to Web Worker.
+* By default, WAVE encoder will be used.
+* @type {function}
+*
+* @example
+* MediaRecorder.prototype.mimeType = 'audio/ogg'
+* MediaRecorder.encoder = oggEncoder
+*/
+MediaRecorder.encoder = wave_encoder_default;
+//#endregion
+//#region ../infra/src/media/blobEncoding.ts
+/** Encodes a blob as raw base64 bytes (no `data:...;base64,` prefix). */
+function blobToRawBase64(blob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const result = reader.result;
+			if (typeof result !== "string") {
+				reject(/* @__PURE__ */ new Error("Failed to encode blob as base64"));
+				return;
 			}
-		},
-		validationFeedback: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: ["markPageHidden", assign({ resumeState: () => "validationFeedback" })]
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			after: { VALIDATION_FEEDBACK_DWELL: [{
-				target: "recording",
-				guard: "hasAttemptsRemaining"
-			}, {
-				target: "finalizing",
-				actions: "setValidationAttemptsExhausted"
-			}] }
-		},
-		flippingId: {
-			after: { ID_FLIP_DWELL: {
-				target: "recording",
-				actions: "advanceStep"
-			} },
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: ["markPageHidden", assign({ resumeState: () => "flippingId" })]
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				},
-				NEXT_STEP: {
-					target: "recording",
-					actions: "advanceStep"
-				}
-			}
-		},
-		switchingCamera: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			invoke: {
-				src: "switchCamera",
-				input: ({ context }) => ({
-					acquire: context.acquireCamera,
-					facingMode: facingModeForStep(context.steps[context.stepIndex]),
-					minDwellMs: context.switchingCameraMinDwellMs
-				}),
-				onDone: {
-					target: "recording",
-					actions: [({ context, event }) => {
-						context.compositor.switchVideo(eventOutputStream(event));
-					}, assign({ stream: ({ event }) => eventOutputStream(event) })]
-				},
-				onError: [{
-					target: "releasingCamera",
-					guard: "canRetryCameraSwitchAfterRelease"
-				}, {
-					target: "error",
-					actions: assign({ error: ({ event }) => errorFromEvent(event) })
-				}]
-			}
-		},
-		releasingCamera: {
-			entry: ["releaseCurrentVideo", assign({ cameraSwitchRetried: () => true })],
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			after: { CAMERA_RELEASE_SETTLE: { target: "switchingCamera" } }
-		},
-		pausing: {
-			on: { MAX_VIDEO_LENGTH_REACHED: { actions: "setMaxVideoLengthReached" } },
-			invoke: {
-				src: "pauseCapture",
-				input: ({ context }) => ({
-					service: context.service,
-					compositor: context.compositor
-				}),
-				onDone: [
-					{
-						target: "finalizing",
-						guard: "maxVideoLengthWasReached"
-					},
-					{
-						target: "error",
-						guard: "pauseFailed",
-						actions: "setPauseError"
-					},
-					{
-						target: "resumingCompositor",
-						guard: "pauseSucceededWhileVisible"
-					},
-					{ target: "suspended" }
-				],
-				onError: [{
-					target: "finalizing",
-					guard: "maxVideoLengthWasReached"
-				}, {
-					target: "error",
-					actions: "setTechnicalActorError"
-				}]
-			}
-		},
-		suspended: { on: {
-			FOREGROUND: {
-				target: "resumingCompositor",
-				actions: "markPageVisible"
-			},
-			MAX_VIDEO_LENGTH_REACHED: {
-				target: "finalizing",
-				actions: "setMaxVideoLengthReached"
-			}
-		} },
-		resumingCompositor: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: "markPageHidden"
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			invoke: {
-				src: "resumeCompositor",
-				input: ({ context }) => ({ compositor: context.compositor }),
-				onDone: [
-					{
-						target: "error",
-						guard: "compositorAudioEnded",
-						actions: "setAudioEndedError"
-					},
-					{
-						target: "reacquiringCamera",
-						guard: "forceVideoRecovery"
-					},
-					{
-						target: "reacquiringCamera",
-						guard: "compositorDidNotResume"
-					},
-					{ target: "resumingRecorder" }
-				],
-				onError: {
-					target: "error",
-					actions: "setTechnicalActorError"
-				}
-			}
-		},
-		reacquiringCamera: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: "markPageHidden"
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			invoke: {
-				src: "acquireCamera",
-				input: ({ context }) => ({
-					acquire: context.acquireCamera,
-					facingMode: facingModeForStep(context.steps[context.stepIndex]),
-					withAudio: false
-				}),
-				onDone: {
-					target: "validatingRecoveredCamera",
-					actions: [({ context, event }) => {
-						context.compositor.switchVideo(eventOutputStream(event));
-					}, assign({ stream: ({ event }) => eventOutputStream(event) })]
-				},
-				onError: {
-					target: "error",
-					actions: "setTechnicalActorError"
-				}
+			const commaIndex = result.indexOf(",");
+			resolve(commaIndex >= 0 ? result.slice(commaIndex + 1) : result);
+		};
+		reader.onerror = () => {
+			reject(reader.error ?? /* @__PURE__ */ new Error("Failed to read blob"));
+		};
+		reader.readAsDataURL(blob);
+	});
+}
+//#endregion
+//#region ../infra/src/providers/browser/mp3Encoder.ts
+/**
+* Worker body of `audio-recorder-polyfill/mpeg-encoder` (MIT), without its
+* `importScripts()` of lamejs from cdnjs. Same message protocol:
+* `['init', sampleRate]`, `['encode', Float32Array]`, `['dump']`.
+*/
+const ENCODER_SOURCE = `
+var CHANNELS = 1;
+var KBPS = 128;
+var DEFAULT_SAMPLE_RATE = 44100;
+var encoder;
+var recorded = new Int8Array();
+
+function concat(a, b) {
+  if (b.length === 0) return a;
+  var c = new Int8Array(a.length + b.length);
+  c.set(a);
+  c.set(b, a.length);
+  return c;
+}
+
+onmessage = function (e) {
+  if (e.data[0] === 'init') {
+    encoder = new lamejs.Mp3Encoder(CHANNELS, e.data[1] || DEFAULT_SAMPLE_RATE, KBPS);
+  } else if (e.data[0] === 'encode') {
+    var buffer = e.data[1];
+    for (var i = 0; i < buffer.length; i++) buffer[i] = buffer[i] * 32767.5;
+    recorded = concat(recorded, encoder.encodeBuffer(buffer));
+  } else {
+    recorded = concat(recorded, encoder.flush());
+    var out = recorded.buffer;
+    recorded = new Int8Array();
+    postMessage(out, [out]);
+  }
+};
+`;
+/**
+* MP3 encoder for `audio-recorder-polyfill` that runs the given lamejs source
+* inside the worker, so voice consent makes no third-party request. The
+* polyfill runs an encoder by stringifying it into a blob: worker
+* (`encoder.toString()`, minus the `() => {` wrapper), so only `toString()`
+* matters here.
+*/
+function createMp3Encoder(lameSource) {
+	return { toString: () => `() => {\n${lameSource}\n${ENCODER_SOURCE}\n}` };
+}
+//#endregion
+//#region ../infra/src/providers/browser/VoiceRecordingProvider.ts
+const AudioRecorderPolyfill = MediaRecorder;
+AudioRecorderPolyfill.prototype.mimeType = "audio/mpeg";
+const MIME_TYPE = "audio/mpeg";
+const lamejs = BrowserLazyImportProvider.getInstance().create(() => import("./lamejs-B6TzhU5q.esm.js").then((module) => module.default), {
+	label: "Voice consent",
+	moduleName: "lamejs",
+	timeoutMs: 1e4,
+	disabledMessage: "voice consent cannot record audio."
+});
+/**
+* Records the audio of a stream and produces a single MP3 blob. Used by the
+* Video Selfie voice-consent step to capture the spoken consent phrase
+* independently of the main video recording (which keeps running on its own
+* recorder).
+*
+* Records from a clone of the supplied stream so stopping this recorder never
+* tears down tracks the main recording is still using.
+*
+* The MP3 encoder (lamejs) loads lazily. Flows with voice consent call
+* {@link VoiceRecordingProvider.preload} when they begin, and construction
+* loads it too, so it is ready long before the user speaks. If it is not,
+* `start()` begins recording once it has loaded.
+*/
+var VoiceRecordingProvider = class VoiceRecordingProvider {
+	/** Starts loading the MP3 encoder, e.g. when a flow with voice consent begins. */
+	static preload() {
+		lamejs.load();
+	}
+	constructor() {
+		this.recorder = null;
+		this.chunks = [];
+		this._isRecording = false;
+		this.pendingStart = null;
+		this.startGeneration = 0;
+		VoiceRecordingProvider.preload();
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	start(stream) {
+		this.reset();
+		this.chunks = [];
+		const lameSource = lamejs.get();
+		if (lameSource !== void 0) {
+			this.startRecorder(stream, lameSource);
+			this._isRecording = true;
+			return;
+		}
+		this._isRecording = true;
+		const generation = this.startGeneration;
+		this.pendingStart = lamejs.load().then((source) => {
+			if (source !== void 0 && generation === this.startGeneration) this.startRecorder(stream, source);
+		}).catch(() => {});
+	}
+	startRecorder(stream, lameSource) {
+		AudioRecorderPolyfill.encoder = createMp3Encoder(lameSource);
+		const audioOnly = new MediaStream(stream.getAudioTracks());
+		const recorder = new AudioRecorderPolyfill(audioOnly.clone());
+		recorder.mimeType = MIME_TYPE;
+		recorder.addEventListener("dataavailable", (event) => {
+			if (event.data.size > 0) this.chunks.push(event.data);
+		});
+		recorder.start();
+		this.recorder = recorder;
+	}
+	async stop() {
+		const pending = this.pendingStart;
+		await pending;
+		if (this.pendingStart === pending) this.pendingStart = null;
+		const recorder = this.recorder;
+		return new Promise((resolve) => {
+			if (!recorder || !this._isRecording) {
+				this._isRecording = false;
+				resolve(new Blob([], { type: MIME_TYPE }));
+				return;
 			}
-		},
-		validatingRecoveredCamera: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: "markPageHidden"
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			invoke: {
-				src: "resumeCompositor",
-				input: ({ context }) => ({ compositor: context.compositor }),
-				onDone: [
-					{
-						target: "error",
-						guard: "compositorAudioEnded",
-						actions: "setAudioEndedError"
-					},
-					{
-						target: "error",
-						guard: "compositorDidNotResume",
-						actions: "setCameraResumeError"
-					},
-					{ target: "resumingRecorder" }
-				],
-				onError: {
-					target: "error",
-					actions: "setTechnicalActorError"
-				}
-			}
-		},
-		resumingRecorder: {
-			on: {
-				BACKGROUND: {
-					target: "pausing",
-					actions: "markPageHidden"
-				},
-				MAX_VIDEO_LENGTH_REACHED: {
-					target: "finalizing",
-					actions: "setMaxVideoLengthReached"
-				}
-			},
-			invoke: {
-				src: "resumeRecorder",
-				input: ({ context }) => ({ service: context.service }),
-				onDone: [
-					{
-						target: "error",
-						guard: "recorderResumeFailed",
-						actions: "setRecorderResumeError"
-					},
-					{
-						target: "validationFeedback",
-						guard: "resumeValidationFeedback"
-					},
-					{
-						target: "flippingId",
-						guard: "resumeFlippingId"
-					},
-					{ target: "recording" }
-				],
-				onError: {
-					target: "error",
-					actions: "setTechnicalActorError"
-				}
-			}
-		},
-		finalizing: {
-			entry: "cancelExecutionTimer",
-			invoke: {
-				src: "finalizeRecording",
-				input: ({ context }) => ({ service: context.service }),
-				onDone: [
-					{
-						target: "error",
-						guard: "maxVideoLengthWasReached",
-						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
-					},
-					{
-						target: "error",
-						guard: "validationAttemptsWereExhausted",
-						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
-					},
-					{
-						target: "error",
-						guard: "uploadReturnedNoRecordingId",
-						actions: [assign({ recordingId: ({ event }) => recordingIdFromEvent(event) }), "setUploadFailedError"]
-					},
-					{
-						target: "success",
-						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
-					}
-				],
-				onError: [
-					{
-						target: "error",
-						guard: "maxVideoLengthWasReached"
-					},
-					{
-						target: "error",
-						guard: "validationAttemptsWereExhausted"
-					},
-					{
-						target: "error",
-						actions: assign({ error: ({ event }) => errorFromEvent(event) })
-					}
-				]
-			}
-		},
-		success: {
-			entry: ["cancelExecutionTimer", "cleanup"],
-			after: { FINAL_SUCCESS_DWELL: "finished" }
-		},
-		finished: { type: "final" },
-		error: {
-			entry: ["cancelExecutionTimer", "cleanup"],
-			after: { MAX_VIDEO_LENGTH_ERROR_DWELL: {
-				target: "finished",
-				guard: "maxVideoLengthWasReached"
-			} },
-			on: { RETRY: [{
-				target: "preparingWasm",
-				guard: "shouldEnterWasmGate",
-				actions: "resetSession"
-			}, {
-				target: "acquiringCamera",
-				guard: "errorIsRetryable",
-				actions: "resetSession"
-			}] }
-		},
-		aborted: {
-			type: "final",
-			entry: ["cancelExecutionTimer", "cleanup"]
+			recorder.addEventListener("stop", () => {
+				this._isRecording = false;
+				recorder.stream?.getTracks().forEach((track) => track.stop());
+				this.recorder = null;
+				resolve(new Blob(this.chunks, { type: MIME_TYPE }));
+			});
+			recorder.stop();
+		});
+	}
+	async stopAsBase64() {
+		const blob = await this.stop();
+		if (blob.size === 0) return "";
+		return blobToRawBase64(blob);
+	}
+	reset() {
+		this.startGeneration += 1;
+		this.pendingStart = null;
+		const recorder = this.recorder;
+		if (recorder && this._isRecording) {
+			try {
+				recorder.stop();
+			} catch {}
+			recorder.stream?.getTracks().forEach((track) => track.stop());
 		}
+		this.recorder = null;
+		this._isRecording = false;
 	}
-});
+};
 //#endregion
-//#region src/modules/video-selfie/videoSelfieRecordingActor.ts
-function getRecordingSteps(options) {
-	if (options.steps && options.steps.length > 0) return options.steps;
-	if (options.config) return resolveVideoSelfieSteps(options.config);
-}
-function createRetryablePreparation(prepare) {
-	let readiness;
-	return () => {
-		if (!readiness) {
-			readiness = Promise.resolve().then(prepare).catch((error) => {
-				readiness = void 0;
-				throw error;
-			});
-			readiness.catch(() => void 0);
-		}
-		return readiness;
-	};
-}
-function createVideoSelfieRecordingActor(visibilityObserver, options = {}) {
-	const config = options.config;
-	const steps = getRecordingSteps(options);
-	const detect = options.dependencies?.detect ?? (config ? createDefaultStepDetector(config, { getWasmUtil: () => WasmUtilProvider.getInstance() }) : void 0);
-	const prepareWasm = config && steps ? () => warmupVideoSelfieWasm(config, steps) : void 0;
-	const ensureWasmReady = prepareWasm ? createRetryablePreparation(prepareWasm) : void 0;
-	if (ensureWasmReady) ensureWasmReady();
-	return createActor(videoSelfieRecordingMachine, { input: {
-		steps,
-		attemptsPerStep: config?.numberOfTries,
-		maxVideoLengthSeconds: config?.maxWaitingVideoSelfieFile,
-		visibilityObserver,
-		ensureWasmReady,
-		dependencies: {
-			...options.dependencies,
-			detect
-		}
-	} }).start();
+//#region src/modules/video-selfie/videoSelfieWasm.ts
+function warmupVideoSelfieWasm(config, steps = resolveVideoSelfieSteps(config)) {
+	return ensureWasmPipelines(videoSelfieWasmPipelines(config, steps));
 }
 //#endregion
-//#region src/modules/video-selfie/videoSelfieRecordingManager.ts
-function mapState(snapshot) {
-	const value = typeof snapshot.value === "string" ? snapshot.value : "idle";
-	const { context } = snapshot;
-	const status = value === "preparingWasm" || value === "acquiringCamera" ? "starting" : value === "pausing" || value === "suspended" || value === "resumingCompositor" || value === "reacquiringCamera" || value === "validatingRecoveredCamera" || value === "resumingRecorder" ? "recording" : value === "releasingCamera" ? "switchingCamera" : value;
-	const steps = context.steps;
-	const stepIndex = context.stepIndex;
-	return {
-		status,
-		step: steps[stepIndex],
-		stepIndex,
-		isLastStep: stepIndex >= steps.length - 1,
-		stream: context.stream,
-		composite: context.composite,
-		detectionStatus: context.detectionStatus,
-		orientation: context.orientation,
-		validationFailure: context.validationFailure,
-		attemptsRemaining: context.attemptsRemaining,
-		recordingId: context.recordingId,
-		error: context.error,
-		errorKind: context.errorKind
-	};
+//#region src/modules/video-selfie/videoSelfieRecordingMachine.ts
+/** A detector that never settles — used when a step has no auto-capture yet. */
+const manualStepDetector = () => new Promise(() => {});
+function eventOutputStream(event) {
+	return event.output;
 }
-function createApi({ actor }) {
-	return {
-		/** Acquire the first camera, open the upload, and begin recording. */
-		start() {
-			actor.send({ type: "START" });
-		},
-		retry() {
-			actor.send({ type: "RETRY" });
-		},
-		/**
-		* Advance to the next step. Switches the camera when the next step's
-		* facing mode differs; finalizes the upload on the last step.
-		*/
-		nextStep() {
-			actor.send({ type: "NEXT_STEP" });
-		},
-		/** Abandon the session without finalizing the upload. */
-		abort() {
-			actor.send({ type: "ABORT" });
-		}
-	};
+function recordingIdFromEvent(event) {
+	return event.output.recordingId;
+}
+function errorFromEvent(event) {
+	return String(event.error);
 }
 /**
-* Creates a manager for a multi-step, camera-switching Video Selfie recording.
-*
-* The whole session records as one continuous video that follows the camera
-* across steps (front for selfie, rear for ID). Exposes `getState()` /
-* `subscribe()` (status, step, preview `stream`, `recordingId`) plus `start()`,
-* `nextStep()`, and `abort()`.
+* Chromium reports a camera the device cannot open right now as
+* `NotReadableError` ("Could not start video source") or `AbortError`
+* ("Starting videoinput failed") — the same pair the rear-camera acquire
+* retries on. Anything else (permission, no device) will not clear by
+* releasing our own camera.
 */
-function createVideoSelfieRecordingManager(options = {}) {
-	const actor = createVideoSelfieRecordingActor(options.dependencies?.visibilityObserver ?? new BrowserVisibilityObserverProvider(), options);
-	const manager = createManager({
-		actor,
-		mapState,
-		createApi
-	});
-	return {
-		...manager,
-		stop() {
-			if (actor.getSnapshot().status === "active") actor.send({ type: "ABORT" });
-			manager.stop();
-		}
-	};
+function isCameraBusyError(error) {
+	const name = typeof error === "object" && error !== null && "name" in error ? error.name : void 0;
+	return name === "NotReadableError" || name === "AbortError";
 }
-//#endregion
-//#region src/modules/video-selfie/videoSelfieSpeechService.ts
-/**
-* Fetches `count` random challenge questions the user answers out loud. The
-* spoken answers are captured in the main video recording (no separate upload)
-* and verified server-side.
-*/
-async function getVideoSelfieQuestions(count) {
-	return (await api.get(endpoints.questionAndAnswer, { query: {
-		numberOfQuestions: count,
-		returnVoiceConsentQuestion: false
-	} })).data.questionAndAnswers ?? [];
+function detectionStatusFromEvent(event) {
+	return event.status;
 }
-/**
-* Fetches the voice-consent phrase the user must read aloud. The phrase is the
-* `answer` of the consent question returned when `returnVoiceConsentQuestion`
-* is requested with no challenge questions.
-*/
-async function getVoiceConsentPhrase() {
-	return (await api.get(endpoints.questionAndAnswer, { query: {
-		numberOfQuestions: 0,
-		returnVoiceConsentQuestion: true
-	} })).data.questionAndAnswers?.[0]?.answer ?? "";
+function detectionErrorFromEvent(event) {
+	return event.error;
+}
+function validationFailureFromEvent(event) {
+	return event.failure;
+}
+function errorKindFromEvent(event) {
+	return event.kind;
 }
+function retryableFailureFromEvent(event) {
+	return event.failure;
+}
+function orientationFromEvent(event) {
+	return event.orientation;
+}
+const SWITCHING_CAMERA_MIN_DWELL_MS = 3e3;
 /**
-* Uploads the recorded consent audio (base64 MP3) for speech-to-text
-* validation. Resolves `{ success: false }` on a network/validation error so
-* the UI can drive its retry loop instead of throwing.
+* How long a just-stopped camera gets to release before another one is
+* opened (see `releasingCamera`). Same settle the rear-camera acquire uses
+* on a busy device; a hardware knob, not a protocol value.
 */
-async function addSpeech(base64Mp3) {
-	try {
-		return { success: (await api.post(endpoints.addSpeechV2, {
-			base64Media: base64Mp3,
-			audioOnly: true
-		})).data.success === true };
-	} catch {
-		return { success: false };
-	}
+const CAMERA_RELEASE_SETTLE_MS = 300;
+const ID_FLIP_DWELL_MS = 4e3;
+const FINAL_SUCCESS_DWELL_MS = 3e3;
+const MAX_VIDEO_LENGTH_ERROR_DWELL_MS = 3e3;
+const VALIDATION_FEEDBACK_DWELL_MS = 3e3;
+const DEFAULT_ATTEMPTS_PER_STEP = 3;
+const DEFAULT_MAX_VIDEO_LENGTH_SECONDS = 300;
+const UNLIMITED_ATTEMPTS = -1;
+function normalizeAttempts(attempts) {
+	if (attempts === UNLIMITED_ATTEMPTS) return UNLIMITED_ATTEMPTS;
+	if (typeof attempts === "number" && attempts > 0) return attempts;
+	return DEFAULT_ATTEMPTS_PER_STEP;
+}
+function normalizeMaxVideoLength(seconds) {
+	if (typeof seconds === "number" && Number.isFinite(seconds) && seconds > 0) return seconds;
+	return DEFAULT_MAX_VIDEO_LENGTH_SECONDS;
+}
+function waitForDwell(ms, signal) {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	return new Promise((resolve) => {
+		const onAbort = () => {
+			timerProvider.clearTimeout(timer);
+			resolve(false);
+		};
+		const timer = timerProvider.setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(true);
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+	});
 }
-//#endregion
-//#region ../../node_modules/.pnpm/audio-recorder-polyfill@0.4.1/node_modules/audio-recorder-polyfill/wave-encoder/index.js
-var wave_encoder_default = () => {
-	let BYTES_PER_SAMPLE = 2;
-	let recorded = [];
-	function encode(buffer) {
-		let length = buffer.length;
-		let data = new Uint8Array(length * BYTES_PER_SAMPLE);
-		for (let i = 0; i < length; i++) {
-			let index = i * BYTES_PER_SAMPLE;
-			let sample = buffer[i];
-			if (sample > 1) sample = 1;
-			else if (sample < -1) sample = -1;
-			sample = sample * 32768;
-			data[index] = sample;
-			data[index + 1] = sample >> 8;
-		}
-		recorded.push(data);
-	}
-	function dump(sampleRate) {
-		let bufferLength = recorded.length ? recorded[0].length : 0;
-		let length = recorded.length * bufferLength;
-		let wav = new Uint8Array(44 + length);
-		let view = new DataView(wav.buffer);
-		view.setUint32(0, 1380533830, false);
-		view.setUint32(4, 36 + length, true);
-		view.setUint32(8, 1463899717, false);
-		view.setUint32(12, 1718449184, false);
-		view.setUint32(16, 16, true);
-		view.setUint16(20, 1, true);
-		view.setUint16(22, 1, true);
-		view.setUint32(24, sampleRate, true);
-		view.setUint32(28, sampleRate * BYTES_PER_SAMPLE, true);
-		view.setUint16(32, BYTES_PER_SAMPLE, true);
-		view.setUint16(34, 8 * BYTES_PER_SAMPLE, true);
-		view.setUint32(36, 1684108385, false);
-		view.setUint32(40, length, true);
-		for (let i = 0; i < recorded.length; i++) wav.set(recorded[i], i * bufferLength + 44);
-		recorded = [];
-		postMessage(wav.buffer, [wav.buffer]);
-	}
-	onmessage = (e) => {
-		if (e.data[0] === "encode") encode(e.data[1]);
-		else if (e.data[0] === "dump") dump(e.data[1]);
-	};
-};
-//#endregion
-//#region ../../node_modules/.pnpm/audio-recorder-polyfill@0.4.1/node_modules/audio-recorder-polyfill/index.js
-let AudioContext = window.AudioContext || window.webkitAudioContext;
-let createWorker = (fn) => {
-	let js = fn.toString().replace(/^(\(\)\s*=>|function\s*\(\))\s*{/, "").replace(/}$/, "");
-	let blob = new Blob([js]);
-	return new Worker(URL.createObjectURL(blob));
-};
-let error = (method) => {
-	let event = new Event("error");
-	event.data = /* @__PURE__ */ new Error("Wrong state for " + method);
-	return event;
-};
-let context;
 /**
-* Audio Recorder with MediaRecorder API.
+* Orchestrates a multi-step Video Selfie session as ONE continuous recording
+* that follows the camera between steps AND auto-advances per step:
 *
-* @example
-* navigator.mediaDevices.getUserMedia({ audio: true }).then(stream => {
-*   let recorder = new MediaRecorder(stream)
-* })
+*   idle ─START▶ [preparingWasm ─▶] acquiringCamera ─▶ starting
+*                                                        │
+*                                                        ▼
+*                              recording ⇄ switchingCamera
+*                                  │            │ busy camera (ENG-57332)
+*                                  │            ▼
+*                                  │      releasingCamera ─settle▶ retry once
+*                                  │ (capture validated → DETECTION_DONE,
+*                                  │  or manual NEXT_STEP)
+*                         last step ─▶ finalizing ─▶ finished
+*
+* While `recording`, a per-step detector runs WASM auto-capture + backend
+* validation; success advances the step (switching the camera when the next
+* step's facing differs), and the final step finalizes the multipart upload.
+*
+* Teardown: `ABORT` is accepted from ANY non-final state and every settled
+* path runs `cleanup`, so no path leaves camera or mic tracks running.
+* XState v5 executes NO exit actions on an external
+* `actor.stop()`, so the manager sends `ABORT` before stopping the actor —
+* never stop this actor directly without aborting first.
 */
-var MediaRecorder = class MediaRecorder {
-	/**
-	* @param {MediaStream} stream The audio stream to record.
-	*/
-	constructor(stream, config = null) {
-		/**
-		* The `MediaStream` passed into the constructor.
-		* @type {MediaStream}
-		*/
-		this.stream = stream;
-		this.config = config;
-		/**
-		* The current state of recording process.
-		* @type {"inactive"|"recording"|"paused"}
-		*/
-		this.state = "inactive";
-		this.em = document.createDocumentFragment();
-		this.encoder = createWorker(MediaRecorder.encoder);
-		let recorder = this;
-		this.encoder.addEventListener("message", (e) => {
-			let event = new Event("dataavailable");
-			event.data = new Blob([e.data], { type: recorder.mimeType });
-			recorder.em.dispatchEvent(event);
-			if (recorder.state === "inactive") recorder.em.dispatchEvent(new Event("stop"));
-		});
-	}
-	/**
-	* Begins recording media.
-	*
-	* @param {number} [timeslice] The milliseconds to record into each `Blob`.
-	*                             If this parameter isn’t included, single `Blob`
-	*                             will be recorded.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* recordButton.addEventListener('click', () => {
-	*   recorder.start()
-	* })
-	*/
-	start(timeslice) {
-		if (this.state !== "inactive") return this.em.dispatchEvent(error("start"));
-		this.state = "recording";
-		if (!context) context = new AudioContext(this.config);
-		this.clone = this.stream.clone();
-		this.input = context.createMediaStreamSource(this.clone);
-		this.processor = context.createScriptProcessor(2048, 1, 1);
-		this.encoder.postMessage(["init", context.sampleRate]);
-		this.processor.onaudioprocess = (e) => {
-			if (this.state === "recording") this.encoder.postMessage(["encode", e.inputBuffer.getChannelData(0)]);
-		};
-		this.input.connect(this.processor);
-		this.processor.connect(context.destination);
-		this.em.dispatchEvent(new Event("start"));
-		if (timeslice) this.slicing = setInterval(() => {
-			if (this.state === "recording") this.requestData();
-		}, timeslice);
-	}
-	/**
-	* Stop media capture and raise `dataavailable` event with recorded data.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* finishButton.addEventListener('click', () => {
-	*   recorder.stop()
-	* })
-	*/
-	stop() {
-		if (this.state === "inactive") return this.em.dispatchEvent(error("stop"));
-		this.requestData();
-		this.state = "inactive";
-		this.clone.getTracks().forEach((track) => {
-			track.stop();
-		});
-		this.processor.disconnect();
-		this.input.disconnect();
-		return clearInterval(this.slicing);
-	}
-	/**
-	* Pauses recording of media streams.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* pauseButton.addEventListener('click', () => {
-	*   recorder.pause()
-	* })
-	*/
-	pause() {
-		if (this.state !== "recording") return this.em.dispatchEvent(error("pause"));
-		this.state = "paused";
-		return this.em.dispatchEvent(new Event("pause"));
+const videoSelfieRecordingSetup = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	delays: {
+		ID_FLIP_DWELL: ID_FLIP_DWELL_MS,
+		FINAL_SUCCESS_DWELL: FINAL_SUCCESS_DWELL_MS,
+		MAX_VIDEO_LENGTH_ERROR_DWELL: MAX_VIDEO_LENGTH_ERROR_DWELL_MS,
+		VALIDATION_FEEDBACK_DWELL: VALIDATION_FEEDBACK_DWELL_MS,
+		CAMERA_RELEASE_SETTLE: CAMERA_RELEASE_SETTLE_MS
+	},
+	actors: {
+		prepareWasm: fromPromise(async ({ input }) => input.ensure()),
+		visibilityChanges: fromCallback(({ input, sendBack }) => input.visibilityObserver.onVisibilityChange((visible) => {
+			sendBack({ type: visible ? "FOREGROUND" : "BACKGROUND" });
+		})),
+		executionTimer: fromCallback(({ input, sendBack, receive }) => {
+			let handle;
+			const cancel = () => {
+				if (handle !== void 0) {
+					input.timer.clearTimeout(handle);
+					handle = void 0;
+				}
+			};
+			receive((event) => {
+				cancel();
+				if (event.type === "ARM") handle = input.timer.setTimeout(() => {
+					handle = void 0;
+					sendBack({ type: "MAX_VIDEO_LENGTH_REACHED" });
+				}, event.durationMs);
+			});
+			return cancel;
+		}),
+		acquireCamera: fromPromise(async ({ input, signal }) => {
+			const stream = await input.acquire(input.facingMode, input.withAudio);
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera acquire cancelled");
+			}
+			return stream;
+		}),
+		switchCamera: fromPromise(async ({ input, signal }) => {
+			const dwellCompleted = waitForDwell(input.minDwellMs, signal);
+			const stream = await input.acquire(input.facingMode, false);
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			if (!await dwellCompleted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			return stream;
+		}),
+		startRecording: fromPromise(async ({ input }) => {
+			await input.service.start(input.stream);
+		}),
+		finalizeRecording: fromPromise(async ({ input }) => input.service.stop()),
+		pauseCapture: fromPromise(async ({ input }) => {
+			const paused = input.service.pause();
+			input.compositor.pause();
+			return paused;
+		}),
+		resumeCompositor: fromPromise(async ({ input, signal }) => input.compositor.resume(signal)),
+		resumeRecorder: fromPromise(async ({ input }) => input.service.resume()),
+		detectStep: fromCallback(({ input, sendBack }) => {
+			const controller = new AbortController();
+			input.detect({
+				step: input.step,
+				stream: input.stream,
+				signal: controller.signal,
+				onStatus: (status) => sendBack({
+					type: "DETECTION_STATUS",
+					status
+				}),
+				onOrientation: (orientation) => sendBack({
+					type: "ORIENTATION",
+					orientation
+				})
+			}).then((result) => {
+				if (result.outcome === "retryableFailure") {
+					sendBack({
+						type: "RETRYABLE_FAILURE",
+						failure: result.failure
+					});
+					return;
+				}
+				if (result.outcome === "validationFailed") {
+					sendBack({
+						type: "VALIDATION_FAILED",
+						failure: result.failure
+					});
+					return;
+				}
+				sendBack({ type: "DETECTION_DONE" });
+			}).catch((err) => {
+				if (!controller.signal.aborted) sendBack({
+					type: "DETECTION_FAILED",
+					error: String(err),
+					kind: isConnectionError(err) ? "connection" : "technical"
+				});
+			});
+			return () => controller.abort();
+		})
+	},
+	actions: {
+		armExecutionTimer: sendTo("executionTimer", ({ context }) => ({
+			type: "ARM",
+			durationMs: context.maxVideoLengthSeconds * 1e3
+		})),
+		cancelExecutionTimer: sendTo("executionTimer", { type: "CANCEL" }),
+		advanceStep: assign({
+			stepIndex: ({ context }) => context.stepIndex + 1,
+			attemptsRemaining: ({ context }) => context.attemptsPerStep,
+			validationFailure: () => void 0,
+			cameraSwitchRetried: () => false
+		}),
+		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
+		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(event) }),
+		setDetectionError: assign({ detectionError: ({ event }) => detectionErrorFromEvent(event) }),
+		setValidationFailure: assign(({ context, event }) => ({
+			attemptsRemaining: context.attemptsRemaining === UNLIMITED_ATTEMPTS ? UNLIMITED_ATTEMPTS : Math.max(0, context.attemptsRemaining - 1),
+			validationFailure: validationFailureFromEvent(event),
+			detectionStatus: "error"
+		})),
+		setUncountedRetryableFailure: assign(({ event }) => ({
+			validationFailure: retryableFailureFromEvent(event),
+			detectionStatus: "error"
+		})),
+		setErrorFromDetection: assign({
+			error: ({ event }) => detectionErrorFromEvent(event),
+			errorKind: ({ event }) => errorKindFromEvent(event)
+		}),
+		clearDetectionFeedback: assign({
+			detectionStatus: () => void 0,
+			detectionError: () => void 0,
+			validationFailure: () => void 0,
+			orientation: () => void 0
+		}),
+		markPageHidden: assign({ isPageVisible: () => false }),
+		markPageVisible: assign({ isPageVisible: () => true }),
+		prepareRecordingSuspension: assign({
+			isPageVisible: () => false,
+			resumeState: () => "recording"
+		}),
+		setUploadFailedError: assign({
+			error: () => "Video upload failed",
+			errorKind: () => "connection"
+		}),
+		setMaxVideoLengthReached: assign({
+			error: () => "maxVideoLengthReached",
+			errorKind: () => "maxVideoLengthReached"
+		}),
+		setValidationAttemptsExhausted: assign({
+			error: () => "Video selfie validation attempts exhausted",
+			errorKind: () => "validationAttemptsExhausted"
+		}),
+		resetSession: assign(({ context }) => ({
+			stepIndex: 0,
+			cameraSwitchRetried: false,
+			stream: void 0,
+			composite: void 0,
+			detectionStatus: void 0,
+			orientation: void 0,
+			detectionError: void 0,
+			validationFailure: void 0,
+			attemptsRemaining: context.attemptsPerStep,
+			recordingId: null,
+			error: void 0,
+			errorKind: void 0,
+			resumeState: "recording"
+		})),
+		cleanup: ({ context }) => {
+			context.service.cleanup();
+			context.compositor.stop();
+			context.stream?.getTracks().forEach((track) => track.stop());
+		},
+		setTechnicalActorError: assign({
+			error: ({ event }) => errorFromEvent(event),
+			errorKind: () => "technical"
+		}),
+		setAudioEndedError: assign({
+			error: () => "Audio track ended while the app was backgrounded",
+			errorKind: () => "technical"
+		}),
+		setCameraResumeError: assign({
+			error: () => "Camera did not produce a fresh frame after foregrounding",
+			errorKind: () => "technical"
+		}),
+		setRecorderResumeError: assign({
+			error: () => "Recording could not resume after foregrounding",
+			errorKind: () => "technical"
+		}),
+		setPauseError: assign({
+			error: () => "Recording could not be paused before backgrounding",
+			errorKind: () => "technical"
+		}),
+		releaseCurrentVideo: ({ context }) => {
+			context.stream?.getVideoTracks().forEach((track) => track.stop());
+		}
+	},
+	guards: {
+		shouldEnterWasmGate: ({ context }) => context.ensureWasmReady !== void 0 && context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
+		isLastStep: ({ context }) => context.stepIndex >= context.steps.length - 1,
+		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining === UNLIMITED_ATTEMPTS || context.attemptsRemaining > 0,
+		nextStepFlipsId: ({ context }) => context.steps[context.stepIndex] === "frontId" && context.steps[context.stepIndex + 1] === "backId",
+		nextStepFlipsCamera: ({ context }) => facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[context.stepIndex + 1]),
+		uploadReturnedNoRecordingId: ({ event }) => recordingIdFromEvent(event) === null,
+		maxVideoLengthWasReached: ({ context }) => context.errorKind === "maxVideoLengthReached",
+		validationAttemptsWereExhausted: ({ context }) => context.errorKind === "validationAttemptsExhausted",
+		errorIsRetryable: ({ context }) => context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
+		canRetryCameraSwitchAfterRelease: ({ context, event }) => !context.cameraSwitchRetried && isCameraBusyError(event.error),
+		pageIsHidden: ({ context }) => !context.isPageVisible,
+		pauseFailed: ({ event }) => !event.output,
+		pauseSucceededWhileVisible: ({ context, event }) => context.isPageVisible && event.output,
+		compositorAudioEnded: ({ event }) => event.output === "audio-ended",
+		compositorDidNotResume: ({ event }) => event.output !== "resumed",
+		forceVideoRecovery: ({ context }) => context.resumeState === "switchingCamera",
+		recorderResumeFailed: ({ event }) => !event.output,
+		resumeValidationFeedback: ({ context }) => context.resumeState === "validationFeedback",
+		resumeFlippingId: ({ context }) => context.resumeState === "flippingId"
 	}
-	/**
-	* Resumes media recording when it has been previously paused.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* resumeButton.addEventListener('click', () => {
-	*   recorder.resume()
-	* })
-	*/
-	resume() {
-		if (this.state !== "paused") return this.em.dispatchEvent(error("resume"));
-		this.state = "recording";
-		return this.em.dispatchEvent(new Event("resume"));
-	}
-	/**
-	* Raise a `dataavailable` event containing the captured media.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* this.on('nextData', () => {
-	*   recorder.requestData()
-	* })
-	*/
-	requestData() {
-		if (this.state === "inactive") return this.em.dispatchEvent(error("requestData"));
-		return this.encoder.postMessage(["dump", context.sampleRate]);
-	}
-	/**
-	* Add listener for specified event type.
-	*
-	* @param {"start"|"stop"|"pause"|"resume"|"dataavailable"|"error"}
-	* type Event type.
-	* @param {function} listener The listener function.
-	*
-	* @return {undefined}
-	*
-	* @example
-	* recorder.addEventListener('dataavailable', e => {
-	*   audio.src = URL.createObjectURL(e.data)
-	* })
-	*/
-	addEventListener(...args) {
-		this.em.addEventListener(...args);
-	}
-	/**
-	* Remove event listener.
-	*
-	* @param {"start"|"stop"|"pause"|"resume"|"dataavailable"|"error"}
-	* type Event type.
-	* @param {function} listener The same function used in `addEventListener`.
-	*
-	* @return {undefined}
-	*/
-	removeEventListener(...args) {
-		this.em.removeEventListener(...args);
+});
+const ADVANCE_TRANSITIONS = [
+	{
+		target: "finalizing",
+		guard: "isLastStep"
+	},
+	{
+		target: "flippingId",
+		guard: "nextStepFlipsId"
+	},
+	{
+		target: "switchingCamera",
+		guard: "nextStepFlipsCamera",
+		actions: "advanceStep"
+	},
+	{
+		target: "recording",
+		reenter: true,
+		actions: "advanceStep"
 	}
-	/**
-	* Calls each of the listeners registered for a given event.
-	*
-	* @param {Event} event The event object.
-	*
-	* @return {boolean} Is event was no canceled by any listener.
-	*/
-	dispatchEvent(...args) {
-		this.em.dispatchEvent(...args);
+];
+const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
+	id: "videoSelfieRecording",
+	initial: "idle",
+	context: ({ input }) => {
+		const visibilityObserver = input.visibilityObserver;
+		const compositor = input.dependencies?.createCompositor?.() ?? createRecordingCompositor();
+		return {
+			service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService("videoselfie", new WorkerEncoderRecordingProvider(compositor)),
+			compositor,
+			acquireCamera: input.dependencies?.acquireCamera ?? defaultAcquireCamera,
+			ensureWasmReady: input.ensureWasmReady,
+			detect: input.dependencies?.detect ?? manualStepDetector,
+			timer: input.dependencies?.timer ?? BrowserTimerProvider.getInstance(),
+			visibilityObserver,
+			isPageVisible: visibilityObserver.isVisible(),
+			resumeState: "recording",
+			steps: input.steps && input.steps.length > 0 ? input.steps : ["selfie"],
+			stepIndex: 0,
+			stream: void 0,
+			composite: void 0,
+			detectionStatus: void 0,
+			orientation: void 0,
+			detectionError: void 0,
+			validationFailure: void 0,
+			attemptsPerStep: normalizeAttempts(input.attemptsPerStep),
+			attemptsRemaining: normalizeAttempts(input.attemptsPerStep),
+			maxVideoLengthSeconds: normalizeMaxVideoLength(input.maxVideoLengthSeconds),
+			recordingId: null,
+			error: void 0,
+			errorKind: void 0,
+			switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS,
+			cameraSwitchRetried: false
+		};
+	},
+	invoke: [{
+		id: "executionTimer",
+		src: "executionTimer",
+		input: ({ context }) => ({ timer: context.timer })
+	}, {
+		id: "visibilityChanges",
+		src: "visibilityChanges",
+		input: ({ context }) => ({ visibilityObserver: context.visibilityObserver })
+	}],
+	on: {
+		ABORT: { target: ".aborted" },
+		BACKGROUND: { actions: "markPageHidden" },
+		FOREGROUND: { actions: "markPageVisible" }
+	},
+	states: {
+		idle: { on: { START: [{
+			target: "preparingWasm",
+			guard: "shouldEnterWasmGate"
+		}, { target: "acquiringCamera" }] } },
+		preparingWasm: { invoke: {
+			src: "prepareWasm",
+			input: ({ context }) => ({ ensure: context.ensureWasmReady }),
+			onDone: { target: "acquiringCamera" },
+			onError: {
+				target: "error",
+				actions: "setTechnicalActorError"
+			}
+		} },
+		acquiringCamera: { invoke: {
+			src: "acquireCamera",
+			input: ({ context }) => ({
+				acquire: context.acquireCamera,
+				facingMode: facingModeForStep(context.steps[context.stepIndex]),
+				withAudio: true
+			}),
+			onDone: {
+				target: "starting",
+				actions: [({ context, event }) => {
+					context.compositor.start(eventOutputStream(event));
+				}, assign({
+					stream: ({ event }) => eventOutputStream(event),
+					composite: ({ context }) => context.compositor.stream
+				})]
+			},
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		starting: { invoke: {
+			src: "startRecording",
+			input: ({ context }) => ({
+				service: context.service,
+				stream: context.composite
+			}),
+			onDone: [{
+				target: "pausing",
+				guard: "pageIsHidden",
+				actions: ["armExecutionTimer", "prepareRecordingSuspension"]
+			}, {
+				target: "recording",
+				actions: "armExecutionTimer"
+			}],
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		recording: {
+			entry: "clearDetectionFeedback",
+			invoke: {
+				src: "detectStep",
+				input: ({ context }) => ({
+					detect: context.detect,
+					step: context.steps[context.stepIndex],
+					stream: context.stream
+				})
+			},
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: "prepareRecordingSuspension"
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				},
+				DETECTION_STATUS: { actions: "setDetectionStatus" },
+				ORIENTATION: { actions: "setOrientation" },
+				DETECTION_DONE: ADVANCE_TRANSITIONS,
+				NEXT_STEP: ADVANCE_TRANSITIONS,
+				VALIDATION_FAILED: {
+					target: "validationFeedback",
+					actions: "setValidationFailure"
+				},
+				RETRYABLE_FAILURE: {
+					target: "validationFeedback",
+					actions: "setUncountedRetryableFailure"
+				},
+				DETECTION_FAILED: {
+					target: "error",
+					actions: "setErrorFromDetection"
+				}
+			}
+		},
+		validationFeedback: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "validationFeedback" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			after: { VALIDATION_FEEDBACK_DWELL: [{
+				target: "recording",
+				guard: "hasAttemptsRemaining"
+			}, {
+				target: "finalizing",
+				actions: "setValidationAttemptsExhausted"
+			}] }
+		},
+		flippingId: {
+			after: { ID_FLIP_DWELL: {
+				target: "recording",
+				actions: "advanceStep"
+			} },
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "flippingId" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				},
+				NEXT_STEP: {
+					target: "recording",
+					actions: "advanceStep"
+				}
+			}
+		},
+		switchingCamera: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			invoke: {
+				src: "switchCamera",
+				input: ({ context }) => ({
+					acquire: context.acquireCamera,
+					facingMode: facingModeForStep(context.steps[context.stepIndex]),
+					minDwellMs: context.switchingCameraMinDwellMs
+				}),
+				onDone: {
+					target: "recording",
+					actions: [({ context, event }) => {
+						context.compositor.switchVideo(eventOutputStream(event));
+					}, assign({ stream: ({ event }) => eventOutputStream(event) })]
+				},
+				onError: [{
+					target: "releasingCamera",
+					guard: "canRetryCameraSwitchAfterRelease"
+				}, {
+					target: "error",
+					actions: assign({ error: ({ event }) => errorFromEvent(event) })
+				}]
+			}
+		},
+		releasingCamera: {
+			entry: ["releaseCurrentVideo", assign({ cameraSwitchRetried: () => true })],
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			after: { CAMERA_RELEASE_SETTLE: { target: "switchingCamera" } }
+		},
+		pausing: {
+			on: { MAX_VIDEO_LENGTH_REACHED: { actions: "setMaxVideoLengthReached" } },
+			invoke: {
+				src: "pauseCapture",
+				input: ({ context }) => ({
+					service: context.service,
+					compositor: context.compositor
+				}),
+				onDone: [
+					{
+						target: "finalizing",
+						guard: "maxVideoLengthWasReached"
+					},
+					{
+						target: "error",
+						guard: "pauseFailed",
+						actions: "setPauseError"
+					},
+					{
+						target: "resumingCompositor",
+						guard: "pauseSucceededWhileVisible"
+					},
+					{ target: "suspended" }
+				],
+				onError: [{
+					target: "finalizing",
+					guard: "maxVideoLengthWasReached"
+				}, {
+					target: "error",
+					actions: "setTechnicalActorError"
+				}]
+			}
+		},
+		suspended: { on: {
+			FOREGROUND: {
+				target: "resumingCompositor",
+				actions: "markPageVisible"
+			},
+			MAX_VIDEO_LENGTH_REACHED: {
+				target: "finalizing",
+				actions: "setMaxVideoLengthReached"
+			}
+		} },
+		resumingCompositor: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: "markPageHidden"
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			invoke: {
+				src: "resumeCompositor",
+				input: ({ context }) => ({ compositor: context.compositor }),
+				onDone: [
+					{
+						target: "error",
+						guard: "compositorAudioEnded",
+						actions: "setAudioEndedError"
+					},
+					{
+						target: "reacquiringCamera",
+						guard: "forceVideoRecovery"
+					},
+					{
+						target: "reacquiringCamera",
+						guard: "compositorDidNotResume"
+					},
+					{ target: "resumingRecorder" }
+				],
+				onError: {
+					target: "error",
+					actions: "setTechnicalActorError"
+				}
+			}
+		},
+		reacquiringCamera: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: "markPageHidden"
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			invoke: {
+				src: "acquireCamera",
+				input: ({ context }) => ({
+					acquire: context.acquireCamera,
+					facingMode: facingModeForStep(context.steps[context.stepIndex]),
+					withAudio: false
+				}),
+				onDone: {
+					target: "validatingRecoveredCamera",
+					actions: [({ context, event }) => {
+						context.compositor.switchVideo(eventOutputStream(event));
+					}, assign({ stream: ({ event }) => eventOutputStream(event) })]
+				},
+				onError: {
+					target: "error",
+					actions: "setTechnicalActorError"
+				}
+			}
+		},
+		validatingRecoveredCamera: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: "markPageHidden"
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			invoke: {
+				src: "resumeCompositor",
+				input: ({ context }) => ({ compositor: context.compositor }),
+				onDone: [
+					{
+						target: "error",
+						guard: "compositorAudioEnded",
+						actions: "setAudioEndedError"
+					},
+					{
+						target: "error",
+						guard: "compositorDidNotResume",
+						actions: "setCameraResumeError"
+					},
+					{ target: "resumingRecorder" }
+				],
+				onError: {
+					target: "error",
+					actions: "setTechnicalActorError"
+				}
+			}
+		},
+		resumingRecorder: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: "markPageHidden"
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			invoke: {
+				src: "resumeRecorder",
+				input: ({ context }) => ({ service: context.service }),
+				onDone: [
+					{
+						target: "error",
+						guard: "recorderResumeFailed",
+						actions: "setRecorderResumeError"
+					},
+					{
+						target: "validationFeedback",
+						guard: "resumeValidationFeedback"
+					},
+					{
+						target: "flippingId",
+						guard: "resumeFlippingId"
+					},
+					{ target: "recording" }
+				],
+				onError: {
+					target: "error",
+					actions: "setTechnicalActorError"
+				}
+			}
+		},
+		finalizing: {
+			entry: "cancelExecutionTimer",
+			invoke: {
+				src: "finalizeRecording",
+				input: ({ context }) => ({ service: context.service }),
+				onDone: [
+					{
+						target: "error",
+						guard: "maxVideoLengthWasReached",
+						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
+					},
+					{
+						target: "error",
+						guard: "validationAttemptsWereExhausted",
+						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
+					},
+					{
+						target: "error",
+						guard: "uploadReturnedNoRecordingId",
+						actions: [assign({ recordingId: ({ event }) => recordingIdFromEvent(event) }), "setUploadFailedError"]
+					},
+					{
+						target: "success",
+						actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
+					}
+				],
+				onError: [
+					{
+						target: "error",
+						guard: "maxVideoLengthWasReached"
+					},
+					{
+						target: "error",
+						guard: "validationAttemptsWereExhausted"
+					},
+					{
+						target: "error",
+						actions: assign({ error: ({ event }) => errorFromEvent(event) })
+					}
+				]
+			}
+		},
+		success: {
+			entry: ["cancelExecutionTimer", "cleanup"],
+			after: { FINAL_SUCCESS_DWELL: "finished" }
+		},
+		finished: { type: "final" },
+		error: {
+			entry: ["cancelExecutionTimer", "cleanup"],
+			after: { MAX_VIDEO_LENGTH_ERROR_DWELL: {
+				target: "finished",
+				guard: "maxVideoLengthWasReached"
+			} },
+			on: { RETRY: [{
+				target: "preparingWasm",
+				guard: "shouldEnterWasmGate",
+				actions: "resetSession"
+			}, {
+				target: "acquiringCamera",
+				guard: "errorIsRetryable",
+				actions: "resetSession"
+			}] }
+		},
+		aborted: {
+			type: "final",
+			entry: ["cancelExecutionTimer", "cleanup"]
+		}
 	}
-};
-/**
-* The MIME type that is being used for recording.
-* @type {string}
-*/
-MediaRecorder.prototype.mimeType = "audio/wav";
+});
+//#endregion
+//#region src/modules/video-selfie/videoSelfieRecordingActor.ts
+function getRecordingSteps(options) {
+	if (options.steps && options.steps.length > 0) return options.steps;
+	if (options.config) return resolveVideoSelfieSteps(options.config);
+}
+function createRetryablePreparation(prepare) {
+	let readiness;
+	return () => {
+		if (!readiness) {
+			readiness = Promise.resolve().then(prepare).catch((error) => {
+				readiness = void 0;
+				throw error;
+			});
+			readiness.catch(() => void 0);
+		}
+		return readiness;
+	};
+}
+function createVideoSelfieRecordingActor(visibilityObserver, options = {}) {
+	const config = options.config;
+	const steps = getRecordingSteps(options);
+	const detect = options.dependencies?.detect ?? (config ? createDefaultStepDetector(config, { getWasmUtil: () => WasmUtilProvider.getInstance() }) : void 0);
+	const prepareWasm = config && steps ? () => warmupVideoSelfieWasm(config, steps) : void 0;
+	const ensureWasmReady = prepareWasm ? createRetryablePreparation(prepareWasm) : void 0;
+	if (ensureWasmReady) ensureWasmReady();
+	if (steps?.includes("speech")) VoiceRecordingProvider.preload();
+	return createActor(videoSelfieRecordingMachine, { input: {
+		steps,
+		attemptsPerStep: config?.numberOfTries,
+		maxVideoLengthSeconds: config?.maxWaitingVideoSelfieFile,
+		visibilityObserver,
+		ensureWasmReady,
+		dependencies: {
+			...options.dependencies,
+			detect
+		}
+	} }).start();
+}
+//#endregion
+//#region src/modules/video-selfie/videoSelfieRecordingManager.ts
+function mapState(snapshot) {
+	const value = typeof snapshot.value === "string" ? snapshot.value : "idle";
+	const { context } = snapshot;
+	const status = value === "preparingWasm" || value === "acquiringCamera" ? "starting" : value === "pausing" || value === "suspended" || value === "resumingCompositor" || value === "reacquiringCamera" || value === "validatingRecoveredCamera" || value === "resumingRecorder" ? "recording" : value === "releasingCamera" ? "switchingCamera" : value;
+	const steps = context.steps;
+	const stepIndex = context.stepIndex;
+	return {
+		status,
+		step: steps[stepIndex],
+		stepIndex,
+		isLastStep: stepIndex >= steps.length - 1,
+		stream: context.stream,
+		composite: context.composite,
+		detectionStatus: context.detectionStatus,
+		orientation: context.orientation,
+		validationFailure: context.validationFailure,
+		attemptsRemaining: context.attemptsRemaining,
+		recordingId: context.recordingId,
+		error: context.error,
+		errorKind: context.errorKind
+	};
+}
+function createApi({ actor }) {
+	return {
+		/** Acquire the first camera, open the upload, and begin recording. */
+		start() {
+			actor.send({ type: "START" });
+		},
+		retry() {
+			actor.send({ type: "RETRY" });
+		},
+		/**
+		* Advance to the next step. Switches the camera when the next step's
+		* facing mode differs; finalizes the upload on the last step.
+		*/
+		nextStep() {
+			actor.send({ type: "NEXT_STEP" });
+		},
+		/** Abandon the session without finalizing the upload. */
+		abort() {
+			actor.send({ type: "ABORT" });
+		}
+	};
+}
 /**
-* Returns `true` if the MIME type specified is one the polyfill can record.
-*
-* This polyfill supports `audio/wav` and `audio/mpeg`.
-*
-* @param {string} mimeType The mimeType to check.
+* Creates a manager for a multi-step, camera-switching Video Selfie recording.
 *
-* @return {boolean} `true` on `audio/wav` and `audio/mpeg` MIME type.
+* The whole session records as one continuous video that follows the camera
+* across steps (front for selfie, rear for ID). Exposes `getState()` /
+* `subscribe()` (status, step, preview `stream`, `recordingId`) plus `start()`,
+* `nextStep()`, and `abort()`.
 */
-MediaRecorder.isTypeSupported = (mimeType) => {
-	return MediaRecorder.prototype.mimeType === mimeType;
-};
+function createVideoSelfieRecordingManager(options = {}) {
+	const actor = createVideoSelfieRecordingActor(options.dependencies?.visibilityObserver ?? new BrowserVisibilityObserverProvider(), options);
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		beforeStop: () => actor.send({ type: "ABORT" })
+	});
+}
+//#endregion
+//#region src/modules/video-selfie/videoSelfieSpeechService.ts
 /**
-* `true` if MediaRecorder can not be polyfilled in the current browser.
-* @type {boolean}
-*
-* @example
-* if (MediaRecorder.notSupported) {
-*   showWarning('Audio recording is not supported in this browser')
-* }
+* Fetches `count` random challenge questions the user answers out loud. The
+* spoken answers are captured in the main video recording (no separate upload)
+* and verified server-side.
 */
-MediaRecorder.notSupported = !navigator.mediaDevices || !AudioContext;
+async function getVideoSelfieQuestions(count) {
+	return (await api.get(endpoints.questionAndAnswer, { query: {
+		numberOfQuestions: count,
+		returnVoiceConsentQuestion: false
+	} })).data.questionAndAnswers ?? [];
+}
 /**
-* Converts RAW audio buffer to compressed audio files.
-* It will be loaded to Web Worker.
-* By default, WAVE encoder will be used.
-* @type {function}
-*
-* @example
-* MediaRecorder.prototype.mimeType = 'audio/ogg'
-* MediaRecorder.encoder = oggEncoder
+* Fetches the voice-consent phrase the user must read aloud. The phrase is the
+* `answer` of the consent question returned when `returnVoiceConsentQuestion`
+* is requested with no challenge questions.
 */
-MediaRecorder.encoder = wave_encoder_default;
-//#endregion
-//#region ../../node_modules/.pnpm/audio-recorder-polyfill@0.4.1/node_modules/audio-recorder-polyfill/mpeg-encoder/index.js
-var mpeg_encoder_default = () => {
-	importScripts("https://cdnjs.cloudflare.com/ajax/libs/lamejs/1.2.0/lame.min.js");
-	let CHANNELS = 1;
-	let KBPS = 128;
-	let DEFAULT_SAMPLE_RATE = 44100;
-	let encoder;
-	let recorded = /* @__PURE__ */ new Int8Array();
-	function concat(a, b) {
-		if (b.length === 0) return a;
-		let c = new Int8Array(a.length + b.length);
-		c.set(a);
-		c.set(b, a.length);
-		return c;
-	}
-	function init(sampleRate) {
-		encoder = new lamejs.Mp3Encoder(CHANNELS, sampleRate || DEFAULT_SAMPLE_RATE, KBPS);
-	}
-	function encode(buffer) {
-		for (let i = 0; i < buffer.length; i++) buffer[i] = buffer[i] * 32767.5;
-		let buf = encoder.encodeBuffer(buffer);
-		recorded = concat(recorded, buf);
-	}
-	function dump() {
-		let buf = encoder.flush();
-		recorded = concat(recorded, buf);
-		let buffer = recorded.buffer;
-		recorded = /* @__PURE__ */ new Int8Array();
-		postMessage(buffer, [buffer]);
-	}
-	onmessage = (e) => {
-		if (e.data[0] === "init") init(e.data[1]);
-		else if (e.data[0] === "encode") encode(e.data[1]);
-		else dump(e.data[1]);
-	};
-};
-//#endregion
-//#region ../infra/src/media/blobEncoding.ts
-/** Encodes a blob as raw base64 bytes (no `data:...;base64,` prefix). */
-function blobToRawBase64(blob) {
-	return new Promise((resolve, reject) => {
-		const reader = new FileReader();
-		reader.onloadend = () => {
-			const result = reader.result;
-			if (typeof result !== "string") {
-				reject(/* @__PURE__ */ new Error("Failed to encode blob as base64"));
-				return;
-			}
-			const commaIndex = result.indexOf(",");
-			resolve(commaIndex >= 0 ? result.slice(commaIndex + 1) : result);
-		};
-		reader.onerror = () => {
-			reject(reader.error ?? /* @__PURE__ */ new Error("Failed to read blob"));
-		};
-		reader.readAsDataURL(blob);
-	});
+async function getVoiceConsentPhrase() {
+	return (await api.get(endpoints.questionAndAnswer, { query: {
+		numberOfQuestions: 0,
+		returnVoiceConsentQuestion: true
+	} })).data.questionAndAnswers?.[0]?.answer ?? "";
 }
-//#endregion
-//#region ../infra/src/providers/browser/VoiceRecordingProvider.ts
-const AudioRecorderPolyfill = MediaRecorder;
-AudioRecorderPolyfill.encoder = mpeg_encoder_default;
-AudioRecorderPolyfill.prototype.mimeType = "audio/mpeg";
-const MIME_TYPE = "audio/mpeg";
 /**
-* Records the audio of a stream and produces a single MP3 blob. Used by the
-* Video Selfie voice-consent step to capture the spoken consent phrase
-* independently of the main video recording (which keeps running on its own
-* recorder).
-*
-* Records from a clone of the supplied stream so stopping this recorder never
-* tears down tracks the main recording is still using.
+* Uploads the recorded consent audio (base64 MP3) for speech-to-text
+* validation. Resolves `{ success: false }` on a network/validation error so
+* the UI can drive its retry loop instead of throwing.
 */
-var VoiceRecordingProvider = class {
-	constructor() {
-		this.recorder = null;
-		this.chunks = [];
-		this._isRecording = false;
-	}
-	get isRecording() {
-		return this._isRecording;
-	}
-	start(stream) {
-		this.reset();
-		this.chunks = [];
-		const audioOnly = new MediaStream(stream.getAudioTracks());
-		const recorder = new AudioRecorderPolyfill(audioOnly.clone());
-		recorder.mimeType = MIME_TYPE;
-		recorder.addEventListener("dataavailable", (event) => {
-			if (event.data.size > 0) this.chunks.push(event.data);
-		});
-		recorder.start();
-		this.recorder = recorder;
-		this._isRecording = true;
-	}
-	stop() {
-		const recorder = this.recorder;
-		return new Promise((resolve) => {
-			if (!recorder || !this._isRecording) {
-				resolve(new Blob([], { type: MIME_TYPE }));
-				return;
-			}
-			recorder.addEventListener("stop", () => {
-				this._isRecording = false;
-				recorder.stream?.getTracks().forEach((track) => track.stop());
-				this.recorder = null;
-				resolve(new Blob(this.chunks, { type: MIME_TYPE }));
-			});
-			recorder.stop();
-		});
-	}
-	async stopAsBase64() {
-		const blob = await this.stop();
-		if (blob.size === 0) return "";
-		return blobToRawBase64(blob);
-	}
-	reset() {
-		const recorder = this.recorder;
-		if (recorder && this._isRecording) {
-			try {
-				recorder.stop();
-			} catch {}
-			recorder.stream?.getTracks().forEach((track) => track.stop());
-		}
-		this.recorder = null;
-		this._isRecording = false;
+async function addSpeech(base64Mp3) {
+	try {
+		return { success: (await api.post(endpoints.addSpeechV2, {
+			base64Media: base64Mp3,
+			audioOnly: true
+		})).data.success === true };
+	} catch {
+		return { success: false };
 	}
-};
+}
 //#endregion
 //#region src/modules/video-selfie/videoSelfieConsentRecorder.ts
 function createConsentRecorder() {