@anonympins/fingerprint 0.6.7 → 0.7.1

package/src/js/pow.solver.js

@@ -1,22 +1,104 @@
 /**
  * @file @/pow.solver.js
- * @description Contient les fonctions côté client pour résoudre les différents types de challenges Proof-of-Work.
- * IMPORTANT: Pour les tâches d'optimisation, ce fichier a besoin d'accéder aux algorithmes de `library.js`.
- * Dans un vrai projet, il faudrait bundler une version client de `library.js` et l'importer ici.
- * Pour cet exemple, nous allons copier/coller les fonctions nécessaires.
- * Fichier compatible à la fois avec l'import de modules ES6 et l'injection directe dans un script HTML.
+ * @description Client-side functions to solve various Proof-of-Work challenges.
+ * IMPORTANT: For optimization tasks, this file requires access to algorithms in `library.js`.
+ * In production, a client bundle of `library.js` should be bundled and imported here.
+ * For this implementation, the necessary functions are embedded.
+ * Compatible with both ES6 module imports and direct HTML script injection.
  */
 
 'use strict';
 
 function secureRandom() {
-    if (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) {
+    if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.getRandomValues) {
         const array = new Uint32Array(1);
-        (window.crypto || window.msCrypto).getRandomValues(array);
-        return array[0] / 0x100000000;
+        globalThis.crypto.getRandomValues(array);
+        return array[0] / 0xffffffff;
     }
     return Math.random();
 }
