@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/video-selfie.esm.js

@@ -1,422 +1,37 @@
-import { t as WasmUtilProvider } from "./WasmUtilProvider-BgzcXBdl.esm.js";
-import { t as ensureWasmPipelines } from "./setup-CfNsYAeB.esm.js";
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import "./clientLifecycle-VyzRfALg.esm.js";
-import "./events-1wxZ97yf.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import "./stats-BVy52wLy.esm.js";
-import "./sessionInitializer-Dj7-aJaP.esm.js";
-import "./browserSimulation-DZwEy9bu.esm.js";
-import "./platform-0Ot-bF_a.esm.js";
-import "./getBrowser-1yNcfFZR.esm.js";
-import "./tri-CFAPtAUM.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-BHuHoYvJ.esm.js";
-import { t as checkPermission } from "./permissionServices-C_kxhNeo.esm.js";
-import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-CxxXV0VN.esm.js";
-import { a as encryptSelfieImage, b as FaceDetectionProvider, l as startDetection, m as uploadSelfie, p as processFace, y as StreamCanvasProcessingSession } from "./onDeviceFaceResults-DILtthks.esm.js";
-import "./ITimerCapability-DJ73P4RK.esm.js";
-import "./canvas-Pi10hG_l.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-ChrMTJv-.esm.js";
-import "./video-ZY92rkel.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-C-Dg6IsJ.esm.js";
-import "./deepsightService-CViys6T4.esm.js";
-import "./getDeviceClass-DIjnTPjR.esm.js";
-import "./types-BKLb3C42.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-CAqUdVkM.esm.js";
-import { n as getSupportedMediaRecorderMimeType } from "./mediaRecorderOptions-CClCKAiF.esm.js";
-import { n as resolveVideoSelfieSteps, r as videoSelfieWasmPipelines, t as facingModeForStep } from "./videoSelfieSteps-Djpv7cjb.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-CZajItdO.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
+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-CYdVacqv.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-unhF9V9F.esm.js";
+import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.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-h_VUk5Vu.esm.js";
 //#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).
+* 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 = 1e3;
+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 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.
+* 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 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.
+* 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
@@ -430,8 +45,6 @@ var MultipartRecordingProvider = class {
 		this._hasError = false;
 		this._error = null;
 		this.mimeType = "";
-		this.buffer = [];
-		this.bufferedBytes = 0;
 		this.partNumber = 0;
 		this.onPart = null;
 	}
@@ -446,8 +59,6 @@ var MultipartRecordingProvider = class {
 	}
 	startRecording(stream, onPart) {
 		this.reset();
-		this.buffer = [];
-		this.bufferedBytes = 0;
 		this.partNumber = 0;
 		this.onPart = onPart;
 		try {
@@ -457,14 +68,17 @@ var MultipartRecordingProvider = class {
 				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();
+				if (event.data.size > 0 && this.onPart) {
+					this.partNumber += 1;
+					this.onPart({
+						chunk: event.data,
+						partNumber: this.partNumber
+					});
 				}
 			};
 			recorder.onerror = (event) => {
-				this._error = `Recording error: ${event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type}`;
+				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;
 			};
@@ -474,7 +88,8 @@ var MultipartRecordingProvider = class {
 			this._error = null;
 			this._hasError = false;
 		} catch (err) {
-			this._error = `Failed to start recording: ${err instanceof Error ? err.message : String(err)}`;
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to start recording: ${detail}`;
 			this._hasError = true;
 		}
 	}
@@ -483,7 +98,6 @@ var MultipartRecordingProvider = class {
 		return new Promise((resolve) => {
 			if (recorder && this._isRecording) {
 				recorder.onstop = () => {
-					this.flushPart();
 					resolve();
 				};
 				recorder.stop();
@@ -503,202 +117,315 @@ var MultipartRecordingProvider = class {
 			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 ../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/videoSelfieUploadService.ts
+//#region src/internal/recordings/videoSelfieChunkUploader.ts
 /**
-* Opens a multipart video-selfie upload session. The returned `uploadId`
-* identifies the session for subsequent part uploads and completion.
+* 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.
 */
-async function initiateVideoSelfieUpload() {
-	return (await api.post(endpoints.videoSelfieUploadInitiate, {})).data.uploadId;
-}
+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;
 /**
-* 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.
+* 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.
 */
-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
-	};
+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;
 }
 /**
-* Finalizes the upload. `parts` must be in ascending `partNumber` order, or
-* S3 reassembly fails. Returns the server-reported status.
+* 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.
 */
-async function completeVideoSelfieUpload(uploadId, parts) {
-	return (await api.post(endpoints.videoSelfieUploadComplete, {
-		uploadId,
-		parts
-	})).data.status;
-}
-
+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;
+}
 /**
 * 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/*`).
+* 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.
 *
-* 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
+* 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.uploadId = null;
-		this.parts = [];
-		this.inflight = [];
-		this.uploadFailed = false;
+		this.timer = BrowserTimerProvider.getInstance();
+		this.session = null;
+		this.uploader = null;
+		this.chunksEmitted = 0;
 	}
 	get isRecording() {
 		return this.recorder.isRecording;
 	}
 	async start(stream) {
-		this.uploadId = await initiateVideoSelfieUpload();
-		this.parts = [];
-		this.inflight = [];
-		this.uploadFailed = false;
+		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 }) => {
-			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);
+			this.chunksEmitted += 1;
+			this.uploader?.enqueue(partNumber, chunk);
 		});
 	}
 	async stop() {
-		const uploadId = this.uploadId;
-		if (!this.recorder.isRecording || !uploadId) return { recordingId: null };
+		const session = this.session;
+		const uploader = this.uploader;
+		if (!this.recorder.isRecording || !session || !uploader) 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);
+		if (!await uploader.drain() || uploader.failed || this.chunksEmitted === 0) {
+			this.abandonUpload(session);
+			return { recordingId: null };
+		}
 		try {
-			await completeVideoSelfieUpload(uploadId, orderedParts);
-			return { recordingId: uploadId };
+			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();
 	}
-};
-
-//#endregion
-//#region src/modules/video-selfie/videoSelfieCameraWarmer.ts
-/**
-* Acquire the camera for a Video Selfie step. The rear (`environment`) steps
-* (frontId / backId / poa) route through {@link getBackCameraStream} so the
-* main autofocus lens is selected — Samsung's default `facingMode:environment`
-* camera is often a fixed-focus auxiliary lens, which blurs the ID steps and
-* stalls capture (client-side blur check is on). This mirrors the ID Capture
-* module. `getBackCameraStream` returns video only, so audio is acquired and
-* merged separately when the step needs it. Front (`user`) steps keep the
-* plain fallback path. Used both as the recording machine's default
-* `acquireCamera` dependency and as this warmer's own acquire/fallback.
-*/
-async function defaultAcquireCamera(facingMode, withAudio) {
-	if (facingMode !== "environment") return requestCameraWithFallback({
-		video: { facingMode },
-		audio: withAudio
-	});
-	const { stream } = await getBackCameraStream();
-	if (withAudio) try {
-		const audioStream = await requestCameraAccess({ audio: true });
-		for (const audioTrack of audioStream.getAudioTracks()) stream.addTrack(audioTrack);
-	} catch (error$1) {
-		stream.getTracks().forEach((track) => track.stop());
-		throw error$1;
-	}
-	return stream;
-}
-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 defaultAcquireCamera(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 defaultAcquireCamera(facingMode, withAudio);
-		},
-		dispose() {
-			if (consumed) return;
-			if (warmed) {
-				stopStream(warmed);
-				warmed = null;
-			} else if (warming) warming.then((stream) => {
-				if (!consumed) stopStream(stream);
+	/**
+	* `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. */
@@ -718,6 +445,52 @@ function detectionStatusFromEvent(event) {
 function detectionErrorFromEvent(event) {
 	return event.error;
 }
+function validationFailureFromEvent(event) {
+	return event.failure;
+}
+function errorKindFromEvent(event) {
+	return event.kind;
+}
+function retryableFailureFromEvent(event) {
+	return event.failure;
+}
+function orientationFromEvent(event) {
+	return event.orientation;
+}
+const SWITCHING_CAMERA_MIN_DWELL_MS = 3e3;
+const ID_FLIP_DWELL_MS = 4e3;
+const FINAL_SUCCESS_DWELL_MS = 3e3;
+const VALIDATION_FEEDBACK_DWELL_MS = 3e3;
+const DEFAULT_ATTEMPTS_PER_STEP = 3;
+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 waitForDwell(ms, signal) {
+	const timerProvider = BrowserTimerProvider.getInstance();
+	return new Promise((resolve) => {
+		const onAbort = () => {
+			timerProvider.clearTimeout(timer);
+			resolve(false);
+		};
+		const timer = timerProvider.setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(true);
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+	});
+}
 /**
 * Orchestrates a multi-step Video Selfie session as ONE continuous recording
 * that follows the camera between steps AND auto-advances per step:
@@ -731,9 +504,9 @@ function detectionErrorFromEvent(event) {
 * 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
+* Teardown: `ABORT` is accepted from ANY non-final state and every settled
+* path runs `cleanup`, so no path leaves camera or mic tracks running.
+* XState v5 executes NO exit actions on an external
 * `actor.stop()`, so the manager sends `ABORT` before stopping the actor —
 * never stop this actor directly without aborting first.
 */
@@ -743,6 +516,11 @@ const videoSelfieRecordingSetup = setup({
 		events: {},
 		input: {}
 	},
+	delays: {
+		ID_FLIP_DWELL: ID_FLIP_DWELL_MS,
+		FINAL_SUCCESS_DWELL: FINAL_SUCCESS_DWELL_MS,
+		VALIDATION_FEEDBACK_DWELL: VALIDATION_FEEDBACK_DWELL_MS
+	},
 	actors: {
 		acquireCamera: fromPromise(async ({ input, signal }) => {
 			const stream = await input.acquire(input.facingMode, input.withAudio);
@@ -752,6 +530,23 @@ const videoSelfieRecordingSetup = setup({
 			}
 			return stream;
 		}),
+		switchCamera: fromPromise(async ({ input, signal }) => {
+			const dwellCompleted = waitForDwell(input.minDwellMs, signal);
+			const stream = await input.acquire(input.facingMode, false);
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			if (!await dwellCompleted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			return stream;
+		}),
 		startRecording: fromPromise(async ({ input }) => {
 			await input.service.start(input.stream);
 		}),
@@ -765,35 +560,104 @@ const videoSelfieRecordingSetup = setup({
 				onStatus: (status) => sendBack({
 					type: "DETECTION_STATUS",
 					status
+				}),
+				onOrientation: (orientation) => sendBack({
+					type: "ORIENTATION",
+					orientation
 				})
-			}).then(() => sendBack({ type: "DETECTION_DONE" })).catch((err) => {
+			}).then((result) => {
+				if (result.outcome === "retryableFailure") {
+					sendBack({
+						type: "RETRYABLE_FAILURE",
+						failure: result.failure
+					});
+					return;
+				}
+				if (result.outcome === "validationFailed") {
+					sendBack({
+						type: "VALIDATION_FAILED",
+						failure: result.failure
+					});
+					return;
+				}
+				sendBack({ type: "DETECTION_DONE" });
+			}).catch((err) => {
 				if (!controller.signal.aborted) sendBack({
 					type: "DETECTION_FAILED",
-					error: String(err)
+					error: String(err),
+					kind: isConnectionError(err) ? "connection" : "technical"
 				});
 			});
 			return () => controller.abort();
 		})
 	},
 	actions: {
-		advanceStep: assign({ stepIndex: ({ context: context$1 }) => context$1.stepIndex + 1 }),
+		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) }),
-		setErrorFromDetection: assign({ error: ({ event }) => detectionErrorFromEvent(event) }),
+		setValidationFailure: assign(({ context, event }) => ({
+			attemptsRemaining: context.attemptsRemaining === UNLIMITED_ATTEMPTS ? UNLIMITED_ATTEMPTS : Math.max(0, context.attemptsRemaining - 1),
+			validationFailure: validationFailureFromEvent(event),
+			detectionStatus: "error"
+		})),
+		setUncountedRetryableFailure: assign(({ event }) => ({
+			validationFailure: retryableFailureFromEvent(event),
+			detectionStatus: "error"
+		})),
+		setErrorFromDetection: assign({
+			error: ({ event }) => detectionErrorFromEvent(event),
+			errorKind: ({ event }) => errorKindFromEvent(event)
+		}),
 		clearDetectionFeedback: assign({
 			detectionStatus: () => void 0,
-			detectionError: () => void 0
+			detectionError: () => void 0,
+			validationFailure: () => void 0,
+			orientation: () => void 0
+		}),
+		setUploadFailedError: assign({
+			error: () => "Video upload failed",
+			errorKind: () => "connection"
 		}),
-		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());
+		resetSession: assign(({ context }) => ({
+			stepIndex: 0,
+			stream: void 0,
+			composite: void 0,
+			detectionStatus: void 0,
+			orientation: void 0,
+			detectionError: void 0,
+			validationFailure: void 0,
+			attemptsRemaining: context.attemptsPerStep,
+			recordingId: null,
+			error: void 0,
+			errorKind: void 0
+		})),
+		cleanup: ({ context }) => {
+			context.service.cleanup();
+			context.compositor.stop();
+			context.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]),
+		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
 	}
 });
