@incodetech/core 2.2.0-rc.8 → 2.3.0-rc.0

package/dist/video-selfie.esm.js

@@ -1,431 +1,21 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { c as abortVideoSelfieUpload, d as uploadVideoSelfiePart, l as completeVideoSelfieUpload, t as ensureWasmPipelines, u as initiateVideoSelfieUpload } from "./setup-CXj5ozZN.esm.js";
+import { t as ensureWasmPipelines } from "./setup-msLybMbC.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { d as videoSelfieWasmPipelines, l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-CD5m8HqZ.esm.js";
-import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
+import { d as facingModeForStep, f as resolveVideoSelfieSteps, p as videoSelfieWasmPipelines } from "./flowServices-B5FwukTQ.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 { n as getSupportedMediaRecorderMimeType } from "./mediaRecorderOptions-dALSV8af.esm.js";
-import { i as createDefaultStepDetector, n as defaultAcquireCamera, o as isConnectionError, r as CameraCompositor, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-BhTWYfGn.esm.js";
-//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
-/**
-* How often `MediaRecorder` hands us buffered data (incremental blobs).
-* 500 ms keeps each blob — and therefore each upload chunk — small: less
-* tail lost when a session is interrupted, and a smaller first blob (init
-* header + keyframe), which is the largest and most timeout-prone chunk.
-* Not lower: request rate doubles per halving, and browsers stop honoring
-* very small timeslices reliably.
-*/
-const TIMESLICE_MS = 500;
-/**
-* Encoder target for the full video-selfie session. Higher than the
-* short-clip liveness path (0.5–1 Mbps) so a multi-minute session keeps
-* usable quality. It's a ceiling — a still scene still encodes well below it.
-*/
-const VIDEO_BITS_PER_SECOND = 25e5;
-/**
-* Records a stream and emits every `MediaRecorder` timeslice blob as its own
-* part, in order. Each blob is a whole container fragment (WebM cluster /
-* fMP4 `moof`+`mdat`), which is the property the video-selfie-service's
-* gap-splicing depends on — parts must never cut a fragment at a byte
-* offset. The service stages sub-5 MiB chunks and combines them server-side,
-* so emitting the smallest whole-fragment unit (~0.5 s of video) maximizes
-* what an interrupted session can salvage.
-*
-* Unlike the short-clip liveness recorder, this does NOT auto-pause on
-* `visibilitychange`: a video-selfie session must record continuously, and a
-* pause with no resume would silently truncate the recording the moment the
-* tab lost visibility.
-*/
-var MultipartRecordingProvider = class {
-	constructor() {
-		this.mediaRecorder = null;
-		this._isRecording = false;
-		this._hasError = false;
-		this._error = null;
-		this.mimeType = "";
-		this.partNumber = 0;
-		this.onPart = null;
-	}
-	get isRecording() {
-		return this._isRecording;
-	}
-	get hasError() {
-		return this._hasError;
-	}
-	get error() {
-		return this._error;
-	}
-	startRecording(stream, onPart) {
-		this.reset();
-		this.partNumber = 0;
-		this.onPart = onPart;
-		try {
-			this.mimeType = getSupportedMediaRecorderMimeType();
-			const recorder = new MediaRecorder(stream.clone(), {
-				mimeType: this.mimeType,
-				videoBitsPerSecond: VIDEO_BITS_PER_SECOND
-			});
-			recorder.ondataavailable = (event) => {
-				if (event.data.size > 0 && this.onPart) {
-					this.partNumber += 1;
-					this.onPart({
-						chunk: event.data,
-						partNumber: this.partNumber
-					});
-				}
-			};
-			recorder.onerror = (event) => {
-				const detail = event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type;
-				this._error = `Recording error: ${detail}`;
-				this._isRecording = false;
-				this._hasError = true;
-			};
-			recorder.start(TIMESLICE_MS);
-			this.mediaRecorder = recorder;
-			this._isRecording = true;
-			this._error = null;
-			this._hasError = false;
-		} catch (err) {
-			const detail = err instanceof Error ? err.message : String(err);
-			this._error = `Failed to start recording: ${detail}`;
-			this._hasError = true;
-		}
-	}
-	stopRecording() {
-		const recorder = this.mediaRecorder;
-		return new Promise((resolve) => {
-			if (recorder && this._isRecording) {
-				recorder.onstop = () => {
-					resolve();
-				};
-				recorder.stop();
-				this._isRecording = false;
-			} else resolve();
-			recorder?.stream?.getTracks().forEach((track) => track.stop());
-		});
-	}
-	reset() {
-		const recorder = this.mediaRecorder;
-		if (recorder) {
-			recorder.ondataavailable = null;
-			recorder.onerror = null;
-			recorder.onstop = null;
-			if (recorder.state !== "inactive") recorder.stop();
-			recorder.stream.getTracks().forEach((track) => track.stop());
-			this.mediaRecorder = null;
-		}
-		this.onPart = null;
-		this._isRecording = false;
-		this._error = null;
-		this._hasError = false;
-	}
-};
-//#endregion
-//#region ../infra/src/providers/browser/BrowserNetworkStatusProvider.ts
-var BrowserNetworkStatusProvider = class {
-	onOnline(listener) {
-		if (typeof window === "undefined" || typeof window.addEventListener !== "function") return () => {};
-		window.addEventListener("online", listener);
-		return () => {
-			window.removeEventListener("online", listener);
-		};
-	}
-};
-//#endregion
-//#region src/internal/recordings/videoSelfieChunkUploader.ts
-/**
-* How many part uploads run concurrently. The service allows 10 rps with a
-* burst of 30 per session; a real recorder emits ~2 chunks/s, so this cap
-* only matters when a backlog is draining after a network stall.
-*/
-const MAX_IN_FLIGHT = 3;
-/** Attempts per chunk in the live round (first try + retries). */
-const MAX_ATTEMPTS = 4;
-/** Extra attempts per parked chunk during the final drain() round. */
-const DRAIN_ATTEMPTS = 2;
-const BACKOFF_BASE_MS = 500;
-const BACKOFF_CAP_MS = 8e3;
-/** Upper bound honored for a server-sent `Retry-After` (seconds). */
-const RETRY_AFTER_CAP_MS = 3e4;
-/**
-* Ceiling on un-acknowledged chunk bytes held in memory. On a network slower
-* than the encoder the backlog grows without bound; past this the upload
-* cannot realistically catch up, so the uploader fails instead of eating
-* memory on a low-end device. ~48 MiB ≈ 2.5 minutes of video at our bitrate.
-*/
-const MAX_BUFFERED_BYTES = 48 * 1024 * 1024;
-function httpStatusOf$1(error) {
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
-	return null;
-}
-function retryAfterMsOf(error) {
-	if (typeof error === "object" && error !== null && "headers" in error && typeof error.headers === "object") {
-		const headers = error.headers;
-		const seconds = Number(headers?.["retry-after"]);
-		if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
-	}
-	return null;
-}
-/**
-* Uploads video-selfie chunks with the client-side half of the service's
-* resilience contract (`video-selfie-service` README, "What a client can
-* rely on"):
-*
-* - **Keep-until-ack** — every chunk is held in memory until its upload
-*   returns 200 (a hole in the sequence can only be filled by that exact
-*   data). Acked bytes are durable in S3 (stored as a part or staged), so
-*   the blob is released the moment the ack lands.
-* - **Retry with backoff** — transient failures (network error/timeout,
-*   408, 429, 5xx) retry the same bytes under the same partNumber with
-*   exponential backoff + full jitter; 429 honors the server's
-*   `Retry-After`. Chunks may land out of order — the service stages them.
-* - **Park, then drain** — a chunk that exhausts its live retries is parked
-*   (blob kept) without failing the recording; {@link drain} gives every
-*   parked chunk a final round once recording stops, so a mid-recording
-*   network outage only fails the upload if it persists to the end. A
-*   browser `online` event un-parks early: parked chunks get a fresh live
-*   round as soon as connectivity returns instead of waiting for stop.
-* - **409 is fatal** — a newer initiate fenced this session out ("latest
-*   initiate wins"); no retry can succeed, so the uploader stops.
-* - **Bounded memory** — when un-acked bytes exceed the ceiling the
-*   uploader fails rather than buffering a runaway backlog.
-*/
-var VideoSelfieChunkUploader = class {
-	constructor(session, dependencies = {}) {
-		this.queue = [];
-		this.parked = [];
-		this.inFlight = 0;
-		this.bufferedBytes = 0;
-		this.fatal = false;
-		this.disposed = false;
-		this.tasks = [];
-		this.session = session;
-		this.timer = dependencies.timer ?? BrowserTimerProvider.getInstance();
-		this.jitter = dependencies.jitter ?? Math.random;
-		const networkStatus = dependencies.networkStatus ?? new BrowserNetworkStatusProvider();
-		this.unsubscribeOnline = networkStatus.onOnline(() => this.unparkEarly());
-	}
-	/** True once the upload cannot complete (fenced out or over the memory cap). */
-	get failed() {
-		return this.fatal;
-	}
-	/**
-	* Accepts the next chunk for upload. Non-blocking: the upload (and any
-	* retries) run in the background; failures surface through {@link failed}
-	* and {@link drain}.
-	*/
-	enqueue(partNumber, chunk) {
-		if (this.fatal || this.disposed) return;
-		this.bufferedBytes += chunk.size;
-		if (this.bufferedBytes > MAX_BUFFERED_BYTES) {
-			this.fatal = true;
-			return;
-		}
-		this.queue.push({
-			partNumber,
-			chunk,
-			attempts: 0
-		});
-		this.pump();
-	}
-	/**
-	* Waits for every accepted chunk to be acknowledged, giving parked chunks
-	* one final retry round. Returns `true` when all chunks landed and the
-	* upload can be completed.
-	*/
-	async drain() {
-		this.unsubscribeOnline();
-		await this.settleLiveRound();
-		while (!this.fatal && this.parked.length > 0) {
-			const chunk = this.parked.shift();
-			chunk.attempts = MAX_ATTEMPTS - DRAIN_ATTEMPTS;
-			this.queue.push(chunk);
-			this.pump();
-			await this.settleLiveRound();
-			if (this.parked.some((p) => p.partNumber === chunk.partNumber)) return false;
-		}
-		return !this.fatal && this.parked.length === 0;
-	}
-	/** Cancels all pending work; held blobs are released. */
-	dispose() {
-		this.disposed = true;
-		this.queue = [];
-		this.parked = [];
-		this.unsubscribeOnline();
-	}
-	/**
-	* Connectivity is back (browser `online` event) — give parked chunks a
-	* fresh live round right away instead of holding them until {@link drain}.
-	* The event is only a hint: chunks that still fail simply park again.
-	*/
-	unparkEarly() {
-		if (this.fatal || this.disposed || this.parked.length === 0) return;
-		for (const chunk of this.parked.splice(0)) {
-			chunk.attempts = 0;
-			this.queue.push(chunk);
-		}
-		this.pump();
-	}
-	async settleLiveRound() {
-		while (this.tasks.length > 0) {
-			const snapshot = [...this.tasks];
-			await Promise.all(snapshot);
-			this.tasks = this.tasks.filter((task) => !snapshot.includes(task));
-		}
-	}
-	pump() {
-		while (!this.fatal && !this.disposed && this.inFlight < MAX_IN_FLIGHT && this.queue.length > 0) {
-			const chunk = this.queue.shift();
-			this.inFlight += 1;
-			const task = this.uploadWithRetry(chunk).finally(() => {
-				this.inFlight -= 1;
-				this.pump();
-			});
-			this.tasks.push(task);
-		}
-	}
-	async uploadWithRetry(pending) {
-		while (!this.disposed) {
-			pending.attempts += 1;
-			try {
-				await uploadVideoSelfiePart(this.session, pending.partNumber, pending.chunk);
-				this.bufferedBytes -= pending.chunk.size;
-				return;
-			} catch (error) {
-				const status = httpStatusOf$1(error);
-				if (status === 409) {
-					this.fatal = true;
-					return;
-				}
-				if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || pending.attempts >= MAX_ATTEMPTS) {
-					this.parked.push(pending);
-					return;
-				}
-				await this.delayBeforeRetry(pending.attempts, error);
-			}
-		}
-	}
-	delayBeforeRetry(attempt, error) {
-		const retryAfterMs = retryAfterMsOf(error);
-		const backoffCeiling = Math.min(BACKOFF_BASE_MS * 2 ** (attempt - 1), BACKOFF_CAP_MS);
-		const waitMs = retryAfterMs ?? backoffCeiling / 2 + this.jitter() * (backoffCeiling / 2);
-		return new Promise((resolve) => {
-			this.timer.setTimeout(resolve, waitMs);
-		});
-	}
-};
-//#endregion
-//#region src/internal/recordings/multipartRecordingService.ts
-/** Attempts for `complete` — documented safe to repeat if the response was lost. */
-const COMPLETE_ATTEMPTS = 3;
-const COMPLETE_BACKOFF_MS = 500;
-function httpStatusOf(error) {
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return error.status;
-	return null;
+import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BrJN1B8A.esm.js";
+import { t as MultipartRecordingService } from "./multipartRecordingService-B3C_zlev.esm.js";
+import { i as CameraCompositor } from "./idCaptureDefaults-BcxjQDI3.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-CB1IzZkt.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));
 }
-/**
-* Records the camera on-device and streams it to the backend as it is
-* captured, using the video-selfie-service multipart upload protocol
-* (`/v1/video-upload/*`).
-*
-* This is the Video Selfie module's client-side recorder and is deliberately
-* independent of the face-capture recording services (`LocalRecordingService`
-* / `OpenViduRecordingService`) — it is the replacement for server-side
-* (OpenVidu) recording, not a sibling of it.
-*
-* Every ~1 s recorder blob uploads as its own chunk, concurrently with
-* recording, through {@link VideoSelfieChunkUploader} (keep-until-ack +
-* retry with backoff — see its doc for the full policy). The service stages
-* sub-5 MiB chunks and combines them server-side, so `stop()` only drains
-* the stragglers and finalizes; client memory holds un-acked chunks only.
-* No client-side encryption: video is encrypted at rest server-side
-* (S3 SSE-AES-256).
-*/
-var MultipartRecordingService = class {
-	constructor() {
-		this.recorder = new MultipartRecordingProvider();
-		this.timer = BrowserTimerProvider.getInstance();
-		this.session = null;
-		this.uploader = null;
-		this.chunksEmitted = 0;
-	}
-	get isRecording() {
-		return this.recorder.isRecording;
-	}
-	async start(stream) {
-		let initiated = await initiateVideoSelfieUpload();
-		if (initiated.parts.length > 0) {
-			await abortVideoSelfieUpload(initiated).catch(() => {});
-			initiated = await initiateVideoSelfieUpload();
-		}
-		this.session = {
-			uploadId: initiated.uploadId,
-			epoch: initiated.epoch
-		};
-		this.uploader = new VideoSelfieChunkUploader(this.session);
-		this.chunksEmitted = 0;
-		this.recorder.startRecording(stream, ({ chunk, partNumber }) => {
-			this.chunksEmitted += 1;
-			this.uploader?.enqueue(partNumber, chunk);
-		});
-	}
-	async stop() {
-		const session = this.session;
-		const uploader = this.uploader;
-		if (!this.recorder.isRecording || !session || !uploader) return { recordingId: null };
-		await this.recorder.stopRecording();
-		if (!await uploader.drain() || uploader.failed || this.chunksEmitted === 0) {
-			this.abandonUpload(session);
-			return { recordingId: null };
-		}
-		try {
-			await this.completeWithRetry(session);
-			this.session = null;
-			this.uploader = null;
-			return { recordingId: session.uploadId };
-		} catch {
-			this.abandonUpload(session);
-			return { recordingId: null };
-		}
-	}
-	cleanup() {
-		if (this.session) this.abandonUpload(this.session);
-		this.recorder.reset();
-	}
-	/**
-	* `complete` is idempotent server-side ("safe to repeat if the response
-	* was lost"), so transient failures — network errors, 5xx, 429 — retry a
-	* couple of times before the recording is declared failed. A 4xx (e.g.
-	* `400` naming a missing part) is permanent: after a clean drain every
-	* chunk was acked, so a reported hole cannot be filled from here.
-	*/
-	async completeWithRetry(session) {
-		for (let attempt = 1;; attempt += 1) try {
-			await completeVideoSelfieUpload(session);
-			return;
-		} catch (error) {
-			const status = httpStatusOf(error);
-			if (status !== null && status >= 400 && status < 500 && status !== 408 && status !== 429 || attempt >= COMPLETE_ATTEMPTS) throw error;
-			await new Promise((resolve) => {
-				this.timer.setTimeout(resolve, COMPLETE_BACKOFF_MS * attempt);
-			});
-		}
-	}
-	/**
-	* Fire-and-forget abort: the upload can no longer complete, so tell the
-	* backend to fail it immediately rather than at its expiry. Best-effort —
-	* an abort that doesn't land (including a 409 from a newer epoch having
-	* taken over) just means the server falls back to expiry or salvage.
-	*/
-	abandonUpload(session) {
-		this.session = null;
-		this.uploader?.dispose();
-		this.uploader = null;
-		abortVideoSelfieUpload(session).catch(() => {});
-	}
-};
 //#endregion
 //#region src/modules/video-selfie/videoSelfieRecordingMachine.ts
 /** A detector that never settles — used when a step has no auto-capture yet. */
