@incodetech/core 0.0.0-dev-20260826-e81bd6f9 → 0.0.0-dev-20260826-80a51538

package/dist/{safeStorage-2nOSCCnG.esm.js → safeStorage-7CmStgyt.esm.js}

@@ -1,7 +1,48 @@
-import { c as loadWasmModule, g as resolveWasmSource, h as missingWasmModelError, l as SemaphoreProvider, n as createWebApiHostAdapter, p as WASM_PIPELINE_MODELS, s as wasmCallWrapper } from "./wasmWebClient-BzFsDjU6.esm.js";
-var mlWasmJSApi_default = class MlWasmJSApi {
-	constructor() {
-		this.versionsFile = null;
+import { _ as resolveWasmSource, c as wasmCallWrapper, g as missingWasmModelError, l as loadWasmModule, m as WASM_PIPELINE_MODELS, n as createWebApiHostAdapter, s as ML_CALL_MAX_POLLS, u as SemaphoreProvider } from "./wasmWebClient-BJCaFeBL.esm.js";
+//#region ../infra/src/wasm/wasmEnumMaps.ts
+function pipelineTypeToWasmEnum(wasmModule, type) {
+	switch (type) {
+		case 0: return wasmModule.WorkflowType.IdBlurGlareWorkflow;
+		case 1: return wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow;
+		case 2: return wasmModule.WorkflowType.IdVideoSelfieWorkflow;
+		case 3: return wasmModule.WorkflowType.SelfieWithAggregationMetrics;
+		case 4: return wasmModule.WorkflowType.SelfieWithQualityMetrics;
+		case 5: return wasmModule.WorkflowType.OnDeviceSelfieWorkflow;
+		default: throw new Error("Unknown pipeline type");
+	}
+}
+function pipelineTypeFromWasmEnum(wasmModule, type) {
+	switch (type) {
+		case wasmModule.WorkflowType.IdBlurGlareWorkflow: return 0;
+		case wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow: return 1;
+		case wasmModule.WorkflowType.IdVideoSelfieWorkflow: return 2;
+		case wasmModule.WorkflowType.SelfieWithAggregationMetrics: return 3;
+		case wasmModule.WorkflowType.SelfieWithQualityMetrics: return 4;
+		case wasmModule.WorkflowType.OnDeviceSelfieWorkflow: return 5;
+		default: throw new Error("Unknown pipeline type");
+	}
+}
+function idCaptureModelTypeToWasmEnum(wasmModule, type) {
+	switch (type) {
+		case 0: return wasmModule.IdCaptureModelType.IdCaptureV1x;
+		case 1: return wasmModule.IdCaptureModelType.IdCaptureV2x;
+		case 2: return wasmModule.IdCaptureModelType.IdCaptureV3x;
+		default: throw new Error("Unknown Id Capture model type");
+	}
+}
+function idCaptureModelTypeFromWasmEnum(wasmModule, type) {
+	switch (type) {
+		case wasmModule.IdCaptureModelType.IdCaptureV1x: return 0;
+		case wasmModule.IdCaptureModelType.IdCaptureV2x: return 1;
+		case wasmModule.IdCaptureModelType.IdCaptureV3x: return 2;
+		default: throw new Error("Unknown Id Capture model type");
+	}
+}
+//#endregion
+//#region ../infra/src/wasm/WasmRuntime.ts
+var WasmRuntime = class WasmRuntime {
+	constructor(loadModule = loadWasmModule) {
+		this.loadModule = loadModule;
 		this.modelsBuffers = null;
 		this.inputImageBuffer = null;
 		this.wasmModule = null;
@@ -14,19 +55,14 @@ var mlWasmJSApi_default = class MlWasmJSApi {
 		this.imageHeight_ = null;
 		this.pipelines_ = null;
 		this.isInitialized_ = false;
-		this.inspectorOpened_ = false;
 		this.onDeviceMode_ = false;
-		this.dsEnabled_ = false;
-		this.wasmCallSemaphore = new SemaphoreProvider();
-		this.Module = null;
+		this.mlCallSemaphore = new SemaphoreProvider();
 	}
-	async initialize({ module, versionsFile, pipelines }) {
+	async initialize({ module, pipelines }) {
 		await this.freeResources();
 		this.pipelines_ = pipelines;
-		this.versionsFile = versionsFile;
-		const { wasmModule, simdUsed } = await loadWasmModule(module);
+		const { wasmModule, simdUsed } = await this.loadModule(module);
 		this.wasmModule = wasmModule;
-		this.Module = window.Module;
 		this.workflowApiUtilities = new this.wasmModule.WorkflowApiUtilities();
 		this.utilityApi = new this.wasmModule.UtilityApi();
 		this.utilityApi.setOnDeviceMode(this.onDeviceMode_);
@@ -36,10 +72,6 @@ var mlWasmJSApi_default = class MlWasmJSApi {
 		this.isInitialized_ = true;
 		return simdUsed;
 	}
-	static getInstance() {
-		if (!MlWasmJSApi.instance) MlWasmJSApi.instance = new MlWasmJSApi();
-		return MlWasmJSApi.instance;
-	}
 	/**
 	* Returns initialization status
 	* @returns
@@ -54,46 +86,43 @@ var mlWasmJSApi_default = class MlWasmJSApi {
 	* @param {number} imageHeight - image height
 	*/
 	async allocateImageBuffers(imageWidth, imageHeight) {
-		this.checkWasmInitialization("Unable to allocate image buffers, cpp API hasn't been initialized");
+		const workflowApiUtilities = this.requireWorkflowApiUtilities("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();
+		this.inputImageBuffer = workflowApiUtilities.allocateInputImageBuffer(imageWidth, imageHeight, 4);
 	}
-	async analyzeFrame(image) {
-		this.checkWasmInitialization("Unable to analyze the frame, cpp API hasn't been initialized");
-		await this.allocateImageBuffers(image.width, image.height);
+	/**
+	* Copies one frame into the shared input image buffer.
+	*
+	* The only write path into `inputImageBuffer`, so no caller outside this class
+	* touches the field. It is the guard + `set()` pair that `process`,
+	* `runIdCapture`, `runSelfieCapture` and `analyzeFrame` each performed inline,
+	* including the error message: semantically identical at all four sites, and
+	* byte-identical at three. `analyzeFrame`'s local capture (`const
+	* inputImageBuffer = this.inputImageBuffer`, then `.set()` on the local) is
+	* folded into a double read of the field, which cannot observe two different
+	* values because nothing awaits between the guard and the `set()`.
+	*
+	* Buffers must already be sized by {@link allocateImageBuffers}.
+	*/
+	writeFrame(image) {
+		if (this.inputImageBuffer === null) throw new Error("Unable to process the image, buffers haven't been allocated!");
 		this.inputImageBuffer.set(image.data);
-		this.utilityApi.analyzeFrame();
+	}
+	async handleDetectionCallAndUpdateState(type) {
+		this.requireWorkflowApiUtilities("Unable to update pipeline state, cpp API hasn't been initialized").handleDetectionCallAndUpdateState(this.pipelineTypeToWasmEnum(type));
 	}
 	/**
 	* 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 (typeof window !== "undefined") window.wasmArrayBuffer = null;
 		if (this.workflowApiUtilities && typeof this.workflowApiUtilities.delete === "function") {
 			this.workflowApiUtilities.delete();
 			this.workflowApiUtilities = null;
@@ -119,29 +148,15 @@ var mlWasmJSApi_default = class MlWasmJSApi {
 	* Clear pipeline state
 	*/
 	resetPipeline(type) {
-		this.checkWasmInitialization("Unable to reset pipeline, cpp API hasn't been initialized");
-		this.workflowApiUtilities.resetWorkflow(this.pipelineTypeToWasmEnum(type));
+		this.requireWorkflowApiUtilities("Unable to reset pipeline, cpp API hasn't been initialized").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();
+		const pipelines = this.pipelines_;
+		if (!this.isInitialized() || pipelines === null) throw new Error("Unable to reset pipelines, cpp API hasn't been initialized");
+		for (const [type] of pipelines) this.resetPipeline(type);
 	}
 	/**
 	* Process one frame using one of the pipelines
@@ -150,317 +165,136 @@ var mlWasmJSApi_default = class MlWasmJSApi {
 	* @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);
+		const message = "Unable to process the image, cpp API hasn't been initialized";
+		const idCaptureWasmApi = this.requireIdCaptureApi(message);
+		const faceProcessingWasmApi = this.requireFaceProcessingApi(message);
+		this.writeFrame(image);
 		switch (type) {
 			case 0:
-			case 1: return this.idCaptureWasmApi.runIdCaptureWorkflow(this.pipelineTypeToWasmEnum(type));
-			case 2: return this.idCaptureWasmApi.runIdVideoSelfieWorkflow();
+			case 1: return idCaptureWasmApi.runIdCaptureWorkflow(this.pipelineTypeToWasmEnum(type));
+			case 2: return idCaptureWasmApi.runIdVideoSelfieWorkflow();
 			case 3:
 			case 4:
-			case 5: return this.faceProcessingWasmApi.runSelfieWorkflow(this.pipelineTypeToWasmEnum(type));
+			case 5: return 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));
-	}
-	setIdBarcodeCaptureEnabled(pipelineType, enabled) {
-		this.checkWasmInitialization("Unable to set barcode capture enabled, cpp API hasn't been initialized");
-		this.idCaptureWasmApi.setIdBarcodeCaptureEnabled(this.pipelineTypeToWasmEnum(pipelineType), enabled);
-	}
-	setIdBarcodeAutoCaptureOnDecode(pipelineType, enabled) {
-		this.checkWasmInitialization("Unable to set barcode auto-capture-on-decode, cpp API hasn't been initialized");
-		this.idCaptureWasmApi.setIdBarcodeAutoCaptureOnDecode(this.pipelineTypeToWasmEnum(pipelineType), enabled);
-	}
-	setIdBarcodeDecodedCallback(pipelineType, onBarcodeDecoded) {
-		this.checkWasmInitialization("Unable to set barcode decoded callback, cpp API hasn't been initialized");
-		this.idCaptureWasmApi.setIdBarcodeDecodedCallback(this.pipelineTypeToWasmEnum(pipelineType), onBarcodeDecoded);
-	}
-	async setIdBarcodeEnhancementModel(pipelineType, modelPath) {
-		this.checkWasmInitialization("Unable to set barcode enhancement model, cpp API hasn't been initialized");
-		const buffer = await resolveWasmSource(modelPath, "barcode model");
-		return this.idCaptureWasmApi.setBarcodeEnhancementModel(this.pipelineTypeToWasmEnum(pipelineType), buffer);
-	}
-	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 message = "Unable load the models, cpp API hasn't been initialized";
+		const buffSizes = new (this.requireWasmModule(message)).WorkflowTypeToIntMap();
 		const modelData = /* @__PURE__ */ new Map();
 		const loadedModels = /* @__PURE__ */ new Map();
-		for (const [type, modelsPaths] of this.pipelines_) {
+		const sizeVectors = [];
+		const pipelines = this.pipelines_;
+		if (pipelines === null) throw new Error(message);
+		for (const [type, modelsPaths] of pipelines) {
 			const wasmType = this.pipelineTypeToWasmEnum(type);
 			const pipelineBuffers = [];
-			const sizes = new this.wasmModule.VectorInt();
+			const sizes = new (this.requireWasmModule(message)).VectorInt();
+			sizeVectors.push(sizes);
 			for (const path of modelsPaths) {
-				if (!loadedModels.has(path)) {
-					const model = await resolveWasmSource(path, "model");
+				let model = loadedModels.get(path);
+				if (!model) {
+					model = await resolveWasmSource(path, "model");
 					loadedModels.set(path, model);
 				}
-				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);
+		const modelsBuffers = this.requireWorkflowApiUtilities(message).allocateModelsBuffers(buffSizes);
+		for (const sizes of sizeVectors) sizes.delete?.();
+		buffSizes.delete?.();
+		this.modelsBuffers = modelsBuffers;
 		for (const [type, data] of modelData) {
-			const buffers = this.modelsBuffers?.get(type);
+			const buffers = modelsBuffers.get(type);
+			if (!buffers) throw new Error("Unable to get model buffer from shared memory!");
 			for (let k = 0; k < buffers.size(); k++) {
-				const buffer = buffers?.get(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");
+		const message = "Unable to initialize pipelines, cpp API hasn't been initialized";
+		this.requireWorkflowApiUtilities(message);
 		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);
+		this.requireWorkflowApiUtilities(message).initializeWorkflows();
 	}
 	getPipelineState() {
-		this.checkWasmInitialization("Unable to get pipeline state, cpp API hasn't been initialized");
-		return this.workflowApiUtilities.getWorkflowState();
+		return this.requireWorkflowApiUtilities("Unable to get pipeline state, cpp API hasn't been initialized").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;
-	}
-	getInspectorOpened() {
-		return this.inspectorOpened_;
-	}
-	setBackgroundMode(backgroundMode) {
-		this.checkWasmInitialization("Unable to set background mode, cpp API hasn't been initialized");
-		this.utilityApi.setBackgroundMode(backgroundMode);
+		const workflowApiUtilities = this.requireWorkflowApiUtilities("Unable to get current pipeline, cpp API hasn't been initialized");
+		return this.pipelineTypeFromWasmEnum(workflowApiUtilities.getCurrentWorkflow());
 	}
 	setOnDeviceMode(enabled) {
 		this.onDeviceMode_ = enabled;
 		if (this.utilityApi != null) this.utilityApi.setOnDeviceMode(enabled);
 	}
-	setDsEnabled(enabled) {
-		this.dsEnabled_ = enabled;
-	}
-	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(this.dsEnabled_, false), true);
-	}
-	async poc(output) {
-		this.checkWasmInitialization("Unable to poc, cpp API hasn't been initialized");
-		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.poc(this.dsEnabled_, output), true);
-	}
-	async rsp() {
-		this.checkWasmInitialization("Unable to rsp, cpp API hasn't been initialized");
-		await wasmCallWrapper(this.wasmCallSemaphore, () => this.utilityApi.rsp(this.dsEnabled_), true);
-	}
-	ssl() {
-		this.checkWasmInitialization("Unable to ssl, cpp API hasn't been initialized");
-		this.utilityApi.ssl(this.dsEnabled_);
-	}
-	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();
+	pipelineTypeToWasmEnum(type) {
+		return pipelineTypeToWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
 	}
-	oev() {
-		this.checkWasmInitialization("Unable to set sensor ending timestamp, cpp API hasn't been initialized");
-		this.utilityApi.oev();
+	pipelineTypeFromWasmEnum(type) {
+		return pipelineTypeFromWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
 	}
-	ckvcks(data) {
-		this.checkWasmInitialization("Unable to ckvcks, cpp API hasn't been initialized");
-		this.utilityApi.ckvcks(data);
+	IdCaptureModelTypeToWasmEnum(type) {
+		return idCaptureModelTypeToWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
 	}
 	/**
-	* 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`.
+	* Kept as an upstream mirror (`src/web/wasmApi.ts` declares the reverse map)
+	* but has no callers, so it stays **private** and off {@link WasmRuntimeApi}:
+	* dead code must not become public surface.
 	*/
-	processPhoto(canvas) {
-		this.checkWasmInitialization("Unable to process photo, cpp API hasn't been initialized");
-		this.faceProcessingWasmApi.processPhoto(canvas);
+	IdCaptureModelTypeFromWasmEnum(type) {
+		return idCaptureModelTypeFromWasmEnum(this.requireWasmModule(WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE), type);
 	}
 	/**
-	* 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.
+	* Handle accessors. Each throws the caller's message when the C++ API is not
+	* initialized and otherwise returns the non-null handle, so every wrapper gets
+	* a narrowed handle without repeating a null check. The message is the
+	* caller's, not this class's, so the wrapper's own pre-init contract is
+	* preserved verbatim.
 	*
-	* 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).
+	* `isInitialized()` checks the four ML handles plus `isInitialized_`; it does
+	* not check `wasmModule` or `webApi`. Both are set in `initialize()` and
+	* cleared in `freeResources()`, i.e. they share the exact lifetime of the four
+	* checked handles, so the extra `=== null` clause is unreachable in practice —
+	* it turns a would-be `TypeError` into the same `Error(message)` in a state
+	* that cannot occur. `!this.isInitialized()` is tested first so the observable
+	* message never changes.
 	*/
-	postFaceResults(config) {
-		this.checkWasmInitialization("Unable to post face results, cpp API hasn't been initialized");
-		return this.webApi.postFaceResults(config ?? {});
+	requireWorkflowApiUtilities(message) {
+		if (!this.isInitialized() || this.workflowApiUtilities === null) throw new Error(message);
+		return this.workflowApiUtilities;
 	}
-	pipelineTypeToWasmEnum(type) {
-		switch (type) {
-			case 0: return this.wasmModule.WorkflowType.IdBlurGlareWorkflow;
-			case 1: return this.wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow;
-			case 2: return this.wasmModule.WorkflowType.IdVideoSelfieWorkflow;
-			case 3: return this.wasmModule.WorkflowType.SelfieWithAggregationMetrics;
-			case 4: return this.wasmModule.WorkflowType.SelfieWithQualityMetrics;
-			case 5: return this.wasmModule.WorkflowType.OnDeviceSelfieWorkflow;
-			default: throw new Error("Unknown pipeline type");
-		}
+	requireUtilityApi(message) {
+		if (!this.isInitialized() || this.utilityApi === null) throw new Error(message);
+		return this.utilityApi;
 	}
-	pipelineTypeFromWasmEnum(type) {
-		switch (type) {
-			case this.wasmModule.WorkflowType.IdBlurGlareWorkflow: return 0;
-			case this.wasmModule.WorkflowType.IdBarcodeAndTextQualityWorkflow: return 1;
-			case this.wasmModule.WorkflowType.IdVideoSelfieWorkflow: return 2;
-			case this.wasmModule.WorkflowType.SelfieWithAggregationMetrics: return 3;
-			case this.wasmModule.WorkflowType.SelfieWithQualityMetrics: return 4;
-			case this.wasmModule.WorkflowType.OnDeviceSelfieWorkflow: return 5;
-			default: throw new Error("Unknown pipeline type");
-		}
+	requireIdCaptureApi(message) {
+		if (!this.isInitialized() || this.idCaptureWasmApi === null) throw new Error(message);
+		return this.idCaptureWasmApi;
 	}
-	IdCaptureModelTypeToWasmEnum(type) {
-		switch (type) {
-			case 0: return this.wasmModule.IdCaptureModelType.IdCaptureV1x;
-			case 1: return this.wasmModule.IdCaptureModelType.IdCaptureV2x;
-			case 2: return this.wasmModule.IdCaptureModelType.IdCaptureV3x;
-			default: throw new Error("Unknown Id Capture model type");
-		}
+	requireFaceProcessingApi(message) {
+		if (!this.isInitialized() || this.faceProcessingWasmApi === null) throw new Error(message);
+		return this.faceProcessingWasmApi;
 	}
-	IdCaptureModelTypeFromWasmEnum(type) {
-		switch (type) {
-			case this.wasmModule.IdCaptureModelType.IdCaptureV1x: return 0;
-			case this.wasmModule.IdCaptureModelType.IdCaptureV2x: return 1;
-			case this.wasmModule.IdCaptureModelType.IdCaptureV3x: return 2;
-			default: throw new Error("Unknown Id Capture model type");
-		}
+	requireWasmModule(message) {
+		if (!this.isInitialized() || this.wasmModule === null) throw new Error(message);
+		return this.wasmModule;
 	}
-	checkWasmInitialization(message) {
-		if (!this.isInitialized()) throw new Error(message);
+	requireWebApi(message) {
+		if (!this.isInitialized() || this.webApi === null) throw new Error(message);
+		return this.webApi;
 	}
-}.getInstance();
+};
+WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE = "Unable to map pipeline type, cpp API hasn't been initialized";
+/** Process-wide runtime. One binary, one heap, one owner. */
+const wasmRuntime = new WasmRuntime();
 //#endregion
 //#region ../infra/src/wasm/warmup.ts
 /**
@@ -586,13 +420,12 @@ async function warmupWasm(config) {
 		loadingPromise = (async () => {
 			try {
 				const pipelinesMap = buildPipelinesMap(combinedPipelines, lastConfig);
-				await mlWasmJSApi_default.initialize({
+				await wasmRuntime.initialize({
 					module: lastConfig,
-					versionsFile: "",
 					pipelines: pipelinesMap
 				});
-				await mlWasmJSApi_default.loadModels();
-				await mlWasmJSApi_default.initializePipelines();
+				await wasmRuntime.loadModels();
+				await wasmRuntime.initializePipelines();
 				state = "ready";
 				loadedPipelines = combinedPipelines;
 				lastConfig = {
@@ -616,14 +449,13 @@ async function warmupWasm(config) {
 	loadingPromise = (async () => {
 		try {
 			const pipelinesMap = buildPipelinesMap(pipelines, config);
-			if (config.onDeviceMode !== void 0) mlWasmJSApi_default.setOnDeviceMode(config.onDeviceMode);
-			await mlWasmJSApi_default.initialize({
+			if (config.onDeviceMode !== void 0) wasmRuntime.setOnDeviceMode(config.onDeviceMode);
+			await wasmRuntime.initialize({
 				module: config,
-				versionsFile: "",
 				pipelines: pipelinesMap
 			});
-			await mlWasmJSApi_default.loadModels();
-			await mlWasmJSApi_default.initializePipelines();
+			await wasmRuntime.loadModels();
+			await wasmRuntime.initializePipelines();
 			state = "ready";
 			loadedPipelines = [...pipelines];
 			lastConfig = {
@@ -679,15 +511,172 @@ function waitForWasm() {
 	return Promise.reject(/* @__PURE__ */ new Error("WASM warmup was not started. Call warmupWasm() first."));
 }
 /**
-* Sets WASM on-device mode on the shared WASM singleton. Applied on the next
+* Sets WASM on-device mode on the shared `wasmRuntime`. Applied on the next
 * `initialize()` (via warmupWasm), or live if WASM is already initialized.
 * Used by setup() to derive on-device mode from the `fingerprint` option so
 * the intent is honored even by lazy warmups whose config does not carry it.
 */
 function setWasmOnDeviceMode(enabled) {
-	mlWasmJSApi_default.setOnDeviceMode(enabled);
+	wasmRuntime.setOnDeviceMode(enabled);
 }
 //#endregion
+//#region ../infra/src/wasm/utilityWasmApi.ts
+/**
+* Utility / metadata domain facade over {@link WasmRuntime}.
+*
+* Holds no WASM state — the runtime owns every handle and buffer. The one
+* qualification: it owns exactly two JS-side flags that the C++ side does not
+* persist and that must be replayed into it at call time —
+*
+* - `dsEnabled_` (deepsight) is passed as an argument on every
+*   `prc`/`poc`/`rsp`/`ssl` call;
+* - `inspectorOpened_` is pushed into C++ inside {@link getMetadata}, right
+*   before reading the metadata, because `setInspectorOpened` may legitimately be
+*   called before WASM is initialized.
+*
+* Both are deliberately **unguarded** setters: they never throw, so the SDK can
+* record them during setup and have them honored once WASM comes up.
+*
+* `prc`/`poc`/`rsp` are the only methods here that hold the ML semaphore.
+* `ssl`/`stl`/`osv`/`oev`/`ckvcks` and everything else are unlocked **by design**
+* (decision D6) — never add locking.
+*
+* Method names, argument order and the pre-initialization error strings are
+* copied verbatim from the mirrored upstream `wasmApi.ts` so a WASM version bump
+* stays a diff against upstream (`docs/processes/WASM_VERSION_MIGRATION.md`).
+* `setSdkPlatform`'s message says "device type" on purpose — do not "fix" it.
+*/
+var UtilityWasmApi = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+		this.inspectorOpened_ = false;
+		this.dsEnabled_ = false;
+	}
+	ens(image) {
+		return this.runtime.requireUtilityApi("Unable to encrypt the image, cpp API hasn't been initialized").ens(image);
+	}
+	isVirtualCamera(label) {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to check if the camera is virtual, cpp API hasn't been initialized");
+		if (label) return utilityApi.isVirtualCamera(label);
+		return false;
+	}
+	estimatePerformance() {
+		return this.runtime.requireUtilityApi("Unable to estimate performance, cpp API hasn't been initialized").estimatePerformance();
+	}
+	async analyzeFrame(image) {
+		const message = "Unable to analyze the frame, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await this.runtime.allocateImageBuffers(image.width, image.height);
+		this.runtime.writeFrame(image);
+		this.runtime.requireUtilityApi(message).analyzeFrame();
+	}
+	/**
+	* 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.runtime.requireUtilityApi("Unable to set production mode, cpp API hasn't been initialized").setProductionMode(productionMode);
+	}
+	setSdkVersion(sdkVersion) {
+		this.runtime.requireUtilityApi("Unable to set sdk version, cpp API hasn't been initialized").setSdkVersion(sdkVersion);
+	}
+	setSdkPlatform(sdkPlatform) {
+		this.runtime.requireUtilityApi("Unable to set device type, cpp API hasn't been initialized").setSdkPlatform(sdkPlatform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set device info, cpp API hasn't been initialized").setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set browser info, cpp API hasn't been initialized").setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set camera info, cpp API hasn't been initialized").setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setZc(zc) {
+		this.runtime.requireUtilityApi("Unable to set zc, cpp API hasn't been initialized").setZc(zc);
+	}
+	setMotionStatus(motionStatus) {
+		this.runtime.requireUtilityApi("Unable to set motion status, cpp API hasn't been initialized").setMotionStatus(motionStatus);
+	}
+	setInspectorOpened(inspectorOpened) {
+		this.inspectorOpened_ = inspectorOpened;
+	}
+	getInspectorOpened() {
+		return this.inspectorOpened_;
+	}
+	setBackgroundMode(backgroundMode) {
+		this.runtime.requireUtilityApi("Unable to set background mode, cpp API hasn't been initialized").setBackgroundMode(backgroundMode);
+	}
+	setDsEnabled(enabled) {
+		this.dsEnabled_ = enabled;
+	}
+	getCheck() {
+		return this.runtime.requireUtilityApi("Unable to get check, cpp API hasn't been initialized").getCheck();
+	}
+	getMetadata() {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to get metadata, cpp API hasn't been initialized");
+		utilityApi.setInspectorOpened(this.inspectorOpened_);
+		return utilityApi.getMetadata();
+	}
+	async prc() {
+		const message = "Unable to prc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).prc(this.dsEnabled_, false), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "prc"
+		});
+	}
+	async poc(output) {
+		const message = "Unable to poc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).poc(this.dsEnabled_, output), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "poc"
+		});
+	}
+	async rsp() {
+		const message = "Unable to rsp, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).rsp(this.dsEnabled_), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "rsp"
+		});
+	}
+	ssl() {
+		this.runtime.requireUtilityApi("Unable to ssl, cpp API hasn't been initialized").ssl(this.dsEnabled_);
+	}
+	stl() {
+		this.runtime.requireUtilityApi("Unable to stl, cpp API hasn't been initialized").stl();
+	}
+	osv() {
+		this.runtime.requireUtilityApi("Unable to set sensor beginning timestamp, cpp API hasn't been initialized").osv();
+	}
+	oev() {
+		this.runtime.requireUtilityApi("Unable to set sensor ending timestamp, cpp API hasn't been initialized").oev();
+	}
+	ckvcks(data) {
+		this.runtime.requireUtilityApi("Unable to ckvcks, cpp API hasn't been initialized").ckvcks(data);
+	}
+	/**
+	* Clear all states, not related to ml pipelines
+	*/
+	resetOther() {
+		this.runtime.requireUtilityApi("Unable to reset other states, cpp API hasn't been initialized").resetOther();
+	}
+	/**
+	* Full reset. Pipelines first, then the non-pipeline state — the order the
+	* mirrored upstream wrapper uses.
+	*/
+	reset() {
+		this.runtime.resetAllPipelines();
+		this.resetOther();
+	}
+};
+const utilityWasmApi = new UtilityWasmApi();
+//#endregion
 //#region ../infra/src/providers/wasm/BaseWasmProvider.ts
 /**
 * Base provider class that abstracts common WASM functionality.
@@ -748,16 +737,16 @@ var BaseWasmProvider = class {
 	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);
+		await wasmRuntime.allocateImageBuffers(image.width, image.height);
+		await wasmRuntime.handleDetectionCallAndUpdateState(pipelineType);
+		return await wasmRuntime.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);
+		if (this._isInitialized && this.pipelineType !== void 0) wasmRuntime.resetPipeline(this.pipelineType);
 	}
 	/**
 	* Disposes of resources and resets initialization state.
@@ -799,50 +788,50 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 	}
 	encryptImage(image) {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.ens(image);
+		return utilityWasmApi.ens(image);
 	}
 	setSdkVersion(version) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setSdkVersion(version);
+		utilityWasmApi.setSdkVersion(version);
 	}
 	setSdkPlatform(platform) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setSdkPlatform(platform);
+		utilityWasmApi.setSdkPlatform(platform);
 	}
 	setDeviceInfo(deviceInfo, overrideExisting = true) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setDeviceInfo(deviceInfo, overrideExisting);
+		utilityWasmApi.setDeviceInfo(deviceInfo, overrideExisting);
 	}
 	setBrowserInfo(browserInfo, overrideExisting = true) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setBrowserInfo(browserInfo, overrideExisting);
+		utilityWasmApi.setBrowserInfo(browserInfo, overrideExisting);
 	}
 	setCameraInfo(cameraInfo, overrideExisting = true) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setCameraInfo(cameraInfo, overrideExisting);
+		utilityWasmApi.setCameraInfo(cameraInfo, overrideExisting);
 	}
 	setMotionStatus(status) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setMotionStatus(status);
+		utilityWasmApi.setMotionStatus(status);
 	}
 	setBackgroundMode(backgroundMode) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setBackgroundMode(backgroundMode);
+		utilityWasmApi.setBackgroundMode(backgroundMode);
 	}
 	setOnDeviceMode(enabled) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setOnDeviceMode(enabled);
+		wasmRuntime.setOnDeviceMode(enabled);
 	}
 	setZc(zc) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setZc(zc);
+		utilityWasmApi.setZc(zc);
 	}
 	setInspectorOpened(opened) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.setInspectorOpened(opened);
+		utilityWasmApi.setInspectorOpened(opened);
 	}
 	getInspectorOpened() {
-		return mlWasmJSApi_default.getInspectorOpened();
+		return utilityWasmApi.getInspectorOpened();
 	}
 	/**
 	* Toggles the WASM module's production mode. When `true`, the native module
@@ -854,67 +843,63 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 	*/
 	async setProductionMode(productionMode) {
 		this.ensureInitialized();
-		await mlWasmJSApi_default.setProductionMode(productionMode);
+		await utilityWasmApi.setProductionMode(productionMode);
 	}
 	getMetadata() {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.getMetadata();
+		return utilityWasmApi.getMetadata();
 	}
 	async analyzeFrame(image) {
 		this.ensureInitialized();
-		await mlWasmJSApi_default.analyzeFrame(image);
+		await utilityWasmApi.analyzeFrame(image);
 	}
 	getCheck() {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.getCheck();
+		return utilityWasmApi.getCheck();
 	}
 	getPipelineState() {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.getPipelineState();
+		return wasmRuntime.getPipelineState();
 	}
 	estimatePerformance() {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.estimatePerformance();
+		return utilityWasmApi.estimatePerformance();
 	}
 	isVirtualCamera(label) {
 		this.ensureInitialized();
-		return mlWasmJSApi_default.isVirtualCamera(label);
+		return utilityWasmApi.isVirtualCamera(label);
 	}
 	async prc() {
 		this.ensureInitialized();
-		await mlWasmJSApi_default.prc();
+		await utilityWasmApi.prc();
 	}
 	async poc(output) {
 		this.ensureInitialized();
-		await mlWasmJSApi_default.poc(output);
+		await utilityWasmApi.poc(output);
 	}
 	async rsp() {
 		this.ensureInitialized();
-		await mlWasmJSApi_default.rsp();
+		await utilityWasmApi.rsp();
 	}
 	ssl() {
 		this.ensureInitialized();
-		mlWasmJSApi_default.ssl();
+		utilityWasmApi.ssl();
 	}
 	stl() {
 		this.ensureInitialized();
-		mlWasmJSApi_default.stl();
+		utilityWasmApi.stl();
 	}
 	osv() {
 		this.ensureInitialized();
-		mlWasmJSApi_default.osv();
+		utilityWasmApi.osv();
 	}
 	oev() {
 		this.ensureInitialized();
-		mlWasmJSApi_default.oev();
+		utilityWasmApi.oev();
 	}
 	ckvcks(data) {
 		this.ensureInitialized();
-		mlWasmJSApi_default.ckvcks(data);
-	}
-	async getVersions() {
-		this.ensureInitialized();
-		return mlWasmJSApi_default.getVersions();
+		utilityWasmApi.ckvcks(data);
 	}
 };
 //#endregion
@@ -952,4 +937,4 @@ function resolveSessionStorage() {
 	}
 }
 //#endregion
-export { getResolvedModelSource as a, mlWasmJSApi_default as c, BaseWasmProvider as i, resolveSessionStorage as n, setWasmOnDeviceMode as o, WasmUtilProvider as r, warmupWasm as s, resolveLocalStorage as t };
+export { utilityWasmApi as a, warmupWasm as c, BaseWasmProvider as i, wasmRuntime as l, resolveSessionStorage as n, getResolvedModelSource as o, WasmUtilProvider as r, setWasmOnDeviceMode as s, resolveLocalStorage as t };