npm - flockml - Versions diffs - 1.0.0 - Mend

flockml 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/deep-profiling-report.html +119 -0
package/dist/activations.d.ts +13 -0
package/dist/activations.js +47 -0
package/dist/break-test.d.ts +1 -0
package/dist/break-test.js +249 -0
package/dist/brutal-test.d.ts +1 -0
package/dist/brutal-test.js +113 -0
package/dist/client-node.d.ts +48 -0
package/dist/client-node.js +174 -0
package/dist/coordinator.d.ts +41 -0
package/dist/coordinator.js +155 -0
package/dist/index.d.ts +5 -0
package/dist/index.js +13 -0
package/dist/matrix.d.ts +67 -0
package/dist/matrix.js +185 -0
package/dist/micro-benchmark.d.ts +1 -0
package/dist/micro-benchmark.js +215 -0
package/dist/network.d.ts +32 -0
package/dist/network.js +127 -0
package/dist/privacy.d.ts +17 -0
package/dist/privacy.js +70 -0
package/dist/quantization.d.ts +33 -0
package/dist/quantization.js +92 -0
package/dist/test.d.ts +1 -0
package/dist/test.js +58 -0
package/dist/worker.d.ts +15 -0
package/dist/worker.js +95 -0
package/package.json +21 -0
package/src/activations.ts +45 -0
package/src/break-test.ts +234 -0
package/src/brutal-test.ts +103 -0
package/src/client-node.ts +154 -0
package/src/coordinator.ts +137 -0
package/src/index.ts +5 -0
package/src/messages.d.ts +429 -0
package/src/messages.js +1173 -0
package/src/messages.proto +30 -0
package/src/micro-benchmark.ts +200 -0
package/src/network.ts +113 -0
package/src/privacy.ts +39 -0
package/src/quantization.ts +82 -0
package/src/test.ts +72 -0
package/src/worker.ts +95 -0
package/stress-report.html +190 -0
package/tsconfig.json +14 -0

package/deep-profiling-report.html ADDED Viewed

@@ -0,0 +1,119 @@
+  <!DOCTYPE html>
+  <html lang="en">
+  <head>
+      <meta charset="UTF-8">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>FlockML TFJS Breakdown</title>
+      <script src="https://cdn.tailwindcss.com"></script>
+  </head>
+  <body class="bg-gray-950 text-gray-100 p-8 font-sans">
+      <div class="max-w-7xl mx-auto">
+          <h1 class="text-4xl font-bold mb-2 bg-gradient-to-r from-green-500 to-blue-500 bg-clip-text text-transparent">FlockML V2: TFJS Benchmarking</h1>
+          <p class="text-gray-400 mb-8">Hardware-accelerated continuous memory telemetry.</p>
+          <div class="bg-gray-900 border border-gray-800 rounded-xl overflow-hidden shadow-2xl mb-8">
+              <table class="w-full text-left border-collapse">
+                  <thead>
+                      <tr class="bg-gray-950 text-gray-400 text-sm uppercase tracking-wider">
+                          <th class="p-4 border-b border-gray-800">Architecture</th>
+                          <th class="p-4 border-b border-gray-800">Parameters</th>
+                          <th class="p-4 border-b border-gray-800">Allocation (RAM)</th>
+                          <th class="p-4 border-b border-gray-800">Train Batch</th>
+                          <th class="p-4 border-b border-gray-800">8-Bit Quantize</th>
+                          <th class="p-4 border-b border-gray-800">Protobuf Encode</th>
+                          <th class="p-4 border-b border-gray-800">Heap Used</th>
+                          <th class="p-4 border-b border-gray-800">Payload Size</th>
+                          <th class="p-4 border-b border-gray-800">Status</th>
+                      </tr>
+                  </thead>
+                  <tbody>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Tiny (MNIST)</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">101,632</td>
+      <td class="p-3 border-b border-gray-800">12.33 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-green-400">9.45 ms</td>
+      <td class="p-3 border-b border-gray-800">21.28 ms</td>
+      <td class="p-3 border-b border-gray-800">0.41 ms</td>
+      <td class="p-3 border-b border-gray-800">-6.29 MB</td>
+      <td class="p-3 border-b border-gray-800">0.10 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Small</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">505,000</td>
+      <td class="p-3 border-b border-gray-800">26.11 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-green-400">13.67 ms</td>
+      <td class="p-3 border-b border-gray-800">79.42 ms</td>
+      <td class="p-3 border-b border-gray-800">0.09 ms</td>
+      <td class="p-3 border-b border-gray-800">-13.89 MB</td>
+      <td class="p-3 border-b border-gray-800">0.48 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Medium (1M Params)</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">1,010,000</td>
+      <td class="p-3 border-b border-gray-800">39.00 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-green-400">24.42 ms</td>
+      <td class="p-3 border-b border-gray-800">159.95 ms</td>
+      <td class="p-3 border-b border-gray-800">0.26 ms</td>
+      <td class="p-3 border-b border-gray-800">51.47 MB</td>
+      <td class="p-3 border-b border-gray-800">0.96 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Large (4M Params)</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">4,020,000</td>
+      <td class="p-3 border-b border-gray-800">124.86 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-green-400">133.69 ms</td>
+      <td class="p-3 border-b border-gray-800">601.77 ms</td>
+      <td class="p-3 border-b border-gray-800">0.31 ms</td>
+      <td class="p-3 border-b border-gray-800">-34.14 MB</td>
+      <td class="p-3 border-b border-gray-800">3.84 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Huge (25M Params)</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">25,050,000</td>
+      <td class="p-3 border-b border-gray-800">745.24 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-green-400">611.36 ms</td>
+      <td class="p-3 border-b border-gray-800">5107.36 ms</td>
+      <td class="p-3 border-b border-gray-800">2.86 ms</td>
+      <td class="p-3 border-b border-gray-800">-21.50 MB</td>
+      <td class="p-3 border-b border-gray-800">23.89 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+    <tr class="hover:bg-gray-800 transition-colors">
+      <td class="p-3 border-b border-gray-800 font-bold">Colossal (100M Params)</td>
+      <td class="p-3 border-b border-gray-800 text-blue-400 font-mono">100,100,000</td>
+      <td class="p-3 border-b border-gray-800">3200.91 ms</td>
+      <td class="p-3 border-b border-gray-800 font-bold text-red-400">3142.55 ms</td>
+      <td class="p-3 border-b border-gray-800">87381.14 ms</td>
+      <td class="p-3 border-b border-gray-800">516.91 ms</td>
+      <td class="p-3 border-b border-gray-800">-25.78 MB</td>
+      <td class="p-3 border-b border-gray-800">95.47 MB</td>
+      <td class="p-3 border-b border-gray-800">Success</td>
+    </tr>
+                  </tbody>
+              </table>
+          </div>
+          <div class="grid grid-cols-1 md:grid-cols-2 gap-8">
+              <div class="p-6 bg-gray-900 border-l-4 border-green-500 rounded-r-xl">
+                  <h3 class="text-xl font-bold text-green-400 mb-2">Phase 5 Successful: GPU Math</h3>
+                  <p class="text-gray-300 space-y-2">
+                      We have completely replaced the pure JS Math Engine with <code>@tensorflow/tfjs</code>. Notice that we no longer crash at 100M parameters. Training memory remains stable because tensors are stored outside V8 Heap.
+                  </p>
+              </div>
+          </div>
+      </div>
+  </body>
+  </html>

package/dist/activations.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+/**
+ * Activation Functions & Calculus for the Neural Network.
+ *
+ * This module contains the non-linear activation functions used in the Forward Pass,
+ * and their corresponding mathematical derivatives used in Backpropagation (Chain Rule)
+ * to calculate the gradients for weight adjustments.
+ */
+export declare function sigmoid(x: number): number;
+export declare function dsigmoid(y: number): number;
+export declare function relu(x: number): number;
+export declare function drelu(y: number): number;
+export declare function tanh(x: number): number;
+export declare function dtanh(y: number): number;

