@incodetech/core 2.0.1 → 2.1.0-rc.1

package/dist/{BrowserStorageProvider-CuOW1Er2.esm.js → BrowserStorageProvider-BpJM-gIl.esm.js}

@@ -1,3 +1,10 @@
+//#region ../infra/src/wasm/wasmDsFlagSync.ts
+function setWasmDsFlagSync(enabled) {
+	if (typeof localStorage === "undefined") return;
+	localStorage.setItem("ds", enabled ? "1" : "0");
+}
+
+//#endregion
 //#region ../infra/src/providers/browser/BrowserStorageProvider.ts
 /**
 * Browser-based storage provider wrapping localStorage.
@@ -52,4 +59,4 @@ var BrowserStorageProvider = class {
 };
 
 //#endregion
-export { BrowserStorageProvider as t };
+export { setWasmDsFlagSync as n, BrowserStorageProvider as t };

package/dist/{IpifyProvider-D7jx52AL.esm.js → IpifyProvider-D4LWD15E.esm.js}

@@ -60,6 +60,34 @@ var BrowserEnvironmentProvider = class {
 			ms: nav.msGetUserMedia !== void 0
 		};
 	}
+	getMaxTouchPoints() {
+		if (typeof navigator === "undefined") return 0;
+		return navigator.maxTouchPoints;
+	}
+	hasOnTouchStart() {
+		if (typeof window !== "undefined" && "ontouchstart" in window) return true;
+		if (typeof document !== "undefined") return "ontouchstart" in document.documentElement;
+		return false;
+	}
+	getNavigatorProductSub() {
+		if (typeof navigator === "undefined") return;
+		return navigator.productSub;
+	}
+	getEvalToStringLength() {
+		return eval.toString().length;
+	}
+	tryFirefoxToSource() {
+		try {
+			throw "a";
+		} catch (err) {
+			try {
+				err.toSource();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	}
 	async fetchJson(url, timeoutMs = 3e3) {
 		try {
 			if (typeof fetch === "undefined") return null;

package/dist/{MotionSensorProvider-4v7xkqAp.esm.js → MotionSensorProvider-Bx7Mpzt0.esm.js}

@@ -1,11 +1,25 @@
 //#region ../infra/src/providers/browser/MotionSensorProvider.ts
-var MotionSensorProvider = class {
+const MOTION_PERMISSION_GRANTED_KEY = "motionSensorsPermissionsGranted";
+const MOTION_PERMISSION_DENIED_KEY = "motionSensorsPermissionsDenied";
+var MotionSensorProvider = class MotionSensorProvider {
+	static isIosMotionPermissionRequired() {
+		return typeof DeviceMotionEvent !== "undefined" && typeof DeviceMotionEvent.requestPermission === "function";
+	}
+	static readSessionFlag(key) {
+		if (typeof sessionStorage === "undefined") return false;
+		return sessionStorage.getItem(key) === "true";
+	}
+	static hasMotionPermissionGrantedInSession() {
+		return MotionSensorProvider.readSessionFlag(MOTION_PERMISSION_GRANTED_KEY);
+	}
+	static hasMotionPermissionDeniedInSession() {
+		return MotionSensorProvider.readSessionFlag(MOTION_PERMISSION_DENIED_KEY);
+	}
 	constructor(thresholds) {
 		this._isRunning = false;
-		this._hasPermission = true;
 		this.acl = null;
 		this.gyro = null;
-		this.minNumberOfFrames = 3;
+		this.minNumberOfFrames = 10;
 		this.maxFrequency = 60;
 		this.emptyParams = {
 			meanX: 0,
@@ -71,6 +85,7 @@ var MotionSensorProvider = class {
 				this.updateParams(this.paramsOrientationOld, orientationVal);
 			}
 		};
+		this._hasPermission = MotionSensorProvider.isIosMotionPermissionRequired() ? MotionSensorProvider.hasMotionPermissionGrantedInSession() : true;
 		this.thresholds = {
 			accThreshold: thresholds?.accThreshold ?? .3,
 			gyroThreshold: thresholds?.gyroThreshold ?? .3,
@@ -92,21 +107,55 @@ var MotionSensorProvider = class {
 	get hasPermission() {
 		return this._hasPermission;
 	}
+	hasBeenRequestedThisSession() {
+		return MotionSensorProvider.hasMotionPermissionGrantedInSession();
+	}
+	hasMotionPermissionDeniedThisSession() {
+		return MotionSensorProvider.hasMotionPermissionDeniedInSession();
+	}
+	markMotionPermissionGrantedInSession() {
+		if (typeof sessionStorage === "undefined") return;
+		sessionStorage.setItem(MOTION_PERMISSION_GRANTED_KEY, String(true));
+		sessionStorage.removeItem(MOTION_PERMISSION_DENIED_KEY);
+		sessionStorage.setItem("motionSensorsPermissionsRequested", String(true));
+	}
+	markMotionPermissionDeniedInSession() {
+		if (typeof sessionStorage === "undefined") return;
+		sessionStorage.setItem(MOTION_PERMISSION_DENIED_KEY, String(true));
+		sessionStorage.removeItem(MOTION_PERMISSION_GRANTED_KEY);
+	}
+	syncSessionPermission() {
+		if (!MotionSensorProvider.isIosMotionPermissionRequired()) {
+			this._hasPermission = true;
+			return;
+		}
+		if (MotionSensorProvider.hasMotionPermissionGrantedInSession()) this._hasPermission = true;
+		else if (MotionSensorProvider.hasMotionPermissionDeniedInSession()) this._hasPermission = false;
+	}
 	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 {
+		if (!MotionSensorProvider.isIosMotionPermissionRequired()) return "not-required";
+		if (MotionSensorProvider.hasMotionPermissionGrantedInSession()) {
+			this._hasPermission = true;
+			return "granted";
+		}
+		if (MotionSensorProvider.hasMotionPermissionDeniedInSession()) {
+			this._hasPermission = false;
+			return "denied";
+		}
+		try {
+			if (await DeviceMotionEvent.requestPermission() !== "granted") {
 				this._hasPermission = false;
+				this.markMotionPermissionDeniedInSession();
 				return "denied";
 			}
+			this._hasPermission = true;
+			this.markMotionPermissionGrantedInSession();
+			return "granted";
+		} catch {
+			this._hasPermission = false;
+			this.markMotionPermissionDeniedInSession();
+			return "denied";
 		}
-		return "not-required";
 	}
 	initializeAccelerometer() {
 		if (!("Accelerometer" in window)) return;
@@ -129,6 +178,7 @@ var MotionSensorProvider = class {
 		} catch {}
 	}
 	async start() {
+		this.syncSessionPermission();
 		if (this._isRunning || !this._hasPermission) return;
 		try {
 			this.initializeAccelerometer();

package/dist/{OpenViduRecordingProvider-CMu6XVdc.esm.js → OpenViduRecordingProvider-O4GjBseO.esm.js}

@@ -1,4 +1,4 @@
-import { t as loadOpenVidu } from "./openviduLazy-Cok70ZSg.esm.js";
+import { t as loadOpenVidu } from "./openviduLazy-Dh14JNJc.esm.js";
 
 //#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
 function createHiddenContainer() {

package/dist/StateMachine-BC_nGvrc.d.ts

@@ -0,0 +1,2 @@
+import { AnyStateMachine, StateMachine, fromCallback, fromPromise } from "xstate";
+export { fromPromise as i, StateMachine as n, fromCallback as r, AnyStateMachine as t };

package/dist/StreamCanvasCapture-ImiDQdVA.esm.js

@@ -0,0 +1,118 @@
+import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
+
+//#region ../infra/src/media/StreamCanvasCapture.ts
+var StreamCanvasCapture = class {
+	constructor(stream, options) {
+		this.hasFrame = false;
+		this.disposed = false;
+		this.eventTarget = new EventTarget();
+		this.video = document.createElement("video");
+		this.video.srcObject = stream;
+		this.video.autoplay = true;
+		this.video.playsInline = true;
+		this.video.muted = true;
+		const settings = stream.getVideoTracks()[0]?.getSettings();
+		const initialWidth = options?.width ?? settings?.width ?? 1280;
+		const initialHeight = options?.height ?? settings?.height ?? 720;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = initialWidth;
+		this.canvas.height = initialHeight;
+		this.ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+		const fps = options?.fps ?? 10;
+		const intervalMs = fps > 0 ? Math.max(16, Math.floor(1e3 / fps)) : 0;
+		this.video.addEventListener("loadedmetadata", () => {
+			if (this.video.videoWidth > 0 && this.video.videoHeight > 0) {
+				this.canvas.width = this.video.videoWidth;
+				this.canvas.height = this.video.videoHeight;
+			}
+		});
+		try {
+			this.video.play();
+		} catch {}
+		this.rafLoop(intervalMs);
+	}
+	addEventListener(type, listener, options) {
+		this.eventTarget.addEventListener(type, listener, options);
+	}
+	removeEventListener(type, listener, options) {
+		this.eventTarget.removeEventListener(type, listener, options);
+	}
+	/**
+	* Returns the latest cached frame as an {@link IncodeCanvas}.
+	*/
+	getLatestCanvas() {
+		if (!this.hasFrame) this.tick();
+		if (!this.hasFrame) return null;
+		return new IncodeCanvas(this.canvas);
+	}
+	/**
+	* Returns the latest cached frame as raw {@link ImageData}.
+	*/
+	getLatestFrame() {
+		if (!this.ctx) return null;
+		if (!this.hasFrame) this.tick();
+		if (!this.hasFrame) return null;
+		try {
+			return this.ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Disposes internal resources and stops the capture loop.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.rafId !== void 0) {
+			window.cancelAnimationFrame(this.rafId);
+			this.rafId = void 0;
+		}
+		this.video.srcObject = null;
+		this.canvas.width = 0;
+		this.canvas.height = 0;
+		this.hasFrame = false;
+	}
+	rafLoop(intervalMs) {
+		const loop = (timeMs) => {
+			if (this.disposed) return;
+			if (intervalMs <= 0 || this.lastTickTimeMs === void 0 || timeMs - this.lastTickTimeMs >= intervalMs) {
+				this.lastTickTimeMs = timeMs;
+				const previousFrameTimeSeconds = this.lastFrameTimeSeconds;
+				this.tick();
+				const currentFrameTimeSeconds = this.video.currentTime;
+				if (previousFrameTimeSeconds === void 0) {
+					if (this.hasFrame) {
+						this.lastFrameTimeSeconds = currentFrameTimeSeconds;
+						this.eventTarget.dispatchEvent(new Event("frame"));
+					}
+				} else if (this.hasFrame && currentFrameTimeSeconds !== previousFrameTimeSeconds) {
+					this.lastFrameTimeSeconds = currentFrameTimeSeconds;
+					this.eventTarget.dispatchEvent(new Event("frame"));
+				}
+			}
+			this.rafId = window.requestAnimationFrame(loop);
+		};
+		this.rafId = window.requestAnimationFrame(loop);
+	}
+	tick() {
+		if (!this.ctx) return;
+		if (this.video.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) return;
+		const videoWidth = this.video.videoWidth;
+		const videoHeight = this.video.videoHeight;
+		if (videoWidth === 0 || videoHeight === 0) return;
+		if (this.canvas.width !== videoWidth || this.canvas.height !== videoHeight) {
+			this.canvas.width = videoWidth;
+			this.canvas.height = videoHeight;
+		}
+		try {
+			this.ctx.drawImage(this.video, 0, 0);
+			this.hasFrame = true;
+		} catch {
+			this.hasFrame = false;
+		}
+	}
+};
+
+//#endregion
+export { StreamCanvasCapture as t };

