@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/id-selfie-flow.esm.js

@@ -0,0 +1,917 @@
+import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
+import { t as ensureWasmPipelines } from "./setup-CYdVacqv.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
+import { i as resolveDashboardModuleConfig, l as facingModeForStep } from "./flowServices-unhF9V9F.esm.js";
+import { c as createManager, n as sendTo, 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 { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-f81FVdQs.esm.js";
+import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
+import { i as uploadSelfie, r as processFace } 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";
+import { a as processId, d as validateUploadResponse, f as ID_ERROR_CODES, l as uploadIdImage } from "./idCaptureServices-CFDwqTtQ.esm.js";
+import { n as getFinishStatus } from "./flowCompletionService-BSe3p7pg.esm.js";
+import { a as delay, c as isWrongVideoSelfieIdSide, n as defaultAcquireCamera, r as CameraCompositor, s as isSelfieValidationError } from "./videoSelfieCameraWarmer-h_VUk5Vu.esm.js";
+//#region src/modules/id-selfie-flow/idSelfieFlowStepDetector.ts
+/** Default autocapture window for the selfie step. */
+const SELFIE_AUTOCAPTURE_MS = 1e4;
+const SELFIE_SUCCESS_DWELL_MS = 900;
+const ID_SUCCESS_DWELL_MS = 900;
+function abortError() {
+	return /* @__PURE__ */ new Error("aborted");
+}
+function throwIfAborted(signal) {
+	if (signal.aborted) throw abortError();
+}
+/**
+* Maps a regular ID-upload validation error to the Video Selfie failure
+* vocabulary the shared UI masks already know how to render.
+*/
+function idValidationFailureFor(validationError) {
+	if (validationError.errorKey === ID_ERROR_CODES.ID_TYPE_UNACCEPTABLE) return "idTypeMismatch";
+	return "idScanFailed";
+}
+/**
+* Builds the per-step detector for the ID + Selfie flow, shipping every
+* accepted frame through the REGULAR onboarding endpoints:
+*
+* - `frontId` / `backId` run the REGULAR ID-capture pipeline (same as the
+*   standalone ID module: best-frame autocapture, quality values, live mask
+*   orientation) → `POST /omni/add/front-id/v2` / `add/back-id/v2` + the
+*   response quality validation the standalone ID module applies.
+* - `selfie` reuses the Video Selfie face UX → encrypt →
+*   `POST /omni/add/face?imageType=selfie` →
+*   `POST /omni/process/face?imageType=selfie`.
+*
+* `process/id` is NOT called here — the state machine invokes it once, after
+* the last ID side is accepted (mirrors how integrators chain the modules).
+*/
+function createIdSelfieFlowStepDetector(config, deps) {
+	return ({ step, stream, signal, onStatus, onOrientation, registerManualCapture }) => {
+		if (step === "selfie") return detectSelfie({
+			config,
+			deps,
+			stream,
+			signal,
+			onStatus,
+			registerManualCapture
+		});
+		if (step === "frontId" || step === "backId") return detectId({
+			step,
+			stream,
+			signal,
+			onStatus,
+			onOrientation,
+			registerManualCapture
+		});
+		return new Promise(() => {});
+	};
+}
+async function detectSelfie(params) {
+	const { config, deps, stream, signal, onStatus, registerManualCapture } = 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 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;
+		let submitting = false;
+		function settle(run) {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			run();
+		}
+		const submit = (canvas, faceCoordinates) => {
+			if (submitting || settled) return;
+			submitting = true;
+			onStatus?.("capturing");
+			(async () => {
+				try {
+					const encryptedBase64Image = await encryptSelfieImage({
+						canvas,
+						dependencies: { getWasmUtil: async () => deps.getWasmUtil() }
+					});
+					throwIfAborted(signal);
+					await uploadSelfie({
+						encryptedBase64Image,
+						faceCoordinates,
+						imageType: "selfie"
+					});
+					throwIfAborted(signal);
+					await processFace("selfie");
+					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))));
+				}
+			})();
+		};
+		const detection = startDetection({
+			config: detectionConfig,
+			capturer,
+			provider,
+			onUpdate: (status) => onStatus?.(status),
+			onSuccess: (canvas, faceCoordinates) => {
+				submit(canvas, faceCoordinates);
+			}
+		});
+		registerManualCapture?.(() => {
+			const canvas = capturer.getLatestCanvas();
+			if (!canvas) return;
+			submit(canvas);
+		});
+		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, stream, signal, onStatus, onOrientation, registerManualCapture } = params;
+	const provider = new IdCaptureProvider();
+	await provider.initialize({});
+	if (signal.aborted) {
+		provider.dispose();
+		throw abortError();
+	}
+	const capturer = new StreamCanvasCapture(stream);
+	const initialCanvas = capturer.getLatestCanvas();
+	const windowDimensions = getWindowDimensions(initialCanvas?.width() ?? 1280, initialCanvas?.height() ?? 720);
+	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: false,
+		glareCheckEnabled: false,
+		faceQualityCheckEnabled: true,
+		iouCheckEnabled: true,
+		fpsLimitEnabled: false
+	});
+	provider.setThresholds(DEFAULT_ID_CAPTURE_THRESHOLDS);
+	provider.setModelType("v2");
+	return new Promise((resolve, reject) => {
+		let validating = false;
+		let wrongSide = false;
+		let settled = false;
+		let toreDown = false;
+		let bestCanvas = null;
+		let storedQuality = {};
+		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()));
+		}
+		function uploadCaptured(base64Image) {
+			validating = true;
+			onStatus?.("capturing");
+			(async () => {
+				try {
+					const response = await uploadIdImage({
+						type: step === "backId" ? "back" : "front",
+						image: base64Image,
+						glare: storedQuality.glare,
+						sharpness: storedQuality.sharpness,
+						signal
+					});
+					throwIfAborted(signal);
+					const validationError = validateUploadResponse({
+						...response,
+						side: step === "backId" ? "back" : "front"
+					});
+					if (validationError) {
+						onStatus?.("error");
+						settle(() => resolve({
+							outcome: "validationFailed",
+							failure: idValidationFailureFor(validationError)
+						}));
+						return;
+					}
+					onStatus?.("success");
+					await delay(ID_SUCCESS_DWELL_MS, signal);
+					settle(() => resolve({ outcome: "success" }));
+				} catch (error) {
+					if (signal.aborted) {
+						settle(() => reject(error instanceof Error ? error : new Error(String(error))));
+						return;
+					}
+					onStatus?.("error");
+					settle(() => resolve({
+						outcome: "retryableFailure",
+						failure: "idScanFailed"
+					}));
+				}
+			})();
+		}
+		provider.setCallbacks({
+			onFarAway: () => {
+				if (!validating && !wrongSide) onStatus?.("tooFar");
+			},
+			onMaskChange: (_show, _mask, _top, orientation) => {
+				onOrientation?.(orientation);
+			},
+			onBlur: () => {
+				if (!validating && !wrongSide) onStatus?.("blur");
+			},
+			onIdNotDetected: () => {
+				if (!validating && !wrongSide) onStatus?.("detecting");
+			},
+			onSwitchToManualCapture: () => {
+				if (!validating) onStatus?.("manualCapture");
+			},
+			onIdSideChange: (side) => {
+				if (validating) return;
+				wrongSide = isWrongVideoSelfieIdSide(step, side);
+				onStatus?.(wrongSide ? "wrongSide" : "detecting");
+			},
+			onCapturing: () => {
+				if (!validating) onStatus?.("capturing");
+			},
+			onBestFrame: (blur, glare, orientation) => {
+				const latest = capturer.getLatestCanvas();
+				if (latest) {
+					bestCanvas = latest.clone();
+					storedQuality = {
+						glare,
+						sharpness: blur
+					};
+				}
+				if (orientation === "horizontal" || orientation === "vertical") onOrientation?.(orientation);
+			},
+			onCapture: () => {
+				if (validating) return;
+				const base64Image = bestCanvas?.getBase64Image() ?? capturer.getLatestCanvas()?.getBase64Image();
+				if (!base64Image) return;
+				uploadCaptured(base64Image);
+			}
+		});
+		registerManualCapture?.(() => {
+			if (validating || settled) return;
+			const base64Image = capturer.getLatestCanvas()?.getBase64Image();
+			if (!base64Image) return;
+			storedQuality = {};
+			uploadCaptured(base64Image);
+		});
+		onStatus?.("detecting");
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) onAbort();
+	});
+}
+//#endregion
+//#region src/modules/id-selfie-flow/idSelfieFlowStateMachine.ts
+/** A detector that never settles — used when no config was provided. */
+const manualStepDetector = () => new Promise(() => {});
+function eventOutputStream(event) {
+	return event.output;
+}
+function errorFromEvent(event) {
+	return String(event.error);
+}
+function detectionStatusFromEvent(event) {
+	return event.status;
+}
+function detectionErrorFromEvent(event) {
+	return event.error;
+}
+function validationFailureFromEvent(event) {
+	return event.failure;
+}
+function orientationFromEvent(event) {
+	return event.orientation;
+}
+function finishStatusFromEvent(event) {
+	return event.output;
+}
+function retryableFailureFromEvent(event) {
+	return event.failure;
+}
+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 waitForDwell(ms, signal) {
+	if (ms <= 0) return Promise.resolve(!signal.aborted);
+	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 the ID + Selfie flow behind the Video Selfie UX: ONE continuous
+* camera session that auto-advances per step and switches the camera facing
+* between the ID and selfie sections — but runs the REGULAR capture pipeline
+* (no recording, no microphone):
+*
+*   idle ─START▶ acquiringCamera ─▶ capturing ⇄ validationFeedback/flippingId
+*                    │ last ID side accepted ─▶ processingId ─▶ switchingCamera
+*                    │ last step accepted ─▶ success ─▶ finished
+*
+* `capturing` runs the injected per-step detector (WASM autocapture + regular
+* endpoint upload). When the last ID side is accepted the machine invokes
+* `process/id` before switching to the selfie; the selfie detector runs
+* `add/face` + `process/face` itself.
+*
+* Teardown mirrors the Video Selfie recording machine: `ABORT` is accepted from
+* any non-final state and every settled path runs `cleanup`. XState v5 executes
+* NO exit actions on an external `actor.stop()`, so the manager sends `ABORT`
+* before stopping the actor.
+*/
+const idSelfieFlowSetup = setup({
+	types: {
+		context: {},
+		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, false);
+			if (signal.aborted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera acquire cancelled");
+			}
+			return stream;
+		}),
+		switchCamera: fromPromise(async ({ input, signal }) => {
+			const dwellCompleted = waitForDwell(input.minDwellMs, signal);
+			const stream = await input.acquire(input.facingMode, false);
+			if (signal.aborted || !await dwellCompleted) {
+				stream.getTracks().forEach((track) => track.stop());
+				throw new Error("Camera switch cancelled");
+			}
+			return stream;
+		}),
+		runProcessId: fromPromise(async ({ input, signal }) => input.run(input.queueName, signal)),
+		runFinish: fromPromise(async ({ input, signal }) => input.run(signal)),
+		detectStep: fromCallback(({ input, sendBack, receive }) => {
+			const controller = new AbortController();
+			let manualCaptureTrigger;
+			receive((event) => {
+				if (event.type === "MANUAL_CAPTURE") manualCaptureTrigger?.();
+			});
+			input.detect({
+				step: input.step,
+				stream: input.stream,
+				signal: controller.signal,
+				onStatus: (status) => sendBack({
+					type: "DETECTION_STATUS",
+					status
+				}),
+				onOrientation: (orientation) => sendBack({
+					type: "ORIENTATION",
+					orientation
+				}),
+				registerManualCapture: (trigger) => {
+					manualCaptureTrigger = trigger;
+				}
+			}).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)
+				});
+			});
+			return () => controller.abort();
+		})
+	},
+	actions: {
+		advanceStep: assign({
+			stepIndex: ({ context }) => context.stepIndex + 1,
+			attemptsRemaining: ({ context }) => context.attemptsPerStep,
+			validationFailure: () => void 0
+		}),
+		setDetectionStatus: assign(({ context, event }) => {
+			const status = detectionStatusFromEvent(event);
+			return {
+				detectionStatus: status,
+				manualCaptureAvailable: context.manualCaptureAvailable || status === "manualCapture"
+			};
+		}),
+		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(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) }),
+		setAttemptsExhaustedError: assign({ error: () => "Capture attempts exhausted" }),
+		clearDetectionFeedback: assign({
+			detectionStatus: () => void 0,
+			validationFailure: () => void 0,
+			orientation: () => void 0,
+			manualCaptureAvailable: () => false
+		}),
+		resetSession: assign(({ context }) => ({
+			stepIndex: 0,
+			stream: void 0,
+			composite: void 0,
+			finishStatus: void 0,
+			orientation: void 0,
+			manualCaptureAvailable: false,
+			detectionStatus: void 0,
+			validationFailure: void 0,
+			attemptsRemaining: context.attemptsPerStep,
+			error: void 0
+		})),
+		cleanup: ({ context }) => {
+			context.compositor.stop();
+			context.stream?.getTracks().forEach((track) => track.stop());
+		}
+	},
+	guards: {
+		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",
+		/** The accepted step closes the ID section → run `process/id` next. */
+		completedIdSection: ({ context }) => isIdStep(context.steps[context.stepIndex]) && !isIdStep(context.steps[context.stepIndex + 1]),
+		nextStepFlipsCamera: ({ context }) => facingModeForStep(context.steps[context.stepIndex]) !== facingModeForStep(context.steps[context.stepIndex + 1])
+	}
+});
+/**
+* Shared advance transitions for an accepted step. Order matters: closing the
+* ID section routes through `processingId` first; the front→back flip shows
+* the flip modal; the final step ends the session.
+*/
+const ADVANCE_TRANSITIONS = [
+	{
+		target: "flippingId",
+		guard: "nextStepFlipsId"
+	},
+	{
+		target: "processingId",
+		guard: "completedIdSection"
+	},
+	{
+		target: "finishing",
+		guard: "isLastStep"
+	},
+	{
+		target: "switchingCamera",
+		guard: "nextStepFlipsCamera",
+		actions: "advanceStep"
+	},
+	{
+		target: "capturing",
+		reenter: true,
+		actions: "advanceStep"
+	}
+];
+const idSelfieFlowMachine = idSelfieFlowSetup.createMachine({
+	id: "idSelfieFlow",
+	initial: "idle",
+	context: ({ input }) => ({
+		compositor: input.dependencies?.createCompositor?.() ?? new CameraCompositor(),
+		acquireCamera: input.dependencies?.acquireCamera ?? defaultAcquireCamera,
+		detect: input.dependencies?.detect ?? manualStepDetector,
+		runProcessId: input.dependencies?.runProcessId ?? (async (queueName, signal) => {
+			await processId(false, queueName, signal);
+		}),
+		runFinish: input.dependencies?.runFinish ?? ((signal) => getFinishStatus(void 0, signal)),
+		finishStatus: void 0,
+		steps: input.steps && input.steps.length > 0 ? input.steps : [
+			"frontId",
+			"backId",
+			"selfie"
+		],
+		stepIndex: 0,
+		stream: void 0,
+		composite: void 0,
+		detectionStatus: void 0,
+		orientation: void 0,
+		manualCaptureAvailable: false,
+		validationFailure: void 0,
+		attemptsPerStep: normalizeAttempts(input.attemptsPerStep),
+		attemptsRemaining: normalizeAttempts(input.attemptsPerStep),
+		processIdQueueName: input.processIdQueueName ?? "",
+		error: void 0,
+		switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS
+	}),
+	on: { ABORT: { target: ".closed" } },
+	states: {
+		idle: { on: { START: { target: "acquiringCamera" } } },
+		acquiringCamera: { invoke: {
+			src: "acquireCamera",
+			input: ({ context }) => ({
+				acquire: context.acquireCamera,
+				facingMode: facingModeForStep(context.steps[context.stepIndex])
+			}),
+			onDone: {
+				target: "capturing",
+				actions: [({ context, event }) => {
+					context.compositor.start(eventOutputStream(event));
+				}, assign({
+					stream: ({ event }) => eventOutputStream(event),
+					composite: ({ context }) => context.compositor.stream
+				})]
+			},
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		capturing: {
+			entry: "clearDetectionFeedback",
+			invoke: {
+				id: "detectStep",
+				src: "detectStep",
+				input: ({ context }) => ({
+					detect: context.detect,
+					step: context.steps[context.stepIndex],
+					stream: context.stream
+				})
+			},
+			on: {
+				DETECTION_STATUS: { actions: "setDetectionStatus" },
+				ORIENTATION: { actions: "setOrientation" },
+				MANUAL_CAPTURE: { actions: sendTo("detectStep", { type: "MANUAL_CAPTURE" }) },
+				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: "capturing",
+			guard: "hasAttemptsRemaining"
+		}, {
+			target: "error",
+			actions: "setAttemptsExhaustedError"
+		}] } },
+		flippingId: {
+			after: { ID_FLIP_DWELL: {
+				target: "capturing",
+				actions: "advanceStep"
+			} },
+			on: { NEXT_STEP: {
+				target: "capturing",
+				actions: "advanceStep"
+			} }
+		},
+		processingId: { invoke: {
+			src: "runProcessId",
+			input: ({ context }) => ({
+				run: context.runProcessId,
+				queueName: context.processIdQueueName
+			}),
+			onDone: [
+				{
+					target: "finishing",
+					guard: "isLastStep"
+				},
+				{
+					target: "switchingCamera",
+					guard: "nextStepFlipsCamera",
+					actions: "advanceStep"
+				},
+				{
+					target: "capturing",
+					reenter: true,
+					actions: "advanceStep"
+				}
+			],
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		switchingCamera: { invoke: {
+			src: "switchCamera",
+			input: ({ context }) => ({
+				acquire: context.acquireCamera,
+				facingMode: facingModeForStep(context.steps[context.stepIndex]),
+				minDwellMs: context.switchingCameraMinDwellMs
+			}),
+			onDone: {
+				target: "capturing",
+				actions: [({ context, event }) => {
+					context.compositor.switchVideo(eventOutputStream(event));
+				}, assign({ stream: ({ event }) => eventOutputStream(event) })]
+			},
+			onError: {
+				target: "error",
+				actions: assign({ error: ({ event }) => errorFromEvent(event) })
+			}
+		} },
+		finishing: {
+			entry: "cleanup",
+			invoke: {
+				src: "runFinish",
+				input: ({ context }) => ({ run: context.runFinish }),
+				onDone: {
+					target: "success",
+					actions: assign({ finishStatus: ({ event }) => finishStatusFromEvent(event) })
+				},
+				onError: {
+					target: "error",
+					actions: assign({ error: ({ event }) => errorFromEvent(event) })
+				}
+			}
+		},
+		success: { after: { FINAL_SUCCESS_DWELL: "finished" } },
+		finished: { type: "final" },
+		error: {
+			entry: "cleanup",
+			on: { RETRY: {
+				target: "acquiringCamera",
+				actions: "resetSession"
+			} }
+		},
+		closed: {
+			type: "final",
+			entry: "cleanup"
+		}
+	}
+});
+//#endregion
+//#region src/modules/id-selfie-flow/idSelfieFlowActor.ts
+function createIdSelfieFlowActor(options = {}) {
+	const config = options.config;
+	const detect = options.dependencies?.detect ?? (config ? createIdSelfieFlowStepDetector(config, { getWasmUtil: () => WasmUtilProvider.getInstance() }) : void 0);
+	return createActor(idSelfieFlowMachine, { input: {
+		steps: config?.steps,
+		attemptsPerStep: config?.numberOfTries,
+		processIdQueueName: config?.processIdQueueName,
+		dependencies: {
+			...options.dependencies,
+			detect
+		}
+	} }).start();
+}
+//#endregion
+//#region src/modules/id-selfie-flow/idSelfieFlowManager.ts
+function mapState(snapshot) {
+	const value = typeof snapshot.value === "string" ? snapshot.value : "idle";
+	const { context } = snapshot;
+	const status = value === "acquiringCamera" ? "starting" : value;
+	const steps = context.steps;
+	const stepIndex = context.stepIndex;
+	return {
+		status,
+		step: steps[stepIndex],
+		stepIndex,
+		isLastStep: stepIndex >= steps.length - 1,
+		stream: context.stream,
+		composite: context.composite,
+		detectionStatus: context.detectionStatus,
+		orientation: context.orientation,
+		manualCaptureAvailable: context.manualCaptureAvailable,
+		validationFailure: context.validationFailure,
+		attemptsRemaining: context.attemptsRemaining,
+		finishStatus: context.finishStatus,
+		error: context.error
+	};
+}
+function createApi({ actor }) {
+	return {
+		/** Acquire the first camera and begin the capture session. */
+		start() {
+			actor.send({ type: "START" });
+		},
+		retry() {
+			actor.send({ type: "RETRY" });
+		},
+		/**
+		* Advance to the next step (manual steps only — the capture steps
+		* auto-advance once the backend accepts the frame).
+		*/
+		nextStep() {
+			actor.send({ type: "NEXT_STEP" });
+		},
+		/**
+		* Capture + upload the current ID frame. Meaningful once
+		* `manualCaptureAvailable` is `true` (autocapture timed out).
+		*/
+		manualCapture() {
+			actor.send({ type: "MANUAL_CAPTURE" });
+		},
+		/** Abandon the session. */
+		abort() {
+			actor.send({ type: "ABORT" });
+		}
+	};
+}
+/**
+* Creates a manager for the ID + Selfie flow PoC: the regular ID front/back +
+* selfie capture pipeline (regular endpoints, regular validations) presented
+* through the Video Selfie continuous-camera UX. No recording, no microphone.
+*
+* Exposes `getState()` / `subscribe()` (status, step, preview `stream`) plus
+* `start()`, `nextStep()`, `retry()`, and `abort()`.
+*/
+function createIdSelfieFlowManager(options = {}) {
+	const actor = createIdSelfieFlowActor(options);
+	const manager = createManager({
+		actor,
+		mapState,
+		createApi
+	});
+	return {
+		...manager,
+		stop() {
+			if (actor.getSnapshot().status === "active") actor.send({ type: "ABORT" });
+			manager.stop();
+		}
+	};
+}
+//#endregion
+//#region src/modules/id-selfie-flow/idSelfieFlowWasm.ts
+/**
+* The WASM pipelines an ID + Selfie flow session loads: the Video Selfie face
+* pipeline for the selfie step, plus the REGULAR ID-capture pipeline (same as
+* the standalone ID module — best-frame autocapture, quality scoring, mask
+* orientation) when any ID step is active.
+*/
+function idSelfieFlowWasmPipelines(config) {
+	const steps = config.steps ?? [
+		"frontId",
+		"backId",
+		"selfie"
+	];
+	const pipelines = ["videoSelfie"];
+	if (steps.includes("frontId") || steps.includes("backId")) pipelines.push("idCapture");
+	return pipelines;
+}
+/**
+* Warms the WASM pipelines the ID + Selfie flow needs. Idempotent and safe to
+* call eagerly (e.g. while the tutorial or permissions screen is up). No-op
+* when WASM was not configured.
+*/
+function warmupIdSelfieFlowWasm(config) {
+	return ensureWasmPipelines(idSelfieFlowWasmPipelines(config));
+}
+//#endregion
+//#region src/modules/id-selfie-flow/idSelfieFlowDashboardConfig.ts
+function definedEntries(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+/**
+* Derives the ID + Selfie flow config from the active session's FLOW
+* configuration — the same dashboard config the regular ID and SELFIE modules
+* read. Requires an active session token (`initializeSession`).
+*
+* Mapping:
+* - Steps: `frontId`/`backId` when the flow has an ID module (`onlyFront` /
+*   `onlyBack` respected), `selfie` when it has a SELFIE module.
+* - `showTutorials`: either module's `showTutorial`.
+* - `numberOfTries`: the larger of the two modules' `captureAttempts`.
+* - Selfie validations (`validateLenses` / mask / eyes / head cover): from
+*   the SELFIE module config.
+*
+* A module missing from the flow simply drops its steps; if neither module is
+* present the promise rejects. Any `options.config` values win over the
+* derived ones. If the flow cannot be fetched but `options.config` was
+* provided, it is returned as-is (standalone fallback).
+*/
+async function resolveIdSelfieFlowConfig(options = {}) {
+	const overrides = options.config ? definedEntries(options.config) : {};
+	const [idConfig, selfieConfig] = await Promise.all([resolveDashboardModuleConfig({
+		moduleKey: "ID",
+		signal: options.signal
+	}).catch(() => void 0), resolveDashboardModuleConfig({
+		moduleKey: "SELFIE",
+		signal: options.signal
+	}).catch(() => void 0)]);
+	if (!idConfig && !selfieConfig) {
+		if (options.config) return options.config;
+		throw new Error("The active flow has neither an ID nor a SELFIE module (and no config was provided)");
+	}
+	const steps = [];
+	if (idConfig) {
+		if (idConfig.onlyBack !== true) steps.push("frontId");
+		if (idConfig.onlyFront !== true) steps.push("backId");
+	}
+	if (selfieConfig) steps.push("selfie");
+	const attempts = Math.max(typeof idConfig?.captureAttempts === "number" ? idConfig.captureAttempts : 0, typeof selfieConfig?.captureAttempts === "number" ? selfieConfig.captureAttempts : 0);
+	return {
+		steps,
+		showTutorials: idConfig?.showTutorial === true || selfieConfig?.showTutorial === true,
+		...attempts > 0 ? { numberOfTries: attempts } : {},
+		validateLenses: selfieConfig?.validateLenses ?? false,
+		validateFaceMask: selfieConfig?.validateFaceMask ?? false,
+		validateClosedEyes: selfieConfig?.validateClosedEyes ?? false,
+		validateHeadCover: selfieConfig?.validateHeadCover ?? false,
+		...overrides
+	};
+}
+//#endregion
+export { createIdSelfieFlowManager, resolveIdSelfieFlowConfig, warmupIdSelfieFlowWasm };