@incodetech/core 0.0.0-dev-20260402-682edb5 → 0.0.0-dev-20260402-7cf9db4

package/dist/BaseWasmProvider-BFXU7jj8.esm.js

@@ -0,0 +1,1536 @@
+import { t as isBrowserSimulation } from "./browserSimulation-zWJAZ1vA.esm.js";
+import { t as api } from "./api-3fZO5bmj.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-D-MPXRbZ.esm.js";
+import { t as addDeviceStats } from "./stats-D4C7iDy1.esm.js";
+
+//#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, 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, isIdFaceQualityCheckEnabled, 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 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) {
+			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/device/getBrowser.ts
+function getUserAgent() {
+	if (typeof navigator === "undefined") return "";
+	return navigator.userAgent;
+}
+
+//#endregion
+//#region ../infra/src/device/getDeviceClass.ts
+function getDeviceInfo() {
+	if (typeof navigator === "undefined") return {
+		userAgent: "",
+		platform: "",
+		maxTouchPoints: 0
+	};
+	return {
+		userAgent: navigator.userAgent,
+		platform: navigator.platform,
+		maxTouchPoints: navigator.maxTouchPoints
+	};
+}
+/**
+* Gets the current window dimensions.
+* Returns default values (1280x720) in non-browser environments.
+*/
+function getWindowDimensions(defaultWidth = 1280, defaultHeight = 720) {
+	if (typeof window === "undefined") return {
+		outerWidth: defaultWidth,
+		outerHeight: defaultHeight,
+		innerWidth: defaultWidth,
+		innerHeight: defaultHeight
+	};
+	return {
+		outerWidth: window.outerWidth,
+		outerHeight: window.outerHeight,
+		innerWidth: window.innerWidth,
+		innerHeight: window.innerHeight
+	};
+}
+
+//#endregion
+//#region ../infra/src/media/canvas.ts
+/**
+* Class representing a canvas element for image capture and manipulation.
+*/
+var IncodeCanvas = class IncodeCanvas {
+	/**
+	* Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
+	* @param imageData - Frame pixels in RGBA format
+	* @returns An {@link IncodeCanvas} containing the provided pixels
+	*/
+	static fromImageData(imageData) {
+		const canvas = document.createElement("canvas");
+		canvas.width = imageData.width;
+		canvas.height = imageData.height;
+		const context = canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return new IncodeCanvas(canvas);
+		if ("putImageData" in context) context.putImageData(imageData, 0, 0);
+		return new IncodeCanvas(canvas);
+	}
+	/**
+	* Create a new canvas element.
+	* @param canvas_ - The canvas element to clone.
+	*/
+	constructor(canvas_) {
+		this.base64Image = null;
+		this.blobData = null;
+		this.canvas = document.createElement("canvas");
+		this.canvas.width = canvas_.width;
+		this.canvas.height = canvas_.height;
+		const context = this.canvas.getContext("2d");
+		if (context) context.drawImage(canvas_, 0, 0);
+	}
+	/**
+	* Check if the current canvas is valid.
+	*/
+	checkCanvas() {
+		return this.canvas && this.canvas.width > 1 && this.canvas.height > 1;
+	}
+	/**
+	* Disposes of resources, including revoking object URLs to prevent memory leaks.
+	*/
+	dispose() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = null;
+		}
+		this.base64Image = null;
+	}
+	/**
+	* Release the data stored by IncodeCanvas.
+	*/
+	release() {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = 1;
+		this.canvas.height = 1;
+		this.canvas.getContext("2d")?.clearRect(0, 0, 1, 1);
+		this.base64Image = null;
+		if (this.blobData?.url) URL.revokeObjectURL(this.blobData.url);
+		this.blobData = null;
+	}
+	/**
+	* Revokes the object URL if one exists, preventing memory leaks.
+	* Use this when you no longer need the preview image URL.
+	*/
+	revokeObjectURL() {
+		if (this.blobData?.url) {
+			URL.revokeObjectURL(this.blobData.url);
+			this.blobData = {
+				...this.blobData,
+				url: ""
+			};
+		}
+	}
+	/**
+	* Get the width of the canvas.
+	*/
+	width() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.width;
+	}
+	/**
+	* Get the height of the canvas.
+	*/
+	height() {
+		if (!this.checkCanvas()) return null;
+		return this.canvas.height;
+	}
+	/**
+	* Set the width of the canvas.
+	*/
+	setWidth(width) {
+		if (!this.checkCanvas()) return;
+		this.canvas.width = width;
+	}
+	/**
+	* Set the height of the canvas.
+	*/
+	setHeight(height) {
+		if (!this.checkCanvas()) return;
+		this.canvas.height = height;
+	}
+	/**
+	* Clone the current canvas.
+	*/
+	clone() {
+		if (!this.checkCanvas()) return null;
+		const cloned = new IncodeCanvas(this.canvas);
+		cloned.setBase64Image(this.base64Image);
+		return cloned;
+	}
+	/**
+	* Deep clone the current IncodeCanvas including blob data.
+	*/
+	async deepClone() {
+		const cloned = this.clone();
+		if (!cloned) return null;
+		if (this.blobData) await cloned.setBlobData(this.blobData);
+		return cloned;
+	}
+	/**
+	* Returns the drawing context on the canvas.
+	*/
+	getContext(contextId, contextAttributes) {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext(contextId, contextAttributes);
+		return context instanceof CanvasRenderingContext2D ? context : null;
+	}
+	/**
+	* Retrieves the image data from the canvas.
+	*/
+	getImageData() {
+		if (!this.checkCanvas()) return null;
+		const context = this.canvas.getContext("2d", { willReadFrequently: true });
+		if (!context) return null;
+		return context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+	}
+	/**
+	* Updates the base64 representation of the current canvas image.
+	*/
+	updateBase64Image(jpegQuality = 1) {
+		if (!this.checkCanvas()) return;
+		this.base64Image = this.canvas.toDataURL("image/jpeg", jpegQuality);
+	}
+	/**
+	* Converts the current canvas element to a base64 string.
+	*/
+	getBase64Image(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64Image = this.base64Image;
+		if (base64Image === null) return null;
+		if (includeDataURLPrefix) return base64Image;
+		const commaIndex = base64Image.indexOf(",");
+		if (commaIndex === -1) return base64Image;
+		return base64Image.slice(commaIndex + 1);
+	}
+	/**
+	* Sets the base64 representation of the current canvas image.
+	*/
+	setBase64Image(base64Image) {
+		this.base64Image = base64Image;
+	}
+	/**
+	* Updates the Blob representation of the current canvas image.
+	*/
+	updateBlob(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return;
+		if (this.base64Image === null) this.updateBase64Image(jpegQuality);
+		const base64 = this.getBase64Image(jpegQuality, includeDataURLPrefix);
+		if (base64) this.blobData = IncodeCanvas.base64ToBlob(base64);
+	}
+	/**
+	* Converts a base64 string to a Blob and creates a URL for it.
+	*/
+	static base64ToBlob(base64) {
+		try {
+			const binary = atob(base64);
+			const array = [];
+			for (let i = 0; i < binary.length; i++) array.push(binary.charCodeAt(i));
+			const blob = new Blob([new Uint8Array(array)]);
+			return {
+				blob,
+				url: URL.createObjectURL(blob)
+			};
+		} catch (error) {
+			console.error("Failed to convert base64 string to Blob:", error);
+		}
+		return null;
+	}
+	/**
+	* Retrieves the Blob data and its URL from the current canvas.
+	*/
+	getBlobData(jpegQuality = 1, includeDataURLPrefix = false) {
+		if (!this.checkCanvas()) return null;
+		if (this.blobData === null) this.updateBlob(jpegQuality, includeDataURLPrefix);
+		return this.blobData;
+	}
+	/**
+	* Sets the Blob data of the current canvas image.
+	*/
+	async setBlobData(blobData) {
+		const blobDataArrayBuffer = await blobData.blob.arrayBuffer();
+		this.blobData = {
+			blob: new Blob([blobDataArrayBuffer], { type: blobData.blob.type }),
+			url: blobData.url
+		};
+	}
+	/**
+	* Returns a resized canvas according to video element size.
+	*/
+	getResizedCanvas(videoElementWidth, videoElementHeight) {
+		if (!this.checkCanvas()) return null;
+		const cameraOffsetX = Math.abs(videoElementWidth - window.innerWidth);
+		const resized = new IncodeCanvas(document.createElement("canvas"));
+		const canvasHeight = this.height();
+		if (!canvasHeight) return null;
+		const ratio = canvasHeight / videoElementHeight;
+		const newWidth = window.innerWidth;
+		const newHeight = window.innerHeight;
+		resized.setWidth(newWidth);
+		resized.setHeight(newHeight);
+		const context = resized.getContext("2d");
+		if (!context) return null;
+		context.drawImage(this.canvas, ratio * cameraOffsetX / 2, 0, ratio * newWidth, ratio * newHeight, 0, 0, newWidth, newHeight);
+		return resized;
+	}
+};
+
+//#endregion
+//#region ../infra/src/media/video.ts
+/**
+* Creates a hidden video element for a stream and appends it to document.body.
+*/
+function createHiddenVideoElement(stream) {
+	if (typeof document === "undefined") throw new Error("Document not available");
+	const video = document.createElement("video");
+	video.autoplay = true;
+	video.playsInline = true;
+	video.muted = true;
+	video.srcObject = stream;
+	video.style.width = "0px";
+	video.style.height = "0px";
+	video.style.position = "absolute";
+	video.style.top = "0";
+	video.style.left = "0";
+	video.style.zIndex = "-1";
+	document.body.appendChild(video);
+	return {
+		element: video,
+		dispose: () => {
+			video.srcObject = null;
+			if (video.parentElement) video.parentElement.removeChild(video);
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/metadataService.ts
+const IP_PROVIDER_URL = "https://api.ipify.org?format=json";
+async function fetchPublicIp(browserEnv) {
+	return (await browserEnv.fetchJson(IP_PROVIDER_URL, 3e3))?.ip || "";
+}
+function createMetadataService(wasmUtil, visibility, browserEnv) {
+	return {
+		async initialize(sdkVersion, disableIpify = false) {
+			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkVersion(sdkVersion);
+			const ua = getUserAgent();
+			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const deviceInfo = getDeviceInfo();
+			const visitorId = browserEnv.generateCanvasFingerprint();
+			const ip = disableIpify ? "" : await fetchPublicIp(browserEnv);
+			const screenDimensions = browserEnv.getScreenDimensions();
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model: "",
+				os: void 0,
+				osVersion: void 0,
+				screenDimensions,
+				numTouchPoints: deviceInfo.maxTouchPoints,
+				fingerprintHash: visitorId,
+				ip,
+				backgroundMode: false
+			};
+			wasmUtil.setDeviceInfo(deviceMetadata);
+			const navigatorPrefixes = browserEnv.getNavigatorPrefixes();
+			const browserInfo = {
+				userAgent: ua,
+				getUserMediaAvailability: {
+					webkit: navigatorPrefixes.webkit,
+					moz: navigatorPrefixes.moz,
+					o: navigatorPrefixes.o,
+					ms: navigatorPrefixes.ms
+				},
+				webglFingerprint: browserEnv.getWebGLRenderer(),
+				inspectorOpened: false,
+				isMockedBrowser: isBrowserSimulation(browserEnv)
+			};
+			wasmUtil.setBrowserInfo(browserInfo, false);
+		},
+		updateCameraInfo(videoTrack) {
+			const settings = videoTrack.getSettings();
+			const capabilities = videoTrack.getCapabilities?.() ?? {};
+			const labels = videoTrack.label ? [videoTrack.label] : [];
+			const cameraInfo = {
+				facingMode: settings.facingMode === "user" ? "frontal" : settings.facingMode === "environment" ? "back" : settings.facingMode || "unknown",
+				settings,
+				capabilities,
+				labels
+			};
+			wasmUtil.setCameraInfo(cameraInfo);
+		},
+		async checkForVirtualCameraByLabel(videoTrack = null) {
+			try {
+				if (!videoTrack) {
+					const labels = await browserEnv.enumerateVideoDeviceLabels();
+					for (const label of labels) if (wasmUtil.isVirtualCamera(label)) return true;
+				}
+				if (videoTrack && wasmUtil.isVirtualCamera(videoTrack.label)) return true;
+				return false;
+			} catch {
+				return false;
+			}
+		},
+		async analyzeFrame(imageData) {
+			await wasmUtil.analyzeFrame(imageData);
+		},
+		setMotionStatus(status) {
+			wasmUtil.setMotionStatus(status);
+		},
+		setBackgroundMode(backgroundMode) {
+			wasmUtil.setBackgroundMode(backgroundMode || visibility.wasBackgrounded);
+			visibility.reset();
+		},
+		estimatePerformance() {
+			return wasmUtil.estimatePerformance();
+		},
+		getMetadata() {
+			return wasmUtil.getMetadata();
+		},
+		getCheck() {
+			return wasmUtil.getCheck();
+		},
+		getPipelineState() {
+			return wasmUtil.getPipelineState();
+		},
+		preparePipelineState() {
+			wasmUtil.getPipelineState();
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/motionStatusService.ts
+function createMotionStatusService(motionSensor) {
+	return {
+		async requestPermission() {
+			return motionSensor.requestPermission();
+		},
+		async start() {
+			await motionSensor.start();
+		},
+		stop() {
+			motionSensor.stop();
+		},
+		check() {
+			return motionSensor.check();
+		},
+		get isRunning() {
+			return motionSensor.isRunning;
+		},
+		get hasPermission() {
+			return motionSensor.hasPermission;
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/virtualCameraCheck.ts
+/**
+* Sends the analyzed frame image to the backend for logging.
+*/
+async function logFrame({ source, base64Image, token }) {
+	try {
+		return (await api.post("/omni/log/frame/v2", { base64Image }, {
+			query: { source },
+			headers: { "X-Incode-Hardware-Id": token }
+		})).data;
+	} catch {
+		return;
+	}
+}
+/**
+* Runs the WASM virtual camera check and handles logging and stats.
+*/
+async function runVirtualCameraCheck({ wasmUtil, source, token }) {
+	const output = {
+		canvas: null,
+		itr: null,
+		skipped: null
+	};
+	await wasmUtil.poc(output);
+	if (output.skipped !== false) return;
+	if (output.canvas && token) {
+		const base64Image = new IncodeCanvas(output.canvas).getBase64Image();
+		if (base64Image) await logFrame({
+			source,
+			base64Image,
+			token
+		});
+	}
+	if (output.itr === true) {
+		addDeviceStats({ virtualCameraDetected: true });
+		wasmUtil.setZc("FAIL");
+	} else if (output.itr === false) wasmUtil.setZc("PASS");
+}
+
+//#endregion
+//#region src/internal/deepsight/deepsightService.ts
+function createDeepsightService(config) {
+	const metadata = createMetadataService(config.wasmUtil, config.visibility, config.browserEnv);
+	const motion = createMotionStatusService(config.motionSensor);
+	return {
+		metadata,
+		motion,
+		async initialize(disableIpify = false) {
+			await metadata.initialize(config.sdkVersion, disableIpify);
+			metadata.estimatePerformance();
+		},
+		async requestMotionPermission() {
+			return motion.requestPermission();
+		},
+		async startMotionSensors() {
+			await motion.start();
+		},
+		stopMotionSensors() {
+			motion.stop();
+		},
+		async checkVirtualCamera(videoTrack) {
+			metadata.updateCameraInfo(videoTrack);
+			return metadata.checkForVirtualCameraByLabel(videoTrack);
+		},
+		async performVirtualCameraCheck(sessionToken, source) {
+			await runVirtualCameraCheck({
+				wasmUtil: config.wasmUtil,
+				source,
+				token: sessionToken
+			});
+		},
+		async performPrcCheck(params) {
+			const prcStream = await requestCameraAccess(params.constraints);
+			const hiddenVideo = createHiddenVideoElement(prcStream);
+			try {
+				await config.wasmUtil.prc();
+			} finally {
+				hiddenVideo.dispose();
+				stopCameraStream(prcStream);
+			}
+		},
+		async analyzeFrame(imageData) {
+			await metadata.analyzeFrame(imageData);
+			metadata.preparePipelineState();
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+		},
+		getMetadata() {
+			return metadata.getMetadata();
+		},
+		getMotionStatus() {
+			return motion.check();
+		},
+		getAnalysisStatus() {
+			return metadata.getCheck();
+		},
+		getPipelineState() {
+			return metadata.getPipelineState();
+		},
+		cleanup() {
+			motion.stop();
+		}
+	};
+}
+
+//#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/wasm/BaseWasmProvider.ts
+/**
+* Base provider class that abstracts common WASM functionality.
+* This serves as a foundation for specific ML capability providers
+* like FaceDetectionProvider and IdCaptureProvider.
+*/
+var BaseWasmProvider = class {
+	/**
+	* Creates a new BaseWasmProvider
+	* @param pipelineType - The WASM pipeline type this provider uses
+	*/
+	constructor(pipelineType) {
+		this._isInitialized = false;
+		this.pipelineType = pipelineType;
+	}
+	/**
+	* Returns whether this provider has been initialized.
+	*/
+	get initialized() {
+		return this._isInitialized;
+	}
+	getPipelineType() {
+		if (this.pipelineType === void 0) throw new Error(`${this.constructor.name} has no pipeline type configured.`);
+		return this.pipelineType;
+	}
+	/**
+	* Initializes the provider by ensuring WASM is loaded
+	* @param config - Provider configuration
+	* @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+	*/
+	async initializeBase(config, pipeline) {
+		if (this._isInitialized) return;
+		if (getWasmStatus().isLoading || isWasmReady()) await waitForWasm();
+		else {
+			if (!config.wasmPath || !config.glueCodePath) throw new Error("WASM path and glue code path are required. Call warmupWasm() first.");
+			await warmupWasm({
+				wasmPath: config.wasmPath,
+				wasmSimdPath: config.wasmSimdPath,
+				glueCodePath: config.glueCodePath,
+				useSimd: config.useSimd,
+				modelsBasePath: config.modelsBasePath,
+				pipelines: [pipeline]
+			});
+		}
+		this._isInitialized = true;
+	}
+	/**
+	* Ensures the provider is initialized before performing operations.
+	* @throws Error if not initialized
+	*/
+	ensureInitialized() {
+		if (!this._isInitialized) throw new Error(`${this.constructor.name} not initialized. Call initialize() first.`);
+	}
+	/**
+	* Processes a frame through the WASM pipeline
+	* @param image - Image data to process
+	* @returns The pipeline result (type depends on pipeline - WASM returns any)
+	*/
+	async processFrameWasm(image) {
+		this.ensureInitialized();
+		const pipelineType = this.getPipelineType();
+		await mlWasmJSApi_default.allocateImageBuffers(image.width, image.height);
+		await mlWasmJSApi_default.handleDetectionCallAndUpdateState(pipelineType);
+		return await mlWasmJSApi_default.process(image, pipelineType);
+	}
+	/**
+	* Resets the pipeline to its initial state.
+	* Safe to call even if not initialized (no-op in that case).
+	*/
+	reset() {
+		if (this._isInitialized && this.pipelineType !== void 0) mlWasmJSApi_default.resetPipeline(this.pipelineType);
+	}
+	/**
+	* Disposes of resources and resets initialization state.
+	* Safe to call even if not initialized.
+	*/
+	async dispose() {
+		this.reset();
+		this._isInitialized = false;
+	}
+};
+
+//#endregion
+export { getDeviceInfo as a, warmupWasm as c, IdCaptureModelType as d, IncodeCanvas as i, mlWasmJSApi_default as l, MotionSensorProvider as n, getWindowDimensions as o, createDeepsightService as r, getUserAgent as s, BaseWasmProvider as t, WasmPipelineType as u };