package/dist/activations.js ADDED Viewed

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Activation Functions & Calculus for the Neural Network.
+ *
+ * This module contains the non-linear activation functions used in the Forward Pass,
+ * and their corresponding mathematical derivatives used in Backpropagation (Chain Rule)
+ * to calculate the gradients for weight adjustments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sigmoid = sigmoid;
+exports.dsigmoid = dsigmoid;
+exports.relu = relu;
+exports.drelu = drelu;
+exports.tanh = tanh;
+exports.dtanh = dtanh;
+// Sigmoid function: squashes numbers between 0 and 1.
+// Used for probability outputs.
+function sigmoid(x) {
+    return 1 / (1 + Math.exp(-x));
+}
+// The derivative of the Sigmoid function.
+// Crucial for calculating the gradient during backpropagation.
+// Math: f'(x) = f(x) * (1 - f(x))
+function dsigmoid(y) {
+    // Note: y is already the sigmoid output here.
+    return y * (1 - y);
+}
+// ReLU (Rectified Linear Unit) function.
+// Allows the network to learn non-linear patterns faster without the vanishing gradient problem.
+function relu(x) {
+    return Math.max(0, x);
+}
+// Derivative of ReLU.
+// Math: 1 if x > 0 else 0
+function drelu(y) {
+    return y > 0 ? 1 : 0;
+}
+// Tanh (Hyperbolic Tangent) function.
+// Squashes numbers between -1 and 1. Good for hidden layers.
+function tanh(x) {
+    return Math.tanh(x);
+}
+// Derivative of Tanh.
+// Math: 1 - f(x)^2
+function dtanh(y) {
+    return 1 - (y * y);
+}

