@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/{recordingService-Ig2UgbLv.esm.js → recordingService-Bn9EdCmz.esm.js}

@@ -1,13 +1,64 @@
-import { l as WasmPipelineType, r as mlWasmJSApi_default, t as BaseWasmProvider } from "./BaseWasmProvider-C_DLEI40.esm.js";
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { i as stopCameraStream, r as requestCameraAccess } from "./camera-PA2Ljri3.esm.js";
-import { n as IncodeCanvas } from "./deepsightService-O74l4Y__.esm.js";
-import { a as isIPhone14OrHigher, n as isDesktop, r as isIOS, t as isAndroid } from "./platform-CfrjKhmi.esm.js";
-import { n as getDesktopCameraStream, t as getBackCameraStream } from "./backCameraStream-DMdMeGk2.esm.js";
-import { t as addDeviceStats } from "./stats-CIfiPzb1.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+import { i as mlWasmJSApi_default, n as BaseWasmProvider, u as WasmPipelineType } from "./WasmUtilProvider-CiEN7Gjn.esm.js";
+import { r as getToken, t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
+import { a as isIPhone14OrHigher, n as isDesktop, r as isIOS, t as isAndroid } from "./platform-SKvEfCBh.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DJWm3V4g.esm.js";
+import { t as sleep } from "./ITimerCapability-CB0I1Uf2.esm.js";
+import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
+import { n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-D7Wo4Nbx.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-C8Do2qYu.esm.js";
+import { t as FACE_ERROR_CODES } from "./types-DsnEVMhr.esm.js";
 
+//#region ../infra/src/scheduling/yieldUntilNextPaint.ts
+/**
+* Resolves after the browser has had a chance to commit and paint a queued
+* render.
+*
+* Strategy:
+* - `requestAnimationFrame` callbacks fire BEFORE the paint of the frame
+*   they belong to (per the HTML5 "update the rendering" step). If we
+*   resolve the promise inside a rAF callback, the await-continuation
+*   runs as a microtask immediately after the callback returns — still
+*   before the paint phase of that frame. A caller that then blocks the
+*   main thread (e.g. synchronous WASM `processPhoto`) starves the paint.
+* - We therefore chain rAF → setTimeout: the rAF fires before frame N's
+*   paint, the setTimeout runs as a macrotask scheduled after frame N's
+*   "update the rendering" step, which the browser will only get to once
+*   the paint actually lands. By the time setTimeout fires, the paint
+*   for the queued render is on screen.
+* - In environments where rAF never ticks (jsdom, happy-dom, backgrounded
+*   tabs), a parallel `setTimeout` fallback at 100 ms resolves instead.
+*   100 ms is comfortably longer than two real-browser frames so rAF +
+*   setTimeout wins reliably in any foregrounded browser. (An earlier
+*   implementation raced rAF against a `MessageChannel` macrotask, but
+*   MessageChannel drains immediately after the current task's
+*   microtasks — before the next paint — so it resolved the promise too
+*   early and defeated the whole point of the helper.)
+*
+* Lives in infra because it touches browser APIs (`requestAnimationFrame`,
+* `setTimeout`) that the architecture rules forbid from core. Core modules
+* that need to yield to the browser render loop should import this helper
+* directly via its file path.
+*/
+function yieldUntilNextPaint() {
+	return new Promise((resolve) => {
+		let resolved = false;
+		const done = () => {
+			if (resolved) return;
+			resolved = true;
+			resolve();
+		};
+		if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => {
+			requestAnimationFrame(() => {
+				setTimeout(done, 0);
+			});
+		});
+		setTimeout(done, 100);
+	});
+}
+
+//#endregion
 //#region ../infra/src/providers/wasm/FaceDetectionProvider.ts
 var FaceDetectionProvider = class extends BaseWasmProvider {
 	constructor() {
@@ -31,10 +82,8 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 			framesAggregationInterval: 2e3,
 			minFramesWithFace: 3
 		};
-		this.currentFrame = null;
 	}
 	async processFrame(image) {
-		this.currentFrame = image;
 		await this.processFrameWasm(image);
 	}
 	async initialize(config) {
@@ -55,15 +104,11 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 	setCallbacks(callbacks) {
 		this.ensureInitialized();
 		const onCaptureWrapper = (wasmCanvas, face) => {
-			let frameCanvas = null;
-			if (this.currentFrame) frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
-			else if (wasmCanvas) frameCanvas = new IncodeCanvas(wasmCanvas);
-			if (!frameCanvas) return;
+			if (!wasmCanvas) return;
+			const frameCanvas = new IncodeCanvas(wasmCanvas);
+			frameCanvas.updateBase64Image();
+			frameCanvas.updateBlob();
 			const faceCoordinates = face ? this.formatFaceCoordinates(face) : this.createDefaultFaceCoordinates(frameCanvas);
-			try {
-				frameCanvas.updateBase64Image();
-				frameCanvas.updateBlob();
-			} catch {}
 			callbacks.onCapture?.(frameCanvas, faceCoordinates);
 		};
 		mlWasmJSApi_default.setFaceDetectionCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onTooClose ?? (() => {}), callbacks.onTooManyFaces ?? (() => {}), callbacks.onNoFace ?? (() => {}), onCaptureWrapper, callbacks.onGetReady ?? (() => {}), callbacks.onGetReadyFinished ?? (() => {}), callbacks.onCenterFace ?? (() => {}), callbacks.onDark ?? (() => {}), callbacks.onBlur ?? (() => {}), callbacks.onFaceAngle ?? (() => {}), callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
@@ -127,10 +172,6 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 		this.ensureInitialized();
 		mlWasmJSApi_default.setFaceDetectionMode(this.getPipelineType(), enabled);
 	}
-	reset() {
-		super.reset();
-		this.currentFrame = null;
-	}
 	createDefaultFaceCoordinates(canvas) {
 		return {
 			rightEyeX: 0,
@@ -240,45 +281,12 @@ async function uploadDeepsightVideo(encryptedVideo, token) {
 	}
 }
 
-//#endregion
-//#region src/internal/faceCapture/types.ts
-const FACE_ERROR_CODES = {
-	FACE_OCCLUDED: "FACE_OCCLUDED",
-	LIVENESS: "LIVENESS_ERROR",
-	BRIGHTNESS: "BRIGHTNESS_ERROR",
-	LENSES: "LENSES_ERROR",
-	MASK: "MASK_ERROR",
-	CLOSED_EYES: "CLOSED_EYES_ERROR",
-	HEAD_COVER: "HEAD_COVER_ERROR",
-	SERVER: "SERVER_ERROR",
-	FACE_NOT_FOUND: "FACE_NOT_FOUND",
-	MULTIPLE_FACES: "MULTIPLE_FACES",
-	TOO_BLURRY: "TOO_BLURRY_ERROR",
-	TOO_DARK: "TOO_DARK_ERROR",
-	USER_IS_NOT_RECOGNIZED: "USER_IS_NOT_RECOGNIZED",
-	SPOOF_ATTEMPT_DETECTED: "SPOOF_ATTEMPT_DETECTED",
-	FACE_TOO_DARK: "FACE_TOO_DARK",
-	LENSES_DETECTED: "LENSES_DETECTED",
-	FACE_MASK_DETECTED: "FACE_MASK_DETECTED",
-	CLOSED_EYES_DETECTED: "CLOSED_EYES_DETECTED",
-	HEAD_COVER_DETECTED: "HEAD_COVER_DETECTED",
-	FACE_CROPPING_FAILED: "FACE_CROPPING_FAILED",
-	FACE_TOO_SMALL: "FACE_TOO_SMALL",
-	FACE_TOO_BLURRY: "FACE_TOO_BLURRY",
-	BAD_PHOTO_QUALITY: "BAD_PHOTO_QUALITY",
-	PROCESSING_ERROR: "PROCESSING_ERROR",
-	BAD_REQUEST: "BAD_REQUEST",
-	NONEXISTENT_CUSTOMER: "NONEXISTENT_CUSTOMER",
-	HINT_NOT_PROVIDED: "HINT_NOT_PROVIDED",
-	SELFIE_IMAGE_LOW_QUALITY: "SELFIE_IMAGE_LOW_QUALITY"
-};
-
 //#endregion
 //#region src/modules/selfie/selfieUploadService.ts
 /**
 * Uploads a selfie image to the backend.
 */
-async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId }) {
+async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, metadata, recordingId, deepsightService }) {
 	try {
 		const payload = {
 			base64Image: encryptedBase64Image,
@@ -294,6 +302,12 @@ async function uploadSelfie({ encryptedBase64Image, faceCoordinates, signal, met
 			query
 		});
 		if (!res.ok) throw new Error(`POST ${endpoints.selfie} failed: ${res.status} ${res.statusText}`);
+		if (deepsightService) addDeviceStats({
+			frontIdStatsAnalysisStatus: "",
+			backIdStatsAnalysisStatus: "",
+			selfieStatsAnalysisStatus: deepsightService.getAnalysisStatus(),
+			motionStatus: deepsightService.getMotionStatus()
+		});
 		return res.data;
 	} catch (error) {
 		const errorCode = getFaceErrorCodeFromHttpError(error);
@@ -326,6 +340,7 @@ async function processFace(imageType = "selfie", signal) {
 
 //#endregion
 //#region src/internal/faceCapture/faceCaptureServices.ts
+const ONDEVICE_AUTOCAPTURE_INTERVAL_MS = 2147483647;
 function sendLabelInspectionEvent() {
 	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
 }
@@ -341,10 +356,11 @@ const IPHONE14_SELFIE_CONSTRAINTS = {
 	video: { height: { ideal: 1080 } },
 	audio: false
 };
-function buildCameraConstraints(resolution) {
+function buildCameraConstraints(resolution, deviceId) {
 	if (resolution) return {
 		video: {
 			facingMode: "user",
+			deviceId: deviceId ? { exact: deviceId } : void 0,
 			height: resolution.height ? { ideal: resolution.height } : void 0,
 			width: resolution.width ? { ideal: resolution.width } : void 0
 		},
@@ -357,16 +373,18 @@ function stopStream(stream) {
 	stopCameraStream(stream);
 }
 async function getFrontCameraStream(resolution) {
-	if (resolution) return requestCameraAccess(buildCameraConstraints(resolution));
-	if (isDesktop()) return getDesktopCameraStream({});
-	return requestCameraAccess(buildCameraConstraints());
+	if (isDesktop()) {
+		if (resolution) return ensureFrontCameraStream((deviceId) => requestCameraAccess(buildCameraConstraints(resolution, deviceId)));
+		return ensureFrontCameraStream((deviceId) => getDesktopCameraStream(deviceId ? { deviceId } : {}));
+	}
+	return requestCameraAccess(resolution ? buildCameraConstraints(resolution) : buildCameraConstraints());
 }
 async function initializeCamera(params) {
 	const { config } = params;
 	const prcConstraints = buildCameraConstraints(config.cameraResolution);
 	const provider = new FaceDetectionProvider();
 	await provider.initialize({
-		autocaptureInterval: config.autoCaptureTimeout * 1e3,
+		autocaptureInterval: isOnDeviceMode(config) ? ONDEVICE_AUTOCAPTURE_INTERVAL_MS : config.autoCaptureTimeout * 1e3,
 		useOnDeviceWorkflow: config.onDeviceFaceResultsSubmissionEnabled === true
 	});
 	provider.setChecksEnabled({
@@ -472,7 +490,7 @@ function buildResolutionFromStream(stream) {
 	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
 }
 async function createOpenViduRecordingProvider() {
-	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-CMu6XVdc.esm.js");
+	const { OpenViduRecordingProvider } = await import("./OpenViduRecordingProvider-O4GjBseO.esm.js");
 	return new OpenViduRecordingProvider();
 }
 async function startRecordingSession(params) {
@@ -512,7 +530,7 @@ async function stopRecording(session) {
 	}
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-Cm4JIT_z.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-65k1Appi.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage
@@ -520,119 +538,116 @@ async function initializeDeepsightSession(options) {
 }
 
 //#endregion
-//#region ../infra/src/media/StreamCanvasCapture.ts
-var StreamCanvasCapture = class {
-	constructor(stream, options) {
-		this.hasFrame = false;
-		this.disposed = false;
-		this.eventTarget = new EventTarget();
-		this.video = document.createElement("video");
-		this.video.srcObject = stream;
-		this.video.autoplay = true;
-		this.video.playsInline = true;
-		this.video.muted = true;
-		const settings = stream.getVideoTracks()[0]?.getSettings();
-		const initialWidth = options?.width ?? settings?.width ?? 1280;
-		const initialHeight = options?.height ?? settings?.height ?? 720;
-		this.canvas = document.createElement("canvas");
-		this.canvas.width = initialWidth;
-		this.canvas.height = initialHeight;
-		this.ctx = this.canvas.getContext("2d", { willReadFrequently: true });
-		const fps = options?.fps ?? 10;
-		const intervalMs = fps > 0 ? Math.max(16, Math.floor(1e3 / fps)) : 0;
-		this.video.addEventListener("loadedmetadata", () => {
-			if (this.video.videoWidth > 0 && this.video.videoHeight > 0) {
-				this.canvas.width = this.video.videoWidth;
-				this.canvas.height = this.video.videoHeight;
-			}
-		});
-		try {
-			this.video.play();
-		} catch {}
-		this.rafLoop(intervalMs);
-	}
-	addEventListener(type, listener, options) {
-		this.eventTarget.addEventListener(type, listener, options);
-	}
-	removeEventListener(type, listener, options) {
-		this.eventTarget.removeEventListener(type, listener, options);
-	}
-	/**
-	* Returns the latest cached frame as an {@link IncodeCanvas}.
-	*/
-	getLatestCanvas() {
-		if (!this.hasFrame) this.tick();
-		if (!this.hasFrame) return null;
-		return new IncodeCanvas(this.canvas);
-	}
-	/**
-	* Returns the latest cached frame as raw {@link ImageData}.
-	*/
-	getLatestFrame() {
-		if (!this.ctx) return null;
-		if (!this.hasFrame) this.tick();
-		if (!this.hasFrame) return null;
-		try {
-			return this.ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
-		} catch {
-			return null;
-		}
-	}
-	/**
-	* Disposes internal resources and stops the capture loop.
-	*/
-	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		if (this.rafId !== void 0) {
-			window.cancelAnimationFrame(this.rafId);
-			this.rafId = void 0;
-		}
-		this.video.srcObject = null;
-		this.canvas.width = 0;
-		this.canvas.height = 0;
-		this.hasFrame = false;
-	}
-	rafLoop(intervalMs) {
-		const loop = (timeMs) => {
-			if (this.disposed) return;
-			if (intervalMs <= 0 || this.lastTickTimeMs === void 0 || timeMs - this.lastTickTimeMs >= intervalMs) {
-				this.lastTickTimeMs = timeMs;
-				const previousFrameTimeSeconds = this.lastFrameTimeSeconds;
-				this.tick();
-				const currentFrameTimeSeconds = this.video.currentTime;
-				if (previousFrameTimeSeconds === void 0) {
-					if (this.hasFrame) {
-						this.lastFrameTimeSeconds = currentFrameTimeSeconds;
-						this.eventTarget.dispatchEvent(new Event("frame"));
-					}
-				} else if (this.hasFrame && currentFrameTimeSeconds !== previousFrameTimeSeconds) {
-					this.lastFrameTimeSeconds = currentFrameTimeSeconds;
-					this.eventTarget.dispatchEvent(new Event("frame"));
-				}
-			}
-			this.rafId = window.requestAnimationFrame(loop);
-		};
-		this.rafId = window.requestAnimationFrame(loop);
-	}
-	tick() {
-		if (!this.ctx) return;
-		if (this.video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
-		const videoWidth = this.video.videoWidth;
-		const videoHeight = this.video.videoHeight;
-		if (videoWidth === 0 || videoHeight === 0) return;
-		if (this.canvas.width !== videoWidth || this.canvas.height !== videoHeight) {
-			this.canvas.width = videoWidth;
-			this.canvas.height = videoHeight;
-		}
-		try {
-			this.ctx.drawImage(this.video, 0, 0);
-			this.hasFrame = true;
-		} catch {
-			this.hasFrame = false;
-		}
+//#region src/internal/faceCapture/onDeviceFaceResults.ts
+/**
+* On-device face-results submission helpers.
+*
+* When a SELFIE or AUTHENTICATION module has
+* `onDeviceFaceResultsSubmissionEnabled: true`, face analysis runs entirely
+* inside the WASM `OnDeviceSelfieWorkflow` pipeline. Captured images are
+* never uploaded — only the staged face-results JSON is POSTed via the WASM
+* `WebApi` to `/omni/add/face-results`. The C++ side encrypts that JSON via
+* `SessionEncryptor`, so the per-request `createWasmApi` encryption pipeline
+* is not engaged on this path.
+*
+* Note: even though the per-request encryption pipeline is skipped, the
+* on-device endpoint (`/omni/add/face-results`) is only served on the
+* E2EE-provisioned host — callers must still configure `setup()` with the
+* dedicated E2EE `apiURL` and `encryption: true`. See `SetupOptions.encryption`.
+*
+* These helpers are deliberately variant-agnostic: both the selfie and auth
+* state machine variants delegate their `prepareFaceUpload`, `uploadFace`,
+* and `processFace` actors here to share behavior. See the "Runtime modes
+* within a module" section of `docs/patterns/XSTATE.md` for the broader
+* pattern.
+*/
+const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
+/**
+* The default (non-on-device) prepare-upload body shared by selfie and auth.
+* Stops any active recording, runs deepsight virtual-camera + frame checks,
+* tracks the capture attempt, and encrypts the captured image.
+*
+* Lifted out of `faceCaptureSetup.ts`'s base `prepareFaceUpload` actor so the
+* default path can be reused by both variants while leaving room for an
+* on-device branch alongside it.
+*/
+async function defaultPrepareFaceUpload(ctx) {
+	const sessionToken = getToken();
+	const recordingId = (await ctx.recordingService?.stop())?.recordingId ?? null;
+	try {
+		if (ctx.deepsightService) await Promise.all([ctx.deepsightService.performVirtualCameraCheck(sessionToken, "SELFIE"), ctx.deepsightService.analyzeFrame(ctx.capturedImage.getImageData())]);
+	} catch (error) {}
+	const logs = ctx.deepsightService?.getPipelineState() ?? "";
+	ctx.dependencies.trackCaptureAttemptFinished?.({ logs });
+	return {
+		encryptedBase64Image: await encryptSelfieImage({
+			canvas: ctx.capturedImage,
+			dependencies: ctx.dependencies
+		}),
+		recordingId
+	};
+}
+/**
+* On-device prepare-upload. No recording to stop (the recording service is
+* never created when the flag is on), no image encryption needed.
+*
+* Behavior depends on which capture path got us here:
+*
+* - **Auto-capture path**: the WASM `OnDeviceSelfiePipeline` has been
+*   consuming every video frame via `processFrame()` and aggregating
+*   results across them. When it picks a best-shot, the C++
+*   `OnDeviceSelfieWorkflow::createOnCaptureHandler` calls
+*   `WebApi::setFaceResults(...)` automatically — staging strong,
+*   aggregated `BestShotData` for the subsequent `postFaceResults` call.
+*   We must NOT call `processPhoto` here: `applyFaceResults` would
+*   overwrite that staged state with a weaker single-frame analysis of a
+*   post-capture snapshot (camera state has already changed: autocapture
+*   freeze, stream pause, post-detection latency), and the server then
+*   rejects the submission as "image quality too low".
+*
+* - **Manual-capture path**: the auto-capture timer expired without a
+*   successful best-shot, so the C++ pipeline has nothing staged. We
+*   need to run a single-frame analysis on the manually captured canvas
+*   via `processPhoto`, which itself calls
+*   `OnDeviceSelfieWorkflow::applyFaceResults` → `WebApi::setFaceResults`
+*   to stage results. Mirrors V1 (`packages/incode-welcome/src/camera/useSelfie.ts`)
+*   where `processPhoto` is only invoked from `handleManualCapture`.
+*
+* Returns sentinel values for `encryptedBase64Image` and `recordingId` so
+* the existing FaceCaptureContext shape remains stable; downstream actors
+* for the on-device path simply ignore them.
+*/
+async function prepareOnDeviceFaceUpload(ctx) {
+	if (!ctx.capturedImage) throw new Error("On-device capture requires a captured image canvas");
+	if (!ctx.provider) throw new Error("On-device capture requires the FaceDetectionProvider to be initialized");
+	if (ctx.manualCaptureTriggered) {
+		await yieldUntilNextPaint();
+		await sleep(350);
+		ctx.provider.processPhoto(ctx.capturedImage.canvas);
 	}
-};
+	return {
+		encryptedBase64Image: "",
+		recordingId: null
+	};
+}
+/**
+* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
+* through the WASM `WebApi`. Used as the `uploadFace` actor body for both
+* selfie and auth variants when on-device mode is enabled.
+*
+* The C++ `WebApi` handles `SessionEncryptor` encryption and the actual
+* HTTP via the WASM `WebClient` — so callers don't need to thread the
+* session-encryption details through JS.
+*/
+async function postOnDeviceFaceResults(ctx, signal) {
+	const provider = ctx.provider;
+	if (!provider) throw new Error("On-device upload requires the FaceDetectionProvider to be initialized");
+	const sessionToken = getToken();
+	return await provider.postFaceResults({
+		headers: sessionToken ? { "X-Incode-Hardware-Id": sessionToken } : void 0,
+		timeout: 3e4
+	}) ?? {};
+}
 
 //#endregion
 //#region src/internal/manualReview/manualReviewService.ts
@@ -898,12 +913,12 @@ var LocalRecordingProvider = class {
 let openViduProviderImportPromise;
 let openViduBrowserImportPromise;
 function loadOpenViduProviderModule() {
-	if (!openViduProviderImportPromise) openViduProviderImportPromise = import("./OpenViduRecordingProvider-CMu6XVdc.esm.js");
+	if (!openViduProviderImportPromise) openViduProviderImportPromise = import("./OpenViduRecordingProvider-O4GjBseO.esm.js");
 	return openViduProviderImportPromise;
 }
 function loadOpenViduBrowserModule() {
 	if (!openViduBrowserImportPromise) openViduBrowserImportPromise = (async () => {
-		return (await import("./openviduLazy-Cm0XFh_v.esm.js")).loadOpenVidu();
+		return (await import("./openviduLazy-B8L--0oe.esm.js")).loadOpenVidu();
 	})();
 	return openViduBrowserImportPromise;
 }
@@ -922,9 +937,11 @@ var LocalRecordingService = class {
 	}
 	async start(stream) {
 		this.recorder.startRecording(stream);
+		this.wasmUtil.osv();
 	}
 	async stop() {
 		if (!this.recorder.isRecording) return { recordingId: null };
+		this.wasmUtil.oev();
 		const result = await this.recorder.stopRecording(10, (base64) => this.wasmUtil.encryptImage(base64), (buffer) => this.wasmUtil.ckvcks(buffer));
 		if (!this.sessionToken) return { recordingId: null };
 		return { recordingId: await uploadDeepsightVideo(result.encryptedVideo, this.sessionToken) };
@@ -932,6 +949,7 @@ var LocalRecordingService = class {
 	async stopAndGetVideo() {
 		if (!this.recorder.isRecording) return { videoBase64: void 0 };
 		try {
+			this.wasmUtil.oev();
 			const videoBase64 = (await this.recorder.stopRecording(10, (base64) => base64, () => {})).encryptedVideo;
 			return { videoBase64: videoBase64 ? videoBase64 : void 0 };
 		} catch {
@@ -1000,4 +1018,4 @@ function createRecordingService(params) {
 }
 
 //#endregion
-export { stopRecording$1 as _, StreamCanvasCapture as a, initializeDeepsightSession as c, stopStream as d, processFace as f, startRecording as g, createRecordingSession as h, flagIdManualReview as i, sendLabelInspectionEvent as l, FACE_ERROR_CODES as m, preloadOpenViduProvider as n, encryptSelfieImage as o, uploadSelfie as p, flagFaceManualReview as r, initializeCamera as s, createRecordingService as t, startDetection as u, StreamCanvasProcessingSession as v };
+export { startRecording as _, defaultPrepareFaceUpload as a, prepareOnDeviceFaceUpload as c, sendLabelInspectionEvent as d, startDetection as f, createRecordingSession as g, uploadSelfie as h, flagIdManualReview as i, initializeCamera as l, processFace as m, preloadOpenViduProvider as n, isOnDeviceMode as o, stopStream as p, flagFaceManualReview as r, postOnDeviceFaceResults as s, createRecordingService as t, initializeDeepsightSession as u, stopRecording$1 as v, StreamCanvasProcessingSession as y };

package/dist/redirect-to-mobile.d.ts

@@ -1,107 +1,9 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { a as RedirectToMobileActor, c as RedirectToMobileServices, i as createRedirectToMobileManagerFromActor, n as RedirectToMobileState, o as redirectToMobileMachine, r as createRedirectToMobileManager, s as RedirectToMobileConfig, t as RedirectToMobileManager } from "./redirectToMobileManager-BNe3IzC_.js";
 
-//#region src/modules/redirect-to-mobile/types.d.ts
-type RedirectToMobileConfig = {
-  flowId?: string;
-  url?: string;
-  disableSmsOption?: boolean;
-  addContinueToDesktop?: boolean;
-  qrPhishingResistance?: boolean;
-  authHint?: string;
-  externalId?: string;
-  lang?: string;
-};
-//#endregion
-//#region src/modules/redirect-to-mobile/redirectToMobileStateMachine.d.ts
+//#region src/modules/redirect-to-mobile/redirectToMobileServices.d.ts
 
-declare const redirectToMobileMachine: any;
-//#endregion
-//#region src/modules/redirect-to-mobile/redirectToMobileActor.d.ts
-type CreateRedirectToMobileActorOptions = {
-  config: RedirectToMobileConfig;
-};
-//#endregion
-//#region src/modules/redirect-to-mobile/redirectToMobileManager.d.ts
-type RedirectToMobileIdleState = {
-  status: 'idle';
-};
-type RedirectToMobileLoadingState = {
-  status: 'loading';
-};
-type RedirectToMobileRedirectingState = {
-  status: 'redirecting';
-  redirectUrl: string;
-  phonePrefix: string;
-  smsSent: boolean;
-  error: string | undefined;
-};
-type RedirectToMobileFinishedState = {
-  status: 'finished';
-};
-type RedirectToMobileClosedState = {
-  status: 'closed';
-};
-type RedirectToMobileErrorState = {
-  status: 'error';
-  error: string;
-};
-type RedirectToMobileState = RedirectToMobileIdleState | RedirectToMobileLoadingState | RedirectToMobileRedirectingState | RedirectToMobileFinishedState | RedirectToMobileClosedState | RedirectToMobileErrorState;
-/**
- * Creates a redirect-to-mobile manager for cross-device onboarding flows.
- *
- * On desktop, displays a QR code (and optional SMS input) so the user can
- * continue on their mobile device. Polls the backend until the mobile
- * session completes, then transitions to `finished`.
- *
- * @param options - Configuration for the redirect module
- * @returns A manager instance with state subscription and API methods
- *
- * @example
- * ```ts
- * const manager = createRedirectToMobileManager({
- *   config: { disableSmsOption: false, addContinueToDesktop: true },
- * });
- *
- * manager.subscribe((state) => {
- *   if (state.status === 'redirecting') {
- *     renderQrCode(state.redirectUrl);
- *   }
- *   if (state.status === 'finished') {
- *     console.log('Mobile onboarding complete');
- *   }
- * });
- *
- * manager.load();
- * ```
- */
-declare function createRedirectToMobileManager(options: CreateRedirectToMobileActorOptions): Manager<RedirectToMobileState> & {
-  /**
-   * Starts the redirect-to-mobile flow by fetching the redirect URL.
-   */
-  load(): void;
-  /**
-   * Sends an SMS with the redirect link to the given phone number.
-   * @param phone - Full phone number with country code
-   */
-  sendSms(phone: string): void;
-  /**
-   * Skips the redirect and allows the user to continue on desktop.
-   */
-  continueOnDesktop(): void;
-  /**
-   * Resets the SMS state so the user can re-enter their phone number.
-   */
-  resetSms(): void;
-  /**
-   * Closes/dismisses the redirect screen.
-   */
-  close(): void;
-  /**
-   * Retries generating the redirect URL after an error.
-   */
-  retry(): void;
-};
-type RedirectToMobileManager = ReturnType<typeof createRedirectToMobileManager>;
+declare const defaultRedirectToMobileServices: RedirectToMobileServices;
 //#endregion
-export { type RedirectToMobileConfig, type RedirectToMobileManager, type RedirectToMobileState, createRedirectToMobileManager, redirectToMobileMachine };
+export { type RedirectToMobileActor, type RedirectToMobileConfig, type RedirectToMobileManager, type RedirectToMobileServices, type RedirectToMobileState, createRedirectToMobileManager, createRedirectToMobileManagerFromActor, defaultRedirectToMobileServices, redirectToMobileMachine };