deploy(hf): sync szl-holdings/a11oy@main derived COPY set

Reusable Dockerfile-COPY-derived deploy from szl-holdings/a11oy main.
Files: 863 Pruned: 0
Derived from Dockerfile COPY sources (NO hand-maintained allowlist).

Signed-off-by: SZL Holdings <noreply@szlholdings.ai>
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

static/3d/holographic.html

@@ -99,6 +99,10 @@ const SURFACES = [
   { id: "pfield", title: "Pressure-Field Coordination", mod: "/static/3d/surfaces/pfield.js" },
   { id: "qhall", title: "Quantum-Inspired Hallucination UQ", mod: "/static/3d/surfaces/qhall.js" },
   { id: "aimc", title: "Analog In-Memory Attention", mod: "/static/3d/surfaces/aimc.js" },
+  { id: "ternary", title: "Ternary 1.58-bit Weights", mod: "/static/3d/surfaces/ternary.js" },
+  { id: "sement", title: "Semantic-Entropy Uncertainty", mod: "/static/3d/surfaces/sement.js" },
+  { id: "inplacettt", title: "In-Place Test-Time Training", mod: "/static/3d/surfaces/inplacettt.js" },
+  { id: "nested", title: "Nested Learning (multi-timescale)", mod: "/static/3d/surfaces/nested.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/inplacettt.js

@@ -0,0 +1,572 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/inplacettt.js — IN-PLACE TEST-TIME TRAINING (InPlaceTTT) organ for
+// the holographic frontier ring (Feng et al. 2026, ByteDance Seed + Peking
+// University — "In-Place Test-Time Training", ICLR 2026 Oral). Renders a stock
+// gated-MLP block whose EXISTING down-projection matrix W_down is re-purposed as
+// FAST WEIGHTS (updated at inference time) while W_up and W_gate stay FROZEN as
+// slow weights. A stream of token chunks flows past the block; a strictly-causal
+// 1-D convolution builds the next-token-prediction target (no future leakage),
+// and ONE gradient step per chunk mutates W_down. Two ribbons contrast the
+// running next-token loss of the ADAPTING run (W_down mutates, proof-teal —
+// FALLS) against the FROZEN-W_down control (lattice-blue — stays FLAT). A HUD
+// reads the live snapshot at /api/killinchu/v1/inplacettt/adapt. Honesty label
+// "MODELED" is read VERBATIM from the JSON and displayed as-is; never upgraded.
+//
+// Surface export shape (mirrors titans.js / kla.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint, inside payload):
+//   d_model, d_ff, vocab, chunk_size, num_chunks, learning_rate, freeze_up,
+//   freeze_gate, fast_matrix, causal_kernel, causal_offsets, causal_guard_ok,
+//   adapt_loss_start, adapt_loss_end, frozen_loss_start, frozen_loss_end,
+//   adapt_loss_drop, frozen_loss_drop, improvement, loss_curve[], w_down_delta_norm
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   In-Place Test-Time Training (mechanism simulated here):
+//     Feng, Luo, Hua, Zhang, He, Huang, Cai 2026, ByteDance Seed + Peking Univ,
+//     arXiv:2604.06169 (ICLR 2026 Oral)
+//     https://arxiv.org/abs/2604.06169
+//   Official code:
+//     https://github.com/ByteDance-Seed/In-Place-TTT
+//
+// DISTINCTNESS (scope-sensitive): vs titans (ADDS a separate memory module +
+//   params, surprise-driven) — inplacettt ADDS NO PARAMETERS, hijacks the
+//   existing W_down, and its update signal is an NTP-aligned loss. vs testtime
+//   (spends more inference COMPUTE against FROZEN weights) — inplacettt MUTATES
+//   weights (W_down is no longer frozen). Compute-allocation vs weight-mutation.
+//
+// HONESTY LABELS: MODELED (deterministic toy analytic simulation of the
+//   down-projection-as-fast-weights / NTP-aligned / causal-chunk-update
+//   mechanism; inspired-not-real; NOT the ByteDance model; toy 8-dim weights;
+//   NO 128k-context / 4B-parameter claim). Read verbatim from JSON; never
+//   upgraded here. The endpoint nests fields under `payload` and the label at
+//   the top level — this surface handles the label at top-level OR inside
+//   payload.label defensively.
+// COLOURS: lattice-blue 0x5b8dee (frozen slow weights / frozen control / spine),
+//   violet-blue 0x8a6bff (chunk stream / W_down fast-weight lattice), proof-teal
+//   0x3af4c8 (adapting run / falling loss / HUD accent), greys (frozen-flat /
+//   degraded). Purple BANNED.
+// 0 RUNTIME CDN. three.js via ctx.THREE (vendored by the 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    = "inplacettt";
+const TITLE = "In-Place Test-Time Training · W_down as Fast Weights (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 inplacettt organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/inplacettt/adapt?seed=42&chunk_size=16&learning_rate=0.2&num_chunks=24";
+
+// data-viz hues — purple BANNED
+const C_FROZEN = 0x5b8dee;  // lattice-blue (frozen slow weights / frozen control / spine)
+const C_FAST   = 0x8a6bff;  // violet-blue (W_down fast-weight lattice / chunk stream)
+const C_ADAPT  = 0x3af4c8;  // proof-teal (adapting run / falling loss / HUD accent)
+const C_FLAT   = 0x5a6570;  // grey (flat frozen loss / low activity)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const FF_COLS     = 16;     // W_down columns rendered (d_ff fast-weight cells)
+const DM_ROWS     = 8;      // W_down rows rendered (d_model)
+const LATTICE_W   = 6.0;    // world-units the W_down lattice spans along X
+const LATTICE_H   = 3.2;    // world-units the W_down lattice spans along Y
+const MAX_CURVE   = 96;     // cap on loss-curve points rendered (== payload cap)
+const CURVE_SPAN  = 12.0;   // world-units the loss ribbons span along X
+const CURVE_Y     = 4.2;    // baseline height of the loss ribbons
+
+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 _lattice    = [];                 // Array<THREE.Mesh> — W_down fast-weight cells
+let _upBar      = null;               // THREE.Mesh — frozen W_up slab
+let _gateBar    = null;               // THREE.Mesh — frozen W_gate slab
+let _adaptLine  = null;               // THREE.Line — adapting-run loss ribbon
+let _frozenLine = null;               // THREE.Line — frozen-control loss ribbon
+let _core       = null;               // THREE.Mesh — central "improvement" core
+
+// live state
+const S = {
+  label:        null,
+  dModel:       null,   // d_model
+  dFf:          null,   // d_ff
+  vocab:        null,   // vocab
+  chunkSize:    null,   // chunk_size
+  numChunks:    null,   // num_chunks
+  learningRate: null,   // learning_rate
+  freezeUp:     null,   // freeze_up
+  freezeGate:   null,   // freeze_gate
+  fastMatrix:   null,   // fast_matrix
+  causalKernel: null,   // causal_kernel[]
+  causalGuard:  null,   // causal_guard_ok
+  adaptStart:   null,   // adapt_loss_start
+  adaptEnd:     null,   // adapt_loss_end
+  frozenStart:  null,   // frozen_loss_start
+  frozenEnd:    null,   // frozen_loss_end
+  adaptDrop:    null,   // adapt_loss_drop
+  frozenDrop:   null,   // frozen_loss_drop
+  improvement:  null,   // improvement
+  curve:        null,   // loss_curve[]
+  deltaNorm:    null,   // w_down_delta_norm
+  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(0, 8, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 2.0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildFrozenSlabs();
+  _buildLattice();
+  _buildLossRibbons();
+  _buildCore();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onAdapt, { 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(44, 44, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// Two FROZEN slow-weight slabs (W_up, W_gate) — rendered lattice-blue and held
+// static: they never change colour or scale from live data (they are frozen).
+function _buildFrozenSlabs() {
+  const THREE = _THREE;
+  const geo = new THREE.BoxGeometry(1.4, 2.4, 0.35);
+  _upBar = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_FROZEN, emissive: C_FROZEN, emissiveIntensity: 0.14, transparent: true, opacity: 0.55 }),
+  );
+  _upBar.position.set(-4.8, 1.4, 0);
+  _group.add(_upBar);
+
+  _gateBar = new THREE.Mesh(
+    geo,
+    new THREE.MeshStandardMaterial({ color: C_FROZEN, emissive: C_FROZEN, emissiveIntensity: 0.14, transparent: true, opacity: 0.55 }),
+  );
+  _gateBar.position.set(-4.8, 1.4, -1.1);
+  _group.add(_gateBar);
+}
+
+// The W_down FAST-WEIGHT lattice: a d_model x d_ff grid of cells. Pre-allocated;
+// cell brightness/scale animate as W_down "adapts" (driven by w_down_delta_norm
+// and the adapting-run loss drop). Violet-blue at rest, warms to proof-teal as
+// the fast weights move.
+function _buildLattice() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.BoxGeometry(0.26, 0.26, 0.26);
+  for (let r = 0; r < DM_ROWS; r++) {
+    for (let c = 0; c < FF_COLS; c++) {
+      const x = -LATTICE_W / 2 + (c / (FF_COLS - 1)) * LATTICE_W;
+      const y = 0.6 + (r / (DM_ROWS - 1)) * LATTICE_H;
+      const mesh = new THREE.Mesh(
+        cellGeo,
+        new THREE.MeshStandardMaterial({ color: C_FAST, emissive: C_FAST, emissiveIntensity: 0.18, transparent: true, opacity: 0.0 }),
+      );
+      mesh.position.set(x, y, 1.4);
+      mesh.visible = false;
+      _group.add(mesh);
+      _lattice.push(mesh);
+    }
+  }
+}
+
+// Two loss ribbons over the chunk axis: adapting (proof-teal, should FALL) and
+// frozen control (grey/lattice-blue, should stay FLAT). Pre-allocated as Lines
+// with MAX_CURVE points; positions rewritten in-place from live loss_curve.
+function _buildLossRibbons() {
+  const THREE = _THREE;
+
+  function mkLine(color) {
+    const pts = [];
+    for (let i = 0; i < MAX_CURVE; i++) {
+      const x = -CURVE_SPAN / 2 + (i / (MAX_CURVE - 1)) * CURVE_SPAN;
+      pts.push(new THREE.Vector3(x, CURVE_Y, -3.0));
+    }
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: color, transparent: true, opacity: 0.85 });
+    const line = new THREE.Line(geo, mat);
+    line.visible = false;
+    _group.add(line);
+    return line;
+  }
+
+  _adaptLine  = mkLine(C_ADAPT);
+  _frozenLine = mkLine(C_FLAT);
+}
+
+function _buildCore() {
+  const THREE = _THREE;
+  _core = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.7, 1),
+    new THREE.MeshStandardMaterial({ color: C_ADAPT, emissive: C_ADAPT, emissiveIntensity: 0.45, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _core.position.set(0, 0.6, 0);
+  _group.add(_core);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onAdapt(j) {
+  // The endpoint nests its metrics under `payload`; the honesty label may sit
+  // at the TOP LEVEL or (defensively) inside payload.label. Read it VERBATIM
+  // from wherever it is — never upgrade.
+  const p = (j && typeof j.payload === "object" && j.payload) ? j.payload : j;
+  const rawLabel = (j && j.label) || (p && p.label) || "MODELED";
+  S.label        = String(rawLabel).toUpperCase();
+
+  S.dModel       = typeof p.d_model           === "number" ? p.d_model           : null;
+  S.dFf          = typeof p.d_ff              === "number" ? p.d_ff              : null;
+  S.vocab        = typeof p.vocab             === "number" ? p.vocab             : null;
+  S.chunkSize    = typeof p.chunk_size        === "number" ? p.chunk_size        : null;
+  S.numChunks    = typeof p.num_chunks        === "number" ? p.num_chunks        : null;
+  S.learningRate = typeof p.learning_rate     === "number" ? p.learning_rate     : null;
+  S.freezeUp     = typeof p.freeze_up         === "boolean" ? p.freeze_up        : null;
+  S.freezeGate   = typeof p.freeze_gate       === "boolean" ? p.freeze_gate      : null;
+  S.fastMatrix   = typeof p.fast_matrix       === "string"  ? p.fast_matrix      : null;
+  S.causalKernel = Array.isArray(p.causal_kernel)          ? p.causal_kernel     : null;
+  S.causalGuard  = typeof p.causal_guard_ok   === "boolean" ? p.causal_guard_ok  : null;
+  S.adaptStart   = typeof p.adapt_loss_start  === "number" ? p.adapt_loss_start  : null;
+  S.adaptEnd     = typeof p.adapt_loss_end    === "number" ? p.adapt_loss_end    : null;
+  S.frozenStart  = typeof p.frozen_loss_start === "number" ? p.frozen_loss_start : null;
+  S.frozenEnd    = typeof p.frozen_loss_end   === "number" ? p.frozen_loss_end   : null;
+  S.adaptDrop    = typeof p.adapt_loss_drop   === "number" ? p.adapt_loss_drop   : null;
+  S.frozenDrop   = typeof p.frozen_loss_drop  === "number" ? p.frozen_loss_drop  : null;
+  S.improvement  = typeof p.improvement       === "number" ? p.improvement       : null;
+  S.curve        = Array.isArray(p.loss_curve)             ? p.loss_curve        : null;
+  S.deltaNorm    = typeof p.w_down_delta_norm === "number" ? p.w_down_delta_norm : null;
+
+  _updateGeometry();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the lattice + ribbons from live data
+// =============================================================================
+function _updateGeometry() {
+  const live = S.state === "live";
+
+  // frozen slow-weight slabs: always lattice-blue when live, grey when not —
+  // and NEVER animated (they are frozen; that is the point).
+  [_upBar, _gateBar].forEach((bar) => {
+    if (!bar) return;
+    const col = live ? C_FROZEN : C_DIM;
+    bar.material.color.setHex(col);
+    bar.material.emissive.setHex(col);
+    bar.material.opacity = live ? 0.55 : 0.22;
+  });
+
+  // W_down fast-weight lattice: activity scales with the total weight movement
+  // (w_down_delta_norm) and the adapting-run loss drop. Cells warm from
+  // violet-blue toward proof-teal as the fast weights adapt.
+  const delta = live && S.deltaNorm != null ? S.deltaNorm : 0;
+  const drop  = live && S.adaptDrop != null ? Math.max(0, S.adaptDrop) : 0;
+  const warm  = Math.min(1, drop * 60);          // how "teal" (adapted) the lattice looks
+  const act   = Math.min(1, delta / 2.0);        // overall movement intensity
+  for (let i = 0; i < _lattice.length; i++) {
+    const mesh = _lattice[i];
+    if (!live) { mesh.visible = false; continue; }
+    mesh.visible = true;
+    // deterministic per-cell phase so the lattice shimmers coherently
+    const adapted = ((i * 2654435761) % 1000) / 1000 < warm;
+    const col = adapted ? C_ADAPT : C_FAST;
+    mesh.material.color.setHex(col);
+    mesh.material.emissive.setHex(col);
+    mesh.material.emissiveIntensity = 0.18 + 0.5 * act + (adapted ? 0.25 : 0);
+    mesh.material.opacity = 0.35 + 0.5 * act;
+    mesh.scale.setScalar(0.8 + 0.5 * act + (adapted ? 0.25 : 0));
+  }
+
+  // loss ribbons: map the live loss_curve onto the two Lines. Adapting should
+  // slope DOWN; frozen should be FLAT. We normalise both against a shared range.
+  const curve = live && S.curve && S.curve.length ? S.curve.slice(0, MAX_CURVE) : [];
+  if (curve.length && _adaptLine && _frozenLine) {
+    let lo = Infinity, hi = -Infinity;
+    for (const c of curve) {
+      const a = typeof c.adapt_loss === "number" ? c.adapt_loss : 0;
+      const f = typeof c.frozen_loss === "number" ? c.frozen_loss : 0;
+      lo = Math.min(lo, a, f); hi = Math.max(hi, a, f);
+    }
+    const rng = hi - lo || 1;
+    _writeRibbon(_adaptLine, curve, "adapt_loss", lo, rng, -2.6);
+    _writeRibbon(_frozenLine, curve, "frozen_loss", lo, rng, -3.4);
+    _adaptLine.visible = true;
+    _frozenLine.visible = true;
+    _adaptLine.material.color.setHex(C_ADAPT);
+    _frozenLine.material.color.setHex(C_FLAT);
+  } else {
+    if (_adaptLine) _adaptLine.visible = false;
+    if (_frozenLine) _frozenLine.visible = false;
+  }
+
+  // central core: size/colour reflect the adapting advantage (improvement)
+  if (_core) {
+    if (live && S.improvement != null) {
+      _core.material.color.setHex(C_ADAPT);
+      _core.material.emissive.setHex(C_ADAPT);
+      _core.material.opacity = 0.85;
+      _core.scale.setScalar(0.8 + Math.max(0, S.improvement) * 40);
+    } else {
+      _core.material.color.setHex(C_DIM);
+      _core.material.emissive.setHex(C_DIM);
+      _core.material.opacity = 0.3;
+      _core.scale.setScalar(0.8);
+    }
+  }
+}
+
+function _writeRibbon(line, curve, key, lo, rng, z) {
+  const pos = line.geometry.attributes.position;
+  const n = Math.min(curve.length, MAX_CURVE);
+  for (let i = 0; i < MAX_CURVE; i++) {
+    const src = i < n ? curve[i] : curve[n - 1];
+    const v = src && typeof src[key] === "number" ? src[key] : lo;
+    const norm = (v - lo) / rng;                 // 0 (best) .. 1 (worst)
+    const x = -CURVE_SPAN / 2 + (i / (MAX_CURVE - 1)) * CURVE_SPAN;
+    const y = CURVE_Y + (1 - norm) * 2.2;        // lower loss -> higher ribbon
+    pos.setXYZ(i, x, y, z);
+  }
+  pos.needsUpdate = true;
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.14;
+  if (_core) {
+    _core.rotation.y += 0.02;
+    _core.rotation.x += 0.009;
+    const pulse = 1.0 + 0.12 * Math.sin(t * 0.0035);
+    const base = (S.state === "live" && S.improvement != null) ? (0.8 + Math.max(0, S.improvement) * 40) : 0.8;
+    _core.scale.setScalar(base * pulse);
+  }
+  // gentle shimmer on the fast-weight lattice (the weights are "moving")
+  if (_lattice.length && S.state === "live") {
+    const a = 0.5 + 0.5 * Math.sin(t * 0.002);
+    for (let i = 0; i < _lattice.length; i += 7) {
+      const m = _lattice[i];
+      if (m && m.visible) m.material.emissiveIntensity = 0.2 + 0.4 * a;
+    }
+  }
+}
+
+// =============================================================================
+// 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%,460px)",
+    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 =
+    'Test-time adaptation with <b>no new module</b>: a stock MLP block\u2019s existing ' +
+    '<b>down-projection W_down</b> is re-purposed as <b>fast weights</b> (updated at inference), ' +
+    'while <b>W_up / W_gate stay frozen</b>. The update target is built by a <b>strictly-causal</b> ' +
+    '1-D convolution over past tokens (no future leakage), and one gradient step runs <b>per chunk</b>. ' +
+    'The <b>adapting</b> run\u2019s next-token loss <b>falls</b>; the <b>frozen-W_down control</b> stays <b>flat</b>. ' +
+    'Honesty label <b>MODELED</b> (inspired-not-real toy simulation; NOT the ByteDance model). 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 = "in-place test-time training";
+  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("ip-fast",   "fast weights (mutated)"));
+  grid.appendChild(kpiRow("ip-frozen", "frozen slow weights"));
+  grid.appendChild(kpiRow("ip-chunks", "chunks \u00d7 chunk_size"));
+  grid.appendChild(kpiRow("ip-lr",     "learning_rate (per chunk)"));
+  grid.appendChild(kpiRow("ip-causal", "causal guard (no future leak)"));
+  grid.appendChild(kpiRow("ip-adapt",  "adapt loss (start \u2192 end) \u2014 MODELED"));
+  grid.appendChild(kpiRow("ip-frozenl","frozen-control loss (flat)"));
+  grid.appendChild(kpiRow("ip-improve","improvement (adapting advantage)"));
+  grid.appendChild(kpiRow("ip-delta",  "W_down movement (L1)"));
+  grid.appendChild(kpiRow("ip-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 = "Feng et al. 2026 (ByteDance Seed + Peking Univ) \u00b7 In-Place Test-Time Training \u00b7 arXiv:2604.06169 (ICLR 2026 Oral) \u00b7 github.com/ByteDance-Seed/In-Place-TTT. MODELED \u00b7 inspired-not-real \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 = "ip-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 chunks = S.numChunks   != null ? String(S.numChunks) : "loading\u2026";
+  const aS = S.adaptStart != null ? S.adaptStart.toFixed(4) : "loading\u2026";
+  const aE = S.adaptEnd   != null ? S.adaptEnd.toFixed(4)   : "loading\u2026";
+  const fE = S.frozenEnd  != null ? S.frozenEnd.toFixed(4)  : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Normally an AI model\u2019s weights are <b>frozen</b> once training ends \u2014 " +
+    "it can\u2019t learn anything new while it answers you. In-Place Test-Time Training lets the model " +
+    "keep learning <i>as it reads</i>, <b>without bolting on any new part</b>: it quietly re-uses one " +
+    "matrix it already has (the <b>down-projection W_down</b>) as a scratchpad it\u2019s allowed to nudge, " +
+    "while the rest of the block stays fixed. To decide how to nudge it, the model looks only at what " +
+    "it has <b>already seen</b> (a strict <b>no-peeking-at-the-future</b> rule) and takes one small step " +
+    "per chunk of text. Over <b>" + chunks + "</b> chunks its next-word error <b>drops from " + aS + " to " + aE + "</b>, " +
+    "while an identical copy whose W_down is <b>kept frozen</b> stays flat at <b>" + fE + "</b>. " +
+    "<br><br><b>Inspired-not-real:</b> this view is a <b>MODELED</b> toy simulation of that mechanism " +
+    "\u2014 random toy weights, an 8-dimension hidden state and a tiny synthetic sequence. It is <b>NOT the " +
+    "ByteDance model</b> and does <b>NOT</b> reproduce the paper\u2019s 128k-context or 4B-parameter results; " +
+    "the loss drop is a qualitative demonstration on a controlled stream, not a benchmark claim. " +
+    "(Different from <b>titans</b>, which adds a whole new memory module, and from <b>testtime</b>, which " +
+    "just spends more compute without changing any weights \u2014 here an existing weight actually moves.)";
+}
+
+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("ip-fast",   t || (S.fastMatrix ? S.fastMatrix + " (fast)" : "W_down (fast)"));
+  _set("ip-frozen", t || ((S.freezeUp || S.freezeGate) ? "W_up + W_gate \u2014 frozen" : "\u2014"));
+  _set("ip-chunks", t || (S.numChunks != null && S.chunkSize != null ? S.numChunks + " \u00d7 " + S.chunkSize : "\u2014"));
+  _set("ip-lr",     t || fx(S.learningRate, 3));
+  _set("ip-causal", t || (S.causalGuard === true ? "OK \u2014 past-only" : (S.causalGuard === false ? "VIOLATION" : "\u2014")));
+  _set("ip-adapt",  t || (S.adaptStart != null && S.adaptEnd != null
+        ? fx(S.adaptStart, 4) + " \u2192 " + fx(S.adaptEnd, 4)
+        : "\u2014"));
+  _set("ip-frozenl", t || (S.frozenEnd != null
+        ? fx(S.frozenEnd, 4) + (S.frozenDrop != null ? " (\u0394 " + fx(S.frozenDrop, 4) + ")" : "")
+        : "\u2014"));
+  _set("ip-improve", t || (S.improvement != null ? "+" + fx(S.improvement, 4) : "\u2014"));
+  _set("ip-delta",  t || fx(S.deltaNorm, 3));
+  // honesty label verbatim — never upgraded
+  _set("ip-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; _lattice = []; _upBar = null; _gateBar = null;
+  _adaptLine = null; _frozenLine = null; _core = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.dModel = S.dFf = S.vocab = null;
+  S.chunkSize = S.numChunks = S.learningRate = null;
+  S.freezeUp = S.freezeGate = S.fastMatrix = S.causalKernel = S.causalGuard = null;
+  S.adaptStart = S.adaptEnd = S.frozenStart = S.frozenEnd = null;
+  S.adaptDrop = S.frozenDrop = S.improvement = S.curve = S.deltaNorm = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/nested.js

@@ -0,0 +1,545 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/nested.js — NESTED LEARNING / CONTINUUM MEMORY SYSTEM ("Hope")
+// organ for the holographic frontier ring (Behrouz, Razaviyayn, Zhong &
+// Mirrokni, Google Research, NeurIPS 2025 — "the illusion of deep learning
+// architectures"). Renders a THREE-TIER PLASTICITY LADDER of memory levels at
+// different update clocks (fast k=1, medium k=8, slow k=64), fed by a streaming
+// toy continual-learning task-block sequence. A HUD contrasts the FORGETTING
+// CURVE of task A for a single-clock baseline vs the multi-timescale CMS
+// schedule from the live snapshot at /api/killinchu/v1/nested/schedule. The
+// slow "core" (protected by a surprise gate) glows proof-teal as it retains
+// early tasks; the always-on baseline overwrites and forgets (grey). Honesty
+// label "MODELED" is read VERBATIM from the JSON and displayed as-is; never
+// upgraded.
+//
+// Surface export shape (mirrors titans.js / episodic.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint, inside payload):
+//   num_tasks, block_len, n_tokens, k_fast, k_med, k_slow, gate, levels[],
+//   taskA_baseline[], taskA_cms[], retainedA_baseline, retainedA_cms,
+//   retention_delta, mean_retention_delta, slow_writes_cms,
+//   slow_writes_baseline, mean_surprise, peak_surprise, momentum, forget_curve[]
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Nested Learning: The Illusion of Deep Learning Architectures (the paradigm,
+//   Continuum Memory System, and "Hope" proof-of-concept simulated here):
+//     Behrouz, Razaviyayn, Zhong & Mirrokni 2025, Google Research, NeurIPS 2025
+//     https://arxiv.org/abs/2512.24695
+//   Google Research blog — Introducing Nested Learning (official announcement):
+//     https://research.google/blog/introducing-nested-learning-a-new-ml-paradigm-for-continual-learning/
+//
+// HONESTY LABELS: MODELED (deterministic re-implementation of the multi-
+//   timescale update-scheduling + optimizer-as-memory arithmetic; NOT the Hope
+//   architecture; NEVER-CLAIMED-AS a trained model). Independent-ablation
+//   nuance: the NeurIPS paper was noted in public commentary to lack full
+//   ablations in its first version, so this demonstrates the SCHEDULING
+//   MECHANISM reduces forgetting on a controlled toy stream — NOT reproducing
+//   Hope's benchmark wins. Read verbatim from JSON; never upgraded here. The
+//   endpoint nests its fields under `payload`, with the label at the top level —
+//   this surface handles the label at top-level OR inside payload.label
+//   defensively.
+// COLOURS: lattice-blue 0x5b8dee (fast level / task stream / spine), violet-blue
+//   0x8a6bff (medium level / clock ring), proof-teal 0x3af4c8 (protected slow
+//   core / retention / HUD accent), greys (forgotten / degraded state). Purple
+//   BANNED.
+// 0 RUNTIME CDN. three.js via ctx.THREE (vendored by the 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    = "nested";
+const TITLE = "Nested Learning · Continuum Memory System (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 nested organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/nested/schedule?seed=42&num_tasks=6&k_fast=1&k_med=8&k_slow=64&gate=0.15";
+
+// data-viz hues — purple BANNED
+const C_FAST    = 0x5b8dee;  // lattice-blue (fast level / task stream / spine)
+const C_MED     = 0x8a6bff;  // violet-blue (medium level / clock ring)
+const C_SLOW    = 0x3af4c8;  // proof-teal (protected slow core / retention / HUD accent)
+const C_FORGET  = 0x5a6570;  // grey (forgotten / overwritten baseline point)
+const C_DIM     = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID    = 0x1b3a44;  // floor / link colour
+
+// layout geometry
+const LEVEL_Y     = [0.7, 2.2, 3.7];  // y of fast / med / slow tiers (bottom -> top)
+const LEVEL_R     = [1.4, 2.6, 3.8];  // ring radius of each tier
+const RING_SEG    = 64;                // ring outline segments
+const MAX_BLOCKS  = 96;                // cap on forgetting-curve markers rendered
+const CURVE_SPAN  = 12.0;              // world-units the forgetting curve spans along X
+
+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 _rings      = [];                 // Array<THREE.LineLoop> — one clock ring per level
+let _tiers      = [];                 // Array<THREE.Mesh> — the three memory-level nodes
+let _baseMarks  = [];                 // Array<THREE.Mesh> — baseline forgetting-curve markers
+let _cmsMarks   = [];                 // Array<THREE.Mesh> — CMS forgetting-curve markers
+let _core       = null;               // THREE.Mesh — central slow-core "retention" node
+
+// live state
+const S = {
+  label:        null,
+  numTasks:     null,   // num_tasks
+  blockLen:     null,   // block_len
+  nTokens:      null,   // n_tokens
+  kFast:        null,   // k_fast
+  kMed:         null,   // k_med
+  kSlow:        null,   // k_slow
+  gate:         null,   // gate
+  taskABase:    null,   // taskA_baseline[]
+  taskACms:     null,   // taskA_cms[]
+  retainBase:   null,   // retainedA_baseline
+  retainCms:    null,   // retainedA_cms
+  retDelta:     null,   // retention_delta
+  meanDelta:    null,   // mean_retention_delta
+  slowWritesCms:  null, // slow_writes_cms
+  slowWritesBase: null, // slow_writes_baseline
+  meanSurprise: null,   // mean_surprise
+  peakSurprise: null,   // peak_surprise
+  momentum:     null,   // momentum
+  curve:        null,   // forget_curve[]
+  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(0, 8, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 2.0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildLadder();
+  _buildCurve();
+  _buildCore();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onNested, { 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(44, 44, C_GRID, 0x0f2027);
+  grid.material.opacity = 0.18; grid.material.transparent = true; grid.position.y = -0.01;
+  _group.add(grid);
+  _floor = grid;
+}
+
+// The plasticity LADDER: three stacked clock rings (fast/med/slow) each with a
+// central level node. Higher rings = slower clocks = more protected memory.
+function _buildLadder() {
+  const THREE = _THREE;
+  const cols = [C_FAST, C_MED, C_SLOW];
+
+  for (let lvl = 0; lvl < 3; lvl++) {
+    const r = LEVEL_R[lvl];
+    const y = LEVEL_Y[lvl];
+
+    // clock ring outline
+    const pts = [];
+    for (let i = 0; i <= RING_SEG; i++) {
+      const a = (i / RING_SEG) * Math.PI * 2;
+      pts.push(new THREE.Vector3(Math.cos(a) * r, y, Math.sin(a) * r));
+    }
+    const geo = new THREE.BufferGeometry().setFromPoints(pts);
+    const mat = new THREE.LineBasicMaterial({ color: cols[lvl], transparent: true, opacity: 0.4 });
+    const ring = new THREE.LineLoop(geo, mat);
+    _group.add(ring);
+    _rings.push(ring);
+
+    // level node (the memory level itself)
+    const node = new THREE.Mesh(
+      new THREE.OctahedronGeometry(0.34, 0),
+      new THREE.MeshStandardMaterial({ color: cols[lvl], emissive: cols[lvl], emissiveIntensity: 0.3, transparent: true, opacity: 0.85 }),
+    );
+    node.position.set(0, y, 0);
+    _group.add(node);
+    _tiers.push(node);
+  }
+}
+
+// Two rows of forgetting-curve markers streaming along X: task-A accuracy after
+// each task block for the single-clock baseline (front row) and the multi-
+// timescale CMS schedule (back row). Height encodes retained accuracy.
+function _buildCurve() {
+  const THREE = _THREE;
+  const mGeo = new THREE.SphereGeometry(0.13, 8, 8);
+  for (let i = 0; i < MAX_BLOCKS; i++) {
+    const x = -CURVE_SPAN / 2 + (i / (MAX_BLOCKS - 1)) * CURVE_SPAN;
+
+    const b = new THREE.Mesh(
+      mGeo,
+      new THREE.MeshStandardMaterial({ color: C_FORGET, emissive: C_FORGET, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+    );
+    b.position.set(x, 0.2, 2.4);
+    b.visible = false;
+    _group.add(b);
+    _baseMarks.push(b);
+
+    const c = new THREE.Mesh(
+      mGeo,
+      new THREE.MeshStandardMaterial({ color: C_SLOW, emissive: C_SLOW, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+    );
+    c.position.set(x, 0.2, -2.4);
+    c.visible = false;
+    _group.add(c);
+    _cmsMarks.push(c);
+  }
+}
+
+function _buildCore() {
+  const THREE = _THREE;
+  _core = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.6, 1),
+    new THREE.MeshStandardMaterial({ color: C_SLOW, emissive: C_SLOW, emissiveIntensity: 0.45, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _core.position.set(0, LEVEL_Y[2], 0);
+  _group.add(_core);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onNested(j) {
+  // The endpoint nests its metrics under `payload`; the honesty label may sit at
+  // the TOP LEVEL or (defensively) inside payload.label. Read it VERBATIM from
+  // wherever it is — never upgrade.
+  const p = (j && typeof j.payload === "object" && j.payload) ? j.payload : j;
+  const rawLabel = (j && j.label) || (p && p.label) || "MODELED";
+  S.label        = String(rawLabel).toUpperCase();
+
+  S.numTasks     = typeof p.num_tasks   === "number" ? p.num_tasks   : null;
+  S.blockLen     = typeof p.block_len   === "number" ? p.block_len   : null;
+  S.nTokens      = typeof p.n_tokens    === "number" ? p.n_tokens    : null;
+  S.kFast        = typeof p.k_fast      === "number" ? p.k_fast      : null;
+  S.kMed         = typeof p.k_med       === "number" ? p.k_med       : null;
+  S.kSlow        = typeof p.k_slow      === "number" ? p.k_slow      : null;
+  S.gate         = typeof p.gate        === "number" ? p.gate        : null;
+  S.retainBase   = typeof p.retainedA_baseline === "number" ? p.retainedA_baseline : null;
+  S.retainCms    = typeof p.retainedA_cms      === "number" ? p.retainedA_cms      : null;
+  S.retDelta     = typeof p.retention_delta    === "number" ? p.retention_delta    : null;
+  S.meanDelta    = typeof p.mean_retention_delta === "number" ? p.mean_retention_delta : null;
+  S.slowWritesCms  = typeof p.slow_writes_cms      === "number" ? p.slow_writes_cms      : null;
+  S.slowWritesBase = typeof p.slow_writes_baseline === "number" ? p.slow_writes_baseline : null;
+  S.meanSurprise = typeof p.mean_surprise === "number" ? p.mean_surprise : null;
+  S.peakSurprise = typeof p.peak_surprise === "number" ? p.peak_surprise : null;
+  S.momentum     = typeof p.momentum      === "number" ? p.momentum      : null;
+  S.taskABase    = Array.isArray(p.taskA_baseline) ? p.taskA_baseline : null;
+  S.taskACms     = Array.isArray(p.taskA_cms)      ? p.taskA_cms      : null;
+  S.curve        = Array.isArray(p.forget_curve)   ? p.forget_curve   : null;
+
+  _updateScene();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — drives the ladder + forgetting curve from live data
+// =============================================================================
+function _updateScene() {
+  const live = S.state === "live";
+  const cols = [C_FAST, C_MED, C_SLOW];
+
+  // clock rings + level nodes degrade to grey when not live
+  for (let lvl = 0; lvl < 3; lvl++) {
+    const ring = _rings[lvl];
+    if (ring) {
+      ring.material.color.setHex(live ? cols[lvl] : C_DIM);
+      ring.material.opacity = live ? 0.4 : 0.12;
+    }
+    const node = _tiers[lvl];
+    if (node) {
+      const c = live ? cols[lvl] : C_FORGET;
+      node.material.color.setHex(c);
+      node.material.emissive.setHex(c);
+      node.material.emissiveIntensity = live ? 0.35 : 0.08;
+      node.material.opacity = live ? 0.9 : 0.25;
+    }
+  }
+
+  // forgetting-curve markers: height = retained task-A accuracy per block.
+  const base = live && S.taskABase && S.taskABase.length ? S.taskABase.slice(0, MAX_BLOCKS) : [];
+  const cms  = live && S.taskACms  && S.taskACms.length  ? S.taskACms.slice(0, MAX_BLOCKS)  : [];
+  const n = Math.max(base.length, cms.length);
+  for (let i = 0; i < MAX_BLOCKS; i++) {
+    const bm = _baseMarks[i];
+    const cm = _cmsMarks[i];
+    if (!live || i >= n) { bm.visible = false; cm.visible = false; continue; }
+
+    if (i < base.length) {
+      const a = base[i];
+      bm.visible = true;
+      bm.position.y = 0.2 + a * 3.2;
+      // baseline that has forgotten (low retention) fades to grey
+      const c = a >= 0.5 ? C_FAST : C_FORGET;
+      bm.material.color.setHex(c);
+      bm.material.emissive.setHex(c);
+      bm.material.emissiveIntensity = 0.2 + 0.5 * a;
+      bm.material.opacity = 0.35 + 0.55 * a;
+      bm.scale.setScalar(0.7 + 0.7 * a);
+    } else { bm.visible = false; }
+
+    if (i < cms.length) {
+      const a = cms[i];
+      cm.visible = true;
+      cm.position.y = 0.2 + a * 3.2;
+      cm.material.color.setHex(C_SLOW);
+      cm.material.emissive.setHex(C_SLOW);
+      cm.material.emissiveIntensity = 0.25 + 0.6 * a;
+      cm.material.opacity = 0.4 + 0.55 * a;
+      cm.scale.setScalar(0.7 + 0.7 * a);
+    } else { cm.visible = false; }
+  }
+
+  // slow core: size/brightness reflect how much of task A the protected core
+  // retains (retainedA_cms), and pulse brighter with the retention advantage.
+  if (_core) {
+    if (live && S.retainCms != null) {
+      _core.material.color.setHex(C_SLOW);
+      _core.material.emissive.setHex(C_SLOW);
+      _core.material.opacity = 0.85;
+      _core.scale.setScalar(0.6 + S.retainCms * 1.0);
+    } else {
+      _core.material.color.setHex(C_DIM);
+      _core.material.emissive.setHex(C_DIM);
+      _core.material.opacity = 0.3;
+      _core.scale.setScalar(0.6);
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.00008) * 0.14;
+  // rings spin at their own clock rate — fast ring spins fastest
+  if (_rings[0]) _rings[0].rotation.y += 0.010;
+  if (_rings[1]) _rings[1].rotation.y += 0.0035;
+  if (_rings[2]) _rings[2].rotation.y += 0.0009;
+  if (_core) {
+    _core.rotation.y += 0.02;
+    _core.rotation.x += 0.009;
+    const pulse = 1.0 + 0.12 * Math.sin(t * 0.0035);
+    const base = (S.state === "live" && S.retainCms != null) ? (0.6 + S.retainCms * 1.0) : 0.6;
+    _core.scale.setScalar(base * 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%,460px)",
+    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 model as a stack of memory levels updating at <b>different clocks</b> (fast/medium/slow), with ' +
+    'the <b>optimizer itself as associative memory</b>. On a toy continual-learning stream, the slow ' +
+    '<b>protected core</b> (a surprise-gated timescale) <b>retains earlier tasks</b> where a single-clock ' +
+    'baseline overwrites and <b>forgets</b> them. ' +
+    'Honesty label <b>MODELED</b> (deterministic scheduling simulation; NOT the Hope architecture). 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 = "nested learning / continuum memory system";
+  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("ne-tasks",   "continual-learning tasks"));
+  grid.appendChild(kpiRow("ne-clocks",  "clocks k_fast / k_med / k_slow"));
+  grid.appendChild(kpiRow("ne-gate",    "slow-core surprise gate"));
+  grid.appendChild(kpiRow("ne-retbase", "task-A retained \u2014 single-clock"));
+  grid.appendChild(kpiRow("ne-retcms",  "task-A retained \u2014 CMS (MODELED)"));
+  grid.appendChild(kpiRow("ne-delta",   "retention gain (CMS \u2212 baseline)"));
+  grid.appendChild(kpiRow("ne-writes",  "slow-core writes CMS / baseline"));
+  grid.appendChild(kpiRow("ne-surprise","mean / peak surprise"));
+  grid.appendChild(kpiRow("ne-momentum","momentum (optimizer-as-memory)"));
+  grid.appendChild(kpiRow("ne-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 = "Behrouz, Razaviyayn, Zhong & Mirrokni 2025 (Google Research) \u00b7 Nested Learning: The Illusion of Deep Learning Architectures \u00b7 NeurIPS 2025 \u00b7 arXiv:2512.24695 \u00b7 research.google/blog Nested Learning. 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 = "ne-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 rBase = S.retainBase != null ? (S.retainBase * 100).toFixed(0) + "%" : "loading\u2026";
+  const rCms  = S.retainCms  != null ? (S.retainCms  * 100).toFixed(0) + "%" : "loading\u2026";
+  const dPct  = S.retDelta   != null ? "+" + (S.retDelta * 100).toFixed(0) + " points" : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> When an AI learns a new skill it often <b>forgets the old one</b> " +
+    "(\u201ccatastrophic forgetting\u201d). Nested Learning treats the model as a <b>stack of memories that " +
+    "update at different speeds</b> \u2014 a fast one that chases whatever it is learning right now, and " +
+    "slower ones that only commit knowledge once it has <b>settled</b>. The slowest \u201ccore\u201d is " +
+    "<b>protected</b>: it refuses to overwrite itself during the noisy middle of learning something new. " +
+    "Here we teach it several small tasks in a row and then check how much of the <b>first</b> task it still " +
+    "remembers. A plain single-speed model keeps only about <b>" + rBase + "</b> of task A, while the " +
+    "multi-speed schedule keeps about <b>" + rCms + "</b> \u2014 a gain of roughly <b>" + dPct + "</b> less " +
+    "forgetting on this toy stream. " +
+    "<b>Honest caveat:</b> this is a <b>MODELED</b> toy simulation of the scheduling idea (tiny linear " +
+    "tasks, hand-set clocks), <b>not the \u201cHope\u201d model</b>. The paper was noted publicly to lack full " +
+    "ablations in its first version, so this only shows the <b>scheduling mechanism</b> reduces forgetting " +
+    "on a controlled stream \u2014 it does <b>not</b> reproduce Hope's language-modeling or needle-in-haystack " +
+    "results or its claimed wins over Titans / Transformers.";
+}
+
+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("ne-tasks",   t || (S.numTasks != null ? String(S.numTasks) : "\u2014"));
+  _set("ne-clocks",  t || (S.kFast != null || S.kMed != null || S.kSlow != null
+        ? (S.kFast != null ? String(S.kFast) : "\u2014") + " / " +
+          (S.kMed  != null ? String(S.kMed)  : "\u2014") + " / " +
+          (S.kSlow != null ? String(S.kSlow) : "\u2014")
+        : "\u2014"));
+  _set("ne-gate",    t || fx(S.gate, 3));
+  _set("ne-retbase", t || pct(S.retainBase, 1));
+  _set("ne-retcms",  t || pct(S.retainCms, 1));
+  _set("ne-delta",   t || (S.retDelta != null ? "+" + (S.retDelta * 100).toFixed(1) + "%" : "\u2014"));
+  _set("ne-writes",  t || (S.slowWritesCms != null || S.slowWritesBase != null
+        ? (S.slowWritesCms != null ? String(S.slowWritesCms) : "\u2014") + " / " +
+          (S.slowWritesBase != null ? String(S.slowWritesBase) : "\u2014")
+        : "\u2014"));
+  _set("ne-surprise", t || (S.meanSurprise != null || S.peakSurprise != null
+        ? fx(S.meanSurprise, 3) + " / " + fx(S.peakSurprise, 3)
+        : "\u2014"));
+  _set("ne-momentum", t || fx(S.momentum, 2));
+  // honesty label verbatim — never upgraded
+  _set("ne-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; _rings = []; _tiers = []; _baseMarks = []; _cmsMarks = []; _core = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.numTasks = S.blockLen = S.nTokens = null;
+  S.kFast = S.kMed = S.kSlow = S.gate = null;
+  S.taskABase = S.taskACms = null;
+  S.retainBase = S.retainCms = S.retDelta = S.meanDelta = null;
+  S.slowWritesCms = S.slowWritesBase = null;
+  S.meanSurprise = S.peakSurprise = S.momentum = null;
+  S.curve = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/sement.js

@@ -0,0 +1,456 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/sement.js — SEMANTIC-ENTROPY / EFFECTIVE-RANK EPISTEMIC-UNCERTAINTY
+// hallucination-detection organ for the holographic frontier ring.
+//
+// Renders two side-by-side "regime" pylons — a CONFIDENT regime and a CONFABULATING regime —
+// driven by a live snapshot from /api/killinchu/v1/sement/estimate. For each regime the organ
+// samples K candidate generations for one fixed prompt, clusters them into semantic-equivalence
+// classes, and shows three bars: NAIVE (surface-string) entropy, SEMANTIC (meaning-cluster)
+// entropy, and spectral EFFECTIVE RANK — plus a threshold-driven answer/abstain verdict. The
+// honest signal it visualizes: semantic entropy AND effective rank both RISE on the confabulating
+// regime while naive entropy can be misleadingly low. Honesty label "MODELED" is read VERBATIM
+// from the JSON and displayed as-is; never upgraded.
+//
+// IMPORTANT — MODELED, NOT A REAL LLM:
+//   This organ simulates the uncertainty-estimation METHOD on synthetic toy data. The
+//   semantic-equivalence clustering is a HAND-SPECIFIED lookup table (real semantic entropy
+//   uses a bidirectional-entailment model); the "hidden states" behind the effective rank are
+//   SYNTHETIC seeded matrices. It demonstrates the ORDERING (uncertain > confident) that the
+//   published methods exploit; it does NOT reproduce AUROC or benchmark numbers and makes no
+//   claim about real-model calibration. This is stated plainly in the "what this means" copy
+//   and echoed in the endpoint's own JSON payload (honest_note).
+//
+// Surface export shape (mirrors qhall.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):
+//   K                 — candidate generations sampled per regime
+//   naive_entropy     — Shannon entropy over SURFACE strings (nats)
+//   semantic_entropy  — Shannon entropy over MEANING clusters (nats)
+//   effective_rank    — exp(entropy of normalized singular values) of synthetic hidden states
+//   decision          — "answer" | "abstain" (threshold on semantic entropy)
+//   n_clusters        — semantic-equivalence classes recovered
+//   ordering_holds    — semantic entropy & effective rank both rise on confabulating
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own):
+//   Farquhar, Kossen, Kuhn & Gal (2024) "Detecting hallucinations in large language models
+//     using semantic entropy". Nature 630, 625-630. DOI 10.1038/s41586-024-07421-0.
+//     https://www.nature.com/articles/s41586-024-07421-0
+//   Wang, Wei, Yue & Sun (2025) "Revisiting Hallucination Detection with Effective
+//     Rank-based Uncertainty". arXiv:2510.08389. https://arxiv.org/abs/2510.08389
+//
+// HONESTY LABELS: MODELED (simulation of the METHOD on synthetic toy data; hand-specified
+//   clustering, synthetic hidden states, NO real LLM). Read verbatim from JSON.
+// COLOURS: lattice-blue 0x5b8dee (confident regime / naive-entropy bar), violet-blue 0x8a6bff
+//   (confabulating regime / semantic-entropy bar — data-viz only), proof-teal 0x3af4c8
+//   (effective-rank accent), greys for dim/idle. Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via page importmap (ctx.THREE).
+// DOCTRINE v11: degrades gracefully (grey) on 404/error; honesty label still shown.
+// This organ adds NOTHING to SZL's own locked-8 / Λ-Conjecture-1.
+
+const ID    = "sement";
+const TITLE = "Semantic-Entropy · Effective-Rank Epistemic Uncertainty (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship origin).
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/sement/estimate?seed=42&K=40&n_clusters=5&threshold=0.6";
+
+// data-viz hues — purple BANNED
+const C_CONF   = 0x5b8dee;  // lattice-blue (confident regime / naive-entropy bar)
+const C_CONFAB = 0x8a6bff;  // violet-blue (confabulating regime / semantic-entropy bar — data-viz only)
+const C_ACCENT = 0x3af4c8;  // proof-teal accent (effective-rank bar + verdict ring)
+const C_DIM    = 0x42505d;  // grey (degraded / no-live-data / idle)
+const C_GRID   = 0x1b3a44;  // floor / link colour
+
+let _stage = null, _THREE = null, _ctx = null, _group = null, _overlay = null;
+let _frameReg = false, _polls = [], _el = {}, _badge = null;
+let _plain = false;
+
+// geometry handles — two regime clusters, each with three metric bars
+let _bars = [];         // Array<THREE.Mesh> — 2 regimes x 3 metrics
+let _rings = [];        // Array<THREE.Mesh> — one verdict ring per regime
+const _MAX_BARS = 6;
+const _pulse = new Float32Array(_MAX_BARS);
+let _built = false;
+
+// live state
+const S = {
+  label:      null,
+  K:          null,   // K samples per regime
+  threshold:  null,   // abstain/answer threshold (nats)
+  ordering:   null,   // ordering_holds
+  // per-regime metrics: index 0 = confident, 1 = confabulating
+  reg: [
+    { name: "confident",     naive: null, sem: null, effr: null, decision: null, nclus: null },
+    { name: "confabulating", naive: null, sem: null, effr: null, decision: null, nclus: 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(0, 7, 20);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(0, 2.0, 0); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildBars();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onEstimate, { badge: _badge, onState: (m) => { S.state = m.state; _paintOverlay(); _updateBars(); } }));
+
+  _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);
+}
+
+// Two regime clusters, each with three metric bars (naive / semantic / effective-rank),
+// plus a verdict ring above each cluster. Heights are set from live data in _updateBars().
+function _buildBars() {
+  const THREE = _THREE;
+  if (_built) return;
+  _built = true;
+
+  const barGeo = new THREE.BoxGeometry(0.9, 1.0, 0.9);
+  const cols = [C_CONF, C_CONFAB, C_ACCENT]; // naive, semantic, effective-rank
+  // regime cluster centres (confident left, confabulating right)
+  const centres = [-5.0, 5.0];
+  const spread = 1.4;
+
+  _bars = [];
+  for (let r = 0; r < 2; r++) {
+    for (let m = 0; m < 3; m++) {
+      const mat = new THREE.MeshStandardMaterial({
+        color: C_DIM, emissive: C_DIM, emissiveIntensity: 0.15, metalness: 0.25, roughness: 0.55,
+      });
+      const mesh = new THREE.Mesh(barGeo, mat);
+      const x = centres[r] + (m - 1) * spread;
+      mesh.position.set(x, 0.5, 0);
+      mesh.userData.baseCol = cols[m];
+      mesh.userData.x = x;
+      _group.add(mesh);
+      _bars.push(mesh);
+    }
+  }
+
+  // verdict rings, one above each regime cluster
+  _rings = [];
+  for (let r = 0; r < 2; r++) {
+    const ring = new THREE.Mesh(
+      new THREE.TorusGeometry(1.6, 0.05, 10, 48),
+      new THREE.MeshStandardMaterial({ color: C_ACCENT, emissive: C_ACCENT, emissiveIntensity: 0.4, transparent: true, opacity: 0.5 }),
+    );
+    ring.position.set(centres[r], 6.4, 0);
+    ring.rotation.x = Math.PI / 2;
+    _group.add(ring);
+    _rings.push(ring);
+  }
+}
+
+// =============================================================================
+// live data handler — reads label VERBATIM (top-level 'label' OR nested 'payload.label')
+// =============================================================================
+function _onEstimate(j) {
+  const p = (j && typeof j.payload === "object" && j.payload) ? j.payload : j;
+  const rawLabel = (p && p.label != null) ? p.label : (j && j.label != null ? j.label : "MODELED");
+  S.label = String(rawLabel).toUpperCase();
+
+  S.K         = typeof p.K              === "number"  ? p.K              : null;
+  S.threshold = typeof p.threshold      === "number"  ? p.threshold      : null;
+  S.ordering  = typeof p.ordering_holds === "boolean" ? p.ordering_holds : null;
+
+  if (Array.isArray(p.regimes)) {
+    p.regimes.forEach((rr) => {
+      const idx = rr && rr.regime === "confabulating" ? 1 : (rr && rr.regime === "confident" ? 0 : -1);
+      if (idx < 0) return;
+      const slot = S.reg[idx];
+      slot.naive    = typeof rr.naive_entropy    === "number" ? rr.naive_entropy    : null;
+      slot.sem      = typeof rr.semantic_entropy === "number" ? rr.semantic_entropy : null;
+      slot.effr     = typeof rr.effective_rank   === "number" ? rr.effective_rank   : null;
+      slot.decision = typeof rr.decision         === "string" ? rr.decision         : null;
+      slot.nclus    = typeof rr.n_clusters       === "number" ? rr.n_clusters       : null;
+    });
+  }
+
+  _updateBars();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — bar heights from metrics, colours by regime/metric, verdict rings
+// =============================================================================
+function _updateBars() {
+  const live = S.state === "live";
+  // normalization so bars stay on-screen: entropies in nats (~0..2), eff-rank (~1..8)
+  const entScale = 1.6;   // world units per nat
+  const rankScale = 0.5;  // world units per rank unit
+  for (let r = 0; r < 2; r++) {
+    const slot = S.reg[r];
+    const vals = [slot.naive, slot.sem, slot.effr];
+    for (let m = 0; m < 3; m++) {
+      const mesh = _bars[r * 3 + m];
+      if (!mesh) continue;
+      let v = vals[m];
+      let h = 0.4;
+      if (live && typeof v === "number") {
+        h = (m === 2 ? v * rankScale : v * entScale);
+        h = Math.max(0.4, Math.min(h, 9.0));
+      }
+      mesh.scale.y = h;
+      mesh.position.y = h / 2;
+      const col = live ? mesh.userData.baseCol : C_DIM;
+      mesh.material.color.setHex(col);
+      mesh.material.emissive.setHex(col);
+      mesh.material.emissiveIntensity = live ? 0.35 : 0.12;
+      if (live) _pulse[r * 3 + m] = 60;
+    }
+    // verdict ring: abstain burns violet-blue + bright; answer stays calm teal
+    const ring = _rings[r];
+    if (ring) {
+      const abstain = slot.decision === "abstain";
+      const rcol = live ? (abstain ? C_CONFAB : C_ACCENT) : C_DIM;
+      ring.material.color.setHex(rcol);
+      ring.material.emissive.setHex(rcol);
+      ring.material.emissiveIntensity = live ? (abstain ? 0.85 : 0.3) : 0.12;
+      ring.material.opacity = live ? 0.6 : 0.2;
+      ring.scale.setScalar(live ? (abstain ? 1.15 : 0.85) : 0.8);
+    }
+  }
+}
+
+// =============================================================================
+// per-frame animation
+// =============================================================================
+function _onFrame() {
+  const t = performance.now();
+  if (_group) _group.rotation.y = Math.sin(t * 0.0001) * 0.12;
+  _rings.forEach((ring) => { if (ring) ring.rotation.z += 0.004; });
+
+  const live = S.state === "live";
+  _bars.forEach((mesh, i) => {
+    if (_pulse[i] > 0) {
+      _pulse[i] -= 1;
+      const f = _pulse[i] / 60;
+      mesh.material.emissiveIntensity = Math.max(mesh.material.emissiveIntensity, 0.2 + 0.7 * f);
+    }
+    if (live) mesh.position.x = mesh.userData.x + Math.sin(t * 0.0011 + i) * 0.02;
+  });
+}
+
+// =============================================================================
+// 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%,480px)",
+    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 =
+    'For one prompt we sample <b>K</b> candidate answers, group answers that <b>mean the same ' +
+    'thing</b> into semantic clusters, and score the <b>entropy</b> over those clusters ' +
+    '(<b>semantic entropy</b>). We compare a <b>confident</b> regime against a ' +
+    '<b>confabulating</b> one, and add the 2025 <b>spectral effective rank</b> of the ' +
+    'hidden states. Semantic entropy and effective rank both <b>rise</b> when the model ' +
+    'confabulates \\u2014 even when naive surface entropy stays misleadingly low \\u2014 so we ' +
+    '<b>abstain</b>. Honesty label <b>MODELED</b> \\u2014 a simulation of the method on ' +
+    'synthetic toy data, <b>not</b> a real 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 = "sement \\u00b7 epistemic uncertainty";
+  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:60%";
+    v.textContent = "\\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("se-K",       "candidate generations K"));
+  grid.appendChild(kpiRow("se-thr",     "abstain threshold (nats)"));
+  grid.appendChild(kpiRow("se-cn",      "confident \\u00b7 naive / semantic H"));
+  grid.appendChild(kpiRow("se-cr",      "confident \\u00b7 effective rank"));
+  grid.appendChild(kpiRow("se-cd",      "confident \\u00b7 decision"));
+  grid.appendChild(kpiRow("se-bn",      "confabulating \\u00b7 naive / semantic H"));
+  grid.appendChild(kpiRow("se-br",      "confabulating \\u00b7 effective rank"));
+  grid.appendChild(kpiRow("se-bd",      "confabulating \\u00b7 decision"));
+  grid.appendChild(kpiRow("se-ord",     "ordering holds (uncertain > confident)"));
+  grid.appendChild(kpiRow("se-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 = "Farquhar, Kossen, Kuhn & Gal, Nature 2024 (DOI 10.1038/s41586-024-07421-0) \\u00b7 " +
+    "Wang, Wei, Yue & Sun arXiv:2510.08389 (2025) \\u00b7 MODELED \\u00b7 hand-specified clustering, " +
+    "synthetic hidden states, no real LLM \\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 = "sement-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 K   = S.K != null ? String(S.K) : "loading\\u2026";
+  const conf = S.reg[0], bad = S.reg[1];
+  const cSem = conf.sem != null ? conf.sem.toFixed(3) : "loading\\u2026";
+  const bSem = bad.sem  != null ? bad.sem.toFixed(3)  : "loading\\u2026";
+  const bNaive = bad.naive != null ? bad.naive.toFixed(3) : "loading\\u2026";
+  const bRank = bad.effr != null ? bad.effr.toFixed(2) : "loading\\u2026";
+  const bDec  = bad.decision || "loading\\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> We ask the model the same question <b>" + K + "</b> times and collect " +
+    "its candidate answers. We group answers that <b>mean the same thing</b> together, then measure " +
+    "how scattered the meanings are (<b>semantic entropy</b>). When the model is <b>confident</b>, " +
+    "almost every answer means the same thing, so semantic entropy is low (here <b>" + cSem + "</b>) " +
+    "and we <b>answer</b>. When the model is <b>confabulating</b>, its answers scatter across many " +
+    "contradictory meanings, so semantic entropy jumps to <b>" + bSem + "</b> and a second, spectral " +
+    "signal \\u2014 the <b>effective rank</b> of its hidden states (\\u2248 <b>" + bRank + "</b>) \\u2014 " +
+    "rises too, so we <b>" + bDec + "</b>. Crucially, plain surface-word entropy on the confabulating " +
+    "case can look misleadingly modest (\\u2248 <b>" + bNaive + "</b>), which is exactly why " +
+    "meaning-level and spectral uncertainty beat surface uncertainty." +
+    "<br><br><b>Important honesty note:</b> this is a <b>MODELED</b> toy simulation of the " +
+    "<b>uncertainty estimator</b>, <b>not a real language model</b>. The step that decides which " +
+    "answers \\u201cmean the same thing\\u201d is a <b>hand-specified lookup table</b> (real semantic " +
+    "entropy uses a trained entailment model), and the <b>hidden states are synthetic seeded " +
+    "matrices</b>. It faithfully demonstrates the <b>ordering</b> (uncertain &gt; confident) that the " +
+    "published methods exploit, but it does <b>not</b> reproduce the Nature paper\\u2019s AUROC or the " +
+    "effective-rank paper\\u2019s benchmark numbers, and makes no claim about real-model calibration " +
+    "(Farquhar et al., Nature 2024; Wang et al., arXiv:2510.08389, 2025).";
+}
+
+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);
+  const conf = S.reg[0], bad = S.reg[1];
+  _set("se-K",   t || (S.K != null ? String(S.K) : "\\u2014"));
+  _set("se-thr", t || fx(S.threshold, 2));
+  _set("se-cn",  t || (conf.naive != null && conf.sem != null ? fx(conf.naive, 3) + " / " + fx(conf.sem, 3) : "\\u2014"));
+  _set("se-cr",  t || fx(conf.effr, 3));
+  _set("se-cd",  t || (conf.decision ? conf.decision.toUpperCase() : "\\u2014"));
+  _set("se-bn",  t || (bad.naive != null && bad.sem != null ? fx(bad.naive, 3) + " / " + fx(bad.sem, 3) : "\\u2014"));
+  _set("se-br",  t || fx(bad.effr, 3));
+  _set("se-bd",  t || (bad.decision ? bad.decision.toUpperCase() : "\\u2014"));
+  _set("se-ord", t || (S.ordering == null ? "\\u2014" : (S.ordering ? "YES \\u2014 semantic H & eff-rank both rise" : "no")));
+  // honesty label verbatim — never upgraded
+  _set("se-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;
+  _bars = []; _rings = [];
+  _built = false;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.K = S.threshold = S.ordering = null;
+  S.reg[0] = { name: "confident",     naive: null, sem: null, effr: null, decision: null, nclus: null };
+  S.reg[1] = { name: "confabulating", naive: null, sem: null, effr: null, decision: null, nclus: null };
+  S.state = "init";
+  _pulse.fill(0);
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };

static/3d/surfaces/ternary.js

@@ -0,0 +1,468 @@
+// SPDX-License-Identifier: Apache-2.0
+// © 2026 Lutar, Stephen P. — SZL Holdings · ORCID 0009-0001-0110-4173 · Doctrine v11
+//
+// surfaces/ternary.js — NATIVE 1.58-BIT TERNARY-WEIGHT LM organ for the
+// holographic frontier ring (BitNet b1.58 BitLinear ternarization + multiply-
+// free integer arithmetic, Microsoft Research-style). Renders a synthetic
+// weight matrix as a 3D lattice of ternary cells: weights that ternarize to +1
+// glow proof-teal (add), -1 glow lattice-blue (subtract), and 0 fade to grey
+// (skip / structured sparsity). A HUD shows the three MEASURED metrics from the
+// live snapshot at /api/killinchu/v1/ternary/quantize:
+//   (1) COMPRESSION (bits/weight + x-shrink), (2) FIDELITY (the MEASURED,
+//   non-zero rel_l2 / cosine error — reported, NOT hidden), (3) ARITHMETIC
+//   PROFILE (float multiplies eliminated). Honesty label "MODELED" is read
+//   VERBATIM from the JSON and displayed as-is; it is never upgraded.
+//
+// Surface export shape (mirrors kvcache.js / aimc.js exactly):
+//   export default { id, title, endpoints, mount(ctx), unmount() }
+//   ctx = { stage, container, live, label, THREE, szl3d }
+//
+// DATA SHOWN (all from live endpoint):
+//   rows, cols, batch, act_bits, beta, sparsity, ternary_counts{neg,zero,pos},
+//   bits_per_weight_ternary, compression_vs_fp16, compression_vs_fp32,
+//   rel_l2_error, cosine_error, float_muls_full, float_muls_ternary,
+//   muls_eliminated, muls_eliminated_frac, int_ops_ternary
+//
+// LEADERS ADOPTED & CITED (clean-room; NOT claimed as SZL's own; VERIFY real):
+//   BitNet b1.58 2B4T Technical Report (mechanism simulated here):
+//     Ma, Wang, Huang, Zhang, Hu, Song, Xia, Wei et al. (Microsoft Research)
+//     arXiv:2504.12285  https://arxiv.org/abs/2504.12285
+//   Official open weights: https://huggingface.co/microsoft/bitnet-b1.58-2B-4T
+//   Official inference stack: https://github.com/microsoft/BitNet
+//   Genealogy "The Era of 1-bit LLMs": arXiv:2402.17764
+//     https://arxiv.org/abs/2402.17764
+//
+// HONESTY LABELS: MODELED (deterministic reproduction of the BitNet b1.58
+//   ternary-quantization + integer-arithmetic MECHANISM on a toy synthetic
+//   matrix; NOT the trained model; error is MEASURED and displayed;
+//   NEVER-CLAIMED-AS a production inference engine). Read verbatim from JSON;
+//   never upgraded here.
+// COLOURS: proof-teal 0x3af4c8 (+1 -> add / HUD accent), lattice-blue 0x5b8dee
+//   (-1 -> subtract), violet-blue 0x8a6bff (rescale/β accent), greys (0 -> skip /
+//   degraded state). Purple BANNED as UI/background.
+// 0 RUNTIME CDN. Vendored three.js via ctx.THREE (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    = "ternary";
+const TITLE = "Native 1.58-bit Ternary-Weight LM · BitNet b1.58 (live)";
+
+// Endpoint is hosted on the dedicated killinchu Space (isolated compute), reached
+// cross-origin (killinchu returns access-control-allow-origin for the flagship).
+// This keeps the ternary organ's rebuilds/faults isolated from the flagship.
+const EP = "https://szlholdings-killinchu.hf.space/api/killinchu/v1/ternary/quantize?seed=42&rows=32&cols=32&batch=16&act_bits=8";
+
+// data-viz hues — purple BANNED
+const C_POS      = 0x3af4c8;  // proof-teal (+1 weight -> add)
+const C_NEG      = 0x5b8dee;  // lattice-blue (-1 weight -> subtract)
+const C_RESCALE  = 0x8a6bff;  // violet-blue (β rescale / accent marker)
+const C_ZERO     = 0x5a6570;  // grey (0 weight -> skip / structured sparsity)
+const C_DIM      = 0x42505d;  // grey (degraded / no-live-data)
+const C_GRID     = 0x1b3a44;  // floor / link colour
+
+// lattice layout geometry
+const CELL_GAP   = 0.44;   // world-units between weight cells
+const MAX_SIDE   = 24;     // cap on cells rendered per axis (perf): MAX_SIDE^2 max
+const CELL_Y     = 0.4;    // resting height of a weight cell
+
+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 _cellMesh = [];                  // Array<THREE.Mesh> — flattened lattice cells
+let _marker   = null;                // THREE.Mesh — β-rescale HUD marker
+
+// live state
+const S = {
+  label:            null,
+  rows:             null,
+  cols:             null,
+  batch:            null,
+  actBits:          null,   // act_bits
+  beta:             null,
+  sparsity:         null,
+  tcNeg:            null,   // ternary_counts.neg
+  tcZero:           null,   // ternary_counts.zero
+  tcPos:            null,   // ternary_counts.pos
+  bitsPerWeight:    null,   // bits_per_weight_ternary
+  compVsFp16:       null,   // compression_vs_fp16
+  compVsFp32:       null,   // compression_vs_fp32
+  relL2Error:       null,   // rel_l2_error (MEASURED)
+  cosineError:      null,   // cosine_error (MEASURED)
+  floatMulsFull:    null,   // float_muls_full
+  floatMulsTernary: null,   // float_muls_ternary
+  mulsEliminated:   null,   // muls_eliminated
+  mulsElimFrac:     null,   // muls_eliminated_frac
+  intOps:           null,   // int_ops_ternary
+  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(6, 8, 16);
+  try { if (_stage.controls && _stage.controls.target) { _stage.controls.target.set(5, 1, 5); _stage.controls.update(); } } catch (_) {}
+  try { _stage.setBloom(true); } catch (_) {}
+
+  _buildFloor();
+  _buildLattice();
+  _buildMarker();
+
+  if (!_frameReg) { _stage.onFrame(_onFrame); _frameReg = true; }
+
+  _badge = ctx.live.createBadge();
+  _polls.push(ctx.live.poll(EP, 5000, _onTernary, { 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 MAX_SIDE x MAX_SIDE lattice of weight-cell meshes. We
+// toggle visibility / color / height in-place as live data arrives (no per-poll
+// geometry churn). Each cell = one ternary weight; we colour by a deterministic
+// sign pattern derived from live ternary_counts (client never invents weights it
+// cannot see — it colours proportionally to the reported neg/zero/pos mix).
+function _buildLattice() {
+  const THREE = _THREE;
+  const cellGeo = new THREE.BoxGeometry(0.26, 0.26, 0.26);
+  for (let r = 0; r < MAX_SIDE; r++) {
+    for (let c = 0; c < MAX_SIDE; c++) {
+      const mesh = new THREE.Mesh(
+        cellGeo,
+        new THREE.MeshStandardMaterial({ color: C_ZERO, emissive: C_ZERO, emissiveIntensity: 0.2, transparent: true, opacity: 0.0 }),
+      );
+      mesh.position.set(c * CELL_GAP, CELL_Y, r * CELL_GAP);
+      mesh.visible = false;
+      _group.add(mesh);
+      _cellMesh.push(mesh);
+    }
+  }
+}
+
+function _buildMarker() {
+  const THREE = _THREE;
+  _marker = new THREE.Mesh(
+    new THREE.IcosahedronGeometry(0.3, 1),
+    new THREE.MeshStandardMaterial({ color: C_RESCALE, emissive: C_RESCALE, emissiveIntensity: 0.5, wireframe: true, transparent: true, opacity: 0.85 }),
+  );
+  _marker.position.set(-1.2, 1.4, -1.2);
+  _group.add(_marker);
+}
+
+// =============================================================================
+// live data handler
+// =============================================================================
+function _onTernary(j) {
+  // read honesty label VERBATIM — never upgrade. handle top-level 'label' OR
+  // nested 'payload.label' to match our own module's shape.
+  const lbl = (j && j.label != null) ? j.label
+            : (j && j.payload && j.payload.label != null) ? j.payload.label
+            : "MODELED";
+  const src = (j && j.payload && typeof j.payload === "object") ? j.payload : j;
+  S.label            = String(lbl).toUpperCase();
+
+  S.rows             = typeof src.rows                    === "number" ? src.rows                    : null;
+  S.cols             = typeof src.cols                    === "number" ? src.cols                    : null;
+  S.batch            = typeof src.batch                   === "number" ? src.batch                   : null;
+  S.actBits          = typeof src.act_bits                === "number" ? src.act_bits                : null;
+  S.beta             = typeof src.beta                    === "number" ? src.beta                    : null;
+  S.sparsity         = typeof src.sparsity                === "number" ? src.sparsity                : null;
+  S.bitsPerWeight    = typeof src.bits_per_weight_ternary === "number" ? src.bits_per_weight_ternary : null;
+  S.compVsFp16       = typeof src.compression_vs_fp16     === "number" ? src.compression_vs_fp16     : null;
+  S.compVsFp32       = typeof src.compression_vs_fp32     === "number" ? src.compression_vs_fp32     : null;
+  S.relL2Error       = typeof src.rel_l2_error            === "number" ? src.rel_l2_error            : null;
+  S.cosineError      = typeof src.cosine_error            === "number" ? src.cosine_error            : null;
+  S.floatMulsFull    = typeof src.float_muls_full         === "number" ? src.float_muls_full         : null;
+  S.floatMulsTernary = typeof src.float_muls_ternary      === "number" ? src.float_muls_ternary      : null;
+  S.mulsEliminated   = typeof src.muls_eliminated         === "number" ? src.muls_eliminated         : null;
+  S.mulsElimFrac     = typeof src.muls_eliminated_frac    === "number" ? src.muls_eliminated_frac    : null;
+  S.intOps           = typeof src.int_ops_ternary         === "number" ? src.int_ops_ternary         : null;
+
+  if (src.ternary_counts && typeof src.ternary_counts === "object") {
+    S.tcNeg  = typeof src.ternary_counts.neg  === "number" ? src.ternary_counts.neg  : null;
+    S.tcZero = typeof src.ternary_counts.zero === "number" ? src.ternary_counts.zero : null;
+    S.tcPos  = typeof src.ternary_counts.pos  === "number" ? src.ternary_counts.pos  : null;
+  }
+
+  _updateLattice();
+  _paintOverlay();
+}
+
+// =============================================================================
+// geometry updater — colours the lattice from the live ternary mix
+// =============================================================================
+// Deterministic per-cell PRNG (LCG, mirrors the module's family) so the lattice
+// pattern is stable across polls and never fabricated beyond the reported mix.
+function _cellSign(idx, pNeg, pZero) {
+  let s = ((idx + 1) * 2654435761) >>> 0;
+  s = (1664525 * s + 1013904223) >>> 0;
+  const u = s / 4294967295;
+  if (u < pZero) return 0;
+  if (u < pZero + pNeg) return -1;
+  return 1;
+}
+
+function _updateLattice() {
+  const live = S.state === "live";
+  const rows = live && S.rows ? Math.min(S.rows, MAX_SIDE) : 0;
+  const cols = live && S.cols ? Math.min(S.cols, MAX_SIDE) : 0;
+
+  const total = (S.tcNeg || 0) + (S.tcZero || 0) + (S.tcPos || 0);
+  const pNeg  = total > 0 ? (S.tcNeg  || 0) / total : 0.33;
+  const pZero = total > 0 ? (S.tcZero || 0) / total : 0.34;
+
+  for (let r = 0; r < MAX_SIDE; r++) {
+    for (let c = 0; c < MAX_SIDE; c++) {
+      const mesh = _cellMesh[r * MAX_SIDE + c];
+      if (!live || r >= rows || c >= cols) {
+        mesh.visible = false;
+        continue;
+      }
+      mesh.visible = true;
+      const sign = _cellSign(r * MAX_SIDE + c, pNeg, pZero);
+      let color;
+      if (sign === 1)      color = C_POS;     // +1 -> add     -> proof-teal
+      else if (sign === -1) color = C_NEG;    // -1 -> subtract -> lattice-blue
+      else                 color = C_ZERO;    //  0 -> skip     -> grey
+      mesh.material.color.setHex(color);
+      mesh.material.emissive.setHex(color);
+      mesh.material.emissiveIntensity = sign === 0 ? 0.12 : 0.55;
+      mesh.material.opacity = sign === 0 ? 0.3 : 0.95;
+      mesh.position.y = sign === 0 ? CELL_Y - 0.28 : CELL_Y;  // zeros sink (skipped)
+    }
+  }
+
+  if (_marker) {
+    if (live) {
+      _marker.material.color.setHex(C_RESCALE);
+      _marker.material.emissive.setHex(C_RESCALE);
+      _marker.material.opacity = 0.85;
+    } 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.14;
+  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%,460px)",
+    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 =
+    'Every weight is constrained to a ternary code <b>{\u22121, 0, +1}</b> (~1.58 bits/weight) via ' +
+    '<b>BitLinear</b>: scale \u03b2 = mean(|W|), then W<sub>t</sub> = round-clip(W/\u03b2). Because weights are ' +
+    'ternary, the float matmul collapses into integer <b>add</b> (+1) / <b>subtract</b> (\u22121) / ' +
+    '<b>skip</b> (0) \u2014 no per-weight multiply. HUD reports three MEASURED metrics: compression, ' +
+    'fidelity error (shown, NOT hidden), and multiplies eliminated. Honesty label <b>MODELED</b> ' +
+    '(deterministic mechanism reproduction on a toy matrix; NOT the trained BitNet model). 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 = "native 1.58-bit ternary-weight lm";
+  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:56%";
+    v.textContent = "\u2014";
+    _el[id] = v;
+    r.appendChild(l); r.appendChild(v); return r;
+  }
+
+  grid.appendChild(kpiRow("tn-dims",     "matrix (rows \u00d7 cols)"));
+  grid.appendChild(kpiRow("tn-actbits",  "activation bit-width (absmax)"));
+  grid.appendChild(kpiRow("tn-beta",     "\u03b2 = mean(|W|) (absmean scale)"));
+  grid.appendChild(kpiRow("tn-mix",      "ternary mix (\u22121 / 0 / +1)"));
+  grid.appendChild(kpiRow("tn-sparsity", "sparsity (weights \u2192 0, skipped)"));
+  grid.appendChild(kpiRow("tn-bpw",      "bits/weight (ternary) \u2014 MODELED"));
+  grid.appendChild(kpiRow("tn-comp16",   "COMPRESSION vs fp16"));
+  grid.appendChild(kpiRow("tn-comp32",   "COMPRESSION vs fp32"));
+  grid.appendChild(kpiRow("tn-rell2",    "FIDELITY \u2014 rel L2 error (MEASURED)"));
+  grid.appendChild(kpiRow("tn-cos",      "FIDELITY \u2014 cosine error (MEASURED)"));
+  grid.appendChild(kpiRow("tn-muls",     "float-muls ELIMINATED"));
+  grid.appendChild(kpiRow("tn-mulsfrac", "multiply-free fraction"));
+  grid.appendChild(kpiRow("tn-intops",   "integer add/sub ops"));
+  grid.appendChild(kpiRow("tn-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 = "BitNet b1.58 \u2014 Ma, Wang, Huang, Zhang, Hu, Song, Xia, Wei et al. (Microsoft Research) arXiv:2504.12285 \u00b7 genealogy arXiv:2402.17764. 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 = "tn-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 comp   = S.compVsFp16   != null ? S.compVsFp16.toFixed(1) + "\u00d7"        : "loading\u2026";
+  const relPct = S.relL2Error   != null ? (S.relL2Error * 100).toFixed(1) + "%"     : "loading\u2026";
+  const mulPct = S.mulsElimFrac != null ? (S.mulsElimFrac * 100).toFixed(1) + "%"   : "loading\u2026";
+  pd.innerHTML =
+    "<b>What this means:</b> Ordinary language models store each number (\u201cweight\u201d) using 16 or 32 " +
+    "bits and multiply by it billions of times. This approach instead snaps every weight to just three " +
+    "values \u2014 minus one, zero, or plus one \u2014 which needs only about 1.58 bits each. That shrinks storage " +
+    "by roughly <b>" + comp + "</b>, and the big multiplications turn into simple add / subtract / skip \u2014 here " +
+    "<b>" + mulPct + "</b> of the multiplies disappear. The catch, shown honestly, is a <b>MEASURED</b> " +
+    "approximation error of about <b>" + relPct + "</b> on this toy matrix \u2014 we display it rather than hide it. " +
+    "This view is a <b>MODELED</b> deterministic reproduction of the ternary-quantization and multiply-free " +
+    "arithmetic MECHANISM on a small synthetic matrix, NOT the trained BitNet model. It does not reproduce " +
+    "downstream accuracy, the 2B-parameter / 4T-token training, or the paper's energy figures. \u201cMatches " +
+    "full precision\u201d is <b>Microsoft's claim</b> about their trained model \u2014 the estate does not independently " +
+    "verify it.";
+}
+
+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("tn-dims",     t || ((S.rows != null && S.cols != null) ? (S.rows + " \u00d7 " + S.cols) : "\u2014"));
+  _set("tn-actbits",  t || (S.actBits != null ? (S.actBits + "-bit") : "\u2014"));
+  _set("tn-beta",     t || fx(S.beta, 4));
+  _set("tn-mix",      t || ((S.tcNeg != null) ? (S.tcNeg + " / " + S.tcZero + " / " + S.tcPos) : "\u2014"));
+  _set("tn-sparsity", t || pct(S.sparsity, 2));
+  _set("tn-bpw",      t || fx(S.bitsPerWeight, 4));
+  _set("tn-comp16",   t || (S.compVsFp16 != null ? S.compVsFp16.toFixed(2) + "\u00d7" : "\u2014"));
+  _set("tn-comp32",   t || (S.compVsFp32 != null ? S.compVsFp32.toFixed(2) + "\u00d7" : "\u2014"));
+  _set("tn-rell2",    t || pct(S.relL2Error, 2));
+  _set("tn-cos",      t || pct(S.cosineError, 2));
+  _set("tn-muls",     t || ((S.mulsEliminated != null && S.floatMulsFull != null) ? (S.mulsEliminated + " / " + S.floatMulsFull) : "\u2014"));
+  _set("tn-mulsfrac", t || pct(S.mulsElimFrac, 2));
+  _set("tn-intops",   t || (S.intOps != null ? String(S.intOps) : "\u2014"));
+  // honesty label verbatim — never upgraded
+  _set("tn-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; _cellMesh = []; _marker = null;
+  _el = {}; _badge = null; _plain = false; _frameReg = false;
+  _stage = _THREE = _ctx = null;
+  S.label = S.rows = S.cols = S.batch = S.actBits = S.beta = S.sparsity = null;
+  S.tcNeg = S.tcZero = S.tcPos = S.bitsPerWeight = null;
+  S.compVsFp16 = S.compVsFp32 = S.relL2Error = S.cosineError = null;
+  S.floatMulsFull = S.floatMulsTernary = S.mulsEliminated = S.mulsElimFrac = S.intOps = null;
+  S.state = "init";
+}
+
+export default { id: ID, title: TITLE, endpoints: [EP], mount, unmount };