@@ -460,21 +50,19 @@ function orientationFromEvent(event) {
 const SWITCHING_CAMERA_MIN_DWELL_MS = 3e3;
 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 isIdStep(step) {
-	return step === "frontId" || step === "backId";
-}
-function nextModuleIndex(context) {
-	let index = context.stepIndex + 1;
-	while (isIdStep(context.steps[index])) index += 1;
-	return index;
+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();
@@ -495,10 +83,13 @@ function waitForDwell(ms, signal) {
 * Orchestrates a multi-step Video Selfie session as ONE continuous recording
 * that follows the camera between steps AND auto-advances per step:
 *
-*   idle ─START▶ acquiringCamera ─▶ starting ─▶ recording ⇄ switchingCamera
-*                                                   │ (capture validated → DETECTION_DONE,
-*                                                   │  or manual NEXT_STEP)
-*                                          last step ─▶ finalizing ─▶ finished
+*   idle ─START▶ [preparingWasm ─▶] acquiringCamera ─▶ starting
+*                                                        │
+*                                                        ▼
+*                              recording ⇄ switchingCamera
+*                                  │ (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
@@ -519,9 +110,31 @@ const videoSelfieRecordingSetup = setup({
 	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
 	},
 	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) {
@@ -551,6 +164,13 @@ const videoSelfieRecordingSetup = setup({
 			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({
@@ -592,16 +212,16 @@ const videoSelfieRecordingSetup = setup({
 		})
 	},
 	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
 		}),
-		advancePastIdSection: assign({
-			stepIndex: ({ context }) => nextModuleIndex(context),
-			attemptsRemaining: ({ context }) => context.attemptsPerStep,
-			validationFailure: () => void 0
-		}),
 		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
 		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(event) }),
 		setDetectionError: assign({ detectionError: ({ event }) => detectionErrorFromEvent(event) }),
@@ -624,10 +244,24 @@ const videoSelfieRecordingSetup = setup({
 			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,
 			stream: void 0,
@@ -639,26 +273,54 @@ const videoSelfieRecordingSetup = setup({
 			attemptsRemaining: context.attemptsPerStep,
 			recordingId: null,
 			error: void 0,
-			errorKind: 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"
+		})
 	},
 	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",
-		exhaustedIdFinishes: ({ context }) => isIdStep(context.steps[context.stepIndex]) && nextModuleIndex(context) >= context.steps.length,
-		nextModuleFlipsCamera: ({ context }) => isIdStep(context.steps[context.stepIndex]) && facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[nextModuleIndex(context)]),
-		isIdExhaustion: ({ context }) => isIdStep(context.steps[context.stepIndex]),
-		exhaustedNonIdFinishes: ({ context }) => !isIdStep(context.steps[context.stepIndex]) && context.stepIndex >= context.steps.length - 1,
-		exhaustedNonIdNextStepFlipsCamera: ({ context }) => !isIdStep(context.steps[context.stepIndex]) && facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[context.stepIndex + 1]),
-		isNonIdExhaustion: ({ context }) => !isIdStep(context.steps[context.stepIndex]),
 		nextStepFlipsCamera: ({ context }) => facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[context.stepIndex + 1]),
-		uploadReturnedNoRecordingId: ({ event }) => recordingIdFromEvent(event) === null
+		uploadReturnedNoRecordingId: ({ event }) => recordingIdFromEvent(event) === null,
+		maxVideoLengthWasReached: ({ context }) => context.errorKind === "maxVideoLengthReached",
+		validationAttemptsWereExhausted: ({ context }) => context.errorKind === "validationAttemptsExhausted",
+		errorIsRetryable: ({ context }) => context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
+		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 = [
@@ -684,29 +346,63 @@ const ADVANCE_TRANSITIONS = [
 const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 	id: "videoSelfieRecording",
 	initial: "idle",
-	context: ({ input }) => ({
-		service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService(),
-		compositor: input.dependencies?.createCompositor?.() ?? new CameraCompositor(),
-		acquireCamera: input.dependencies?.acquireCamera ?? defaultAcquireCamera,
-		detect: input.dependencies?.detect ?? manualStepDetector,
-		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),
-		recordingId: null,
-		error: void 0,
-		errorKind: void 0,
-		switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS
-	}),
-	on: { ABORT: { target: ".aborted" } },
+	context: ({ input }) => {
+		const visibilityObserver = input.visibilityObserver;
+		return {
+			service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService(),
+			compositor: input.dependencies?.createCompositor?.() ?? new CameraCompositor(),
+			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
+		};
+	},
+	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: "acquiringCamera" } } },
+		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 }) => ({
@@ -734,7 +430,14 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 				service: context.service,
 				stream: context.composite
 			}),