package/dist/break-test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/break-test.js ADDED Viewed

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const coordinator_1 = require("./coordinator");
+const client_node_1 = require("./client-node");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+console.log("=== INITIATING BRUTAL BREAK TEST ===");
+const scales = [100, 1000, 5000, 10000, 50000, 100000, 250000, 500000, 1000000];
+const results = [];
+let broken = false;
+// Mock data
+const inputs = [[0, 0], [0, 1], [1, 0], [1, 1]];
+const targets = [[0], [1], [1], [0]];
+for (const scale of scales) {
+    if (broken)
+        break;
+    console.log(`\n--- Testing Scale: ${scale} Clients ---`);
+    try {
+        // Check if we're approaching V8 memory limit (assuming 1.4GB default)
+        const memBefore = process.memoryUsage().heapUsed / 1024 / 1024;
+        if (memBefore > 1000) {
+            console.log(`⚠️ Dangerously high memory (${memBefore.toFixed(0)} MB). Approaching V8 limit.`);
+        }
+        const coordinator = new coordinator_1.Coordinator(2, 4, 1);
+        const payloads = [];
+        // Simulate clients locally without actually instantiating 100,000 full FlockNode classes
+        // to save V8 heap overhead (we want to test the Math/Network layer, not Node.js class overhead)
+        // Actually, to be brutally honest, we SHOULD instantiate them to see if the browser memory blows up.
+        // But in a real scenario, these are distributed across 100,000 different devices.
+        // If we instantiate 100,000 on ONE machine, we are testing the machine, not the architecture's scalability.
+        // So, we will generate 1 payload, and copy it N times to simulate N inbound websocket requests.
+        console.log(`[Edge] Simulating ${scale} device payloads...`);
+        const mockNode = new client_node_1.FlockNode(2, 4, 1);
+        mockNode.connect('wss://mock');
+        const startingWeights = coordinator.getGlobalWeightsForBroadcast();
+        mockNode.syncGlobalWeights(startingWeights.weights_ih, startingWeights.weights_ho, startingWeights.bias_h, startingWeights.bias_o);
+        mockNode.trainLocalBatch(inputs, targets);
+        const basePayload = mockNode.exportSecureGradients();
+        // Create an array of references (or actual copies if we want to test server memory)
+        // We must test server memory, so we will allocate real memory for incoming arrays.
+        let edgeTime = 0;
+        const startPayloadGen = performance.now();
+        for (let i = 0; i < scale; i++) {
+            // In reality, each client takes ~3ms. So edge computation is deeply parallel.
+            // We will just record the theoretical parallel time (which is just ~3ms across the globe)
+            // and test the SERVER's ability to hold and process them.
+            // Simulate unique payload instances arriving in memory
+            payloads.push(new Uint8Array(basePayload));
+        }
+        const endPayloadGen = performance.now();
+        const serverMemBefore = process.memoryUsage().heapUsed / 1024 / 1024;
+        console.log(`[Server] Memory Usage Before Aggregation: ${serverMemBefore.toFixed(2)} MB`);
+        console.log(`[Server] Coordinator receiving ${scale} payloads...`);
+        const startReceive = performance.now();
+        for (const p of payloads) {
+            coordinator.receiveUpdate(p);
+        }
+        const endReceive = performance.now();
+        console.log(`[Server] Running FedAvg on ${scale} matrices...`);
+        const startAgg = performance.now();
+        coordinator.aggregate();
+        const endAgg = performance.now();
+        const serverMemAfter = process.memoryUsage().heapUsed / 1024 / 1024;
+        const timeTaken = (endAgg - startReceive);
+        console.log(`✅ Success for ${scale} clients. Time: ${timeTaken.toFixed(2)}ms`);
+        results.push({
+            scale,
+            payloadSizeKB: (scale * basePayload.length) / 1024,
+            receiveTime: (endReceive - startReceive),
+            aggTime: (endAgg - startAgg),
+            totalTime: timeTaken,
+            memBefore: serverMemBefore,
+            memAfter: serverMemAfter,
+            status: 'Success'
+        });
+        // Artificially break if processing takes longer than 5 seconds (real-time websocket timeout)
+        if (timeTaken > 5000) {
+            console.log(`❌ BROKEN: Server aggregation took ${timeTaken.toFixed(2)}ms (Exceeded 5000ms timeout)`);
+            broken = true;
+            results[results.length - 1].status = 'Broken: Latency Timeout (>5s)';
+        }
+        // Force garbage collection if available
+        if (global.gc)
+            global.gc();
+    }
+    catch (err) {
+        console.log(`❌ BROKEN at ${scale} clients: ${err.message}`);
+        broken = true;
+        results.push({
+            scale,
+            payloadSizeKB: 0,
+            receiveTime: 0,
+            aggTime: 0,
+            totalTime: 0,
+            memBefore: 0,
+            memAfter: 0,
+            status: `Broken: ${err.message}`
+        });
+    }
+}
+// Generate HTML Report
+const htmlPath = path.resolve(process.cwd(), 'stress-report.html');
+const rows = results.map(r => `
+  <tr class="${r.status.includes('Broken') ? 'bg-red-900/50 text-red-200' : 'hover:bg-gray-800 transition-colors'}">
+    <td class="p-3 border-b border-gray-800 font-mono text-blue-400">${r.scale.toLocaleString()}</td>
+    <td class="p-3 border-b border-gray-800">${r.payloadSizeKB.toFixed(2)} KB</td>
+    <td class="p-3 border-b border-gray-800">${r.receiveTime.toFixed(2)} ms</td>
+    <td class="p-3 border-b border-gray-800">${r.aggTime.toFixed(2)} ms</td>
+    <td class="p-3 border-b border-gray-800 font-bold ${r.totalTime > 2000 ? 'text-yellow-400' : 'text-green-400'}">${r.totalTime.toFixed(2)} ms</td>
+    <td class="p-3 border-b border-gray-800">${r.memAfter.toFixed(2)} MB</td>
+    <td class="p-3 border-b border-gray-800">${r.status}</td>
+  </tr>
+`).join('');
+const htmlContent = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FlockML Brutal Break Test Report</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+</head>
+<body class="bg-gray-950 text-gray-100 p-8 font-sans">
+    <div class="max-w-6xl mx-auto">
+        <h1 class="text-4xl font-bold mb-2 bg-gradient-to-r from-red-500 to-orange-500 bg-clip-text text-transparent">FlockML V2 Brutal Break Test</h1>
+        <p class="text-gray-400 mb-8">Pushing the Central Coordinator Server to its absolute limits until architecture failure.</p>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-8 mb-8">
+            <div class="bg-gray-900 border border-gray-800 rounded-xl p-6 shadow-2xl">
+                <h2 class="text-xl font-semibold mb-4 text-gray-200">Server Latency (FedAvg + Protobuf)</h2>
+                <canvas id="latencyChart"></canvas>
+            </div>
+            <div class="bg-gray-900 border border-gray-800 rounded-xl p-6 shadow-2xl">
+                <h2 class="text-xl font-semibold mb-4 text-gray-200">Server Heap Memory Usage</h2>
+                <canvas id="memoryChart"></canvas>
+            </div>
+        </div>
+        <div class="bg-gray-900 border border-gray-800 rounded-xl overflow-hidden shadow-2xl">
+            <table class="w-full text-left border-collapse">
+                <thead>
+                    <tr class="bg-gray-950 text-gray-400 text-sm uppercase tracking-wider">
+                        <th class="p-4 border-b border-gray-800">Concurrent Clients</th>
+                        <th class="p-4 border-b border-gray-800">Total Bandwidth</th>
+                        <th class="p-4 border-b border-gray-800">Protobuf Decode</th>
+                        <th class="p-4 border-b border-gray-800">FedAvg Compute</th>
+                        <th class="p-4 border-b border-gray-800">Total Server Delay</th>
+                        <th class="p-4 border-b border-gray-800">Heap Memory</th>
+                        <th class="p-4 border-b border-gray-800">System Status</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    ${rows}
+                </tbody>
+            </table>
+        </div>
+        <div class="mt-8 p-6 bg-gray-900 border-l-4 border-blue-500 rounded-r-xl">
+            <h3 class="text-lg font-bold text-blue-400 mb-2">Architectural Conclusion</h3>
+            <p class="text-gray-300">
+                This test simulates extreme real-world thundering herd conditions. The breaking point indicates where the single-threaded Node.js Coordinator reaches hardware limits. To scale beyond the breaking point, horizontal scaling (Load Balancers + Redis pub/sub) or migrating the backend math to PyTorch (C++) is required.
+            </p>
+        </div>
+    </div>
+    <script>
+        const data = ${JSON.stringify(results)};
+        const labels = data.map(d => d.scale.toLocaleString());
+        // Latency Chart
+        new Chart(document.getElementById('latencyChart'), {
+            type: 'line',
+            data: {
+                labels,
+                datasets: [{
+                    label: 'Total Delay (ms)',
+                    data: data.map(d => d.totalTime),
+                    borderColor: '#3b82f6',
+                    backgroundColor: 'rgba(59, 130, 246, 0.1)',
+                    borderWidth: 2,
+                    fill: true,
+                    tension: 0.4
+                }]
+            },
+            options: {
+                responsive: true,
+                scales: { y: { beginAtZero: true, grid: { color: '#1f2937' } }, x: { grid: { color: '#1f2937' } } },
+                plugins: { legend: { display: false } }
+            }
+        });
+        // Memory Chart
+        new Chart(document.getElementById('memoryChart'), {
+            type: 'bar',
+            data: {
+                labels,
+                datasets: [{
+                    label: 'Heap Usage (MB)',
+                    data: data.map(d => d.memAfter),
+                    backgroundColor: '#f97316',
+                    borderRadius: 4
+                }]
+            },
+            options: {
+                responsive: true,
+                scales: { y: { beginAtZero: true, grid: { color: '#1f2937' } }, x: { grid: { color: '#1f2937' } } },
+                plugins: { legend: { display: false } }
+            }
+        });
+    </script>
+</body>
+</html>
+`;
+fs.writeFileSync(htmlPath, htmlContent);
+console.log(`\n✅ HTML Report generated at: ${htmlPath}`);

package/dist/brutal-test.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/brutal-test.js ADDED Viewed

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const coordinator_1 = require("./coordinator");
+const client_node_1 = require("./client-node");
+console.log("=== FLOCKML V2 BRUTAL STRESS TEST ===");
+// 1. Initialize Central Coordinator
+const coordinator = new coordinator_1.Coordinator(2, 4, 1);
+console.log("\n[Server] Initialized FedAvg Coordinator.");
+const startingWeights = coordinator.getGlobalWeightsForBroadcast();
+const NUM_CLIENTS = 100;
+const NUM_ATTACKERS = 5;
+console.log(`\n[Network] Spinning up ${NUM_CLIENTS} simulated FlockNodes...`);
+const clients = [];
+for (let i = 0; i < NUM_CLIENTS; i++) {
+    const node = new client_node_1.FlockNode(2, 4, 1);
+    node.connect('wss://mock.network');
+    node.syncGlobalWeights(startingWeights.weights_ih, startingWeights.weights_ho, startingWeights.bias_h, startingWeights.bias_o);
+    clients.push(node);
+}
+console.log(`[Network] Initiating local training on all ${NUM_CLIENTS} devices...`);
+const inputs = [[0, 0], [0, 1], [1, 0], [1, 1]];
+const targets = [[0], [1], [1], [0]];
+// 2. Train all nodes
+let start = performance.now();
+for (const client of clients) {
+    // Train locally
+    client.trainLocalBatch(inputs, targets);
+}
+let end = performance.now();
+console.log(`[Edge] Training complete. Time taken: ${(end - start).toFixed(2)}ms`);
+// 3. Sybil Attack Injection
+console.log(`\n[Attack] Injecting ${NUM_ATTACKERS} Sybil Attacks (Data Poisoning)...`);
+const tf = __importStar(require("@tensorflow/tfjs-core"));
+for (let i = 0; i < NUM_ATTACKERS; i++) {
+    // We manually corrupt the weights to mimic a malicious actor modifying the browser memory
+    const shape_ih = clients[i].network.weights_ih.shape;
+    clients[i].network.weights_ih.assign(tf.fill(shape_ih, NaN));
+    const shape_ho = clients[i].network.weights_ho.shape;
+    clients[i].network.weights_ho.assign(tf.fill(shape_ho, Infinity));
+}
+// 4. Secure, Quantize, and Serialize
+start = performance.now();
+const payloads = [];
+let totalBytes = 0;
+for (const client of clients) {
+    client.privacyEpsilon = 1.0;
+    const binaryPayload = client.exportSecureGradients();
+    payloads.push(binaryPayload);
+    totalBytes += binaryPayload.length;
+}
+end = performance.now();
+console.log(`[Edge] Quantization & Protobuf Encoding complete. Time taken: ${(end - start).toFixed(2)}ms`);
+console.log(`[Network] Total Payload Size for ${NUM_CLIENTS} nodes: ${(totalBytes / 1024).toFixed(2)} KB (Avg: ${(totalBytes / NUM_CLIENTS).toFixed(0)} bytes/node)`);
+// 5. Server Aggregation
+console.log("\n[Server] Receiving 100 Encrypted Binary Payloads...");
+const oldWeight = coordinator.globalModel.weights_ih.dataSync()[0];
+start = performance.now();
+for (const payload of payloads) {
+    coordinator.receiveUpdate(payload);
+}
+console.log("[Server] Running Federated Averaging (FedAvg) + Anomaly Detection...");
+coordinator.aggregate();
+end = performance.now();
+const newWeight = coordinator.globalModel.weights_ih.dataSync()[0];
+console.log(`\n=== STRESS TEST RESULTS ===`);
+console.log(`Server Processing Time: ${(end - start).toFixed(2)}ms`);
+console.log(`Global Weight Before:   ${oldWeight.toFixed(4)}`);
+console.log(`Global Weight After:    ${newWeight.toFixed(4)}`);
+console.log(`Weight Delta:           ${(newWeight - oldWeight).toFixed(4)}`);
+if (Number.isNaN(newWeight) || !Number.isFinite(newWeight)) {
+    console.log("\n❌ FAILED: The global model was destroyed by the Sybil Attack.");
+    process.exit(1);
+}
+else {
+    console.log("\n✅ SUCCESS: The global model survived the Sybil attack and successfully aggregated the honest gradients!");
+}
+// Cleanup Web Workers to prevent hanging
+for (const client of clients) {
+    client.destroy();
+}

package/dist/client-node.d.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import { NeuralNetwork } from './network';
+import { QuantizedPayload } from './quantization';
+import { WorkerManager } from './worker';
+import * as tf from '@tensorflow/tfjs';
+/**
+ * The FlockML Client Node.
+ *
+ * Powered by TFJS. It encapsulates the neural network, the privacy engine, and the quantization engine.
+ * In a full production build, this entire class would be serialized into a Blob
+ * and executed inside a background Web Worker to keep the UI at 60fps.
+ */
+export declare class FlockNode {
+    network: NeuralNetwork;
+    isConnected: boolean;
+    isTraining: boolean;
+    privacyEpsilon: number;
+    workerManager: WorkerManager;
+    dynamicBatchSize: number;
+    error_ih?: tf.Tensor2D;
+    error_ho?: tf.Tensor2D;
+    error_bh?: tf.Tensor2D;
+    error_bo?: tf.Tensor2D;
+    constructor(inputNodes?: number, hiddenNodes?: number, outputNodes?: number);
+    /**
+     * Connects to the central FedAvg Coordinator.
+     */
+    connect(websocketUrl: string): void;
+    /**
+     * Receives the latest global model from the server.
+     */
+    syncGlobalWeights(qWeightsIH: QuantizedPayload, qWeightsHO: QuantizedPayload, qBiasH: QuantizedPayload, qBiasO: QuantizedPayload): void;
+    /**
+     * Performs one local training epoch on a batch of data.
+     */
+    trainLocalBatch(inputs: number[][], targets: number[][]): void;
+    /**
+     * Cleans up background threads.
+     */
+    destroy(): void;
+    /**
+     * Helper function to map our payload into the protobuf format
+     */
+    private mapToProto;
+    /**
+     * Secures, compresses, and binary-serializes the newly trained weights.
+     */
+    exportSecureGradients(): Uint8Array;
+}