DaisyChain-Web demo: P2P browser training through verified INT8 units

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+*.log
+.DS_Store

Dockerfile

@@ -0,0 +1,8 @@
+FROM node:20-slim
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm install --omit=dev
+COPY . .
+ENV PORT=7860
+EXPOSE 7860
+CMD ["node", "server.js"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dean Byrne (Quazim0t0) / DaisyChainAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,10 +1,31 @@
 ---
-title: DaisyChain Web
-emoji: 💻
-colorFrom: blue
-colorTo: pink
+title: DaisyChain-Web
+emoji: 🌼
+colorFrom: green
+colorTo: yellow
 sdk: docker
+app_port: 7860
 pinned: false
+license: mit
+short_description: Train a shared model P2P by opening a browser tab
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌼 DaisyChain-Web — train by opening a page
+
+Open this Space on two or more devices and they train a shared model together —
+**peer-to-peer over WebRTC**, right in the browser, computing through verified
+INT8 neural units (WebGPU, or the same units on CPU for old machines).
+
+- Devices on the same network auto-group (Snapdrop-style).
+- Cross-network: everyone opens `?room=YOUR-CODE` — the room's creator approves
+  each device before it can join.
+- Gradients are averaged every step with a deterministic Adam optimizer, so all
+  devices end with bit-identical weights.
+- Download your trained model, or upload a checkpoint to restore the whole group.
+
+Part of **[DaisyChain-Train](https://huggingface.co/DaisyChainAI/DaisyChain-Train)** —
+a pipeline for reusing old/spare hardware to train neural networks.
+
+**Heads up:** peers connect directly (WebRTC), so devices in your group can see
+each other's IP address, and there is no gradient authentication — only train
+with devices/people you trust. Proof of concept.

package-lock.json

@@ -0,0 +1,37 @@
+{
+  "name": "daisychain-web",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "daisychain-web",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "ws": "^8.21.0"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    }
+  }
+}

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "daisychain-web",
+  "version": "0.1.0",
+  "description": "Train a shared model P2P in the browser — WebRTC mesh + WebGPU compute. Open a page, become a node.",
+  "license": "MIT",
+  "author": "Dean Byrne (Quazim0t0) / DaisyChainAI",
+  "scripts": {
+    "start": "node server.js",
+    "test": "node test_core.js"
+  },
+  "dependencies": {
+    "ws": "^8.21.0"
+  }
+}

public/app.js

