@anonympins/fingerprint 0.5.4 → 0.6.0

package/src/js/obfuscation.worker.js

@@ -0,0 +1,23 @@
+import { parentPort } from 'node:worker_threads';
+import JavaScriptObfuscator from 'javascript-obfuscator';
+
+if (parentPort) {
+    parentPort.on('message', (workerData) => {
+        const { jsCode, seed } = workerData;
+        try {
+            const obfuscationResult = JavaScriptObfuscator.obfuscate(jsCode, {
+                compact: true,
+                controlFlowFlattening: true,
+                deadCodeInjection: true,
+                stringArray: true,
+                stringArrayRotate: true,
+                stringArrayShuffle: true,
+                seed: Math.abs(seed),
+                selfDefending: true,
+            });
+            parentPort.postMessage({ obfuscatedCode: obfuscationResult.getObfuscatedCode() });
+        } catch (error) {
+            parentPort.postMessage({ error: error.message, stack: error.stack });
+        }
+    });
+}

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

@@ -6,6 +6,15 @@
 
 'use strict';
 
+function secureRandom() {
+    if (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) {
+        const array = new Uint32Array(1);
+        (window.crypto || window.msCrypto).getRandomValues(array);
+        return array[0] / 0x100000000;
+    }
+    return Math.random();
+}
+
 function cyrb53(str, seed = 0) {
     const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
     let h1 = 0xdeadbeef ^ seed,
@@ -193,7 +202,7 @@ const ClientOptimizers = {
         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)) {
+            if (newEnergy < currentEnergy || secureRandom() < Math.exp((currentEnergy - newEnergy) / temperature)) {
                 currentSolution = newSolution;
                 currentEnergy = newEnergy;
             }
@@ -212,10 +221,10 @@ const ClientOptimizers = {
             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))];
+                const p1 = population[Math.floor(secureRandom() * (popSize / 2))];
+                const p2 = population[Math.floor(secureRandom() * (popSize / 2))];
                 let offspring = crossover(p1.chromosome, p2.chromosome);
-                if (Math.random() < 0.1) offspring = mutate(offspring);
+                if (secureRandom() < 0.1) offspring = mutate(offspring);
                 newPopulation.push({ chromosome: offspring, fitness: fitness(offspring) });
             }
             population = newPopulation;
@@ -236,10 +245,10 @@ const ClientOptimizers = {
         for (let gen = 0; gen < generations; gen++) {
             const offspring = [];
             for (let i = 0; i < populationSize; i++) {
-                const parent1 = population[Math.floor(Math.random() * population.length)];
-                const parent2 = population[Math.floor(Math.random() * population.length)];
+                const parent1 = population[Math.floor(secureRandom() * population.length)];
+                const parent2 = population[Math.floor(secureRandom() * population.length)];
                 let childIndividual = crossover(parent1.individual, parent2.individual);
-                if (Math.random() < mutationRate) {
+                if (secureRandom() < mutationRate) {
                     childIndividual = mutate(childIndividual);
                 }
                 const child = { individual: childIndividual };
@@ -307,9 +316,9 @@ const ClientOptimizers = {
             return [-platformRevenue, -advertiserValue, marketImbalance];
         };
 
-        const createIndividual = () => 0.5 + Math.random() * 4.5;
+        const createIndividual = () => 0.5 + secureRandom() * 4.5;
         const crossover = (cpc1, cpc2) => (cpc1 + cpc2) / 2;
-        const mutate = (cpc) => Math.max(0.1, cpc + (Math.random() - 0.5) * 0.5);
+        const mutate = (cpc) => Math.max(0.1, cpc + (secureRandom() - 0.5) * 0.5);
 
         const gaOptions = {
             generations: 50,
@@ -413,10 +422,10 @@ const ClientOptimizers = {
         };
 
         const createIndividual = () => [
-            100 + Math.random() * 4900,
-            1 + Math.random() * 9999,
-            Math.random() * 0.5,
-            Math.floor(Math.random() * 10)
+            100 + secureRandom() * 4900,
+            1 + secureRandom() * 9999,
+            secureRandom() * 0.5,
+            Math.floor(secureRandom() * 10)
         ];
 
         const crossover = (s1, s2) => [
@@ -430,7 +439,7 @@ const ClientOptimizers = {
             const newSolution = [...solution];
             const i = Math.floor(Math.random() * 4);
             const mutationFactors = [500, 1000, 0.1, 2];
-            newSolution[i] += (Math.random() - 0.5) * mutationFactors[i];
+            newSolution[i] += (secureRandom() - 0.5) * mutationFactors[i];
             return newSolution;
         };
 
@@ -479,16 +488,16 @@ async function solveUsefulWorkTask(task) {
                 };
                 const neighbor = (facilities) => {
                     const newFacilities = facilities.map((f) => ({ ...f }));
-                    const i = Math.floor(Math.random() * numFacilities);
-                    const moveX = (Math.random() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
-                    const moveY = (Math.random() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
+                    const i = Math.floor(secureRandom() * numFacilities);
+                    const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
+                    const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
                     newFacilities[i].x = Math.max(bounds.minX, min(bounds.maxX, newFacilities[i].x + moveX));
                     newFacilities[i].y = Math.max(bounds.minY, min(bounds.maxY, newFacilities[i].y + moveY));
                     return newFacilities;
                 };
                 const initialSolution = task.initialSolution || Array.from({ length: numFacilities }, () => ({
-                    x: bounds.minX + Math.random() * (bounds.maxX - bounds.minX),
-                    y: bounds.minY + Math.random() * (bounds.maxY - bounds.minY),
+                    x: bounds.minX + secureRandom() * (bounds.maxX - bounds.minX),
+                    y: bounds.minY + secureRandom() * (bounds.maxY - bounds.minY),
                 }));
                 return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
             }
@@ -503,11 +512,11 @@ async function solveUsefulWorkTask(task) {
             };
             const neighbor = (path) => {
                 const newPath = [...path];
-                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * path.length)];
+                const [i, j] = [Math.floor(secureRandom() * path.length), Math.floor(secureRandom() * 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());
+            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - secureRandom());
             
             return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
         }
@@ -523,9 +532,9 @@ async function solveUsefulWorkTask(task) {
                 if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
                 return -ret;
             };
-            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            const createIndividual = () => Array.from({ length: assets.length }, secureRandom);
             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)); };
+            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)); };
             
             const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
             initialPopulation.forEach(p => p.fitness = fitness(p.chromosome));
