Spaces:
Running
Running
| <html lang="en"> | |
| <head> | |
| <meta charset="utf-8"/> | |
| <meta name="viewport" content="width=device-width, initial-scale=1"/> | |
| <title>The a11oy Brain — moldable · SZL Holdings</title> | |
| <!-- 0 runtime CDN. three.js is vendored in-image and served same-origin through the | |
| /static/3d/vendor/... importmap below (see VENDOR_MANIFEST.md). System fonts only. | |
| This page is a SELF-CONTAINED, MOLDABLE 3D brain of the SZL Holdings estate. | |
| Eight lobes are wired to one same-origin evidence contract. On each request the | |
| server performs fixed-allowlist, read-only, timeout + byte-bounded public reads: | |
| · Models / Datasets / Spaces / Collections — Hugging Face Hub API (SZLHOLDINGS) | |
| · Repositories — GitHub REST API (org szl-holdings) | |
| · Proved formulas — a commit-pinned ProvedFormulas.lean artifact, fetched | |
| server-side, SHA-256 verified, then counted for `theorem` declarations. | |
| · Fleet vitals — live /healthz probes of the organ Spaces (a11oy · killinchu · | |
| anatomy · amaru · sentra), each answer is that organ's own, right now. | |
| · Open frontier — live Hub counts of the open-weights orgs the a11oy backbone | |
| is built to route to (DeepSeek · Qwen · Kimi/Moonshot) plus GLM/Z.ai (watched). | |
| Every number on screen is MEASURED from those live reads (a real 0 stays 0) or | |
| UNKNOWN where the source exposes none; an unreachable feed degrades to an honest | |
| NO-LIVE-DATA state. There is no stale cache or hidden fallback. Nothing is fabricated. | |
| MOLDING is a local, display-only sculpt: dragging in Mold mode displaces mesh | |
| vertices on YOUR device only. It never changes, and can never change, any | |
| measured number. Λ = Conjecture 1. --> | |
| <script type="importmap"> | |
| { | |
| "imports": { | |
| "three": "/static/3d/vendor/three/three.module.min.js", | |
| "three/webgpu": "/static/3d/vendor/three/three.webgpu.min.js", | |
| "three/addons/": "/static/3d/vendor/three/addons/" | |
| } | |
| } | |
| </script> | |
| <style> | |
| :root{--bg:#05070d;--panel:#0b121b;--line:#1b2734;--teal:#39d3c4;--proof:#3af4c8;--gold:#e8c074; | |
| --sky:#6fb1ff;--green:#2fd07a;--rose:#e08a8a;--cream:#eef3f6;--para:#9fb1bf;} | |
| *{box-sizing:border-box} | |
| html,body{margin:0;height:100%} | |
| body{background:var(--bg);color:var(--cream);font:14px/1.5 ui-sans-serif,system-ui,Segoe UI,Roboto,Arial; | |
| overflow:hidden;display:flex;flex-direction:column;height:100vh;height:100svh;height:100dvh} | |
| header{padding:10px 16px;border-bottom:1px solid var(--line);background:linear-gradient(180deg,#08101a,#05070d); | |
| display:flex;align-items:center;gap:14px;flex-wrap:wrap;flex:0 0 auto} | |
| h1{font-size:16px;margin:0;letter-spacing:.4px} | |
| .badge{display:inline-block;font:10.5px ui-monospace,monospace;padding:2px 7px;border-radius:6px; | |
| border:1px solid var(--line);color:var(--gold);background:#10171f;white-space:nowrap} | |
| #backend{color:var(--teal)} | |
| a{color:var(--teal);text-decoration:none} | |
| #stage-wrap{position:relative;flex:1 1 auto;min-height:0;width:100%} | |
| #stage{position:absolute;inset:0} | |
| #stage canvas{display:block;width:100%;height:100%;touch-action:none;cursor:grab} | |
| #fallback{position:absolute;inset:0;display:none;align-items:center;justify-content:center; | |
| text-align:center;color:var(--para);padding:24px;font:13px ui-monospace,monospace;line-height:1.6} | |
| #fallback code{color:var(--teal)} | |
| #hud{position:absolute;left:14px;top:14px;z-index:6;display:flex;flex-direction:column;gap:7px; | |
| max-width:min(94%,440px);font:12px ui-monospace,SFMono-Regular,Menlo,monospace;color:#cfe0ea; | |
| background:rgba(6,11,16,.78);border:1px solid #15212c;border-radius:11px;padding:12px 14px; | |
| -webkit-backdrop-filter:blur(3px);backdrop-filter:blur(3px);max-height:calc(100% - 28px);overflow-y:auto} | |
| #hud .h-title{font:600 13px ui-sans-serif,system-ui;color:#eef3f6;letter-spacing:.4px; | |
| display:flex;gap:8px;align-items:center;flex-wrap:wrap} | |
| #hud .h-sub{color:#46586a;font-weight:400;font-size:11px} | |
| #hud .row{display:flex;align-items:center;gap:8px;justify-content:space-between} | |
| #hud .row .name{display:flex;align-items:center;gap:7px;color:#9fb1bf} | |
| #hud .row .dot{width:9px;height:9px;border-radius:50%;box-shadow:0 0 7px currentColor;flex:0 0 auto} | |
| #hud .row .right{display:flex;align-items:center;gap:6px} | |
| #hud .row .val{color:#eef3f6} | |
| #hud .attestation{display:block;color:#9fb1bf;font-size:9.5px;line-height:1.45;padding:5px 7px; | |
| margin:-2px 0 1px 16px;border-left:2px solid #375464;background:rgba(8,20,15,.58); | |
| overflow-wrap:anywhere;word-break:break-word} | |
| #hud .attestation[data-state="VERIFIED"]{color:var(--proof);border-left-color:var(--proof)} | |
| #hud .attestation[data-state="UNAVAILABLE"]{color:#e08a8a;border-left-color:#e08a8a} | |
| #hud .note{color:#6d7d8a;font-size:10.5px;line-height:1.45;margin-top:2px;border-top:1px solid #15212c;padding-top:6px} | |
| #hud .plainbtn{font:11px ui-monospace,monospace;padding:5px 11px;border-radius:7px;border:1px solid var(--proof); | |
| background:#08140f;color:var(--proof);cursor:pointer;width:fit-content;margin-top:2px} | |
| #hud .plain{font-size:10.5px;color:#c9d6df;line-height:1.55;border:1px dashed #26333f;border-radius:7px; | |
| padding:7px 9px;display:none;margin-top:2px} | |
| /* mold controls — bottom-right, out of the HUD's way */ | |
| #mold-ui{position:absolute;right:14px;bottom:14px;z-index:6;display:flex;gap:8px;align-items:center; | |
| font:11.5px ui-monospace,monospace} | |
| #mold-ui button{font:600 11.5px ui-monospace,monospace;padding:8px 14px;border-radius:9px;cursor:pointer; | |
| border:1px solid var(--line);background:#0b121b;color:#cfe0ea;transition:all .15s} | |
| #mold-ui button.on{border-color:var(--proof);color:var(--proof);background:#08140f; | |
| box-shadow:0 0 14px rgba(58,244,200,.25)} | |
| #mold-ui #mold-hint{color:#6d7d8a;background:rgba(6,11,16,.78);border:1px solid #15212c;border-radius:8px; | |
| padding:6px 10px;max-width:280px;display:none} | |
| #surface-caption{padding:4px 14px;border-top:1px solid var(--line);background:#060c14;color:var(--para); | |
| font:10.5px ui-monospace,monospace;letter-spacing:.2px;flex:0 0 auto;white-space:nowrap;overflow:hidden; | |
| text-overflow:ellipsis;z-index:6} | |
| #surface-caption:empty{display:none} | |
| footer{padding:6px 14px;border-top:1px solid var(--line);flex:0 0 auto;background:#070d15;color:var(--para); | |
| font:10.5px ui-monospace,monospace;letter-spacing:.3px;z-index:6;white-space:nowrap;overflow-x:auto; | |
| -webkit-overflow-scrolling:touch} | |
| @media (max-width:640px){ | |
| header{padding:8px 12px;gap:8px} | |
| h1{font-size:14px;flex:1 1 100%} | |
| header .badge{font-size:9.5px;padding:2px 6px} | |
| #three-rev-badge,#cdn-badge{display:none} | |
| #hud{max-width:calc(100% - 20px);left:10px;top:10px;font-size:11px;padding:10px 12px} | |
| #mold-ui #mold-hint{display:none } | |
| footer{font-size:9px;padding:5px 10px} | |
| } | |
| </style> | |
| </head> | |
| <body> | |
| <header> | |
| <h1>🧠 The a11oy Brain</h1> | |
| <span class="badge" id="backend">renderer: …</span> | |
| <span class="badge" id="three-rev-badge">three r<span id="three-rev">…</span></span> | |
| <span class="badge" id="cdn-badge">0 runtime CDN</span> | |
| <span class="badge">Λ = Conjecture 1</span> | |
| <a href="/static/3d/estate.html" class="badge" title="Holographic estate map — every live Hub asset">◇ estate</a> | |
| <a href="/static/3d/holographic.html" class="badge" title="The full holographic estate — 100+ live 3D surfaces">◇ surfaces</a> | |
| <a href="/" style="margin-left:auto;font:11px ui-monospace,monospace">← a11oy</a> | |
| </header> | |
| <div id="stage-wrap"> | |
| <div id="stage"></div> | |
| <div id="fallback">3D unavailable on this device — the brain needs a WebGL2 or WebGPU canvas.<br> | |
| All underlying data is still available as JSON / source, e.g.<br> | |
| <code>huggingface.co/api/models?author=SZLHOLDINGS</code> · | |
| <code>api.github.com/orgs/szl-holdings/repos</code></div> | |
| <!-- Live lobe rollup HUD (built in JS so every chip is a real doctrine label). --> | |
| <div id="hud"></div> | |
| <div id="mold-ui"> | |
| <span id="mold-hint">drag the cortex to push it out · hold <b>Shift</b> (or use two fingers) to carve in · | |
| sculpting is display-only on your device, the measured numbers never change</span> | |
| <button id="mode-btn" type="button" title="Toggle between orbiting the brain and molding its cortex">🖐 Mold</button> | |
| <button id="reset-btn" type="button" title="Restore the original cortex (display-only)">↺ Reset sculpt</button> | |
| </div> | |
| </div> | |
| <div id="surface-caption" title=""></div> | |
| <footer>Doctrine v11 · Λ = Conjecture 1 · eight lobes wired live: Hugging Face Hub (SZLHOLDINGS + open-frontier orgs) · | |
| GitHub org (szl-holdings) · ProvedFormulas.lean counted through a same-origin bounded evidence route · organ /healthz vitals · | |
| every count MEASURED or honestly UNKNOWN / NO-LIVE-DATA · sculpting is local + display-only · | |
| 0 runtime CDN (three.js vendored in-image) · trust < 100%</footer> | |
| <script type="module"> | |
| import szl3d from "/static/3d/szl3d/szl3d_boot.js"; | |
| import * as live from "/static/3d/szl3d/szl3d_live.js"; | |
| import * as label from "/static/3d/szl3d/szl3d_label.js"; | |
| import * as THREE from "three"; | |
| // --------------------------------------------------------------------------- | |
| // Doctrine v11 (binding): WIRE TO LIVE DATA. Eight lobes = one same-origin | |
| // evidence contract backed by fixed, bounded, read-only public observations. | |
| // Every value is MEASURED from a live read (a real 0 stays 0), or UNKNOWN where | |
| // the source exposes none. A failed feed shows NO-LIVE-DATA, never a guess. | |
| // Molding is a local display-only sculpt — it cannot alter any measured value. | |
| // --------------------------------------------------------------------------- | |
| const HF_ORG = "SZLHOLDINGS"; | |
| const GH_ORG = "szl-holdings"; | |
| const BRAIN_EVIDENCE = "/api/a11oy/v1/holographic/brain/evidence"; | |
| // Palette accents (doctrine-safe — NEVER purple). One per lobe. | |
| const COL = { | |
| formulas: 0x3af4c8, // proof-teal — the reasoning cortex | |
| models: 0xe8c074, // gold | |
| datasets: 0x39d3c4, // teal | |
| spaces: 0x6fb1ff, // sky | |
| collections: 0x2fd07a, // green | |
| repos: 0xe08a8a, // rose — the motor cortex (code) | |
| fleet: 0xd9e46e, // lime — brainstem vitals | |
| frontier: 0xff9d5c, // amber — the harnessed open frontier | |
| cortex: 0x0f2f33, | |
| wire: 0x2a8f86, | |
| }; | |
| // Each lobe: a fixed anatomical direction on the cortex + one live read. | |
| // `fetchStat` returns { text, honesty, caption } — resolved independently so a | |
| // single failing feed only degrades its own lobe. | |
| async function getEvidence() { | |
| // One same-origin browser read. The server performs a fixed-allowlist, read-only, | |
| // timeout + byte-bounded observation. There is no last-good or hidden fallback. | |
| const r = await fetch(BRAIN_EVIDENCE, { | |
| headers: { accept: "application/json" }, cache: "no-store", | |
| signal: AbortSignal.timeout(12000), | |
| }); | |
| if (!r.ok) throw new Error("HTTP " + r.status); | |
| const j = await r.json(); | |
| if (!j || j.schema !== "a11oy.holographic.brain-evidence.v1" || !j.lobes) { | |
| throw new Error("unexpected evidence payload"); | |
| } | |
| return j; | |
| } | |
| const EVIDENCE = getEvidence(); | |
| function requireLive(evidence, key) { | |
| const lobe = evidence.lobes && evidence.lobes[key]; | |
| if (!lobe || lobe.state !== "LIVE") { | |
| throw new Error((lobe && lobe.reason) || "source unavailable"); | |
| } | |
| return lobe; | |
| } | |
| function countText(lobe) { | |
| return lobe.lower_bound ? lobe.count + "+ (page cap — lower bound)" : String(lobe.count); | |
| } | |
| const LOBES = [ | |
| { | |
| key: "formulas", name: "Frontal — proved formulas", color: COL.formulas, | |
| dir: [0, 0.55, 0.95], url: "https://github.com/" + GH_ORG + "/a11oy/blob/22b084d4a74abb4d5911ca9dc303c35d222bd284/proofs/lutar-lean/Lutar/Puriq/Formulas/ProvedFormulas.lean", | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "formulas"); | |
| if (s.integrity_state !== "VERIFIED" || s.mutable_reference !== false || | |
| !/^[0-9a-f]{40}$/.test(s.source_commit || "") || | |
| !/^[0-9a-f]{64}$/.test(s.content_sha256 || "")) { | |
| throw new Error("formula integrity contract incomplete"); | |
| } | |
| const n = s.theorem_count; | |
| return { text: n + " theorems", honesty: "MEASURED", | |
| attestation: "proof artifact · immutable commit " + s.source_commit + | |
| " · SHA-256 " + s.content_sha256 + " · " + s.integrity_state, | |
| caption: "Frontal lobe · " + n + " `theorem` declarations counted server-side from a commit-pinned " + | |
| "ProvedFormulas.lean artifact · SHA-256 " + s.content_sha256.slice(0, 12) + "… VERIFIED · " + | |
| "MEASURED via same-origin bounded evidence route · click to read the pinned proofs" }; | |
| }, | |
| }, | |
| { | |
| key: "models", name: "Parietal — models", color: COL.models, | |
| dir: [0.55, 0.85, -0.15], url: "https://huggingface.co/" + HF_ORG, | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "models"); | |
| return { text: countText(s), honesty: s.lower_bound ? "STRUCTURAL-ONLY" : "MEASURED", | |
| caption: "Parietal lobe · " + countText(s) + " models on the live Hub · " + | |
| (s.downloads_sum_known ? "Σ " + s.downloads_sum.toLocaleString() + " downloads · MEASURED (live Hub)" : "some download counts UNKNOWN") + | |
| " · click to open " + HF_ORG + " on Hugging Face" }; | |
| }, | |
| }, | |
| { | |
| key: "datasets", name: "Temporal L — datasets", color: COL.datasets, | |
| dir: [-0.95, -0.05, 0.15], url: "https://huggingface.co/" + HF_ORG + "?tab=datasets" , | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "datasets"); | |
| return { text: countText(s), honesty: s.lower_bound ? "STRUCTURAL-ONLY" : "MEASURED", | |
| caption: "Left temporal lobe · " + countText(s) + " datasets on the live Hub · " + | |
| (s.downloads_sum_known ? "Σ " + s.downloads_sum.toLocaleString() + " downloads · MEASURED (live Hub)" : "some download counts UNKNOWN") + | |
| " · click to open the datasets" }; | |
| }, | |
| }, | |
| { | |
| key: "spaces", name: "Temporal R — Spaces", color: COL.spaces, | |
| dir: [0.95, -0.05, 0.15], url: "https://huggingface.co/" + HF_ORG + "?tab=spaces", | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "spaces"); | |
| return { text: countText(s), honesty: s.lower_bound ? "STRUCTURAL-ONLY" : "MEASURED", | |
| caption: "Right temporal lobe · " + countText(s) + " live Spaces · " + | |
| (s.likes_sum_known ? "Σ " + s.likes_sum.toLocaleString() + " likes · MEASURED (live Hub)" : "some like counts UNKNOWN") + | |
| " · Space downloads: UNKNOWN (Hub exposes none) · click to open the Spaces" }; | |
| }, | |
| }, | |
| { | |
| key: "collections", name: "Occipital — collections", color: COL.collections, | |
| dir: [0, 0.35, -1], url: "https://huggingface.co/" + HF_ORG, | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "collections"); | |
| const honesty = s.lower_bound ? "STRUCTURAL-ONLY" : "MEASURED"; | |
| return { text: countText(s), honesty, | |
| caption: "Occipital lobe · " + countText(s) + " curated collections on the live Hub · " + honesty + " · " + | |
| "click to open " + HF_ORG }; | |
| }, | |
| }, | |
| { | |
| key: "repos", name: "Cerebellum — repositories", color: COL.repos, | |
| dir: [0, -0.75, -0.75], url: "https://github.com/" + GH_ORG, | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "repos"); | |
| return { text: countText(s), honesty: s.lower_bound ? "STRUCTURAL-ONLY" : "MEASURED", | |
| caption: "Cerebellum · " + countText(s) + " public repositories in the live GitHub org · " + | |
| (s.stargazers_count_sum_known ? "Σ " + s.stargazers_count_sum.toLocaleString() + " stars · MEASURED (GitHub API)" : "some star counts UNKNOWN") + | |
| " · click to open github.com/" + GH_ORG }; | |
| }, | |
| }, | |
| { | |
| key: "fleet", name: "Brainstem — fleet vitals", color: COL.fleet, | |
| dir: [0, -0.92, 0.05], url: "https://huggingface.co/" + HF_ORG, | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "fleet"); | |
| return { text: s.up_count + "/" + s.organ_count + " organs report ok", honesty: "MEASURED", | |
| caption: "Brainstem · live /healthz probes made by the same-origin bounded evidence route — " + | |
| s.organs.map((r) => r.organ + ": " + (r.up ? "ok" : r.health_state)).join(" · ") + | |
| " · MEASURED (each value is that organ's own live answer; a missing endpoint is said, not guessed)" }; | |
| }, | |
| }, | |
| { | |
| key: "frontier", name: "R frontal — open frontier", color: COL.frontier, | |
| dir: [0.7, 0.45, 0.62], url: "https://huggingface.co/deepseek-ai", | |
| fetchStat: async () => { | |
| const s = requireLive(await EVIDENCE, "frontier"); | |
| return { text: (s.lower_bound ? "\u2265 " + s.count : String(s.count)) + " open models", | |
| honesty: s.data_label, | |
| caption: "Right frontal · the open-weights frontier harnessed by the a11oy backbone " + | |
| "(DeepSeek · Qwen · Kimi/Moonshot — wired providers · GLM/Z.ai — watched) · " + | |
| s.sources.map((c) => c.org + ": " + c.count_display).join(" · ") + | |
| " · counted live from the public Hub via same-origin bounded evidence (page cap 100/org — lower bound when capped)" }; | |
| }, | |
| }, | |
| ]; | |
| const stageEl = document.getElementById("stage"); | |
| const fallbackEl = document.getElementById("fallback"); | |
| const captionEl = document.getElementById("surface-caption"); | |
| document.getElementById("three-rev").textContent = THREE.REVISION; | |
| let stage = null; | |
| let brain = null; // THREE.Group holding cortex + lobes | |
| let cortex = null; // the sculptable mesh | |
| let cortexWire = null; // wireframe overlay sharing the same geometry | |
| let basePos = null; // pristine vertex positions for Reset | |
| const lobeMarkers = {}; // key -> { marker, label, lobe } | |
| const pickable = []; // lobe markers for raycasting | |
| // --------------------------------------------------------------------------- | |
| // boot the shared renderer (WebGL2 default — WebGPU is not production-safe on | |
| // all platforms per doctrine; the toolkit falls back honestly either way). | |
| // --------------------------------------------------------------------------- | |
| async function ensureStage() { | |
| if (stage) return stage; | |
| try { | |
| stage = await szl3d.boot(stageEl, { | |
| bloom: { strength: 0.85, radius: 0.5, threshold: 0.18 }, | |
| cameraPos: [0, 3.5, 12.5], | |
| forceWebGL: true, | |
| }); | |
| document.getElementById("backend").textContent = "renderer: " + stage.backend.toUpperCase(); | |
| stage.start(); | |
| } catch (e) { | |
| fallbackEl.style.display = "flex"; | |
| document.getElementById("backend").textContent = "renderer: UNAVAILABLE"; | |
| console.error("[brain] stage boot failed:", e); | |
| throw e; | |
| } | |
| return stage; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // The cortex: a high-resolution icosphere shaped into a brain-like form with a | |
| // midline fissure and deterministic sine-fold "gyri". The shaping is purely | |
| // aesthetic (display-only); the DATA lives in the lobe reads, never the shape. | |
| // --------------------------------------------------------------------------- | |
| function brainShape(v) { | |
| // v: THREE.Vector3 on the unit sphere -> returns shaped position | |
| const x = v.x, y = v.y, z = v.z; | |
| // base ellipsoid: wider than tall, longest front-to-back | |
| let px = x * 1.06, py = y * 0.88, pz = z * 1.28; | |
| // flatten the underside a little (temporal floor) | |
| if (py < -0.45) py = -0.45 + (py + 0.45) * 0.55; | |
| // midline longitudinal fissure: pinch |x| near 0 on the upper half | |
| const mid = Math.exp(-(x * x) / 0.02); | |
| if (y > -0.1) { py -= 0.10 * mid * (y + 0.1); px *= (1 - 0.16 * mid); } | |
| // deterministic cortical folds (sine-noise, display-only) | |
| const th = Math.atan2(z, x), ph = Math.asin(Math.max(-1, Math.min(1, y))); | |
| const fold = | |
| 0.028 * Math.sin(9 * th + 2.1 * Math.sin(3 * ph)) + | |
| 0.022 * Math.sin(7 * ph + 1.7 * Math.sin(4 * th)) + | |
| 0.014 * Math.sin(13 * th - 5 * ph); | |
| const r = 1 + fold * (y > -0.35 ? 1 : 0.35); // calmer folds near the base | |
| return new THREE.Vector3(px * r, py * r, pz * r); | |
| } | |
| function buildBrain() { | |
| brain = new THREE.Group(); | |
| stage.scene.add(brain); | |
| const R = 3.1; | |
| const geo = new THREE.IcosahedronGeometry(1, 5); // 10242 verts — smooth enough to sculpt | |
| const pos = geo.attributes.position; | |
| const v = new THREE.Vector3(); | |
| for (let i = 0; i < pos.count; i++) { | |
| v.fromBufferAttribute(pos, i).normalize(); | |
| const p = brainShape(v).multiplyScalar(R); | |
| pos.setXYZ(i, p.x, p.y, p.z); | |
| } | |
| geo.computeVertexNormals(); | |
| basePos = new Float32Array(pos.array); // pristine copy for Reset | |
| cortex = new THREE.Mesh( | |
| geo, | |
| new THREE.MeshStandardMaterial({ | |
| color: COL.cortex, emissive: 0x123a3e, emissiveIntensity: 0.55, | |
| metalness: 0.15, roughness: 0.55, flatShading: false, | |
| }), | |
| ); | |
| brain.add(cortex); | |
| // wireframe overlay SHARES the geometry — sculpting updates both in lockstep | |
| cortexWire = new THREE.Mesh( | |
| geo, | |
| new THREE.MeshBasicMaterial({ color: COL.wire, wireframe: true, transparent: true, opacity: 0.14 }), | |
| ); | |
| cortexWire.scale.setScalar(1.001); | |
| brain.add(cortexWire); | |
| // faint polar floor grid for depth | |
| try { | |
| const grid = new THREE.PolarGridHelper(9, 8, 6, 64, 0x14212b, 0x0e1922); | |
| grid.position.y = -4.6; | |
| if (grid.material) { grid.material.transparent = true; grid.material.opacity = 0.35; } | |
| if (Array.isArray(grid.material)) grid.material.forEach((m) => { m.transparent = true; m.opacity = 0.35; }); | |
| stage.scene.add(grid); | |
| } catch (_) {} | |
| // lobe markers + billboards (loading placeholders until the live reads land) | |
| LOBES.forEach((lobe) => { | |
| const d = new THREE.Vector3(lobe.dir[0], lobe.dir[1], lobe.dir[2]).normalize(); | |
| const surf = brainShape(d).multiplyScalar(R); | |
| const marker = new THREE.Mesh( | |
| new THREE.SphereGeometry(0.22, 18, 18), | |
| new THREE.MeshStandardMaterial({ | |
| color: lobe.color, emissive: lobe.color, emissiveIntensity: 0.55, | |
| metalness: 0.25, roughness: 0.4, | |
| }), | |
| ); | |
| marker.position.copy(surf).multiplyScalar(1.04); | |
| marker.userData = { caption: lobe.name + " · loading live read…", url: lobe.url, base: 0.55 }; | |
| brain.add(marker); | |
| pickable.push(marker); | |
| const lp = surf.clone().multiplyScalar(1.28); | |
| const lbl = label.billboard(THREE, "STRUCTURAL-ONLY", | |
| { text: lobe.name + " · …", scale: 0.42, position: [lp.x, lp.y, lp.z] }); | |
| brain.add(lbl); | |
| lobeMarkers[lobe.key] = { marker, label: lbl, lobe, labelPos: lp }; | |
| }); | |
| // gentle idle motion + marker pulse (paused while molding so the surface holds still) | |
| const clock = new THREE.Clock(); | |
| stage.onFrame(() => { | |
| const t = clock.getElapsedTime(); | |
| if (!molding && !dragging) brain.rotation.y += 0.0016; | |
| Object.values(lobeMarkers).forEach(({ marker }, i) => { | |
| const s = 1 + 0.1 * Math.sin(t * 1.6 + i * 1.1); | |
| marker.scale.setScalar(s); | |
| }); | |
| }); | |
| } | |
| // swap a lobe billboard (billboards are cheap canvas sprites; rebuild in place) | |
| function refreshLobeLabel(key, honesty, text) { | |
| const lm = lobeMarkers[key]; | |
| if (!lm) return; | |
| brain.remove(lm.label); | |
| try { if (lm.label.material && lm.label.material.map) lm.label.material.map.dispose(); lm.label.material.dispose(); } catch (_) {} | |
| const p = lm.labelPos; | |
| const lbl = label.billboard(THREE, honesty, { text, scale: 0.42, position: [p.x, p.y, p.z] }); | |
| brain.add(lbl); | |
| lm.label = lbl; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // MOLDING — local, display-only sculpting. Raycast the cortex, displace nearby | |
| // vertices along the drag direction with a smooth falloff. Reset restores the | |
| // pristine geometry. None of this touches any measured value. | |
| // --------------------------------------------------------------------------- | |
| let molding = false; // Mold mode on/off | |
| let dragging = false; // actively sculpting this pointer-drag | |
| const SCULPT_R = 0.9; // falloff radius (world units) | |
| const SCULPT_K = 0.05; // strength per move event | |
| const modeBtn = document.getElementById("mode-btn"); | |
| const resetBtn = document.getElementById("reset-btn"); | |
| const moldHint = document.getElementById("mold-hint"); | |
| function setMold(on) { | |
| molding = on; | |
| modeBtn.classList.toggle("on", on); | |
| modeBtn.textContent = on ? "🧭 Orbit" : "🖐 Mold"; | |
| moldHint.style.display = on ? "block" : "none"; | |
| if (stage && stage.controls) stage.controls.enabled = !on; | |
| stage.renderer.domElement.style.cursor = on ? "crosshair" : "grab"; | |
| captionEl.textContent = on | |
| ? "Mold mode · drag the cortex to push it out · hold Shift to carve in · Reset restores it · display-only, data untouched" | |
| : "Orbit mode · drag to orbit, scroll to zoom · hover a lobe for its live read · click a lobe to open its source"; | |
| } | |
| function wireMolding() { | |
| const canvas = stage.renderer.domElement; | |
| const ray = new THREE.Raycaster(); | |
| const ndc = new THREE.Vector2(); | |
| const hitP = new THREE.Vector3(); | |
| const vv = new THREE.Vector3(); | |
| const nn = new THREE.Vector3(); | |
| function castCortex(ev) { | |
| const rect = canvas.getBoundingClientRect(); | |
| ndc.x = ((ev.clientX - rect.left) / rect.width) * 2 - 1; | |
| ndc.y = -((ev.clientY - rect.top) / rect.height) * 2 + 1; | |
| ray.setFromCamera(ndc, stage.camera); | |
| const hit = ray.intersectObject(cortex, false)[0]; | |
| return hit || null; | |
| } | |
| function sculpt(hit, carveIn) { | |
| // hit.point is world-space; cortex lives inside the rotated `brain` group, | |
| // so work in the cortex's local space. | |
| hitP.copy(hit.point); | |
| cortex.worldToLocal(hitP); | |
| const pos = cortex.geometry.attributes.position; | |
| const nrm = cortex.geometry.attributes.normal; | |
| const sgn = carveIn ? -1 : 1; | |
| for (let i = 0; i < pos.count; i++) { | |
| vv.fromBufferAttribute(pos, i); | |
| const d = vv.distanceTo(hitP); | |
| if (d > SCULPT_R) continue; | |
| const w = Math.pow(1 - d / SCULPT_R, 2); // smooth falloff | |
| nn.fromBufferAttribute(nrm, i); | |
| vv.addScaledVector(nn, sgn * SCULPT_K * w); | |
| pos.setXYZ(i, vv.x, vv.y, vv.z); | |
| } | |
| pos.needsUpdate = true; | |
| cortex.geometry.computeVertexNormals(); | |
| } | |
| canvas.addEventListener("pointerdown", (ev) => { | |
| if (!molding) return; | |
| const hit = castCortex(ev); | |
| if (hit) { dragging = true; canvas.setPointerCapture(ev.pointerId); sculpt(hit, ev.shiftKey || ev.button === 2); } | |
| }); | |
| canvas.addEventListener("pointermove", (ev) => { | |
| if (!molding || !dragging) return; | |
| const hit = castCortex(ev); | |
| if (hit) sculpt(hit, ev.shiftKey || ev.buttons === 2); | |
| }); | |
| const stop = (ev) => { if (dragging) { dragging = false; try { canvas.releasePointerCapture(ev.pointerId); } catch (_) {} } }; | |
| canvas.addEventListener("pointerup", stop); | |
| canvas.addEventListener("pointercancel", stop); | |
| canvas.addEventListener("contextmenu", (ev) => { if (molding) ev.preventDefault(); }); | |
| modeBtn.addEventListener("click", () => setMold(!molding)); | |
| resetBtn.addEventListener("click", () => { | |
| const pos = cortex.geometry.attributes.position; | |
| pos.array.set(basePos); | |
| pos.needsUpdate = true; | |
| cortex.geometry.computeVertexNormals(); | |
| captionEl.textContent = "Cortex restored to its pristine shape (the sculpt was display-only all along)."; | |
| }); | |
| } | |
| // --------------------------------------------------------------------------- | |
| // HUD — eight live lobe reads + doctrine honesty chips. | |
| // --------------------------------------------------------------------------- | |
| const hudEl = document.getElementById("hud"); | |
| const hud = {}; | |
| let liveBadge = null; | |
| function buildHud() { | |
| const title = document.createElement("div"); | |
| title.className = "h-title"; | |
| title.innerHTML = "\ud83e\udde0 The a11oy Brain <span class='h-sub'>eight lobes \u00b7 eight live reads</span>"; | |
| hudEl.appendChild(title); | |
| liveBadge = live.createBadge(); | |
| hudEl.appendChild(liveBadge.el); | |
| const mkRow = (key, name, color) => { | |
| const wrap = document.createElement("div"); wrap.className = "row"; | |
| const left = document.createElement("span"); left.className = "name"; | |
| if (color != null) { | |
| const dot = document.createElement("span"); dot.className = "dot"; | |
| dot.style.color = "#" + color.toString(16).padStart(6, "0"); | |
| left.appendChild(dot); | |
| } | |
| left.appendChild(document.createTextNode(name)); | |
| const right = document.createElement("span"); right.className = "right"; | |
| const val = document.createElement("span"); val.className = "val"; val.textContent = "…"; | |
| const chip = label.chip("STRUCTURAL-ONLY"); chip.style.transform = "scale(.9)"; | |
| right.appendChild(val); right.appendChild(chip); | |
| wrap.appendChild(left); wrap.appendChild(right); | |
| hudEl.appendChild(wrap); | |
| hud[key] = { val, chip }; | |
| }; | |
| LOBES.forEach((l) => { | |
| mkRow(l.key, l.name, l.color); | |
| if (l.key === "formulas") { | |
| const proof = document.createElement("a"); | |
| proof.id = "formula-attestation"; | |
| proof.className = "attestation"; | |
| proof.href = l.url; | |
| proof.target = "_blank"; | |
| proof.rel = "noopener"; | |
| proof.setAttribute("aria-live", "polite"); | |
| proof.dataset.state = "PENDING"; | |
| proof.textContent = "proof artifact · integrity verification pending…"; | |
| proof.title = "Open the immutable formula source artifact"; | |
| hudEl.appendChild(proof); | |
| hud[l.key].attestation = proof; | |
| } | |
| }); | |
| const note = document.createElement("div"); | |
| note.className = "note"; | |
| note.textContent = "Each lobe is one live public observation (Hugging Face Hub, GitHub API, the raw " + | |
| "ProvedFormulas.lean source, or the organs' own /healthz answers), exposed to this page through one " + | |
| "same-origin, fixed-allowlist, bounded read-only evidence contract with no stale fallback. " + | |
| "Every count is MEASURED from that read (a real 0 stays 0); " + | |
| "UNKNOWN where the source exposes none; NO-LIVE-DATA if a feed is unreachable. Molding the cortex is a " + | |
| "local, display-only sculpt — it never changes a measured number. Nothing is fabricated. \u039b = Conjecture 1."; | |
| hudEl.appendChild(note); | |
| const legend = label.legend(); legend.style.opacity = "0.85"; | |
| hudEl.appendChild(legend); | |
| const pl = document.createElement("button"); | |
| pl.className = "plainbtn"; pl.textContent = "\u25d1 what this means"; | |
| pl.title = "Plain-language explanation for investors & consumers."; | |
| const pd = document.createElement("div"); pd.className = "plain"; | |
| pd.innerHTML = "<b>What this means:</b> this brain is a live portrait of what SZL Holdings actually " + | |
| "publishes, organ by organ: its <b>AI models</b>, <b>datasets</b>, running <b>Spaces</b> and " + | |
| "<b>collections</b> on Hugging Face, its open <b>code repositories</b> on GitHub, and the machine-checked " + | |
| "<b>mathematical theorems</b> in its proof corpus \u2014 each fetched live from the public source the moment " + | |
| "you opened this page. The <b>brainstem</b> shows the platform's organs answering their own health checks " + | |
| "right now, and the <b>open frontier</b> lobe counts the open-weights model fleets (DeepSeek, Qwen, Kimi, GLM) " + | |
| "that a11oy's multi-provider backbone is built to harness. We only show numbers those sources actually report; " + | |
| "anything they don't expose is " + | |
| "marked <b>UNKNOWN</b>, and a feed that's down shows <b>NO-LIVE-DATA</b>, never a made-up figure. " + | |
| "And yes \u2014 you can <b>mold</b> the cortex with your pointer. That sculpt happens only on your screen: " + | |
| "it's the one part of this page that is play, and it is labeled as such."; | |
| pl.addEventListener("click", () => { const on = pd.style.display !== "block"; pd.style.display = on ? "block" : "none"; pl.style.background = on ? "#0f2a20" : "#08140f"; }); | |
| hudEl.appendChild(pl); hudEl.appendChild(pd); | |
| } | |
| function setRow(key, text, honesty) { | |
| const r = hud[key]; | |
| if (!r) return; | |
| r.val.textContent = text; | |
| label.updateChip(r.chip, honesty); | |
| } | |
| function setFormulaAttestation(text, state) { | |
| const proof = hud.formulas && hud.formulas.attestation; | |
| if (!proof) return; | |
| proof.textContent = text; | |
| proof.dataset.state = state; | |
| proof.title = text; | |
| } | |
| // --------------------------------------------------------------------------- | |
| // pointer picking — hover to caption a lobe, click to open its live source. | |
| // (Only in orbit mode; mold mode owns the pointer.) | |
| // --------------------------------------------------------------------------- | |
| function wirePicking() { | |
| const canvas = stage.renderer.domElement; | |
| const ray = new THREE.Raycaster(); | |
| const ndc = new THREE.Vector2(); | |
| let hovered = null; | |
| function pick(ev) { | |
| const rect = canvas.getBoundingClientRect(); | |
| ndc.x = ((ev.clientX - rect.left) / rect.width) * 2 - 1; | |
| ndc.y = -((ev.clientY - rect.top) / rect.height) * 2 + 1; | |
| ray.setFromCamera(ndc, stage.camera); | |
| const hit = ray.intersectObjects(pickable, false)[0]; | |
| return hit ? hit.object : null; | |
| } | |
| function setHover(obj) { | |
| if (hovered === obj) return; | |
| if (hovered) hovered.material.emissiveIntensity = hovered.userData.base; | |
| hovered = obj; | |
| if (hovered) { | |
| hovered.material.emissiveIntensity = Math.min(1.4, hovered.userData.base + 0.6); | |
| captionEl.textContent = hovered.userData.caption; | |
| captionEl.title = hovered.userData.caption; | |
| canvas.style.cursor = "pointer"; | |
| } else { | |
| canvas.style.cursor = "grab"; | |
| } | |
| } | |
| canvas.addEventListener("pointermove", (ev) => { if (!molding) setHover(pick(ev)); }); | |
| canvas.addEventListener("pointerleave", () => setHover(null)); | |
| canvas.addEventListener("click", (ev) => { | |
| if (molding) return; | |
| const obj = pick(ev); | |
| if (obj && obj.userData.url) window.open(obj.userData.url, "_blank", "noopener"); | |
| }); | |
| } | |
| // --------------------------------------------------------------------------- | |
| // orchestrate: boot -> brain -> HUD -> eight live reads (each honest on its own). | |
| // The live reads NEVER depend on the renderer: on a WebGL-less device the HUD | |
| // still fills with real measured values (the LIVE badge reflects the feeds, | |
| // not the canvas) — an honest fallback, never a frozen "…". | |
| // --------------------------------------------------------------------------- | |
| async function main() { | |
| buildHud(); | |
| let stageOk = true; | |
| try { await ensureStage(); } catch (_) { stageOk = false; } | |
| if (stageOk) { | |
| buildBrain(); | |
| wirePicking(); | |
| wireMolding(); | |
| setMold(false); | |
| } | |
| let ok = 0, structuralOnly = false; | |
| await Promise.all(LOBES.map(async (lobe) => { | |
| try { | |
| const s = await lobe.fetchStat(); | |
| setRow(lobe.key, s.text, s.honesty); | |
| if (lobe.key === "formulas") setFormulaAttestation(s.attestation, "VERIFIED"); | |
| refreshLobeLabel(lobe.key, s.honesty, lobe.name + " \u00b7 " + s.text); | |
| const lm = lobeMarkers[lobe.key]; | |
| if (lm) lm.marker.userData.caption = s.caption; | |
| if (s.honesty !== "MEASURED") structuralOnly = true; | |
| ok++; | |
| } catch (e) { | |
| console.warn("[brain] " + lobe.key + " unavailable:", e && e.message); | |
| setRow(lobe.key, "NO-LIVE-DATA", "STRUCTURAL-ONLY"); | |
| if (lobe.key === "formulas") { | |
| setFormulaAttestation("proof artifact · integrity UNAVAILABLE · no theorem count trusted", "UNAVAILABLE"); | |
| } | |
| refreshLobeLabel(lobe.key, "STRUCTURAL-ONLY", lobe.name + " \u00b7 NO-LIVE-DATA"); | |
| const lm = lobeMarkers[lobe.key]; | |
| if (lm) lm.marker.userData.caption = lobe.name + " \u00b7 NO-LIVE-DATA \u2014 this feed is unreachable right now; nothing is guessed in its place."; | |
| } | |
| })); | |
| if (ok === LOBES.length && !structuralOnly) { | |
| if (liveBadge) liveBadge.set(live.LIVE_STATES.LIVE, { at: Date.now() }); | |
| } else if (ok > 0) { | |
| if (liveBadge) liveBadge.set(live.LIVE_STATES.DEGRADED, { at: Date.now() }); | |
| } else { | |
| if (liveBadge) liveBadge.set(live.LIVE_STATES.ERROR); | |
| } | |
| } | |
| // expose a tiny hook for headless selftest harnesses (parity with the shell). | |
| window.__SZL3D_BRAIN__ = { get stage() { return stage; }, get cortex() { return cortex; }, lobeMarkers, LOBES }; | |
| main(); | |
| </script> | |
| </body> | |
| </html> | |