@anonympins/fingerprint 0.1.4 → 0.2.1

package/library.js

@@ -289,20 +289,23 @@ const Optimization = {
    * @param {number} numCycles - Le nombre total de cycles à exécuter.
    * @param {boolean} [logProgress=false] - Si true, affiche la progression dans la console.
    * @param {object} [options={}] - Options pour la parallélisation.
-   * @param {number} [options.concurrency] - Le nombre de workers à utiliser en parallèle. Par défaut, le nombre de cœurs CPU.
+   * @param {number} [options.concurrency] - Le nombre de workers à utiliser en parallèle. Par défaut, le nombre de cœurs CPU. 
+   * @param {function(number): Array<any>} [options.workerDataGenerator] - Une fonction qui, pour chaque cycle (index), génère les arguments spécifiques à passer au solveur. Si non fournie, `baseSolverArgs` est utilisé tel quel.
    * @returns {Promise<{bestResult: object, stats: {scores: Array<number>, average: number, stdDev: number}}>} Le meilleur résultat et des statistiques.
    */
   async runMultipleParallel(
     solverName,
-    baseSolverArgs,
+    baseSolverArgs = [], // Default to empty array if not provided
     numCycles,
     logProgress = false,
     options = {},
   ) {
     const concurrency = options.concurrency || os.cpus().length;
+    const workerDataGenerator = options.workerDataGenerator;
+
     if (logProgress) {
       console.log(
-        `   (Utilisation d'un pool de ${concurrency} workers pour ${numCycles} cycles)`,
+        `   (Utilisation d'un pool de ${concurrency} workers pour ${numCycles} cycles avec le solveur ${solverName})`,
       );
     }
 
@@ -317,18 +320,15 @@ const Optimization = {
 
         const workerData = {
           solverName,
-          solverArgs: [
-            // Chaque worker génère son propre jeu de données aléatoires pour garantir l'indépendance des cycles.
-            Array.from({ length: 50 }, () => ({
-              x: Math.random() * 100,
-              y: Math.random() * 100,
-            })),
-            ...baseSolverArgs,
-          ],
+          solverArgs: workerDataGenerator
+            ? workerDataGenerator(taskIndex)
+            : baseSolverArgs,
         };
 
-        const result = await new Promise((resolve, reject) => {
-          const worker = new Worker("./worker.js", { workerData });
+        const result = await new Promise(async (resolve, reject) => {
+          // Le chemin du worker doit être absolu ou relatif au fichier appelant.
+          // On utilise import.meta.url pour résoudre le chemin de manière fiable.
+          const worker = new Worker(new URL('./optimization.worker.js', import.meta.url), { workerData });
           worker.on("message", resolve);
           worker.on("error", reject);
           worker.on("exit", (code) => {
@@ -1313,15 +1313,21 @@ Optimization.Operators.createOptimalTtlEvaluator = ({ suspicionScore }) => {
  * @param {string} numberString - Une chaîne de chiffres (ex: "123456789").
  * @returns {number} Un score de déviation (0 = parfait, > 0.15 = suspect).
  */
-Optimization.Operators.benfordTest = (numberString) => {
-    const firstDigits = numberString.replace(/[^1-9]/g, ''); // Garde uniquement les chiffres de 1 à 9
-    if (firstDigits.length < 10) {
+Optimization.Operators.benfordTest = (numbers) => {
+    if (!Array.isArray(numbers)) {
+        // Si l'entrée n'est pas un tableau, on ne peut pas l'analyser.
+        return 0;
+    }
+    const leadingDigits = numbers.map(n => String(n).trim().charAt(0))
+                                 .filter(d => d >= '1' && d <= '9'); // On ne garde que les chiffres de 1 à 9.
+
+    if (leadingDigits.length < 10) {
         return 0; // Pas assez de données pour un test fiable
     }
 
     const counts = Array(10).fill(0);
-    for (let i = 0; i < firstDigits.length; i++) {
-        counts[parseInt(firstDigits[i], 10)]++;
+    for (let i = 0; i < leadingDigits.length; i++) {
+        counts[parseInt(leadingDigits[i], 10)]++;
     }
 
     // Distribution attendue selon la loi de Benford pour le premier chiffre
@@ -1332,7 +1338,7 @@ Optimization.Operators.benfordTest = (numberString) => {
 
     let totalDeviation = 0;
     for (let i = 1; i <= 9; i++) {
-        const observedFrequency = (counts[i] / firstDigits.length) * 100;
+        const observedFrequency = (counts[i] / leadingDigits.length) * 100;
         const expectedFrequency = benfordDistribution[i];
         totalDeviation += Math.pow(observedFrequency - expectedFrequency, 2);
     }

package/optimization.worker.js

@@ -0,0 +1,28 @@
+/**
+ * @file @/optimization.worker.js
+ * @description Web Worker générique pour exécuter les algorithmes d'optimisation de la bibliothèque `Optimization`.
+ * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { Optimization } from './library.js'; // Assurez-vous que le chemin est correct
+
+if (parentPort) {
+    parentPort.on('message', async () => { // Le message est vide, on utilise workerData
+        const { solverName, solverArgs } = workerData;
+
+        // Gérer les solveurs imbriqués (ex: 'Operators.solvePortfolio')
+        const solverFunction = solverName.split('.').reduce((obj, prop) => obj && obj[prop], Optimization);
+
+        if (typeof solverFunction === 'function') {
+            try {
+                const result = await solverFunction(...solverArgs);
+                parentPort.postMessage(result);
+            } catch (error) {
+                parentPort.postMessage({ error: error.message, stack: error.stack });
+            }
+        } else {
+            parentPort.postMessage({ error: `Solver '${solverName}' not found or is not a function in Optimization library.` });
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anonympins/fingerprint",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "An HTTP(S) client mitigation and anti-bot protection library for Node.js/Express, based on digital fingerprinting and dynamic Proof-of-Work (PoW) challenges.",
   "main": "fingerprint.js",
   "type": "module",
@@ -15,6 +15,9 @@
     "fingerprint.client.js",
     "fingerprint.builder.js",
     "pow.solver.js",
+    "pow.worker.js",
+    "problem-manager.js",
+    "optimization.worker.js",
     "library.js",
     "redis-store.js",
     "mongodb-store.js",

package/pow.solver.js

@@ -1,32 +1,51 @@
 /**
  * @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.
  */
 
 'use strict';
 
 /**
- * Résout un challenge CPU basé sur une cible (version inline pour compatibilité HTML).
- * @param {string} clientIp - L'adresse IP du client.
- * @param {string} nonce - Le nonce du challenge.
+ * 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 {string} clientSecret - Le secret client (optionnel).
  * @param {Function} progressCallback - Callback pour les mises à jour de progression.
  * @returns {Promise<number>} La solution (un nombre entier).
  */
-export async function solveCpuTargetInline(clientIp, nonce, target, clientSecret = null, progressCallback) {
-    // Le 'target' est déjà un BigInt lorsqu'il est appelé depuis la page de challenge.
-    // On s'assure juste qu'il est bien de ce type.
+export async function solveCpuTargetInline(baseBlock, target, progressCallback) {
+    // --- FIX: Add validation for the target to prevent BigInt conversion errors ---
+    if (typeof target !== 'bigint' && (typeof target !== 'string' || !/^[0-9a-fA-F]+$/.test(target))) {
+        throw new TypeError(`Invalid target type: expected a BigInt or a hex string, but got ${typeof target} with value ${target}`);
+    }
+
     const cpuTarget = typeof target === 'bigint' ? target : BigInt('0x' + target);
+    // --- END FIX ---
+    const encoder = new TextEncoder();
     let cpuSolution = 0;
-    const ipPart = clientIp || ''; // Use empty string if IP is null/undefined
-    while (true) { // When a clientSecret is used, the IP is omitted from the hash to make it independent of the network.
-        const msg = clientSecret ?
-            `${nonce}:${cpuSolution}:${clientSecret}` :
-            `${ipPart}:${nonce}:${cpuSolution}`;
-        const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(msg));
+
+    while (true) {
+        const solutionBytes = encoder.encode(String(cpuSolution));
+        
+        // Concaténation binaire directe : c'est plus rapide et plus sûr.
+        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 ---
+        if (cpuSolution === 0) { // Log only the first attempt
+            console.log(`[FP Client Solve] Attempt 0 hash: "0x${hashHex}"`);
+        }
+        // --- FIN DES LOGS ---
         if (BigInt('0x' + hashHex) < cpuTarget) break;
         cpuSolution++;
         if (cpuSolution % 100000 === 0) {
@@ -169,32 +188,186 @@ export async function solveTsp(cities, targetMaxDistance) {
     return { path: solutionPath, distance: solutionDistance };
 }
 
+// --- Fonctions d'optimisation copiées/adaptées de library.js pour le client ---
+
+const ClientOptimizers = {
+    simulatedAnnealing(initialSolution, evaluator, neighbor, iterations, temp, cooling) {
+        let currentSolution = initialSolution;
+        let currentEnergy = evaluator(currentSolution);
+        let temperature = temp;
+
+        for (let i = 0; i < iterations; i++) {
+            const newSolution = neighbor(currentSolution);
+            const newEnergy = evaluator(newSolution);
+            if (newEnergy < currentEnergy || Math.random() < Math.exp((currentEnergy - newEnergy) / temperature)) {
+                currentSolution = newSolution;
+                currentEnergy = newEnergy;
+            }
+            temperature *= cooling;
+        }
+        return { solution: currentSolution, energy: currentEnergy };
+    },
+
+    geneticAlgorithm(createIndividual, fitness, crossover, mutate, generations, popSize) {
+        let population = Array.from({ length: popSize }, () => {
+            const chromosome = createIndividual();
+            return { chromosome, fitness: fitness(chromosome) };
+        });
+
+        for (let gen = 0; gen < generations; gen++) {
+            population.sort((a, b) => a.fitness - b.fitness);
+            const newPopulation = [population[0]]; // Elitism
+            while (newPopulation.length < popSize) {
+                const p1 = population[Math.floor(Math.random() * (popSize / 2))];
+                const p2 = population[Math.floor(Math.random() * (popSize / 2))];
+                let offspring = crossover(p1.chromosome, p2.chromosome);
+                if (Math.random() < 0.1) offspring = mutate(offspring);
+                newPopulation.push({ chromosome: offspring, fitness: fitness(offspring) });
+            }
+            population = newPopulation;
+        }
+        return population;
+    }
+};
+
+/**
+ * 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.
+ */
+async function solveUsefulWorkTask(task) {
+    await new Promise(r => setTimeout(r, 10)); // Yield thread
+
+    switch (task.type) {
+        case 'simulated_annealing_iterations': {
+            const { cities } = task.payload;
+            const distance = (c1, c2) => Math.sqrt(Math.pow(c1.x - c2.x, 2) + Math.pow(c1.y - c2.y, 2));
+            const evaluator = (path) => {
+                let total = 0;
+                for (let i = 0; i < path.length - 1; i++) total += distance(cities[path[i]], cities[path[i + 1]]);
+                total += distance(cities[path[path.length - 1]], cities[path[0]]);
+                return total;
+            };
+            const neighbor = (path) => {
+                const newPath = [...path];
+                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * path.length)];
+                [newPath[i], newPath[j]] = [newPath[j], newPath[i]];
+                return newPath;
+            };
+            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - Math.random());
+            
+            return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
+        }
+
+        case 'genetic_algorithm_generations': {
+            const { assets, maxVolatility } = task.payload;
+            const fitness = (weights) => {
+                const total = weights.reduce((s, w) => s + w, 0);
+                if (total === 0) return Infinity;
+                const normW = weights.map(w => w / total);
+                const ret = normW.reduce((s, w, i) => s + w * assets[i].expectedReturn, 0);
+                const vol = normW.reduce((s, w, i) => s + w * assets[i].volatility, 0);
+                if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
+                return -ret;
+            };
+            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
+            const mutate = p => { const n = [...p], i = Math.floor(Math.random() * n.length); n[i] += (Math.random() - 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
+            const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
+            initialPopulation.forEach(p => p.fitness = fitness(p.chromosome));
+
+            const finalPopulation = ClientOptimizers.geneticAlgorithm(createIndividual, fitness, crossover, mutate, task.generations, task.payload.options.populationSize);
+            return { population: finalPopulation };
+        }
+
+        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".
+            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.
+            return clientSolver(...baseSolverArgs);
+
+        default:
+            throw new Error(`Unknown useful work type: ${task.type}`);
+    }
+}
+
+/**
+ * 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.
+ */
+export async function solveOptimizationTask(initialPopulation, generations) {
+    // Fonctions AG simplifiées (croisement, mutation)
+    const crossover = (p1, p2) => p1.map((w, i) => (w + p2[i]) / 2);
+    const mutate = (p) => {
+        const newP = [...p];
+        const i = Math.floor(Math.random() * newP.length);
+        newP[i] += (Math.random() - 0.5) * 0.2;
+        return newP;
+    };
+
+    let population = initialPopulation;
+
+    for (let gen = 0; gen < generations; gen++) {
+        // Sélection simple : on garde les 50% meilleurs
+        const parents = population.sort((a, b) => a.fitness - b.fitness).slice(0, Math.ceil(population.length / 2));
+        const newPopulation = [...parents]; // Élitisme
+
+        while (newPopulation.length < population.length) {
+            const parent1 = parents[Math.floor(Math.random() * parents.length)];
+            const parent2 = parents[Math.floor(Math.random() * parents.length)];
+            let offspring = crossover(parent1.chromosome, parent2.chromosome);
+            if (Math.random() < 0.1) offspring = mutate(offspring);
+            // La fitness sera recalculée côté serveur pour la vérification.
+            newPopulation.push({ chromosome: offspring, fitness: -1 });
+        }
+        population = newPopulation;
+        // Pause pour ne pas geler l'UI sur les longues tâches
+        if (gen % 10 === 0) await new Promise(r => setTimeout(r, 0));
+    }
+    return population;
+}
+
 /**
  * Fonction principale qui reçoit un objet challenge et le résout.
  * @param {object} challenge - L'objet challenge reçu du serveur.
  * @returns {Promise<object>} Un objet contenant la ou les solutions.
  */
-export async function solveChallenge(challenge) {
-    const { type, nonce, clientSecret, cpuTarget, memDifficulty, cities, clientIp, targetMaxDistance } = challenge;
+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 } = challenge;
     const solutions = {};
 
     switch (type) {
         case 'cpu_target':
-            const baseMessageCpu = `:${nonce}`; // L'IP est gérée côté serveur
+            // Note: This case is not fully exercised by tests as it relies on Web Workers.
             if (!cpuTarget) {
                 throw new Error("Challenge data is missing 'cpuTarget' property.");
             }
             const target = cpuTarget; // Keep variable name for consistency below
-            solutions.cpu = await solveCpuTarget(baseMessageCpu, BigInt('0x' + target));
+            // Pour ce challenge simple, le baseBlock est juste le nonce.
+            const baseBlockBytes = new TextEncoder().encode(nonce + ":");
+            solutions.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
-            const baseMessageCombined = `${nonce}:${clientSecret}`;
+            const baseMessageCombined = `:${nonce}:${clientSecret}`;
             const memSeed = `:${nonce}:${clientSecret}`;
             const [cpuSol, memSol] = await Promise.all([
                 (async () => {
-                    if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property.");
-                    return solveCpuTargetInline(null, nonce, cpuTarget, clientSecret);
+                    if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property."); // Pass fingerprint to solver
+                    const baseBlock = new Uint8Array(challenge.baseBlock);
+                    return solveCpuTargetInline(baseBlock, cpuTarget, null);
                 })(),
                 solveMemory(memSeed, memDifficulty)
             ]);
@@ -203,11 +376,12 @@ export async function solveChallenge(challenge) {
             break;
         case 'cpu_mem_inline':
             // Version inline pour compatibilité HTML avec IP incluse
-            const memSeedInline = `${nonce}:${clientSecret}`;
+            const memSeedInline = `:${nonce}:${clientSecret}`;
             const [cpuSolInline, memSolInline] = await Promise.all([
                 (async () => {
                     if (!cpuTarget) throw new Error("Challenge data is missing 'cpuTarget' property.");
-                    return solveCpuTargetInline(clientIp, nonce, cpuTarget, clientSecret);
+                    const baseBlock = new Uint8Array(challenge.baseBlock);
+                    return solveCpuTargetInline(baseBlock, cpuTarget, null);
                 })(),
                 solveMemory(memSeedInline, memDifficulty)
             ]);
@@ -219,6 +393,15 @@ export async function solveChallenge(challenge) {
             solutions.tsp = tspResult.path;
             solutions.distance = tspResult.distance;
             break;
+        case 'optimization_task':
+            const finalPopulation = await solveOptimizationTask(optimizationTask.population, optimizationTask.generations);
+            solutions.population = finalPopulation.map(p => p.chromosome); // On ne renvoie que les chromosomes
+            break;
+        case 'useful_work_task':
+            const workResult = await solveUsefulWorkTask(usefulWorkTask.task);
+            solutions.work_result = workResult;
+            solutions.problem_id = usefulWorkTask.problemId;
+            break;
         default:
             throw new Error(`Unknown challenge type: ${type}`);
     }

package/pow.worker.js

@@ -0,0 +1,27 @@
+/**
+ * @file @/pow.worker.js
+ * @description Web Worker dédié à la résolution du challenge CPU.
+ * Ce script s'exécute sur un thread séparé pour ne pas bloquer l'interface utilisateur.
+ */
+
+self.onmessage = async (event) => {
+    const { message, target } = event.data;
+    let solution = 0;
+    const encoder = new TextEncoder();
+
+    // La boucle de calcul intensive est isolée dans ce worker.
+    while (true) {
+        const currentMessage = `${message}:${solution}`;
+        const data = encoder.encode(currentMessage);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+
+        if (BigInt('0x' + hashHex) < target) {
+            // Une fois la solution trouvée, on la renvoie au thread principal.
+            self.postMessage({ solution });
+            return;
+        }
+        solution++;
+    }
+};

package/problem-manager.js

@@ -0,0 +1,175 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { Optimization } from './library.js';
+
+/**
+ * @namespace ProblemInitializers
+ * @description Fonctions pour générer dynamiquement les données d'un problème.
+ */
+const ProblemInitializers = {
+    /**
+     * Génère un ensemble de points aléatoires pour un problème de TSP.
+     * @param {object} params - Les paramètres de génération.
+     * @param {number} params.count - Le nombre de points à générer.
+     * @param {{x: number, y: number}} [params.bounds={x: 1000, y: 1000}] - Les limites spatiales.
+     * @returns {Array<{x: number, y: number}>}
+     */
+    'generate:randomPoints': (params) => {
+        const { count, bounds = { x: 1000, y: 1000 } } = params;
+        if (isNaN(count)) return [];
+        return Array.from({ length: count }, () => ({ x: Math.random() * bounds.x, y: Math.random() * bounds.y }));
+    },
+
+    /**
+     * Génère un ensemble d'actifs financiers aléatoires pour un problème de portefeuille.
+     * @param {object} params - Les paramètres de génération.
+     * @param {number} params.count - Le nombre d'actifs à générer.
+     * @returns {Array<{expectedReturn: number, volatility: number}>}
+     */
+    'generate:randomAssets': (params) => {
+        const { count } = params;
+        if (isNaN(count)) return [];
+        return Array.from({ length: count }, () => ({
+            expectedReturn: Math.random() * 0.2,
+            volatility: 0.1 + Math.random() * 0.3
+        }));
+    },
+
+    /**
+     * Crée une fonction qui génère des arguments pour chaque worker de `runMultipleParallel`.
+     * Permet de faire varier les paramètres (ex: solution initiale) pour chaque cycle.
+     * @param {object} params - Les paramètres de configuration.
+     * @param {Array<any>} params.baseArgs - Les arguments de base, communs à tous les workers.
+     * @param {object} params.variations - Décrit comment faire varier un argument.
+     * @returns {function(number): Array<any>} La fonction `workerDataGenerator`.
+     */
+    'generate:parallelArgs': (params) => {
+        const { baseArgs, variations } = params;
+        return (cycleIndex) => {
+            const cycleArgs = [...baseArgs];
+            // Pour l'instant, on gère la variation de la solution initiale pour le TSP
+            if (variations?.initialSolution === 'random') {
+                cycleArgs[0] = cycleArgs[0].sort(() => Math.random() - 0.5);
+            }
+            return cycleArgs;
+        };
+    }
+};
+
+class ProblemManager {
+    constructor(configPath) {
+        this.configPath = configPath;
+        this.problems = this.loadProblems();
+        this.currentProblemIndex = 0;
+    }
+
+    loadProblems() {
+        try {
+            const data = readFileSync(this.configPath, 'utf-8');
+            const problems = JSON.parse(data);
+            // Initialisation dynamique des problèmes
+            for (const problem of problems) { // eslint-disable-line no-unused-vars
+                for (const key in problem.payload) {
+                    const value = problem.payload[key];
+                    // On cherche une instruction d'initialisation (ex: { "$init": "generate:randomPoints", ... })
+                    if (typeof value === 'object' && value !== null && value.$init) {
+                        const initializer = ProblemInitializers[value.$init];
+                        if (initializer) {
+                            // On remplace l'objet d'instruction par les données générées.
+                            problem.payload[key] = initializer(value.params || {});
+                        }
+                    }
+                }
+            }
+            return problems;
+        } catch (error) {
+            console.error(`[ProblemManager] Erreur lors du chargement du fichier de problèmes: ${error.message}`);
+            return []; // Retourne un tableau vide en cas d'erreur pour éviter un crash
+        }
+    }
+
+    saveProblems() {
+        // Note: Dans un vrai scénario, utilisez une base de données pour éviter les race conditions.
+        try {
+            writeFileSync(this.configPath, JSON.stringify(this.problems, null, 2));
+        } catch (error) {
+            console.error(`[ProblemManager] Erreur lors de la sauvegarde du fichier de problèmes: ${error.message}`);
+        }
+    }
+
+    /**
+     * Sélectionne un problème et génère une unité de travail.
+     * @param {number} suspicionFactor - Le facteur de suspicion pour ajuster la difficulté.
+     * @returns {{problemId: string, task: object}|null}
+     */
+    dispatchWork(suspicionFactor) {
+        if (this.problems.length === 0) return null;
+
+        const problem = this.problems[this.currentProblemIndex];
+        this.currentProblemIndex = (this.currentProblemIndex + 1) % this.problems.length;
+
+        const task = { type: problem.workUnit.type };
+        const { scalingFactor } = problem.workUnit;
+
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations':
+                // Assurer une difficulté minimale pour que le challenge soit significatif
+                const baseIterations = Math.max(15000, problem.workUnit.baseIterations || 0);
+                task.iterations = scalingFactor
+                    ? Math.floor(baseIterations * Math.pow(scalingFactor, suspicionFactor))
+                    : Math.floor(baseIterations * (0.5 + suspicionFactor));
+                task.payload = problem.payload;
+                task.initialSolution = problem.state.bestSolution;
+                break;
+
+            case 'genetic_algorithm_generations':
+                // Assurer une difficulté minimale pour que le challenge soit significatif
+                const baseGenerations = Math.max(50, problem.workUnit.baseGenerations || 0);
+                task.generations = scalingFactor
+                    ? Math.floor(baseGenerations * Math.pow(scalingFactor, suspicionFactor))
+                    : Math.floor(baseGenerations * (0.5 + suspicionFactor));
+                task.payload = problem.payload;
+                task.initialPopulation = problem.state.population;
+                break;
+
+            case 'run_multiple_parallel':
+                task.solverName = problem.workUnit.solverName;
+                task.numCycles = problem.workUnit.numCycles;
+                // Les arguments et le générateur sont dans le payload pour plus de flexibilité
+                task.baseSolverArgs = problem.payload.baseSolverArgs;
+                task.workerDataGenerator = problem.payload.workerDataGenerator;
+                task.logProgress = problem.payload.logProgress || false;
+                task.concurrency = problem.payload.concurrency;
+                break;
+        }
+
+        return { problemId: problem.id, task };
+    }
+
+    /**
+     * Intègre la solution d'un client dans l'état du problème.
+     * @param {string} problemId - L'ID du problème.
+     * @param {object} solutionData - La solution renvoyée par le client.
+     */
+    integrateSolution(problemId, solutionData) {
+        const problem = this.problems.find(p => p.id === problemId);
+        if (!problem) return;
+
+        switch (problem.workUnit.type) {
+            case 'simulated_annealing_iterations':
+                if (solutionData.energy < (parseFloat(problem.state.bestEnergy) || Infinity)) {
+                    problem.state.bestSolution = solutionData.solution;
+                    problem.state.bestEnergy = solutionData.energy;
+                    console.log(`[ProblemManager] Nouvelle meilleure solution pour ${problemId}: ${solutionData.energy.toFixed(2)}`);
+                }
+                break;
+            case 'genetic_algorithm_generations':
+                problem.state.population = solutionData.population;
+                console.log(`[ProblemManager] Population mise à jour pour ${problemId}.`);
+                break;
+        }
+        this.saveProblems();
+    }
+}
+
+export { ProblemManager }; // Export the class for testing
+export const problemManager = new ProblemManager('./problems.config.json');