@anonympins/fingerprint 0.3.7 → 0.4.0

package/src/js/mongodb-store.js

@@ -1,80 +1,80 @@
-/**
- * @file Creates a store adapter for MongoDB.
- * This adapter uses a collection as a key-value store and leverages MongoDB's TTL indexes
- * for automatic expiration of documents.
- */
-
-/**
- * Creates a store adapter for a MongoDB collection.
- * It's recommended to pass the `db` object and let the adapter handle the collection.
- *
- * **Note:** For TTL to work, you must create a TTL index on the `expiresAt` field in your collection.
- * In the mongo shell, run:
- * `db.yourCollectionName.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 })`
- *
- * @param {import('mongodb').Db} db - An instance of a MongoDB Db object.
- * @param {string} [collectionName='fingerprint_store'] - The name of the collection to use.
- * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
- */
-export function createMongoDbStore(db, collectionName = 'fingerprint_store') {
-  const collection = db.collection(collectionName);
-  
-  // Custom replacer/reviver to handle Set serialization (identical to Redis/SQL stores)
-  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
-  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
-
-  return {
-    async get(key) {
-      const doc = await collection.findOne({ _id: key });
-      if (!doc) return null;
-
-      // Active expiration check to bypass eventual consistency of MongoDB's 60s TTL cleanup daemon
-      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
-        await this.delete(key);
-        return null;
-      }
-
-      try {
-        return JSON.parse(doc.value, reviver);
-      } catch (e) {
-        // Fallback for legacy un-serialized raw values
-        return doc.value;
-      }
-    },
-    async set(key, value, ttl) {
-      const stringValue = JSON.stringify(value, replacer);
-      const doc = {
-        _id: key,
-        value: stringValue,
-      };
-
-      if (ttl && ttl > 0) {
-        // Set the expiration date for the TTL index.
-        doc.expiresAt = new Date(Date.now() + ttl * 1000);
-      }
-
-      await collection.updateOne(
-        { _id: key },
-        { $set: doc },
-        { upsert: true }
-      );
-    },
-    async has(key) {
-      const doc = await collection.findOne({ _id: key }, { projection: { expiresAt: 1 } });
-      if (!doc) return false;
-
-      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
-        await this.delete(key);
-        return false;
-      }
-      return true;
-    },
-    async delete(key) {
-      await collection.deleteOne({ _id: key });
-    },
-    async init() {
-      // Automates index configuration
-      await collection.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 });
-    }
-  };
+/**
+ * @file Creates a store adapter for MongoDB.
+ * This adapter uses a collection as a key-value store and leverages MongoDB's TTL indexes
+ * for automatic expiration of documents.
+ */
+
+/**
+ * Creates a store adapter for a MongoDB collection.
+ * It's recommended to pass the `db` object and let the adapter handle the collection.
+ *
+ * **Note:** For TTL to work, you must create a TTL index on the `expiresAt` field in your collection.
+ * In the mongo shell, run:
+ * `db.yourCollectionName.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 })`
+ *
+ * @param {import('mongodb').Db} db - An instance of a MongoDB Db object.
+ * @param {string} [collectionName='fingerprint_store'] - The name of the collection to use.
+ * @returns {import('./fingerprint.js').IStore} An object that complies with the IStore interface.
+ */
+export function createMongoDbStore(db, collectionName = 'fingerprint_store') {
+  const collection = db.collection(collectionName);
+  
+  // Custom replacer/reviver to handle Set serialization (identical to Redis/SQL stores)
+  const replacer = (k, v) => (v instanceof Set ? Array.from(v) : v);
+  const reviver = (k, v) => (k === 'ips' && Array.isArray(v) ? new Set(v) : v);
+
+  return {
+    async get(key) {
+      const doc = await collection.findOne({ _id: key });
+      if (!doc) return null;
+
+      // Active expiration check to bypass eventual consistency of MongoDB's 60s TTL cleanup daemon
+      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
+        await this.delete(key);
+        return null;
+      }
+
+      try {
+        return JSON.parse(doc.value, reviver);
+      } catch (e) {
+        // Fallback for legacy un-serialized raw values
+        return doc.value;
+      }
+    },
+    async set(key, value, ttl) {
+      const stringValue = JSON.stringify(value, replacer);
+      const doc = {
+        _id: key,
+        value: stringValue,
+      };
+
+      if (ttl && ttl > 0) {
+        // Set the expiration date for the TTL index.
+        doc.expiresAt = new Date(Date.now() + ttl * 1000);
+      }
+
+      await collection.updateOne(
+        { _id: key },
+        { $set: doc },
+        { upsert: true }
+      );
+    },
+    async has(key) {
+      const doc = await collection.findOne({ _id: key }, { projection: { expiresAt: 1 } });
+      if (!doc) return false;
+
+      if (doc.expiresAt && new Date(doc.expiresAt) < new Date()) {
+        await this.delete(key);
+        return false;
+      }
+      return true;
+    },
+    async delete(key) {
+      await collection.deleteOne({ _id: key });
+    },
+    async init() {
+      // Automates index configuration
+      await collection.createIndex({ "expiresAt": 1 }, { expireAfterSeconds: 0 });
+    }
+  };
 }

