@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/BaseWasmProvider-C_DLEI40.esm.js

@@ -0,0 +1,1118 @@
+//#region ../infra/src/providers/browser/SemaphoreProvider.ts
+const DEFAULT_ACQUIRE_TIMEOUT_MS = 3e4;
+/**
+* Counting-semaphore implementation of {@link IConcurrencyCapability}.
+*
+* Default `maxConcurrent=1` makes it behave as a mutex; set higher for
+* parallel-bounded access. Each acquire returns a numeric `threadId` for
+* tracing — the slot index, in `[0, maxConcurrent)` — that must be passed back
+* to `release`.
+*
+* If all slots stay occupied longer than `acquireTimeoutMs` (default 30s), the
+* pending wait still resolves when a slot frees, but `console.error` is logged
+* as a deadlock-watchdog signal. Misuse — out-of-range or double-released
+* `threadId`s — is also logged and treated as a no-op rather than thrown.
+*/
+var SemaphoreProvider = class {
+	constructor(maxConcurrent = 1, acquireTimeoutMs = DEFAULT_ACQUIRE_TIMEOUT_MS) {
+		this.pending = [];
+		this.available = [];
+		this.processing = /* @__PURE__ */ new Set();
+		this.maxId = maxConcurrent - 1;
+		this.acquireTimeoutMs = acquireTimeoutMs;
+		for (let i = 0; i < maxConcurrent; i++) this.available.push(i);
+	}
+	/**
+	* Acquire a slot. Resolves immediately with the slot's `threadId` if one is
+	* free, otherwise queues FIFO and resolves when a holder releases.
+	*/
+	async acquire() {
+		if (this.available.length > 0) {
+			const threadId = this.available.shift();
+			this.processing.add(threadId);
+			return threadId;
+		}
+		return new Promise((resolve, reject) => {
+			const entry = {
+				resolve: (threadId) => {
+					clearTimeout(entry.timer);
+					this.processing.add(threadId);
+					resolve(threadId);
+				},
+				reject: (error) => {
+					clearTimeout(entry.timer);
+					reject(error);
+				},
+				timer: setTimeout(() => {
+					console.error(`SemaphoreProvider: all slots occupied for ${this.acquireTimeoutMs}ms, ${this.pending.length} request(s) waiting`);
+				}, this.acquireTimeoutMs)
+			};
+			this.pending.push(entry);
+		});
+	}
+	/**
+	* Return a slot to the pool. The next pending waiter (if any) is resolved
+	* with this `threadId`; otherwise the slot is added back to `available`.
+	* Releasing an out-of-range or already-released `threadId` logs an error and
+	* is otherwise a no-op.
+	*/
+	release(threadId) {
+		if (threadId < 0 || threadId > this.maxId) {
+			console.error(`SemaphoreProvider: invalid threadId ${threadId}`);
+			return;
+		}
+		if (!this.processing.has(threadId)) {
+			console.error(`SemaphoreProvider: double-release of threadId ${threadId}`);
+			return;
+		}
+		this.processing.delete(threadId);
+		if (this.pending.length > 0) this.pending.shift().resolve(threadId);
+		else this.available.unshift(threadId);
+	}
+	/**
+	* Cancel all pending acquires with a reset error and replenish all slots.
+	* Existing holders are not contacted — a `release` after reset will log a
+	* double-release warning rather than disrupt the new pool.
+	*/
+	reset() {
+		const waiters = this.pending;
+		this.pending = [];
+		this.available = [];
+		this.processing = /* @__PURE__ */ new Set();
+		for (let i = 0; i <= this.maxId; i++) this.available.push(i);
+		for (const waiter of waiters) waiter.reject(/* @__PURE__ */ new Error("SemaphoreProvider reset: pending acquire cancelled"));
+	}
+	/**
+	* Acquire a slot, invoke `fn(threadId, ...args)`, then release the slot in a
+	* `finally` block. Errors thrown by `fn` propagate to the caller after the
+	* slot is released.
+	*/
+	async withLock(fn, ...args) {
+		const threadId = await this.acquire();
+		try {
+			return await fn(threadId, ...args);
+		} finally {
+			this.release(threadId);
+		}
+	}
+};
+
+//#endregion
+//#region ../infra/src/wasm/apiUtilities.ts
+if (typeof window !== "undefined" && window.wasmArrayBuffer === void 0) window.wasmArrayBuffer = null;
+let loadPromise = null;
+let loadedResult = null;
+async function importGlue(glueCodePath) {
+	const mod = await import(
+		/* @vite-ignore */
+		/* webpackIgnore: true */
+		glueCodePath
+);
+	if (typeof mod.Module !== "function") throw new Error(`WASM glue at ${glueCodePath} did not export a Module factory`);
+	return mod.Module;
+}
+async function fetchWasmBinary(libPath) {
+	const response = await fetch(libPath);
+	if (!response.ok) throw new Error(`Failed to fetch WASM binary at ${libPath}: ${response.status} ${response.statusText}`);
+	const buffer = await response.arrayBuffer();
+	return new Uint8Array(buffer);
+}
+async function instantiate(factory, libPath) {
+	window.wasmArrayBuffer = await fetchWasmBinary(libPath);
+	return await factory();
+}
+/**
+* Derive a sibling `.js` path from a `.wasm` path by replacing the trailing
+* extension. Used as a last-resort default when callers pass a `wasmSimdPath`
+* without an accompanying `glueCodeSimdPath` — matches the legacy CDN naming
+* convention (`webLibSimd.wasm` <-> `webLibSimd.js`).
+*/
+function deriveSiblingJsPath(wasmPath) {
+	return wasmPath.replace(/\.wasm($|\?)/, ".js$1");
+}
+/**
+* Load the WASM module, memoized. Subsequent calls return the same instance.
+*
+* SIMD-first with fallback: if `useSimd !== false` and a `wasmSimdPath` is
+* provided, the SIMD binary + SIMD glue are tried first; on instantiation
+* failure the non-SIMD binary + non-SIMD glue are used. Each `.wasm` is
+* paired with its matching `.js` glue — they cannot be mixed.
+*/
+async function loadWasmModule(config) {
+	if (loadedResult) return loadedResult;
+	if (loadPromise) return loadPromise;
+	loadPromise = (async () => {
+		try {
+			const wantSimd = config.useSimd !== false;
+			const simdBinary = config.wasmSimdPath ?? config.wasmPath;
+			if (wantSimd && simdBinary !== config.wasmPath) try {
+				const simdFactory = await importGlue(config.glueCodeSimdPath ?? deriveSiblingJsPath(simdBinary));
+				window.Module = simdFactory;
+				const result$1 = {
+					wasmModule: await instantiate(simdFactory, simdBinary),
+					simdUsed: true
+				};
+				loadedResult = result$1;
+				return result$1;
+			} catch (simdError) {
+				console.warn("[Incode SDK] SIMD WASM load failed, falling back to non-SIMD", simdError);
+			}
+			const nonSimdFactory = await importGlue(config.glueCodePath);
+			window.Module = nonSimdFactory;
+			const result = {
+				wasmModule: await instantiate(nonSimdFactory, config.wasmPath),
+				simdUsed: false
+			};
+			loadedResult = result;
+			return result;
+		} catch (error) {
+			loadPromise = null;
+			throw error;
+		}
+	})();
+	return loadPromise;
+}
+
+//#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/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["OnDeviceSelfieWorkflow"] = 5] = "OnDeviceSelfieWorkflow";
+	return WasmPipelineType$1;
+}({});
+
+//#endregion
+//#region ../infra/src/wasm/wasmCallUtils.ts
+async function wasmCallWrapper(concurrency, wasmMethod, useSemaphore = true, ...args) {
+	const innerCall = async () => {
+		while (true) {
+			if (wasmMethod(...args)) return;
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		}
+	};
+	if (useSemaphore) {
+		await concurrency.withLock(innerCall);
+		return;
+	}
+	await innerCall();
+}
+
+//#endregion
+//#region ../infra/src/wasm/wasmWebClient.ts
+/**
+* JavaScript bridge for the C++ `WebClient` exposed by `webLib.wasm`.
+*
+* The pinned WASM bundle ships a `WebClient` class alongside the ML pipeline
+* APIs. This module instantiates it once (sharing the singleton `wasmModule`
+* with `mlWasmJSApi`) and exposes a small TypeScript-friendly surface that
+* `createWasmApi` can drive.
+*
+* Concurrency model mirrors the legacy implementation:
+* - 4-slot semaphore keyed by per-request `threadId` so multiple HTTP calls
+*   can run in parallel without trampling shared C++ state.
+* - Each WASM-side method that performs in-binary HTTP (request methods AND
+*   `createApi`'s in-binary `/e2ee/key` handshake) returns `false` while in
+*   flight and `true` once the C++ side has finished; the JS bridge awaits
+*   completion via {@link wasmCallWrapper}.
+* - Result extraction (`getRequestResult`) is per-thread for HTTP requests
+*   and uses `threadId = -1` for the session-level `createApi` handshake.
+*
+* Encryption support: `setupConnection` accepts an `encryptionEnabled` flag
+* that triggers the in-binary RSA/AES handshake. The OAEP MGF1 hash is
+* controlled by the `useSha256` flag forwarded to the C++ `createApi`:
+* `true` = SHA-256 MGF1, `false` = SHA-1 MGF1 (Java-compat default).
+* State lives in the C++ binary and (for SDK config) in
+* `@incodetech/core`'s `setup.ts` — this module caches nothing.
+*/
+const HTTP_CONCURRENCY = 4;
+/**
+* Sentinel `threadId` used by the session-level `createApi` handshake when we
+* read its result via `getRequestResult`. Per-request HTTP traffic uses real
+* thread ids handed out by the semaphore; the handshake has no slot of its
+* own, so the C++ side stores its result under `-1`. Mirrors legacy
+* `checkError(threadId = -1)`.
+*/
+const SETUP_THREAD_ID = -1;
+var WasmWebClientError = class extends Error {
+	constructor(message, statusCode, data) {
+		super(message);
+		this.name = "WasmWebClientError";
+		this.status = statusCode;
+		this.statusCode = statusCode;
+		if (statusCode > 0 || data !== void 0) this.response = {
+			status: statusCode,
+			data
+		};
+	}
+};
+let webClientApi = null;
+let initPromise = null;
+let semaphore = new SemaphoreProvider(HTTP_CONCURRENCY);
+const isWebClientWasm = (mod) => {
+	return typeof mod.WebClient === "function";
+};
+const toStringRecord = (obj) => {
+	if (!obj) return void 0;
+	const result = {};
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (value === void 0 || value === null) continue;
+		result[key] = String(value);
+	}
+	return result;
+};
+/**
+* Loads the shared WASM module (if not already loaded) and instantiates the
+* C++ `WebClient`. Idempotent — repeated calls reuse the existing instance.
+*
+* `glueCodeSimdPath` is paired with `wasmSimdPath` (`webLibSimd.js` for
+* `webLibSimd.wasm`). Pass `''` to derive it automatically from
+* `wasmSimdPath` by replacing the `.wasm` extension with `.js`.
+*/
+async function initializeWasmWebClient(wasmPath, wasmSimdPath, glueCodePath, glueCodeSimdPath, useSimd) {
+	if (webClientApi) return;
+	if (initPromise) return initPromise;
+	initPromise = (async () => {
+		try {
+			const { wasmModule } = await loadWasmModule({
+				wasmPath,
+				wasmSimdPath,
+				glueCodePath,
+				glueCodeSimdPath: glueCodeSimdPath || void 0,
+				useSimd
+			});
+			if (!isWebClientWasm(wasmModule)) throw new Error("WASM module does not expose a WebClient class. Update webLib.wasm to a build that includes WebClient.");
+			webClientApi = new wasmModule.WebClient();
+		} catch (error) {
+			initPromise = null;
+			throw error;
+		}
+	})();
+	return initPromise;
+}
+/**
+* Configures the C++ WebClient connection. Safe to call multiple times — each
+* call resets the underlying session and re-applies default headers.
+*
+* `defaultHeaders` are applied **before** `createApi`, so the in-binary RSA
+* handshake (`GET /e2ee/key/v2` + `POST /e2ee/key`) sees the same headers as
+* data requests. Without this ordering, environments that require auth/version
+* headers on the handshake (e.g. `x-api-key`, `api-version`) would 401/4xx
+* before any encrypted traffic ever flowed.
+*
+* The C++ `createApi` returns `false` while the in-binary handshake is still
+* in flight and `true` once both the `/e2ee/key/v2` GET and the `/e2ee/key`
+* POST have completed (encryption on) or once the WebClient is configured
+* (encryption off — same boolean convention, just no network traffic). The
+* JS bridge waits on that boolean via {@link wasmCallWrapper}, then surfaces
+* any handshake error captured on the session-level (`threadId = -1`)
+* request slot. Mirrors legacy
+* `ms-incodesmile-web/packages/incode-welcome/src/wasmUtils/webClientApi.ts`
+* `setupConnection`.
+*
+* `useSha256` selects the OAEP MGF1 hash for the in-binary RSA wrap:
+* - `true` → MGF1 = SHA-256. Caller is responsible for attaching the
+*   `X-RSA-Encryption-Scheme: RSA/NONE/OAEPWITHSHA-256ANDMGF1PADDING`
+*   header on subsequent encrypted requests so the server matches.
+* - `false` → MGF1 = SHA-1 (Java-compat default). No scheme header needed;
+*   the server falls back to the legacy Java default.
+*/
+async function setupWasmConnection(apiURL, token, encryptionEnabled, defaultHeaders, useSha256) {
+	const api = ensureReady();
+	api.resetSessionState?.();
+	api.setDefaultHeaders?.(defaultHeaders);
+	await wasmCallWrapper(semaphore, () => api.createApi(apiURL, token, useSha256, encryptionEnabled), false);
+	const result = api.getRequestResult(SETUP_THREAD_ID);
+	if (result.hasError) throw new WasmWebClientError(result.errorMessage || "WebClient handshake failed", result.statusCode, result.result);
+}
+/**
+* Executes a single HTTP request through the WASM WebClient.
+*
+* Acquires a semaphore slot for `threadId`, registers progress callbacks, runs
+* the request via {@link wasmCallWrapper} (busy-polls until the WASM method
+* returns `true`), then extracts the per-thread result. Throws
+* {@link WasmWebClientError} on non-2xx or transport errors.
+*
+* The `ie` (inline-encryption) flag is forwarded to the C++ WebClient for
+* mutating methods. Default `false` — the SDK HTTP path leaves payloads
+* unencrypted at the WebClient layer. The C++ `WebApi.postFaceResults`
+* pre-encrypts its JSON via `SessionEncryptor` and calls back into this
+* function with `ie=true`; see {@link createWebApiHostAdapter}.
+*/
+async function executeWasmRequest(method, url, body, headers, params, timeout, onUploadProgress, ie = false) {
+	const api = ensureReady();
+	const stringParams = toStringRecord(params);
+	return semaphore.withLock(async (threadId) => {
+		if (onUploadProgress && api.setOnUploadProgress) api.setOnUploadProgress((event) => {
+			try {
+				onUploadProgress(event);
+			} catch (error) {
+				console.error("WasmWebClient: error in onUploadProgress callback", error);
+			}
+		});
+		try {
+			await wasmCallWrapper(semaphore, () => callWasmMethod(api, method, threadId, url, body, headers, stringParams, timeout, ie), false);
+			return readResult(api, threadId);
+		} finally {
+			api.clearOnUploadProgress?.(threadId);
+			api.clearOnDownloadProgress?.(threadId);
+		}
+	});
+}
+function callWasmMethod(api, method, threadId, url, body, headers, params, timeout, ie) {
+	switch (method) {
+		case "GET": return api.get(threadId, url, params, headers, timeout);
+		case "POST": return api.post(threadId, url, body ?? {}, headers, params, timeout, ie);
+		case "PUT": return api.put(threadId, url, body ?? {}, headers, params, timeout, ie);
+		case "PATCH": return api.patch(threadId, url, body ?? {}, headers, params, timeout, ie);
+		case "DELETE": return api.del(threadId, url, body ?? {}, headers, params, timeout, ie);
+		default: throw new Error(`Unsupported WASM HTTP method: ${method}`);
+	}
+}
+const DEFAULT_WEBAPI_TIMEOUT_MS = 3e4;
+let webApiHttpTransport = null;
+function setWebApiHttpTransport(transport) {
+	webApiHttpTransport = transport;
+}
+function createWebApiHostAdapter() {
+	return { post(url, body, config) {
+		const effectiveConfig = config ?? {};
+		const transport = webApiHttpTransport;
+		if (transport) return transport(url, body, effectiveConfig);
+		return executeWasmRequest("POST", url, body, effectiveConfig.headers ?? {}, effectiveConfig.params, effectiveConfig.timeout ?? DEFAULT_WEBAPI_TIMEOUT_MS, void 0, effectiveConfig.ie === true);
+	} };
+}
+function readResult(api, threadId) {
+	const response = api.getRequestResult(threadId);
+	if (response.hasError) throw new WasmWebClientError(response.errorMessage || "WasmWebClient request failed", response.statusCode, response.result);
+	return {
+		data: response.result,
+		status: response.statusCode
+	};
+}
+function ensureReady() {
+	if (!webClientApi) throw new Error("WasmWebClient not initialized. Call initializeWasmWebClient() first.");
+	return webClientApi;
+}
+
+//#endregion
+//#region ../infra/src/wasm/mlWasmJSApi.ts
+var MlWasmJSApi = class MlWasmJSApi {
+	constructor() {
+		this.versionsFile = null;
+		this.modelsBuffers = null;
+		this.inputImageBuffer = null;
+		this.wasmModule = null;
+		this.workflowApiUtilities = null;
+		this.utilityApi = null;
+		this.idCaptureWasmApi = null;
+		this.faceProcessingWasmApi = null;
+		this.webApi = null;
+		this.imageWidth_ = null;
+		this.imageHeight_ = null;
+		this.pipelines_ = null;
+		this.isInitialized_ = false;
+		this.inspectorOpened_ = false;
+		this.wasmCallSemaphore = new SemaphoreProvider();
+		this.Module = null;
+	}
+	/**
+	* 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 {string} glueCodePath - The path to the non-SIMD glue (`webLib.js`)
+	* @param {string} glueCodeSimdPath - The path to the SIMD-paired glue (`webLibSimd.js`); pass `''` to derive from `webLibPathSimd`
+	* @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, glueCodeSimdPath, useSimd, versionsFile, pipelines) {
+		await this.freeResources();
+		this.pipelines_ = pipelines;
+		this.versionsFile = versionsFile;
+		const { wasmModule, simdUsed } = await loadWasmModule({
+			glueCodePath,
+			glueCodeSimdPath: glueCodeSimdPath || void 0,
+			wasmPath: webLibPath,
+			wasmSimdPath: webLibPathSimd,
+			useSimd
+		});
+		this.wasmModule = wasmModule;
+		this.Module = window.Module;
+		this.workflowApiUtilities = new this.wasmModule.WorkflowApiUtilities();
+		this.utilityApi = new this.wasmModule.UtilityApi();
+		this.idCaptureWasmApi = new this.wasmModule.IdCaptureApi();
+		this.faceProcessingWasmApi = new this.wasmModule.FaceProcessingApi();
+		this.webApi = new this.wasmModule.WebApi(createWebApiHostAdapter());
+		this.isInitialized_ = true;
+		return simdUsed;
+	}
+	static getInstance() {
+		if (!MlWasmJSApi.instance) MlWasmJSApi.instance = new MlWasmJSApi();
+		return MlWasmJSApi.instance;
+	}
+	/**
+	* Returns initialization status
+	* @returns
+	*/
+	isInitialized() {
+		return this.workflowApiUtilities != null && this.utilityApi != null && this.idCaptureWasmApi != null && this.faceProcessingWasmApi != 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.workflowApiUtilities.allocateInputImageBuffer(imageWidth, imageHeight, 4);
+	}
+	async handleDetectionCallAndUpdateState(type) {
+		this.checkWasmInitialization("Unable to update pipeline state, cpp API hasn't been initialized");
+		this.workflowApiUtilities.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.workflowApiUtilities && typeof this.workflowApiUtilities.delete === "function") {
+			this.workflowApiUtilities.delete();
+			this.workflowApiUtilities = 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.faceProcessingWasmApi && typeof this.faceProcessingWasmApi.delete === "function") {
+			this.faceProcessingWasmApi.delete();
+			this.faceProcessingWasmApi = null;
+		}
+		if (this.webApi && typeof this.webApi.delete === "function") this.webApi.delete();
+		this.webApi = 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.workflowApiUtilities.resetWorkflow(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.runIdCaptureWorkflow(this.pipelineTypeToWasmEnum(type));
+			case WasmPipelineType.IdVideoSelfiePipeline: return this.idCaptureWasmApi.runIdVideoSelfieWorkflow();
+			case WasmPipelineType.SelfieWithAggregationMetrics:
+			case WasmPipelineType.SelfieWithQualityMetrics:
+			case WasmPipelineType.OnDeviceSelfieWorkflow: return this.faceProcessingWasmApi.runSelfieWorkflow(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.faceProcessingWasmApi.runSelfieCapture();
+	}
+	async setFacePositionConstraints(type, minX, minY, maxX, maxY) {
+		this.checkWasmInitialization("Unable to set face position constraints, cpp API hasn't been initialized");
+		this.faceProcessingWasmApi.setFacePositionConstraints(this.pipelineTypeToWasmEnum(type), minX, minY, maxX, maxY);
+	}
+	async setFaceDetectionThresholds(type, brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold, getReadyDelay, framesAggregationInterval, minFramesWithFace) {
+		this.checkWasmInitialization("Unable to set face detection thresholds, cpp API hasn't been initialized");
+		this.faceProcessingWasmApi.setFaceProcessingThresholds(this.pipelineTypeToWasmEnum(type), brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold, getReadyDelay, framesAggregationInterval, minFramesWithFace);
+	}
+	async setFaceAttributesThresholds(type, headwearThreshold, lensesThreshold, closedEyesThreshold, maskThreshold) {
+		this.checkWasmInitialization("Unable to set face attributes thresholds, cpp API hasn't been initialized");
+		this.faceProcessingWasmApi.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.faceProcessingWasmApi.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.faceProcessingWasmApi.setFaceProcessingMode(this.pipelineTypeToWasmEnum(type), isVideoSelfie);
+	}
+	async setFaceDetectionCallbacks(type, onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded) {
+		this.checkWasmInitialization("Unable to set face detection callbacks, cpp API hasn't been initialized");
+		this.faceProcessingWasmApi.setFaceProcessingCallbacks(this.pipelineTypeToWasmEnum(type), onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded);
+	}
+	async setIdCaptureThresholds(type, blurThreshold, blurChangeThreshold, glareThreshold, clsThreshold, sideThreshold, iouThreshold, idDetectedTimeout, autocaptureTimeout, framesAggregationInterval) {
+		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);
+	}
+	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, isFPSLimitEnabled) {
+		this.checkWasmInitialization("Unable to set config params, cpp API hasn't been initialized");
+		this.idCaptureWasmApi.setIdCaptureConfigParams(this.pipelineTypeToWasmEnum(type), isFixedMask, isIPhone14OrHigher, idType, isBlurCheckEnabled, isGlareCheckEnabled, isIouCheckEnabled, isFPSLimitEnabled);
+	}
+	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 loadModels() {
+		this.checkWasmInitialization("Unable load the models, cpp API hasn't been initialized");
+		const buffSizes = new this.wasmModule.WorkflowTypeToIntMap();
+		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.workflowApiUtilities.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.workflowApiUtilities.initializeWorkflows();
+	}
+	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.workflowApiUtilities.getWorkflowState();
+	}
+	getCurrentPipeline() {
+		this.checkWasmInitialization("Unable to get current pipeline, cpp API hasn't been initialized");
+		return this.pipelineTypeFromWasmEnum(this.workflowApiUtilities.getCurrentWorkflow());
+	}
+	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");
+		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.prc(), true);
+	}
+	async poc(output) {
+		this.checkWasmInitialization("Unable to poc, cpp API hasn't been initialized");
+		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.poc(output), true);
+	}
+	ckvcks(data) {
+		this.checkWasmInitialization("Unable to ckvcks, cpp API hasn't been initialized");
+		this.utilityApi.ckvcks(data);
+	}
+	/**
+	* Synchronous manual-capture entry point for the OnDevice selfie workflow.
+	* Runs face detection + the full on-device quality / liveness / age pipeline
+	* on a single canvas image and stages the results inside the WASM `WebApi`
+	* for the next {@link postFaceResults} call. No polling, no semaphore wrap.
+	*
+	* Mirrors `ml-wasm-kit/WasmApi.processPhoto`.
+	*/
+	processPhoto(canvas) {
+		this.checkWasmInitialization("Unable to process photo, cpp API hasn't been initialized");
+		this.faceProcessingWasmApi.processPhoto(canvas);
+	}
+	/**
+	* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
+	* via the C++ `WebApi`. The C++ side encrypts the body with
+	* `SessionEncryptor` and routes through the WASM `WebClient` with inline
+	* encryption (`ie=true`) — this does NOT depend on the WebClient E2EE
+	* session setup, so it works whether `setupWasmConnection` was called with
+	* `encryptionEnabled` true or false.
+	*
+	* Reads from the `WebApi` instance constructed in {@link initialize}. The
+	* C++ `OnDeviceSelfieWorkflow` has already staged the aggregated best-shot
+	* results into that instance via `WebApi::setFaceResults(...)` during
+	* per-frame processing (auto-capture) or via {@link processPhoto}
+	* (manual-capture).
+	*/
+	postFaceResults(config) {
+		this.checkWasmInitialization("Unable to post face results, cpp API hasn't been initialized");
+		return this.webApi.postFaceResults(config ?? {});
+	}
+	pipelineTypeToWasmEnum(type) {
+		switch (type) {
+			case WasmPipelineType.IdBlurGlarePipeline: return this.wasmModule.WorkflowType.IdBlurGlareWorkflow;
+			case WasmPipelineType.IdBarcodeAndTextQualityPipeline: return this.wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow;
+			case WasmPipelineType.IdVideoSelfiePipeline: return this.wasmModule.WorkflowType.IdVideoSelfieWorkflow;
+			case WasmPipelineType.SelfieWithAggregationMetrics: return this.wasmModule.WorkflowType.SelfieWithAggregationMetrics;
+			case WasmPipelineType.SelfieWithQualityMetrics: return this.wasmModule.WorkflowType.SelfieWithQualityMetrics;
+			case WasmPipelineType.OnDeviceSelfieWorkflow: return this.wasmModule.WorkflowType.OnDeviceSelfieWorkflow;
+			default: throw new Error("Unknown pipeline type");
+		}
+	}
+	pipelineTypeFromWasmEnum(type) {
+		switch (type) {
+			case this.wasmModule.WorkflowType.IdBlurGlareWorkflow: return WasmPipelineType.IdBlurGlarePipeline;
+			case this.wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow: return WasmPipelineType.IdBarcodeAndTextQualityPipeline;
+			case this.wasmModule.WorkflowType.IdVideoSelfieWorkflow: return WasmPipelineType.IdVideoSelfiePipeline;
+			case this.wasmModule.WorkflowType.SelfieWithAggregationMetrics: return WasmPipelineType.SelfieWithAggregationMetrics;
+			case this.wasmModule.WorkflowType.SelfieWithQualityMetrics: return WasmPipelineType.SelfieWithQualityMetrics;
+			case this.wasmModule.WorkflowType.OnDeviceSelfieWorkflow: return WasmPipelineType.OnDeviceSelfieWorkflow;
+			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);
+	}
+};
+var mlWasmJSApi_default = MlWasmJSApi.getInstance();
+
+//#endregion
+//#region ../infra/src/wasm/warmup.ts
+/**
+* Pipelines preloaded when no explicit `pipelines` array is passed to
+* {@link warmupWasm}. The on-device selfie bundle is opt-in (loaded only when
+* a SELFIE/AUTH module has `onDeviceFaceResultsSubmissionEnabled: true`), so
+* it is intentionally excluded here to keep the default warmup small.
+*/
+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_2_fp16.ortmodelv2"
+	],
+	onDeviceSelfie: [
+		"selfie_bf_angles_192x192_opset9_fp16.ortmodelv2",
+		"face_attributes_v1_3_fp16.ortmodelv2",
+		"mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2",
+		"face_occlusion_v0_2_fp16.ortmodelv2",
+		"ondevice_physical_liveness_v2_1_fp16.ortmodelv2",
+		"age_estimation_v2_2_2_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 "onDeviceSelfie": return WasmPipelineType.OnDeviceSelfieWorkflow;
+		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.glueCodeSimdPath ?? "") !== (config.glueCodeSimdPath ?? "") || (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.glueCodeSimdPath ?? "", 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.glueCodeSimdPath ?? "", 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;
+		const status = getWasmStatus();
+		if (status.isLoading || isWasmReady() || status.error) 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,
+				glueCodeSimdPath: config.glueCodeSimdPath,
+				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
+export { executeWasmRequest as a, setupWasmConnection as c, WasmWebClientError as i, WasmPipelineType as l, warmupWasm as n, initializeWasmWebClient as o, mlWasmJSApi_default as r, setWebApiHttpTransport as s, BaseWasmProvider as t, IdCaptureModelType as u };