package/dist/StreamCanvasCapture-yyl20qd9.d.ts

@@ -0,0 +1,152 @@
+import { t as CameraStream } from "./camera-SRBpPq2X.js";
+
+//#region ../infra/src/media/canvas.d.ts
+/**
+ * Class representing a canvas element for image capture and manipulation.
+ */
+declare class IncodeCanvas {
+  canvas: HTMLCanvasElement;
+  private base64Image;
+  private blobData;
+  /**
+   * 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: ImageData): IncodeCanvas;
+  /**
+   * Create a new canvas element.
+   * @param canvas_ - The canvas element to clone.
+   */
+  constructor(canvas_: HTMLCanvasElement);
+  /**
+   * Check if the current canvas is valid.
+   */
+  private checkCanvas;
+  /**
+   * Disposes of resources, including revoking object URLs to prevent memory leaks.
+   */
+  dispose(): void;
+  /**
+   * Release the data stored by IncodeCanvas.
+   */
+  release(): void;
+  /**
+   * Revokes the object URL if one exists, preventing memory leaks.
+   * Use this when you no longer need the preview image URL.
+   */
+  revokeObjectURL(): void;
+  /**
+   * Get the width of the canvas.
+   */
+  width(): number | null;
+  /**
+   * Get the height of the canvas.
+   */
+  height(): number | null;
+  /**
+   * Set the width of the canvas.
+   */
+  setWidth(width: number): void;
+  /**
+   * Set the height of the canvas.
+   */
+  setHeight(height: number): void;
+  /**
+   * Clone the current canvas.
+   */
+  clone(): IncodeCanvas | null;
+  /**
+   * Deep clone the current IncodeCanvas including blob data.
+   */
+  deepClone(): Promise<IncodeCanvas | null>;
+  /**
+   * Returns the drawing context on the canvas.
+   */
+  getContext(contextId: '2d', contextAttributes?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
+  /**
+   * Retrieves the image data from the canvas.
+   */
+  getImageData(): ImageData | null;
+  /**
+   * Updates the base64 representation of the current canvas image.
+   */
+  updateBase64Image(jpegQuality?: number): void;
+  /**
+   * Converts the current canvas element to a base64 string.
+   */
+  getBase64Image(jpegQuality?: number, includeDataURLPrefix?: boolean): string | null;
+  /**
+   * Sets the base64 representation of the current canvas image.
+   */
+  setBase64Image(base64Image: string | null): void;
+  /**
+   * Updates the Blob representation of the current canvas image.
+   */
+  updateBlob(jpegQuality?: number, includeDataURLPrefix?: boolean): void;
+  /**
+   * Converts a base64 string to a Blob and creates a URL for it.
+   */
+  static base64ToBlob(base64: string): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Retrieves the Blob data and its URL from the current canvas.
+   */
+  getBlobData(jpegQuality?: number, includeDataURLPrefix?: boolean): {
+    blob: Blob;
+    url: string;
+  } | null;
+  /**
+   * Sets the Blob data of the current canvas image.
+   */
+  setBlobData(blobData: {
+    blob: Blob;
+    url: string;
+  }): Promise<void>;
+  /**
+   * Returns a resized canvas according to video element size.
+   */
+  getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
+}
+//#endregion
+//#region ../infra/src/media/StreamCanvasCapture.d.ts
+type StreamCanvasCaptureOptions = {
+  fps?: number;
+  width?: number;
+  height?: number;
+};
+type StreamCanvasCaptureEventMap = {
+  frame: Event;
+};
+declare class StreamCanvasCapture {
+  private video;
+  private canvas;
+  private ctx;
+  private rafId;
+  private lastFrameTimeSeconds;
+  private lastTickTimeMs;
+  private hasFrame;
+  private disposed;
+  private eventTarget;
+  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
+  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+  /**
+   * Returns the latest cached frame as an {@link IncodeCanvas}.
+   */
+  getLatestCanvas(): IncodeCanvas | null;
+  /**
+   * Returns the latest cached frame as raw {@link ImageData}.
+   */
+  getLatestFrame(): ImageData | null;
+  /**
+   * Disposes internal resources and stops the capture loop.
+   */
+  dispose(): void;
+  private rafLoop;
+  private tick;
+}
+//#endregion
+export { IncodeCanvas as n, StreamCanvasCapture as t };

package/dist/{BaseWasmProvider-C_DLEI40.esm.js → WasmUtilProvider-BKWm8rSA.esm.js}

@@ -1,3 +1,13 @@
+//#region ../infra/src/wasm/wasmPathUtils.ts
+function deriveSiblingJsPath(wasmPath) {
+	const index = wasmPath.lastIndexOf(".wasm");
+	if (index === -1) return wasmPath;
+	const rest = wasmPath.slice(index + 5);
+	if (rest !== "" && !rest.startsWith("?")) return wasmPath;
+	return `${wasmPath.slice(0, index)}.js${rest}`;
+}
+
+//#endregion
 //#region ../infra/src/providers/browser/SemaphoreProvider.ts
 const DEFAULT_ACQUIRE_TIMEOUT_MS = 3e4;
 /**
@@ -99,6 +109,26 @@ var SemaphoreProvider = class {
 
 //#endregion
 //#region ../infra/src/wasm/apiUtilities.ts
+/**
+* Shared WASM module loader.
+*
+* The pinned `webLib.wasm` (see `wasmDefaults.ts`) bundles BOTH the ML pipeline
+* APIs (used by `mlWasmJSApi.ts`) AND a C++ `WebClient` HTTP client (used by
+* `wasmWebClient.ts`). Both consumers must share a single instantiated
+* `wasmModule` — calling the glue `Module()` factory twice would re-instantiate
+* the WASM heap and produce divergent state.
+*
+* This module memoizes the load: the first caller (whichever arrives first —
+* ML init or HTTP init) triggers the fetch + glue load, and subsequent callers
+* await the same promise. Idempotent on success; on failure, the singleton is
+* cleared so the next caller retries.
+*
+* SIMD fallback mirrors the legacy behavior: try the SIMD binary + SIMD glue
+* (`webLibSimd.js` + `webLibSimd.wasm`) first, fall back to the non-SIMD pair
+* (`webLib.js` + `webLib.wasm`) on instantiation failure. Each binary MUST be
+* paired with its matching glue — the CDN ships them as paired artifacts and
+* mixing them produces an unusable module.
+*/
 if (typeof window !== "undefined" && window.wasmArrayBuffer === void 0) window.wasmArrayBuffer = null;
 let loadPromise = null;
 let loadedResult = null;
@@ -122,15 +152,6 @@ async function instantiate(factory, 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
@@ -690,6 +711,13 @@ var MlWasmJSApi = class MlWasmJSApi {
 		if (!this.modelsBuffers) await this.loadModels();
 		this.workflowApiUtilities.initializeWorkflows();
 	}
+	/**
+	* Sets the native (C++) utility API's production mode. When `true`, the WASM
+	* module suppresses its verbose debug logging; when `false`, it emits it.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	* @throws If the WASM C++ API has not been initialized yet.
+	*/
 	async setProductionMode(productionMode) {
 		this.checkWasmInitialization("Unable to set production mode, cpp API hasn't been initialized");
 		this.utilityApi.setProductionMode(productionMode);
@@ -752,12 +780,32 @@ var MlWasmJSApi = class MlWasmJSApi {
 	}
 	async prc() {
 		this.checkWasmInitialization("Unable to prc, cpp API hasn't been initialized");
-		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.prc(), true);
+		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.prc(false), true);
 	}
 	async poc(output) {
 		this.checkWasmInitialization("Unable to poc, cpp API hasn't been initialized");
 		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.poc(output), true);
 	}