@@ -802,6 +666,10 @@ const ADVANCE_TRANSITIONS = [
 		target: "finalizing",
 		guard: "isLastStep"
 	},
+	{
+		target: "flippingId",
+		guard: "nextStepFlipsId"
+	},
 	{
 		target: "switchingCamera",
 		guard: "nextStepFlipsCamera",
@@ -813,7 +681,7 @@ const ADVANCE_TRANSITIONS = [
 		actions: "advanceStep"
 	}
 ];
-const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
+const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 	id: "videoSelfieRecording",
 	initial: "idle",
 	context: ({ input }) => ({
@@ -826,27 +694,33 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 		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
+		error: void 0,
+		errorKind: void 0,
+		switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS
 	}),
 	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]),
+			input: ({ context }) => ({
+				acquire: context.acquireCamera,
+				facingMode: facingModeForStep(context.steps[context.stepIndex]),
 				withAudio: true
 			}),
 			onDone: {
 				target: "starting",
-				actions: [({ context: context$1, event }) => {
-					context$1.compositor.start(eventOutputStream(event));
+				actions: [({ context, event }) => {
+					context.compositor.start(eventOutputStream(event));
 				}, assign({
 					stream: ({ event }) => eventOutputStream(event),
-					composite: ({ context: context$1 }) => context$1.compositor.stream
+					composite: ({ context }) => context.compositor.stream
 				})]
 			},
 			onError: {
@@ -856,9 +730,9 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 		} },
 		starting: { invoke: {
 			src: "startRecording",
-			input: ({ context: context$1 }) => ({
-				service: context$1.service,
-				stream: context$1.composite
+			input: ({ context }) => ({
+				service: context.service,
+				stream: context.composite
 			}),
 			onDone: { target: "recording" },
 			onError: {
@@ -870,33 +744,87 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 			entry: "clearDetectionFeedback",
 			invoke: {
 				src: "detectStep",
-				input: ({ context: context$1 }) => ({
-					detect: context$1.detect,
-					step: context$1.steps[context$1.stepIndex],
-					stream: context$1.stream
+				input: ({ context }) => ({
+					detect: context.detect,
+					step: context.steps[context.stepIndex],
+					stream: context.stream
 				})
 			},
 			on: {
 				DETECTION_STATUS: { actions: "setDetectionStatus" },
+				ORIENTATION: { actions: "setOrientation" },
 				DETECTION_DONE: ADVANCE_TRANSITIONS,
 				NEXT_STEP: ADVANCE_TRANSITIONS,
+				VALIDATION_FAILED: {
+					target: "validationFeedback",
+					actions: "setValidationFailure"
+				},
+				RETRYABLE_FAILURE: {
+					target: "validationFeedback",
+					actions: "setUncountedRetryableFailure"
+				},
 				DETECTION_FAILED: {
 					target: "error",
 					actions: "setErrorFromDetection"
 				}
 			}
 		},
+		validationFeedback: { after: { VALIDATION_FEEDBACK_DWELL: [{
+			target: "recording",
+			guard: "hasAttemptsRemaining"
+		}, ...[
+			{
+				target: "finalizing",
+				guard: "exhaustedIdFinishes"
+			},
+			{
+				target: "switchingCamera",
+				guard: "nextModuleFlipsCamera",
+				actions: "advancePastIdSection"
+			},
+			{
+				target: "recording",
+				reenter: true,
+				guard: "isIdExhaustion",
+				actions: "advancePastIdSection"
+			},
+			{
+				target: "finalizing",
+				guard: "exhaustedNonIdFinishes"
+			},
+			{
+				target: "switchingCamera",
+				guard: "exhaustedNonIdNextStepFlipsCamera",
+				actions: "advanceStep"
+			},
+			{
+				target: "recording",
+				reenter: true,
+				guard: "isNonIdExhaustion",
+				actions: "advanceStep"
+			}
+		]] } },
+		flippingId: {
+			after: { ID_FLIP_DWELL: {
+				target: "recording",
+				actions: "advanceStep"
+			} },
+			on: { NEXT_STEP: {
+				target: "recording",
+				actions: "advanceStep"
+			} }
+		},
 		switchingCamera: { invoke: {
-			src: "acquireCamera",
-			input: ({ context: context$1 }) => ({
-				acquire: context$1.acquireCamera,
-				facingMode: facingModeForStep(context$1.steps[context$1.stepIndex]),
-				withAudio: false
+			src: "switchCamera",
+			input: ({ context }) => ({
+				acquire: context.acquireCamera,
+				facingMode: facingModeForStep(context.steps[context.stepIndex]),
+				minDwellMs: context.switchingCameraMinDwellMs
 			}),
 			onDone: {
 				target: "recording",
-				actions: [({ context: context$1, event }) => {
-					context$1.compositor.switchVideo(eventOutputStream(event));
+				actions: [({ context, event }) => {
+					context.compositor.switchVideo(eventOutputStream(event));
 				}, assign({ stream: ({ event }) => eventOutputStream(event) })]
 			},
 			onError: {
@@ -906,13 +834,13 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 		} },
 		finalizing: { invoke: {
 			src: "finalizeRecording",
-			input: ({ context: context$1 }) => ({ service: context$1.service }),
+			input: ({ context }) => ({ service: context.service }),
 			onDone: [{
 				target: "error",
 				guard: "uploadReturnedNoRecordingId",
 				actions: [assign({ recordingId: ({ event }) => recordingIdFromEvent(event) }), "setUploadFailedError"]
 			}, {
-				target: "finished",
+				target: "success",
 				actions: assign({ recordingId: ({ event }) => recordingIdFromEvent(event) })
 			}],
 			onError: {
@@ -920,13 +848,17 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 				actions: assign({ error: ({ event }) => errorFromEvent(event) })
 			}
 		} },
-		finished: {
-			type: "final",
-			entry: "cleanup"
+		success: {
+			entry: "cleanup",
+			after: { FINAL_SUCCESS_DWELL: "finished" }
 		},
+		finished: { type: "final" },
 		error: {
-			type: "final",
-			entry: "cleanup"
+			entry: "cleanup",
+			on: { RETRY: {
+				target: "acquiringCamera",
+				actions: "resetSession"
+			} }
 		},
 		aborted: {
 			type: "final",
@@ -934,8 +866,6 @@ const _videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 		}
 	}
 });
-const videoSelfieRecordingMachine = _videoSelfieRecordingMachine;
-
 //#endregion
 //#region src/modules/video-selfie/videoSelfieRecordingActor.ts
 function createVideoSelfieRecordingActor(options = {}) {
@@ -943,41 +873,54 @@ function createVideoSelfieRecordingActor(options = {}) {
 	const detect = options.dependencies?.detect ?? (config ? createDefaultStepDetector(config, { getWasmUtil: () => WasmUtilProvider.getInstance() }) : void 0);
 	return createActor(videoSelfieRecordingMachine, { input: {
 		steps: config ? resolveVideoSelfieSteps(config) : void 0,
+		attemptsPerStep: config?.numberOfTries,
 		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 { context } = snapshot;
 	const status = value === "acquiringCamera" ? "starting" : value;
-	const steps = context$1.steps;
-	const stepIndex = context$1.stepIndex;
+	const steps = context.steps;
+	const stepIndex = context.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
+		stream: context.stream,
+		composite: context.composite,
+		detectionStatus: context.detectionStatus,
+		orientation: context.orientation,
+		validationFailure: context.validationFailure,
+		attemptsRemaining: context.attemptsRemaining,
+		recordingId: context.recordingId,
+		error: context.error,
+		errorKind: context.errorKind
 	};
 }
 function createApi({ actor }) {
 	return {
+		/** Acquire the first camera, open the upload, and begin recording. */
 		start() {
 			actor.send({ type: "START" });
 		},
+		retry() {
+			actor.send({ type: "RETRY" });
+		},
+		/**
+		* Advance to the next step. Switches the camera when the next step's
+		* facing mode differs; finalizes the upload on the last step.
+		*/
 		nextStep() {
 			actor.send({ type: "NEXT_STEP" });
 		},
+		/** Abandon the session without finalizing the upload. */
 		abort() {
 			actor.send({ type: "ABORT" });
 		}
@@ -1006,7 +949,6 @@ function createVideoSelfieRecordingManager(options = {}) {
 		}
 	};
 }
-
 //#endregion
 //#region src/modules/video-selfie/videoSelfieWasm.ts
 /**
@@ -1022,7 +964,6 @@ function createVideoSelfieRecordingManager(options = {}) {
 function warmupVideoSelfieWasm(config) {
 	return ensureWasmPipelines(videoSelfieWasmPipelines(config));
 }
-
 //#endregion
 //#region src/modules/video-selfie/videoSelfieSpeechService.ts
 /**
@@ -1062,7 +1003,6 @@ async function addSpeech(base64Mp3) {
 		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 = () => {
@@ -1109,7 +1049,6 @@ var wave_encoder_default = () => {
 		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;
@@ -1333,8 +1272,6 @@ MediaRecorder$1.notSupported = !navigator.mediaDevices || !AudioContext;
 * 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 = () => {
@@ -1343,7 +1280,7 @@ var mpeg_encoder_default = () => {
 	let KBPS = 128;
 	let DEFAULT_SAMPLE_RATE = 44100;
 	let encoder;
-	let recorded = new Int8Array();
+	let recorded = /* @__PURE__ */ new Int8Array();
 	function concat(a, b) {
 		if (b.length === 0) return a;
 		let c = new Int8Array(a.length + b.length);
@@ -1363,7 +1300,7 @@ var mpeg_encoder_default = () => {
 		let buf = encoder.flush();
 		recorded = concat(recorded, buf);
 		let buffer = recorded.buffer;
-		recorded = new Int8Array();
+		recorded = /* @__PURE__ */ new Int8Array();
 		postMessage(buffer, [buffer]);
 	}
 	onmessage = (e) => {
@@ -1372,7 +1309,6 @@ var mpeg_encoder_default = () => {
 		else dump(e.data[1]);
 	};
 };
-
 //#endregion
 //#region ../infra/src/media/blobEncoding.ts
 /** Encodes a blob as raw base64 bytes (no `data:...;base64,` prefix). */
@@ -1394,10 +1330,9 @@ function blobToRawBase64(blob) {
 		reader.readAsDataURL(blob);
 	});
 }
-
 //#endregion
 //#region ../infra/src/providers/browser/VoiceRecordingProvider.ts
-const AudioRecorderPolyfill = audio_recorder_polyfill_default;
+const AudioRecorderPolyfill = MediaRecorder$1;
 AudioRecorderPolyfill.encoder = mpeg_encoder_default;
 AudioRecorderPolyfill.prototype.mimeType = "audio/mpeg";
 const MIME_TYPE = "audio/mpeg";
@@ -1422,7 +1357,8 @@ var VoiceRecordingProvider = class {
 	start(stream) {
 		this.reset();
 		this.chunks = [];
-		const recorder = new AudioRecorderPolyfill(new MediaStream(stream.getAudioTracks()).clone());
+		const audioOnly = new MediaStream(stream.getAudioTracks());
+		const recorder = new AudioRecorderPolyfill(audioOnly.clone());
 		recorder.mimeType = MIME_TYPE;
 		recorder.addEventListener("dataavailable", (event) => {
 			if (event.data.size > 0) this.chunks.push(event.data);
@@ -1464,7 +1400,6 @@ var VoiceRecordingProvider = class {
 		this._isRecording = false;
 	}
 };
-
 //#endregion
 //#region src/modules/video-selfie/videoSelfieConsentRecorder.ts
 function createConsentRecorder() {
@@ -1483,7 +1418,6 @@ function createConsentRecorder() {
 		}
 	};
 }
-
 //#endregion
 //#region src/modules/video-selfie/videoSelfieFlowModuleMachine.ts
 /**
@@ -1496,10 +1430,9 @@ function createConsentRecorder() {
 * 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.
+* **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 /
@@ -1515,6 +1448,5 @@ const videoSelfieFlowModuleMachine = setup({}).createMachine({
 	initial: "running",
 	states: { running: {} }
 });
-
 //#endregion
-export { createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };
+export { createConsentRecorder, createVideoSelfieCameraWarmer, createVideoSelfieRecordingManager, facingModeForStep, getVideoSelfieQuestions, getVoiceConsentPhrase, resolveVideoSelfieSteps, videoSelfieFlowModuleMachine, videoSelfieWasmPipelines, warmupVideoSelfieWasm };