@privateid/ultrapass-web-sdk 1.7.0 → 2.0.0

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

@@ -7,12 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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, setDebugType } from '../../modules/internal/shared/shared.utils';
-import { checkCacheAndCurrentAreSameVersion, fetchResource, flatImageDataArraysIntoUint8Array, readCurrentWasmVersion, readFromIndexedDB, removeNullBytesFromDecodedString, writeToIndexedDB, validateCustomWasmUrl, } from './wasm-worker.utils';
+import { checkCacheAndCurrentAreSameVersion, classifyFailureReason, clearCacheEntry, flatImageDataArraysIntoUint8Array, isCacheCorruptionFailure, readCurrentWasmVersion, readFromIndexedDBWithTimeout, removeNullBytesFromDecodedString, validateCustomWasmUrl, validateWasmBinary, writeToCacheQuietly, } from './wasm-worker.utils';
 import { WASM_ULTRA_FOLDER_NAME } from './wasm-worker.constants';
 const callbackRegistry = {
     result: null,
@@ -105,6 +102,11 @@ export class WasmWorkerService {
     loadModules(params, errorCallback, progressCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
+                // Handle session regeneration without re-downloading modules.
+                // This path is used when credentials change (e.g., token refresh) but modules are already loaded.
+                if (this.wasmPrividModules && this.wasmSession && params.shouldRegenerateSession) {
+                    return this.regenerateSession(params, errorCallback, progressCallback);
+                }
                 // If modules are already loaded and session exists, don't re-initialize!
                 // Re-initialization corrupts the WASM state causing _privid_check_models() to return 0
                 if (this.wasmPrividModules && this.wasmSession) {
@@ -116,6 +118,7 @@ export class WasmWorkerService {
                         return { message: 'Already loaded', status: this.lastLoadStatus };
                     }
                     catch (error) {
+                        printLogs('[WasmWorkerService] loadModules error', error);
                         return { message: 'Retrying initialization', status: null };
                     }
                 }
@@ -134,7 +137,40 @@ export class WasmWorkerService {
             }
         });
     }
+    regenerateSession(params, errorCallback, progressCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            printLogs('[WasmWorkerService] Regenerating session as requested', '');
+            // Update callbacks and credentials for the new session
+            this.proxiedErrorCallback = errorCallback;
+            callbackRegistry.error = errorCallback;
+            this.proxiedProgressCallback = progressCallback;
+            callbackRegistry.progress = progressCallback;
+            this.apiUrl = params.apiUrl;
+            this.sessionToken = params.sessionToken;
+            this.publicKey = params.publicKey;
+            // Deinitialize the old session to free C++ heap memory.
+            // Wrapped in try-catch: if deinit throws (e.g., due to the C++ layer's internal state),
+            // we log and proceed -- a leaked session is better than a blocked regeneration.
+            try {
+                this.wasmPrividModules._privid_deinitialize_session(this.wasmSession);
+            }
+            catch (error) {
+                printLogs('[WasmWorkerService] _privid_deinitialize_session failed (non-fatal, proceeding with regeneration)', error, 'WARN');
+            }
+            // Null the existing session so initializeWasmSession creates a new one
+            // (initializeWasmSession returns early if this.wasmSession is already set)
+            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');
+            }
+            this.wasmSession = newSession;
+            return { message: 'Session regenerated', status: this.lastLoadStatus };
+        });
+    }
     loadModulesInternal(params, errorCallback, progressCallback) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.proxiedErrorCallback = errorCallback;
             callbackRegistry.error = errorCallback;
@@ -143,151 +179,53 @@ export class WasmWorkerService {
             this.apiUrl = params.apiUrl;
             this.sessionToken = params.sessionToken;
             this.publicKey = params.publicKey;
-            this.useCdnLink = params.useCdn;
+            this.useCdnLink = (_a = params.useCdn) !== null && _a !== void 0 ? _a : true;
             this.setCache = params.cacheConfig;
             this.isSimd = params.simd;
             this.customWasm = params.customWasm || null;
             this.wasmBaseUrl = params.wasmBaseUrl || null;
-            // Only set debugType if explicitly provided (legacy support)
-            // Note: Debug type is already cached globally from WasmOrchestratorService.initialize()
             if (params.debugType) {
                 this.debugType = params.debugType;
-                // Set debug type onto Web Worker Context
                 setDebugType(params.debugType);
             }
-            // Store WASM folder name from orchestrator (feature flag resolved on main thread)
             if (params.wasmFolderName) {
                 this.wasmFolderName = params.wasmFolderName;
             }
+            if (params.cdnBaseUrl) {
+                this.cdnUrl = params.cdnBaseUrl;
+            }
             printLogs('[WasmWorkerService] isLoad params: ', params);
+            // --- Resolve version ---
             const modulePath = params.simd ? 'simd' : 'nosimd';
             const moduleName = 'privid_fhe_ultra';
-            const cachedModule = yield readFromIndexedDB(WASM_ULTRA_FOLDER_NAME);
             const currentModuleVersionJSON = yield readCurrentWasmVersion(modulePath, this.wasmBaseUrl, this.getWasmFolderName());
             this.currentWasmVersion = currentModuleVersionJSON.version;
-            printLogs('[WasmWorkerService] currentModuleVersionJSON: ', currentModuleVersionJSON.version);
-            // If custom WASM config is provided, validate and load with fallback
-            if (this.customWasm) {
-                printLogs('[WasmWorkerService] Custom WASM detected, validating...', this.customWasm);
-                const isValid = yield validateCustomWasmUrl(this.customWasm.url);
-                if (isValid) {
-                    const expectedVersion = currentModuleVersionJSON.version;
-                    const providedVersion = this.customWasm.version;
-                    // Check version equality
-                    if (providedVersion !== expectedVersion) {
-                        printLogs('[WasmWorkerService] Version mismatch detected, falling back to CDN', { expected: expectedVersion, provided: providedVersion }, 'WARN');
-                        this.customWasm = null;
-                        this.lastLoadStatus = { source: 'custom-fallback', versionMatch: false };
-                        // Continue with normal cache/CDN flow
-                    }
-                    else {
-                        printLogs('[WasmWorkerService] Version match confirmed', { version: providedVersion });
-                        // Proceed with loading
-                        printLogs('[WasmWorkerService] Custom WASM URL is valid, loading...', this.customWasm.url);
-                        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);
-                        }
-                        this.lastLoadStatus = { source: 'custom', versionMatch: true };
-                        return { message: 'Loaded from custom URL', status: this.lastLoadStatus };
-                    }
-                }
-                else {
-                    printLogs('[WasmWorkerService] Custom WASM URL validation failed, falling back to CDN', '', 'WARN');
-                    this.customWasm = null;
-                    this.lastLoadStatus = { source: 'custom-fallback', versionMatch: false };
-                    // Continue with normal cache/CDN flow
-                }
-            }
-            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 { message: 'Loaded from package (cache invalid)', status: this.lastLoadStatus };
-                            }
-                            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);
-                            if (!this.lastLoadStatus) {
-                                this.lastLoadStatus = { source: 'cache', versionMatch: true };
-                            }
-                            return { message: 'Loaded from cache (wasm and script)', status: this.lastLoadStatus };
-                        }
-                        catch (error) {
-                            printLogs('[WasmWorkerService] Error loading from cache:', error, 'ERROR');
-                            yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
-                            return { message: 'Loaded from package (cache error)', status: this.lastLoadStatus };
-                        }
-                        finally {
-                            // Clean up the blob URL
-                            URL.revokeObjectURL(blobUrl);
-                        }
-                    }
-                }
-                else if (this.wasmPrividModules && params.shouldRegenerateSession) {
-                    printLogs('[WasmWorkerService] Regenerating session as requested', '');
-                    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');
-                    }
-                    this.wasmSession = newSession;
-                }
-                else {
-                    yield this.loadFromPackage(currentModuleVersionJSON.version, modulePath, moduleName, params.usageScenario, params.cacheContent);
-                    return { message: 'Loaded', status: this.lastLoadStatus };
-                }
-                // 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);
-                }
-                if (!this.lastLoadStatus) {
-                    this.lastLoadStatus = { source: 'cache', versionMatch: true };
-                }
-                return { message: 'Cache Loaded', status: this.lastLoadStatus };
-            }
-            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);
-            }
-            if (!this.lastLoadStatus) {
-                this.lastLoadStatus = { source: 'cdn', versionMatch: true };
-            }
-            return { message: 'Loaded', status: this.lastLoadStatus };
-        });
-    }
-    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);
+            // --- Resolve WASM module through tier pipeline ---
+            // Note: this.setCache may be undefined when cacheConfig is not passed in LoadParams.
+            // Default to true to match WasmOrchestratorService behavior (hardcodes cacheConfig: true).
+            const ctx = {
+                modulePath,
+                moduleName,
+                version: currentModuleVersionJSON.version,
+                saveCache: (_b = this.setCache) !== null && _b !== void 0 ? _b : true,
+            };
+            const result = yield this.resolveWasmModule(ctx);
+            this.wasmPrividModules = result.module;
+            this.lastLoadStatus = result.status;
+            // --- Initialize WASM session ---
             if (!this.checkWasmLoaded) {
-                yield this.initializeWasmSession(usageScenario, cache_content);
+                yield this.initializeWasmSession(params.usageScenario, params.cacheContent);
                 this.checkWasmLoaded = true;
             }
-            return true;
+            // --- Final verification ---
+            if (!this.wasmPrividModules || !this.wasmSession) {
+                throw new Error('WASM modules loaded but session not initialized');
+            }
+            printLogs(`[WasmWorkerService] Load complete. Source: ${result.status.source}, Attempts: ${result.attempts.length}`, result.attempts);
+            return {
+                message: `Loaded from ${result.status.source}`,
+                status: this.lastLoadStatus,
+            };
         });
     }
     /**
@@ -300,85 +238,31 @@ export class WasmWorkerService {
         }
         return `../wasm/${relativePath}`;
     }
-    loadWasmModule(modulePath, moduleName, saveCache, version) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If custom WASM config is provided (e.g., from iOS WebView), use it directly
-            if (this.customWasm) {
-                printLogs('[WasmWorkerService] Using custom WASM URL:', this.customWasm.url);
-                // For custom URLs, we still need the JS file from the normal location
-                const scriptUrls = {
-                    cdn: `${this.cdnUrl}/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.js`,
-                    local: this.getLocalWasmUrl(`${this.getWasmFolderName()}/${modulePath}/${version}/${moduleName}.js`),
-                };
-                const wasm = yield fetch(this.customWasm.url);
-                if (!wasm.ok) {
-                    throw new Error(`Failed to fetch custom WASM from ${this.customWasm.url}: ${wasm.status}`);
-                }
-                const script = yield fetchResource(scriptUrls, this.useCdnLink);
-                const scriptBuffer = yield script.text();
-                const buffer = yield wasm.arrayBuffer();
-                printLogs(`[WasmWorkerService] loadWasmModule script and buffer from custom URL': `, { scriptBuffer, buffer });
-                const blob = new Blob([scriptBuffer], { type: 'application/javascript' });
-                const blobUrl = URL.createObjectURL(blob);
-                try {
-                    importScripts(blobUrl);
-                    if (typeof createTFLiteModule === 'undefined') {
-                        throw new Error('createTFLiteModule not defined after loading script');
-                    }
-                    const module = yield createTFLiteModule({ wasmBinary: buffer });
-                    printLogs('[WasmWorkerService] loadWasmModule module from custom URL: ', module);
-                    // Note: We don't cache when using custom URLs as they're iOS-specific
-                    return module;
-                }
-                catch (error) {
-                    printLogs('[WasmWorkerService] Error loading WASM module from custom URL:', error, 'ERROR');
-                    throw error;
-                }
-                finally {
-                    URL.revokeObjectURL(blobUrl);
-                }
-            }
-            // Standard loading path (CDN or local)
-            const wasmUrls = {
-                cdn: `${this.cdnUrl}/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.wasm`,
-                local: this.getLocalWasmUrl(`${this.getWasmFolderName()}/${modulePath}/${version}/${moduleName}.wasm`),
-            };
-            const scriptUrls = {
-                cdn: `${this.cdnUrl}/${WASM_ULTRA_FOLDER_NAME}/${modulePath}/${version}/${moduleName}.js`,
-                local: this.getLocalWasmUrl(`${this.getWasmFolderName()}/${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);
+    /**
+     * Loads a script via direct URL importScripts with CDN/local fallback.
+     * Avoids blob: URLs which are blocked by strict Content-Security-Policy.
+     */
+    importScriptFromUrl(scriptUrls) {
+        let localError;
+        try {
+            importScripts(scriptUrls.local);
+            return;
+        }
+        catch (error) {
+            localError = error;
+            printLogs('[WasmWorkerService] Local importScripts failed, trying CDN', localError, 'WARN');
+        }
+        if (this.useCdnLink) {
             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;
+                importScripts(scriptUrls.cdn);
             }
-            finally {
-                // Clean up the blob URL to free memory
-                URL.revokeObjectURL(blobUrl);
+            catch (cdnError) {
+                throw new Error(`Both local and CDN importScripts failed. Local error: ${localError}; CDN error: ${cdnError}`);
             }
-        });
+        }
+        else {
+            throw new Error(`Local importScripts failed and CDN is disabled: ${localError}`);
+        }
     }
     initializeWasmSession(usageScenario = '', cache_content = '') {
         return __awaiter(this, void 0, void 0, function* () {
@@ -403,6 +287,184 @@ export class WasmWorkerService {
             return wasmSessionPointer;
         });
     }
+    resolveWasmModule(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const attempts = [];
+            const tiers = [];
+            console.log('[WasmWorkerService] resolveWasmModule ctx:', ctx);
+            // Build tier list based on configuration
+            if (this.customWasm) {
+                tiers.push({
+                    source: 'custom',
+                    obtain: () => this.obtainFromCustomUrl(this.customWasm, ctx.version),
+                    shouldCache: false,
+                });
+            }
+            tiers.push({
+                source: 'cache',
+                obtain: () => this.obtainFromCache(ctx.version),
+                shouldCache: false,
+            });
+            tiers.push({
+                source: 'local',
+                obtain: () => this.obtainFromNetwork(ctx, 'local'),
+                shouldCache: ctx.saveCache,
+            });
+            if (this.useCdnLink) {
+                tiers.push({
+                    source: 'cdn',
+                    obtain: () => this.obtainFromNetwork(ctx, 'cdn'),
+                    shouldCache: ctx.saveCache,
+                });
+            }
+            // Load the Emscripten JS runtime once for ctx.modulePath (SIMD or noSIMD).
+            // If SIMD compilation fails later, compileWasmBinary -> obtainFromNetworkWithFallback
+            // reloads the noSIMD JS runtime separately (it's a different Emscripten build).
+            // Wrapped in try-catch to add context: if this fails, no tier can succeed because
+            // createTFLiteModule won't be defined. The error is rethrown with the original message
+            // preserved so callers see both the context and the root cause.
+            try {
+                this.loadWasmRuntime(ctx);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                throw new Error(`WASM JS runtime failed to load for ${ctx.modulePath}/${ctx.version}: ${msg}`);
+            }
+            let fallback;
+            for (const tier of tiers) {
+                try {
+                    const buffer = yield tier.obtain();
+                    const validation = validateWasmBinary(buffer);
+                    if (!validation.valid) {
+                        throw new Error(`Validation failed: ${validation.reason}`);
+                    }
+                    const module = yield this.compileWasmBinary(buffer, ctx);
+                    if (tier.shouldCache) {
+                        yield writeToCacheQuietly(buffer, module, this.getWasmFolderName());
+                    }
+                    attempts.push({ source: tier.source, success: true });
+                    // Determine the reported source. When the custom URL tier failed and we fell
+                    // back to cache/CDN, the source is the successful tier but we also record the
+                    // custom-fallback status for backward compatibility with existing consumers.
+                    const reportedSource = (fallback === null || fallback === void 0 ? void 0 : fallback.originalSource) === 'custom' ? 'custom-fallback' : tier.source;
+                    const versionMatch = reportedSource !== 'custom-fallback';
+                    return {
+                        module,
+                        status: Object.assign({ source: reportedSource, versionMatch }, (fallback && { fallback })),
+                        attempts,
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    attempts.push({ source: tier.source, success: false, error: errorMessage });
+                    printLogs(`[WasmWorkerService] Tier '${tier.source}' failed: ${errorMessage}`, error, 'WARN');
+                    // Record the first failure as the fallback reason (skip both 'local' and 'cdn' since both are network tiers)
+                    if (!fallback && tier.source !== 'cdn' && tier.source !== 'local') {
+                        fallback = {
+                            originalSource: tier.source,
+                            reason: classifyFailureReason(error),
+                        };
+                    }
+                    // Only evict cache on corruption-related failures (validation failed, corrupted data).
+                    // Do NOT evict on cache miss or version mismatch -- those are normal operational states.
+                    if (tier.source === 'cache' && isCacheCorruptionFailure(error)) {
+                        yield clearCacheEntry(this.getWasmFolderName()).catch(() => { });
+                    }
+                }
+            }
+            throw new Error(`All WASM loading tiers failed. Attempts: ${JSON.stringify(attempts)}`);
+        });
+    }
+    loadWasmRuntime(ctx) {
+        const scriptUrls = {
+            cdn: `${this.cdnUrl}/${this.getWasmFolderName()}/${ctx.modulePath}/${ctx.version}/${ctx.moduleName}.js`,
+            local: this.getLocalWasmUrl(`${this.getWasmFolderName()}/${ctx.modulePath}/${ctx.version}/${ctx.moduleName}.js`),
+        };
+        this.importScriptFromUrl(scriptUrls);
+        if (typeof createTFLiteModule === 'undefined') {
+            throw new Error('createTFLiteModule not defined after loading WASM runtime');
+        }
+    }
+    obtainFromCache(expectedVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cached = yield readFromIndexedDBWithTimeout(this.getWasmFolderName());
+            if (!cached || !cached.cachedWasm) {
+                throw new Error('Cache miss: no cached WASM found');
+            }
+            if (!checkCacheAndCurrentAreSameVersion(cached, { version: expectedVersion })) {
+                throw new Error(`Cache version mismatch: cached=${cached.version}, expected=${expectedVersion}`);
+            }
+            return cached.cachedWasm;
+        });
+    }
+    obtainFromCustomUrl(customWasm, expectedVersion) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Step 1: Validate the URL is accessible (HEAD request, matches existing behavior)
+            const isValid = yield validateCustomWasmUrl(customWasm.url);
+            if (!isValid) {
+                throw new Error(`Custom URL validation failed for ${customWasm.url}`);
+            }
+            // Step 2: Version check -- prevent loading a WASM binary with the wrong version,
+            // which could cause silent failures or crashes in the C++ layer.
+            if (customWasm.version !== expectedVersion) {
+                printLogs('[WasmWorkerService] Custom WASM version mismatch', { expected: expectedVersion, provided: customWasm.version }, 'WARN');
+                throw new Error(`Custom URL version mismatch: provided=${customWasm.version}, expected=${expectedVersion}`);
+            }
+            // Step 3: Fetch the binary
+            const response = yield fetch(customWasm.url);
+            if (!response.ok) {
+                throw new Error(`Custom URL fetch failed: ${response.status} for ${customWasm.url}`);
+            }
+            return response.arrayBuffer();
+        });
+    }
+    obtainFromNetwork(ctx, source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wasmUrl = source === 'cdn'
+                ? `${this.cdnUrl}/${this.getWasmFolderName()}/${ctx.modulePath}/${ctx.version}/${ctx.moduleName}.wasm`
+                : this.getLocalWasmUrl(`${this.getWasmFolderName()}/${ctx.modulePath}/${ctx.version}/${ctx.moduleName}.wasm`);
+            const response = yield fetch(wasmUrl);
+            if (!response.ok) {
+                throw new Error(`Fetch failed: ${response.status} for ${wasmUrl}`);
+            }
+            return response.arrayBuffer();
+        });
+    }
+    compileWasmBinary(wasmBinary, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield createTFLiteModule({ wasmBinary });
+            }
+            catch (error) {
+                if (error instanceof WebAssembly.CompileError && ctx.modulePath === 'simd') {
+                    printLogs('[WasmWorkerService] SIMD CompileError -- retrying with noSIMD', error, 'WARN');
+                    return this.obtainFromNetworkWithFallback(ctx);
+                }
+                throw error;
+            }
+        });
+    }
+    obtainFromNetworkWithFallback(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const noSimdCtx = Object.assign(Object.assign({}, ctx), { modulePath: 'nosimd' });
+            // Fetch noSIMD binary from network (local first, CDN fallback)
+            let buffer;
+            try {
+                buffer = yield this.obtainFromNetwork(noSimdCtx, 'local');
+            }
+            catch (localError) {
+                if (this.useCdnLink) {
+                    buffer = yield this.obtainFromNetwork(noSimdCtx, 'cdn');
+                }
+                else {
+                    throw new Error(`Local noSIMD fetch failed and CDN is disabled: ${localError}`);
+                }
+            }
+            // Load the noSIMD JS runtime (overwrites the global createTFLiteModule)
+            this.loadWasmRuntime(noSimdCtx);
+            return createTFLiteModule({ wasmBinary: buffer });
+        });
+    }
     ultraEnroll(params, resultCallback) {
         return __awaiter(this, void 0, void 0, function* () {
             callbackRegistry.result = resultCallback;
@@ -859,6 +921,7 @@ export class WasmWorkerService {
                     yield this.moduleInitializationLock;
                 }
                 catch (error) {
+                    printLogs('[WasmWorkerService] ensureModulesInitialized: Initialization failed during wait', error, 'ERROR');
                     return false;
                 }
             }
@@ -881,6 +944,7 @@ export class WasmWorkerService {
                     }, this.proxiedErrorCallback);
                 }
                 catch (error) {
+                    printLogs('[WasmWorkerService] ensureModulesInitialized: Failed to load WASM modules', error, 'ERROR');
                     return false;
                 }
             }