@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/videoSelfieCameraWarmer-h_VUk5Vu.esm.js

@@ -0,0 +1,651 @@
+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 { l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-unhF9V9F.esm.js";
+import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
+import { t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
+import { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-f81FVdQs.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.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-C2PYBVsp.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-WeHbQM7W.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);
+}
+/** Attempts for the selfie upload + process round (first try + retries). */
+const SELFIE_SUBMIT_ATTEMPTS = 3;
+const SELFIE_SUBMIT_BACKOFF_MS = 2e3;
+/**
+* True for HTTP-transport-shaped failures — network error / client-side
+* timeout (status 0), 408, 429, 5xx — as opposed to a backend verdict.
+* Plain Errors (aborts, programming faults) are not connection errors.
+*/
+function isConnectionError(error) {
+	if (typeof error !== "object" || error === null || !("status" in error)) return false;
+	const status = error.status;
+	if (typeof status !== "number") return false;
+	return status === 0 || status === 408 || status === 429 || status >= 500;
+}
+/**
+* True for errors where the selfie submission never got a meaningful backend
+* verdict, as opposed to a validation outcome. Re-sending the same payload
+* can succeed, so these are retried in place instead of failing the whole
+* recording.
+*/
+function isSelfieTransportError(error) {
+	return !isSelfieValidationError(error) && isConnectionError(error);
+}
+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, onOrientation }) => {
+		if (step === "selfie") return detectSelfie({
+			config,
+			deps,
+			stream,
+			signal,
+			onStatus
+		});
+		if (step === "frontId" || step === "backId") return detectId({
+			step,
+			config,
+			stream,
+			signal,
+			onStatus,
+			onOrientation
+		});
+		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);
+						for (let attempt = 1;; attempt += 1) try {
+							await uploadSelfie({
+								encryptedBase64Image,
+								faceCoordinates,
+								imageType
+							});
+							throwIfAborted(signal);
+							await processFace(imageType);
+							break;
+						} catch (error) {
+							if (signal.aborted || !isSelfieTransportError(error) || attempt >= SELFIE_SUBMIT_ATTEMPTS) throw error;
+							await delay(SELFIE_SUBMIT_BACKOFF_MS * attempt, signal);
+						}
+						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) throw error;
+		if (isSelfieTransportError(error)) {
+			onStatus?.("error");
+			return {
+				outcome: "retryableFailure",
+				failure: "selfieUploadFailed"
+			};
+		}
+		if (!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, onOrientation } = 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");
+			},
+			onMaskChange: (_show, _mask, _top, orientation) => {
+				onOrientation?.(orientation);
+			},
+			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
+//#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
+export { delay as a, isWrongVideoSelfieIdSide as c, createDefaultStepDetector as i, defaultAcquireCamera as n, isConnectionError as o, CameraCompositor as r, isSelfieValidationError as s, createVideoSelfieCameraWarmer as t };