-			onDone: { target: "recording" },
+			onDone: [{
+				target: "pausing",
+				guard: "pageIsHidden",
+				actions: ["armExecutionTimer", "prepareRecordingSuspension"]
+			}, {
+				target: "recording",
+				actions: "armExecutionTimer"
+			}],
 			onError: {
 				target: "error",
 				actions: assign({ error: ({ event }) => errorFromEvent(event) })
@@ -751,6 +454,14 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 				})
 			},
 			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,
@@ -769,111 +480,354 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 				}
 			}
 		},
-		validationFeedback: { after: { VALIDATION_FEEDBACK_DWELL: [{
-			target: "recording",
-			guard: "hasAttemptsRemaining"
-		}, ...[
-			{
-				target: "finalizing",
-				guard: "exhaustedIdFinishes"
-			},
-			{
-				target: "switchingCamera",
-				guard: "nextModuleFlipsCamera",
-				actions: "advancePastIdSection"
+		validationFeedback: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "validationFeedback" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
 			},
-			{
+			after: { VALIDATION_FEEDBACK_DWELL: [{
 				target: "recording",
-				reenter: true,
-				guard: "isIdExhaustion",
-				actions: "advancePastIdSection"
-			},
-			{
+				guard: "hasAttemptsRemaining"
+			}, {
 				target: "finalizing",
-				guard: "exhaustedNonIdFinishes"
-			},
-			{
-				target: "switchingCamera",
-				guard: "exhaustedNonIdNextStepFlipsCamera",
-				actions: "advanceStep"
-			},
-			{
-				target: "recording",
-				reenter: true,
-				guard: "isNonIdExhaustion",
-				actions: "advanceStep"
-			}
-		]] } },
+				actions: "setValidationAttemptsExhausted"
+			}] }
+		},
 		flippingId: {
 			after: { ID_FLIP_DWELL: {
 				target: "recording",
 				actions: "advanceStep"
 			} },
-			on: { NEXT_STEP: {
-				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: { 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) })]
+		switchingCamera: {
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
 			},
-			onError: {
-				target: "error",
-				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			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: "error",
+					actions: assign({ error: ({ event }) => errorFromEvent(event) })
+				}
 			}
-		} },
-		finalizing: { invoke: {
-			src: "finalizeRecording",
-			input: ({ context }) => ({ service: context.service }),
-			onDone: [{
-				target: "error",
-				guard: "uploadReturnedNoRecordingId",
-				actions: [assign({ recordingId: ({ event }) => recordingIdFromEvent(event) }), "setUploadFailedError"]
-			}, {
-				target: "success",
-				actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
-			}],
-			onError: {
-				target: "error",
-				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+		},
+		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: "cleanup",
+			entry: ["cancelExecutionTimer", "cleanup"],
 			after: { FINAL_SUCCESS_DWELL: "finished" }
 		},
 		finished: { type: "final" },
 		error: {
-			entry: "cleanup",
-			on: { RETRY: {
+			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: "cleanup"
+			entry: ["cancelExecutionTimer", "cleanup"]
 		}
 	}
 });
 //#endregion
 //#region src/modules/video-selfie/videoSelfieRecordingActor.ts
-function createVideoSelfieRecordingActor(options = {}) {
+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: config ? resolveVideoSelfieSteps(config) : void 0,
+		steps,
 		attemptsPerStep: config?.numberOfTries,
+		maxVideoLengthSeconds: config?.maxWaitingVideoSelfieFile,
+		visibilityObserver,
+		ensureWasmReady,
 		dependencies: {
 			...options.dependencies,
 			detect
@@ -885,7 +839,7 @@ function createVideoSelfieRecordingActor(options = {}) {
 function mapState(snapshot) {
 	const value = typeof snapshot.value === "string" ? snapshot.value : "idle";
 	const { context } = snapshot;
-	const status = value === "acquiringCamera" ? "starting" : value;
+	const status = value === "preparingWasm" || value === "acquiringCamera" ? "starting" : value === "pausing" || value === "suspended" || value === "resumingCompositor" || value === "reacquiringCamera" || value === "validatingRecoveredCamera" || value === "resumingRecorder" ? "recording" : value;
 	const steps = context.steps;
 	const stepIndex = context.stepIndex;
 	return {
@@ -935,7 +889,7 @@ function createApi({ actor }) {
 * `nextStep()`, and `abort()`.
 */
 function createVideoSelfieRecordingManager(options = {}) {
-	const actor = createVideoSelfieRecordingActor(options);
+	const actor = createVideoSelfieRecordingActor(options.dependencies?.visibilityObserver ?? new BrowserVisibilityObserverProvider(), options);
 	const manager = createManager({
 		actor,
 		mapState,
@@ -950,21 +904,6 @@ function createVideoSelfieRecordingManager(options = {}) {
 	};
 }
 //#endregion
-//#region src/modules/video-selfie/videoSelfieWasm.ts
-/**
-* Warms the WASM pipelines the Video Selfie flow needs (face detection, plus the
-* ID-capture pipeline when `checkIdScan` is on), reusing the WASM config stored
-* by `setup({ wasm })`.
-*
-* Idempotent and safe to call eagerly — the UI invokes it when the tutorial
-* mounts so the models finish loading while the user reads the instructions, and
-* detection is ready the instant recording starts (mirrors how the selfie and ID
-* modules warm up during their tutorials). No-op when WASM was not configured.
-*/
-function warmupVideoSelfieWasm(config) {
-	return ensureWasmPipelines(videoSelfieWasmPipelines(config));
-}
-//#endregion
 //#region src/modules/video-selfie/videoSelfieSpeechService.ts
 /**
 * Fetches `count` random challenge questions the user answers out loud. The
@@ -1071,7 +1010,7 @@ let context;
 *   let recorder = new MediaRecorder(stream)
 * })
 */
-var MediaRecorder$1 = class MediaRecorder$1 {
+var MediaRecorder = class MediaRecorder {
 	/**
 	* @param {MediaStream} stream The audio stream to record.
 	*/
@@ -1088,7 +1027,7 @@ var MediaRecorder$1 = class MediaRecorder$1 {
 		*/
 		this.state = "inactive";
 		this.em = document.createDocumentFragment();
-		this.encoder = createWorker(MediaRecorder$1.encoder);
+		this.encoder = createWorker(MediaRecorder.encoder);
 		let recorder = this;
 		this.encoder.addEventListener("message", (e) => {
 			let event = new Event("dataavailable");
@@ -1238,7 +1177,7 @@ var MediaRecorder$1 = class MediaRecorder$1 {
 * The MIME type that is being used for recording.
 * @type {string}
 */
-MediaRecorder$1.prototype.mimeType = "audio/wav";
+MediaRecorder.prototype.mimeType = "audio/wav";
 /**
 * Returns `true` if the MIME type specified is one the polyfill can record.
 *
@@ -1248,8 +1187,8 @@ MediaRecorder$1.prototype.mimeType = "audio/wav";
 *
 * @return {boolean} `true` on `audio/wav` and `audio/mpeg` MIME type.
 */
-MediaRecorder$1.isTypeSupported = (mimeType) => {
-	return MediaRecorder$1.prototype.mimeType === mimeType;
+MediaRecorder.isTypeSupported = (mimeType) => {
+	return MediaRecorder.prototype.mimeType === mimeType;
 };
 /**
 * `true` if MediaRecorder can not be polyfilled in the current browser.
@@ -1260,7 +1199,7 @@ MediaRecorder$1.isTypeSupported = (mimeType) => {
 *   showWarning('Audio recording is not supported in this browser')
 * }
 */
-MediaRecorder$1.notSupported = !navigator.mediaDevices || !AudioContext;
+MediaRecorder.notSupported = !navigator.mediaDevices || !AudioContext;
 /**
 * Converts RAW audio buffer to compressed audio files.
 * It will be loaded to Web Worker.
@@ -1271,7 +1210,7 @@ MediaRecorder$1.notSupported = !navigator.mediaDevices || !AudioContext;
 * MediaRecorder.prototype.mimeType = 'audio/ogg'
 * MediaRecorder.encoder = oggEncoder
 */
-MediaRecorder$1.encoder = wave_encoder_default;
+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 = () => {
@@ -1332,7 +1271,7 @@ function blobToRawBase64(blob) {
 }
 //#endregion
 //#region ../infra/src/providers/browser/VoiceRecordingProvider.ts
-const AudioRecorderPolyfill = MediaRecorder$1;
+const AudioRecorderPolyfill = MediaRecorder;
 AudioRecorderPolyfill.encoder = mpeg_encoder_default;
 AudioRecorderPolyfill.prototype.mimeType = "audio/mpeg";
 const MIME_TYPE = "audio/mpeg";
@@ -1419,34 +1358,4 @@ function createConsentRecorder() {
 	};
 }
 //#endregion
-//#region src/modules/video-selfie/videoSelfieFlowModuleMachine.ts
-/**
-* Parked flow-module machine for the `VIDEO_ONBOARDING` step.
-*
-* The video-selfie UI component owns the entire capture / streaming / upload
-* lifecycle (it creates its own {@link createVideoSelfieRecordingManager}) and
-* signals completion to the flow via `flowManager.completeModule()`
-* (`MODULE_COMPLETE`). This machine therefore only needs to hold the step open:
-* it starts in a non-final `running` state and never transitions, so the
-* orchestrated flow stays in `runningModule` until the UI advances it.
-*
-* **Completion contract:** the L2 `incode-video-selfie` web component calls
-* `flowManager.completeModule()` once the recording manager reaches `finished`.
-* Recoverable errors stay inside the module until the user retries.
-*
-* **Abort / unmount:** if the user closes the module or the web component
-* unmounts before completion, the orchestrated flow manager's existing close /
-* abort path (`MODULE_CLOSE` / session teardown) is responsible for exiting the
-* step. This parked machine does not model those paths itself.
-*
-* Contrast {@link noOpFlowModuleMachine}, whose initial state is `final` — that
-* is used for headless steps (e.g. `IP_ADDRESS`) that must complete instantly
-* with no UI. Using a no-op here would skip the video-selfie UI entirely.
-*/
-const videoSelfieFlowModuleMachine = setup({}).createMachine({
-	id: "videoSelfieFlowModule",
-	initial: "running",
-	states: { running: {} }
-});
-//#endregion
-export { createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };
+export { VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE, createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };