@incodetech/core 0.0.0-dev-20260729-9e7b030a → 0.0.0-dev-20260729-a31df3b7

package/dist/video-selfie.esm.js

@@ -1,543 +1,13 @@
 import { t as WasmUtilProvider } from "./WasmUtilProvider-D13sxEmA.esm.js";
-import { t as ensureWasmPipelines } from "./setup-BVuwm-QH.esm.js";
+import { t as ensureWasmPipelines } from "./setup-sxUVsl_J.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-DOfmJylF.esm.js";
-import { d as videoSelfieWasmPipelines, l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-ZgW3UGcz.esm.js";
+import { d as videoSelfieWasmPipelines, l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-BuSZYjB9.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 { t as checkPermission } from "./permissionServices-GFikEK6S.esm.js";
-import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-BmFEyPP_.esm.js";
-import { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-D8FzOXsM.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-BqiXcU28.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { i as uploadSelfie, r as processFace, t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-DCRRRj38.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
 import { n as getSupportedMediaRecorderMimeType } from "./mediaRecorderOptions-CUsftWlH.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-BDS43fFL.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;
-}
-const SELFIE_SUCCESS_DWELL_MS = 900;
-/**
-* 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;
-const SELFIE_VALIDATION_ERROR_CODES = [
-	FACE_ERROR_CODES.FACE_OCCLUDED,
-	FACE_ERROR_CODES.LIVENESS,
-	FACE_ERROR_CODES.BRIGHTNESS,
-	FACE_ERROR_CODES.LENSES,
-	FACE_ERROR_CODES.MASK,
-	FACE_ERROR_CODES.CLOSED_EYES,
-	FACE_ERROR_CODES.HEAD_COVER,
-	FACE_ERROR_CODES.FACE_NOT_FOUND,
-	FACE_ERROR_CODES.MULTIPLE_FACES,
-	FACE_ERROR_CODES.TOO_BLURRY,
-	FACE_ERROR_CODES.TOO_DARK,
-	FACE_ERROR_CODES.USER_IS_NOT_RECOGNIZED,
-	FACE_ERROR_CODES.SPOOF_ATTEMPT_DETECTED,
-	FACE_ERROR_CODES.FACE_TOO_DARK,
-	FACE_ERROR_CODES.LENSES_DETECTED,
-	FACE_ERROR_CODES.FACE_MASK_DETECTED,
-	FACE_ERROR_CODES.CLOSED_EYES_DETECTED,
-	FACE_ERROR_CODES.HEAD_COVER_DETECTED,
-	FACE_ERROR_CODES.FACE_CROPPING_FAILED,
-	FACE_ERROR_CODES.FACE_TOO_SMALL,
-	FACE_ERROR_CODES.FACE_TOO_BLURRY,
-	FACE_ERROR_CODES.BAD_PHOTO_QUALITY,
-	FACE_ERROR_CODES.SELFIE_IMAGE_LOW_QUALITY
-];
-const SELFIE_VALIDATION_STATUS_CODES = [
-	3004,
-	3005,
-	3006,
-	3007,
-	4010,
-	4019,
-	4077,
-	4078
-];
-function getErrorStatus(error) {
-	if (typeof error !== "object" || error === null) return;
-	if ("data" in error) {
-		const data = error.data;
-		if (typeof data === "object" && data !== null && "status" in data && typeof data.status === "number") return data.status;
-	}
-	if ("status" in error && typeof error.status === "number") return error.status;
-}
-function isSelfieValidationError(error) {
-	const errorCode = getFaceErrorCodeFromUnknown(error);
-	if (errorCode !== void 0 && SELFIE_VALIDATION_ERROR_CODES.includes(errorCode)) return true;
-	const status = getErrorStatus(error);
-	return status !== void 0 && SELFIE_VALIDATION_STATUS_CODES.includes(status);
-}
-function isIdComparisonValidationError(error) {
-	return typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" && error.status > 0;
-}
-function abortError() {
-	return /* @__PURE__ */ new Error("aborted");
-}
-function throwIfAborted(signal) {
-	if (signal.aborted) throw abortError();
-}
-/** Resolves after `ms`, or rejects early if `signal` aborts. */
-function delay(ms, signal) {
-	if (signal.aborted) return Promise.reject(abortError());
-	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(abortError());
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-		if (signal.aborted) onAbort();
-	});
-}
-function isWrongVideoSelfieIdSide(step, reportedSide) {
-	const side = reportedSide.toLowerCase();
-	if (side === "wrong") return true;
-	const isFront = side.includes("front") && !side.includes("back");
-	const isBack = side.includes("back") && !side.includes("front");
-	return step === "frontId" ? isBack : isFront;
-}
-/**
-* 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
-	});
-	if (signal.aborted) {
-		provider.dispose();
-		throw abortError();
-	}
-	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) => {
-		if (signal.aborted) {
-			reject(abortError());
-			return;
-		}
-		let settled = false;
-		function settle(run) {
-			if (settled) return;
-			settled = true;
-			signal.removeEventListener("abort", onAbort);
-			run();
-		}
-		const detection = startDetection({
-			config: detectionConfig,
-			capturer,
-			provider,
-			onUpdate: (status) => onStatus?.(status),
-			onSuccess: (canvas, faceCoordinates) => {
-				onStatus?.("capturing");
-				(async () => {
-					try {
-						const encryptedBase64Image = await encryptSelfieImage({
-							canvas,
-							dependencies: { getWasmUtil: async () => deps.getWasmUtil() }
-						});
-						throwIfAborted(signal);
-						await uploadSelfie({
-							encryptedBase64Image,
-							faceCoordinates,
-							imageType
-						});
-						throwIfAborted(signal);
-						await processFace(imageType);
-						throwIfAborted(signal);
-						onStatus?.("success");
-						await delay(SELFIE_SUCCESS_DWELL_MS, signal);
-						settle(resolve);
-					} catch (error) {
-						settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-					}
-				})();
-			}
-		});
-		function onAbort() {
-			detection.cleanup();
-			settle(() => reject(abortError()));
-		}
-		signal.addEventListener("abort", onAbort, { once: true });
-		if (signal.aborted) onAbort();
-	});
-	try {
-		await runAttempt();
-		return { outcome: "success" };
-	} catch (error) {
-		if (signal.aborted || !isSelfieValidationError(error)) throw error;
-		onStatus?.("error");
-		return {
-			outcome: "validationFailed",
-			failure: "selfieVerificationFailed"
-		};
-	} 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 });
-	if (signal.aborted) {
-		provider.dispose();
-		throw abortError();
-	}
-	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("v2");
-	const capturer = new StreamCanvasCapture(stream);
-	return new Promise((resolve, reject) => {
-		let validating = false;
-		let wrongSide = false;
-		let settled = false;
-		let toreDown = false;
-		const session = new StreamCanvasProcessingSession({
-			capturer,
-			provider
-		});
-		function teardown() {
-			if (toreDown) return;
-			toreDown = true;
-			session.dispose();
-			capturer.dispose();
-			provider.dispose();
-		}
-		function settle(run) {
-			if (settled) return;
-			settled = true;
-			signal.removeEventListener("abort", onAbort);
-			teardown();
-			run();
-		}
-		function onAbort() {
-			settle(() => reject(abortError()));
-		}
-		provider.setCallbacks({
-			onFarAway: () => {
-				if (!validating && !wrongSide) onStatus?.("tooFar");
-			},
-			onBlur: () => {
-				if (!validating && !wrongSide) onStatus?.("blur");
-			},
-			onIdSideChange: (side) => {
-				wrongSide = isWrongVideoSelfieIdSide(step, side);
-				onStatus?.(wrongSide ? "wrongSide" : "detecting");
-			},
-			onCapturing: () => {
-				if (validating || wrongSide) return;
-				const base64Image = capturer.getLatestCanvas()?.getBase64Image();
-				if (!base64Image) return;
-				validating = true;
-				onStatus?.("capturing");
-				(async () => {
-					try {
-						const result = await validateIdFrame(step, config, base64Image);
-						if (result.outcome === "success") {
-							throwIfAborted(signal);
-							onStatus?.("success");
-							await delay(ID_SUCCESS_DWELL_MS, signal);
-							settle(() => resolve(result));
-							return;
-						}
-						onStatus?.("error");
-						settle(() => resolve(result));
-					} catch (error) {
-						if (signal.aborted) {
-							settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-							return;
-						}
-						onStatus?.("error");
-						if (isIdComparisonValidationError(error)) {
-							settle(() => resolve({
-								outcome: "validationFailed",
-								failure: "idScanFailed"
-							}));
-							return;
-						}
-						settle(() => resolve({
-							outcome: "retryableFailure",
-							failure: "idScanFailed"
-						}));
-					}
-				})();
-			}
-		});
-		onStatus?.("detecting");
-		signal.addEventListener("abort", onAbort, { once: true });
-		if (signal.aborted) onAbort();
-	});
-}
-/** 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 {
-				outcome: "validationFailed",
-				failure: "idTypeMismatch"
-			};
-		}
-		if (config.compareBackOcrEnabled) {
-			if ((await compareVideoSelfieBackOcr(base64Image)).success === false) return {
-				outcome: "validationFailed",
-				failure: "nameVerificationFailed"
-			};
-		}
-		return { outcome: "success" };
-	}
-	if (config.compareIdEnabled) {
-		const result = await compareVideoSelfieId(base64Image);
-		if (result.idTypeMatched === false) return {
-			outcome: "validationFailed",
-			failure: "idTypeMismatch"
-		};
-		if (typeof result.faceRecognitionConfidence === "number" && !isFaceRecognitionMatch(result.faceRecognitionConfidence)) return {
-			outcome: "validationFailed",
-			failure: "photoVerificationFailed"
-		};
-	}
-	if (config.compareOcrEnabled) {
-		if ((await compareVideoSelfieOcr(base64Image)).success === false) return {
-			outcome: "validationFailed",
-			failure: "nameVerificationFailed"
-		};
-	}
-	return { outcome: "success" };
-}
-//#endregion
-//#region ../infra/src/media/CameraCompositor.ts
-const MAX_COMPOSITE_LONG_EDGE = 1280;
-const MAX_COMPOSITE_SHORT_EDGE = 720;
-const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
-/**
-* 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.frameRequestId = null;
-		this.frameRequestKind = null;
-		this.lastDrawTimeMs = null;
-		this.lastVideoTimeSeconds = null;
-		this.audioTrack = null;
-		this.videoTrack = null;
-		this.composite = null;
-		this.fps = options.fps ?? 30;
-		this.frameIntervalMs = this.fps > 0 ? 1e3 / this.fps : 0;
-	}
-	/**
-	* 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);
-		this.startDrawLoop();
-		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() {
-		this.cancelDrawLoop();
-		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() {
-		this.cancelDrawLoop();
-		this.lastDrawTimeMs = null;
-		this.lastVideoTimeSeconds = null;
-		const draw = (timeMs) => {
-			const elapsed = this.lastDrawTimeMs === null ? Infinity : timeMs - this.lastDrawTimeMs;
-			if ((this.frameIntervalMs === 0 || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) this.lastDrawTimeMs = timeMs;
-			this.scheduleNextFrame(draw);
-		};
-		this.scheduleNextFrame(draw);
-	}
-	scheduleNextFrame(callback) {
-		const video = this.video;
-		if (video && typeof video.requestVideoFrameCallback === "function") {
-			this.frameRequestKind = "video";
-			this.frameRequestId = video.requestVideoFrameCallback(callback);
-			return;
-		}
-		this.frameRequestKind = "animation";
-		this.frameRequestId = requestAnimationFrame(callback);
-	}
-	cancelDrawLoop() {
-		if (this.frameRequestId === null) return;
-		if (this.frameRequestKind === "video" && this.video && typeof this.video.cancelVideoFrameCallback === "function") this.video.cancelVideoFrameCallback(this.frameRequestId);
-		else cancelAnimationFrame(this.frameRequestId);
-		this.frameRequestId = null;
-		this.frameRequestKind = null;
-	}
-	drawCurrentFrame() {
-		const video = this.video;
-		const canvas = this.canvas;
-		const ctx = this.ctx;
-		if (!video || !canvas || !ctx || video.videoWidth <= 0) return false;
-		if (this.lastVideoTimeSeconds === video.currentTime) return false;
-		const dimensions = this.getBoundedDimensions(video.videoWidth, video.videoHeight);
-		if (canvas.width !== dimensions.width || canvas.height !== dimensions.height) {
-			canvas.width = dimensions.width;
-			canvas.height = dimensions.height;
-		}
-		ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-		this.lastVideoTimeSeconds = video.currentTime;
-		return true;
-	}
-	getBoundedDimensions(width, height) {
-		const longEdge = Math.max(width, height);
-		const shortEdge = Math.min(width, height);
-		const scale = Math.min(1, MAX_COMPOSITE_LONG_EDGE / longEdge, MAX_COMPOSITE_SHORT_EDGE / shortEdge);
-		return {
-			width: Math.max(1, Math.round(width * scale)),
-			height: Math.max(1, Math.round(height * scale))
-		};
-	}
-};
-//#endregion
+import { i as createDefaultStepDetector, n as defaultAcquireCamera, r as CameraCompositor, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-lG-12ONu.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
@@ -767,80 +237,6 @@ var MultipartRecordingService = class {
 	}
 };
 //#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) {
-		stream.getTracks().forEach((track) => track.stop());
-		throw error;
-	}
-	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);
-			});
-		}
-	};
-}
-//#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(() => {});
@@ -865,6 +261,9 @@ function validationFailureFromEvent(event) {
 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;
@@ -968,6 +367,10 @@ const videoSelfieRecordingSetup = setup({
 				onStatus: (status) => sendBack({
 					type: "DETECTION_STATUS",
 					status
+				}),
+				onOrientation: (orientation) => sendBack({
+					type: "ORIENTATION",
+					orientation
 				})
 			}).then((result) => {
 				if (result.outcome === "retryableFailure") {
@@ -1006,6 +409,7 @@ const videoSelfieRecordingSetup = setup({
 			validationFailure: () => void 0
 		}),
 		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
+		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(event) }),
 		setDetectionError: assign({ detectionError: ({ event }) => detectionErrorFromEvent(event) }),
 		setValidationFailure: assign(({ context, event }) => ({
 			attemptsRemaining: context.attemptsRemaining === UNLIMITED_ATTEMPTS ? UNLIMITED_ATTEMPTS : Math.max(0, context.attemptsRemaining - 1),
@@ -1020,7 +424,8 @@ const videoSelfieRecordingSetup = setup({
 		clearDetectionFeedback: assign({
 			detectionStatus: () => void 0,
 			detectionError: () => void 0,
-			validationFailure: () => void 0
+			validationFailure: () => void 0,
+			orientation: () => void 0
 		}),
 		setUploadFailedError: assign({ error: () => "Video upload failed" }),
 		resetSession: assign(({ context }) => ({
@@ -1028,6 +433,7 @@ const videoSelfieRecordingSetup = setup({
 			stream: void 0,
 			composite: void 0,
 			detectionStatus: void 0,
+			orientation: void 0,
 			detectionError: void 0,
 			validationFailure: void 0,
 			attemptsRemaining: context.attemptsPerStep,
@@ -1087,6 +493,7 @@ 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),
@@ -1143,6 +550,7 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 			},
 			on: {
 				DETECTION_STATUS: { actions: "setDetectionStatus" },
+				ORIENTATION: { actions: "setOrientation" },
 				DETECTION_DONE: ADVANCE_TRANSITIONS,
 				NEXT_STEP: ADVANCE_TRANSITIONS,
 				VALIDATION_FAILED: {
@@ -1286,6 +694,7 @@ function mapState(snapshot) {
 		stream: context.stream,
 		composite: context.composite,
 		detectionStatus: context.detectionStatus,
+		orientation: context.orientation,
 		validationFailure: context.validationFailure,
 		attemptsRemaining: context.attemptsRemaining,
 		recordingId: context.recordingId,