@privateid/ultrapass-web-sdk 1.3.1 → 1.3.2-1300478

package/dist/application/workers/wasm/WasmWorkerService.js

@@ -0,0 +1,801 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable lines-between-class-members */
+/* eslint-disable import/prefer-default-export */
+import { expose } from 'comlink';
+import { printLogs } from '../../modules/internal/shared/shared.utils';
+import { checkCacheAndCurrentAreSameVersion, fetchResource, flatImageDataArraysIntoUint8Array, readCurrentWasmVersion, readFromIndexedDB, removeNullBytesFromDecodedString, writeToIndexedDB, } from './wasm-worker.utils';
+import { WASM_ULTRA_FOLDER_NAME } from './wasm-worker.constants';
+const callbackRegistry = {
+    result: null,
+    error: null,
+    progress: null,
+    wasmCropping: null,
+};
+// Set up the global WASM callbacks once at module level
+// These MUST be on globalThis for WASM to find them (due to IIFE build format)
+// In WasmWorkerService.ts, update the globalThis.privid_wasm_result function (around line 43)
+globalThis.privid_wasm_result = (operation, id, response_str) => {
+    if (callbackRegistry.result) {
+        try {
+            printLogs('[WasmWorkerService] privid_wasm_result called with operation:', operation);
+            printLogs('[WasmWorkerService] privid_wasm_result called with id:', id);
+            printLogs('[WasmWorkerService] privid_wasm_result called with response_str:', response_str);
+            callbackRegistry.result(operation, id, response_str);
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] Error in result callback:', error, 'ERROR');
+        }
+    }
+    else {
+        printLogs('[WasmWorkerService] No result callback registered', '', 'WARN');
+    }
+};
+globalThis.privid_wasm_error = (operation, id, error_str) => {
+    printLogs('[WasmWorkerService] privid_wasm_error called:', { operation, id, error_str }, 'ERROR');
+    if (callbackRegistry.error) {
+        try {
+            callbackRegistry.error(operation, id, error_str);
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] Error in error callback:', error, 'ERROR');
+        }
+    }
+    else {
+        printLogs('[WasmWorkerService] No error callback registered', '', 'WARN');
+    }
+};
+globalThis.privid_wasm_progress = (progress_type, message, progress_value) => {
+    printLogs('[WasmWorkerService] privid_wasm_progress called:', { progress_type, message, progress_value });
+    if (callbackRegistry.progress) {
+        try {
+            callbackRegistry.progress(progress_type, message, progress_value);
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] Error in progress callback:', error, 'ERROR');
+        }
+    }
+};
+globalThis.privid_wasm_cropping = (base64Image) => {
+    printLogs('[WasmWorkerService] privid_wasm_cropping called', base64Image);
+    if (callbackRegistry.wasmCropping) {
+        try {
+            callbackRegistry.wasmCropping(base64Image);
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] Error in wasmCropping callback:', error, 'ERROR');
+        }
+    }
+};
+export class WasmWorkerService {
+    constructor() {
+        this.wasmPrividModules = null;
+        this.apiUrl = null;
+        this.sessionToken = null;
+        this.publicKey = null;
+        this.debugType = null;
+        this.inputPtr = null;
+        this.imageInputSize = null;
+        this.barCodePtr = null;
+        this.proxiedResultCallback = null;
+        this.proxiedErrorCallback = null;
+        this.proxiedProgressCallback = null;
+        this.wasmSession = null;
+        this.setCache = true;
+        this.checkWasmLoaded = false;
+        this.antispoofVersion = null;
+        this.cdnUrl = 'https://ultra-wasm.devel.privateid.com';
+        this.useCdnLink = true;
+        this.isSimd = null;
+    }
+    loadModules(params, errorCallback, progressCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.proxiedErrorCallback = errorCallback;
+            callbackRegistry.error = errorCallback;
+            this.proxiedProgressCallback = progressCallback;
+            callbackRegistry.progress = progressCallback;
+            this.apiUrl = params.apiUrl;
+            this.sessionToken = params.sessionToken;
+            this.publicKey = params.publicKey;
+            this.useCdnLink = params.useCdn;
+            this.setCache = params.cacheConfig;
+            this.isSimd = params.simd;
+            if (params.debugType) {
+                this.debugType = params.debugType;
+            }
+            printLogs('[WasmWorkerService] isLoad params: ', params);
+            const modulePath = params.simd ? 'simd' : 'nosimd';
+            const moduleName = 'privid_fhe_ultra';
+            const cachedModule = yield readFromIndexedDB(WASM_ULTRA_FOLDER_NAME);
+            const currentModuleVersionJSON = yield readCurrentWasmVersion(modulePath);
+            if (checkCacheAndCurrentAreSameVersion(cachedModule, currentModuleVersionJSON)) {
+                printLogs('[WasmWorkerService] same version confirmed', '');
+                printLogs('[WasmWorkerService] PRIVMODULES LOADED?: ', this.wasmPrividModules);
+                if (!this.wasmPrividModules) {
+                    const { cachedWasm, cachedScript } = cachedModule;
+                    if (cachedWasm && cachedScript) {
+                        const blob = new Blob([cachedScript], { type: 'application/javascript' });
+                        const blobUrl = URL.createObjectURL(blob);
+                        try {
+                            // Import the cached script using importScripts
+                            importScripts(blobUrl);
+                            // Check if createTFLiteModule is now available
+                            if (typeof createTFLiteModule === 'undefined') {
+                                printLogs('[WasmWorkerService] createTFLiteModule not defined, falling back to package', '', 'WARN');
+                                yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
+                                return 'Loaded from package (cache invalid)';
+                            }
+                            this.wasmPrividModules = yield createTFLiteModule({ wasmBinary: cachedWasm });
+                            printLogs('[WasmWorkerService] ULTRA MODULES ', this.wasmPrividModules);
+                            if (!this.checkWasmLoaded) {
+                                yield this.initializeWasmSession(params.usageScenario, params.cacheContent);
+                                this.checkWasmLoaded = true;
+                            }
+                            printLogs('[WasmWorkerService] WASM MODULES: ', this.wasmPrividModules);
+                        }
+                        catch (error) {
+                            printLogs('[WasmWorkerService] Error loading from cache:', error, 'ERROR');
+                            yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
+                            return 'Loaded from package (cache error)';
+                        }
+                        finally {
+                            // Clean up the blob URL
+                            URL.revokeObjectURL(blobUrl);
+                        }
+                    }
+                }
+                else if (this.wasmPrividModules && params.shouldRegenerateSession) {
+                    this.wasmSession = null;
+                    const newSession = yield this.initializeWasmSession(params.usageScenario, params.cacheContent);
+                    if (!newSession) {
+                        printLogs('[WasmWorkerService] ERROR: Failed to regenerate session', '', 'ERROR');
+                        throw new Error('Session regeneration failed');
+                    }
+                }
+                else {
+                    yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
+                    return 'Loaded';
+                }
+                // Final verification that WASM is fully initialized
+                if (!this.wasmPrividModules || !this.wasmSession) {
+                    const error = 'WASM modules loaded but session not initialized';
+                    printLogs(`[WasmWorkerService] ERROR: ${error}`, '', 'ERROR');
+                    throw new Error(error);
+                }
+                return 'Cache Loaded';
+            }
+            yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
+            // Final verification that WASM is fully initialized
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                const error = 'WASM modules loaded but session not initialized';
+                printLogs(`[WasmWorkerService] ERROR: ${error}`, '', 'ERROR');
+                throw new Error(error);
+            }
+            return 'Loaded';
+        });
+    }
+    loadFromPackage(wasmVersion, modulePath, moduleName, usageScenario, cache_content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            printLogs('[WasmWorkerService loadFromPackage wasmVersion: ', wasmVersion);
+            this.wasmPrividModules = yield this.loadWasmModule(modulePath, moduleName, true, wasmVersion);
+            if (!this.checkWasmLoaded) {
+                yield this.initializeWasmSession(usageScenario, cache_content);
+                this.checkWasmLoaded = true;
+            }
+            return true;
+        });
+    }
+    loadWasmModule(modulePath, moduleName, saveCache, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wasmUrls = {
+                cdn: `${this.cdnUrl}/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.wasm`,
+                local: `../wasm/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.wasm`,
+            };
+            const scriptUrls = {
+                cdn: `${this.cdnUrl}/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.js`,
+                local: `../wasm/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.js`,
+            };
+            const wasm = yield fetchResource(wasmUrls, this.useCdnLink);
+            const script = yield fetchResource(scriptUrls, this.useCdnLink);
+            const scriptBuffer = yield script.text();
+            const buffer = yield wasm.arrayBuffer();
+            printLogs(`[WasmWorkerService] loadWasmModule script and buffer': `, { scriptBuffer, buffer });
+            const blob = new Blob([scriptBuffer], { type: 'application/javascript' });
+            const blobUrl = URL.createObjectURL(blob);
+            try {
+                // Import the script in the worker context using importScripts
+                importScripts(blobUrl);
+                // Check if createTFLiteModule is now available
+                if (typeof createTFLiteModule === 'undefined') {
+                    throw new Error('createTFLiteModule not defined after loading script');
+                }
+                // Now createTFLiteModule should be available globally
+                const module = yield createTFLiteModule({ wasmBinary: buffer });
+                printLogs('[WasmWorkerService] loadWasmModule module: ', module);
+                if (saveCache) {
+                    const moduleVersion = module.UTF8ToString(module._privid_get_version());
+                    yield writeToIndexedDB(WASM_ULTRA_FOLDER_NAME, buffer, scriptBuffer, moduleVersion);
+                }
+                return module;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] Error loading WASM module:', error, 'ERROR');
+                throw error;
+            }
+            finally {
+                // Clean up the blob URL to free memory
+                URL.revokeObjectURL(blobUrl);
+            }
+        });
+    }
+    initializeWasmSession(usageScenario = '', cache_content = '') {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.wasmSession) {
+                return this.wasmSession;
+            }
+            const settings = Object.assign(Object.assign({}, this.apiUrl), { session_token: this.sessionToken, public_key: this.publicKey, debug_level: this.debugType, custom_settings: { usage_scenario: usageScenario, cache_content } });
+            printLogs(`[WasmWorkerService] initializeWasmSession settings:`, settings);
+            const resultPointers = this.createWasmResultPointers();
+            const stringBuffer = this.createStringBuffer(JSON.stringify(settings));
+            const isSessionInitialized = this.wasmPrividModules._privid_initialize_session(...stringBuffer.getArgs(), resultPointers.getOuterPointer());
+            printLogs(`[WasmWorkerService] initializeWasmSession isSessionInitialized: `, isSessionInitialized);
+            stringBuffer.free();
+            const isLoadedModels = this.checkModelsAreLoaded();
+            printLogs(`[WasmWorkerService] initializeWasmSession isLoadedModels: `, isLoadedModels);
+            if (!isSessionInitialized) {
+                printLogs('[WasmWorkerService] ERROR: privid_initialize_session failed', '', 'ERROR');
+                printLogs('[WasmWorkerService] Settings were:', settings, 'ERROR');
+                return null;
+            }
+            const wasmSessionPointer = resultPointers.getInnerPointer();
+            this.wasmSession = wasmSessionPointer;
+            printLogs(`[WasmWorkerService] initializeWasmSession wasmSessionPointer: `, wasmSessionPointer);
+            return wasmSessionPointer;
+        });
+    }
+    ultraEnroll(params, resultCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: params.simd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraEnroll error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const imageInputSize = params.imageData.data.length * params.imageData.data.BYTES_PER_ELEMENT;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            // TODO: @pahferreira - what does this line do?
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(params.imageData.data), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const encoder = new TextEncoder();
+            const config_bytes = encoder.encode(`${params.config}`);
+            const configInputSize = config_bytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            // TODO: @pahferreira - what does this line do?
+            this.wasmPrividModules.HEAP8.set(config_bytes, configInputPtr / config_bytes.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraEnroll config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_user_enroll(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, params.imageData.width /* width of one image */, params.imageData.height /* height of one image */, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs(`[WasmWorkerService] ultraEnroll error: `, error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    ultraPredict(params, resultCallback, onAntiSpoofProgress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (onAntiSpoofProgress) {
+                callbackRegistry.progress = onAntiSpoofProgress;
+            }
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: params.simd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraPredict error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const imageInput = flatImageDataArraysIntoUint8Array(params.originalImages);
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const imageInputSize = imageInput.length * imageInput.BYTES_PER_ELEMENT;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(imageInput), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraPredict config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_user_predict(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, params.originalImages[0].width /* width of one image */, params.originalImages[0].height /* height of one image */, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] ultraPredict error:', error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    ultraAgeEstimate(params, resultCallback, onAntiSpoofProgress, onWasmCroppingCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (onAntiSpoofProgress) {
+                callbackRegistry.progress = onAntiSpoofProgress;
+            }
+            if (onWasmCroppingCallback) {
+                callbackRegistry.wasmCropping = onWasmCroppingCallback;
+            }
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: params.simd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraAgeEstimate error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const imageInput = flatImageDataArraysIntoUint8Array(params.originalImages);
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const imageInputSize = imageInput.length * imageInput.BYTES_PER_ELEMENT;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(imageInput), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraAgeEstimate config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_estimate_age(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, params.originalImages[0].width /* width of one image */, params.originalImages[0].height /* height of one image */, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs(`[WasmWorkerService] ultraAgeEstimate error: `, error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    ultraCompareEmbeddings(params, resultCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: true,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraCompareEmbeddings error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const embeddingsABytes = encoder.encode(`${params.encryptedEmbeddingsA}`);
+            const embeddingsASize = embeddingsABytes.length;
+            const embeddingsAPtr = this.allocatePointer(embeddingsASize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(embeddingsABytes), embeddingsAPtr);
+            const embeddingsBBytes = encoder.encode(`${params.encryptedEmbeddingsB}`);
+            const embeddingsBSize = embeddingsBBytes.length;
+            const embeddingsBPtr = this.allocatePointer(embeddingsBSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(embeddingsBBytes), embeddingsBPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraCompareEmbeddings config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_compare_embeddings(this.wasmSession /* session pointer */, configInputPtr, configInputSize, embeddingsAPtr, embeddingsASize, embeddingsBPtr, embeddingsBSize, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] ultraCompareEmbeddings error:', error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(embeddingsAPtr, embeddingsBPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    pkiEncrypt(params) {
+        if (!this.wasmPrividModules || !this.wasmSession) {
+            return { error: true };
+        }
+        const encoder = new TextEncoder();
+        const payloadBytes = encoder.encode(params.payload);
+        const payloadSize = payloadBytes.length;
+        const payloadPtr = this.allocatePointer(payloadSize);
+        const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+        const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+        this.wasmPrividModules.HEAP8.set(payloadBytes, payloadPtr / payloadBytes.BYTES_PER_ELEMENT);
+        const configBytes = encoder.encode(params.config);
+        const configInputSize = configBytes.length;
+        const configInputPtr = this.allocatePointer(configInputSize);
+        this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+        printLogs('[WasmWorkerService] pkiEncrypt params: ', params);
+        try {
+            this.wasmPrividModules._privid_encrypt_payload(this.wasmSession /* session pointer */, configInputPtr, configInputSize, payloadPtr, payloadSize, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+            const [outputBufferSizes] = new Uint32Array(this.wasmPrividModules.HEAPU8.buffer, resultLenPtr, 1);
+            if (outputBufferSizes > 0) {
+                const outputBufferSize = new Uint32Array(this.wasmPrividModules.HEAPU8.buffer, resultLenPtr, 1)[0];
+                const outputBufferSecPtr = new Uint32Array(this.wasmPrividModules.HEAPU8.buffer, resultFirstPtr, 1)[0];
+                const outputBufferPtr = new Uint8Array(this.wasmPrividModules.HEAPU8.buffer, outputBufferSecPtr, outputBufferSize);
+                const decoder = new TextDecoder('utf-8');
+                const decode = decoder.decode(outputBufferPtr);
+                decode.replace(/\0/g, ''); // Remove null terminators if any
+                decode.replace(' ', '');
+                const result = removeNullBytesFromDecodedString(decode);
+                printLogs('[WasmWorkerService] pkiEncrypt result: ', result);
+                return result;
+            }
+            return {
+                error: true,
+            };
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] pkiEncrypt error:', error, 'ERROR');
+            return {
+                error: true,
+            };
+        }
+        finally {
+            this.releasePointers(payloadPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+        }
+    }
+    ultraScanBackDocument(params, resultCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: params.simd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraScanBackDocument error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const imageInputSize = params.imageInput.data.length * params.imageInput.data.BYTES_PER_ELEMENT;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(params.imageInput.data), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraScanBackDocument config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_doc_scan_back(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, params.imageInput.width /* width of one image */, params.imageInput.height /* height of one image */, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] ultraScanBackDocument error:', error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    ultraScanFrontDocument(params, resultCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: params.simd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraScanFrontDocument error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const imageInputSize = params.imageInput.data.length * params.imageInput.data.BYTES_PER_ELEMENT;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(params.imageInput.data), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraScanFrontDocument config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_doc_scan_front(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, params.imageInput.width /* width of one image */, params.imageInput.height /* height of one image */, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] ultraScanFrontDocument error:', error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    ultraDocumentOcr(params, resultCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            callbackRegistry.result = resultCallback;
+            if (!this.wasmPrividModules) {
+                yield this.loadModules({
+                    simd: this.isSimd,
+                    apiUrl: this.apiUrl,
+                    sessionToken: this.sessionToken,
+                    publicKey: this.publicKey,
+                    debugType: this.debugType || '',
+                    cacheConfig: this.setCache,
+                }, this.proxiedErrorCallback);
+            }
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                printLogs('[WasmWorkerService] ultraDocumentOcr error: WASM not fully initialized', '', 'ERROR');
+                return false;
+            }
+            const encoder = new TextEncoder();
+            const configBytes = encoder.encode(params.config);
+            const inputImageBytes = encoder.encode(`${params.imageInput}`);
+            const configInputSize = configBytes.length;
+            const configInputPtr = this.allocatePointer(configInputSize);
+            this.wasmPrividModules.HEAP8.set(configBytes, configInputPtr / configBytes.BYTES_PER_ELEMENT);
+            const imageInputSize = inputImageBytes.length;
+            const imageInputPtr = this.allocatePointer(imageInputSize);
+            this.wasmPrividModules.HEAPU8.set(new Uint8Array(inputImageBytes), imageInputPtr);
+            const resultFirstPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            const resultLenPtr = this.allocatePointer(Int32Array.BYTES_PER_ELEMENT);
+            printLogs('[WasmWorkerService] ultraDocumentOcr config: ', params.config);
+            try {
+                this.wasmPrividModules._privid_doc_ocr_front_enc(this.wasmSession /* session pointer */, configInputPtr, configInputSize, imageInputPtr /* input images */, imageInputSize, resultFirstPtr /* operation result output buffer */, resultLenPtr /* operation result buffer length */);
+                return true;
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] ultraDocumentOcr error:', error, 'ERROR');
+                return false;
+            }
+            finally {
+                this.releasePointers(imageInputPtr, resultFirstPtr, resultLenPtr, configInputPtr);
+            }
+        });
+    }
+    checkModelsAreLoaded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wasmPrividModules) {
+                    yield this.loadModules({
+                        simd: this.isSimd,
+                        apiUrl: this.apiUrl,
+                        sessionToken: this.sessionToken,
+                        publicKey: this.publicKey,
+                        debugType: this.debugType || '',
+                        cacheConfig: this.setCache,
+                    }, this.proxiedErrorCallback);
+                }
+                const isLoaded = this.wasmPrividModules._privid_check_models();
+                return isLoaded;
+            }
+            catch (error) {
+                printLogs(`[WasmWorkerService] checkModelsAreLoaded error`, error, 'ERROR');
+                return false;
+            }
+        });
+    }
+    freeMemory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.wasmPrividModules) {
+                    yield this.loadModules({
+                        simd: this.isSimd,
+                        apiUrl: this.apiUrl,
+                        sessionToken: this.sessionToken,
+                        publicKey: this.publicKey,
+                        debugType: this.debugType || '',
+                        cacheConfig: this.setCache,
+                    }, this.proxiedErrorCallback);
+                }
+                const freeMemoryResult = this.wasmPrividModules._privid_free_memory();
+                return freeMemoryResult;
+            }
+            catch (error) {
+                printLogs(`[WasmWorkerService] freeMemory error: `, error, 'ERROR');
+                return false;
+            }
+        });
+    }
+    /**
+     * Creates pointers for WASM function results.
+     * This helper manages outer and inner pointers for functions that return results via pointer arguments.
+     *
+     * @returns Object with methods to get outer and inner pointers
+     */
+    createWasmResultPointers() {
+        // TODO: Should we manipulate multiple pointers in Javascript?
+        let out_ptr = null;
+        let in_ptr = null;
+        return {
+            /**
+             * @brief  Allocates a pointer to contain the result and return it,
+             * if the container is already created it will be returned
+             */
+            getOuterPointer: () => {
+                // TODO: may be used SharedArrayBuffer() instead
+                // allocate memory the expected pointer (outer pointer or container)
+                if (!out_ptr)
+                    out_ptr = this.wasmPrividModules._malloc(Int32Array.BYTES_PER_ELEMENT);
+                return out_ptr;
+            },
+            /**
+             * @brief Creates a javascript Uint32Array pointer to contain the result pointed by outer_ptr and return it,
+             * It is the responsability of the caller to free the pointer returned by this function
+             */
+            getInnerPointer: () => {
+                //  If we did not allocate yet the output buffer return null
+                if (!out_ptr)
+                    return null;
+                // if we already have our inner pointer for this closure return it
+                if (in_ptr)
+                    return in_ptr;
+                // Access  the outer pointer as an arry of uint32 which conatin a single cell
+                // whose value is the pointer allocated in the wasm module (inner pointer of the output param)
+                // and return it
+                [in_ptr] = new Uint32Array(this.wasmPrividModules.HEAPU8.buffer, out_ptr, 1);
+                return in_ptr;
+            },
+        };
+    }
+    /**
+     * Creates a managed string buffer for WASM function calls.
+     * This helper allocates WASM memory for string arguments and provides automatic cleanup.
+     * It converts JavaScript strings to UTF-8 encoded bytes that can be passed to WASM functions.
+     *
+     * @param text - The string value to encode (null/undefined will result in [0, 0] args)
+     * @returns Object with methods to get pointer arguments and free memory
+    
+     */
+    createStringBuffer(text) {
+        let memoryPointer = null;
+        let bufferSize = 0;
+        let cachedArgs = null;
+        return {
+            /**
+             * Gets the [pointer, size] tuple for WASM function arguments.
+             * Results are cached - subsequent calls return the same values.
+             * @returns [pointer, size] tuple or [0, 0] for null/undefined input
+             */
+            getArgs: () => {
+                // Return cached result if already computed
+                if (cachedArgs !== null) {
+                    return cachedArgs;
+                }
+                // Handle null, undefined, or NaN cases
+                if (text == null || (typeof text === 'number' && Number.isNaN(text))) {
+                    cachedArgs = [0, 0];
+                    return cachedArgs;
+                }
+                try {
+                    // Convert to string and encode to UTF-8
+                    const stringValue = String(text);
+                    const encoder = new TextEncoder();
+                    const bytes = encoder.encode(stringValue);
+                    // Calculate buffer size and allocate WASM memory
+                    bufferSize = bytes.length * bytes.BYTES_PER_ELEMENT;
+                    memoryPointer = this.wasmPrividModules._malloc(bufferSize);
+                    if (memoryPointer === 0) {
+                        throw new Error('WASM memory allocation failed');
+                    }
+                    // Copy bytes to WASM heap
+                    this.wasmPrividModules.HEAP8.set(bytes, memoryPointer / bytes.BYTES_PER_ELEMENT);
+                    cachedArgs = [memoryPointer, bufferSize];
+                    return cachedArgs;
+                }
+                catch (error) {
+                    printLogs('[WasmWorkerService] createStringBuffer error:', error, 'ERROR');
+                    // Return safe defaults on error
+                    cachedArgs = [0, 0];
+                    return cachedArgs;
+                }
+            },
+            /**
+             * Frees the allocated WASM memory.
+             * IMPORTANT: Always call this after using the buffer to prevent memory leaks.
+             * After calling free(), the buffer can be reused for the same text.
+             */
+            free: () => {
+                if (memoryPointer !== null && memoryPointer !== 0) {
+                    try {
+                        this.wasmPrividModules._free(memoryPointer);
+                    }
+                    catch (error) {
+                        printLogs('[WasmWorkerService] free buffer error:', error, 'ERROR');
+                    }
+                    memoryPointer = null;
+                    bufferSize = 0;
+                    cachedArgs = null;
+                }
+            },
+            /**
+             * Check if memory has been allocated
+             */
+            isAllocated: () => memoryPointer !== null && memoryPointer !== 0,
+        };
+    }
+    releasePointers(...pointers) {
+        pointers.forEach((ptr) => {
+            if (ptr !== null && ptr !== 0) {
+                try {
+                    this.wasmPrividModules._free(ptr);
+                }
+                catch (error) {
+                    printLogs('[WasmWorkerService] releasePointers error:', error, 'ERROR');
+                }
+            }
+        });
+    }
+    allocatePointer(size) {
+        try {
+            const ptr = this.wasmPrividModules._malloc(size);
+            return ptr;
+        }
+        catch (error) {
+            printLogs('[WasmWorkerService] allocatePointer error:', error, 'ERROR');
+            return 0;
+        }
+    }
+}
+// Expose the Class using Comlink
+expose(WasmWorkerService);
+//# sourceMappingURL=WasmWorkerService.js.map