@incodetech/core 2.1.0-rc.2 → 2.1.0-rc.4

package/dist/video-selfie.esm.js

@@ -0,0 +1,1506 @@
+import { t as WasmUtilProvider } from "./WasmUtilProvider-ADG54T6M.esm.js";
+import { t as ensureWasmPipelines } from "./setup-hKBHwm6K.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import "./clientLifecycle-Ct7h9uxx.esm.js";
+import "./events-1wxZ97yf.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import "./stats-BVy52wLy.esm.js";
+import "./browserSimulation-DFpmweuc.esm.js";
+import "./sessionInitializer-CzPdr0Q1.esm.js";
+import "./thumbmarkAdapter-CVyiGp0-.esm.js";
+import "./platform-BoeUeUrV.esm.js";
+import "./tri-CFBjqf5E.esm.js";
+import { a as fromPromise, i as fromCallback, l as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
+import "./MotionSensorProvider-BkHKMCPE.esm.js";
+import { t as checkPermission } from "./permissionServices-D9lmzFYc.esm.js";
+import { i as requestCameraWithFallback } from "./camera-B0yWS33x.esm.js";
+import { a as encryptSelfieImage, b as FaceDetectionProvider, l as startDetection, m as uploadSelfie, p as processFace, y as StreamCanvasProcessingSession } from "./onDeviceFaceResults-BdfKrQrf.esm.js";
+import "./ITimerCapability-G7lQg-be.esm.js";
+import "./canvas-DsJa51yU.esm.js";
+import "./backCameraStream-POavVKz4.esm.js";
+import "./video-DXf5H9rY.esm.js";
+import { n as getWindowDimensions } from "./getDeviceClass-BdgmyOOu.esm.js";
+import "./deepsightService-BsLpJT8o.esm.js";
+import "./getDeviceClass-QxbJwsOO.esm.js";
+import "./types-Db2ooXIu.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CRk7c7u7.esm.js";
+import { n as getSupportedMediaRecorderMimeType } from "./mediaRecorderOptions-BIn657lu.esm.js";
+import { n as resolveVideoSelfieSteps, r as videoSelfieWasmPipelines, t as facingModeForStep } from "./videoSelfieSteps-C6E7mKFt.esm.js";
+import { i as IdCaptureProvider, n as DEFAULT_ID_CAPTURE_MODEL_VERSION, r as DEFAULT_ID_CAPTURE_THRESHOLDS, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-DJmo-U3D.esm.js";
+
+//#region src/modules/video-selfie/videoSelfieCompareService.ts
+async function postVideoSelfieCompare(endpoint, base64Image) {
+	return (await api.post(endpoint, { base64Image })).data;
+}
+/** Compare a front-ID frame from the video selfie against the captured ID. */
+const compareVideoSelfieId = (base64Image) => postVideoSelfieCompare(endpoints.videoSelfieCompareId, base64Image);
+/** Compare OCR from a front-ID frame against the captured ID's OCR. */
+const compareVideoSelfieOcr = (base64Image) => postVideoSelfieCompare(endpoints.videoSelfieCompareOcr, base64Image);
+/** Compare a back-ID frame from the video selfie against the captured ID. */
+const compareVideoSelfieBackId = (base64Image) => postVideoSelfieCompare(endpoints.videoSelfieCompareBackId, base64Image);
+/** Compare OCR from a back-ID frame against the captured ID's OCR. */
+const compareVideoSelfieBackOcr = (base64Image) => postVideoSelfieCompare(endpoints.videoSelfieCompareBackOcr, base64Image);
+
+//#endregion
+//#region src/modules/video-selfie/videoSelfieStepDetector.ts
+/** Default autocapture window for the selfie step when the config omits one. */
+const SELFIE_AUTOCAPTURE_MS = 1e4;
+/**
+* Whether the backend reported a confident face match on a front-ID compare.
+* The backend normalizes `faceRecognitionConfidence` to 0 (no match) or 1 (match).
+*/
+function isFaceRecognitionMatch(confidence) {
+	if (typeof confidence !== "number") return true;
+	return confidence >= 1;
+}
+/**
+* Max selfie capture attempts before the step fails. Each backend rejection
+* (e.g. 4077 low quality / liveness) re-arms the pipeline and scans again;
+* after this many tries the step rejects. Mirrors V1's `numberOfTries`.
+*/
+const MAX_SELFIE_ATTEMPTS = 3;
+/**
+* How long the ID step holds on the "success" state (green check) after the
+* backend validates a side, before advancing. Gives the user a beat to see the
+* capture succeeded instead of the step jumping silently. Mirrors V1's
+* IdVideoSelfie success flash.
+*/
+const ID_SUCCESS_DWELL_MS = 900;
+/**
+* How long an ID step holds the "show the front / back of your ID" instruction
+* before autocapture is armed. No frame is captured or validated during this
+* window, so the guidance can't be overwritten by capture feedback before the
+* user has read it. Mirrors the UI's `ID_INSTRUCTION_DWELL_MS` message pin.
+*/
+const ID_INSTRUCTION_DWELL_MS = 3e3;
+/** Resolves after `ms`, or rejects early if `signal` aborts. */
+function delay(ms, signal) {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	return new Promise((resolve, reject) => {
+		const timer = timerProvider.setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			timerProvider.clearTimeout(timer);
+			reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Builds the default per-step detector from the module config. Today it
+* auto-captures the `selfie` step (face detection → `add/face` → `process/face`);
+* ID / proof-of-address / questions / speech advance manually until their
+* detectors land.
+*/
+function createDefaultStepDetector(config, deps) {
+	return ({ step, stream, signal, onStatus }) => {
+		if (step === "selfie") return detectSelfie({
+			config,
+			deps,
+			stream,
+			signal,
+			onStatus
+		});
+		if (step === "frontId" || step === "backId") return detectId({
+			step,
+			config,
+			stream,
+			signal,
+			onStatus
+		});
+		return new Promise(() => {});
+	};
+}
+async function detectSelfie(params) {
+	const { config, deps, stream, signal, onStatus } = params;
+	const provider = new FaceDetectionProvider();
+	await provider.initialize({
+		autocaptureInterval: SELFIE_AUTOCAPTURE_MS,
+		useOnDeviceWorkflow: false,
+		videoSelfie: true
+	});
+	provider.setChecksEnabled({
+		lenses: config.validateLenses ?? false,
+		mask: config.validateFaceMask ?? false,
+		closedEyes: config.validateClosedEyes ?? false,
+		headWear: config.validateHeadCover ?? false,
+		occlusion: false
+	});
+	const imageType = config.useAsSelfie === true ? "selfie" : "videoSelfie";
+	const capturer = new StreamCanvasCapture(stream);
+	const detectionConfig = {
+		showTutorial: false,
+		validateBrightness: false,
+		validateLenses: config.validateLenses ?? false,
+		validateFaceMask: config.validateFaceMask ?? false,
+		validateClosedEyes: config.validateClosedEyes ?? false,
+		validateHeadCover: config.validateHeadCover ?? false,
+		autoCaptureTimeout: SELFIE_AUTOCAPTURE_MS / 1e3
+	};
+	const runAttempt = () => new Promise((resolve, reject) => {
+		const onAbort = () => {
+			detection.cleanup();
+			reject(/* @__PURE__ */ new Error("aborted"));
+		};
+		const settle = (run) => {
+			signal.removeEventListener("abort", onAbort);
+			run();
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		const detection = startDetection({
+			config: detectionConfig,
+			capturer,
+			provider,
+			onUpdate: (status) => onStatus?.(status),
+			onSuccess: (canvas, faceCoordinates) => {
+				(async () => {
+					try {
+						await uploadSelfie({
+							encryptedBase64Image: await encryptSelfieImage({
+								canvas,
+								dependencies: { getWasmUtil: async () => deps.getWasmUtil() }
+							}),
+							faceCoordinates,
+							imageType
+						});
+						await processFace(imageType);
+						settle(resolve);
+					} catch (error$1) {
+						settle(() => reject(error$1 instanceof Error ? error$1 : new Error(String(error$1))));
+					}
+				})();
+			}
+		});
+	});
+	try {
+		for (let attempt = 1; attempt <= MAX_SELFIE_ATTEMPTS; attempt++) try {
+			await runAttempt();
+			return;
+		} catch (error$1) {
+			if (signal.aborted || attempt >= MAX_SELFIE_ATTEMPTS) throw error$1;
+			onStatus?.("error");
+			provider.reset();
+			await delay(1500, signal);
+		}
+	} finally {
+		capturer.dispose();
+		provider.dispose();
+	}
+}
+async function detectId(params) {
+	const { step, config, stream, signal, onStatus } = params;
+	const provider = new IdCaptureProvider();
+	await provider.initialize({ videoSelfie: true });
+	const windowDimensions = getWindowDimensions();
+	provider.setGeometry({
+		...DEFAULT_ID_CAPTURE_GEOMETRY,
+		windowOuterWidth: windowDimensions.outerWidth,
+		windowOuterHeight: windowDimensions.outerHeight,
+		windowInnerWidth: windowDimensions.innerWidth,
+		windowInnerHeight: windowDimensions.innerHeight
+	});
+	provider.setSettings({
+		isFixedMask: false,
+		isIPhone14OrHigher: false,
+		idType: step === "backId" ? "BackId" : "FrontId",
+		blurCheckEnabled: true,
+		glareCheckEnabled: false,
+		faceQualityCheckEnabled: false,
+		iouCheckEnabled: true,
+		fpsLimitEnabled: false
+	});
+	provider.setThresholds(DEFAULT_ID_CAPTURE_THRESHOLDS);
+	provider.setModelType(DEFAULT_ID_CAPTURE_MODEL_VERSION);
+	const capturer = new StreamCanvasCapture(stream);
+	return new Promise((resolve, reject) => {
+		let validating = false;
+		let armed = false;
+		provider.setCallbacks({
+			onFarAway: () => {
+				if (armed && !validating) onStatus?.("tooFar");
+			},
+			onBlur: () => {
+				if (armed && !validating) onStatus?.("blur");
+			},
+			onCapturing: () => {
+				if (!armed || validating) return;
+				const base64Image = capturer.getLatestCanvas()?.getBase64Image();
+				if (!base64Image) return;
+				validating = true;
+				onStatus?.("capturing");
+				(async () => {
+					try {
+						if (await validateIdFrame(step, config, base64Image)) {
+							onStatus?.("success");
+							await delay(ID_SUCCESS_DWELL_MS, signal);
+							teardown();
+							resolve();
+							return;
+						}
+						validating = false;
+					} catch (error$1) {
+						teardown();
+						reject(error$1 instanceof Error ? error$1 : new Error(String(error$1)));
+					}
+				})();
+			}
+		});
+		const session = new StreamCanvasProcessingSession({
+			capturer,
+			provider
+		});
+		let toreDown = false;
+		const teardown = () => {
+			if (toreDown) return;
+			toreDown = true;
+			session.dispose();
+			capturer.dispose();
+			provider.dispose();
+		};
+		signal.addEventListener("abort", () => {
+			teardown();
+			reject(/* @__PURE__ */ new Error("aborted"));
+		}, { once: true });
+		delay(ID_INSTRUCTION_DWELL_MS, signal).then(() => {
+			if (toreDown || signal.aborted) return;
+			armed = true;
+			onStatus?.("detecting");
+		}).catch(() => {});
+	});
+}
+/** Runs the configured ID/OCR comparisons for a captured ID frame. */
+async function validateIdFrame(step, config, base64Image) {
+	if (step === "backId") {
+		if (config.compareBackIdEnabled) {
+			const result = await compareVideoSelfieBackId(base64Image);
+			if (result.idSideMatched === false || result.success === false) return false;
+		}
+		if (config.compareBackOcrEnabled) {
+			if ((await compareVideoSelfieBackOcr(base64Image)).success === false) return false;
+		}
+		return true;
+	}
+	if (config.compareIdEnabled) {
+		const result = await compareVideoSelfieId(base64Image);
+		if (result.idTypeMatched === false) return false;
+		if (typeof result.faceRecognitionConfidence === "number" && !isFaceRecognitionMatch(result.faceRecognitionConfidence)) return false;
+	}
+	if (config.compareOcrEnabled) {
+		if ((await compareVideoSelfieOcr(base64Image)).success === false) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region ../infra/src/media/CameraCompositor.ts
+/**
+* Composites the *active* camera into a canvas and exposes the canvas as a
+* single, stable `MediaStream` to record. Switching cameras (front ↔ back)
+* just repoints what the canvas draws — the output stream and its audio track
+* are never replaced — so a single `MediaRecorder` produces one continuous
+* video that follows the camera switches (V1 parity), instead of restarting
+* per camera.
+*
+* The audio track from the initial stream is carried through unchanged across
+* video switches, so there's no audio glitch when the camera flips.
+*/
+var CameraCompositor = class {
+	constructor(options = {}) {
+		this.canvas = null;
+		this.ctx = null;
+		this.video = null;
+		this.rafId = null;
+		this.audioTrack = null;
+		this.videoTrack = null;
+		this.composite = null;
+		this.fps = options.fps ?? 30;
+	}
+	/**
+	* Begin compositing `stream` and return the composite stream to record. The
+	* stream's audio track (if any) is carried through unchanged across later
+	* `switchVideo` calls.
+	*/
+	start(stream) {
+		this.canvas = document.createElement("canvas");
+		this.ctx = this.canvas.getContext("2d");
+		this.video = document.createElement("video");
+		this.video.muted = true;
+		this.video.playsInline = true;
+		this.audioTrack = stream.getAudioTracks()[0] ?? null;
+		this.setVideoSource(stream);
+		const composite = this.canvas.captureStream(this.fps);
+		if (this.audioTrack) composite.addTrack(this.audioTrack);
+		this.composite = composite;
+		this.startDrawLoop();
+		return composite;
+	}
+	/**
+	* Swap the camera feeding the canvas without interrupting the composite
+	* stream. Pass a video-only stream (audio is kept from `start`). The previous
+	* video track is stopped.
+	*/
+	switchVideo(stream) {
+		if (!this.composite) return;
+		const previousVideoTrack = this.videoTrack;
+		this.setVideoSource(stream);
+		if (previousVideoTrack) previousVideoTrack.stop();
+	}
+	/** The composite stream being recorded, if compositing is active. */
+	get stream() {
+		return this.composite ?? void 0;
+	}
+	/** Stop compositing and release the canvas, audio, and video tracks. */
+	stop() {
+		if (this.rafId !== null) {
+			cancelAnimationFrame(this.rafId);
+			this.rafId = null;
+		}
+		this.videoTrack?.stop();
+		this.audioTrack?.stop();
+		this.composite?.getTracks().forEach((track) => track.stop());
+		if (this.video) this.video.srcObject = null;
+		this.canvas = null;
+		this.ctx = null;
+		this.video = null;
+		this.videoTrack = null;
+		this.audioTrack = null;
+		this.composite = null;
+	}
+	setVideoSource(stream) {
+		this.videoTrack = stream.getVideoTracks()[0] ?? null;
+		const video = this.video;
+		if (!video) return;
+		video.srcObject = new MediaStream(stream.getVideoTracks());
+		video.play().catch(() => {});
+	}
+	startDrawLoop() {
+		const draw = () => {
+			const video = this.video;
+			const canvas = this.canvas;
+			const ctx = this.ctx;
+			if (video && canvas && ctx && video.videoWidth > 0) {
+				if (canvas.width !== video.videoWidth || canvas.height !== video.videoHeight) {
+					canvas.width = video.videoWidth;
+					canvas.height = video.videoHeight;
+				}
+				ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			}
+			this.rafId = requestAnimationFrame(draw);
+		};
+		this.rafId = requestAnimationFrame(draw);
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
+/**
+* S3 multipart requires every part except the last to be at least 5 MB, so we
+* buffer recorded data until it crosses this threshold before emitting a part.
+*/
+const MIN_PART_SIZE_BYTES = 5 * 1024 * 1024;
+/**
+* How often `MediaRecorder` hands us buffered data (incremental blobs).
+*/
+const TIMESLICE_MS = 1e3;
+/**
+* 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 and accumulates past the 5 MB part threshold instead of compressing a
+* near-static face down to a single sub-5 MB part. It's a ceiling — a still
+* scene still encodes well below it.
+*/
+const VIDEO_BITS_PER_SECOND = 25e5;
+/**
+* Records a stream and streams it out as size-bounded parts for S3 multipart
+* upload. Parts are emitted during recording (not buffered to the end), so the
+* client never holds more than ~one part in memory regardless of video length.
+*
+* 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.buffer = [];
+		this.bufferedBytes = 0;
+		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.buffer = [];
+		this.bufferedBytes = 0;
+		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.buffer.push(event.data);
+					this.bufferedBytes += event.data.size;
+					if (this.bufferedBytes >= MIN_PART_SIZE_BYTES) this.flushPart();
+				}
+			};
+			recorder.onerror = (event) => {
+				this._error = `Recording error: ${event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start(TIMESLICE_MS);
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			this._error = `Failed to start recording: ${err instanceof Error ? err.message : String(err)}`;
+			this._hasError = true;
+		}
+	}
+	stopRecording() {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve) => {
+			if (recorder && this._isRecording) {
+				recorder.onstop = () => {
+					this.flushPart();
+					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.buffer = [];
+		this.bufferedBytes = 0;
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+	flushPart() {
+		if (this.bufferedBytes === 0 || !this.onPart) return;
+		const chunk = new Blob(this.buffer, { type: this.mimeType });
+		this.partNumber += 1;
+		this.onPart({
+			chunk,
+			partNumber: this.partNumber
+		});
+		this.buffer = [];
+		this.bufferedBytes = 0;
+	}
+};
+
+//#endregion
+//#region src/internal/recordings/videoSelfieUploadService.ts
+/**
+* Opens a multipart video-selfie upload session. The returned `uploadId`
+* identifies the session for subsequent part uploads and completion.
+*/
+async function initiateVideoSelfieUpload() {
+	return (await api.post(endpoints.videoSelfieUploadInitiate, {})).data.uploadId;
+}
+/**
+* Uploads a single chunk as a multipart part. The body is the raw video bytes
+* (no base64, no client-side encryption — encryption at rest is server-side
+* S3 SSE). Returns the part number + `eTag` needed to complete the upload.
+*/
+async function uploadVideoSelfiePart(uploadId, partNumber, chunk) {
+	const response = await api.post(endpoints.videoSelfieUploadPart, chunk, {
+		query: {
+			uploadId,
+			partNumber
+		},
+		headers: { "Content-Type": "application/octet-stream" }
+	});
+	return {
+		partNumber: response.data.partNumber,
+		eTag: response.data.eTag
+	};
+}
+/**
+* Finalizes the upload. `parts` must be in ascending `partNumber` order, or
+* S3 reassembly fails. Returns the server-reported status.
+*/
+async function completeVideoSelfieUpload(uploadId, parts) {
+	return (await api.post(endpoints.videoSelfieUploadComplete, {
+		uploadId,
+		parts
+	})).data.status;
+}
+
+//#endregion
+//#region src/internal/recordings/multipartRecordingService.ts
+/**
+* Records the camera on-device and streams it to the backend as it is
+* captured, using the S3 multipart upload protocol
+* (`/omni/video-selfie/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.
+*
+* Parts upload concurrently with recording, so `stop()` only flushes the final
+* part and finalizes — keeping the whole session inside the server's
+* video-selfie timeout regardless of length, with client memory bounded to
+* ~one part. No client-side encryption: video is encrypted at rest server-side
+* (S3 SSE-AES-256).
+*/
+var MultipartRecordingService = class {
+	constructor() {
+		this.recorder = new MultipartRecordingProvider();
+		this.uploadId = null;
+		this.parts = [];
+		this.inflight = [];
+		this.uploadFailed = false;
+	}
+	get isRecording() {
+		return this.recorder.isRecording;
+	}
+	async start(stream) {
+		this.uploadId = await initiateVideoSelfieUpload();
+		this.parts = [];
+		this.inflight = [];
+		this.uploadFailed = false;
+		this.recorder.startRecording(stream, ({ chunk, partNumber }) => {
+			const uploadId = this.uploadId;
+			if (!uploadId) return;
+			const task = uploadVideoSelfiePart(uploadId, partNumber, chunk).then((part) => {
+				this.parts.push(part);
+			}).catch(() => {
+				this.uploadFailed = true;
+			});
+			this.inflight.push(task);
+		});
+	}
+	async stop() {
+		const uploadId = this.uploadId;
+		if (!this.recorder.isRecording || !uploadId) return { recordingId: null };
+		await this.recorder.stopRecording();
+		await Promise.all(this.inflight);
+		if (this.uploadFailed || this.parts.length === 0) return { recordingId: null };
+		const orderedParts = [...this.parts].sort((a, b) => a.partNumber - b.partNumber);
+		try {
+			await completeVideoSelfieUpload(uploadId, orderedParts);
+			return { recordingId: uploadId };
+		} catch {
+			return { recordingId: null };
+		}
+	}
+	cleanup() {
+		this.recorder.reset();
+	}
+};
+
+//#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 defaultAcquireCamera(facingMode, withAudio) {
+	return requestCameraWithFallback({
+		video: { facingMode },
+		audio: withAudio
+	});
+}
+function eventOutputStream(event) {
+	return event.output;
+}
+function recordingIdFromEvent(event) {
+	return event.output.recordingId;
+}
+function errorFromEvent(event) {
+	return String(event.error);
+}
+function detectionStatusFromEvent(event) {
+	return event.status;
+}
+function detectionErrorFromEvent(event) {
+	return event.error;
+}
+/**
+* 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
+*
+* 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 terminal
+* state runs `cleanup` on entry, so no settled 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.
+*/
+const videoSelfieRecordingSetup = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		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;
+		}),
+		startRecording: fromPromise(async ({ input }) => {
+			await input.service.start(input.stream);
+		}),
+		finalizeRecording: fromPromise(async ({ input }) => input.service.stop()),
+		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
+				})
+			}).then(() => sendBack({ type: "DETECTION_DONE" })).catch((err) => {
+				if (!controller.signal.aborted) sendBack({
+					type: "DETECTION_FAILED",
+					error: String(err)
+				});
+			});
+			return () => controller.abort();
+		})
+	},
+	actions: {
+		advanceStep: assign({ stepIndex: ({ context: context$1 }) => context$1.stepIndex + 1 }),
+		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
+		setDetectionError: assign({ detectionError: ({ event }) => detectionErrorFromEvent(event) }),
+		setErrorFromDetection: assign({ error: ({ event }) => detectionErrorFromEvent(event) }),
+		clearDetectionFeedback: assign({
+			detectionStatus: () => void 0,
+			detectionError: () => void 0
+		}),
+		setUploadFailedError: assign({ error: () => "Video upload failed" }),
+		cleanup: ({ context: context$1 }) => {
+			context$1.service.cleanup();
+			context$1.compositor.stop();
+			context$1.stream?.getTracks().forEach((track) => track.stop());
+		}
+	},
+	guards: {
+		isLastStep: ({ context: context$1 }) => context$1.stepIndex >= context$1.steps.length - 1,
+		nextStepFlipsCamera: ({ context: context$1 }) => facingModeForStep(context$1.steps[context$1.stepIndex]) !== facingModeForStep(context$1.steps[context$1.stepIndex + 1]),
+		uploadReturnedNoRecordingId: ({ event }) => recordingIdFromEvent(event) === null
+	}
+});
+const ADVANCE_TRANSITIONS = [
+	{
+		target: "finalizing",
+		guard: "isLastStep"
+	},
+	{
+		target: "switchingCamera",
+		guard: "nextStepFlipsCamera",
+		actions: "advanceStep"
+	},
+	{
+		target: "recording",
+		reenter: true,
+		actions: "advanceStep"
+	}
+];
+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,
+		detectionError: void 0,
+		recordingId: null,
+		error: void 0
+	}),
+	on: { ABORT: { target: ".aborted" } },
+	states: {
+		idle: { on: { START: { target: "acquiringCamera" } } },
+		acquiringCamera: { invoke: {
+			src: "acquireCamera",
+			input: ({ context: context$1 }) => ({
+				acquire: context$1.acquireCamera,
+				facingMode: facingModeForStep(context$1.steps[context$1.stepIndex]),
+				withAudio: true
+			}),
+			onDone: {
+				target: "starting",
+				actions: [({ context: context$1, event }) => {
+					context$1.compositor.start(eventOutputStream(event));
+				}, assign({
+					stream: ({ event }) => eventOutputStream(event),
+					composite: ({ context: context$1 }) => context$1.compositor.stream
+				})]
+			},
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		starting: { invoke: {
+			src: "startRecording",
+			input: ({ context: context$1 }) => ({
+				service: context$1.service,
+				stream: context$1.composite
+			}),
+			onDone: { target: "recording" },
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		recording: {
+			entry: "clearDetectionFeedback",
+			invoke: {
+				src: "detectStep",
+				input: ({ context: context$1 }) => ({
+					detect: context$1.detect,
+					step: context$1.steps[context$1.stepIndex],
+					stream: context$1.stream
+				})
+			},
+			on: {
+				DETECTION_STATUS: { actions: "setDetectionStatus" },
+				DETECTION_DONE: ADVANCE_TRANSITIONS,
+				NEXT_STEP: ADVANCE_TRANSITIONS,
+				DETECTION_FAILED: {
+					target: "error",
+					actions: "setErrorFromDetection"
+				}
+			}
+		},
+		switchingCamera: { invoke: {
+			src: "acquireCamera",
+			input: ({ context: context$1 }) => ({
+				acquire: context$1.acquireCamera,
+				facingMode: facingModeForStep(context$1.steps[context$1.stepIndex]),
+				withAudio: false
+			}),
+			onDone: {
+				target: "recording",
+				actions: [({ context: context$1, event }) => {
+					context$1.compositor.switchVideo(eventOutputStream(event));
+				}, assign({ stream: ({ event }) => eventOutputStream(event) })]
+			},
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		finalizing: { invoke: {
+			src: "finalizeRecording",
+			input: ({ context: context$1 }) => ({ service: context$1.service }),
+			onDone: [{
+				target: "error",
+				guard: "uploadReturnedNoRecordingId",
+				actions: [assign({ recordingId: ({ event }) => recordingIdFromEvent(event) }), "setUploadFailedError"]
+			}, {
+				target: "finished",
+				actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
+			}],
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		finished: {
+			type: "final",
+			entry: "cleanup"
+		},
+		error: {
+			type: "final",
+			entry: "cleanup"
+		},
+		aborted: {
+			type: "final",
+			entry: "cleanup"
+		}
+	}
+});
+const videoSelfieRecordingMachine = _videoSelfieRecordingMachine;
+
+//#endregion
+//#region src/modules/video-selfie/videoSelfieRecordingActor.ts
+function createVideoSelfieRecordingActor(options = {}) {
+	const config = options.config;
+	const detect = options.dependencies?.detect ?? (config ? createDefaultStepDetector(config, { getWasmUtil: () => WasmUtilProvider.getInstance() }) : void 0);
+	return createActor(videoSelfieRecordingMachine, { input: {
+		steps: config ? resolveVideoSelfieSteps(config) : void 0,
+		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: context$1 } = snapshot;
+	const status = value === "acquiringCamera" ? "starting" : value;
+	const steps = context$1.steps;
+	const stepIndex = context$1.stepIndex;
+	return {
+		status,
+		step: steps[stepIndex],
+		stepIndex,
+		isLastStep: stepIndex >= steps.length - 1,
+		stream: context$1.stream,
+		composite: context$1.composite,
+		detectionStatus: context$1.detectionStatus,
+		recordingId: context$1.recordingId,
+		error: context$1.error
+	};
+}
+function createApi({ actor }) {
+	return {
+		start() {
+			actor.send({ type: "START" });
+		},
+		nextStep() {
+			actor.send({ type: "NEXT_STEP" });
+		},
+		abort() {
+			actor.send({ type: "ABORT" });
+		}
+	};
+}
+/**
+* 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()`.
+*/
+function createVideoSelfieRecordingManager(options = {}) {
+	const actor = createVideoSelfieRecordingActor(options);
+	const manager = createManager({
+		actor,
+		mapState,
+		createApi
+	});
+	return {
+		...manager,
+		stop() {
+			if (actor.getSnapshot().status === "active") actor.send({ type: "ABORT" });
+			manager.stop();
+		}
+	};
+}
+
+//#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/videoSelfieCameraWarmer.ts
+function defaultAcquire(facingMode, withAudio) {
+	return requestCameraWithFallback({
+		video: { facingMode },
+		audio: withAudio
+	});
+}
+function stopStream(stream) {
+	stream?.getTracks().forEach((track) => track.stop());
+}
+/**
+* Creates a {@link VideoSelfieCameraWarmer} for the given config. The first
+* camera (and whether it needs audio) is derived from the resolved step order —
+* the same first acquire the recording machine performs on `START`.
+*/
+function createVideoSelfieCameraWarmer(config) {
+	const firstFacing = facingModeForStep(resolveVideoSelfieSteps(config)[0] ?? "selfie");
+	let warming = null;
+	let warmed = null;
+	let consumed = false;
+	return {
+		warm() {
+			if (warming) return;
+			warming = (async () => {
+				try {
+					if (await checkPermission() !== "granted") return null;
+					warmed = await defaultAcquire(firstFacing, true);
+					return warmed;
+				} catch {
+					return null;
+				}
+			})();
+		},
+		async acquireCamera(facingMode, withAudio) {
+			if (!consumed && facingMode === firstFacing && withAudio) {
+				consumed = true;
+				const stream = warmed ?? (warming ? await warming : null);
+				warmed = null;
+				if (stream) return stream;
+			}
+			return defaultAcquire(facingMode, withAudio);
+		},
+		dispose() {
+			if (consumed) return;
+			if (warmed) {
+				stopStream(warmed);
+				warmed = null;
+			} else if (warming) warming.then((stream) => {
+				if (!consumed) stopStream(stream);
+			});
+		}
+	};
+}
+
+//#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 ?? [];
+}
+/**
+* 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 ?? "";
+}
+/**
+* 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.
+*/
+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 ../../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.
+*
+* @example
+* navigator.mediaDevices.getUserMedia({ audio: true }).then(stream => {
+*   let recorder = new MediaRecorder(stream)
+* })
+*/
+var MediaRecorder$1 = class MediaRecorder$1 {
+	/**
+	* @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$1.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"));
+	}
+	/**
+	* 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$1.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$1.isTypeSupported = (mimeType) => {
+	return MediaRecorder$1.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$1.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$1.encoder = wave_encoder_default;
+var audio_recorder_polyfill_default = MediaRecorder$1;
+
+//#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 = 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 = 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);
+	});
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/VoiceRecordingProvider.ts
+const AudioRecorderPolyfill = audio_recorder_polyfill_default;
+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.
+*/
+var VoiceRecordingProvider = class {
+	constructor() {
+		this.recorder = null;
+		this.chunks = [];
+		this._isRecording = false;
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	start(stream) {
+		this.reset();
+		this.chunks = [];
+		const recorder = new AudioRecorderPolyfill(new MediaStream(stream.getAudioTracks()).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;
+	}
+};
+
+//#endregion
+//#region src/modules/video-selfie/videoSelfieConsentRecorder.ts
+function createConsentRecorder() {
+	const provider = new VoiceRecordingProvider();
+	return {
+		start(stream) {
+			provider.start(stream);
+		},
+		async submit() {
+			const base64 = await provider.stopAsBase64();
+			if (base64.length === 0) return { success: false };
+			return addSpeech(base64);
+		},
+		cancel() {
+			provider.reset();
+		}
+	};
+}
+
+//#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 MUST call
+* `flowManager.completeModule()` once the recording manager reaches `finished`
+* (success) or `error` (terminal failure). Until that event is sent, the flow
+* orchestrator remains in `runningModule` — this is intentional.
+*
+* **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 };