@incodetech/core 0.0.0-dev-20260126-4504c5b

package/dist/src-DYtpbFY5.esm.js

@@ -0,0 +1,2781 @@
+import { a as __toDynamicImportESM } from "./chunk-V5DOKNPJ.esm.js";
+
+//#region ../infra/src/capabilities/platform.ts
+/**
+* Platform detection utilities for camera operations.
+* These are pure functions with no external dependencies and can be used by all layers.
+*/
+let uxType = null;
+function isTouchDevice() {
+	return (typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false) || "ontouchstart" in (typeof document !== "undefined" ? document.documentElement : {});
+}
+function isTabletWithoutAndroid(userAgent) {
+	const isLinux = /Linux/i.test(userAgent);
+	const isChrome = /Chrome/i.test(userAgent) && !/Edge/i.test(userAgent);
+	return !/Mobile|Android/i.test(userAgent) && isLinux && isChrome && isTouchDevice();
+}
+function isIOS(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
+	return /iPad|iPhone|iPod/.test(ua) || /Mac OS/.test(ua) && hasTouchPoints || /iPadOS/.test(ua);
+}
+function isAndroid(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Android/i.test(ua);
+}
+function isDesktop(userAgent) {
+	if (uxType) return uxType === "desktop";
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return !(/Mobile|Android/i.test(ua) || isTabletWithoutAndroid(ua) || isIOS(ua));
+}
+function isSafari(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Safari/i.test(ua) && !/Chrome|Chromium|Edge/i.test(ua);
+}
+const IPHONE_14_PLUS_DIMENSIONS = [
+	{
+		outerHeight: 852,
+		outerWidth: 393
+	},
+	{
+		outerHeight: 932,
+		outerWidth: 430
+	},
+	{
+		innerHeight: 631,
+		innerWidth: 375
+	},
+	{
+		innerHeight: 920,
+		innerWidth: 402
+	},
+	{
+		outerHeight: 874,
+		outerWidth: 402
+	},
+	{
+		innerHeight: 874,
+		innerWidth: 402
+	},
+	{
+		outerHeight: 912,
+		outerWidth: 420
+	},
+	{
+		outerHeight: 873,
+		outerWidth: 402
+	},
+	{
+		outerHeight: 956,
+		outerWidth: 440
+	}
+];
+function isIPhone14OrHigher() {
+	if (typeof window === "undefined") return false;
+	const { outerHeight, outerWidth, innerHeight, innerWidth } = window;
+	return IPHONE_14_PLUS_DIMENSIONS.some((dims) => dims.outerHeight === outerHeight && dims.outerWidth === outerWidth || dims.innerHeight === innerHeight && dims.innerWidth === innerWidth);
+}
+
+//#endregion
+//#region ../infra/src/http/createApi.ts
+var FetchHttpError = class extends Error {
+	constructor(status, statusText, url, method, headers, data) {
+		super(`HTTP ${status} ${statusText}`);
+		this.ok = false;
+		this.status = status;
+		this.statusText = statusText;
+		this.url = url;
+		this.method = method;
+		this.headers = headers;
+		this.data = data;
+		this.name = "FetchHttpError";
+	}
+};
+const buildQueryString = (query) => {
+	if (!query) return "";
+	const params = new URLSearchParams();
+	Object.entries(query).forEach(([key, value]) => {
+		if (value !== void 0 && value !== null) params.append(key, String(value));
+	});
+	const str = params.toString();
+	return str ? `?${str}` : "";
+};
+const buildUrl = (baseURL, url, query) => {
+	const queryString = buildQueryString(query);
+	if (url.startsWith("http://") || url.startsWith("https://")) return `${url}${queryString}`;
+	return `${baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL}${url.startsWith("/") ? url : `/${url}`}${queryString}`;
+};
+const prepareBody = (body) => {
+	if (body === null || body === void 0) return null;
+	if (body instanceof FormData || body instanceof Blob || body instanceof ArrayBuffer) return body;
+	if (typeof body === "object") return JSON.stringify(body);
+	return String(body);
+};
+const parseResponse = async (response, parseType) => {
+	if (parseType === "response") return response;
+	if (parseType === "blob") return await response.blob();
+	if (parseType === "arrayBuffer") return await response.arrayBuffer();
+	if (parseType === "text") return await response.text();
+	const contentType = response.headers.get("content-type") ?? "";
+	if (parseType === "json" || contentType.includes("application/json")) try {
+		return await response.json();
+	} catch {
+		return await response.text();
+	}
+	return await response.text();
+};
+const DEFAULT_TIMEOUT = 3e4;
+const requestWithXHR = (fullUrl, method, mergedHeaders, requestBody, timeout, signal, onUploadProgress) => {
+	return new Promise((resolve, reject) => {
+		const xhr = new XMLHttpRequest();
+		xhr.open(method, fullUrl, true);
+		Object.entries(mergedHeaders).forEach(([key, value]) => {
+			xhr.setRequestHeader(key, value);
+		});
+		xhr.timeout = timeout;
+		xhr.upload.onprogress = (event) => {
+			if (event.lengthComputable) {
+				const percentComplete = event.loaded / event.total * 100;
+				onUploadProgress(Math.round(percentComplete));
+			}
+		};
+		xhr.onload = () => {
+			const responseHeaders = {};
+			xhr.getAllResponseHeaders().split("\r\n").forEach((line) => {
+				const parts = line.split(": ");
+				if (parts.length === 2) responseHeaders[parts[0].toLowerCase()] = parts[1];
+			});
+			let data;
+			try {
+				if ((xhr.getResponseHeader("content-type") ?? "").includes("application/json")) data = JSON.parse(xhr.responseText);
+				else data = xhr.responseText;
+			} catch {
+				data = xhr.responseText;
+			}
+			if (xhr.status >= 200 && xhr.status < 300) resolve({
+				ok: true,
+				status: xhr.status,
+				statusText: xhr.statusText,
+				url: fullUrl,
+				headers: responseHeaders,
+				data
+			});
+			else reject(new FetchHttpError(xhr.status, xhr.statusText, fullUrl, method, responseHeaders, data));
+		};
+		xhr.onerror = () => {
+			reject(new FetchHttpError(0, "Network Error", fullUrl, method, {}, null));
+		};
+		xhr.ontimeout = () => {
+			reject(new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null));
+		};
+		if (signal) signal.addEventListener("abort", () => {
+			xhr.abort();
+			reject(new FetchHttpError(0, "Request aborted", fullUrl, method, {}, null));
+		});
+		xhr.send(requestBody);
+	});
+};
+const createApi = (config) => {
+	const headers = {
+		"Content-Type": "application/json",
+		Accept: "application/json",
+		"api-version": "1.0",
+		...config.customHeaders ?? {}
+	};
+	const defaults = {
+		baseURL: config.apiURL,
+		headers
+	};
+	const client = {
+		defaults,
+		async request(requestConfig) {
+			const { method = "GET", url, headers: headers$1 = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT, parse, onUploadProgress } = requestConfig;
+			const fullUrl = buildUrl(defaults.baseURL, url, params ?? query);
+			const mergedHeaders = {
+				...defaults.headers,
+				...headers$1
+			};
+			const requestBody = prepareBody(body);
+			let finalHeaders = mergedHeaders;
+			if (requestBody === null && (method === "POST" || method === "PUT" || method === "PATCH")) {
+				const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
+				finalHeaders = headersWithoutContentType;
+			}
+			if (onUploadProgress) {
+				if (requestBody !== null && typeof ReadableStream !== "undefined" && requestBody instanceof ReadableStream) throw new Error("Upload progress tracking is not supported for ReadableStream bodies");
+				return requestWithXHR(fullUrl, method, finalHeaders, requestBody, timeout, signal, onUploadProgress);
+			}
+			const controller = new AbortController();
+			const abortSignal = signal ?? controller.signal;
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const response = await fetch(fullUrl, {
+					method,
+					headers: finalHeaders,
+					body: requestBody,
+					signal: abortSignal
+				});
+				if (timeoutId) clearTimeout(timeoutId);
+				const responseHeaders = {};
+				response.headers.forEach((value, key) => {
+					responseHeaders[key] = value;
+				});
+				const data = await parseResponse(response, parse);
+				if (!response.ok) throw new FetchHttpError(response.status, response.statusText, fullUrl, method, responseHeaders, data);
+				return {
+					ok: true,
+					status: response.status,
+					statusText: response.statusText,
+					url: fullUrl,
+					headers: responseHeaders,
+					data
+				};
+			} catch (error) {
+				if (timeoutId) clearTimeout(timeoutId);
+				if (error instanceof FetchHttpError) throw error;
+				if (error instanceof Error && error.name === "AbortError") throw new FetchHttpError(0, "Request timeout", fullUrl, method, {}, null);
+				throw error;
+			}
+		},
+		get(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "GET"
+			});
+		},
+		post(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "POST"
+			});
+		},
+		put(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "PUT"
+			});
+		},
+		patch(url, body, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				body,
+				method: "PATCH"
+			});
+		},
+		delete(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "DELETE"
+			});
+		},
+		head(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "HEAD"
+			});
+		},
+		options(url, config$1) {
+			return client.request({
+				...config$1,
+				url,
+				method: "OPTIONS"
+			});
+		},
+		setHeader(name, value) {
+			defaults.headers[name] = value;
+		}
+	};
+	return client;
+};
+var createApi_default = createApi;
+
+//#endregion
+//#region ../infra/src/manager/Manager.ts
+/**
+* Creates a manager that wraps a state machine actor with a clean public API.
+*
+* The manager provides:
+* - `getState()` - Returns the mapped public state
+* - `subscribe()` - Listen to state changes
+* - `stop()` - Stop the actor
+* - Plus any custom API methods from `createApi`
+*
+* @template TMachine - The state machine type
+* @template TMapState - Function type that maps raw snapshot to public state
+* @template TCreateApi - Function type that creates the custom API
+*
+* @param options - Configuration options
+* @param options.actor - The started actor instance
+* @param options.mapState - Function to transform raw snapshot into public state
+* @param options.createApi - Factory function to create custom API methods
+*
+* @returns Combined manager with base methods and custom API
+*
+* @example
+* ```ts
+* const manager = createManager({
+*   actor: createActor(myMachine).start(),
+*   mapState: (snapshot) => ({ status: snapshot.value }),
+*   createApi: ({ actor }) => ({
+*     doSomething() { actor.send({ type: 'DO_IT' }); }
+*   }),
+* });
+* ```
+*/
+function createManager(options) {
+	const { actor, mapState, createApi: createApi$1 } = options;
+	function getSnapshot() {
+		return actor.getSnapshot();
+	}
+	function getState() {
+		return mapState(getSnapshot());
+	}
+	function subscribe(listener) {
+		const subscription = actor.subscribe(() => {
+			listener(getState());
+		});
+		return () => subscription.unsubscribe();
+	}
+	const api = createApi$1({
+		actor,
+		getSnapshot
+	});
+	const base = {
+		getState,
+		subscribe,
+		stop() {
+			actor.stop();
+		}
+	};
+	return Object.defineProperties(base, Object.getOwnPropertyDescriptors(api));
+}
+
+//#endregion
+//#region ../infra/src/media/camera.ts
+/**
+* Request camera access with specific constraints.
+* Throws if the request fails - no automatic fallback.
+*/
+async function requestCameraAccess(constraints) {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) throw new Error("MediaDevices API not available");
+	return navigator.mediaDevices.getUserMedia(constraints);
+}
+function stopCameraStream(stream) {
+	for (const track of stream.getTracks()) track.stop();
+}
+async function enumerateVideoDevices() {
+	if (typeof navigator === "undefined" || !navigator.mediaDevices) return [];
+	return (await navigator.mediaDevices.enumerateDevices()).filter((d) => d.kind === "videoinput");
+}
+async function applyTrackConstraints(track, constraints) {
+	await track.applyConstraints(constraints);
+}
+
+//#endregion
+//#region ../infra/src/media/canvas.ts
+/**
+* Class representing a canvas element for image capture and manipulation.
+*/
+var IncodeCanvas = class IncodeCanvas {
+	/**
+	* Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+	* @param imageData - Frame pixels in RGBA format
+	* @returns An {@link IncodeCanvas} containing the provided pixels
+	*/
+	static fromImageData(imageData) {
+		const canvas = document.createElement("canvas");
+		canvas.width = imageData.width;
+		canvas.height = imageData.height;
+		const context = canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return new IncodeCanvas(canvas);
+		if ("putImageData" in context) context.putImageData(imageData, 0, 0);
+		return new IncodeCanvas(canvas);
+	}
+	/**
+	* Create a new canvas element.
+	* @param canvas_ - The canvas element to clone.
+	*/
+	constructor(canvas_) {
+		this.base64Image = null;
+		this.blobData = null;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = canvas_.width;
+		this.canvas.height = canvas_.height;
+		const context = this.canvas.getContext("2d");
+		if (context) context.drawImage(canvas_, 0, 0);
+	}
+	/**
+	* Check if the current canvas is valid.
+	*/
+	checkCanvas() {
+		return this.canvas && this.canvas.width > 1 && this.canvas.height > 1;
+	}
+	/**
+	* Disposes of resources, including revoking object URLs to prevent memory leaks.
+	*/
+	dispose() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = null;
+		}
+		this.base64Image = null;
+	}
+	/**
+	* Release the data stored by IncodeCanvas.
+	*/
+	release() {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = 1;
+		this.canvas.height = 1;
+		this.canvas.getContext("2d")?.clearRect(0, 0, 1, 1);
+		this.base64Image = null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		this.blobData = null;
+	}
+	/**
+	* Revokes the object URL if one exists, preventing memory leaks.
+	* Use this when you no longer need the preview image URL.
+	*/
+	revokeObjectURL() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = {
+				...this.blobData,
+				url: ""
+			};
+		}
+	}
+	/**
+	* Get the width of the canvas.
+	*/
+	width() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.width;
+	}
+	/**
+	* Get the height of the canvas.
+	*/
+	height() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.height;
+	}
+	/**
+	* Set the width of the canvas.
+	*/
+	setWidth(width) {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = width;
+	}
+	/**
+	* Set the height of the canvas.
+	*/
+	setHeight(height) {
+		if (!this.checkCanvas()) return;
+		this.canvas.height = height;
+	}
+	/**
+	* Clone the current canvas.
+	*/
+	clone() {
+		if (!this.checkCanvas()) return null;
+		const cloned = new IncodeCanvas(this.canvas);
+		cloned.setBase64Image(this.base64Image);
+		return cloned;
+	}
+	/**
+	* Deep clone the current IncodeCanvas including blob data.
+	*/
+	async deepClone() {
+		const cloned = this.clone();
+		if (!cloned) return null;
+		if (this.blobData) await cloned.setBlobData(this.blobData);
+		return cloned;
+	}
+	/**
+	* Returns the drawing context on the canvas.
+	*/
+	getContext(contextId, contextAttributes) {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext(contextId, contextAttributes);
+		return context instanceof CanvasRenderingContext2D ? context : null;
+	}
+	/**
+	* Retrieves the image data from the canvas.
+	*/
+	getImageData() {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return null;
+		return context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+	}
+	/**
+	* Updates the base64 representation of the current canvas image.
+	*/
+	updateBase64Image(jpegQuality = 1) {
+		if (!this.checkCanvas()) return;
+		this.base64Image = this.canvas.toDataURL("image/jpeg", jpegQuality);
+	}
+	/**
+	* Converts the current canvas element to a base64 string.
+	*/
+	getBase64Image(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64Image = this.base64Image;
+		if (base64Image === null) return null;
+		if (includeDataURLPrefix) return base64Image;
+		const commaIndex = base64Image.indexOf(",");
+		if (commaIndex === -1) return base64Image;
+		return base64Image.slice(commaIndex + 1);
+	}
+	/**
+	* Sets the base64 representation of the current canvas image.
+	*/
+	setBase64Image(base64Image) {
+		this.base64Image = base64Image;
+	}
+	/**
+	* Updates the Blob representation of the current canvas image.
+	*/
+	updateBlob(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64 = this.getBase64Image(jpegQuality, includeDataURLPrefix);
+		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
+	}
+	/**
+	* Converts a base64 string to a Blob and creates a URL for it.
+	*/
+	static base64ToBlob(base64) {
+		try {
+			const binary = atob(base64);
+			const array = [];
+			for (let i = 0; i < binary.length; i++) array.push(binary.charCodeAt(i));
+			const blob = new Blob([new Uint8Array(array)]);
+			return {
+				blob,
+				url: URL.createObjectURL(blob)
+			};
+		} catch (error) {
+			console.error("Failed to convert base64 string to Blob:", error);
+		}
+		return null;
+	}
+	/**
+	* Retrieves the Blob data and its URL from the current canvas.
+	*/
+	getBlobData(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.blobData === null) this.updateBlob(jpegQuality, includeDataURLPrefix);
+		return this.blobData;
+	}
+	/**
+	* Sets the Blob data of the current canvas image.
+	*/
+	async setBlobData(blobData) {
+		const blobDataArrayBuffer = await blobData.blob.arrayBuffer();
+		this.blobData = {
+			blob: new Blob([blobDataArrayBuffer], { type: blobData.blob.type }),
+			url: blobData.url
+		};
+	}
+	/**
+	* Returns a resized canvas according to video element size.
+	*/
+	getResizedCanvas(videoElementWidth, videoElementHeight) {
+		if (!this.checkCanvas()) return null;
+		const cameraOffsetX = Math.abs(videoElementWidth - window.innerWidth);
+		const resized = new IncodeCanvas(document.createElement("canvas"));
+		const canvasHeight = this.height();
+		if (!canvasHeight) return null;
+		const ratio = canvasHeight / videoElementHeight;
+		const newWidth = window.innerWidth;
+		const newHeight = window.innerHeight;
+		resized.setWidth(newWidth);
+		resized.setHeight(newHeight);
+		const context = resized.getContext("2d");
+		if (!context) {
+			console.error("Failed to get 2d context in getResizedCanvas method.");
+			return null;
+		}
+		context.drawImage(this.canvas, ratio * cameraOffsetX / 2, 0, ratio * newWidth, ratio * newHeight, 0, 0, newWidth, newHeight);
+		return resized;
+	}
+};
+
+//#endregion
+//#region ../infra/src/media/video.ts
+/**
+* Creates a hidden video element for a stream and appends it to document.body.
+*/
+function createHiddenVideoElement(stream) {
+	if (typeof document === "undefined") throw new Error("Document not available");
+	const video = document.createElement("video");
+	video.autoplay = true;
+	video.playsInline = true;
+	video.muted = true;
+	video.srcObject = stream;
+	video.style.width = "0px";
+	video.style.height = "0px";
+	video.style.position = "absolute";
+	video.style.top = "0";
+	video.style.left = "0";
+	video.style.zIndex = "-1";
+	document.body.appendChild(video);
+	return {
+		element: video,
+		dispose: () => {
+			video.srcObject = null;
+			if (video.parentElement) video.parentElement.removeChild(video);
+		}
+	};
+}
+
+//#endregion
+//#region ../infra/src/media/permissions.ts
+async function queryPermission(name) {
+	try {
+		if (typeof navigator === "undefined" || !navigator.permissions) return "prompt";
+		return (await navigator.permissions.query({ name })).state;
+	} catch {
+		return "prompt";
+	}
+}
+async function queryCameraPermission() {
+	return queryPermission("camera");
+}
+
+//#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;
+		}
+	}
+};
+
+//#endregion
+//#region ../infra/src/media/StreamCanvasProcessingSession.ts
+var StreamCanvasProcessingSession = class {
+	/**
+	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
+	* and drives a provider's `processFrame()` method with backpressure.
+	*/
+	constructor(params) {
+		this.disposed = false;
+		this.isProcessing = false;
+		this.onFrameEvent = () => {
+			if (this.disposed || this.isProcessing) return;
+			const frame = this.capturer.getLatestFrame();
+			if (!frame) return;
+			this.onFrame?.(frame);
+			this.isProcessing = true;
+			this.provider.processFrame(frame).catch(() => {}).finally(() => {
+				this.isProcessing = false;
+			});
+		};
+		this.capturer = params.capturer;
+		this.provider = params.provider;
+		this.onFrame = params.onFrame;
+		this.capturer.addEventListener("frame", this.onFrameEvent);
+	}
+	/**
+	* Unsubscribes from frame events and resets the provider.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.capturer.removeEventListener("frame", this.onFrameEvent);
+		this.provider.reset();
+	}
+	/**
+	* Returns whether the session has been disposed.
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+};
+
+//#endregion
+//#region ../infra/src/media/VideoTrimmer.ts
+async function getDurationBySeek(videoBlob) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.src = URL.createObjectURL(videoBlob);
+	try {
+		if (!Number.isFinite(video.duration)) {
+			video.currentTime = Number.MAX_SAFE_INTEGER;
+			await new Promise((resolve) => {
+				const onDurationChange = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("durationchange", onDurationChange);
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						resolve(video.duration);
+					}
+				};
+				const onTimeUpdate = () => {
+					if (Number.isFinite(video.duration)) {
+						video.removeEventListener("timeupdate", onTimeUpdate);
+						video.removeEventListener("durationchange", onDurationChange);
+						resolve(video.duration);
+					}
+				};
+				video.addEventListener("durationchange", onDurationChange);
+				video.addEventListener("timeupdate", onTimeUpdate);
+			});
+		}
+		const duration = video.duration;
+		return Number.isFinite(duration) ? duration : null;
+	} finally {
+		URL.revokeObjectURL(video.src);
+		video.src = "";
+	}
+}
+async function trimLastNSecondsUsingPlayback(videoBlob, seconds) {
+	const video = document.createElement("video");
+	video.preload = "metadata";
+	video.playsInline = true;
+	video.muted = true;
+	const videoURL = URL.createObjectURL(videoBlob);
+	video.src = videoURL;
+	const duration = await getDurationBySeek(videoBlob);
+	if (!duration || duration < seconds) {
+		URL.revokeObjectURL(videoURL);
+		return videoBlob;
+	}
+	const startTime = Math.max(0, Math.floor(duration) - seconds);
+	await new Promise((resolve) => {
+		if (video.readyState >= 2) resolve();
+		else video.addEventListener("loadedmetadata", () => resolve(), { once: true });
+	});
+	const canvas = document.createElement("canvas");
+	canvas.width = 230;
+	canvas.height = 320;
+	const captureFps = isAndroid() ? 15 : 24;
+	const stream = canvas.captureStream(captureFps);
+	const ctx = canvas.getContext("2d");
+	video.currentTime = startTime;
+	await new Promise((resolve) => {
+		video.addEventListener("seeked", () => resolve(), { once: true });
+	});
+	ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+	const mimeType = videoBlob.type || (MediaRecorder.isTypeSupported("video/webm") ? "video/webm" : "video/mp4");
+	const mediaRecorder = new MediaRecorder(stream.clone(), {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	});
+	const chunks = [];
+	mediaRecorder.ondataavailable = (event) => {
+		if (event.data.size > 0) chunks.push(event.data);
+	};
+	const recordingPromise = new Promise((resolve) => {
+		mediaRecorder.onstop = () => {
+			const trimmedBlob$1 = new Blob(chunks, { type: mimeType });
+			URL.revokeObjectURL(videoURL);
+			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
+			stream.getTracks().forEach((track) => track.stop());
+			video.src = "";
+			resolve(trimmedBlob$1);
+		};
+	});
+	video.addEventListener("play", () => {
+		function drawVideo() {
+			if (video.currentTime >= duration) {
+				mediaRecorder.stop();
+				video.pause();
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			requestAnimationFrame(drawVideo);
+		}
+		drawVideo();
+		setTimeout(() => {
+			mediaRecorder.start(100);
+		}, 500);
+	});
+	video.play().catch(() => {
+		URL.revokeObjectURL(videoURL);
+	});
+	const trimmedBlob = await recordingPromise;
+	console.timeEnd("trimLastNSecondsUsingPlayback");
+	return trimmedBlob;
+}
+async function trimLastNSeconds(videoBlob, seconds) {
+	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/BrowserEnvironmentProvider.ts
+var BrowserEnvironmentProvider = class {
+	getScreenDimensions() {
+		if (typeof screen === "undefined") return {
+			width: 0,
+			height: 0
+		};
+		return {
+			width: screen.width,
+			height: screen.height
+		};
+	}
+	generateCanvasFingerprint() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const ctx = canvas.getContext("2d");
+			if (!ctx) return "";
+			ctx.textBaseline = "top";
+			ctx.font = "14px Arial";
+			ctx.fillText("fingerprint", 2, 2);
+			return canvas.toDataURL().slice(-50);
+		} catch {
+			return "";
+		}
+	}
+	getWebGLRenderer() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+			if (!gl) return "";
+			const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+			if (!debugInfo) return "";
+			return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+		} catch {
+			return "";
+		}
+	}
+	getWindowProperty(prop) {
+		if (typeof window === "undefined") return;
+		return window[prop];
+	}
+	getNavigatorProperty(prop) {
+		if (typeof navigator === "undefined") return;
+		return navigator[prop];
+	}
+	getNavigatorPrefixes() {
+		if (typeof navigator === "undefined") return {
+			webkit: false,
+			moz: false,
+			o: false,
+			ms: false
+		};
+		const nav = navigator;
+		return {
+			webkit: nav.webkitGetUserMedia !== void 0,
+			moz: nav.mozGetUserMedia !== void 0,
+			o: nav.oGetUserMedia !== void 0,
+			ms: nav.msGetUserMedia !== void 0
+		};
+	}
+	async fetchJson(url, timeoutMs = 3e3) {
+		try {
+			if (typeof fetch === "undefined") return null;
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+			const response = await fetch(url, { signal: controller.signal });
+			clearTimeout(timeoutId);
+			return await response.json();
+		} catch {
+			return null;
+		}
+	}
+	async enumerateVideoDeviceLabels() {
+		try {
+			if (typeof navigator === "undefined" || !navigator.mediaDevices?.enumerateDevices) return [];
+			return (await navigator.mediaDevices.enumerateDevices()).filter((device) => device.kind === "videoinput").map((device) => device.label);
+		} catch {
+			return [];
+		}
+	}
+	getTimestamp() {
+		return Date.now();
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/BrowserStorageProvider.ts
+/**
+* Browser-based storage provider wrapping localStorage.
+* Handles JSON serialization/deserialization automatically.
+*/
+var BrowserStorageProvider = class {
+	/**
+	* Retrieves a value from localStorage.
+	* @param key - The storage key
+	* @returns The stored value or null if not found
+	* @throws Error if stored value is invalid JSON
+	*/
+	async get(key) {
+		try {
+			const item = localStorage.getItem(key);
+			if (item === null) return null;
+			return JSON.parse(item);
+		} catch (error) {
+			if (error instanceof SyntaxError) throw new Error(`Invalid JSON stored at key "${key}": ${error.message}`);
+			throw error;
+		}
+	}
+	/**
+	* Stores a value in localStorage.
+	* @param key - The storage key
+	* @param value - The value to store (will be serialized as JSON)
+	* @throws Error if value cannot be serialized or quota is exceeded
+	*/
+	async set(key, value) {
+		try {
+			const serialized = JSON.stringify(value);
+			localStorage.setItem(key, serialized);
+		} catch (error) {
+			if ((error instanceof DOMException || error.name === "QuotaExceededError") && error.name === "QuotaExceededError") throw new Error(`Storage quota exceeded for key "${key}"`);
+			if (error instanceof TypeError) throw new Error(`Failed to serialize value for key "${key}": ${error.message}`);
+			throw error;
+		}
+	}
+	/**
+	* Removes a value from localStorage.
+	* @param key - The storage key to remove
+	*/
+	async remove(key) {
+		localStorage.removeItem(key);
+	}
+	/**
+	* Clears all values from localStorage.
+	*/
+	async clear() {
+		localStorage.clear();
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/BrowserTimerProvider.ts
+var BrowserTimerProvider = class BrowserTimerProvider {
+	static getInstance() {
+		if (!BrowserTimerProvider.instance) BrowserTimerProvider.instance = new BrowserTimerProvider();
+		return BrowserTimerProvider.instance;
+	}
+	setTimeout(callback, delayMs) {
+		return setTimeout(callback, delayMs);
+	}
+	setInterval(callback, delayMs) {
+		return setInterval(callback, delayMs);
+	}
+	clearTimeout(handle) {
+		clearTimeout(handle);
+	}
+	clearInterval(handle) {
+		clearInterval(handle);
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/LocalRecordingProvider.ts
+function toBase64(videoBlob) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onloadend = () => {
+			const base64 = reader.result.split(",")[1];
+			resolve(base64);
+		};
+		reader.onerror = () => reject(reader.error ?? /* @__PURE__ */ new Error("FileReader error"));
+		reader.readAsDataURL(videoBlob);
+	});
+}
+function getSupportedMediaRecorderMimeType() {
+	const possibleTypes = isIOS() ? [
+		"video/mp4",
+		"video/webm",
+		"video/webm;codecs=vp9",
+		"video/webm;codecs=vp8"
+	] : [
+		"video/webm",
+		"video/webm;codecs=vp9",
+		"video/webm;codecs=vp8",
+		"video/mp4"
+	];
+	for (const type of possibleTypes) if (MediaRecorder.isTypeSupported(type)) return type;
+	return "";
+}
+function getAdaptiveMediaRecorderOptions() {
+	const mimeType = getSupportedMediaRecorderMimeType();
+	if (isIOS()) return {
+		mimeType,
+		videoBitsPerSecond: 1e6,
+		bitsPerSecond: 1e6
+	};
+	return {
+		mimeType,
+		videoBitsPerSecond: 5e5,
+		bitsPerSecond: 5e5
+	};
+}
+var LocalRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.stream = null;
+		this.pauseRecordingBound = this.pauseRecording.bind(this);
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream) {
+		this.reset();
+		this.registerEventListeners();
+		this.stream = stream;
+		try {
+			const options = getAdaptiveMediaRecorderOptions();
+			this.mimeType = options.mimeType;
+			const recorder = new MediaRecorder(stream.clone(), options);
+			recorder.onerror = (event) => {
+				this._error = `Recording error: ${event}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start();
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			this._error = `Failed to start recording: ${err}`;
+			this._hasError = true;
+		}
+	}
+	async stopRecording(trimSeconds, encrypt, generateChecksum) {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve, reject) => {
+			this.removeEventListeners();
+			if (recorder && this._isRecording) {
+				const chunks = [];
+				recorder.ondataavailable = (event) => {
+					if (event.data.size > 0) chunks.push(event.data);
+				};
+				recorder.onstop = async () => {
+					try {
+						const trimmedVideo = await trimLastNSeconds(new Blob(chunks, { type: this.mimeType }), trimSeconds);
+						const encryptedVideoBase64 = encrypt(await toBase64(trimmedVideo));
+						generateChecksum(await trimmedVideo.arrayBuffer());
+						this._isRecording = false;
+						resolve({
+							trimmedBlob: trimmedVideo,
+							encryptedVideo: encryptedVideoBase64
+						});
+					} catch (error) {
+						this._isRecording = false;
+						this._error = `Recording stop failed: ${error}`;
+						this._hasError = true;
+						reject(error);
+					}
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve({
+				trimmedBlob: new Blob([], { type: this.mimeType }),
+				encryptedVideo: ""
+			});
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	reset() {
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+	pauseRecording() {
+		if (!this._isRecording) return;
+		if (this.mediaRecorder?.state === "recording") try {
+			this.mediaRecorder.pause();
+		} catch {}
+	}
+	registerEventListeners() {
+		document.addEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+	removeEventListeners() {
+		document.removeEventListener("visibilitychange", this.pauseRecordingBound);
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/MotionSensorProvider.ts
+var MotionSensorProvider = class {
+	constructor(thresholds) {
+		this._isRunning = false;
+		this._hasPermission = true;
+		this.acl = null;
+		this.gyro = null;
+		this.minNumberOfFrames = 3;
+		this.maxFrequency = 60;
+		this.emptyParams = {
+			meanX: 0,
+			meanY: 0,
+			meanZ: 0,
+			m2X: 0,
+			m2Y: 0,
+			m2Z: 0,
+			cumulativeAbsErrorX: 0,
+			cumulativeAbsErrorY: 0,
+			cumulativeAbsErrorZ: 0,
+			ptsNum: 0
+		};
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+		this.deviceMotionListener = (event) => {
+			if (event.accelerationIncludingGravity) {
+				const accGrVal = {
+					x: event.accelerationIncludingGravity.x,
+					y: event.accelerationIncludingGravity.y,
+					z: event.accelerationIncludingGravity.z
+				};
+				if (this.checkFields(accGrVal)) {
+					this.paramsAccGrOld.ptsNum += 1;
+					this.updateParams(this.paramsAccGrOld, accGrVal);
+				}
+			}
+			if (event.acceleration) {
+				const accVal = {
+					x: event.acceleration.x,
+					y: event.acceleration.y,
+					z: event.acceleration.z
+				};
+				if (this.checkFields(accVal)) {
+					this.paramsAccOld.ptsNum += 1;
+					this.updateParams(this.paramsAccOld, accVal);
+				}
+			}
+			if (event.rotationRate) {
+				const gyroVal = {
+					x: event.rotationRate.alpha,
+					y: event.rotationRate.beta,
+					z: event.rotationRate.gamma
+				};
+				if (this.checkFields(gyroVal)) {
+					this.paramsGyroscopeOld.ptsNum += 1;
+					this.updateParams(this.paramsGyroscopeOld, gyroVal);
+				}
+			}
+		};
+		this.deviceOrientationListener = (event) => {
+			const orientationVal = {
+				x: event.alpha,
+				y: event.beta,
+				z: event.gamma
+			};
+			if (this.checkFields(orientationVal)) {
+				this.paramsOrientationOld.ptsNum += 1;
+				this.updateParams(this.paramsOrientationOld, orientationVal);
+			}
+		};
+		this.thresholds = {
+			accThreshold: thresholds?.accThreshold ?? .3,
+			gyroThreshold: thresholds?.gyroThreshold ?? .3,
+			accGrOldThreshold: thresholds?.accGrOldThreshold ?? .3,
+			accOldThreshold: thresholds?.accOldThreshold ?? .3,
+			gyroscopeOldThreshold: thresholds?.gyroscopeOldThreshold ?? 10,
+			orientationOldThreshold: thresholds?.orientationOldThreshold ?? 10,
+			maeAccThreshold: thresholds?.maeAccThreshold ?? .3,
+			maeGyroThreshold: thresholds?.maeGyroThreshold ?? .3,
+			maeAccGrOldThreshold: thresholds?.maeAccGrOldThreshold ?? .3,
+			maeAccOldThreshold: thresholds?.maeAccOldThreshold ?? .3,
+			maeGyroscopeOldThreshold: thresholds?.maeGyroscopeOldThreshold ?? 10,
+			maeOrientationOldThreshold: thresholds?.maeOrientationOldThreshold ?? 10
+		};
+	}
+	get isRunning() {
+		return this._isRunning;
+	}
+	get hasPermission() {
+		return this._hasPermission;
+	}
+	async requestPermission() {
+		if (typeof DeviceMotionEvent !== "undefined" && typeof DeviceMotionEvent.requestPermission === "function") {
+			sessionStorage.setItem("motionSensorsPermissionsRequested", String(true));
+			try {
+				if (await DeviceMotionEvent.requestPermission() !== "granted") {
+					this._hasPermission = false;
+					return "denied";
+				}
+				return "granted";
+			} catch {
+				this._hasPermission = false;
+				return "denied";
+			}
+		}
+		return "not-required";
+	}
+	initializeAccelerometer() {
+		if (!("Accelerometer" in window)) return;
+		try {
+			const AccelerometerConstructor = window.Accelerometer;
+			if (AccelerometerConstructor) {
+				this.acl = new AccelerometerConstructor({ frequency: this.maxFrequency });
+				this.acl.addEventListener("reading", () => this.updateAcc());
+			}
+		} catch {}
+	}
+	initializeGyroscope() {
+		if (!("Gyroscope" in window)) return;
+		try {
+			const GyroscopeConstructor = window.Gyroscope;
+			if (GyroscopeConstructor) {
+				this.gyro = new GyroscopeConstructor({ frequency: this.maxFrequency });
+				this.gyro.addEventListener("reading", () => this.updateGyro());
+			}
+		} catch {}
+	}
+	async start() {
+		if (this._isRunning || !this._hasPermission) return;
+		try {
+			this.initializeAccelerometer();
+			if (this.acl) this.acl.start();
+		} catch {}
+		try {
+			this.initializeGyroscope();
+			if (this.gyro) this.gyro.start();
+		} catch {}
+		window.addEventListener("devicemotion", this.deviceMotionListener);
+		window.addEventListener("deviceorientation", this.deviceOrientationListener);
+		this._isRunning = true;
+	}
+	stop() {
+		this._isRunning = false;
+		if (this.acl) this.acl.stop();
+		if (this.gyro) this.gyro.stop();
+		window.removeEventListener("devicemotion", this.deviceMotionListener);
+		window.removeEventListener("deviceorientation", this.deviceOrientationListener);
+		this.paramsAcc = { ...this.emptyParams };
+		this.paramsGyro = { ...this.emptyParams };
+		this.paramsAccGrOld = { ...this.emptyParams };
+		this.paramsAccOld = { ...this.emptyParams };
+		this.paramsGyroscopeOld = { ...this.emptyParams };
+		this.paramsOrientationOld = { ...this.emptyParams };
+	}
+	updateAcc() {
+		if (!this._isRunning || !this.acl) return;
+		this.paramsAcc.ptsNum += 1;
+		const val = {
+			x: this.acl.x,
+			y: this.acl.y,
+			z: this.acl.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsAcc, val);
+	}
+	updateGyro() {
+		if (!this._isRunning || !this.gyro) return;
+		this.paramsGyro.ptsNum += 1;
+		const val = {
+			x: this.gyro.x,
+			y: this.gyro.y,
+			z: this.gyro.z
+		};
+		if (this.checkFields(val)) this.updateParams(this.paramsGyro, val);
+	}
+	check() {
+		if (!this._hasPermission) return "UNCLEAR";
+		const result = this.checkStability();
+		return result === null ? "UNCLEAR" : result ? "FAIL" : "PASS";
+	}
+	checkStability() {
+		if (!this._isRunning) return null;
+		const filteredStdChecks = [
+			this.gyro ? this.isBelowStdThreshold(this.paramsGyro, this.thresholds.gyroThreshold) : null,
+			this.acl ? this.isBelowStdThreshold(this.paramsAcc, this.thresholds.accThreshold) : null,
+			this.isBelowStdThreshold(this.paramsAccGrOld, this.thresholds.accGrOldThreshold),
+			this.isBelowStdThreshold(this.paramsAccOld, this.thresholds.accOldThreshold),
+			this.isBelowStdThreshold(this.paramsGyroscopeOld, this.thresholds.gyroscopeOldThreshold),
+			this.isBelowStdThreshold(this.paramsOrientationOld, this.thresholds.orientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalStdCheck = filteredStdChecks.length > 0 ? filteredStdChecks.every((check) => check) : null;
+		const filteredMaeChecks = [
+			this.gyro ? this.isBelowMaeThreshold(this.paramsGyro, this.thresholds.maeGyroThreshold) : null,
+			this.acl ? this.isBelowMaeThreshold(this.paramsAcc, this.thresholds.maeAccThreshold) : null,
+			this.isBelowMaeThreshold(this.paramsAccGrOld, this.thresholds.maeAccGrOldThreshold),
+			this.isBelowMaeThreshold(this.paramsAccOld, this.thresholds.maeAccOldThreshold),
+			this.isBelowMaeThreshold(this.paramsGyroscopeOld, this.thresholds.maeGyroscopeOldThreshold),
+			this.isBelowMaeThreshold(this.paramsOrientationOld, this.thresholds.maeOrientationOldThreshold)
+		].filter((check) => check !== null);
+		const finalMaeCheck = filteredMaeChecks.length > 0 ? filteredMaeChecks.every((check) => check) : null;
+		return finalStdCheck === null ? finalMaeCheck === null ? null : finalMaeCheck : finalMaeCheck !== null ? finalStdCheck && finalMaeCheck : finalStdCheck;
+	}
+	updateParams(params, val) {
+		const deltaX = val.x - params.meanX;
+		const deltaY = val.y - params.meanY;
+		const deltaZ = val.z - params.meanZ;
+		params.meanX += deltaX / params.ptsNum;
+		params.meanY += deltaY / params.ptsNum;
+		params.meanZ += deltaZ / params.ptsNum;
+		params.m2X += deltaX * (val.x - params.meanX);
+		params.m2Y += deltaY * (val.y - params.meanY);
+		params.m2Z += deltaZ * (val.z - params.meanZ);
+		params.cumulativeAbsErrorX += Math.abs(val.x - params.meanX);
+		params.cumulativeAbsErrorY += Math.abs(val.y - params.meanY);
+		params.cumulativeAbsErrorZ += Math.abs(val.z - params.meanZ);
+	}
+	calculateStd(params) {
+		const variance = {
+			x: params.m2X / params.ptsNum,
+			y: params.m2Y / params.ptsNum,
+			z: params.m2Z / params.ptsNum
+		};
+		return {
+			x: Math.sqrt(variance.x),
+			y: Math.sqrt(variance.y),
+			z: Math.sqrt(variance.z)
+		};
+	}
+	calculateMae(params) {
+		return {
+			x: params.cumulativeAbsErrorX / params.ptsNum,
+			y: params.cumulativeAbsErrorY / params.ptsNum,
+			z: params.cumulativeAbsErrorZ / params.ptsNum
+		};
+	}
+	checkFields(point) {
+		return point.x !== null && point.y !== null && point.z !== null;
+	}
+	isBelowStdThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const std = this.calculateStd(params);
+		return std.x < threshold && std.y < threshold && std.z < threshold;
+	}
+	isBelowMaeThreshold(params, threshold) {
+		if (params.ptsNum < this.minNumberOfFrames) return null;
+		const mae = this.calculateMae(params);
+		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/openviduLazy.ts
+let openViduImport;
+async function enableProdModeBeforeLoad() {
+	const { OpenViduLogger } = await import("./OpenViduLogger-DyqID_-7.esm.js").then(__toDynamicImportESM(1));
+	OpenViduLogger.getInstance().enableProdMode();
+}
+async function loadOpenVidu() {
+	if (openViduImport) return openViduImport;
+	await enableProdModeBeforeLoad();
+	openViduImport = import("./lib-CbAibJlt.esm.js").then(__toDynamicImportESM(1));
+	return openViduImport;
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
+function createHiddenContainer() {
+	const id = `inc_rec_${Math.random().toString(36).slice(2)}`;
+	const existing = document.getElementById(id);
+	if (existing) return {
+		id,
+		element: existing
+	};
+	const div = document.createElement("div");
+	div.id = id;
+	div.style.display = "none";
+	document.body.appendChild(div);
+	return {
+		id,
+		element: div
+	};
+}
+var OpenViduRecordingProvider = class {
+	async connect(params) {
+		const { OpenVidu } = await loadOpenVidu();
+		const container = createHiddenContainer();
+		const ov = new OpenVidu();
+		const session = ov.initSession();
+		const videoTrack = params.stream.getVideoTracks()[0];
+		const audioTrack = params.stream.getAudioTracks()[0];
+		const hasAudio = audioTrack !== void 0;
+		const publisher = ov.initPublisher(container.id, {
+			publishAudio: hasAudio,
+			audioSource: hasAudio ? audioTrack : false,
+			videoSource: videoTrack ?? false,
+			frameRate: 30
+		});
+		session.on("exception", (event) => {
+			const e = event;
+			params.events?.onSessionException?.({
+				name: e?.name,
+				message: e?.message,
+				sessionId: session.sessionId
+			});
+		});
+		publisher.on("streamCreated", () => {
+			params.events?.onPublisherCreated?.({
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+		});
+		await session.connect(params.sessionToken);
+		params.events?.onSessionConnected?.(session.sessionId);
+		try {
+			await session.publish(publisher);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			params.events?.onPublisherError?.({
+				message,
+				sessionId: session.sessionId,
+				streamId: publisher.stream?.streamId
+			});
+			throw error;
+		}
+		return {
+			sessionId: session.sessionId,
+			publisher: {
+				getStreamId: () => publisher.stream?.streamId,
+				replaceVideoTrack: async (track) => {
+					await publisher.replaceTrack(track);
+				},
+				destroy: () => {}
+			},
+			disconnect: async () => {
+				try {
+					session.disconnect();
+					params.stream.getTracks().forEach((t) => {
+						t.stop();
+					});
+				} finally {
+					params.events?.onSessionDisconnected?.(session.sessionId);
+					if (container.element.parentNode) container.element.parentNode.removeChild(container.element);
+				}
+			}
+		};
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/VisibilityProvider.ts
+var VisibilityProvider = class {
+	constructor() {
+		this._wasBackgrounded = false;
+		this.visibilityChangeHandler = this.onVisibilityChange.bind(this);
+		document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	get wasBackgrounded() {
+		return this._wasBackgrounded;
+	}
+	reset() {
+		this._wasBackgrounded = false;
+	}
+	cleanup() {
+		document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+	}
+	onVisibilityChange() {
+		if (document.hidden) this._wasBackgrounded = true;
+	}
+};
+
+//#endregion
+//#region ../infra/src/wasm/IdCaptureModelType.ts
+let IdCaptureModelType = /* @__PURE__ */ function(IdCaptureModelType$1) {
+	IdCaptureModelType$1[IdCaptureModelType$1["IdCaptureV1x"] = 0] = "IdCaptureV1x";
+	IdCaptureModelType$1[IdCaptureModelType$1["IdCaptureV2x"] = 1] = "IdCaptureV2x";
+	IdCaptureModelType$1[IdCaptureModelType$1["IdCaptureV3x"] = 2] = "IdCaptureV3x";
+	return IdCaptureModelType$1;
+}({});
+
+//#endregion
+//#region ../infra/src/wasm/Mutex.ts
+var Semaphore = class {
+	constructor(maxConcurrent = 1) {
+		this.maxConcurrent = maxConcurrent;
+		this.current = 0;
+		this.queue = [];
+	}
+	async acquire() {
+		if (this.current < this.maxConcurrent) {
+			this.current++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve) => {
+			this.queue.push(resolve);
+		});
+	}
+	release() {
+		this.current = Math.max(0, this.current - 1);
+		if (this.queue.length > 0 && this.current < this.maxConcurrent) {
+			this.current++;
+			const next = this.queue.shift();
+			if (next) next();
+		}
+	}
+};
+var Mutex = class {
+	constructor() {
+		this.semaphore = new Semaphore(1);
+	}
+	async lock() {
+		return this.semaphore.acquire();
+	}
+	unlock() {
+		this.semaphore.release();
+	}
+	async withLock(fn, ...args) {
+		await this.lock();
+		try {
+			return await fn(...args);
+		} finally {
+			this.unlock();
+		}
+	}
+};
+
+//#endregion
+//#region ../infra/src/wasm/WasmPipelineType.ts
+let WasmPipelineType = /* @__PURE__ */ function(WasmPipelineType$1) {
+	WasmPipelineType$1[WasmPipelineType$1["IdBlurGlarePipeline"] = 0] = "IdBlurGlarePipeline";
+	WasmPipelineType$1[WasmPipelineType$1["IdBarcodeAndTextQualityPipeline"] = 1] = "IdBarcodeAndTextQualityPipeline";
+	WasmPipelineType$1[WasmPipelineType$1["IdVideoSelfiePipeline"] = 2] = "IdVideoSelfiePipeline";
+	WasmPipelineType$1[WasmPipelineType$1["SelfieWithAggregationMetrics"] = 3] = "SelfieWithAggregationMetrics";
+	WasmPipelineType$1[WasmPipelineType$1["SelfieWithQualityMetrics"] = 4] = "SelfieWithQualityMetrics";
+	WasmPipelineType$1[WasmPipelineType$1["IdFaceDetectionPipeline"] = 5] = "IdFaceDetectionPipeline";
+	return WasmPipelineType$1;
+}({});
+
+//#endregion
+//#region ../infra/src/wasm/mlWasmJSApi.ts
+window.wasmArrayBuffer = null;
+var MlWasmJSApi = class MlWasmJSApi {
+	constructor() {
+		this.versionsFile = null;
+		this.modelsBuffers = null;
+		this.inputImageBuffer = null;
+		this.wasmModule = null;
+		this.pipelineApiUtilities = null;
+		this.utilityApi = null;
+		this.idCaptureWasmApi = null;
+		this.faceDetectionWasmApi = null;
+		this.imageWidth_ = null;
+		this.imageHeight_ = null;
+		this.pipelines_ = null;
+		this.isInitialized_ = false;
+		this.inspectorOpened_ = false;
+		this.wasmCallMutex = new Mutex();
+		this.Module = null;
+		this.loadModule = async (glueCodePath) => {
+			this.Module = (await import(
+				/* @vite-ignore */
+				/* webpackIgnore: true */
+				glueCodePath
+)).Module;
+		};
+	}
+	/**
+	* Initiallization method, use it when the application starts
+	* TODO: this method can return the list of promises to be awaited together with other initialization code
+	* @param {string} webLibPath - The path to the webassembly binary
+	* @param {string} webLibPathSimd - The path to the SIMD version webassembly binary
+	* @param {boolean} useSimd - Indicates whether SIMD optimizations should be used
+	* @param {string} versionsFile - The path to the file containing versioning information
+	* @param {Map.<WasmPipelineType, Array<string>>} pipelines - pipelines for initialization and corresponding models paths
+	* @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether SIMD is enabled once the initialization is complete.
+	* @throws {Error} Throws an error if the initialization fails.
+	*/
+	async initialize(webLibPath, webLibPathSimd, glueCodePath, useSimd, versionsFile, pipelines) {
+		await this.freeResources();
+		this.pipelines_ = pipelines;
+		this.versionsFile = versionsFile;
+		await this.loadModule(glueCodePath);
+		const simdIsEnabled = await this.loadWasm(useSimd, webLibPath, webLibPathSimd);
+		this.pipelineApiUtilities = new this.wasmModule.PipelineApiUtilities();
+		this.utilityApi = new this.wasmModule.UtilityApi();
+		this.idCaptureWasmApi = new this.wasmModule.IdCaptureApi();
+		this.faceDetectionWasmApi = new this.wasmModule.FaceDetectionApi();
+		this.isInitialized_ = true;
+		return simdIsEnabled;
+	}
+	static getInstance() {
+		if (!MlWasmJSApi.instance) MlWasmJSApi.instance = new MlWasmJSApi();
+		return MlWasmJSApi.instance;
+	}
+	/**
+	* Returns initialization status
+	* @returns
+	*/
+	isInitialized() {
+		return this.pipelineApiUtilities != null && this.utilityApi != null && this.idCaptureWasmApi != null && this.faceDetectionWasmApi != null && this.isInitialized_;
+	}
+	/**
+	* Allocate shared memory for image buffers (RGBA format)
+	* Use it every time when the frame dimentions changes
+	* @param {number} imageWidth - image width
+	* @param {number} imageHeight - image height
+	*/
+	async allocateImageBuffers(imageWidth, imageHeight) {
+		this.checkWasmInitialization("Unable to allocate image buffers, cpp API hasn't been initialized");
+		if (imageWidth && imageHeight && imageWidth == this.imageWidth_ && imageHeight == this.imageHeight_ && this.inputImageBuffer && imageWidth * imageHeight * 4 === this.inputImageBuffer.length) return;
+		this.imageWidth_ = imageWidth;
+		this.imageHeight_ = imageHeight;
+		this.inputImageBuffer = this.pipelineApiUtilities.allocateInputImageBuffer(imageWidth, imageHeight, 4);
+	}
+	async handleDetectionCallAndUpdateState(type) {
+		this.checkWasmInitialization("Unable to update pipeline state, cpp API hasn't been initialized");
+		this.pipelineApiUtilities.handleDetectionCallAndUpdateState(this.pipelineTypeToWasmEnum(type));
+	}
+	ens(image) {
+		this.checkWasmInitialization("Unable to encrypt the image, cpp API hasn't been initialized");
+		return this.utilityApi.ens(image);
+	}
+	isVirtualCamera(label) {
+		this.checkWasmInitialization("Unable to check if the camera is virtual, cpp API hasn't been initialized");
+		if (label) return this.utilityApi.isVirtualCamera(label);
+		return false;
+	}
+	estimatePerformance() {
+		this.checkWasmInitialization("Unable to estimate performance, cpp API hasn't been initialized");
+		return this.utilityApi.estimatePerformance();
+	}
+	async analyzeFrame(image) {
+		this.checkWasmInitialization("Unable to analyze the frame, cpp API hasn't been initialized");
+		await this.allocateImageBuffers(image.width, image.height);
+		this.inputImageBuffer.set(image.data);
+		this.utilityApi.analyzeFrame();
+	}
+	/**
+	* Free allocated memory
+	*/
+	async freeResources() {
+		this.versionsFile = null;
+		this.modelsBuffers = null;
+		this.inputImageBuffer = null;
+		this.imageWidth_ = null;
+		this.imageHeight_ = null;
+		this.pipelines_ = null;
+		window.wasmArrayBuffer = null;
+		if (this.pipelineApiUtilities && typeof this.pipelineApiUtilities.delete === "function") {
+			this.pipelineApiUtilities.delete();
+			this.pipelineApiUtilities = null;
+		}
+		if (this.utilityApi && typeof this.utilityApi.delete === "function") {
+			this.utilityApi.delete();
+			this.utilityApi = null;
+		}
+		if (this.idCaptureWasmApi && typeof this.idCaptureWasmApi.delete === "function") {
+			this.idCaptureWasmApi.delete();
+			this.idCaptureWasmApi = null;
+		}
+		if (this.faceDetectionWasmApi && typeof this.faceDetectionWasmApi.delete === "function") {
+			this.faceDetectionWasmApi.delete();
+			this.faceDetectionWasmApi = null;
+		}
+		this.wasmModule = null;
+		this.isInitialized_ = false;
+	}
+	/**
+	* Clear pipeline state
+	*/
+	resetPipeline(type) {
+		this.checkWasmInitialization("Unable to reset pipeline, cpp API hasn't been initialized");
+		this.pipelineApiUtilities.resetPipeline(this.pipelineTypeToWasmEnum(type));
+	}
+	/**
+	* Clear all pipelines states
+	*/
+	resetAllPipelines() {
+		this.checkWasmInitialization("Unable to reset pipelines, cpp API hasn't been initialized");
+		for (const [type, model] of this.pipelines_) this.resetPipeline(type);
+	}
+	/**
+	* Clear all states, not related to ml pipelines
+	*/
+	resetOther() {
+		this.checkWasmInitialization("Unable to reset other states, cpp API hasn't been initialized");
+		this.utilityApi.resetOther();
+	}
+	/**
+	* Full reset
+	*/
+	reset() {
+		this.resetAllPipelines();
+		this.resetOther();
+	}
+	/**
+	* Process one frame using one of the pipelines
+	* @param {ImageData} image - input image
+	* @param {WasmPipelineType} type - pipeline type
+	* @returns
+	*/
+	async process(image, type) {
+		this.checkWasmInitialization("Unable to process the image, cpp API hasn't been initialized");
+		if (this.inputImageBuffer === null) throw new Error("Unable to process the image, buffers haven't been allocated!");
+		this.inputImageBuffer.set(image.data);
+		switch (type) {
+			case WasmPipelineType.IdBlurGlarePipeline:
+			case WasmPipelineType.IdBarcodeAndTextQualityPipeline: return this.idCaptureWasmApi.runIdCapturePipeline(this.pipelineTypeToWasmEnum(type));
+			case WasmPipelineType.IdFaceDetectionPipeline: return this.faceDetectionWasmApi.runIdFaceDetectionPipeline();
+			case WasmPipelineType.IdVideoSelfiePipeline: return this.idCaptureWasmApi.runIdVideoSelfiePipeline();
+			case WasmPipelineType.SelfieWithAggregationMetrics:
+			case WasmPipelineType.SelfieWithQualityMetrics: return this.faceDetectionWasmApi.runSelfieFaceDetectionPipeline(this.pipelineTypeToWasmEnum(type));
+			default: throw new Error("Unknown pipeline type");
+		}
+	}
+	async runIdCapture(image) {
+		this.checkWasmInitialization("Unable to run Id Capture, cpp API hasn't been initialized");
+		if (this.inputImageBuffer === null) throw new Error("Unable to process the image, buffers haven't been allocated!");
+		this.inputImageBuffer.set(image.data);
+		return this.idCaptureWasmApi.runIdCapture();
+	}
+	async runSelfieCapture(image) {
+		this.checkWasmInitialization("Unable to run Selfie Capture, cpp API hasn't been initialized");
+		if (this.inputImageBuffer === null) throw new Error("Unable to process the image, buffers haven't been allocated!");
+		this.inputImageBuffer.set(image.data);
+		return this.faceDetectionWasmApi.runSelfieCapture();
+	}
+	async setFacePositionConstraints(type, minX, minY, maxX, maxY) {
+		this.checkWasmInitialization("Unable to set face position constraints, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFacePositionConstraints(this.pipelineTypeToWasmEnum(type), minX, minY, maxX, maxY);
+	}
+	async setFaceDetectionThresholds(type, brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold) {
+		this.checkWasmInitialization("Unable to set face detection thresholds, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFaceDetectionThresholds(this.pipelineTypeToWasmEnum(type), brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold);
+	}
+	async setFaceAttributesThresholds(type, headwearThreshold, lensesThreshold, closedEyesThreshold, maskThreshold) {
+		this.checkWasmInitialization("Unable to set face attributes thresholds, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFaceAttributesThresholds(this.pipelineTypeToWasmEnum(type), headwearThreshold, lensesThreshold, closedEyesThreshold, maskThreshold);
+	}
+	async setFaceChecksEnabled(type, isLensesCheckEnabled, isMaskCheckEnabled, isClosedEyesCheckEnabled, isHeadWearCheckEnabled, isOcclusionCheckEnabled) {
+		this.checkWasmInitialization("Unable to set face checks enabled flags, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFaceChecksEnabled(this.pipelineTypeToWasmEnum(type), isLensesCheckEnabled, isMaskCheckEnabled, isClosedEyesCheckEnabled, isHeadWearCheckEnabled, isOcclusionCheckEnabled);
+	}
+	async setFaceDetectionMode(type, isVideoSelfie) {
+		this.checkWasmInitialization("Unable to set face detection mode, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFaceDetectionMode(this.pipelineTypeToWasmEnum(type), isVideoSelfie);
+	}
+	async setFaceDetectionCallbacks(type, onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onBestShot, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded) {
+		this.checkWasmInitialization("Unable to set face detection callbacks, cpp API hasn't been initialized");
+		this.faceDetectionWasmApi.setFaceDetectionCallbacks(this.pipelineTypeToWasmEnum(type), onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onBestShot, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded);
+	}
+	async setIdCaptureThresholds(type, blurThreshold, blurChangeThreshold, glareThreshold, clsThreshold, sideThreshold, iouThreshold, idDetectedTimeout, autocaptureTimeout, framesAggregationInterval, minFaceIdQualityScore) {
+		this.checkWasmInitialization("Unable to set thresholds, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureThresholds(this.pipelineTypeToWasmEnum(type), blurThreshold, blurChangeThreshold, glareThreshold, clsThreshold, sideThreshold, iouThreshold, idDetectedTimeout, autocaptureTimeout, framesAggregationInterval, minFaceIdQualityScore);
+	}
+	async setIdCaptureCallbacks(type, onFarAway, onDetectionStarted, onMaskChange, onBlur, onGlare, onCapturing, onCapture, onBestFrame, onIDNotDetected, onSwitchToManualCapture, onIDTypeChange, onIDSideChange, onCapturingCounterValueChange) {
+		this.checkWasmInitialization("Unable to set callbacks, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureCallbacks(this.pipelineTypeToWasmEnum(type), onFarAway, onDetectionStarted, onMaskChange, onBlur, onGlare, onCapturing, onCapture, onBestFrame, onIDNotDetected, onSwitchToManualCapture, onIDTypeChange, onIDSideChange, onCapturingCounterValueChange);
+	}
+	async setIdCaptureGeometryParams(type, areaDown, areaUp, areaIOSPassportUp, areaIOSPassportDown, widthIOSUp, widthIOSDown, widthDown, widthUp, windowOuterWidth, windowOuterHeight, windowInnerWidth, windowInnerHeight) {
+		this.checkWasmInitialization("Unable to set geometry params, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureGeometryParams(this.pipelineTypeToWasmEnum(type), areaDown, areaUp, areaIOSPassportUp, areaIOSPassportDown, widthIOSUp, widthIOSDown, widthDown, widthUp, windowOuterWidth, windowOuterHeight, windowInnerWidth, windowInnerHeight);
+	}
+	async setIdCaptureConfigParams(type, isFixedMask, isIPhone14OrHigher$1, idType, isBlurCheckEnabled, isGlareCheckEnabled, isIdFaceQualityCheckEnabled, isIouCheckEnabled) {
+		this.checkWasmInitialization("Unable to set config params, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureConfigParams(this.pipelineTypeToWasmEnum(type), isFixedMask, isIPhone14OrHigher$1, idType, isBlurCheckEnabled, isGlareCheckEnabled, isIdFaceQualityCheckEnabled, isIouCheckEnabled);
+	}
+	setIdCaptureModelType(pipelineType, modelType) {
+		this.checkWasmInitialization("Unable to set model type, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureModelType(this.pipelineTypeToWasmEnum(pipelineType), this.IdCaptureModelTypeToWasmEnum(modelType));
+	}
+	IdPerspectiveTransform(image, frameRect) {
+		this.checkWasmInitialization("Unable to perform perspective transform, cpp API hasn't been initialized");
+		return this.idCaptureWasmApi.IdPerspectiveTransform(image, frameRect);
+	}
+	async getVersions() {
+		const text = await (await fetch(this.versionsFile)).text();
+		return JSON.parse(text);
+	}
+	async loadWasm(useSimd, webLibPath, webLibPathSimd) {
+		const libPath = useSimd ? webLibPathSimd : webLibPath;
+		try {
+			window.wasmArrayBuffer = await fetch(libPath).then((response) => response.arrayBuffer()).then((buffer) => new Uint8Array(buffer));
+			this.wasmModule = await this.Module();
+		} catch (e) {
+			console.log(e, useSimd, "useSmd");
+			if (useSimd) return await this.loadWasm(false, webLibPath, webLibPathSimd);
+			else throw e;
+		}
+		return useSimd;
+	}
+	async loadModels() {
+		this.checkWasmInitialization("Unable load the models, cpp API hasn't been initialized");
+		const buffSizes = new this.wasmModule.PipelineTypeToIntMap();
+		const modelData = /* @__PURE__ */ new Map();
+		const loadedModels = /* @__PURE__ */ new Map();
+		for (const [type, modelsPaths] of this.pipelines_) {
+			const wasmType = this.pipelineTypeToWasmEnum(type);
+			const pipelineBuffers = [];
+			const sizes = new this.wasmModule.VectorInt();
+			for (const path of modelsPaths) {
+				if (!loadedModels.has(path)) {
+					const model$1 = await fetch(path).then((response) => response.arrayBuffer()).then((buffer) => new Uint8Array(buffer));
+					loadedModels.set(path, model$1);
+				}
+				const model = loadedModels.get(path);
+				sizes.push_back(model.byteLength);
+				pipelineBuffers.push(model);
+			}
+			buffSizes.set(wasmType, sizes);
+			modelData.set(wasmType, pipelineBuffers);
+		}
+		this.modelsBuffers = this.pipelineApiUtilities.allocateModelsBuffers(buffSizes);
+		for (const [type, data] of modelData) {
+			const buffers = this.modelsBuffers?.get(type);
+			for (let k = 0; k < buffers.size(); k++) {
+				const buffer = buffers?.get(k);
+				if (buffer) buffer.set(data[k]);
+				else throw new Error("Unable to get model buffer from shared memory!");
+			}
+		}
+	}
+	async initializePipelines() {
+		this.checkWasmInitialization("Unable to initialize pipelines, cpp API hasn't been initialized");
+		if (!this.modelsBuffers) await this.loadModels();
+		this.pipelineApiUtilities.initializePipelines();
+	}
+	async setProductionMode(productionMode) {
+		this.checkWasmInitialization("Unable to set production mode, cpp API hasn't been initialized");
+		this.utilityApi.setProductionMode(productionMode);
+	}
+	getPipelineState() {
+		this.checkWasmInitialization("Unable to get pipeline state, cpp API hasn't been initialized");
+		return this.pipelineApiUtilities.getPipelineState();
+	}
+	getCurrentPipeline() {
+		this.checkWasmInitialization("Unable to get current pipeline, cpp API hasn't been initialized");
+		return this.pipelineTypeFromWasmEnum(this.pipelineApiUtilities.getCurrentPipeline());
+	}
+	setSdkVersion(sdkVersion) {
+		this.checkWasmInitialization("Unable to set sdk version, cpp API hasn't been initialized");
+		this.utilityApi.setSdkVersion(sdkVersion);
+	}
+	setSdkPlatform(sdkPlatform) {
+		this.checkWasmInitialization("Unable to set device type, cpp API hasn't been initialized");
+		this.utilityApi.setSdkPlatform(sdkPlatform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.checkWasmInitialization("Unable to set device info, cpp API hasn't been initialized");
+		this.utilityApi.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.checkWasmInitialization("Unable to set browser info, cpp API hasn't been initialized");
+		this.utilityApi.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.checkWasmInitialization("Unable to set camera info, cpp API hasn't been initialized");
+		this.utilityApi.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setZc(zc) {
+		this.checkWasmInitialization("Unable to set zc, cpp API hasn't been initialized");
+		this.utilityApi.setZc(zc);
+	}
+	setMotionStatus(motionStatus) {
+		this.checkWasmInitialization("Unable to set motion status, cpp API hasn't been initialized");
+		this.utilityApi.setMotionStatus(motionStatus);
+	}
+	setMetadataField(key, value) {
+		this.checkWasmInitialization("Unable to set metadata field, cpp API hasn't been initialized");
+		this.utilityApi.setMetadataField(key, value);
+	}
+	setInspectorOpened(inspectorOpened) {
+		this.inspectorOpened_ = inspectorOpened;
+	}
+	setBackgroundMode(backgroundMode) {
+		this.checkWasmInitialization("Unable to set background mode, cpp API hasn't been initialized");
+		this.utilityApi.setBackgroundMode(backgroundMode);
+	}
+	getCheck() {
+		this.checkWasmInitialization("Unable to get check, cpp API hasn't been initialized");
+		return this.utilityApi.getCheck();
+	}
+	getMetadata() {
+		this.checkWasmInitialization("Unable to get metadata, cpp API hasn't been initialized");
+		this.utilityApi.setInspectorOpened(this.inspectorOpened_);
+		return this.utilityApi.getMetadata();
+	}
+	async prc() {
+		this.checkWasmInitialization("Unable to prc, cpp API hasn't been initialized");
+		return await this.wasmCallWrapper(this.utilityApi.prc.bind(this.utilityApi), []);
+	}
+	async poc(output) {
+		this.checkWasmInitialization("Unable to poc, cpp API hasn't been initialized");
+		await this.wasmCallWrapper(this.utilityApi.poc.bind(this.utilityApi), [output]);
+	}
+	async pc(deviceId) {
+		this.checkWasmInitialization("Unable to pc, cpp API hasn't been initialized");
+		await this.wasmCallWrapper(this.utilityApi.pc.bind(this.utilityApi), [deviceId]);
+	}
+	ckvcks(data) {
+		this.checkWasmInitialization("Unable to ckvcks, cpp API hasn't been initialized");
+		this.utilityApi.ckvcks(data);
+	}
+	pipelineTypeToWasmEnum(type) {
+		switch (type) {
+			case WasmPipelineType.IdBlurGlarePipeline: return this.wasmModule.PipelineType.IdBlurGlarePipeline;
+			case WasmPipelineType.IdBarcodeAndTextQualityPipeline: return this.wasmModule.PipelineType.IdBarcodeAndTextQualityPipeline;
+			case WasmPipelineType.IdFaceDetectionPipeline: return this.wasmModule.PipelineType.IdFaceDetectionPipeline;
+			case WasmPipelineType.IdVideoSelfiePipeline: return this.wasmModule.PipelineType.IdVideoSelfiePipeline;
+			case WasmPipelineType.SelfieWithAggregationMetrics: return this.wasmModule.PipelineType.SelfieWithAggregationMetrics;
+			case WasmPipelineType.SelfieWithQualityMetrics: return this.wasmModule.PipelineType.SelfieWithQualityMetrics;
+			default: throw new Error("Unknown pipeline type");
+		}
+	}
+	pipelineTypeFromWasmEnum(type) {
+		switch (type) {
+			case this.wasmModule.PipelineType.IdBlurGlarePipeline: return WasmPipelineType.IdBlurGlarePipeline;
+			case this.wasmModule.IdBarcodeAndTextQualityPipeline: return WasmPipelineType.IdBarcodeAndTextQualityPipeline;
+			case this.wasmModule.PipelineType.IdFaceDetectionPipeline: return WasmPipelineType.IdFaceDetectionPipeline;
+			case this.wasmModule.PipelineType.IdVideoSelfiePipeline: return WasmPipelineType.IdVideoSelfiePipeline;
+			case this.wasmModule.PipelineType.SelfieWithAggregationMetrics: return WasmPipelineType.SelfieWithAggregationMetrics;
+			case this.wasmModule.PipelineType.SelfieWithQualityMetrics: return WasmPipelineType.SelfieWithQualityMetrics;
+			default: throw new Error("Unknown pipeline type");
+		}
+	}
+	IdCaptureModelTypeToWasmEnum(type) {
+		switch (type) {
+			case IdCaptureModelType.IdCaptureV1x: return this.wasmModule.IdCaptureModelType.IdCaptureV1x;
+			case IdCaptureModelType.IdCaptureV2x: return this.wasmModule.IdCaptureModelType.IdCaptureV2x;
+			case IdCaptureModelType.IdCaptureV3x: return this.wasmModule.IdCaptureModelType.IdCaptureV3x;
+			default: throw new Error("Unknown Id Capture model type");
+		}
+	}
+	IdCaptureModelTypeFromWasmEnum(type) {
+		switch (type) {
+			case this.wasmModule.IdCaptureModelType.IdCaptureV1x: return IdCaptureModelType.IdCaptureV1x;
+			case this.wasmModule.IdCaptureModelType.IdCaptureV2x: return IdCaptureModelType.IdCaptureV2x;
+			case this.wasmModule.IdCaptureModelType.IdCaptureV3x: return IdCaptureModelType.IdCaptureV3x;
+			default: throw new Error("Unknown Id Capture model type");
+		}
+	}
+	checkWasmInitialization(message) {
+		if (!this.isInitialized()) throw new Error(message);
+	}
+	async wasmCallWrapper(wasmMethod, args = []) {
+		return await this.wasmCallMutex.withLock(async (...args$1) => {
+			let isFinished = false;
+			try {
+				while (true) {
+					isFinished = wasmMethod(...args$1);
+					if (isFinished) return;
+					await new Promise((resolve) => setTimeout(resolve, 0));
+				}
+			} catch (e) {
+				console.log("Error in wasmCallWrapper:", e);
+			}
+		}, ...args);
+	}
+};
+var mlWasmJSApi_default = MlWasmJSApi.getInstance();
+
+//#endregion
+//#region ../infra/src/wasm/warmup.ts
+/** Array of all available pipelines */
+const WASM_PIPELINES = ["selfie", "idCapture"];
+/**
+* Default model files for each pipeline.
+* These are the ONNX model files required by each ML pipeline.
+*/
+const DEFAULT_PIPELINE_MODELS = {
+	selfie: [
+		"selfie_bf_angles_192x192_opset9_fp16.ortmodelv2",
+		"face_attributes_v1_3_fp16.ortmodelv2",
+		"mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2",
+		"face_occlusion_v0_1_fp16.ortmodelv2"
+	],
+	idCapture: ["id_capture_2_01_fp16.ortmodelv2", "id_fiqa_19a81a0b9bf6492eb03b4667f6db4c85_fp16.ortmodelv2"]
+};
+let state = "idle";
+let loadingPromise = null;
+let wasmError = null;
+let loadedPipelines = [];
+let lastConfig = null;
+function mapPipelineToWasmType(pipeline) {
+	switch (pipeline) {
+		case "selfie": return WasmPipelineType.SelfieWithQualityMetrics;
+		case "idCapture": return WasmPipelineType.IdBlurGlarePipeline;
+		default: throw new Error(`Unknown pipeline: ${pipeline}`);
+	}
+}
+/**
+* Derives the models base path from the WASM path.
+* Assumes models are in a 'models' subdirectory relative to the WASM binary location.
+* e.g., '/wasm/v2/binary.wasm' -> '/wasm/v2/models'
+*/
+function deriveModelsBasePath(wasmPath) {
+	const lastSlashIndex = wasmPath.lastIndexOf("/");
+	if (lastSlashIndex === -1) return "models";
+	return `${wasmPath.substring(0, lastSlashIndex)}/models`;
+}
+/**
+* Builds the pipelines map with model paths for WASM initialization.
+* @param pipelines - Array of pipeline types to initialize
+* @param modelsBasePath - Base path where model files are located
+* @param customModels - Optional custom model files per pipeline
+*/
+function buildPipelinesMap(pipelines, modelsBasePath, customModels) {
+	const pipelinesMap = /* @__PURE__ */ new Map();
+	for (const pipeline of pipelines) {
+		const wasmType = mapPipelineToWasmType(pipeline);
+		if (!pipelinesMap.has(wasmType)) {
+			const modelPaths = (customModels?.[pipeline] ?? DEFAULT_PIPELINE_MODELS[pipeline]).map((modelFile) => `${modelsBasePath}/${modelFile}`);
+			pipelinesMap.set(wasmType, modelPaths);
+		}
+	}
+	return pipelinesMap;
+}
+/**
+* Preloads WASM binary and ML models at app startup.
+* Runs asynchronously - app can continue while WASM loads in background.
+*
+* Model files are automatically loaded based on the pipeline type.
+* By default, models are expected in a 'models' subdirectory relative to the WASM binary.
+*
+* @param config - Configuration for WASM warmup
+* @returns Promise that resolves when WASM is ready
+*
+* @example
+* ```ts
+* // Basic usage - models loaded from /wasm/v2/models/
+* warmupWasm({
+*   wasmPath: '/wasm/v2/ml-wasm.wasm',
+*   glueCodePath: '/wasm/v2/ml-wasm.js',
+*   pipelines: ['selfie', 'idCapture'],
+* });
+*
+* // With explicit models path
+* warmupWasm({
+*   wasmPath: '/wasm/v2/ml-wasm.wasm',
+*   glueCodePath: '/wasm/v2/ml-wasm.js',
+*   modelsBasePath: 'https://cdn.example.com/wasm/v2/models',
+*   pipelines: ['selfie'],
+* });
+* ```
+*/
+async function warmupWasm(config) {
+	const pipelines = config.pipelines ?? [...WASM_PIPELINES];
+	const modelsBasePath = config.modelsBasePath ?? deriveModelsBasePath(config.wasmPath);
+	if (state === "loading" && loadingPromise) return loadingPromise;
+	if (state === "ready") {
+		if (pipelines.filter((p) => !loadedPipelines.includes(p)).length === 0) return;
+		if (!lastConfig) throw new Error("Cannot add pipelines: original warmup config not available");
+		if (lastConfig.wasmPath !== config.wasmPath || lastConfig.glueCodePath !== config.glueCodePath || (lastConfig.wasmSimdPath ?? lastConfig.wasmPath) !== (config.wasmSimdPath ?? config.wasmPath) || (lastConfig.useSimd ?? true) !== (config.useSimd ?? true)) throw new Error("Cannot add pipelines: WASM config mismatch. Use same wasmPath, glueCodePath, and useSimd settings.");
+		const combinedPipelines = [...new Set([...loadedPipelines, ...pipelines])];
+		state = "loading";
+		wasmError = null;
+		loadingPromise = (async () => {
+			try {
+				const pipelinesMap = buildPipelinesMap(combinedPipelines, lastConfig.modelsBasePath ?? deriveModelsBasePath(lastConfig.wasmPath), lastConfig.pipelineModels);
+				await mlWasmJSApi_default.initialize(lastConfig.wasmPath, lastConfig.wasmSimdPath ?? lastConfig.wasmPath, lastConfig.glueCodePath, lastConfig.useSimd ?? true, "", pipelinesMap);
+				await mlWasmJSApi_default.loadModels();
+				await mlWasmJSApi_default.initializePipelines();
+				state = "ready";
+				loadedPipelines = combinedPipelines;
+				lastConfig = {
+					...lastConfig,
+					pipelines: combinedPipelines
+				};
+				loadingPromise = null;
+			} catch (error) {
+				state = "error";
+				wasmError = error instanceof Error ? error : new Error(String(error));
+				loadingPromise = null;
+				throw wasmError;
+			}
+		})();
+		return loadingPromise;
+	}
+	state = "loading";
+	wasmError = null;
+	loadingPromise = (async () => {
+		try {
+			const pipelinesMap = buildPipelinesMap(pipelines, modelsBasePath, config.pipelineModels);
+			await mlWasmJSApi_default.initialize(config.wasmPath, config.wasmSimdPath ?? config.wasmPath, config.glueCodePath, config.useSimd ?? true, "", pipelinesMap);
+			await mlWasmJSApi_default.loadModels();
+			await mlWasmJSApi_default.initializePipelines();
+			state = "ready";
+			loadedPipelines = [...pipelines];
+			lastConfig = {
+				...config,
+				pipelines
+			};
+			loadingPromise = null;
+		} catch (error) {
+			state = "error";
+			wasmError = error instanceof Error ? error : new Error(String(error));
+			loadingPromise = null;
+			throw wasmError;
+		}
+	})();
+	return loadingPromise;
+}
+/**
+* Returns the current warmup status.
+* Useful for showing loading indicators.
+*
+* @returns Current warmup status
+*/
+function getWasmStatus() {
+	return {
+		isReady: state === "ready",
+		isLoading: state === "loading",
+		error: wasmError ?? void 0,
+		loadedPipelines: [...loadedPipelines]
+	};
+}
+/**
+* Returns true if WASM is fully initialized and ready.
+*
+* @returns True if WASM is ready
+*/
+function isWasmReady() {
+	return state === "ready";
+}
+/**
+* Returns a promise that resolves when WASM is ready.
+* - If ready: resolves immediately
+* - If loading: waits for completion, then resolves
+* - If not started: rejects with error
+*
+* @returns Promise that resolves when WASM is ready
+* @throws Error if WASM is in error state or was never started
+*/
+function waitForWasm() {
+	if (state === "ready") return Promise.resolve();
+	if (state === "loading" && loadingPromise) return loadingPromise;
+	if (state === "error") return Promise.reject(wasmError ?? /* @__PURE__ */ new Error("WASM initialization failed"));
+	return Promise.reject(/* @__PURE__ */ new Error("WASM warmup was not started. Call warmupWasm() first."));
+}
+
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.ts
+/**
+* Base provider class that abstracts common WASM functionality.
+* This serves as a foundation for specific ML capability providers
+* like FaceDetectionProvider and IdCaptureProvider.
+*/
+var BaseWasmProvider = class {
+	/**
+	* Creates a new BaseWasmProvider
+	* @param pipelineType - The WASM pipeline type this provider uses
+	*/
+	constructor(pipelineType) {
+		this._isInitialized = false;
+		this.pipelineType = pipelineType;
+	}
+	/**
+	* Returns whether this provider has been initialized.
+	*/
+	get initialized() {
+		return this._isInitialized;
+	}
+	getPipelineType() {
+		if (this.pipelineType === void 0) throw new Error(`${this.constructor.name} has no pipeline type configured.`);
+		return this.pipelineType;
+	}
+	/**
+	* Initializes the provider by ensuring WASM is loaded
+	* @param config - Provider configuration
+	* @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+	*/
+	async initializeBase(config, pipeline) {
+		if (this._isInitialized) return;
+		if (getWasmStatus().isLoading || isWasmReady()) await waitForWasm();
+		else {
+			if (!config.wasmPath || !config.glueCodePath) throw new Error("WASM path and glue code path are required. Call warmupWasm() first.");
+			await warmupWasm({
+				wasmPath: config.wasmPath,
+				wasmSimdPath: config.wasmSimdPath,
+				glueCodePath: config.glueCodePath,
+				useSimd: config.useSimd,
+				modelsBasePath: config.modelsBasePath,
+				pipelines: [pipeline]
+			});
+		}
+		this._isInitialized = true;
+	}
+	/**
+	* Ensures the provider is initialized before performing operations.
+	* @throws Error if not initialized
+	*/
+	ensureInitialized() {
+		if (!this._isInitialized) throw new Error(`${this.constructor.name} not initialized. Call initialize() first.`);
+	}
+	/**
+	* Processes a frame through the WASM pipeline
+	* @param image - Image data to process
+	* @returns The pipeline result (type depends on pipeline - WASM returns any)
+	*/
+	async processFrameWasm(image) {
+		this.ensureInitialized();
+		const pipelineType = this.getPipelineType();
+		await mlWasmJSApi_default.allocateImageBuffers(image.width, image.height);
+		await mlWasmJSApi_default.handleDetectionCallAndUpdateState(pipelineType);
+		return await mlWasmJSApi_default.process(image, pipelineType);
+	}
+	/**
+	* Resets the pipeline to its initial state.
+	* Safe to call even if not initialized (no-op in that case).
+	*/
+	reset() {
+		if (this._isInitialized && this.pipelineType !== void 0) mlWasmJSApi_default.resetPipeline(this.pipelineType);
+	}
+	/**
+	* Disposes of resources and resets initialization state.
+	* Safe to call even if not initialized.
+	*/
+	async dispose() {
+		this.reset();
+		this._isInitialized = false;
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.ts
+var FaceDetectionProvider = class extends BaseWasmProvider {
+	constructor() {
+		super(WasmPipelineType.SelfieWithQualityMetrics);
+		this.defaultThresholds = {
+			frameMinX: 0,
+			frameMinY: 0,
+			frameMaxX: 1,
+			frameMaxY: 1,
+			brightnessThreshold: 50,
+			blurrinessThreshold: 50,
+			tiltRotationAngleThreshold: 15,
+			minMagicCropSize: 200,
+			headwearThreshold: .86,
+			lensesThreshold: .95,
+			closedEyesThreshold: .9,
+			maskThreshold: .85,
+			minFaceQualityScore: .63,
+			faceOcclusionThreshold: .3
+		};
+		this.currentFrame = null;
+		this.bestCanvas = null;
+		this.bestFace = null;
+	}
+	async processFrame(image) {
+		this.currentFrame = image;
+		await this.processFrameWasm(image);
+	}
+	async initialize(config) {
+		await this.initializeBase(config, "selfie");
+		this.applyDefaults(config.autocaptureInterval ?? 0);
+	}
+	setCallbacks(callbacks) {
+		this.ensureInitialized();
+		const onBestShotWrapper = (face) => {
+			this.bestFace = face;
+			if (this.currentFrame) {
+				const frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
+				this.bestCanvas = frameCanvas.clone() ?? frameCanvas;
+			}
+			callbacks.onBestShot?.(face);
+		};
+		const onCaptureWrapper = () => {
+			let frameCanvas = this.bestCanvas;
+			if (!frameCanvas && this.currentFrame) frameCanvas = IncodeCanvas.fromImageData(this.currentFrame);
+			if (!frameCanvas) return;
+			const faceCoordinates = this.bestFace ? this.formatFaceCoordinates(this.bestFace) : this.createDefaultFaceCoordinates(frameCanvas);
+			try {
+				frameCanvas.updateBase64Image();
+				frameCanvas.updateBlob();
+			} catch {}
+			callbacks.onCapture?.(frameCanvas, faceCoordinates);
+			this.bestCanvas = null;
+			this.bestFace = null;
+		};
+		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 ?? (() => {}), onBestShotWrapper, callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
+	}
+	setPositionConstraints(constraints) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFacePositionConstraints(this.getPipelineType(), constraints.minX, constraints.minY, constraints.maxX, constraints.maxY);
+	}
+	applyDefaults(autocaptureInterval = 0) {
+		this.ensureInitialized();
+		this.setThresholds({
+			brightnessThreshold: this.defaultThresholds.brightnessThreshold,
+			blurrinessThreshold: this.defaultThresholds.blurrinessThreshold,
+			tiltRotationAngleThreshold: this.defaultThresholds.tiltRotationAngleThreshold,
+			minMagicCropSize: this.defaultThresholds.minMagicCropSize,
+			autocaptureInterval,
+			minFaceQualityScore: this.defaultThresholds.minFaceQualityScore,
+			faceOcclusionThreshold: this.defaultThresholds.faceOcclusionThreshold
+		});
+		this.setPositionConstraints({
+			minX: this.defaultThresholds.frameMinX,
+			minY: this.defaultThresholds.frameMinY,
+			maxX: this.defaultThresholds.frameMaxX,
+			maxY: this.defaultThresholds.frameMaxY
+		});
+		this.setAttributesThresholds({
+			headwearThreshold: this.defaultThresholds.headwearThreshold,
+			lensesThreshold: this.defaultThresholds.lensesThreshold,
+			closedEyesThreshold: this.defaultThresholds.closedEyesThreshold,
+			maskThreshold: this.defaultThresholds.maskThreshold
+		});
+	}
+	setAutocaptureInterval(interval) {
+		this.ensureInitialized();
+		if (!this.currentThresholds) {
+			this.applyDefaults(interval);
+			return;
+		}
+		this.setThresholds({
+			...this.currentThresholds,
+			autocaptureInterval: interval
+		});
+	}
+	setThresholds(thresholds) {
+		this.ensureInitialized();
+		this.currentThresholds = { ...thresholds };
+		mlWasmJSApi_default.setFaceDetectionThresholds(this.getPipelineType(), thresholds.brightnessThreshold, thresholds.blurrinessThreshold, thresholds.tiltRotationAngleThreshold, thresholds.minMagicCropSize, thresholds.autocaptureInterval, thresholds.minFaceQualityScore, thresholds.faceOcclusionThreshold);
+	}
+	setAttributesThresholds(thresholds) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceAttributesThresholds(this.getPipelineType(), thresholds.headwearThreshold, thresholds.lensesThreshold, thresholds.closedEyesThreshold, thresholds.maskThreshold);
+	}
+	setChecksEnabled(config) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceChecksEnabled(this.getPipelineType(), config.lenses, config.mask, config.closedEyes, config.headWear, config.occlusion);
+	}
+	setVideoSelfieMode(enabled) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setFaceDetectionMode(this.getPipelineType(), enabled);
+	}
+	reset() {
+		super.reset();
+		this.currentFrame = null;
+		this.bestCanvas = null;
+		this.bestFace = null;
+	}
+	createDefaultFaceCoordinates(canvas) {
+		return {
+			rightEyeX: 0,
+			rightEyeY: 0,
+			leftEyeX: 0,
+			leftEyeY: 0,
+			noseTipX: 0,
+			noseTipY: 0,
+			rightMouthX: 0,
+			rightMouthY: 0,
+			mouthX: 0,
+			mouthY: 0,
+			x: 0,
+			y: 0,
+			width: canvas.width() ?? 0,
+			height: canvas.height() ?? 0
+		};
+	}
+	formatFaceCoordinates(face) {
+		return {
+			rightEyeX: face.rightEye.x,
+			rightEyeY: face.rightEye.y,
+			leftEyeX: face.leftEye.x,
+			leftEyeY: face.leftEye.y,
+			noseTipX: face.noseTip.x,
+			noseTipY: face.noseTip.y,
+			rightMouthX: face.rightMouthCorner.x,
+			rightMouthY: face.rightMouthCorner.y,
+			mouthX: face.leftMouthCorner.x,
+			mouthY: face.leftMouthCorner.y,
+			x: face.rect.x,
+			y: face.rect.y,
+			width: face.rect.width,
+			height: face.rect.height
+		};
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/wasm/IdCaptureProvider.ts
+var IdCaptureProvider = class extends BaseWasmProvider {
+	constructor() {
+		super(WasmPipelineType.IdBlurGlarePipeline);
+		this.lastProcessResult = null;
+		this.capturedCanvas = null;
+		this.originalCapturedCanvas = null;
+	}
+	async initialize(config) {
+		await this.initializeBase(config, "idCapture");
+	}
+	setCallbacks(callbacks) {
+		this.ensureInitialized();
+		const onCaptureWrapper = () => {
+			callbacks.onCapture?.();
+		};
+		mlWasmJSApi_default.setIdCaptureCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onDetectionStarted ?? (() => {}), callbacks.onMaskChange ? (show, mask, top, orientation) => callbacks.onMaskChange?.(show, mask, top, orientation) : () => {}, callbacks.onBlur ?? (() => {}), callbacks.onGlare ?? (() => {}), callbacks.onCapturing ?? (() => {}), callbacks.onCapture ? onCaptureWrapper : () => {}, callbacks.onBestFrame ? (blur, glare, orientation) => callbacks.onBestFrame?.(blur, glare, orientation) : () => {}, callbacks.onIdNotDetected ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onIdTypeChange ? (idType) => callbacks.onIdTypeChange?.(idType) : () => {}, callbacks.onIdSideChange ? (side) => callbacks.onIdSideChange?.(side) : () => {}, callbacks.onCapturingCounterValueChange ? (value) => callbacks.onCapturingCounterValueChange?.(value) : () => {});
+	}
+	setThresholds(thresholds) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setIdCaptureThresholds(this.getPipelineType(), thresholds.blurThreshold, thresholds.blurChangeThreshold, thresholds.glareThreshold, thresholds.clsThreshold, thresholds.sideThreshold, thresholds.iouThreshold, thresholds.idDetectedTimeout, thresholds.autocaptureTimeout, thresholds.framesAggregationInterval, thresholds.minFaceIdQualityScore);
+	}
+	setGeometry(geometry) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setIdCaptureGeometryParams(this.getPipelineType(), geometry.areaDown, geometry.areaUp, geometry.areaIOSPassportUp, geometry.areaIOSPassportDown, geometry.widthIOSUp, geometry.widthIOSDown, geometry.widthDown, geometry.widthUp, geometry.windowOuterWidth, geometry.windowOuterHeight, geometry.windowInnerWidth, geometry.windowInnerHeight);
+	}
+	setSettings(settings) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setIdCaptureConfigParams(this.getPipelineType(), settings.isFixedMask, settings.isIPhone14OrHigher, settings.idType, settings.blurCheckEnabled, settings.glareCheckEnabled, settings.faceQualityCheckEnabled, settings.iouCheckEnabled);
+	}
+	setModelType(modelType) {
+		this.ensureInitialized();
+		let wasmModelType;
+		switch (modelType) {
+			case "v1":
+				wasmModelType = IdCaptureModelType.IdCaptureV1x;
+				break;
+			case "v2":
+				wasmModelType = IdCaptureModelType.IdCaptureV2x;
+				break;
+			case "v3":
+				wasmModelType = IdCaptureModelType.IdCaptureV3x;
+				break;
+			default: throw new Error(`Unknown model type: ${modelType}`);
+		}
+		mlWasmJSApi_default.setIdCaptureModelType(this.getPipelineType(), wasmModelType);
+	}
+	/**
+	* Processes a frame through the WASM pipeline and stores the result.
+	*/
+	async processFrame(image) {
+		const result = await this.processFrameWasm(image);
+		const pipelineType = this.getPipelineType();
+		if (result && pipelineType === WasmPipelineType.IdBlurGlarePipeline) this.lastProcessResult = result;
+		else this.lastProcessResult = null;
+	}
+	/**
+	* Gets the last process result from the most recent frame processing.
+	* @returns The last process result with quad coordinates, or null if not available
+	*/
+	getLastProcessResult() {
+		return this.lastProcessResult;
+	}
+	transformPerspective(canvas, frameRect) {
+		this.ensureInitialized();
+		const originalWidth = canvas.width();
+		const originalHeight = canvas.height();
+		try {
+			const imageData = canvas.getImageData();
+			if (!imageData) return canvas;
+			const transformedCanvas = mlWasmJSApi_default.IdPerspectiveTransform(imageData, frameRect);
+			if (transformedCanvas) {
+				const wrappedCanvas = new IncodeCanvas(transformedCanvas);
+				const wrappedWidth = wrappedCanvas.width();
+				const wrappedHeight = wrappedCanvas.height();
+				if (wrappedWidth === originalWidth && wrappedHeight === originalHeight) {
+					const croppedCanvas = this.cropCanvasToRect(wrappedCanvas, {
+						x: Math.round(frameRect.x),
+						y: Math.round(frameRect.y),
+						w: Math.round(frameRect.w),
+						h: Math.round(frameRect.h)
+					});
+					if (croppedCanvas) return croppedCanvas;
+				}
+				return wrappedCanvas;
+			}
+			return canvas;
+		} catch (_error) {
+			return canvas;
+		}
+	}
+	/**
+	* Crops a canvas to the specified rectangle region.
+	* @param canvas - The canvas to crop
+	* @param rect - The rectangle to crop to (x, y, w, h)
+	* @returns A new IncodeCanvas with the cropped region, or null if cropping fails
+	*/
+	cropCanvasToRect(canvas, rect) {
+		const canvasWidth = canvas.width();
+		const canvasHeight = canvas.height();
+		if (!canvasWidth || !canvasHeight) return null;
+		const x = Math.max(0, Math.min(rect.x, canvasWidth));
+		const y = Math.max(0, Math.min(rect.y, canvasHeight));
+		const w = Math.max(1, Math.min(rect.w, canvasWidth - x));
+		const h = Math.max(1, Math.min(rect.h, canvasHeight - y));
+		const croppedCanvasElement = document.createElement("canvas");
+		croppedCanvasElement.width = w;
+		croppedCanvasElement.height = h;
+		const ctx = croppedCanvasElement.getContext("2d");
+		if (!ctx) return null;
+		ctx.drawImage(canvas.canvas, x, y, w, h, 0, 0, w, h);
+		return new IncodeCanvas(croppedCanvasElement);
+	}
+	/**
+	* Gets the captured canvas (transformed for preview).
+	* @returns The captured canvas, or null if not available
+	*/
+	getCapturedCanvas() {
+		return this.capturedCanvas;
+	}
+	/**
+	* Gets the original captured canvas (full frame for upload).
+	* @returns The original captured canvas, or null if not available
+	*/
+	getOriginalCapturedCanvas() {
+		return this.originalCapturedCanvas;
+	}
+	/**
+	* Sets the captured canvases (original and transformed).
+	* @param original - The original full-frame canvas (for upload)
+	* @param transformed - The transformed canvas (for preview)
+	*/
+	setCapturedCanvases(original, transformed) {
+		this.originalCapturedCanvas = original;
+		this.capturedCanvas = transformed;
+	}
+	reset() {
+		super.reset();
+		this.lastProcessResult = null;
+		this.capturedCanvas = null;
+		this.originalCapturedCanvas = null;
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/wasm/WasmUtilProvider.ts
+var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
+	static async getInstance() {
+		if (WasmUtilProvider.instance) return WasmUtilProvider.instance;
+		if (WasmUtilProvider.initPromise) return WasmUtilProvider.initPromise;
+		WasmUtilProvider.initPromise = (async () => {
+			const instance = new WasmUtilProvider();
+			await instance.initializeBase({}, "selfie");
+			WasmUtilProvider.instance = instance;
+			return instance;
+		})();
+		return WasmUtilProvider.initPromise;
+	}
+	static resetInstance() {
+		WasmUtilProvider.instance = void 0;
+		WasmUtilProvider.initPromise = void 0;
+	}
+	constructor() {
+		super(void 0);
+	}
+	async initialize(config) {
+		if (this.initialized) return;
+		const pipeline = config.pipelines?.[0] ?? "selfie";
+		await this.initializeBase(config, pipeline);
+	}
+	async processFrame(_image) {
+		throw new Error("WasmUtilProvider does not support frame processing. Use encryptImage() instead.");
+	}
+	encryptImage(image) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.ens(image);
+	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBackgroundMode(backgroundMode);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setInspectorOpened(opened);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getCheck();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.isVirtualCamera(label);
+	}
+	async prc() {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.prc();
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.poc(output);
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.ckvcks(data);
+	}
+	async getVersions() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getVersions();
+	}
+};
+
+//#endregion
+//#region ../infra/src/wasm/idCaptureDefaults.ts
+/**
+* Default WASM thresholds for ID capture quality checks.
+* Based on legacy pipelinesConfig.ts values.
+*/
+const DEFAULT_ID_CAPTURE_THRESHOLDS = {
+	blurThreshold: .2,
+	blurChangeThreshold: .2,
+	glareThreshold: .3,
+	clsThreshold: .98,
+	sideThreshold: .8,
+	iouThreshold: .8,
+	idDetectedTimeout: 1e4,
+	autocaptureTimeout: 5e3,
+	framesAggregationInterval: 3e3,
+	minFaceIdQualityScore: .62
+};
+/**
+* Default model version for ID capture.
+*/
+const DEFAULT_ID_CAPTURE_MODEL_VERSION = "v2";
+
+//#endregion
+export { createManager as C, isIOS as D, isDesktop as E, isIPhone14OrHigher as O, stopCameraStream as S, isAndroid as T, createHiddenVideoElement as _, FaceDetectionProvider as a, enumerateVideoDevices as b, OpenViduRecordingProvider as c, BrowserTimerProvider as d, BrowserStorageProvider as f, queryCameraPermission as g, StreamCanvasCapture as h, IdCaptureProvider as i, isSafari as k, MotionSensorProvider as l, StreamCanvasProcessingSession as m, DEFAULT_ID_CAPTURE_THRESHOLDS as n, warmupWasm as o, BrowserEnvironmentProvider as p, WasmUtilProvider as r, VisibilityProvider as s, DEFAULT_ID_CAPTURE_MODEL_VERSION as t, LocalRecordingProvider as u, IncodeCanvas as v, createApi_default as w, requestCameraAccess as x, applyTrackConstraints as y };