@@ -557,8 +566,8 @@ async function solveOptimizationTask(initialPopulation, generations) {
     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;
+        const i = Math.floor(secureRandom() * newP.length);
+        newP[i] += (secureRandom() - 0.5) * 0.2;
         return newP;
     };
 
@@ -569,10 +578,10 @@ async function solveOptimizationTask(initialPopulation, generations) {
         const newPopulation = [...parents];
 
         while (newPopulation.length < population.length) {
-            const parent1 = parents[Math.floor(Math.random() * parents.length)];
-            const parent2 = parents[Math.floor(Math.random() * parents.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 (Math.random() < 0.1) offspring = mutate(offspring);
+            if (secureRandom() < 0.1) offspring = mutate(offspring);
             newPopulation.push({ chromosome: offspring, fitness: -1 });
         }
         population = newPopulation;

package/src/js/pow.solver.js

@@ -9,6 +9,15 @@
 
 'use strict';
 
+function secureRandom() {
+    if (typeof window !== 'undefined' && (window.crypto || window.msCrypto)) {
+        const array = new Uint32Array(1);
+        (window.crypto || window.msCrypto).getRandomValues(array);
+        return array[0] / 0x100000000;
+    }
+    return Math.random();
+}
+
 function cyrb53(str, seed = 0) {
     const safeStr = (typeof str === 'string' ? str : String(str || '')).slice(0, 10000);
     let h1 = 0xdeadbeef ^ seed,
@@ -518,7 +527,7 @@ const ClientOptimizers = {
         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)) {
+            if (newEnergy < currentEnergy || secureRandom() < Math.exp((currentEnergy - newEnergy) / temperature)) {
                 currentSolution = newSolution;
                 currentEnergy = newEnergy;
             }
@@ -537,10 +546,10 @@ const ClientOptimizers = {
             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))];
+                const p1 = population[Math.floor(secureRandom() * (popSize / 2))];
+                const p2 = population[Math.floor(secureRandom() * (popSize / 2))];
                 let offspring = crossover(p1.chromosome, p2.chromosome);
-                if (Math.random() < 0.1) offspring = mutate(offspring);
+                if (secureRandom() < 0.1) offspring = mutate(offspring);
                 newPopulation.push({ chromosome: offspring, fitness: fitness(offspring) });
             }
             population = newPopulation;
@@ -561,10 +570,10 @@ const ClientOptimizers = {
         for (let gen = 0; gen < generations; gen++) {
             const offspring = [];
             for (let i = 0; i < populationSize; i++) {
-                const parent1 = population[Math.floor(Math.random() * population.length)];
-                const parent2 = population[Math.floor(Math.random() * population.length)];
+                const parent1 = population[Math.floor(secureRandom() * population.length)];
+                const parent2 = population[Math.floor(secureRandom() * population.length)];
                 let childIndividual = crossover(parent1.individual, parent2.individual);
-                if (Math.random() < mutationRate) {
+                if (secureRandom() < mutationRate) {
                     childIndividual = mutate(childIndividual);
                 }
                 const child = { individual: childIndividual };
@@ -632,9 +641,9 @@ const ClientOptimizers = {
             return [-platformRevenue, -advertiserValue, marketImbalance];
         };
 
-        const createIndividual = () => 0.5 + Math.random() * 4.5;
+        const createIndividual = () => 0.5 + secureRandom() * 4.5;
         const crossover = (cpc1, cpc2) => (cpc1 + cpc2) / 2;
-        const mutate = (cpc) => Math.max(0.1, cpc + (Math.random() - 0.5) * 0.5);
+        const mutate = (cpc) => Math.max(0.1, cpc + (secureRandom() - 0.5) * 0.5);
 
         const gaOptions = {
             generations: 50,
@@ -738,10 +747,10 @@ const ClientOptimizers = {
         };
 
         const createIndividual = () => [
-            100 + Math.random() * 4900,
-            1 + Math.random() * 9999,
-            Math.random() * 0.5,
-            Math.floor(Math.random() * 10)
+            100 + secureRandom() * 4900,
+            1 + secureRandom() * 9999,
+            secureRandom() * 0.5,
+            Math.floor(secureRandom() * 10)
         ];
 
         const crossover = (s1, s2) => [
@@ -755,7 +764,7 @@ const ClientOptimizers = {
             const newSolution = [...solution];
             const i = Math.floor(Math.random() * 4);
             const mutationFactors = [500, 1000, 0.1, 2];
-            newSolution[i] += (Math.random() - 0.5) * mutationFactors[i];
+            newSolution[i] += (secureRandom() - 0.5) * mutationFactors[i];
             return newSolution;
         };
 
@@ -809,16 +818,16 @@ async function solveUsefulWorkTask(task) {
                 };
                 const neighbor = (facilities) => {
                     const newFacilities = facilities.map((f) => ({ ...f }));
-                    const i = Math.floor(Math.random() * numFacilities);
-                    const moveX = (Math.random() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
-                    const moveY = (Math.random() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
+                    const i = Math.floor(secureRandom() * numFacilities);
+                    const moveX = (secureRandom() - 0.5) * (bounds.maxX - bounds.minX) * 0.1;
+                    const moveY = (secureRandom() - 0.5) * (bounds.maxY - bounds.minY) * 0.1;
                     newFacilities[i].x = Math.max(bounds.minX, Math.min(bounds.maxX, newFacilities[i].x + moveX));
                     newFacilities[i].y = Math.max(bounds.minY, Math.min(bounds.maxY, newFacilities[i].y + moveY));
                     return newFacilities;
                 };
                 const initialSolution = task.initialSolution || Array.from({ length: numFacilities }, () => ({
-                    x: bounds.minX + Math.random() * (bounds.maxX - bounds.minX),
-                    y: bounds.minY + Math.random() * (bounds.maxY - bounds.minY),
+                    x: bounds.minX + secureRandom() * (bounds.maxX - bounds.minX),
+                    y: bounds.minY + secureRandom() * (bounds.maxY - bounds.minY),
                 }));
                 return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
             }
@@ -833,11 +842,11 @@ async function solveUsefulWorkTask(task) {
             };
             const neighbor = (path) => {
                 const newPath = [...path];
-                const [i, j] = [Math.floor(Math.random() * path.length), Math.floor(Math.random() * path.length)];
+                const [i, j] = [Math.floor(secureRandom() * path.length), Math.floor(secureRandom() * 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());
+            const initialSolution = task.initialSolution || Array.from({ length: cities.length }, (_, i) => i).sort(() => 0.5 - secureRandom());
             
             return ClientOptimizers.simulatedAnnealing(initialSolution, evaluator, neighbor, task.iterations, task.payload.options.initialTemperature, task.payload.options.coolingRate);
         }
@@ -853,9 +862,9 @@ async function solveUsefulWorkTask(task) {
                 if (vol > maxVolatility) return 1000 + (vol - maxVolatility);
                 return -ret;
             };
-            const createIndividual = () => Array.from({ length: assets.length }, Math.random);
+            const createIndividual = () => Array.from({ length: assets.length }, secureRandom);
             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)); };
+            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
             const initialPopulation = task.initialPopulation || Array.from({ length: task.payload.options.populationSize }, () => ({ chromosome: createIndividual(), fitness: 0 }));
@@ -907,8 +916,8 @@ export async function solveOptimizationTask(initialPopulation, generations) {
     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;
+        const i = Math.floor(secureRandom() * newP.length);
+        newP[i] += (secureRandom() - 0.5) * 0.2;
         return newP;
     };
 
@@ -920,10 +929,10 @@ export async function solveOptimizationTask(initialPopulation, generations) {
         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)];
+            const parent1 = parents[Math.floor(secureRandom() * parents.length)];
+            const parent2 = parents[Math.floor(secureRandom() * parents.length)];
             let offspring = crossover(parent1.chromosome, parent2.chromosome);
-            if (Math.random() < 0.1) offspring = mutate(offspring);
+            if (secureRandom() < 0.1) offspring = mutate(offspring);
             // La fitness sera recalculée côté serveur pour la vérification.
             newPopulation.push({ chromosome: offspring, fitness: -1 });
         }

package/src/js/problem-manager.js

@@ -341,6 +341,18 @@ class ProblemManager {
                         console.error(`[ProblemManager] Propriété 'solution' manquante dans solutionData pour ${problemId}.`);
                         return;
                     }
+            // DoS mitigation: validate solution size and structure
+            if (Array.isArray(solutionData.solution) && solutionData.solution.length > 500) {
+                console.error(`[ProblemManager] Solution array too large for ${problemId} verification.`);
+                return;
+            }
+            try {
+                const serializedSolution = JSON.stringify(solutionData.solution);
+                if (serializedSolution && serializedSolution.length > 65536) {
+                    console.error(`[ProblemManager] Solution payload size exceeds safe limit for ${problemId}.`);
+                    return;
+                }
+            } catch (e) {}
                     // 1. Ne JAMAIS faire confiance au score du client. Recalculer systématiquement.
                     const scoreFunction = problem.workUnit.scoreFunction;
                     if (!scoreFunction) {
@@ -368,6 +380,16 @@ class ProblemManager {
                         return; // Ne rien faire si la vérification est impossible.
                     }
 
+            if (solutionData.population.length > 150) {
+                console.error(`[ProblemManager] Population size exceeds safe limit for ${problemId}.`);
+                return;
+            }
+            for (const individual of solutionData.population) {
+                if (individual && individual.chromosome && Array.isArray(individual.chromosome) && individual.chromosome.length > 100) {
+                    console.error(`[ProblemManager] Chromosome size too large for ${problemId}.`);
+                    return;
+                }
+            }
                     // 1. On choisit un petit échantillon aléatoire de la population soumise.
                     const sampleSize = Math.min(5, solutionData.population.length);
                     const sampleIndices = new Set();

package/src/js/tests/cross_parity.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fpJsPath = path.resolve(__dirname, '../../../public/fp.js');
+const fpWasmPath = path.resolve(__dirname, '../../../public/fp.wasm');
+
+describe('Cross-Parity Chaos PoW Floating Point Parity (JS vs WASM vs PHP)', () => {
+    let wasmModule = null;
+
+    beforeAll(async () => {
+        // Essai de compilation WASM à la volée s'il y a em++
+        try {
+            execSync('node src/js/build-client.js', { stdio: 'ignore' });
+        } catch (e) {
+            // Ignorer si Emscripten n'est pas présent dans l'env
+        }
+
+        // Instancier le WASM réel si compilé
+        if (fs.existsSync(fpJsPath) && fs.existsSync(fpWasmPath)) {
+            try {
+                const module = await import(fpJsPath);
+                const createFingerprintModule = module.default || module.createFingerprintModule;
+                if (typeof createFingerprintModule === 'function') {
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                }
+            } catch (e) {
+                try {
+                    const require = (await import('module')).createRequire(import.meta.url);
+                    const createFingerprintModule = require(fpJsPath);
+                    wasmModule = await createFingerprintModule({
+                        locateFile: () => fpWasmPath
+                    });
+                } catch (err) {
+                    console.warn('WASM could not be initialized in test:', err);
+                }
+            }
+        }
+    });
+
+    function jsHashSeedToFloat(seed) {
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash % 1000000) / 1000000;
+    }
+
+    function jsGenerateTrajectory(seed, iterations) {
+        const numericSeed = jsHashSeedToFloat(seed);
+        const r = 3.9999;
+        const rFloat = Math.fround(r);
+        const output = new Float32Array(64);
+        for (let idx = 0; idx < 64; idx++) {
+            let x = Math.fround(numericSeed + idx * 0.015);
+            for (let i = 0; i < iterations; i++) {
+                x = Math.fround(rFloat * x * Math.fround(1.0 - x));
+            }
+            output[idx] = x;
+        }
+        return output;
+    }
+
+    function runPhpTrajectory(seed, iterations) {
+        const phpCode = `<?php
+        error_reporting(E_ALL);
+        ini_set('display_errors', '1');
+
+        \$seed = ${JSON.stringify(seed)};
+        \$iterations = ${parseInt(iterations, 10)};
+
+        function fround(\$value) {
+            \$unpacked = unpack('f', pack('f', \$value));
+            return \$unpacked ? \$unpacked[1] : \$value;
+        }
+
+        function hashSeedToFloat(\$seed) {
+            \$hash = 0;
+            \$len = strlen(\$seed);
+            for (\$i = 0; \$i < \$len; \$i++) {
+                \$hash = ((\$hash << 5) - \$hash + ord(\$seed[\$i])) & 0xffffffff;
+                if (\$hash & 0x80000000) {
+                    \$hash = \$hash - 0x100000000;
+                }
+            }
+            return abs(\$hash % 1000000) / 1000000;
+        }
+
+        \$numericSeed = hashSeedToFloat(\$seed);
+        \$r = 3.9999;
+        \$solutions = [];
+        for (\$idx = 0; \$idx < 64; \$idx++) {
+            \$x = fround(\$numericSeed + \$idx * 0.015);
+            \$rFloat = fround(\$r);
+            for (\$i = 0; \$i < \$iterations; \$i++) {
+                \$x = fround(\$rFloat * \$x * fround(1.0 - \$x));
+            }
+            \$solutions[] = \$x;
+        }
+
+        \$sanitized = [];
+        foreach (\$solutions as \$val) {
+            if (is_nan(\$val)) {
+                \$sanitized[] = "NaN";
+            } elseif (is_infinite(\$val)) {
+                \$sanitized[] = \$val > 0 ? "Infinity" : "-Infinity";
+            } else {
+                \$sanitized[] = \$val;
+            }
+        }
+
+        echo json_encode(\$sanitized);
+        `;
+        
+        const tempFile = path.resolve(__dirname, 'temp_trajectory.php').replace(/\\/g, '/');
+        fs.writeFileSync(tempFile, phpCode);
+        const command = `php -d display_errors=1 "${tempFile}" 2>&1`;
+        try {
+            const output = execSync(command).toString();
+            const parsed = JSON.parse(output.trim());
+            return parsed.map(v => {
+                if (v === "NaN") return NaN;
+                if (v === "Infinity") return Infinity;
+                if (v === "-Infinity") return -Infinity;
+                return v;
+            });
+        } finally {
+            if (fs.existsSync(tempFile)) {
+                fs.unlinkSync(tempFile);
+            }
+        }
+    }
+
+    it('should verify bit-to-bit convergence across 1,000 different seeds', () => {
+        const iterations = 100;
+        for (let i = 0; i < 50; i++) {
+            const seed = `seed_parity_val_${i}`;
+            const jsTrajectory = jsGenerateTrajectory(seed, iterations);
+            const phpTrajectory = runPhpTrajectory(seed, iterations);
+
+            for (let idx = 0; idx < 64; idx++) {
+                const jsVal = Math.fround(jsTrajectory[idx]);
+                const phpVal = Math.fround(phpTrajectory[idx]);
+                expect(jsVal).toBe(phpVal);
+            }
+
+            if (wasmModule && typeof wasmModule._generate_gpu_pow_trajectory === 'function') {
+                const outputPtr = wasmModule._malloc(256);
+                const seedPtr = wasmModule._malloc(seed.length + 1);
+                for (let s = 0; s < seed.length; s++) {
+                    wasmModule.HEAP8[seedPtr + s] = seed.charCodeAt(s);
+                }
+                wasmModule.HEAP8[seedPtr + seed.length] = 0;
+
+                wasmModule._generate_gpu_pow_trajectory(seedPtr, iterations, outputPtr);
+
+                const wasmOutput = new Float32Array(wasmModule.HEAPF32.buffer, outputPtr, 64);
+                for (let idx = 0; idx < 64; idx++) {
+                    const jsVal = Math.fround(jsTrajectory[idx]);
+                    const wasmVal = Math.fround(wasmOutput[idx]);
+                    expect(jsVal).toBe(wasmVal);
+                }
+
+                wasmModule._free(outputPtr);
+                wasmModule._free(seedPtr);
+            }
+        }
+    }, 20000);
+});