@@ -0,0 +1,334 @@
+// DaisyChain-Web client: connect P2P (WebRTC), compute (WebGPU or CPU), and
+// train a shared model together — averaging gradients over the data channels.
+"use strict";
+
+const DIN = 16, H = 16, DOUT = 4, NPER = 128, LR = 0.03, DEFAULT_STEPS = 300;
+const D = { n: NPER, din: DIN, h: H, dout: DOUT };
+const STUN = [{ urls: "stun:stun.l.google.com:19302" }];
+
+const ui = {
+  status: document.getElementById("status"),
+  backend: document.getElementById("backend"),
+  me: document.getElementById("me"),
+  peers: document.getElementById("peers"),
+  loss: document.getElementById("loss"),
+  step: document.getElementById("step"),
+  bar: document.getElementById("bar"),
+  diff: document.getElementById("diff"),
+  log: document.getElementById("log"),
+  start: document.getElementById("start"),
+  save: document.getElementById("save"),
+  load: document.getElementById("load"),
+  loadBtn: document.getElementById("loadBtn"),
+  requests: document.getElementById("requests"),
+};
+function log(m) { ui.log.textContent = `${new Date().toLocaleTimeString()}  ${m}\n` + ui.log.textContent; }
+function setStatus(s) { ui.status.textContent = s; }
+
+// ---- deterministic RNG so every peer agrees on W_true and W0 (no broadcast) --
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+
+// ---- state -----------------------------------------------------------------
+// friendly device name (cottagecore, Snapdrop-style)
+const ADJ = ["Mossy", "Golden", "Amber", "Fern", "Hazel", "Cozy", "Wandering", "Little",
+             "Sunny", "Misty", "Wild", "Quiet", "Brave", "Dusty", "Merry"];
+const NOUN = ["Fox", "Hare", "Owl", "Badger", "Toad", "Sparrow", "Otter", "Deer",
+              "Hedgehog", "Mushroom", "Acorn", "Willow", "Robin", "Fawn", "Moth"];
+const deviceName = ADJ[Math.floor(Math.random() * ADJ.length)] + " " +
+                   NOUN[Math.floor(Math.random() * NOUN.length)];
+
+let myId = null, compute = null, ws = null, L = null, wasDenied = false;
+const pcs = new Map(), chans = new Map();      // peerId -> RTCPeerConnection / DataChannel
+const names = new Map();                       // peerId -> device name
+const incoming = new Map();                    // step -> Map(peerId -> Float32Array)
+let W1, W2, Xdata, Ydata, training = false;    // 2-layer verified model
+let trainedSteps = 0;                          // steps baked into the current weights
+function nmeOf(id) { return names.get(id) || id; }
+
+function room() { return new URLSearchParams(location.search).get("room"); }   // null -> group by network
+function updatePeers() { ui.peers.textContent = chans.size ? [...chans.keys()].map(nmeOf).join(", ") : "(none yet)"; }
+
+// ---- signaling + WebRTC ----------------------------------------------------
+function connectSignaling() {
+  const proto = location.protocol === "https:" ? "wss" : "ws";
+  const params = new URLSearchParams();
+  params.set("name", deviceName);
+  if (room()) params.set("room", room());                             // no code -> group by network
+  ws = new WebSocket(`${proto}://${location.host}/?${params}`);
+  ws.onopen = () => setStatus(room() ? `connected — private room "${room()}"` : "connected — grouping with devices on your network");
+  ws.onclose = () => { if (!wasDenied) setStatus("signaling disconnected"); };
+  ws.onmessage = async (ev) => {
+    const msg = JSON.parse(ev.data);
+    if (msg.type === "welcome") {
+      myId = msg.id;
+      if (msg.room) log(`group: ${msg.room.startsWith("net:") ? "your network" : "private room " + msg.room.replace("room:", "")}`);
+      if (msg.host) { log("you host this room — joiners wait for your approval"); setStatus(`hosting private room "${room()}"`); }
+      else if (room()) setStatus(`accepted into private room "${room()}"`);
+      // I'm newest: initiate to everyone already here
+      for (const p of msg.peers) { names.set(p.id, p.name); initiatePeer(p.id); }
+    } else if (msg.type === "waiting") {
+      setStatus("knocking — waiting for the room's host to let you in…");
+    } else if (msg.type === "denied") {
+      wasDenied = true;
+      setStatus("the host declined your request to join");
+      log("join request declined by the host");
+    } else if (msg.type === "host") {
+      log("the host left — you are now the host of this room");
+      setStatus(`hosting private room "${room()}"`);
+    } else if (msg.type === "join-request") {
+      addJoinRequest(msg.id, msg.name);
+    } else if (msg.type === "peer-joined") {
+      names.set(msg.id, msg.name);
+      log(`${msg.name} joined (they will connect to me)`);
+    } else if (msg.type === "peer-left") {
+      log(`${nmeOf(msg.id)} left`); cleanupPeer(msg.id); names.delete(msg.id); updatePeers();
+    } else if (msg.type === "signal") {
+      await onSignal(msg.from, msg.data);
+    }
+  };
+}
+function signal(to, data) { ws.send(JSON.stringify({ type: "signal", to, data })); }
+
+// host-side Accept/Deny row for a knocking device (textContent only — the name
+// comes off the wire and must never be parsed as HTML)
+function addJoinRequest(id, name) {
+  const row = document.createElement("div");
+  row.style.cssText = "display:flex;gap:8px;align-items:center;justify-content:space-between;margin-top:10px;flex-wrap:wrap";
+  const who = document.createElement("span");
+  who.textContent = `🚪 ${name} wants to join`;
+  const btn = (label, allow) => {
+    const b = document.createElement("button");
+    b.textContent = label;
+    b.style.cssText = "padding:6px 14px;font-size:.85rem" + (allow ? "" : ";background:#8b2e25");
+    b.onclick = () => {
+      ws.send(JSON.stringify({ type: "admit", id, allow }));
+      row.remove();
+      log(allow ? `you let ${name} in` : `you declined ${name}`);
+    };
+    return b;
+  };
+  row.append(who, btn("Accept", true), btn("Deny", false));
+  ui.requests.appendChild(row);
+}
+
+function newPC(peerId) {
+  const pc = new RTCPeerConnection({ iceServers: STUN });
+  pc.onicecandidate = (e) => { if (e.candidate) signal(peerId, { candidate: e.candidate }); };
+  pc.onconnectionstatechange = () => { if (pc.connectionState === "failed") cleanupPeer(peerId); };
+  pcs.set(peerId, pc);
+  return pc;
+}
+function initiatePeer(peerId) {
+  const pc = newPC(peerId);
+  const dc = pc.createDataChannel("daisy");
+  setupChannel(peerId, dc);
+  pc.createOffer().then(o => pc.setLocalDescription(o)).then(() => signal(peerId, { sdp: pc.localDescription }));
+}
+async function onSignal(from, data) {
+  let pc = pcs.get(from);
+  if (data.sdp) {
+    if (!pc) { pc = newPC(from); pc.ondatachannel = (e) => setupChannel(from, e.channel); }
+    await pc.setRemoteDescription(data.sdp);
+    if (data.sdp.type === "offer") {
+      const ans = await pc.createAnswer(); await pc.setLocalDescription(ans);
+      signal(from, { sdp: pc.localDescription });
+    }
+  } else if (data.candidate && pc) {
+    try { await pc.addIceCandidate(data.candidate); } catch (e) {}
+  }
+}
+function setupChannel(peerId, dc) {
+  dc.binaryType = "arraybuffer";
+  dc.onopen = () => { chans.set(peerId, dc); updatePeers(); log(`connected to ${nmeOf(peerId)}`); ui.start.disabled = false; };
+  dc.onclose = () => { chans.delete(peerId); updatePeers(); wake(); };
+  dc.onmessage = (e) => onGrad(peerId, e.data);
+}
+function cleanupPeer(id) { const pc = pcs.get(id); if (pc) pc.close(); pcs.delete(id); chans.delete(id); wake(); }
+
+// ---- checkpoints ------------------------------------------------------------
+// File layout (also the broadcast payload after the sentinel):
+//   8 bytes magic "DAISYPT1" | int32 din,h,dout,steps | f32 W1 | f32 W2
+// DaisyChain's own format (not torch-pickle) — .pt extension for familiarity.
+const CKPT_MAGIC = "DAISYPT1";
+const CKPT_SENTINEL = -2;                      // wire: [int32 -2][checkpoint bytes]
+
+function packCheckpoint() {
+  const buf = new ArrayBuffer(8 + 16 + (W1.length + W2.length) * 4);
+  new Uint8Array(buf, 0, 8).set([...CKPT_MAGIC].map(c => c.charCodeAt(0)));
+  new Int32Array(buf, 8, 4).set([DIN, H, DOUT, trainedSteps]);
+  new Float32Array(buf, 24, W1.length).set(W1);
+  new Float32Array(buf, 24 + W1.length * 4, W2.length).set(W2);
+  return buf;
+}
+function parseCheckpoint(buf) {
+  const magic = String.fromCharCode(...new Uint8Array(buf, 0, 8));
+  if (magic !== CKPT_MAGIC) throw new Error("not a DaisyChain checkpoint");
+  const [din, h, dout, steps] = new Int32Array(buf, 8, 4);
+  if (din !== DIN || h !== H || dout !== DOUT)
+    throw new Error(`shape mismatch: file is ${din}×${h}×${dout}, this build is ${DIN}×${H}×${DOUT}`);
+  if (buf.byteLength !== 24 + (din * h + h * dout) * 4) throw new Error("truncated checkpoint");
+  return { steps, w1: new Float32Array(buf.slice(24, 24 + din * h * 4)),
+           w2: new Float32Array(buf.slice(24 + din * h * 4)) };
+}
+function applyCheckpoint(ck, from) {
+  W1.set(ck.w1); W2.set(ck.w2); trainedSteps = ck.steps;
+  ui.save.disabled = false;
+  ui.step.textContent = `${ck.steps} baked in`;
+  log(`checkpoint loaded (${ck.steps} steps) ${from ? "from " + from : "from file"} — all set to resume`);
+}
+function broadcastCheckpoint() {
+  const ck = packCheckpoint();
+  const msg = new ArrayBuffer(4 + ck.byteLength);
+  new Int32Array(msg, 0, 1)[0] = CKPT_SENTINEL;
+  new Uint8Array(msg, 4).set(new Uint8Array(ck));
+  let n = 0;
+  for (const dc of chans.values()) if (dc.readyState === "open") { dc.send(msg); n++; }
+  log(`checkpoint pushed to ${n} device(s)`);
+}
+function saveCheckpoint() {
+  const blob = new Blob([packCheckpoint()], { type: "application/octet-stream" });
+  const a = document.createElement("a");
+  a.href = URL.createObjectURL(blob);
+  a.download = `daisychain-${DIN}x${H}x${DOUT}-step${trainedSteps}.pt`;
+  a.click();
+  URL.revokeObjectURL(a.href);
+}
+
+// ---- gradient wire format:  [int32 step][float32 grad...] -----------------
+function packGrad(step, grad) {
+  const buf = new ArrayBuffer(4 + grad.byteLength);
+  new Int32Array(buf, 0, 1)[0] = step;
+  new Float32Array(buf, 4).set(grad);
+  return buf;
+}
+const waiters = new Set();                       // pending waitForGrads checkers
+function wake() { for (const w of waiters) w(); }
+function onGrad(peerId, buf) {
+  const step = new Int32Array(buf, 0, 1)[0];
+  if (step === CKPT_SENTINEL) {                  // a peer pushed a checkpoint
+    if (training) { log(`ignored checkpoint from ${nmeOf(peerId)} (training in progress)`); return; }
+    try { applyCheckpoint(parseCheckpoint(buf.slice(4)), nmeOf(peerId)); }
+    catch (e) { log(`bad checkpoint from ${nmeOf(peerId)}: ${e.message}`); }
+    return;
+  }
+  const grad = new Float32Array(buf.slice(4));
+  if (!incoming.has(step)) incoming.set(step, new Map());
+  incoming.get(step).set(peerId, grad);
+  wake();                                        // resolve waits immediately (no polling)
+}
+function broadcastGrad(step, grad) { const b = packGrad(step, grad); for (const dc of chans.values()) if (dc.readyState === "open") dc.send(b); }
+// Event-driven: re-checked on every gradient arrival and peer departure, plus a
+// coarse fallback timer (background tabs throttle timers to ~1s, so the old
+// 15ms poll was the bottleneck there). Peers that left are dropped from the
+// wait — a device dying no longer costs the full timeout every step.
+function waitForGrads(step, cohort, timeoutMs = 8000) {
+  return new Promise((resolve) => {
+    const t0 = Date.now();
+    let timer = null;
+    const check = () => {
+      const live = cohort.filter(id => chans.has(id));   // prune departed peers
+      const got = incoming.get(step) || new Map();
+      const have = live.filter(id => got.has(id));
+      if (have.length === live.length || Date.now() - t0 > timeoutMs) {
+        waiters.delete(check); clearInterval(timer);
+        resolve(have.map(id => got.get(id)));
+      }
+    };
+    waiters.add(check);
+    timer = setInterval(check, 500);                     // safety net only
+    check();
+  });
+}
+
+// ---- compute: one async training step THROUGH the verified units -----------
+async function localStep() {
+  // forward runs through the verified INT8 multiply (WebGPU or CPU); STE backward
+  const fwd = await Verified.forward(Xdata, Ydata, W1, W2, D, L, compute.matmulInt8);
+  const grad = Verified.backward(Xdata, W1, W2, fwd, D);          // flat [gW1, gW2]
+  return { loss: fwd.loss, grad };
+}
+
+// ---- the training loop -----------------------------------------------------
+async function train() {
+  if (training) return; training = true; ui.start.disabled = true;
+  const cohort = [...chans.keys()];                    // lock the cohort (departed peers are pruned per-step)
+  const steps = DEFAULT_STEPS;
+  const opt = TrainCore.makeAdam(W1.length + W2.length, { lr: 0.2 });   // swept: best on the verified-unit STE grads
+  log(`training started — cohort ${cohort.length} peer(s), world ${cohort.length + 1}, optimizer ${opt.name}`);
+  for (let s = 0; s < steps; s++) {
+    const { loss, grad } = await localStep();
+    broadcastGrad(s, grad);
+    const remote = cohort.length ? await waitForGrads(s, cohort) : [];
+    const all = [grad, ...remote];
+    const avg = TrainCore.averageGrads(all);
+    const upd = opt.step(avg);                      // DaisyAdam on the cluster-avg grad
+    Verified.splitApply(W1, W2, upd, 1);            // W -= 1 * upd (lr folded into upd)
+    incoming.delete(s);
+    trainedSteps++;
+    if (s % 10 === 0 || s === steps - 1) {
+      ui.loss.textContent = loss.toFixed(5);
+      ui.step.textContent = `${s + 1} / ${steps}`;
+      ui.bar.style.width = `${Math.round(100 * (s + 1) / steps)}%`;
+      await new Promise(r => setTimeout(r, 0));         // yield to UI
+    }
+  }
+  ui.diff.textContent = `done — trained through the verified units; all peers share one model.`;
+  log(`training done — final loss ${ui.loss.textContent}`);
+  training = false;
+  ui.save.disabled = false;
+  ui.start.disabled = false;
+}
+
+// 2-layer float target (matches the model shape) for a learnable task
+function target(X) {
+  const Wt1 = randn(DIN * H, mulberry32(42)), Wt2 = randn(H * DOUT, mulberry32(43));
+  const hpre = TrainCore.matmul(X, Wt1, NPER, DIN, H);
+  for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]);
+  return TrainCore.matmul(hpre, Wt2, NPER, H, DOUT);
+}
+
+// ---- boot ------------------------------------------------------------------
+(async function () {
+  // Neural Units are mandatory: no LUTs -> no training, period. There is no
+  // float fallback path anywhere in this app; both backends (WebGPU shader and
+  // CPU JS) compute every product through the verified mul8 LUT.
+  try {
+    L = await Compute.loadLUTs();                        // the verified units, as tables
+    if (!(L.mul instanceof Int16Array) || L.mul.length !== 65536)
+      throw new Error("mul8 LUT malformed");
+    // self-test: the unit must reproduce a known product before we trust it
+    if (L.mul[((7 & 0xFF) * 256) + (-3 & 0xFF)] !== -21)
+      throw new Error("mul8 LUT self-test failed (7 × -3 ≠ -21)");
+    compute = await Compute.initCompute(L);
+  } catch (e) {
+    setStatus("NEURAL UNITS UNAVAILABLE — training disabled");
+    ui.backend.textContent = "unavailable";
+    log(`FATAL: verified neural units failed to load (${e.message}). ` +
+        `This build only trains through the units — there is no fallback.`);
+    ui.start.disabled = true;
+    return;                                              // no signaling, no training
+  }
+  ui.backend.textContent = `${compute.backend.toUpperCase()} — ${compute.label} · through verified INT8 units`;
+  // deterministic shared init (no weight broadcast); per-peer random data shard
+  W1 = randn(DIN * H, mulberry32(7));
+  W2 = randn(H * DOUT, mulberry32(8));
+  Xdata = randn(NPER * DIN);
+  Ydata = target(Xdata);
+  ui.me.textContent = deviceName;
+  updatePeers();
+  connectSignaling();
+  ui.start.onclick = train;
+  ui.save.onclick = saveCheckpoint;
+  ui.loadBtn.onclick = () => { if (training) { log("can't load a checkpoint mid-training"); return; } ui.load.click(); };
+  ui.load.onchange = async () => {
+    const f = ui.load.files[0]; ui.load.value = "";
+    if (!f) return;
+    try {
+      const ck = parseCheckpoint(await f.arrayBuffer());
+      applyCheckpoint(ck, null);
+      broadcastCheckpoint();                             // every device resumes from this
+    } catch (e) { log(`checkpoint rejected: ${e.message}`); }
+  };
+  log(`ready — this device is "${deviceName}", computing through verified units on ${compute.backend.toUpperCase()}`);
+})();

public/index.html

@@ -0,0 +1,123 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DaisyChain-Web — train by opening a page</title>
+<style>
+  :root {
+    --page-bg: #efe4c9;
+    --card-bg: #fbf6e8;
+    --card-border: rgba(139, 111, 71, 0.30);
+    --text: #2a1d0a;
+    --text-soft: #6b4423;
+    --accent: #4a7c2e;
+    --accent-deep: #2d5016;
+    --counter-bg: linear-gradient(135deg, #2d5016 0%, #1f3a0f 100%);
+    --counter-num: #f5ecd9;
+    --counter-label: #c9b072;
+    --btn: linear-gradient(135deg, #4a7c2e 0%, #2d5016 100%);
+    --btn-hover: linear-gradient(135deg, #5a8c3e 0%, #3d6020 100%);
+    --warn: #8b2e25;
+    --link: #4a7c2e;
+    --track: rgba(139, 111, 71, 0.22);
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --page-bg: #14100a; --card-bg: #1f1a12; --card-border: rgba(201, 176, 114, 0.35);
+      --text: #ede1c3; --text-soft: #c9b072; --accent: #9bc466; --accent-deep: #6b9039;
+      --counter-bg: linear-gradient(135deg, #1a2e0d 0%, #0c1606 100%);
+      --counter-label: #c9b072; --warn: #ff9b8e; --link: #9bc466; --track: rgba(201,176,114,0.20);
+    }
+  }
+  * { box-sizing: border-box; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+         max-width: 720px; margin: 0 auto; padding: 24px 18px 40px; line-height: 1.5;
+         background: var(--page-bg); color: var(--text); }
+  h1 { margin: 0 0 2px; font-size: 1.7rem; letter-spacing: .3px; }
+  .sub { color: var(--text-soft); margin: 0 0 18px; font-size: .92rem; }
+  .sub code { background: rgba(74,124,46,.12); padding: 1px 5px; border-radius: 4px; }
+  .card { background: var(--card-bg); border: 1px solid var(--card-border);
+          border-radius: 10px; padding: 14px 16px; margin: 12px 0;
+          box-shadow: 0 2px 10px rgba(0,0,0,0.06); }
+  .lbl { color: var(--text-soft); font-size: 11px; font-weight: 800; letter-spacing: 1.5px;
+         text-transform: uppercase; margin-bottom: 8px; }
+  .row { display: flex; justify-content: space-between; gap: 12px; padding: 3px 0; font-size: .95rem; }
+  .k { color: var(--text-soft); } .v { font-weight: 700; text-align: right; }
+  .device { font-family: 'Courier New', monospace; font-size: 1.5rem; font-weight: 700;
+            color: var(--accent-deep); }
+  @media (prefers-color-scheme: dark) { .device { color: var(--accent); } }
+  .counter { background: var(--counter-bg); border-radius: 10px; padding: 14px 16px; text-align: center; }
+  .counter .num { font-family: 'Courier New', monospace; font-size: 2.2rem; font-weight: 700; color: var(--counter-num); }
+  .counter .cl { color: var(--counter-label); font-size: 11px; text-transform: uppercase; letter-spacing: 1.5px; }
+  .track { width: 100%; height: 10px; border-radius: 6px; background: var(--track); overflow: hidden; margin-top: 12px; }
+  #bar { height: 10px; width: 0; background: linear-gradient(90deg, #6b9039, #9bc466); transition: width .25s; }
+  button { background: var(--btn); color: #f5ecd9; border: 0; border-radius: 8px;
+           padding: 12px 26px; font-weight: 800; font-size: 1rem; letter-spacing: .5px; cursor: pointer;
+           box-shadow: 0 3px 10px rgba(74,49,16,0.18); transition: .15s; }
+  button:hover:not(:disabled) { background: var(--btn-hover); box-shadow: 0 5px 14px rgba(74,49,16,0.28); }
+  button:disabled { background: #8b7d5e; opacity: .55; cursor: not-allowed; box-shadow: none; }
+  pre { background: rgba(0,0,0,0.05); border-radius: 8px; padding: 10px; max-height: 150px;
+        overflow: auto; font-size: .78rem; color: var(--text-soft); white-space: pre-wrap; margin: 0;
+        font-family: 'Courier New', monospace; }
+  @media (prefers-color-scheme: dark) { pre { background: rgba(0,0,0,0.25); } }
+  .note { color: var(--text-soft); font-size: .82rem; }
+  .note b { color: var(--warn); }
+  .diff { color: var(--accent-deep); font-weight: 600; font-size: .88rem; }
+  @media (prefers-color-scheme: dark) { .diff { color: var(--accent); } }
+</style>
+</head>
+<body>
+  <h1>🌼 DaisyChain-Web</h1>
+  <p class="sub">Open this on your other devices <b>on the same network</b> and they train a shared model together — peer-to-peer, right in the browser, through the emulated GPU logic. Only devices on your network are grouped (like Snapdrop). To invite people across networks, everyone opens <code>?room=YOUR-CODE</code> — the person who created the room approves each device before it can join.</p>
+
+  <div class="card">
+    <div class="lbl">🌲 This device</div>
+    <div class="device" id="me">—</div>
+    <div class="row" style="margin-top:8px"><span class="k">Status</span><span class="v" id="status">starting…</span></div>
+    <div class="row"><span class="k">Compute</span><span class="v" id="backend">detecting…</span></div>
+  </div>
+
+  <div class="card">
+    <div class="lbl">🍄 Devices in your group</div>
+    <div class="row"><span class="v" id="peers" style="text-align:left">(none yet)</span></div>
+    <div id="requests"></div>
+  </div>
+
+  <div class="card" style="text-align:center">
+    <button id="start" disabled>Start training</button>
+    <p class="note" style="margin:.6rem 0 0">Enabled once another device joins. (Or open a second tab to try it.)</p>
+  </div>
+
+  <div class="card">
+    <div class="lbl">✦ Training</div>
+    <div class="row"><span class="k">Step</span><span class="v" id="step">— / —</span></div>
+    <div class="counter" style="margin:10px 0"><div class="num" id="loss">—</div><div class="cl">cluster-avg loss · lower is better</div></div>
+    <div class="track"><div id="bar"></div></div>
+    <div class="row" style="margin-top:10px"><span class="diff" id="diff"></span></div>
+  </div>
+
+  <div class="card">
+    <div class="lbl">💾 Model checkpoint</div>
+    <div style="display:flex;gap:10px;flex-wrap:wrap;justify-content:center">
+      <button id="save" disabled>Download model (.pt)</button>
+      <button id="loadBtn">Load checkpoint…</button>
+      <input type="file" id="load" accept=".pt" style="display:none">
+    </div>
+    <p class="note" style="margin:.6rem 0 0;text-align:center">Loading a checkpoint applies it here <b>and</b> pushes it to every connected device — use it to recover the group after a failure.</p>
+  </div>
+
+  <div class="card">
+    <div class="lbl">❋ Log</div>
+    <pre id="log"></pre>
+  </div>
+
+  <p class="note">Needs a secure context (localhost or HTTPS) for WebGPU + cross-device WebRTC. No WebGPU? The same verified INT8 units run on CPU — old machines (e.g. via Supermium) still join, just slower. Every training step goes through the Neural Units; there is no plain-float path, and if the units fail to load, training is disabled.</p>
+  <p class="note"><b>Heads up:</b> peers connect directly (WebRTC), so devices in your group can see each other's IP address, and there's no gradient authentication — only train with devices/people you trust. Proof of concept.</p>
+
+  <script src="traincore.js"></script>
+  <script src="verified_core.js"></script>
+  <script src="webgpu.js"></script>
+  <script src="app.js"></script>
+</body>
+</html>

public/luts_meta.json

@@ -0,0 +1 @@
+{"mul": [256, 256], "requant": 65536, "relu": 256, "shift": 8}

public/mul_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5cecff7e22049d0083ad9ee36dcf0695222c61621bacfd5a401c7b133abe892d
+size 131072

public/relu_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2acb03ba7520467636273208563f8e733494748f4aa5ac2dba89d9560050da79
+size 256

public/requant_lut.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:173444ecfa293433329a333289983a665c481d913e9fd1c2778b55380ca4dd31
+size 65536

public/traincore.js

@@ -0,0 +1,91 @@
+// Shared training math — pure JS. Used as the WebGPU fallback in the browser,
+// and unit-tested directly in Node. Model: linear regression Y = X @ W (MSE).
+// The GEMMs here are exactly what the WebGPU compute shader replaces.
+(function (root) {
+  "use strict";
+
+  // C(m×n) = A(m×k) @ B(k×n), all Float32Array row-major
+  function matmul(A, B, m, k, n) {
+    const C = new Float32Array(m * n);
+    for (let i = 0; i < m; i++) {
+      for (let p = 0; p < k; p++) {
+        const a = A[i * k + p];
+        if (a === 0) continue;
+        const bo = p * n, co = i * n;
+        for (let j = 0; j < n; j++) C[co + j] += a * B[bo + j];
+      }
+    }
+    return C;
+  }
+
+  function transpose(A, rows, cols) {
+    const T = new Float32Array(rows * cols);
+    for (let i = 0; i < rows; i++)
+      for (let j = 0; j < cols; j++) T[j * rows + i] = A[i * cols + j];
+    return T;
+  }
+
+  // Forward + loss + gradient for one shard.
+  //   X: n×din,  W: din×dout,  y: n×dout
+  //   gradW = (2/n) * Xᵀ @ (X@W - y)   (din×dout)
+  // matmulFn lets the browser swap in the WebGPU GEMM (same signature as matmul).
+  function forwardLossGrad(X, y, W, n, din, dout, matmulFn) {
+    const mm = matmulFn || matmul;
+    const pred = mm(X, W, n, din, dout);          // n×dout   (GEMM)
+    const resid = new Float32Array(n * dout);
+    let loss = 0;
+    for (let i = 0; i < n * dout; i++) {
+      const r = pred[i] - y[i];
+      resid[i] = r; loss += r * r;
+    }
+    loss /= (n * dout);
+    const Xt = transpose(X, n, din);              // din×n
+    const g = mm(Xt, resid, din, n, dout);        // din×dout (GEMM)
+    const scale = 2 / n;
+    for (let i = 0; i < g.length; i++) g[i] *= scale;
+    return { pred, loss, gradW: g };
+  }
+
+  function applyGrad(W, gradAvg, lr) {
+    for (let i = 0; i < W.length; i++) W[i] -= lr * gradAvg[i];
+  }
+
+  // average a list of gradient Float32Arrays (equal weight)
+  function averageGrads(grads) {
+    const out = new Float32Array(grads[0].length);
+    for (const g of grads) for (let i = 0; i < g.length; i++) out[i] += g[i];
+    for (let i = 0; i < out.length; i++) out[i] /= grads.length;
+    return out;
+  }
+
+  // DaisyAdam — Adam with bias correction, applied to the cluster-averaged
+  // gradient. State is a pure function of the gradient sequence, so every peer
+  // that averages the same gradients keeps bit-identical moments: no optimizer
+  // state ever crosses the wire. Momentum also smooths the noisy STE gradients
+  // coming out of the verified INT8 units.
+  function makeAdam(dim, opts) {
+    const o = opts || {};
+    const lr = o.lr ?? 0.02, b1 = o.beta1 ?? 0.9, b2 = o.beta2 ?? 0.999, eps = o.eps ?? 1e-8;
+    const m = new Float32Array(dim), v = new Float32Array(dim);
+    let t = 0;
+    return {
+      name: `adam(lr=${lr})`,
+      // returns the update u; caller does W[i] -= u[i]
+      step(g) {
+        t++;
+        const c1 = 1 - Math.pow(b1, t), c2 = 1 - Math.pow(b2, t);
+        const u = new Float32Array(dim);
+        for (let i = 0; i < dim; i++) {
+          m[i] = b1 * m[i] + (1 - b1) * g[i];
+          v[i] = b2 * v[i] + (1 - b2) * g[i] * g[i];
+          u[i] = lr * (m[i] / c1) / (Math.sqrt(v[i] / c2) + eps);
+        }
+        return u;
+      },
+    };
+  }
+
+  const api = { matmul, transpose, forwardLossGrad, applyGrad, averageGrads, makeAdam };
+  if (typeof module !== "undefined" && module.exports) module.exports = api;
+  else root.TrainCore = api;
+})(typeof self !== "undefined" ? self : this);

public/verified_core.js

@@ -0,0 +1,84 @@
+// Verified INT8 compute — the emulated GPU logic, in the browser.
+// A layer's forward runs THROUGH the units: quantize -> LUT multiply -> requant
+// -> optional ReLU -> dequant. Backward is a straight-through estimator (the
+// integer path has no gradient), so ordinary float weights still learn.
+// Same units as the Python/Docker DaisyChain; here they're lookup tables.
+(function (root) {
+  "use strict";
+
+  let TC;   // TrainCore (matmul/transpose) — resolved per environment at the end
+
+  function quantize(X) {
+    let mx = 0; for (let i = 0; i < X.length; i++) { const a = Math.abs(X[i]); if (a > mx) mx = a; }
+    const scale = Math.max(mx / 127, 1e-8);
+    const q = new Int8Array(X.length);
+    for (let i = 0; i < X.length; i++) { let v = Math.round(X[i] / scale); q[i] = v < -128 ? -128 : v > 127 ? 127 : v; }
+    return { q, scale };
+  }
+
+  // int8 matmul via the verified multiply LUT: acc(m×n) = sum_k mulLUT[Xq,Wq]
+  function lutMatmulJS(Xq, Wq, m, k, n, L) {
+    const C = new Int32Array(m * n), mul = L.mul;
+    for (let i = 0; i < m; i++) {
+      for (let p = 0; p < k; p++) {
+        const au = (Xq[i * k + p] & 0xFF) * 256, wo = p * n, co = i * n;
+        for (let j = 0; j < n; j++) C[co + j] += mul[au + (Wq[wo + j] & 0xFF)];
+      }
+    }
+    return C;
+  }
+
+  // one verified layer forward; returns float out (+ cache for STE backward).
+  // Every product goes through the verified INT8 multiply (mul8 LUT) with exact
+  // int32 accumulation — i.e. an emulated INT8 tensor-core GEMM — then dequant.
+  async function linearFwd(X, W, m, k, n, L, useRelu, matmulInt8) {
+    const xq = quantize(X), wq = quantize(W);
+    const acc = await (matmulInt8 || lutMatmulJS)(xq.q, wq.q, m, k, n, L);  // verified multiply
+    const dq = xq.scale * wq.scale;
+    const out = new Float32Array(m * n);
+    const mask = useRelu ? new Uint8Array(m * n) : null;
+    for (let i = 0; i < m * n; i++) {
+      let v = acc[i] * dq;
+      if (useRelu) { if (v > 0) mask[i] = 1; else v = 0; }
+      out[i] = v;
+    }
+    return { out, mask };
+  }
+
+  // 2-layer MLP: X→H (relu) →dout. Forward through verified units, MSE loss.
+  async function forward(X, y, W1, W2, D, L, matmulInt8) {
+    const { n, din, h, dout } = D;
+    const l1 = await linearFwd(X, W1, n, din, h, L, true, matmulInt8);
+    const l2 = await linearFwd(l1.out, W2, n, h, dout, L, false, matmulInt8);
+    const resid = new Float32Array(n * dout); let loss = 0;
+    for (let i = 0; i < resid.length; i++) { const r = l2.out[i] - y[i]; resid[i] = r; loss += r * r; }
+    loss /= resid.length;
+    return { loss, resid, z1: l1.out, mask1: l1.mask };
+  }
+
+  // STE backward (verified matmul treated as float X@W). Returns flat [gW1, gW2].
+  function backward(X, W1, W2, fwd, D) {
+    const { n, din, h, dout } = D;
+    const { resid, z1, mask1 } = fwd;
+    const s = 2 / n;
+    const dout_ = new Float32Array(resid.length);
+    for (let i = 0; i < resid.length; i++) dout_[i] = resid[i] * s;
+    const mm = TC.matmul, tr = TC.transpose;
+    const gW2 = mm(tr(z1, n, h), dout_, h, n, dout);          // z1ᵀ @ dout
+    const dz1 = mm(dout_, tr(W2, h, dout), n, dout, h);        // dout @ W2ᵀ
+    for (let i = 0; i < dz1.length; i++) if (!mask1[i]) dz1[i] = 0;  // relu grad
+    const gW1 = mm(tr(X, n, din), dz1, din, n, h);            // Xᵀ @ dz1
+    const g = new Float32Array(gW1.length + gW2.length);
+    g.set(gW1, 0); g.set(gW2, gW1.length);
+    return g;
+  }
+
+  function splitApply(W1, W2, gAvg, lr) {
+    for (let i = 0; i < W1.length; i++) W1[i] -= lr * gAvg[i];
+    for (let j = 0; j < W2.length; j++) W2[j] -= lr * gAvg[W1.length + j];
+  }
+
+  const api = { quantize, lutMatmulJS, linearFwd, forward, backward, splitApply };
+  if (typeof module !== "undefined" && module.exports) { TC = require("./traincore.js"); module.exports = api; }
+  else { TC = root.TrainCore; root.Verified = api; }
+})(typeof self !== "undefined" ? self : this);

public/webgpu.js

@@ -0,0 +1,91 @@
+// WebGPU INT8 matmul via the verified multiply LUT — the emulated GPU logic
+// running on the browser's GPU. Automatic CPU fallback (same LUT) for machines
+// without WebGPU (e.g. old PCs via Supermium). initCompute() returns
+//   { backend, label, matmulInt8(Xq, Wq, m, k, n, L) -> Int32Array }
+// matching Verified.lutMatmulJS, so the trainer is device-blind.
+(function (root) {
+  "use strict";
+
+  const WGSL = `
+    @group(0) @binding(0) var<storage, read> Xq  : array<i32>;   // int8 byte per elem
+    @group(0) @binding(1) var<storage, read> Wq  : array<i32>;
+    @group(0) @binding(2) var<storage, read> lut : array<i32>;   // 65536 signed products
+    @group(0) @binding(3) var<storage, read_write> C : array<i32>;
+    @group(0) @binding(4) var<uniform> dims : vec3<u32>;         // m, k, n
+    @compute @workgroup_size(8, 8)
+    fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+      let m = dims.x; let k = dims.y; let n = dims.z;
+      let row = gid.x; let col = gid.y;
+      if (row >= m || col >= n) { return; }
+      var s : i32 = 0;
+      for (var p = 0u; p < k; p = p + 1u) {
+        let au = u32(Xq[row * k + p] & 255);
+        let bu = u32(Wq[p * n + col] & 255);
+        s = s + lut[au * 256u + bu];
+      }
+      C[row * n + col] = s;
+    }`;
+
+  async function loadLUTs(base) {
+    base = base || "";
+    const [mulB, reqB, reluB, meta] = await Promise.all([
+      fetch(base + "mul_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "requant_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "relu_lut.bin").then(r => r.arrayBuffer()),
+      fetch(base + "luts_meta.json").then(r => r.json()),
+    ]);
+    return { mul: new Int16Array(mulB), requant: new Int8Array(reqB),
+             relu: new Int8Array(reluB), shift: meta.shift };
+  }
+
+  async function initCompute(L) {
+    const cpu = { backend: "cpu", label: "CPU (JS)",
+                  matmulInt8: (Xq, Wq, m, k, n, LL) => root.Verified.lutMatmulJS(Xq, Wq, m, k, n, LL) };
+    if (!(root.navigator && navigator.gpu)) return cpu;
+    try {
+      const adapter = await navigator.gpu.requestAdapter();
+      if (!adapter) return cpu;
+      const device = await adapter.requestDevice();
+      const module = device.createShaderModule({ code: WGSL });
+      const pipeline = device.createComputePipeline({ layout: "auto", compute: { module, entryPoint: "main" } });
+      // upload the multiply LUT once (as i32)
+      const lut32 = new Int32Array(L.mul);   // widen int16 -> int32
+      const lutBuf = device.createBuffer({ size: lut32.byteLength, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST });
+      device.queue.writeBuffer(lutBuf, 0, lut32);
+      const info = adapter.info || {};
+      return { backend: "webgpu", label: info.description || info.vendor || "WebGPU",
+               matmulInt8: (Xq, Wq, m, k, n) => gpuMatmul(device, pipeline, lutBuf, Xq, Wq, m, k, n) };
+    } catch (e) { console.warn("WebGPU init failed, CPU fallback:", e); return cpu; }
+  }
+
+  async function gpuMatmul(device, pipeline, lutBuf, Xq, Wq, m, k, n) {
+    const X32 = Int32Array.from(Xq), W32 = Int32Array.from(Wq);   // byte -> i32
+    const bufX = mk(device, X32.byteLength, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const bufW = mk(device, W32.byteLength, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST);
+    const bytesC = m * n * 4;
+    const bufC = mk(device, bytesC, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC);
+    const bufD = mk(device, 16, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+    device.queue.writeBuffer(bufX, 0, X32);
+    device.queue.writeBuffer(bufW, 0, W32);
+    device.queue.writeBuffer(bufD, 0, new Uint32Array([m, k, n]));
+    const bind = device.createBindGroup({ layout: pipeline.getBindGroupLayout(0), entries: [
+      { binding: 0, resource: { buffer: bufX } }, { binding: 1, resource: { buffer: bufW } },
+      { binding: 2, resource: { buffer: lutBuf } }, { binding: 3, resource: { buffer: bufC } },
+      { binding: 4, resource: { buffer: bufD } } ] });
+    const enc = device.createCommandEncoder();
+    const pass = enc.beginComputePass();
+    pass.setPipeline(pipeline); pass.setBindGroup(0, bind);
+    pass.dispatchWorkgroups(Math.ceil(m / 8), Math.ceil(n / 8)); pass.end();
+    const read = mk(device, bytesC, GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ);
+    enc.copyBufferToBuffer(bufC, 0, read, 0, bytesC);
+    device.queue.submit([enc.finish()]);
+    await read.mapAsync(GPUMapMode.READ);
+    const out = new Int32Array(read.getMappedRange().slice(0));
+    read.unmap();
+    [bufX, bufW, bufC, bufD, read].forEach(b => b.destroy());
+    return out;
+  }
+  function mk(device, size, usage) { return device.createBuffer({ size, usage }); }
+
+  root.Compute = { initCompute, loadLUTs };
+})(self);

server.js

@@ -0,0 +1,111 @@
+// DaisyChain-Web signaling + static host.
+// - Serves public/ (the page users open).
+// - WebSocket signaling: introduces peers in a room and relays WebRTC
+//   offers/answers/ICE. It never sees the compute — that's P2P over WebRTC.
+// Only dependency: `ws`.  Run:  npm install && node server.js
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { WebSocketServer } = require("ws");
+
+// Snapdrop-style: peers are grouped by their PUBLIC IP, so only devices on the
+// same network auto-discover each other. An explicit ?room=CODE overrides this
+// to connect across networks (share the code with people you invite).
+function clientIP(req) {
+  const xff = req.headers["x-forwarded-for"];
+  if (xff) return xff.split(",")[0].trim();
+  return (req.socket.remoteAddress || "unknown").replace(/^::ffff:/, "");
+}
+function roomFor(req) {
+  const u = new URL(req.url, "http://x");
+  const code = u.searchParams.get("room");
+  if (code) return "room:" + code;
+  const h = crypto.createHash("sha256").update(clientIP(req)).digest("hex").slice(0, 10);
+  return "net:" + h;               // same network -> same room (IP not exposed in the id)
+}
+
+const PORT = process.env.PORT || 8787;
+const PUB = path.join(__dirname, "public");
+const TYPES = { ".html": "text/html", ".js": "text/javascript",
+                ".css": "text/css", ".json": "application/json" };
+
+const server = http.createServer((req, res) => {
+  let p = decodeURIComponent(req.url.split("?")[0]);
+  if (p === "/") p = "/index.html";
+  const file = path.join(PUB, path.normalize(p));
+  if (!file.startsWith(PUB)) { res.writeHead(403); return res.end(); }
+  fs.readFile(file, (err, data) => {
+    if (err) { res.writeHead(404); return res.end("not found"); }
+    res.writeHead(200, { "Content-Type": TYPES[path.extname(file)] || "application/octet-stream" });
+    res.end(data);
+  });
+});
+
+const wss = new WebSocketServer({ server });
+// roomId -> { peers: Map(id -> {ws,name}), host: id|null, pending: Map(id -> {ws,name}) }
+// Private rooms (room:CODE) are gated: the creator is the host, and everyone
+// arriving later waits until the host accepts them — knowing the code is not
+// enough. Network rooms (net:) keep auto-join (same LAN, Snapdrop-style).
+const rooms = new Map();
+let nextId = 1;
+
+function send(ws, obj) { if (ws.readyState === 1) ws.send(JSON.stringify(obj)); }
+
+wss.on("connection", (ws, req) => {
+  const roomId = roomFor(req);
+  const name = (new URL(req.url, "http://x").searchParams.get("name") || "").slice(0, 40) || ("p" + nextId);
+  const id = "p" + (nextId++);
+  ws.peerId = id; ws.roomId = roomId;
+  if (!rooms.has(roomId)) rooms.set(roomId, { peers: new Map(), host: null, pending: new Map() });
+  const room = rooms.get(roomId);
+  const isPrivate = roomId.startsWith("room:");
+
+  function admit(pid, peer) {
+    const roster = [...room.peers.entries()].map(([qid, v]) => ({ id: qid, name: v.name }));
+    send(peer.ws, { type: "welcome", id: pid, room: roomId, peers: roster, host: room.host === pid });
+    for (const [, v] of room.peers) send(v.ws, { type: "peer-joined", id: pid, name: peer.name });
+    room.peers.set(pid, peer);
+  }
+
+  if (isPrivate && room.peers.size === 0) room.host = id;   // creator hosts
+  if (isPrivate && room.host !== id) {
+    room.pending.set(id, { ws, name });
+    send(ws, { type: "waiting" });
+    const h = room.peers.get(room.host);
+    if (h) send(h.ws, { type: "join-request", id, name });
+  } else {
+    admit(id, { ws, name });
+  }
+
+  ws.on("message", (buf) => {
+    let msg; try { msg = JSON.parse(buf); } catch { return; }
+    if (msg.type === "signal" && msg.to && room.peers.has(id)) {   // relay WebRTC signaling
+      const target = room.peers.get(msg.to);
+      if (target) send(target.ws, { type: "signal", from: id, data: msg.data });
+    } else if (msg.type === "admit" && id === room.host) {         // host verdict on a joiner
+      const p = room.pending.get(msg.id);
+      if (!p) return;
+      room.pending.delete(msg.id);
+      if (msg.allow) admit(msg.id, p);
+      else { send(p.ws, { type: "denied" }); p.ws.close(); }
+    }
+  });
+
+  ws.on("close", () => {
+    room.pending.delete(id);
+    if (room.peers.delete(id))
+      for (const [, v] of room.peers) send(v.ws, { type: "peer-left", id });
+    if (room.host === id) {                                        // host left: promote oldest
+      room.host = room.peers.keys().next().value ?? null;
+      const h = room.peers.get(room.host);
+      if (h) {
+        send(h.ws, { type: "host" });
+        for (const [pid, p] of room.pending) send(h.ws, { type: "join-request", id: pid, name: p.name });
+      }
+    }
+    if (room.peers.size === 0 && room.pending.size === 0) rooms.delete(roomId);
+  });
+});
+
+server.listen(PORT, () => console.log(`DaisyChain-Web on http://localhost:${PORT}`));

test_core.js

@@ -0,0 +1,54 @@
+// Verifies the training loop + 2-peer gradient averaging in pure Node (no
+// browser). Simulates two peers each holding half the data; they average
+// gradients every step. Proves: (a) it converges, (b) both replicas stay
+// identical — the same guarantees the browser P2P version needs.
+const T = require("./public/traincore.js");
+
+function randn(n) {
+  const a = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    let u = 0, v = 0;
+    while (u === 0) u = Math.random();
+    while (v === 0) v = Math.random();
+    a[i] = Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
+  }
+  return a;
+}
+
+const din = 16, dout = 4, nPer = 128, steps = 400, lr = 0.05;
+
+// ground-truth weights
+const Wtrue = randn(din * dout);
+function makeShard() {
+  const X = randn(nPer * din);
+  const y = T.matmul(X, Wtrue, nPer, din, dout);   // clean targets
+  return { X, y };
+}
+const A = makeShard(), B = makeShard();
+
+// both peers start from the SAME W0 (initiator broadcasts it)
+const W0 = randn(din * dout);
+const Wa = Float32Array.from(W0), Wb = Float32Array.from(W0);
+
+let loss = 0;
+for (let s = 0; s < steps; s++) {
+  const ra = T.forwardLossGrad(A.X, A.y, Wa, nPer, din, dout);
+  const rb = T.forwardLossGrad(B.X, B.y, Wb, nPer, din, dout);
+  const avg = T.averageGrads([ra.gradW, rb.gradW]);   // <-- exchanged P2P
+  T.applyGrad(Wa, avg, lr);
+  T.applyGrad(Wb, avg, lr);
+  loss = (ra.loss + rb.loss) / 2;
+  if (s % 80 === 0 || s === steps - 1)
+    console.log(`  step ${s}  cluster-avg loss ${loss.toFixed(6)}`);
+}
+
+let maxDiff = 0;
+for (let i = 0; i < Wa.length; i++) maxDiff = Math.max(maxDiff, Math.abs(Wa[i] - Wb[i]));
+let recovery = 0;
+for (let i = 0; i < Wtrue.length; i++) recovery = Math.max(recovery, Math.abs(Wa[i] - Wtrue[i]));
+
+console.log(`\nreplica max param diff: ${maxDiff.toExponential(3)}`);
+console.log(`max |W - W_true|:       ${recovery.toExponential(3)}`);
+const ok = loss < 1e-3 && maxDiff < 1e-9 && recovery < 0.05;
+console.log(ok ? "\nCORE TEST PASSED — converged, replicas in sync." : "\nCORE TEST FAILED");
+process.exit(ok ? 0 : 1);

test_optimizer.js

@@ -0,0 +1,63 @@
+// Verifies DaisyAdam (TrainCore.makeAdam) on the path that matters: training
+// THROUGH the verified INT8 units, where STE gradients are noisy and plain SGD
+// plateaus. Checks (a) two replicas fed the same averaged gradients stay
+// bit-identical, (b) Adam reaches a lower loss than SGD in the same steps.
+const fs = require("fs");
+const path = require("path");
+const T = require("./public/traincore.js");
+const V = require("./public/verified_core.js");
+
+function loadLUTs() {
+  const p = (f) => path.join(__dirname, "public", f);
+  return {
+    mul: new Int16Array(fs.readFileSync(p("mul_lut.bin")).buffer.slice(0)),
+    requant: new Int8Array(fs.readFileSync(p("requant_lut.bin")).buffer.slice(0)),
+    relu: new Int8Array(fs.readFileSync(p("relu_lut.bin")).buffer.slice(0)),
+  };
+}
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+
+const L = loadLUTs();
+const D = { n: 128, din: 16, h: 16, dout: 4 }, steps = 300;
+
+const Wtrue1 = randn(D.din * D.h, mulberry32(42)), Wtrue2 = randn(D.h * D.dout, mulberry32(43));
+function target(X) { const hpre = T.matmul(X, Wtrue1, D.n, D.din, D.h); for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]); return T.matmul(hpre, Wtrue2, D.n, D.h, D.dout); }
+const XA = randn(D.n * D.din, mulberry32(11)), yA = target(XA);
+const XB = randn(D.n * D.din, mulberry32(12)), yB = target(XB);
+
+async function run(useAdam) {
+  const W1a = randn(D.din * D.h, mulberry32(7)), W2a = randn(D.h * D.dout, mulberry32(8));
+  const W1b = Float32Array.from(W1a), W2b = Float32Array.from(W2a);
+  const dim = W1a.length + W2a.length;
+  const oa = T.makeAdam(dim, { lr: 0.2 }), ob = T.makeAdam(dim, { lr: 0.2 });
+  let loss = 0;
+  for (let s = 0; s < steps; s++) {
+    const fa = await V.forward(XA, yA, W1a, W2a, D, L), ga = V.backward(XA, W1a, W2a, fa, D);
+    const fb = await V.forward(XB, yB, W1b, W2b, D, L), gb = V.backward(XB, W1b, W2b, fb, D);
+    const avg = T.averageGrads([ga, gb]);
+    if (useAdam) {
+      V.splitApply(W1a, W2a, oa.step(avg), 1);
+      V.splitApply(W1b, W2b, ob.step(avg), 1);
+    } else {
+      V.splitApply(W1a, W2a, avg, 0.03);
+      V.splitApply(W1b, W2b, avg, 0.03);
+    }
+    loss = (fa.loss + fb.loss) / 2;
+  }
+  let diff = 0;
+  for (let i = 0; i < W1a.length; i++) diff = Math.max(diff, Math.abs(W1a[i] - W1b[i]));
+  for (let i = 0; i < W2a.length; i++) diff = Math.max(diff, Math.abs(W2a[i] - W2b[i]));
+  return { loss, diff };
+}
+
+(async function () {
+  const sgd = await run(false);
+  const adam = await run(true);
+  console.log(`SGD(lr=0.03)      final loss ${sgd.loss.toFixed(5)}`);
+  console.log(`DaisyAdam(lr=0.2) final loss ${adam.loss.toFixed(5)}  replica diff ${adam.diff.toExponential(3)}`);
+  const ok = adam.diff === 0 && adam.loss < sgd.loss;
+  console.log(ok ? "\nOPTIMIZER TEST PASSED — deterministic replicas, beats SGD through the verified units."
+                 : "\nOPTIMIZER TEST FAILED");
+  process.exit(ok ? 0 : 1);
+})();

test_verified.js

@@ -0,0 +1,48 @@
+// Proves 2-peer training THROUGH the verified units (LUTs) converges and stays
+// in sync — the browser will do exactly this, with the matmul on WebGPU.
+const fs = require("fs");
+const path = require("path");
+const T = require("./public/traincore.js");
+const V = require("./public/verified_core.js");
+
+function loadLUTs() {
+  const p = (f) => path.join(__dirname, "public", f);
+  const mul = new Int16Array(fs.readFileSync(p("mul_lut.bin")).buffer.slice(0));
+  const requant = new Int8Array(fs.readFileSync(p("requant_lut.bin")).buffer.slice(0));
+  const relu = new Int8Array(fs.readFileSync(p("relu_lut.bin")).buffer.slice(0));
+  return { mul, requant, relu };
+}
+
+function randn(n, rng) { const r = rng || Math.random; const o = new Float32Array(n); for (let i = 0; i < n; i += 2) { let u = 0, v = 0; while (u === 0) u = r(); while (v === 0) v = r(); const m = Math.sqrt(-2 * Math.log(u)); o[i] = m * Math.cos(2 * Math.PI * v); if (i + 1 < n) o[i + 1] = m * Math.sin(2 * Math.PI * v); } return o; }
+function mulberry32(a) { return function () { a |= 0; a = a + 0x6D2B79F5 | 0; let t = Math.imul(a ^ a >>> 15, 1 | a); t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t; return ((t ^ t >>> 14) >>> 0) / 4294967296; }; }
+
+const L = loadLUTs();
+const D = { n: 128, din: 16, h: 16, dout: 4 }, lr = 0.03, steps = 300;
+
+// shared deterministic truth + init; per-peer data shard
+const Wtrue1 = randn(D.din * D.h, mulberry32(42)), Wtrue2 = randn(D.h * D.dout, mulberry32(43));
+function target(X) { const hpre = T.matmul(X, Wtrue1, D.n, D.din, D.h); for (let i = 0; i < hpre.length; i++) hpre[i] = Math.max(0, hpre[i]); return T.matmul(hpre, Wtrue2, D.n, D.h, D.dout); }
+const XA = randn(D.n * D.din), yA = target(XA);
+const XB = randn(D.n * D.din), yB = target(XB);
+
+const W1a = randn(D.din * D.h, mulberry32(7)), W2a = randn(D.h * D.dout, mulberry32(8));
+const W1b = Float32Array.from(W1a), W2b = Float32Array.from(W2a);
+
+(async function () {
+  let loss = 0, loss0 = 0;
+  for (let s = 0; s < steps; s++) {
+    const fa = await V.forward(XA, yA, W1a, W2a, D, L), ga = V.backward(XA, W1a, W2a, fa, D);
+    const fb = await V.forward(XB, yB, W1b, W2b, D, L), gb = V.backward(XB, W1b, W2b, fb, D);
+    const avg = T.averageGrads([ga, gb]);               // <-- exchanged P2P
+    V.splitApply(W1a, W2a, avg, lr);
+    V.splitApply(W1b, W2b, avg, lr);
+    loss = (fa.loss + fb.loss) / 2; if (s === 0) loss0 = loss;
+    if (s % 60 === 0 || s === steps - 1) console.log(`  step ${s}  cluster-avg loss ${loss.toFixed(5)}`);
+  }
+  let diff = 0; for (let i = 0; i < W1a.length; i++) diff = Math.max(diff, Math.abs(W1a[i] - W1b[i]));
+  for (let i = 0; i < W2a.length; i++) diff = Math.max(diff, Math.abs(W2a[i] - W2b[i]));
+  console.log(`\nreplica max param diff: ${diff.toExponential(3)}`);
+  const ok = loss < loss0 * 0.3 && diff < 1e-9;
+  console.log(ok ? "VERIFIED TEST PASSED — trained through the units, converged, replicas in sync." : "FAILED");
+  process.exit(ok ? 0 : 1);
+})();