package/src/js/pow.solver.inline.js

@@ -22,6 +22,24 @@ async function solveCpuTargetInline(baseBlock, target, progressCallback) {
     const cpuTarget = typeof target === 'bigint' ? target : BigInt('0x' + target);
     // --- END FIX ---
     const encoder = new TextEncoder();
+
+    const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
+    if (wasmModule && typeof wasmModule._solve_cpu_target === 'function') {
+        const len = baseBlock.length;
+        const ptr = wasmModule._malloc(len);
+        wasmModule.HEAPU8.set(baseBlock, ptr);
+        const targetStr = typeof target === 'string' ? target : target.toString(16);
+        const targetPtr = wasmModule._malloc(targetStr.length + 1);
+        for (let i = 0; i < targetStr.length; i++) {
+            wasmModule.HEAP8[targetPtr + i] = targetStr.charCodeAt(i);
+        }
+        wasmModule.HEAP8[targetPtr + targetStr.length] = 0;
+        const solution = wasmModule._solve_cpu_target(ptr, len, targetPtr);
+        wasmModule._free(ptr);
+        wasmModule._free(targetPtr);
+        return solution;
+    }
+
     let cpuSolution = 0;
 
     while (true) {
@@ -101,6 +119,19 @@ async function solveMemory(seed, difficulty) {
     const YIELD_THRESHOLD = 100000;
     const size = difficulty * 1024 * 1024;
     const buffer = new Uint32Array(size / 4);
+
+    const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
+    if (wasmModule && typeof wasmModule._solve_memory_challenge === 'function') {
+        const seedPtr = wasmModule._malloc(seed.length + 1);
+        for (let i = 0; i < seed.length; i++) {
+            wasmModule.HEAP8[seedPtr + i] = seed.charCodeAt(i);
+        }
+        wasmModule.HEAP8[seedPtr + seed.length] = 0;
+        const solution = wasmModule._solve_memory_challenge(seedPtr, difficulty);
+        wasmModule._free(seedPtr);
+        return solution;
+    }
+
     let h = new TextEncoder().encode(seed).reduce((acc, v) => acc + v, 0);
     for (let i = 0; i < buffer.length; i++) {
         buffer[i] = (h = Math.imul(h ^ i, 1597334677));

package/src/js/pow.solver.js

@@ -25,6 +25,24 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
     const cpuTarget = typeof target === 'bigint' ? target : BigInt('0x' + target);
     // --- END FIX ---
     const encoder = new TextEncoder();
+
+    const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
+    if (wasmModule && typeof wasmModule._solve_cpu_target === 'function') {
+        const len = baseBlock.length;
+        const ptr = wasmModule._malloc(len);
+        wasmModule.HEAPU8.set(baseBlock, ptr);
+        const targetStr = typeof target === 'string' ? target : target.toString(16);
+        const targetPtr = wasmModule._malloc(targetStr.length + 1);
+        for (let i = 0; i < targetStr.length; i++) {
+            wasmModule.HEAP8[targetPtr + i] = targetStr.charCodeAt(i);
+        }
+        wasmModule.HEAP8[targetPtr + targetStr.length] = 0;
+        const solution = wasmModule._solve_cpu_target(ptr, len, targetPtr);
+        wasmModule._free(ptr);
+        wasmModule._free(targetPtr);
+        return solution;
+    }
+
     let cpuSolution = 0;
 
     while (true) {
@@ -102,6 +120,19 @@ export async function solveMemory(seed, difficulty) {
     const YIELD_THRESHOLD = 100000;
     const size = difficulty * 1024 * 1024;
     const buffer = new Uint32Array(size / 4);
+
+    const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
+    if (wasmModule && typeof wasmModule._solve_memory_challenge === 'function') {
+        const seedPtr = wasmModule._malloc(seed.length + 1);
+        for (let i = 0; i < seed.length; i++) {
+            wasmModule.HEAP8[seedPtr + i] = seed.charCodeAt(i);
+        }
+        wasmModule.HEAP8[seedPtr + seed.length] = 0;
+        const solution = wasmModule._solve_memory_challenge(seedPtr, difficulty);
+        wasmModule._free(seedPtr);
+        return solution;
+    }
+
     let h = new TextEncoder().encode(seed).reduce((acc, v) => acc + v, 0);
 
     for (let i = 0; i < buffer.length; i++) {

package/src/js/tests/fingerprint.builder.test.js

@@ -0,0 +1,79 @@
+import {describe, expect, it} from 'vitest';
+import {FingerprintBuilder} from '../fingerprint.builder.js';
+
+describe('FingerprintBuilder.compare', () => {
+
+    // Empreinte réaliste d'un utilisateur légitime (ex: Chrome sur Windows)
+    // C'est l'empreinte qui serait stockée lors de la première visite.
+    const realisticOriginalFp = new FingerprintBuilder()
+        .add('cvs', 'mock-canvas-data-v1')
+        .add('gpu', 'ANGLE (NVIDIA GeForce RTX 3080 Direct3D11 vs_5_0 ps_5_0)')
+        .add('hw', '16_8_0') // 16 cores, 8GB RAM, no touch
+        .add('os', 'Win32')
+        .add('ua', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36')
+        .add('ja3', '771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0')
+        // En-têtes qui peuvent changer lors de la requête de résolution du challenge
+        .add('cookie_keys', '_ga,session,device_id')
+        .add('upgrade', '1')
+        .toString();
+
+    it('should return a similarity score of 1.0 for the same device with minor volatile changes', () => {
+        // Scénario de succès : L'utilisateur résout un challenge.
+        // L'empreinte du solveur est presque identique, mais certains en-têtes "volatils"
+        // (comme la présence de cookies ou 'upgrade-insecure-requests') ont changé ou disparu.
+        // La fonction `compare` est conçue pour ignorer ces clés volatiles.
+        const realisticSolverFp = new FingerprintBuilder()
+            .add('cvs', 'mock-canvas-data-v1') // Identique
+            .add('gpu', 'ANGLE (NVIDIA GeForce RTX 3080 Direct3D11 vs_5_0 ps_5_0)') // Identique
+            .add('hw', '16_8_0') // Identique
+            .add('os', 'Win32') // Identique
+            .add('ua', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36') // Identique
+            .add('ja3', '771,4865-4866-4867-49195-49199-49196-49200-52393-52392-49171-49172-156-157-47-53,0-23-65281-10-11-35-16-5-13-18-51-45-43-27-17513,29-23-24,0') // Identique
+            // La clé 'cookie_keys' est absente, simulant une requête sans cookies.
+            // La clé 'upgrade' est également absente.
+            .toString();
+
+        const similarity = FingerprintBuilder.compare(realisticOriginalFp, realisticSolverFp);
+
+        // La similarité doit être de 1.0 car toutes les différences concernent des clés volatiles
+        // qui sont ignorées par la comparaison.
+        expect(similarity).toBe(1.0);
+    });
+
+    it('should return a low similarity score for two completely different devices', () => {
+        // Scénario d'échec : Un attaquant a volé le cookie `device_id` et tente de
+        // résoudre un challenge depuis une machine différente (ex: un serveur Linux avec Firefox).
+        const differentSolverFp = new FingerprintBuilder()
+            .add('cvs', 'different-canvas-data') // Différent
+            .add('gpu', 'llvmpipe (LLVM 15.0.7, 256 bits)') // Différent (GPU de VM)
+            .add('hw', '8_4_0') // Différent
+            .add('os', 'Linux x86_64') // Différent
+            .add('ua', 'Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0') // Différent
+            .add('ja3', '771,49195-49199-52393-52392-49196-49200-49162-49161-49171-49172-156-157-47-53,65281-11-10-35-16-5-13-51-45-43-27-23-17513,29-23-24,0') // Différent (JA3 de Firefox)
+            .toString();
+
+        const similarity = FingerprintBuilder.compare(realisticOriginalFp, differentSolverFp);
+
+        // La similarité doit être très faible (proche de 0) car tous les signaux forts sont différents.
+        expect(similarity).toBeLessThan(0.1);
+    });
+
+    it('should return 0 if one of the fingerprints is null or empty', () => {
+        expect(FingerprintBuilder.compare(realisticOriginalFp, null)).toBe(0);
+        expect(FingerprintBuilder.compare(null, realisticOriginalFp)).toBe(0);
+        expect(FingerprintBuilder.compare(realisticOriginalFp, '')).toBe(0);
+        expect(FingerprintBuilder.compare('', realisticOriginalFp)).toBe(0);
+        expect(FingerprintBuilder.compare(null, null)).toBe(0);
+    });
+
+    it('should handle fingerprints with missing components gracefully', () => {
+        const partialFp = new FingerprintBuilder()
+            .add('ua', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36')
+            .add('os', 'Win32')
+            .toString(); // Manque GPU, canvas, etc.
+
+        const similarity = FingerprintBuilder.compare(realisticOriginalFp, partialFp);
+        expect(similarity).toBeGreaterThan(0);
+        expect(similarity).toBeLessThan(1);
+    });
+});

package/src/js/tests/fingerprint.client.init.test.js

@@ -0,0 +1,120 @@
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import {JSDOM} from 'jsdom';
+import ClientLibrary from '../fingerprint.client.js';
+
+// --- Setup JSDOM Environment ---
+// Vitest peut être configuré pour le faire automatiquement, mais le faire manuellement
+// ici rend le test explicite et portable.
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+    url: 'http://localhost',
+});
+
+// In recent Node.js versions, some global properties like 'navigator', 'performance',
+// and 'screen' are read-only. To ensure our JSDOM environment works correctly across
+// all versions, we use Object.defineProperty to make these properties writable.
+Object.defineProperty(global, 'window', { value: dom.window, writable: true });
+Object.defineProperty(global, 'document', { value: dom.window.document, writable: true });
+Object.defineProperty(global, 'navigator', { value: dom.window.navigator, writable: true });
+Object.defineProperty(global, 'screen', { value: dom.window.screen, writable: true });
+Object.defineProperty(global, 'performance', { value: dom.window.performance, writable: true });
+
+global.fetch = vi.fn(); // Mock global fetch
+global.Headers = dom.window.Headers;
+global.Request = dom.window.Request;
+global.URL = dom.window.URL;
+global.TextEncoder = dom.window.TextEncoder;
+
+
+describe('ClientLibrary.initializeClient', () => {
+
+    // On utilise des espions (spies) pour vérifier si les méthodes internes sont appelées.
+    let startMouseSpy, startKeystrokeSpy, initHoneypotsSpy, injectTrapsSpy, initFetchSpy;
+
+    beforeEach(() => {
+        // Réinitialiser l'état du client avant chaque test
+        ClientLibrary._resetCache();
+
+        // Créer les espions sur les méthodes internes
+        startMouseSpy = vi.spyOn(ClientLibrary, 'startMouseEntropyTracker');
+        startKeystrokeSpy = vi.spyOn(ClientLibrary, 'startKeystrokeDynamicsTracker');
+        initHoneypotsSpy = vi.spyOn(ClientLibrary, 'initializeHoneypots');
+        injectTrapsSpy = vi.spyOn(ClientLibrary, 'injectTrapLinks');
+        initFetchSpy = vi.spyOn(ClientLibrary, 'initializeFetch');
+    });
+
+    afterEach(() => {
+        // Restaurer les espions après chaque test pour ne pas affecter les autres tests
+        vi.restoreAllMocks();
+    });
+
+    it('should enable all trackers by default', () => {
+        ClientLibrary.initializeClient();
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+    });
+
+    it('should disable mouse and keystroke trackers when configured', () => {
+        ClientLibrary.initializeClient({ mouse: false, keystrokes: false });
+
+        expect(startMouseSpy).not.toHaveBeenCalled();
+        expect(startKeystrokeSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize honeypots with the provided field names', () => {
+        const honeypotFields = ['email_confirm', 'user_nickname'];
+        ClientLibrary.initializeClient({ honeypots: honeypotFields });
+
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(honeypotFields);
+    });
+
+    it('should not initialize honeypots if the array is empty', () => {
+        ClientLibrary.initializeClient({ honeypots: [] });
+
+        expect(initHoneypotsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should inject trap URLs when provided', () => {
+        const urls = ['/trap1?sig=123', '/trap2?sig=456'];
+        ClientLibrary.initializeClient({ trapUrls: urls });
+
+        expect(injectTrapsSpy).toHaveBeenCalledWith(urls);
+    });
+
+    it('should not inject trap URLs if the array is empty', () => {
+        ClientLibrary.initializeClient({ trapUrls: [] });
+
+        expect(injectTrapsSpy).not.toHaveBeenCalled();
+    });
+
+    it('should initialize fetch interception when fetch config is present', () => {
+        const targetDomains = ['api.example.com'];
+        ClientLibrary.initializeClient({ fetch: { targetDomains } });
+
+        expect(initFetchSpy).toHaveBeenCalledWith(targetDomains);
+    });
+
+    it('should not initialize fetch interception if fetch config is absent', () => {
+        ClientLibrary.initializeClient(); // No fetch config
+
+        expect(initFetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('should call all initializers correctly when a full config is provided', () => {
+        const config = {
+            mouse: true,
+            keystrokes: true,
+            honeypots: ['field1'],
+            trapUrls: ['/trap1'],
+            fetch: { targetDomains: ['api.com'] }
+        };
+        ClientLibrary.initializeClient(config);
+
+        expect(startMouseSpy).toHaveBeenCalled();
+        expect(startKeystrokeSpy).toHaveBeenCalled();
+        expect(initHoneypotsSpy).toHaveBeenCalledWith(config.honeypots);
+        expect(injectTrapsSpy).toHaveBeenCalledWith(config.trapUrls);
+        expect(initFetchSpy).toHaveBeenCalledWith(config.fetch.targetDomains);
+    });
+
+});

package/src/js/tests/fingerprint.client.test.js

@@ -0,0 +1,105 @@
+/**
+ * @vitest-environment jsdom
+ */
+
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import ClientLibrary from '../fingerprint.client.js';
+
+describe('ClientLibrary WASM Integration', () => {
+    beforeEach(() => {
+        // Réinitialise le cache et les mocks avant chaque test
+        ClientLibrary._resetCache();
+        vi.spyOn(console, 'log').mockImplementation(() => {});
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+        // Supprime les mocks globaux pour éviter les fuites entre les tests
+        delete window.createFingerprintModule;
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('should successfully load WASM module and switch hasher', async () => {
+        // 1. Simuler un module WASM fonctionnel
+        const mockWasmModule = {
+            _hash_string: vi.fn((str) => 99999), // Un mock qui retourne une valeur distincte
+        };
+
+        // 2. Simuler le chargement du script et l'initialisation du module
+        // On attache les fonctions de simulation à `window` car c'est ce que le code cherche
+        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
+
+        // On simule l'injection du script en appelant directement `onload`
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            // Simule le chargement réussi du script
+            script.onload();
+            return script;
+        });
+
+        // 3. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 4. Vérifier que le hasher a été remplacé
+        const wasmHash = ClientLibrary._hasher("test");
+        expect(wasmHash).toBe(99999);
+        expect(mockWasmModule._hash_string).toHaveBeenCalledWith("test");
+        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
+    });
+
+    it('should gracefully fall back to JS hasher if WASM module fails to load', async () => {
+        // 1. Simuler un échec de chargement du script
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            script.onerror(new Error('Script loading failed'));
+            return script;
+        });
+
+        // 2. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 3. Vérifier que le hasher est toujours l'implémentation JS
+        const jsHash = ClientLibrary._hasher("test");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
+        
+        expect(jsHash).toBe(originalJsHash);
+        expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'), expect.any(Error));
+    });
+
+    it('should gracefully fall back if WASM module does not export _hash_string', async () => {
+        // 1. Simuler un module WASM malformé (sans la fonction attendue)
+        const mockWasmModule = {};
+        window.createFingerprintModule = vi.fn().mockResolvedValue(mockWasmModule);
+
+        vi.spyOn(document.head, 'appendChild').mockImplementation((script) => {
+            script.onload();
+            return script;
+        });
+
+        // 2. Appeler la fonction d'initialisation
+        await ClientLibrary.initializeWasm('/fake/path/to/fp.js');
+
+        // 3. Vérifier le fallback
+        const jsHash = ClientLibrary._hasher("test");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("test");
+        expect(jsHash).toBe(originalJsHash); 
+        // L'assertion est maintenant plus précise : elle vérifie le message générique ET le message d'erreur spécifique.
+        expect(console.warn).toHaveBeenCalledWith(
+            expect.stringContaining('WASM module failed to load'), 
+            expect.objectContaining({ message: 'WASM module did not export _hash_string.' })
+        );
+    });
+
+    it('should use the default JS hasher if WASM is not configured', async () => {
+        // Ensure no WASM path is provided in the config
+        ClientLibrary.initializeClient({});
+
+        // Verify that the active hasher is the original JS implementation
+        const jsHash = ClientLibrary._hasher("another test string");
+        const originalJsHash = (await import('../fingerprint.builder.js')).cyrb53("another test string");
+
+        expect(jsHash).toBe(originalJsHash);
+        // Ensure no WASM-related console logs or warnings were made
+        expect(console.log).not.toHaveBeenCalledWith(expect.stringContaining('WASM module loaded successfully'));
+        expect(console.warn).not.toHaveBeenCalledWith(expect.stringContaining('WASM module failed to load'));
+    });
+});