v0.9.6: InfoNet hashchain, Wormhole gate encryption, mesh reputation, 16 community contributors

Gate messages now propagate via the Infonet hashchain as encrypted blobs — every node syncs them
through normal chain sync while only Gate members with MLS keys can decrypt. Added mesh reputation
system, peer push workers, voluntary Wormhole opt-in for node participation, fork recovery,
killwormhole scripts, obfuscated terminology, and hardened the self-updater to protect encryption
keys and chain state during updates.

New features: Shodan search, train tracking, Sentinel Hub imagery, 8 new intelligence layers,
CCTV expansion to 11,000+ cameras across 6 countries, Mesh Terminal CLI, prediction markets,
desktop-shell scaffold, and comprehensive mesh test suite (215 frontend + backend tests passing).

Community contributors: @wa1id, @AlborzNazari, @adust09, @Xpirix, @imqdcr, @csysp, @suranyami,
@chr0n1x, @johan-martensson, @singularfailure, @smithbh, @OrfeoTerkuci, @deuza, @tm-const,
@Elhard1, @ttulttul

frontend/scripts/dev-all.cjs

@@ -0,0 +1,61 @@
+const { spawn } = require("child_process");
+const path = require("path");
+
+const frontendDir = path.resolve(__dirname, "..");
+const backendLauncher = path.resolve(frontendDir, "..", "start-backend.js");
+const nextBin = require.resolve("next/dist/bin/next");
+
+/** @type {import("child_process").ChildProcess[]} */
+const children = [];
+
+function start(label, file, args, cwd) {
+  const child = spawn(file, args, {
+    cwd,
+    env: process.env,
+    stdio: "inherit",
+    windowsHide: false,
+  });
+
+  child.on("error", (error) => {
+    console.error(`[${label}] failed to start:`, error);
+    shutdown(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal || (code ?? 0) !== 0) {
+      console.error(`[${label}] exited with ${signal ?? code}`);
+      shutdown(typeof code === "number" ? code : 1);
+      return;
+    }
+    shutdown(0);
+  });
+
+  children.push(child);
+  return child;
+}
+
+let shuttingDown = false;
+
+function shutdown(exitCode) {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  for (const child of children) {
+    if (!child.killed) {
+      child.kill();
+    }
+  }
+  process.exit(exitCode);
+}
+
+process.on("SIGINT", () => shutdown(0));
+process.on("SIGTERM", () => shutdown(0));
+
+start(
+  "frontend",
+  process.execPath,
+  [nextBin, "dev", "--hostname", "127.0.0.1", "--port", "3000"],
+  frontendDir,
+);
+start("backend", process.execPath, [backendLauncher], frontendDir);

frontend/scripts/report-bundle-size.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+const root = path.resolve(__dirname, '..');
+const nextDir = path.join(root, '.next');
+
+function dirSize(p) {
+  let total = 0;
+  if (!fs.existsSync(p)) return 0;
+  const stats = fs.statSync(p);
+  if (stats.isFile()) return stats.size;
+  for (const entry of fs.readdirSync(p)) {
+    total += dirSize(path.join(p, entry));
+  }
+  return total;
+}
+
+const total = dirSize(nextDir);
+const staticSize = dirSize(path.join(nextDir, 'static'));
+const serverSize = dirSize(path.join(nextDir, 'server'));
+
+const toKb = (b) => Math.round(b / 1024);
+
+console.log('Bundle size report');
+console.log(`.next total:  ${toKb(total)} KB`);
+console.log(`.next/static: ${toKb(staticSize)} KB`);
+console.log(`.next/server: ${toKb(serverSize)} KB`);
+
+const limitKb = process.env.BUNDLE_SIZE_LIMIT_KB ? Number(process.env.BUNDLE_SIZE_LIMIT_KB) : null;
+if (limitKb && toKb(total) > limitKb) {
+  console.error(`Bundle size exceeds limit: ${toKb(total)} KB > ${limitKb} KB`);
+  process.exit(1);
+}

frontend/scripts/vite-no-net-use.cjs

@@ -0,0 +1,21 @@
+const childProcess = require('child_process');
+
+const originalExec = childProcess.exec;
+
+childProcess.exec = function exec(command, options, callback) {
+  const cmd = typeof command === 'string' ? command.trim().toLowerCase() : '';
+  if (cmd === 'net use') {
+    const cb = typeof options === 'function' ? options : callback;
+    if (typeof cb === 'function') {
+      process.nextTick(() => cb(null, '', ''));
+    }
+    return {
+      pid: 0,
+      stdout: null,
+      stderr: null,
+      on() {},
+      kill() {},
+    };
+  }
+  return originalExec.apply(this, arguments);
+};