+	async rsp() {
+		this.checkWasmInitialization("Unable to rsp, cpp API hasn't been initialized");
+		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.rsp(), true);
+	}
+	ssl() {
+		this.checkWasmInitialization("Unable to ssl, cpp API hasn't been initialized");
+		this.utilityApi.ssl();
+	}
+	stl() {
+		this.checkWasmInitialization("Unable to stl, cpp API hasn't been initialized");
+		this.utilityApi.stl();
+	}
+	osv() {
+		this.checkWasmInitialization("Unable to set sensor beginning timestamp, cpp API hasn't been initialized");
+		this.utilityApi.osv();
+	}
+	oev() {
+		this.checkWasmInitialization("Unable to set sensor ending timestamp, cpp API hasn't been initialized");
+		this.utilityApi.oev();
+	}
 	ckvcks(data) {
 		this.checkWasmInitialization("Unable to ckvcks, cpp API hasn't been initialized");
 		this.utilityApi.ckvcks(data);
@@ -1115,4 +1163,147 @@ var BaseWasmProvider = class {
 };
 
 //#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 };
+//#region ../infra/src/providers/wasm/WasmUtilProvider.ts
+var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
+	static async getInstance() {
+		if (WasmUtilProvider.instance) return WasmUtilProvider.instance;
+		if (WasmUtilProvider.initPromise) return WasmUtilProvider.initPromise;
+		WasmUtilProvider.initPromise = (async () => {
+			const instance = new WasmUtilProvider();
+			await instance.initializeBase({}, "selfie");
+			WasmUtilProvider.instance = instance;
+			return instance;
+		})();
+		return WasmUtilProvider.initPromise;
+	}
+	static resetInstance() {
+		WasmUtilProvider.instance = void 0;
+		WasmUtilProvider.initPromise = void 0;
+	}
+	constructor() {
+		super(void 0);
+	}
+	async initialize(config) {
+		if (this.initialized) return;
+		const pipeline = config.pipelines?.[0] ?? "selfie";
+		await this.initializeBase(config, pipeline);
+	}
+	async processFrame(_image) {
+		throw new Error("WasmUtilProvider does not support frame processing. Use encryptImage() instead.");
+	}
+	encryptImage(image) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.ens(image);
+	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setBackgroundMode(backgroundMode);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.setInspectorOpened(opened);
+	}
+	/**
+	* Toggles the WASM module's production mode. When `true`, the native module
+	* suppresses its verbose debug logging/console output; when `false`, those
+	* logs are emitted. The SDK forces this to `true` by default and only flips
+	* it off when the caller opts in via `setup({ wasm: { showLogs: true } })`.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	*/
+	async setProductionMode(productionMode) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.setProductionMode(productionMode);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getCheck();
+	}
+	getPipelineState() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getPipelineState();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.isVirtualCamera(label);
+	}
+	async prc() {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.prc();
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.poc(output);
+	}
+	async rsp() {
+		this.ensureInitialized();
+		await mlWasmJSApi_default.rsp();
+	}
+	ssl() {
+		this.ensureInitialized();
+		mlWasmJSApi_default.ssl();
+	}
+	stl() {
+		this.ensureInitialized();
+		mlWasmJSApi_default.stl();
+	}
+	osv() {
+		this.ensureInitialized();
+		mlWasmJSApi_default.osv();
+	}
+	oev() {
+		this.ensureInitialized();
+		mlWasmJSApi_default.oev();
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		mlWasmJSApi_default.ckvcks(data);
+	}
+	async getVersions() {
+		this.ensureInitialized();
+		return mlWasmJSApi_default.getVersions();
+	}
+};
+
+//#endregion
+export { WasmWebClientError as a, setWebApiHttpTransport as c, IdCaptureModelType as d, deriveSiblingJsPath as f, mlWasmJSApi_default as i, setupWasmConnection as l, BaseWasmProvider as n, executeWasmRequest as o, warmupWasm as r, initializeWasmWebClient as s, WasmUtilProvider as t, WasmPipelineType as u };