feat(frontier): specdecode+flowmatch+dllm surfaces+tabs (organs on killinchu)

Surfaces 19-21. Poll killinchu cross-origin. MODELED. Nothing in locked-8; Lambda stays Conjecture 1.

static/3d/holographic.html

@@ -77,6 +77,9 @@ const SURFACES = [
   { id: "testtime", title: "Test-Time Compute", mod: "/static/3d/surfaces/testtime.js" },
   { id: "ssm", title: "State-Space (Mamba-3)", mod: "/static/3d/surfaces/ssm.js" },
   { id: "genie", title: "Genie World-Model", mod: "/static/3d/surfaces/genie.js" },
+  { id: "specdecode", title: "Speculative Decoding", mod: "/static/3d/surfaces/specdecode.js" },
+  { id: "flowmatch", title: "Flow Matching", mod: "/static/3d/surfaces/flowmatch.js" },
+  { id: "dllm", title: "Diffusion LLM", mod: "/static/3d/surfaces/dllm.js" },
   { id: "energy",      title: "Energy",      mod: "/static/3d/surfaces/energy.js" },
   { id: "fabric",      title: "Fabric",      mod: "/static/3d/surfaces/fabric.js" },
   { id: "pnt",         title: "PNT",         mod: "/static/3d/surfaces/pnt.js" },

static/3d/surfaces/dllm.js

@@ -0,0 +1,453 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/dllm.js — DIFFUSION-LLM PARALLEL DENOISING organ for the holographic
+// frontier ring (Mercury/LLaDA-style masked-diffusion decoding, MODELED).
+//
+// Renders the token sequence as a 3D row/grid lattice driven by a live closed-
+// form snapshot from /api/killinchu/v1/dllm/denoise:
+//   - ALL `length` positions start MASKED (grey cubes).
+//   - Across `steps` denoising rounds, a highest-confidence-first schedule
+//     unmasks a batch of NEW positions EACH round, in parallel (not left-to-
+//     right) -- they light up lattice-blue -> violet-blue as rounds advance.
+//   - A HUD shows parallelism_factor (= length/steps, tokens decided per
+//     round) and the tokens_per_round schedule, contrasted against the
+//     autoregressive baseline of 1.0 token/step.
+// Honesty label "MODELED" is read VERBATIM from the JSON and displayed as-is;
+// it is never upgraded.
+//
+// Surface export shape (mirrors testtime.js / interpretability.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   length, steps, parallelism_factor, tokens_per_round[], cumulative_unmasked[],
+//   confidence_trajectory[], final_sequence[] (synthetic token ids)
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   LLaDA (masked diffusion LLM): Nie et al. 2025, arXiv:2502.09992
+//     https://arxiv.org/abs/2502.09992  ·  https://github.com/ML-GSAI/LLaDA
+//   Mercury (Inception Labs, commercial-scale diffusion LLM): arXiv:2506.17298
+//     https://arxiv.org/abs/2506.17298
+//   D3PM (discrete-state denoising diffusion foundation): Austin et al. 2021,
+//     arXiv:2107.03006  https://arxiv.org/abs/2107.03006
+//
+// HONESTY LABELS: MODELED (clean-room deterministic simulation of the masked-
+//   diffusion parallel-decoding SCHEDULE; NOT a trained diffusion LLM; NEVER-
+//   CLAIMED-AS Mercury/LLaDA). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (unmasked tokens), violet-blue 0x8a6bff
+//   (recently-unmasked / active-round highlight), proof-teal 0x3af4c8 (HUD
+//   accent), greys (masked / degraded). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "dllm";
+const TITLE = "Diffusion-LLM Parallel Denoising (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the dLLM organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/dllm/denoise?seed=42&steps=8&length=64";
+
+// data-viz hues — purple BANNED
+const C_MASKED  = 0x3a4149;  // grey — still-masked token (pre-denoise)
+const C_UNMASK  = 0x5b8dee;  // lattice-blue — committed/unmasked token
+const C_RECENT  = 0x8a6bff;  // violet-blue — unmasked THIS round (active highlight)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_ACCENT  = 0x3af4c8;  // proof-teal accent (HUD / round marker)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// grid layout geometry
+const CELL      = 0.42;   // world-units per token cell
+const GAP       = 0.10;   // world-units gap between cells
+const MAX_COLS  = 16;     // wrap the row into a grid after this many columns
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _cells = [];     // Array<THREE.Mesh> — one per token position
+let _floor = null;
+let _roundMarker = null; // THREE.Mesh — pulsing "current round" indicator
+
+// round-by-round playback state (client-side animation over the live schedule)
+let _playTimer = null;
+let _playRound = 0;
+
+// live state
+const S = {
+  label:        null,
+  length:       null,
+  steps:        null,
+  parallelism:  null,
+  tokensPerRound: null,   // tokens_per_round[]
+  cumulative:   null,     // cumulative_unmasked[]
+  confidence:   null,     // confidence_trajectory[]
+  finalSeq:     null,     // final_sequence[]
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(3, 6, 14);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(3, 0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildRoundMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onDenoise, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.4;
+  _group.add(grid);
+  _floor = grid;
+}
+
+function _buildRoundMarker() {
+  const THREE = _THREE;
+  _roundMarker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.20, 1),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _roundMarker.position.set(0, 1.4, 0);
+  _group.add(_roundMarker);
+}
+
+// Build (or rebuild) the token lattice once `length` is known from live data.
+function _ensureCells(length) {
+  if (_cells.length === length) return;
+  // dispose old cells first
+  _cells.forEach((m) => {
+    _group.remove(m);
+    if (m.geometry && m.geometry.dispose) m.geometry.dispose();
+    if (m.material && m.material.dispose) m.material.dispose();
+  });
+  _cells = [];
+
+  const THREE = _THREE;
+  const geo = new THREE.BoxGeometry(CELL, CELL, CELL);
+  const cols = Math.min(MAX_COLS, Math.max(1, length));
+  for (let i = 0; i < length; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const mat = new THREE.MeshStandardMaterial({ color: C_MASKED, emissive: C_MASKED, emissiveIntensity: 0.15, transparent: true, opacity: 0.85 });
+    const m = new THREE.Mesh(geo, mat);
+    m.position.set(col * (CELL + GAP), -row * (CELL + GAP), 0);
+    _group.add(m);
+    _cells.push(m);
+  }
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onDenoise(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label        = (j.label || "MODELED").toUpperCase();
+  S.length       = typeof j.length === "number" ? j.length : null;
+  S.steps        = typeof j.steps === "number" ? j.steps : null;
+  S.parallelism  = typeof j.parallelism_factor === "number" ? j.parallelism_factor : null;
+  S.tokensPerRound = Array.isArray(j.tokens_per_round) ? j.tokens_per_round : null;
+  S.cumulative   = Array.isArray(j.cumulative_unmasked) ? j.cumulative_unmasked : null;
+  S.confidence   = Array.isArray(j.confidence_trajectory) ? j.confidence_trajectory : null;
+  S.finalSeq     = Array.isArray(j.final_sequence) ? j.final_sequence : null;
+
+  if (S.length) _ensureCells(S.length);
+  _restartPlayback();
+  _paintOverlay();
+}
+
+// =============================================================================
+// round-by-round playback — animates the parallel unmask schedule so the
+// viewer can SEE positions light up in batches per round, not left-to-right.
+// =============================================================================
+function _restartPlayback() {
+  if (_playTimer) { clearInterval(_playTimer); _playTimer = null; }
+  _playRound = 0;
+  if (!(S.state === "live" && S.length && S.steps && S.tokensPerRound)) {
+    _paintMasked();
+    return;
+  }
+  // Deterministic-looking reveal order: fixed shuffled index list derived from
+  // the cell count (client-side only, purely for visual ordering — the
+  // authoritative parallel-unmask COUNTS per round come from the live endpoint).
+  const order = _shuffledIndices(S.length);
+  let cursor = 0;
+  _paintMasked();
+
+  _playTimer = setInterval(() => {
+    if (_playRound >= S.tokensPerRound.length) {
+      clearInterval(_playTimer); _playTimer = null;
+      return;
+    }
+    const n = S.tokensPerRound[_playRound] || 0;
+    for (let k = 0; k < n && cursor < order.length; k++, cursor++) {
+      _lightCell(order[cursor], true);
+    }
+    // dim the "recent" highlight from the previous round back to steady unmasked-blue
+    _settleColors();
+    _playRound += 1;
+    _updateRoundMarker();
+  }, 650);
+}
+
+function _shuffledIndices(n) {
+  // simple deterministic-seeded shuffle (Mulberry32-style) purely for display order
+  let seed = (n * 2654435761) >>> 0;
+  function rnd() {
+    seed = (seed + 0x6D2B79F5) >>> 0;
+    let t = seed;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  }
+  const idx = Array.from({ length: n }, (_, i) => i);
+  for (let i = n - 1; i > 0; i--) {
+    const j = Math.floor(rnd() * (i + 1));
+    [idx[i], idx[j]] = [idx[j], idx[i]];
+  }
+  return idx;
+}
+
+function _paintMasked() {
+  _cells.forEach((m) => {
+    m.material.color.setHex(C_MASKED);
+    m.material.emissive.setHex(C_MASKED);
+    m.material.emissiveIntensity = 0.15;
+    m.material.opacity = 0.85;
+  });
+}
+
+function _lightCell(i, recent) {
+  const m = _cells[i];
+  if (!m) return;
+  const c = recent ? C_RECENT : C_UNMASK;
+  m.material.color.setHex(c);
+  m.material.emissive.setHex(c);
+  m.material.emissiveIntensity = recent ? 0.7 : 0.35;
+  m.material.opacity = 1.0;
+  m._recentTick = 3; // frames-ish counter handled in _onFrame settle pass
+}
+
+function _settleColors() {
+  // cells lit "recent" (violet-blue) on the previous tick fade to steady
+  // lattice-blue on this tick, so only the CURRENT round's batch glows bright.
+  _cells.forEach((m) => {
+    if (m.material.color.getHex() === C_RECENT) {
+      m.material.color.setHex(C_UNMASK);
+      m.material.emissive.setHex(C_UNMASK);
+      m.material.emissiveIntensity = 0.35;
+    }
+  });
+}
+
+function _updateRoundMarker() {
+  if (!_roundMarker || !_cells.length) return;
+  const cols = Math.min(MAX_COLS, Math.max(1, S.length || 1));
+  const x = ((cols - 1) * (CELL + GAP)) / 2;
+  _roundMarker.position.set(x, 1.4, 0);
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.12;
+  if (_roundMarker) {
+    _roundMarker.rotation.y += 0.02;
+    _roundMarker.rotation.x += 0.01;
+    const pulse = 1.0 + 0.15 * Math.sin(t * 0.004);
+    _roundMarker.scale.setScalar(pulse);
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'Diffusion LLMs (<b>Mercury</b>/<b>LLaDA</b>-style) start from a <b>fully-masked</b> sequence ' +
+    'and unmask ALL positions in <b>parallel</b> across denoising rounds \u2014 not left-to-right like ' +
+    'autoregressive decoding. Honesty label <b>MODELED</b> (clean-room simulation of the decoding ' +
+    'SCHEDULE; NOT a trained diffusion LLM). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "dllm-parallel-denoise";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("dl-length",   "sequence length"));
+  grid.appendChild(kpiRow("dl-steps",    "denoising rounds (steps)"));
+  grid.appendChild(kpiRow("dl-parallel", "parallelism factor \u2014 MODELED"));
+  grid.appendChild(kpiRow("dl-ar",       "vs autoregressive (1.0 tok/step)"));
+  grid.appendChild(kpiRow("dl-tpr",      "tokens/round schedule"));
+  grid.appendChild(kpiRow("dl-conf",     "confidence trajectory (last)"));
+  grid.appendChild(kpiRow("dl-label",    "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "LLaDA \u2014 Nie et al. arXiv:2502.09992 (github.com/ML-GSAI/LLaDA) \u00b7 Mercury (Inception Labs) arXiv:2506.17298 \u00b7 D3PM \u2014 Austin et al. arXiv:2107.03006. MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "dl-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const len   = S.length != null ? String(S.length) : "loading\u2026";
+  const steps = S.steps  != null ? String(S.steps)  : "loading\u2026";
+  const par   = S.parallelism != null ? S.parallelism.toFixed(2) : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> A normal (autoregressive) AI writes one word at a time, so a " +
+    len + "-token answer takes " + len + " sequential steps. A <b>diffusion LLM</b> instead starts " +
+    "with a completely blank/masked answer and fills in <b>many words at once</b>, refining the " +
+    "whole thing over just " + steps + " rounds. That is a <b>" + par + "x parallelism factor</b> \u2014 " +
+    "roughly " + par + " tokens decided per round versus 1 token per step for old-style decoding. " +
+    "This view is a <b>MODELED</b> clean-room simulation of that decoding SCHEDULE, not a real " +
+    "trained diffusion model \u2014 and it is NEVER claimed to be Mercury or LLaDA themselves.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("dl-length",   t || (S.length != null ? String(S.length) : "\u2014"));
+  _set("dl-steps",    t || (S.steps  != null ? String(S.steps)  : "\u2014"));
+  _set("dl-parallel", t || (S.parallelism != null ? fx(S.parallelism, 3) + "x" : "\u2014"));
+  _set("dl-ar",       t || (S.parallelism != null ? fx(S.parallelism, 2) + "x faster (tokens/round vs 1.0 tok/step)" : "\u2014"));
+  _set("dl-tpr",      t || (S.tokensPerRound ? S.tokensPerRound.join(",") : "\u2014"));
+  _set("dl-conf",     t || (S.confidence && S.confidence.length ? fx(S.confidence[S.confidence.length - 1], 3) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("dl-label",    t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  if (_playTimer) { try { clearInterval(_playTimer); } catch (_) {} _playTimer = null; }
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _cells = []; _floor = null; _roundMarker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _playRound = 0;
+  _stage = _THREE = _ctx = null;
+  S.label = S.length = S.steps = S.parallelism = null;
+  S.tokensPerRound = S.cumulative = S.confidence = S.finalSeq = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/flowmatch.js

@@ -0,0 +1,448 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/flowmatch.js — RECTIFIED-FLOW / FLOW-MATCHING ODE-SAMPLER organ for the
+// holographic frontier ring. Renders the ODE trajectory of a rectified-flow sampler:
+// dx/dt = v(x,t) = x1 - x0 (a constant straight-line velocity field), integrated with
+// explicit-Euler steps from a noise point x0 ~ N(0,I) to a target point x1.
+//
+// Renders a 3D flow path driven by a live closed-form snapshot from
+// /api/killinchu/v1/flowmatch/sample:
+//   1. A noise-cloud marker at x0 (start of the flow).
+//   2. The Euler-integrated trajectory as a growing line from x0 toward x1 — for the
+//      rectified (straight-line) case this path IS a straight line.
+//   3. A target marker at x1 (end of the flow).
+// A HUD shows final_error DROPPING as steps increase (few-step vs many-step comparison)
+// plus straightness_score and steps_to_converge — the rectified-flow win: few steps
+// already converge. Honesty label "MODELED" is read VERBATIM from the JSON and
+// displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors testtime.js / interpretability.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   dims, steps, x0, x1, trajectory[], final_error, straightness_score,
+//   steps_to_converge, few_vs_many{few_steps,few_step_error,many_steps,many_step_error}
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Flow Matching for Generative Modeling: Lipman et al. 2022, arXiv:2210.02747
+//     https://arxiv.org/abs/2210.02747
+//   Rectified Flow ("Flow Straight and Fast"): Liu et al. 2022, arXiv:2209.03003
+//     https://arxiv.org/abs/2209.03003
+//   FLUX (production rectified-flow model, Black Forest Labs — cited only, NEVER
+//     claimed as SZL's own): https://github.com/black-forest-labs/flux
+//
+// HONESTY LABELS: MODELED (deterministic analytic rectified-flow ODE integration on a
+//   toy noise->target case; NOT a trained flow/diffusion model; NEVER-CLAIMED-AS FLUX
+//   or Stable Diffusion 3). Read verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (trajectory path), violet-blue 0x8a6bff (noise/target
+//   markers — data-viz only), proof-teal 0x3af4c8 (HUD accent / convergence marker).
+//   Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "flowmatch";
+const TITLE = "Rectified Flow · Flow-Matching ODE Sampler (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the flow-matching organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/flowmatch/sample?seed=42&steps=8&dims=3";
+
+// data-viz hues — purple BANNED
+const C_PATH    = 0x5b8dee;  // lattice-blue (ODE trajectory path)
+const C_MARKERS = 0x8a6bff;  // violet-blue (x0 noise / x1 target markers — data-viz only)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_ACCENT  = 0x3af4c8;  // proof-teal accent (HUD / convergence marker)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// path layout geometry
+const PATH_SCALE = 1.6;   // world-units per unit of raw x/y/z coordinate
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _pathLine  = null;    // THREE.Line — Euler-integrated trajectory
+let _pathDots  = [];      // Array<THREE.Mesh> — markers along the trajectory
+let _x0Marker  = null;    // THREE.Mesh — noise-cloud start marker
+let _x1Marker  = null;    // THREE.Mesh — target end marker
+let _converge  = null;    // THREE.Mesh — pulsing "converged" HUD marker
+let _floor     = null;
+
+// live state
+const S = {
+  label:        null,
+  dims:         null,
+  steps:        null,
+  x0:           null,
+  x1:           null,
+  trajectory:   null,   // [{t, x}, ...]
+  finalError:   null,
+  straightness: null,
+  stepsToConverge: null,
+  fewSteps:     null,
+  fewError:     null,
+  manySteps:    null,
+  manyError:    null,
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(2, 6, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(2, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildPath();
+  _buildMarkers();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onSample, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Pre-allocate the trajectory line geometry with a fixed max point-count; update
+// point positions in-place as live data arrives (no per-poll geometry churn).
+const _MAX_PTS = 130; // covers up to 128-step many-step trajectories
+
+function _buildPath() {
+  const THREE = _THREE;
+  const pts = new Array(_MAX_PTS).fill(0).map(() => new THREE.Vector3(0, 0, 0));
+  const geo = new THREE.BufferGeometry().setFromPoints(pts);
+  const mat = new THREE.LineBasicMaterial({ color: C_PATH, transparent: true, opacity: 0.85, linewidth: 2 });
+  _pathLine = new THREE.Line(geo, mat);
+  _group.add(_pathLine);
+
+  const dotGeo = new THREE.SphereGeometry(0.07, 10, 8);
+  for (let i = 0; i < _MAX_PTS; i++) {
+    const m = new THREE.Mesh(dotGeo, new THREE.MeshStandardMaterial({ color: C_PATH, emissive: C_PATH, emissiveIntensity: 0.3 }));
+    m.visible = false;
+    _group.add(m);
+    _pathDots.push(m);
+  }
+}
+
+function _buildMarkers() {
+  const THREE = _THREE;
+  // noise-cloud start marker (x0) — wireframe icosahedron, violet-blue
+  _x0Marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.28, 1),
+    new THREE.MeshStandardMaterial({ color: C_MARKERS, emissive: C_MARKERS, emissiveIntensity: 0.4, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _group.add(_x0Marker);
+
+  // target end marker (x1) — solid octahedron, violet-blue
+  _x1Marker = new THREE.Mesh(
+    new THREE.OctahedronGeometry(0.30, 0),
+    new THREE.MeshStandardMaterial({ color: C_MARKERS, emissive: C_MARKERS, emissiveIntensity: 0.5, transparent: true, opacity: 0.9 }),
+  );
+  _group.add(_x1Marker);
+
+  // convergence pulse marker — proof-teal, sits at the ODE's final point
+  _converge = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.16, 1),
+    new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.6, wireframe: true, transparent: true, opacity: 0.9 }),
+  );
+  _group.add(_converge);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onSample(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label        = (j.label || "MODELED").toUpperCase();
+  S.dims         = typeof j.dims  === "number" ? j.dims  : null;
+  S.steps        = typeof j.steps === "number" ? j.steps : null;
+  S.x0           = Array.isArray(j.x0) ? j.x0 : null;
+  S.x1           = Array.isArray(j.x1) ? j.x1 : null;
+  S.trajectory   = Array.isArray(j.trajectory) ? j.trajectory : null;
+  S.finalError   = typeof j.final_error === "number" ? j.final_error : null;
+  S.straightness = typeof j.straightness_score === "number" ? j.straightness_score : null;
+  S.stepsToConverge = typeof j.steps_to_converge === "number" ? j.steps_to_converge : null;
+
+  const fvm = j.few_vs_many || {};
+  S.fewSteps   = typeof fvm.few_steps  === "number" ? fvm.few_steps  : null;
+  S.fewError   = typeof fvm.few_step_error  === "number" ? fvm.few_step_error  : null;
+  S.manySteps  = typeof fvm.many_steps === "number" ? fvm.many_steps : null;
+  S.manyError  = typeof fvm.many_step_error === "number" ? fvm.many_step_error : null;
+
+  _updatePath();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the trajectory path + markers from live data
+// =============================================================================
+function _proj(vec) {
+  // Project a small dims-length vector (2..8 dims) down to 3D world coords by
+  // taking the first 3 components (pad with 0 if fewer). Pure display mapping —
+  // does not alter any reported numeric values.
+  const x = (vec[0] || 0) * PATH_SCALE;
+  const y = (vec[1] || 0) * PATH_SCALE;
+  const z = (vec[2] || 0) * PATH_SCALE;
+  return [x, y, z];
+}
+
+function _updatePath() {
+  const live = S.state === "live";
+
+  if (live && S.trajectory && S.trajectory.length) {
+    const pos = _pathLine.geometry.attributes.position;
+    const n = Math.min(_MAX_PTS, S.trajectory.length);
+    for (let i = 0; i < _MAX_PTS; i++) {
+      const row = S.trajectory[Math.min(i, n - 1)];
+      const [x, y, z] = _proj(row.x || []);
+      pos.setXYZ(i, x, y, z);
+      if (i < n) {
+        _pathDots[i].position.set(x, y, z);
+        _pathDots[i].visible = true;
+      } else {
+        _pathDots[i].visible = false;
+      }
+    }
+    pos.needsUpdate = true;
+    _pathLine.geometry.computeBoundingSphere();
+    _pathLine.material.color.setHex(C_PATH);
+    _pathLine.material.opacity = 0.85;
+
+    // x0 / x1 markers
+    if (S.x0) { const [x, y, z] = _proj(S.x0); _x0Marker.position.set(x, y, z); }
+    if (S.x1) { const [x, y, z] = _proj(S.x1); _x1Marker.position.set(x, y, z); }
+    _x0Marker.material.color.setHex(C_MARKERS); _x0Marker.material.emissive.setHex(C_MARKERS); _x0Marker.material.opacity = 0.85;
+    _x1Marker.material.color.setHex(C_MARKERS); _x1Marker.material.emissive.setHex(C_MARKERS); _x1Marker.material.opacity = 0.9;
+
+    // convergence marker sits at the ODE's final integrated point
+    const lastRow = S.trajectory[S.trajectory.length - 1];
+    if (lastRow && lastRow.x) {
+      const [x, y, z] = _proj(lastRow.x);
+      _converge.position.set(x, y, z);
+    }
+    _converge.material.color.setHex(C_ACCENT);
+    _converge.material.emissive.setHex(C_ACCENT);
+    _converge.material.opacity = 0.9;
+  } else {
+    _pathDots.forEach((d) => { d.visible = false; });
+    _pathLine.material.color.setHex(C_DIM);
+    _pathLine.material.opacity = 0.25;
+    _x0Marker.material.color.setHex(C_DIM); _x0Marker.material.emissive.setHex(C_DIM); _x0Marker.material.opacity = 0.3;
+    _x1Marker.material.color.setHex(C_DIM); _x1Marker.material.emissive.setHex(C_DIM); _x1Marker.material.opacity = 0.3;
+    _converge.material.color.setHex(C_DIM); _converge.material.emissive.setHex(C_DIM); _converge.material.opacity = 0.3;
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00010) * 0.15;
+  if (_converge) {
+    _converge.rotation.y += 0.02;
+    _converge.rotation.x += 0.01;
+    const pulse = 1.0 + 0.15 * Math.sin(t * 0.004);
+    _converge.scale.setScalar(pulse);
+  }
+  if (_x1Marker) { _x1Marker.rotation.y += 0.01; }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A <b>rectified-flow ODE sampler</b>: integrate dx/dt = v(x,t) = x1 \u2212 x0 (a ' +
+    '<b>straight-line velocity field</b>) from noise x0 to a target x1 with Euler steps. ' +
+    'Honesty label <b>MODELED</b> (analytic toy case; NOT a trained flow/diffusion model; ' +
+    'never claimed as FLUX or SD3). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#5b8dee;box-shadow:0 0 7px #5b8dee";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#5b8dee;letter-spacing:.3px";
+  nm.textContent = "flow-matching";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("fm-dims",   "dims"));
+  grid.appendChild(kpiRow("fm-steps",  "steps (Euler)"));
+  grid.appendChild(kpiRow("fm-err",    "final_error \u2014 MODELED"));
+  grid.appendChild(kpiRow("fm-straight","straightness_score"));
+  grid.appendChild(kpiRow("fm-conv",   "steps_to_converge"));
+  grid.appendChild(kpiRow("fm-few",    "few-step error"));
+  grid.appendChild(kpiRow("fm-many",   "many-step error"));
+  grid.appendChild(kpiRow("fm-label",  "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Lipman et al. arXiv:2210.02747 (Flow Matching) \u00b7 Liu et al. arXiv:2209.03003 (Rectified Flow) \u00b7 FLUX github.com/black-forest-labs/flux (cited only). MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "fm-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const steps = S.steps != null ? String(S.steps) : "loading\u2026";
+  const few   = S.fewSteps != null ? String(S.fewSteps) : "1";
+  const many  = S.manySteps != null ? String(S.manySteps) : "128";
+  const str   = S.straightness != null ? (S.straightness * 100).toFixed(2) + "%" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Older generative-AI samplers (like standard diffusion) need " +
+    "<i>many small steps</i> to trace a curved path from random noise to a real output. " +
+    "<b>Rectified flow</b> instead learns (or here, defines) a <b>straight-line path</b> " +
+    "from noise to the target, so a model can take just <b>" + few + " step</b> and land " +
+    "almost exactly on target \u2014 versus needing <b>" + many + " steps</b> the old way, " +
+    "with barely any extra benefit. The path here is <b>" + str + " straight</b>. This is " +
+    "the same core idea behind fast production image generators like FLUX. This view is a " +
+    "<b>MODELED</b> analytic toy case (not a trained model, not FLUX itself), used at " +
+    "steps=" + steps + " to show the effect live.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function pct(v, d) { return typeof v === "number" ? (v * 100).toFixed(d) + "%" : "\u2014"; }
+function sci(v, d) { return typeof v === "number" ? v.toExponential(d) : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("fm-dims",     t || (S.dims != null ? String(S.dims) : "\u2014"));
+  _set("fm-steps",    t || (S.steps != null ? String(S.steps) : "\u2014"));
+  _set("fm-err",      t || sci(S.finalError, 3));
+  _set("fm-straight", t || pct(S.straightness, 2));
+  _set("fm-conv",     t || (S.stepsToConverge != null ? String(S.stepsToConverge) : "\u2014"));
+  _set("fm-few",      t || (S.fewSteps != null ? `${sci(S.fewError, 2)} (n=${S.fewSteps})` : "\u2014"));
+  _set("fm-many",     t || (S.manySteps != null ? `${sci(S.manyError, 2)} (n=${S.manySteps})` : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("fm-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _pathLine = null; _pathDots = []; _x0Marker = null; _x1Marker = null; _converge = null; _floor = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.dims = S.steps = S.x0 = S.x1 = S.trajectory = null;
+  S.finalError = S.straightness = S.stepsToConverge = null;
+  S.fewSteps = S.fewError = S.manySteps = S.manyError = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/specdecode.js

@@ -0,0 +1,433 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/specdecode.js — SELF-SPECULATIVE MULTI-TOKEN DECODING organ for the
+// holographic frontier ring (Medusa/EAGLE-style draft-then-verify). Renders the
+// draft model proposing `draft_len` candidate tokens per step as a 3D token-tree
+// / pipeline, then colors each proposed token ACCEPTED (proof-teal) or REJECTED
+// (grey) per the live snapshot from /api/killinchu/v1/specdecode/simulate. A HUD
+// shows acceptance_rate + speedup_factor. Honesty label "MODELED" is read
+// VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors testtime.js / interpretability.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   draft_len, trials, acceptance_rate, mean_accept_len, mean_tokens_per_step,
+//   speedup_factor, per_step_accept_lengths[], lossless
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Speculative Decoding (accept/reject arithmetic simulated here):
+//     Leviathan, Kalman & Matias 2023, arXiv:2211.17192
+//     https://arxiv.org/abs/2211.17192
+//   Medusa (multiple decoding heads, tree verification — reference only):
+//     Cai et al. 2024, github.com/FasterDecoding/Medusa
+//     https://github.com/FasterDecoding/Medusa
+//   EAGLE (feature-level extrapolation drafting — reference only):
+//     Li et al. 2024, arXiv:2401.15077
+//     https://arxiv.org/abs/2401.15077
+//
+// HONESTY LABELS: MODELED (deterministic re-implementation of the accept/reject
+//   arithmetic; NOT Medusa/EAGLE; NEVER-CLAIMED-AS a production drafter). Read
+//   verbatim from JSON; never upgraded here.
+// COLOURS: lattice-blue 0x5b8dee (draft tokens / pipeline), proof-teal 0x3af4c8
+//   (accepted tokens / HUD accent), greys (rejected tokens / degraded state).
+//   Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js r170 via page importmap.
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// Nothing here is in the locked-8. Λ stays Conjecture 1. Trust never 100%.
+
+const ID    = "specdecode";
+const TITLE = "Self-Speculative Decoding · Draft-then-Verify (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin: https://a-11-oy.com).
+// This keeps the spec-decode organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/specdecode/simulate?seed=42&draft_len=6&trials=256";
+
+// data-viz hues — purple BANNED
+const C_DRAFT   = 0x5b8dee;  // lattice-blue (draft-proposed token / pipeline spine)
+const C_ACCEPT  = 0x3af4c8;  // proof-teal (accepted token / HUD accent)
+const C_REJECT  = 0x5a6570;  // grey (rejected token)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// token-tree pipeline layout geometry
+const STEP_LEN    = 2.1;   // world-units between steps along X (pipeline axis)
+const TOKEN_GAP   = 0.85;  // world-units between tokens within a step (Y, draft depth)
+const MAX_STEPS   = 10;    // number of recent steps rendered along the pipeline
+const MAX_TOKENS  = 12;    // cap on draft_len rendered per step (perf)
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles
+let _floor      = null;
+let _spine      = null;               // THREE.Line — pipeline spine (draft -> verify axis)
+let _tokenMesh  = [];                 // Array<Array<THREE.Mesh>> — [step][tokenIdx]
+let _stepLinks  = [];                 // Array<THREE.Line> — link from spine to each step's tokens
+let _marker     = null;               // THREE.Mesh — HUD "current step" pulsing marker
+
+// live state
+const S = {
+  label:        null,
+  draftLen:     null,   // draft_len
+  trials:       null,   // trials
+  acceptRate:   null,   // acceptance_rate
+  meanAccept:   null,   // mean_accept_len
+  meanTokens:   null,   // mean_tokens_per_step
+  speedup:      null,   // speedup_factor
+  stepLengths:  null,   // per_step_accept_lengths[]
+  lossless:     null,   // lossless (bool)
+  state:        "init",
+};
+
+// =============================================================================
+// mount(ctx)
+// =============================================================================
+export function mount(ctx) {
+  _ctx = ctx; _stage = ctx.stage; _THREE = ctx.THREE;
+  _group = new _THREE.Group();
+  _stage.scene.add(_group);
+  _stage.camera.position.set(4, 7, 18);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(6, 2, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildPipeline();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onSpecdecode, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); } }));
+
+  _buildOverlay();
+  return { id: ID, started: true };
+}
+
+// =============================================================================
+// builders
+// =============================================================================
+function _buildFloor() {
+  const THREE = _THREE;
+  const grid = new THREE.GridHelper(40, 40, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Pre-allocate a fixed grid of token meshes: MAX_STEPS steps x MAX_TOKENS tokens
+// per step. We toggle visibility / color / position in-place as live data
+// arrives (no per-poll geometry churn).
+function _buildPipeline() {
+  const THREE = _THREE;
+
+  // pipeline spine: a straight line along X marking the draft->verify axis
+  {
+    const pts = [new THREE.Vector3(0, 0, 0), new THREE.Vector3(STEP_LEN * (MAX_STEPS - 1) + 1, 0, 0)];
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: C_DRAFT, transparent: true, opacity: 0.45 });
+    _spine = new THREE.Line(geo, mat);
+    _group.add(_spine);
+  }
+
+  const tokenGeo = new THREE.OctahedronGeometry(0.20, 0);
+  for (let s = 0; s < MAX_STEPS; s++) {
+    const stepTokens = [];
+    const x = s * STEP_LEN;
+    for (let t = 0; t < MAX_TOKENS; t++) {
+      const y = 0.4 + t * TOKEN_GAP;
+      const mesh = new THREE.Mesh(
+        tokenGeo,
+        new THREE.MeshStandardMaterial({ color: C_DRAFT, emissive: C_DRAFT, emissiveIntensity: 0.25, transparent: true, opacity: 0.0 }),
+      );
+      mesh.position.set(x, y, 0);
+      mesh.visible = false;
+      _group.add(mesh);
+      stepTokens.push(mesh);
+    }
+    _tokenMesh.push(stepTokens);
+
+    // vertical link line from spine up to the step's token column
+    const linkGeo = new THREE.BufferGeometry().setFromPoints([
+      new THREE.Vector3(x, 0, 0), new THREE.Vector3(x, 0.4 + (MAX_TOKENS - 1) * TOKEN_GAP, 0),
+    ]);
+    const linkMat = new THREE.LineBasicMaterial({ color: C_GRID, transparent: true, opacity: 0.25 });
+    const link = new THREE.Line(linkGeo, linkMat);
+    link.visible = false;
+    _group.add(link);
+    _stepLinks.push(link);
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.26, 1),
+    new THREE.MeshStandardMaterial({ color: C_ACCEPT, emissive: C_ACCEPT, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(0, -0.6, 0);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onSpecdecode(j) {
+  // read honesty label VERBATIM — never upgrade
+  S.label       = (j.label || "MODELED").toUpperCase();
+  S.draftLen    = typeof j.draft_len              === "number" ? j.draft_len              : null;
+  S.trials      = typeof j.trials                 === "number" ? j.trials                 : null;
+  S.acceptRate  = typeof j.acceptance_rate        === "number" ? j.acceptance_rate        : null;
+  S.meanAccept  = typeof j.mean_accept_len        === "number" ? j.mean_accept_len        : null;
+  S.meanTokens  = typeof j.mean_tokens_per_step   === "number" ? j.mean_tokens_per_step   : null;
+  S.speedup     = typeof j.speedup_factor         === "number" ? j.speedup_factor         : null;
+  S.stepLengths = Array.isArray(j.per_step_accept_lengths) ? j.per_step_accept_lengths : null;
+  S.lossless    = typeof j.lossless               === "boolean" ? j.lossless              : null;
+
+  _updatePipeline();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the token-tree / pipeline from live data
+// =============================================================================
+function _updatePipeline() {
+  const live = S.state === "live";
+  const draftLen = live && S.draftLen ? Math.min(S.draftLen, MAX_TOKENS) : 0;
+  const steps = live && S.stepLengths && S.stepLengths.length
+    ? S.stepLengths.slice(0, MAX_STEPS)
+    : [];
+
+  for (let s = 0; s < MAX_STEPS; s++) {
+    const acceptedLen = s < steps.length ? steps[s] : -1;
+    const showStep = live && s < steps.length && draftLen > 0;
+    _stepLinks[s].visible = showStep;
+
+    for (let t = 0; t < MAX_TOKENS; t++) {
+      const mesh = _tokenMesh[s][t];
+      if (!showStep || t >= draftLen) {
+        mesh.visible = false;
+        continue;
+      }
+      mesh.visible = true;
+      const accepted = t < acceptedLen;
+      const color = accepted ? C_ACCEPT : C_REJECT;
+      mesh.material.color.setHex(color);
+      mesh.material.emissive.setHex(color);
+      mesh.material.emissiveIntensity = accepted ? 0.55 : 0.12;
+      mesh.material.opacity = accepted ? 0.95 : 0.35;
+      // rejected tokens (and everything after the first rejection) sit slightly
+      // recessed in Z to visually read as "pruned" from the accepted path.
+      mesh.position.z = accepted ? 0 : -0.35;
+    }
+  }
+
+  // spine + marker degrade to grey when not live
+  _spine.material.color.setHex(live ? C_DRAFT : C_DIM);
+  _spine.material.opacity = live ? 0.45 : 0.15;
+
+  if (_marker) {
+    if (live && S.speedup != null) {
+      _marker.material.color.setHex(C_ACCEPT);
+      _marker.material.emissive.setHex(C_ACCEPT);
+      _marker.material.opacity = 0.85;
+      // marker rides along X proportional to speedup_factor (visual "throughput" cue)
+      const x = Math.min(STEP_LEN * (MAX_STEPS - 1), (S.speedup || 1) * STEP_LEN * 0.9);
+      _marker.position.set(x, -0.6, 0);
+    } else {
+      _marker.material.color.setHex(C_DIM);
+      _marker.material.emissive.setHex(C_DIM);
+      _marker.material.opacity = 0.3;
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00009) * 0.12;
+  if (_marker) {
+    _marker.rotation.y += 0.025;
+    _marker.rotation.x += 0.012;
+    const pulse = 1.0 + 0.15 * Math.sin(t * 0.004);
+    _marker.scale.setScalar(pulse);
+  }
+}
+
+// =============================================================================
+// overlay
+// =============================================================================
+function _buildOverlay() {
+  const ctx = _ctx;
+  _overlay = document.createElement("div");
+  Object.assign(_overlay.style, {
+    position: "absolute", left: "14px", top: "14px", zIndex: "6",
+    display: "flex", flexDirection: "column", gap: "8px",
+    maxWidth: "min(94%,440px)",
+    font: "12px ui-sans-serif,system-ui,Segoe UI,Roboto,Arial",
+    color: "#eef3f6",
+  });
+
+  const h = document.createElement("div");
+  h.style.cssText = "font:600 13px ui-sans-serif,system-ui;letter-spacing:.4px";
+  h.textContent = TITLE;
+  _overlay.appendChild(h);
+
+  const sub = document.createElement("div");
+  sub.style.cssText = "color:#9fb1bf;font-size:11px;line-height:1.55";
+  sub.innerHTML =
+    'A small <b>draft</b> model proposes several tokens per step; the <b>target</b> model ' +
+    'verifies them all in one parallel pass, accepting via rejection sampling ' +
+    '(accept if p<sub>draft</sub> \u2264 p<sub>target</sub>, else w.p. p<sub>target</sub>/p<sub>draft</sub>). ' +
+    'Output distribution is <b>lossless</b> \u2014 identical to plain autoregressive decoding, just faster. ' +
+    'Honesty label <b>MODELED</b> (deterministic accept/reject simulation; NOT Medusa/EAGLE). 0 runtime CDN.';
+  _overlay.appendChild(sub);
+
+  const brow = document.createElement("div");
+  brow.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap";
+  if (_badge && _badge.el) brow.appendChild(_badge.el);
+  _overlay.appendChild(brow);
+
+  const card = document.createElement("div");
+  card.style.cssText = "background:#0a1117;border:1px solid #1d2a36;border-radius:9px;padding:9px 10px;display:flex;flex-direction:column;gap:6px";
+
+  const chead = document.createElement("div");
+  chead.style.cssText = "display:flex;align-items:center;gap:8px;flex-wrap:wrap";
+  const dot = document.createElement("span");
+  dot.style.cssText = "width:9px;height:9px;border-radius:50%;background:#3af4c8;box-shadow:0 0 7px #3af4c8";
+  const nm = document.createElement("b");
+  nm.style.cssText = "font-size:12px;color:#3af4c8;letter-spacing:.3px";
+  nm.textContent = "self-speculative decoding";
+  chead.appendChild(dot); chead.appendChild(nm);
+  card.appendChild(chead);
+
+  const grid = document.createElement("div");
+  grid.style.cssText = "display:grid;grid-template-columns:1fr;gap:4px";
+
+  function kpiRow(id, label) {
+    const r = document.createElement("div");
+    r.style.cssText = "display:flex;justify-content:space-between;gap:10px;font-size:11px";
+    const l = document.createElement("span"); l.style.cssText = "color:#9fb1bf"; l.textContent = label;
+    const v = document.createElement("b");
+    v.id = id;
+    v.style.cssText = "font-variant-numeric:tabular-nums;color:#eef3f6;text-align:right;max-width:58%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("sd-draftlen", "draft_len (\u03b3 proposed/step)"));
+  grid.appendChild(kpiRow("sd-trials",   "trials simulated"));
+  grid.appendChild(kpiRow("sd-accrate",  "acceptance_rate \u2014 MODELED"));
+  grid.appendChild(kpiRow("sd-meanacc",  "mean accepted tokens/step"));
+  grid.appendChild(kpiRow("sd-speedup",  "speedup_factor \u2014 MODELED"));
+  grid.appendChild(kpiRow("sd-lossless", "lossless?"));
+  grid.appendChild(kpiRow("sd-label",    "honesty label"));
+  card.appendChild(grid);
+
+  const fn = document.createElement("div");
+  fn.style.cssText = "font-size:9.5px;color:#6b7a86;line-height:1.5";
+  fn.textContent = "Leviathan et al. arXiv:2211.17192 (speculative decoding) \u00b7 Medusa github.com/FasterDecoding/Medusa \u00b7 EAGLE arXiv:2401.15077. MODELED \u00b7 not claimed-as.";
+  card.appendChild(fn);
+  _overlay.appendChild(card);
+
+  const pl = document.createElement("button");
+  pl.textContent = "\u25d1 what this means";
+  pl.title = "Toggle plain-language explanation for investors & consumers.";
+  pl.style.cssText = "font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid #3af4c8;background:#08140f;color:#3af4c8;cursor:pointer;width:fit-content";
+  pl.addEventListener("click", () => {
+    _plain = !_plain;
+    pl.style.background = _plain ? "#0f2a20" : "#08140f";
+    _applyPlain();
+  });
+  _overlay.appendChild(pl);
+
+  const pd = document.createElement("div");
+  pd.id = "sd-plain";
+  pd.style.cssText = "font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px;padding:7px 9px;display:none";
+  _el["plain"] = pd;
+  _overlay.appendChild(pd);
+
+  (ctx.container || document.body).appendChild(_overlay);
+  _paintOverlay();
+}
+
+function _applyPlain() {
+  const pd = _el["plain"];
+  if (!pd) return;
+  pd.style.display = _plain ? "block" : "none";
+  if (!_plain) return;
+  const g       = S.draftLen   != null ? String(S.draftLen) : "loading\u2026";
+  const accPct  = S.acceptRate != null ? (S.acceptRate * 100).toFixed(1) + "%" : "loading\u2026";
+  const speedup = S.speedup    != null ? S.speedup.toFixed(2) + "\u00d7" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Instead of generating one word at a time, a small, cheap " +
+    "\u201cdraft\u201d model quickly guesses <b>" + g + " words ahead</b>. The big \u201ctarget\u201d " +
+    "model then checks all of those guesses <i>at once</i> and keeps every guess it agrees with " +
+    "(here, about <b>" + accPct + "</b> of guesses survive). Because checking a whole batch of " +
+    "guesses costs about the same as generating one word normally, this yields roughly a <b>" +
+    speedup + " speedup</b> in tokens produced per expensive model pass \u2014 with " +
+    "<i>zero change</i> to what the model actually outputs (mathematically lossless, per " +
+    "Leviathan et al. 2023). Plain: same answer, produced faster. This view is a <b>MODELED</b> " +
+    "closed-form simulation of the accept/reject math, not a run of Medusa or EAGLE.";
+}
+
+function _tok(s) {
+  if (s === "live") return null;
+  if (s === "missing") return "NO-LIVE-DATA";
+  if (s === "degraded") return "DEGRADED";
+  if (s === "error") return "OFFLINE";
+  return "\u2026";
+}
+
+function fx(v, d) { return typeof v === "number" ? v.toFixed(d) : "\u2014"; }
+function pct(v, d) { return typeof v === "number" ? (v * 100).toFixed(d) + "%" : "\u2014"; }
+function _set(id, v) { if (_el[id]) _el[id].textContent = v; }
+
+function _paintOverlay() {
+  const t = _tok(S.state);
+  _set("sd-draftlen", t || (S.draftLen != null ? String(S.draftLen) : "\u2014"));
+  _set("sd-trials",   t || (S.trials   != null ? String(S.trials)   : "\u2014"));
+  _set("sd-accrate",  t || pct(S.acceptRate, 2));
+  _set("sd-meanacc",  t || fx(S.meanAccept, 3));
+  _set("sd-speedup",  t || (S.speedup != null ? S.speedup.toFixed(3) + "\u00d7" : "\u2014"));
+  _set("sd-lossless", t || (S.lossless === true ? "yes (rejection-sampling identity)" : S.lossless === false ? "no" : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("sd-label", t || (S.label || "MODELED"));
+  if (_plain) _applyPlain();
+}
+
+// =============================================================================
+// unmount — clean up everything; must not affect other organs
+// =============================================================================
+export function unmount() {
+  _polls.forEach((p) => { try { p.stop(); } catch (_) {} }); _polls = [];
+  try { if (_overlay && _overlay.parentNode) _overlay.parentNode.removeChild(_overlay); } catch (_) {}
+  try {
+    if (_group && _stage) {
+      _group.traverse((o) => {
+        if (o.geometry && o.geometry.dispose) o.geometry.dispose();
+        if (o.material) {
+          const ms = Array.isArray(o.material) ? o.material : [o.material];
+          ms.forEach((m) => { if (m.dispose) m.dispose(); });
+        }
+      });
+      _stage.scene.remove(_group);
+    }
+  } catch (_) {}
+  _group = _overlay = null;
+  _floor = null; _spine = null; _tokenMesh = []; _stepLinks = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.draftLen = S.trials = S.acceptRate = null;
+  S.meanAccept = S.meanTokens = S.speedup = S.stepLengths = S.lossless = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };