@incodetech/core 2.0.0-alpha.1 → 2.0.0-alpha.11

package/dist/endpoints-B0ltwtb5.esm.js

@@ -0,0 +1,2335 @@
+import { a as __toDynamicImportESM } from "./chunk-C_Yo44FK.esm.js";
+
+//#region ../infra/src/capabilities/platform.ts
+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);
+}
+
+//#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 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$1 = {
+		defaults,
+		async request(requestConfig) {
+			const { method = "GET", url, headers: headers$1 = {}, query, params, body, signal, timeout = config.timeout ?? DEFAULT_TIMEOUT, parse } = requestConfig;
+			const fullUrl = buildUrl(defaults.baseURL, url, params ?? query);
+			const mergedHeaders = {
+				...defaults.headers,
+				...headers$1
+			};
+			const controller = new AbortController();
+			const abortSignal = signal ?? controller.signal;
+			const timeoutId = setTimeout(() => controller.abort(), timeout);
+			try {
+				const requestBody = prepareBody(body);
+				let finalHeaders = mergedHeaders;
+				if (requestBody === null && (method === "POST" || method === "PUT" || method === "PATCH")) {
+					const { "Content-Type": _, ...headersWithoutContentType } = mergedHeaders;
+					finalHeaders = headersWithoutContentType;
+				}
+				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$1.request({
+				...config$1,
+				url,
+				method: "GET"
+			});
+		},
+		post(url, body, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				body,
+				method: "POST"
+			});
+		},
+		put(url, body, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				body,
+				method: "PUT"
+			});
+		},
+		patch(url, body, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				body,
+				method: "PATCH"
+			});
+		},
+		delete(url, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				method: "DELETE"
+			});
+		},
+		head(url, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				method: "HEAD"
+			});
+		},
+		options(url, config$1) {
+			return client$1.request({
+				...config$1,
+				url,
+				method: "OPTIONS"
+			});
+		},
+		setHeader(name, value) {
+			defaults.headers[name] = value;
+		}
+	};
+	return client$1;
+};
+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$1 = createApi$1({
+		actor,
+		getSnapshot
+	});
+	const base = {
+		getState,
+		subscribe,
+		stop() {
+			actor.stop();
+		}
+	};
+	return Object.defineProperties(base, Object.getOwnPropertyDescriptors(api$1));
+}
+
+//#endregion
+//#region ../infra/src/media/camera.ts
+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();
+}
+
+//#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;
+	}
+	/**
+	* 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;
+		this.blobData = null;
+	}
+	/**
+	* 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/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 width = options?.width ?? settings?.width ?? 640;
+		const height = options?.height ?? settings?.height ?? 480;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = width;
+		this.canvas.height = height;
+		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;
+		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) {
+	console.log("[VideoTrimmer] Starting playback-based trimming...");
+	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);
+	console.log("[VideoTrimmer] Video duration:", duration);
+	if (!duration || duration < seconds) {
+		console.log("[VideoTrimmer] Video too short, returning original");
+		URL.revokeObjectURL(videoURL);
+		return videoBlob;
+	}
+	const startTime = Math.max(0, Math.floor(duration) - seconds);
+	console.log("[VideoTrimmer] Trimming from", startTime, "to", duration);
+	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 = () => {
+			console.log("[VideoTrimmer] Recording stopped, chunks:", chunks.length);
+			const trimmedBlob = new Blob(chunks, { type: mimeType });
+			URL.revokeObjectURL(videoURL);
+			mediaRecorder.stream?.getTracks().forEach((track) => track.stop());
+			stream.getTracks().forEach((track) => track.stop());
+			video.src = "";
+			console.log("[VideoTrimmer] Playback-based trimming complete, size:", trimmedBlob.size);
+			resolve(trimmedBlob);
+		};
+	});
+	video.addEventListener("play", () => {
+		console.log("[VideoTrimmer] Video playing, starting recording...");
+		function drawVideo() {
+			if (video.currentTime >= duration) {
+				console.log("[VideoTrimmer] Reached end, stopping...");
+				mediaRecorder.stop();
+				video.pause();
+				return;
+			}
+			ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+			requestAnimationFrame(drawVideo);
+		}
+		drawVideo();
+		setTimeout(() => {
+			console.log("[VideoTrimmer] Starting MediaRecorder...");
+			mediaRecorder.start(100);
+		}, 500);
+	});
+	console.log("[VideoTrimmer] Starting video playback...");
+	video.play().catch((err) => {
+		console.error("[VideoTrimmer] Play failed:", err);
+		URL.revokeObjectURL(videoURL);
+	});
+	return await recordingPromise;
+}
+async function trimLastNSeconds(videoBlob, seconds) {
+	console.log(`[VideoTrimmer] trimLastNSeconds called (trim to ${seconds}s from ${videoBlob.size} bytes)`);
+	console.log("[VideoTrimmer] Using playback-based trimming");
+	return await trimLastNSecondsUsingPlayback(videoBlob, seconds);
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/DeepsightRecordingProvider.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 DeepsightRecordingProvider = 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) {
+			console.error(`Failed to start recording: ${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-20ZYS-mT.esm.js").then(__toDynamicImportESM(1));
+	OpenViduLogger.getInstance().enableProdMode();
+}
+async function loadOpenVidu() {
+	if (openViduImport) return openViduImport;
+	await enableProdModeBeforeLoad();
+	openViduImport = import("./lib-CykGFCEr.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, 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, 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
+	*/
+	async processFrame(image) {
+		this.ensureInitialized();
+		const pipelineType = this.getPipelineType();
+		await mlWasmJSApi_default.allocateImageBuffers(image.width, image.height);
+		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 super.processFrame(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/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);
+	}
+	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 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 src/internal/http/api.ts
+let client = null;
+let currentToken = null;
+function setClient(httpClient) {
+	client = httpClient;
+}
+function setToken(token) {
+	currentToken = token;
+}
+function getToken() {
+	return currentToken;
+}
+function getApi() {
+	if (!client) throw new Error("SDK not configured. Call setup({ apiURL: \"...\" }) first.");
+	return client;
+}
+function resetApi() {
+	client = null;
+	currentToken = null;
+}
+function addTokenHeader(config) {
+	if (!currentToken) return config ?? {};
+	return {
+		...config,
+		headers: {
+			...config?.headers,
+			"X-Incode-Hardware-Id": currentToken
+		}
+	};
+}
+const api = {
+	get(url, config) {
+		return getApi().get(url, addTokenHeader(config));
+	},
+	post(url, data, config) {
+		return getApi().post(url, data, addTokenHeader(config));
+	},
+	put(url, data, config) {
+		return getApi().put(url, data, addTokenHeader(config));
+	},
+	patch(url, data, config) {
+		return getApi().patch(url, data, addTokenHeader(config));
+	},
+	delete(url, config) {
+		return getApi().delete(url, addTokenHeader(config));
+	}
+};
+
+//#endregion
+//#region src/internal/http/endpoints.ts
+const endpoints = {
+	createSession: "/omni/start",
+	flow: "/omni/onboarding/flow",
+	events: "/omni/interview-events",
+	selfie: "/omni/add/face",
+	recordingCreateSessionV2: "/omni/recordings/create-session/v2",
+	recordingStartV2: "/omni/recordings/record-start/v2",
+	recordingStopV2: "/omni/recordings/record-stop/v2",
+	deepsightVideoImport: "/omni/recordings/import",
+	phone: "/omni/add/phone",
+	phoneInstant: "/omni/instant/add/phone",
+	getPhone: "/omni/get/phone",
+	startInfo: "/omni/start-info",
+	sendSmsOtp: "/omni/send/sms-otp",
+	compareOtp: "/omni/compare/otp",
+	email: "/omni/add/email",
+	getEmail: "/omni/get/email"
+};
+
+//#endregion
+export { queryCameraPermission as _, resetApi as a, createManager as b, WasmUtilProvider as c, VisibilityProvider as d, OpenViduRecordingProvider as f, StreamCanvasCapture as g, StreamCanvasProcessingSession as h, getToken as i, FaceDetectionProvider as l, DeepsightRecordingProvider as m, api as n, setClient as o, MotionSensorProvider as p, getApi as r, setToken as s, endpoints as t, warmupWasm as u, requestCameraAccess as v, createApi_default as x, stopCameraStream as y };