+/**
+ * Standalone synchronous SHA-256 implementation usable anywhere (HTTP, insecure contexts, Workers).
+ */
+function sha256Sync(bytes) {
+    if (bytes instanceof ArrayBuffer) {
+        bytes = new Uint8Array(bytes);
+    } else if (ArrayBuffer.isView(bytes) && !(bytes instanceof Uint8Array)) {
+        bytes = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+    var K = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76ca1422,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+    ];
+    var H = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+    ];
+    var l = bytes.length;
+    var bitLen = l * 8;
+    var padLen = ((l + 8) >> 6 << 6) + 64;
+    var buf = new Uint8Array(padLen);
+    buf.set(bytes);
+    buf[l] = 0x80;
+    var view = new DataView(buf.buffer);
+    view.setUint32(padLen - 4, bitLen >>> 0);
+    view.setUint32(padLen - 8, Math.floor(bitLen / 0x100000000));
+
+    var W = new Int32Array(64);
+    for (var i = 0; i < padLen; i += 64) {
+        for (var t = 0; t < 16; t++) {
+            W[t] = view.getInt32(i + t * 4);
+        }
+        for (var t = 16; t < 64; t++) {
+            var s0 = ((W[t - 15] >>> 7) | (W[t - 15] << 25)) ^ ((W[t - 15] >>> 18) | (W[t - 15] << 14)) ^ (W[t - 15] >>> 3);
+            var s1 = ((W[t - 2] >>> 17) | (W[t - 2] << 15)) ^ ((W[t - 2] >>> 19) | (W[t - 2] << 13)) ^ (W[t - 2] >>> 10);
+            W[t] = (W[t - 16] + s0 + W[t - 7] + s1) | 0;
+        }
+        var a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+        for (var t = 0; t < 64; t++) {
+            var S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            var ch = (e & f) ^ ((~e) & g);
+            var temp1 = (h + S1 + ch + K[t] + W[t]) | 0;
+            var S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            var maj = (a & b) ^ (a & c) ^ (b & c);
+            var temp2 = (S0 + maj) | 0;
+            h = g; g = f; f = e; e = (d + temp1) | 0;
+            d = c; c = b; b = a; a = (temp1 + temp2) | 0;
+        }
+        H[0] = (H[0] + a) | 0;
+        H[1] = (H[1] + b) | 0;
+        H[2] = (H[2] + c) | 0;
+        H[3] = (H[3] + d) | 0;
+        H[4] = (H[4] + e) | 0;
+        H[5] = (H[5] + f) | 0;
+        H[6] = (H[6] + g) | 0;
+        H[7] = (H[7] + h) | 0;
+    }
+    var hex = '';
+    for (var i = 0; i < 8; i++) {
+        hex += (H[i] >>> 0).toString(16).padStart(8, '0');
+    }
+    return hex;
+}
+
+async function safeDigestSha256Hex(bytes) {
+    const cryptoObj = (typeof globalThis !== 'undefined' && globalThis.crypto) ? globalThis.crypto : (typeof window !== 'undefined' ? window.crypto : null);
+    if (cryptoObj && cryptoObj.subtle && typeof cryptoObj.subtle.digest === 'function') {
+        try {
+            const buf = await cryptoObj.subtle.digest("SHA-256", bytes);
+            return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+        } catch (e) {
+            // Transparent fallback
+        }
+    }
+    return sha256Sync(bytes);
+}
 
 function cyrb53(str, seed = 0) {
     const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
@@ -102,6 +184,25 @@ export async function initializeSpace(seed, sizeMb) {
     store.put({ sizeMb, seed }, metadataKey);
 }
 
+export async function readSpaceBlock(blockIdx) {
+    const db = await openDb();
+    const transaction = db.transaction("blocks", "readonly");
+    const store = transaction.objectStore("blocks");
+    const getReq = store.get(blockIdx);
+    return new Promise((resolve, reject) => {
+        getReq.onsuccess = () => {
+            const block = getReq.result;
+            if (block) {
+                const hex = Array.from(block).map(b => b.toString(16).padStart(2, '0')).join('');
+                resolve(hex);
+            } else {
+                reject(new Error("Block not found"));
+            }
+        };
+        getReq.onerror = () => reject(getReq.error);
+    });
+}
+
 export async function solveSpaceChallenge(seed, queries, nonce, clientSecret, peerBlock = '') {
     const db = await openDb();
     const transaction = db.transaction("blocks", "readonly");
@@ -139,11 +240,11 @@ export async function solveSpaceChallenge(seed, queries, nonce, clientSecret, pe
 }
 
 /**
- * Résout un challenge CPU basé sur une cible en utilisant un bloc de base binaire.
- * @param {Uint8Array} baseBlock - Le bloc de données initial (nonce, secret, fp) fourni par le serveur.
- * @param {bigint} target - La cible à atteindre.
- * @param {Function} progressCallback - Callback pour les mises à jour de progression.
- * @returns {Promise<number>} La solution (un nombre entier).
+ * Solves a target-based CPU challenge using a binary base block.
+ * @param {Uint8Array} baseBlock - Initial data block (nonce, secret, fp) provided by the server.
+ * @param {bigint} target - Target difficulty to reach.
+ * @param {Function} progressCallback - Progress update callback.
+ * @returns {Promise<number>} Solution integer.
  */
 export async function solveCpuTargetInline(baseBlock, target, progressCallback) {
     // --- FIX: Add validation for the target to prevent BigInt conversion errors ---
@@ -163,33 +264,74 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
         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.HEAPU8[targetPtr + i] = targetStr.charCodeAt(i);
+        }
+        wasmModule.HEAPU8[targetPtr + targetStr.length] = 0; // Null-terminator
+        try {
+            const solution = wasmModule._solve_cpu_target(ptr, len, targetPtr);
+            return solution;
+        } finally {
+            wasmModule._free(ptr);
+            wasmModule._free(targetPtr);
         }
-        wasmModule.HEAP8[targetPtr + targetStr.length] = 0;
-        const solution = wasmModule._solve_cpu_target(ptr, len, targetPtr);
-        wasmModule._free(ptr);
-        wasmModule._free(targetPtr);
-        return solution;
     }
 
         // Try Web Worker execution first if supported and not blocked by CSP
         if (typeof window !== 'undefined' && typeof Worker !== 'undefined') {
             try {
+                const staticWorkerPath = window.ClientLibrary?.workerPath || (window.ClientConfig && window.ClientConfig.workerPath);
+                const sha256FnStr = sha256Sync.toString();
+                if (staticWorkerPath) {
+                    return await new Promise((resolve, reject) => {
+                        const worker = new Worker(staticWorkerPath);
+                        worker.onmessage = (event) => {
+                            if (event.data.type === 'progress') {
+                                if (progressCallback) progressCallback(event.data.solution);
+                            } else if (event.data.type === 'success') {
+                                resolve(event.data.solution);
+                                worker.terminate();
+                            } else if (event.data.solution !== undefined) {
+                                // Fallback for backward compatibility with previous signature
+                                resolve(event.data.solution);
+                                worker.terminate();
+                            }
+                        };
+                        worker.onerror = (err) => {
+                            worker.terminate();
+                            reject(err);
+                        };
+                        worker.postMessage({ baseBlock, target: cpuTarget.toString() });
+                    });
+                }
                 return await new Promise((resolve, reject) => {
                     const workerCode = `
                         self.onmessage = async (e) => {
                             const { baseBlock, target } = e.data;
                             const cpuTarget = BigInt(target);
                             const encoder = new TextEncoder();
+                            const hasSubtle = typeof self.crypto !== 'undefined' && self.crypto && self.crypto.subtle && typeof self.crypto.subtle.digest === 'function';
+                             const sha256Fallback = ${sha256FnStr};
                             let cpuSolution = 0;
                             while (true) {
                                 const solutionBytes = encoder.encode(String(cpuSolution));
                                 const finalBlock = new Uint8Array(baseBlock.length + solutionBytes.length);
                                 finalBlock.set(baseBlock);
                                 finalBlock.set(solutionBytes, baseBlock.length);
-                                const buf = await crypto.subtle.digest("SHA-256", finalBlock);
-                                const hashHex = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
-                                if (BigInt('0x' + hashHex) < cpuTarget) break;
+                                let hashHex = '';
+                                 if (hasSubtle) {
+                                     try {
+                                         const buf = await self.crypto.subtle.digest("SHA-256", finalBlock);
+                                         const arr = new Uint8Array(buf);
+                                         for (let j = 0; j < arr.length; j++) {
+                                             hashHex += arr[j].toString(16).padStart(2, '0');
+                                         }
+                                     } catch (subtleErr) {
+                                         hashHex = sha256Fallback(finalBlock);
+                                     }
+                                 } else {
+                                     hashHex = sha256Fallback(finalBlock);
+                                 }
+                                 if (BigInt('0x' + hashHex) < cpuTarget) break;
                                 cpuSolution++;
                                 if (cpuSolution % 25000 === 0) {
                                     self.postMessage({ type: 'progress', solution: cpuSolution });
@@ -224,22 +366,17 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
     while (true) {
         const solutionBytes = encoder.encode(String(cpuSolution));
         
-        // Concaténation binaire directe : c'est plus rapide et plus sûr.
+        // Direct binary concatenation: faster and safer.
         const finalBlock = new Uint8Array(baseBlock.length + solutionBytes.length);
         finalBlock.set(baseBlock);
         finalBlock.set(solutionBytes, baseBlock.length);
 
-        if (cpuSolution === 0) {
-            const reconstructedMsg = new TextDecoder().decode(finalBlock);
-            console.log('[FP Solve Debug] Client will hash message:', reconstructedMsg);
-        }
-        const buf = await crypto.subtle.digest("SHA-256", finalBlock);
-        const hashHex = Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
-        // --- AJOUT DE LOGS POUR LE DÉBOGAGE CÔTÉ CLIENT ---
+        const hashHex = await safeDigestSha256Hex(finalBlock);
+        // --- CLIENT-SIDE DEBUG LOGS ---
         if (cpuSolution === 0) { // Log only the first attempt
             console.log(`[FP Client Solve] Attempt 0 hash: "0x${hashHex}"`);
         }
-        // --- FIN DES LOGS ---
+        // --- END DEBUG LOGS ---
         if (BigInt('0x' + hashHex) < cpuTarget) break;
         cpuSolution++;
             if (cpuSolution % 50000 === 0) {
@@ -255,28 +392,28 @@ export async function solveCpuTargetInline(baseBlock, target, progressCallback)
 }
 
 /**
- * Résout un challenge CPU basé sur une cible (version Web Worker).
- * @param {string} message - Le message à hasher (ex: `ip:nonce:solution:secret`).
- * @param {bigint} target - La cible à atteindre.
- * @returns {Promise<number>} La solution (un nombre entier).
+ * Solves a target-based CPU challenge (Web Worker version).
+ * @param {string} message - Message to hash (e.g. `ip:nonce:solution:secret`).
+ * @param {bigint} target - Target difficulty to reach.
+ * @returns {Promise<number>} Solution integer.
  */
 export async function solveCpuTarget(message, target) {
     // Vérifie si les Web Workers sont supportés par le navigateur.
     if (typeof(Worker) === "undefined") {
         console.warn("Web Workers not supported. Falling back to main thread calculation (UI may freeze).");
-        // Ici, on pourrait remettre l'ancienne implémentation comme solution de secours.
-        // Pour la clarté, nous supposons que les workers sont disponibles.
+        // An inline fallback implementation could be placed here if needed.
+        // For clarity, we assume worker availability.
         throw new Error("Web Worker support is required for CPU challenges.");
     }
 
     return new Promise((resolve, reject) => {
-        // Crée un worker à partir du script dédié. Le chemin doit être accessible publiquement.
-        // Assurez-vous que `pow.worker.js` est servi par votre serveur statique.
+        // Create a worker from the dedicated script. The path must be publicly accessible.
+        // Ensure `pow.worker.js` is served by your static assets server.
         const worker = new Worker('./pow.worker.js');
 
         worker.onmessage = (event) => {
             resolve(event.data.solution);
-            worker.terminate(); // Nettoie le worker une fois le travail terminé.
+            worker.terminate(); // Clean up worker once finished.
         };
 
         worker.onerror = (error) => {
@@ -284,16 +421,16 @@ export async function solveCpuTarget(message, target) {
             worker.terminate();
         };
 
-        // Envoie les données du challenge au worker pour qu'il commence le calcul.
+        // Send challenge data to the worker to start calculation.
         worker.postMessage({ message, target });
     });
 }
 
 /**
- * Résout un challenge basé sur la mémoire.
- * @param {string} seed - La graine pour l'initialisation de la mémoire.
- * @param {number} difficulty - La difficulté (en Mo).
- * @returns {Promise<number>} La solution (nombre entier).
+ * Solves a memory-hard challenge.
+ * @param {string} seed - Seed for memory initialization.
+ * @param {number} difficulty - Difficulty in MB.
+ * @returns {Promise<number>} Solution integer.
  */
 export async function solveMemory(seed, difficulty) {
     const wasmModule = typeof window !== 'undefined' ? (window.wasmModule || (window.ClientLibrary && window.ClientLibrary.wasmModule)) : null;
@@ -315,8 +452,7 @@ export async function solveMemory(seed, difficulty) {
     if (numBlocks === 0) return { solution: 0, merkleRoot: '', proofs: {} };
 
     async function hashBlock(block) {
-        const buf = await crypto.subtle.digest("SHA-256", block.buffer);
-        return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, '0')).join('');
+        return await safeDigestSha256Hex(block.buffer);
     }
 
     function hexToBytes(hex) {
@@ -347,8 +483,7 @@ export async function solveMemory(seed, difficulty) {
             const left = currentLayer[i];
             const right = currentLayer[i + 1] || left;
             const combined = hexToBytes(left + right);
-            const hashBuf = await crypto.subtle.digest("SHA-256", combined);
-            const hashHex = Array.from(new Uint8Array(hashBuf)).map(b => b.toString(16).padStart(2, '0')).join('');
+            const hashHex = await safeDigestSha256Hex(combined);
             nextLayer.push(hashHex);
         }
         tree.push(nextLayer);
@@ -397,12 +532,12 @@ export async function solveMemory(seed, difficulty) {
 }
 
 /**
- * Résout un challenge de type "Problème du Voyageur de Commerce" (TSP).
- * NOTE: Ceci est une implémentation simple (heuristique du plus proche voisin) et n'est pas garantie
- * de trouver la solution optimale, mais elle est suffisante pour un challenge.
- * @param {Array<{x: number, y: number}>} cities - Les coordonnées des villes.
- * @param {number} targetMaxDistance - La distance maximale acceptable.
- * @returns {Promise<{path: number[], distance: number}>} Le chemin et la distance.
+ * Solves a Traveling Salesperson Problem (TSP) challenge.
+ * NOTE: Uses a nearest-neighbor heuristic which may not find the global optimum,
+ * but is sufficient for verification challenges.
+ * @param {Array<{x: number, y: number}>} cities - City coordinates.
+ * @param {number} targetMaxDistance - Maximum acceptable distance.
+ * @returns {Promise<{path: number[], distance: number}>} Tour path and distance.
  */
 export async function solveTsp(cities, targetMaxDistance) {
     // Utility function to calculate the distance between two cities
@@ -460,7 +595,7 @@ export async function solveTsp(cities, targetMaxDistance) {
     return { path: solutionPath, distance: solutionDistance };
 }
 
-// --- Fonctions d'optimisation copiées/adaptées de library.js pour le client ---
+// --- Optimization functions adapted from library.js for client usage ---
 
 function paretoDominates(objectivesA, objectivesB) {
     let aIsBetterInOne = false;
@@ -781,7 +916,7 @@ const ClientOptimizers = {
 
         const mutate = (solution) => {
             const newSolution = [...solution];
-            const i = Math.floor(Math.random() * 4);
+            const i = Math.floor(secureRandom() * 4);
             const mutationFactors = [500, 1000, 0.1, 2];
             newSolution[i] += (secureRandom() - 0.5) * mutationFactors[i];
             return newSolution;
@@ -808,9 +943,9 @@ const ClientOptimizers = {
 };
 
 /**
- * Résout une unité de travail utile (Useful Work Unit).
- * @param {object} task - La tâche envoyée par le serveur.
- * @returns {Promise<object>} Le résultat du calcul.
+ * Solves a Useful Work Unit (uPoW).
+ * @param {object} task - Task payload sent by the server.
+ * @returns {Promise<object>} Computation result.
  */
 async function solveUsefulWorkTask(task) {
     await new Promise(r => setTimeout(r, 10)); // Yield thread
@@ -885,7 +1020,7 @@ async function solveUsefulWorkTask(task) {
             const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
             const mutate = p => { const n = [...p], i = Math.floor(secureRandom() * n.length); n[i] += (secureRandom() - 0.5) * 0.2; return n.map(v => Math.max(0, v)); };
             
-            // Le client doit recréer la population si elle n'est pas fournie
+            // The client must recreate the population if not provided
             const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
             initialPopulation.forEach(p => p.fitness = fitness(p.chromosome));
 
@@ -894,33 +1029,31 @@ async function solveUsefulWorkTask(task) {
         }
 
         case 'run_multiple_parallel':
-            // Côté client, on ne peut pas utiliser de vrais workers pour `runMultipleParallel`.
-            // On exécute donc une version simplifiée : un seul cycle du solveur demandé.
-            // Cela reste un travail coûteux et valide le principe du "Useful Work".
+            // On the client side, Web Workers are not nested for runMultipleParallel.
+            // Run a single cycle of the requested solver.
+            // This still represents non-trivial computational work for useful PoW.
             const { solverName, baseSolverArgs } = task;
             const clientSolver = ClientOptimizers[solverName];
             if (!clientSolver) throw new Error(`Solver ${solverName} not found on client.`);
             
-            // On simule l'appel avec les arguments de base.
-            // Note: `baseSolverArgs` peut contenir des options.
+            // Execute solver with base arguments.
+            // Note: `baseSolverArgs` may contain solver options.
             return clientSolver(...baseSolverArgs);
         
         case 'multi_objective_genetic_algorithm': {
-            // C'est ici que la connexion se fait !
-            // On cherche le solveur demandé (ex: 'cpc.solve') dans notre registre client.
+            // Look up requested solver (e.g. 'cpc.solve') in the client registry.
             const solverFunction = ClientOptimizers[task.solverName];
             if (!solverFunction) {
                 throw new Error(`Solver '${task.solverName}' not found on client.`);
             }
             // On appelle le solveur en lui passant le payload et les options.
-            // La fonction `solveOptimalCPC` attend le payload comme premier argument.
+            // Invoke solver with payload and options.
             return solverFunction(task.payload, { generations: task.generations, initialFront: task.initialFront });
         }
 
         case 'pytorch_onnx_learning': {
-            // Dans un environnement de production réel avec ONNX Runtime Web, on chargerait le modèle .onnx 
-            // et on exécuterait un calcul de gradient (backward pass).
-            // Ici, nous simulons le calcul de gradient mathématique équivalent pour la régression/classification.
+            // In a production environment with ONNX Runtime Web, load .onnx and execute gradient backward pass.
+            // Here, simulate the gradient backward pass for regression/classification.
             const { weights, payload } = task;
             const inputs = payload.inputs || [];
             const labels = payload.labels || [];
@@ -946,7 +1079,7 @@ async function solveUsefulWorkTask(task) {
             const labels = payload.labels || [];
             try {
                 const tf = await loadTfjs();
-                // Chargement non-bloquant du modèle au format JSON
+                // Non-blocking model loading
                 const model = await tf.loadLayersModel(modelPath);
                 
                 const xs = tf.tensor2d(inputs);
@@ -958,7 +1091,7 @@ async function solveUsefulWorkTask(task) {
                     return tf.losses.meanSquaredError(ys, preds);
                 };
                 
-                // Dérivation automatique pour le calcul exact des gradients
+                // Automatic differentiation for exact gradient computation
                 const gFn = tf.grad(lossFn);
                 const grads = gFn(trainableVars);
                 
@@ -989,15 +1122,15 @@ async function solveUsefulWorkTask(task) {
 }
 
 /**
- * Résout une tâche d'optimisation basée sur un algorithme génétique.
- * Reçoit une population et la fait évoluer pendant un certain nombre de générations.
- * NOTE: Cette fonction est une version simplifiée de l'AG de `library.js` adaptée au client.
- * @param {Array<object>} initialPopulation - La population de départ.
- * @param {number} generations - Le nombre de générations à exécuter.
- * @returns {Promise<Array<object>>} La population finale après évolution.
+ * Solves an optimization task using a genetic algorithm.
+ * Evolves a population for a specified number of generations.
+ * NOTE: Simplified client adaptation of GA in `library.js`.
+ * @param {Array<object>} initialPopulation - Starting population.
+ * @param {number} generations - Number of generations to run.
+ * @returns {Promise<Array<object>>} Final evolved population.
  */
 export async function solveOptimizationTask(initialPopulation, generations) {
-    // Fonctions AG simplifiées (croisement, mutation)
+    // Simplified GA operators (crossover, mutation)
     const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
     const mutate = (p) => {
         const newP = [...p];
@@ -1009,20 +1142,20 @@ export async function solveOptimizationTask(initialPopulation, generations) {
     let population = initialPopulation;
 
     for (let gen = 0; gen < generations; gen++) {
-        // Sélection simple : on garde les 50% meilleurs
+        // Simple selection: keep top 50%
         const parents = population.sort((a, b) => a.fitness - b.fitness).slice(0, Math.ceil(population.length / 2));
-        const newPopulation = [...parents]; // Élitisme
+        const newPopulation = [...parents]; // Elitism
 
         while (newPopulation.length < population.length) {
             const parent1 = parents[Math.floor(secureRandom() * parents.length)];
             const parent2 = parents[Math.floor(secureRandom() * parents.length)];
             let offspring = crossover(parent1.chromosome, parent2.chromosome);
             if (secureRandom() < 0.1) offspring = mutate(offspring);
-            // La fitness sera recalculée côté serveur pour la vérification.
+            // Fitness is recalculated server-side for verification.
             newPopulation.push({ chromosome: offspring, fitness: -1 });
         }
         population = newPopulation;
-        // Pause pour ne pas geler l'UI sur les longues tâches
+        // Yield execution to prevent freezing the UI on long tasks
         if (gen % 10 === 0) await new Promise(r => setTimeout(r, 0));
     }
     return population;
@@ -1030,7 +1163,7 @@ export async function solveOptimizationTask(initialPopulation, generations) {
 
 /**
  * @class ChallengeSolution
- * @description Encapsule une solution de challenge et fournit des méthodes pour la manipuler.
+ * @description Encapsulates a challenge solution and formatting helpers.
  * @private
  */
 class ChallengeSolution {
@@ -1041,14 +1174,14 @@ class ChallengeSolution {
     }
 
     /**
-     * Applique les paramètres de la solution à un objet URL.
-     * @param {URL} url - L'objet URL à modifier.
+     * Applies solution parameters to a URL instance.
+     * @param {URL} url - Target URL object to modify.
      */
     applyToUrl(url) {
         url.searchParams.set('pow_type', this.type);
         url.searchParams.set('pow_nonce', this.nonce);
 
-        // Logique de formatage spécifique à chaque type de challenge
+        // Challenge-specific parameter formatting
         if (this.type === 'cpu_mem' || this.type === 'cpu_mem_inline' || this.type === 'cpu_target') {
             Object.entries(this.rawSolution).forEach(([key, value]) => {
                 if (typeof value === 'object' && value !== null) {
@@ -1061,17 +1194,17 @@ class ChallengeSolution {
             url.searchParams.set('pow_solution_work_result', JSON.stringify(this.rawSolution.work_result));
             url.searchParams.set('pow_problem_id', this.rawSolution.problem_id);
         } else {
-            // Pour les cas simples comme 'tsp' où la solution est une seule valeur
+            // Single-value solutions like TSP
             url.searchParams.set('pow_solution', JSON.stringify(this.rawSolution));
         }
     }
 }
 
 /**
- * Fonction principale qui reçoit un objet challenge et le résout.
- * @param {object} challenge - L'objet challenge reçu du serveur.
- * @param {string} [fingerprint=''] - L'empreinte de l'appareil qui résout le challenge.
- * @returns {Promise<ChallengeSolution>} Un objet `ChallengeSolution` encapsulant le résultat.
+ * Main entry point to resolve a received challenge payload.
+ * @param {object} challenge - Challenge payload received from the server.
+ * @param {string} [fingerprint=''] - Device fingerprint of the solver.
+ * @returns {Promise<ChallengeSolution>} `ChallengeSolution` wrapping the result.
  */
 export async function solveChallenge(challenge, fingerprint = '') { // The fingerprint is now passed from the client library
     const { type, nonce, clientSecret, cpuTarget, memDifficulty, cities, clientIp, targetMaxDistance, optimizationTask, usefulWorkTask, queries, sizeMb } = challenge;
@@ -1084,12 +1217,12 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
                 throw new Error("Challenge data is missing 'cpuTarget' property.");
             }
             const target = cpuTarget; // Keep variable name for consistency below
-            // Pour ce challenge simple, le baseBlock est juste le nonce.
+            // For this simple challenge, baseBlock is the nonce.
             const baseBlockBytes = new TextEncoder().encode(nonce + ":");
             rawSolution.cpu = await solveCpuTargetInline(baseBlockBytes, target, null);
             break;
         case 'cpu_mem':
-            // Pour les appels API, le client IP n'est pas connu, on ne le met pas dans le message
+            // For API calls, client IP is omitted from client-side message reconstruction
             const baseMessageCombined = `:${nonce}:${clientSecret}`;
             const memSeed = `:${nonce}:${clientSecret}`;
             const [cpuSol, memSol] = await Promise.all([
@@ -1104,7 +1237,7 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
             rawSolution.mem = memSol;
             break;
         case 'cpu_mem_inline':
-            // Version inline pour compatibilité HTML avec IP incluse
+            // Inline version for HTML compatibility with IP
             const memSeedInline = `:${nonce}:${clientSecret}`;
             const [cpuSolInline, memSolInline] = await Promise.all([
                 (async () => {
@@ -1119,12 +1252,12 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
             break;
         case 'tsp':
             const tspResult = await solveTsp(cities, targetMaxDistance);
-            // Pour ce challenge, la solution est juste le chemin.
+            // For TSP, solution is the tour path array
             rawSolution = tspResult.path;
             break;
         case 'optimization_task':
             const finalPopulation = await solveOptimizationTask(optimizationTask.population, optimizationTask.generations);
-            rawSolution = finalPopulation.map(p => p.chromosome); // On ne renvoie que les chromosomes
+            rawSolution = finalPopulation.map(p => p.chromosome); // Return chromosomes only
             break;
         case 'useful_work_task':
             const workResult = await solveUsefulWorkTask(usefulWorkTask.task);
@@ -1142,11 +1275,12 @@ export async function solveChallenge(challenge, fingerprint = '') { // The finge
     return new ChallengeSolution(type, nonce, rawSolution);
 }
 
-// --- Compatibilité pour l'injection directe dans le HTML ---
-// Si le script est chargé dans un navigateur (window existe), on attache les fonctions nécessaires à window.
+// --- Direct HTML script injection compatibility ---
+// If loaded in browser context (window exists), expose methods on window.
 if (typeof window !== 'undefined') {
     window.solveCpuChallengeInline = solveCpuTargetInline;
     window.solveMemoryChallenge = solveMemory;
+    window.readSpaceBlock = readSpaceBlock;
     window.solveTspChallenge = solveTsp;
     window.solveChallenge = solveChallenge;
 }