/* eslint-disable */ /* TrustFortress — sections, rewritten to tell the math story. Depends on globals from cube.jsx (FlowCube, ProblemCube, CornerCube, NarrativeCube, FACES, T) and from app.jsx (R reveal, Eyebrow, Logomark, go) — those load AFTER us, so we reference them lazily inside components, not at module top-level. */ const { useState: uS, useEffect: uE, useRef: uR } = React; // T palette is on window (set by cube.jsx). var (not const/let) so multiple // babel-standalone scripts can re-declare without "already declared" errors. var T = window.T; /* hoisted helpers used by PROBLEMS */ function arr9(v) { return Array(9).fill(v); } function arr9WithFail(idx) { const a = Array(9).fill(true); a[idx] = false; return a; } /* ============================================================ HERO The cube enacts the admission flow on its surface. ============================================================ */ function Hero() { return (
Cubie v2.0 · 163 theorems · 7 deliverables · WriteOK = D ∧ G ∧ T ∧ P Live · sub-1ms hot path
Proof-carrying admission

Every AI request
becomes a cube.
Six faces solve, or it never runs.

Before a GPU spends a cycle, the request is folded into a {" "}54-check lattice — six faces, three rows each: {" "}proof, binding, freshness. Two corners must agree. Either an admission lease emits in microseconds, or a typed denial certificate names the exact cell that failed.

{[ { k: "DEPLOY △", v: "identity ∧ lineage ∧ policy", c: T.violetSoft }, { k: "COMPUTE △", v: "context ∧ runtime ∧ outcome", c: T.teal }, { k: "TOPOLOGY", v: "nonces unique · targets match", c: T.amber }, { k: "POLICY", v: "signed compiled bundle", c: T.sky }, ].map((x, i) => (
{x.k}
{x.v}
))}
); } /* ============================================================ PROBLEM Each scenario shows the cube state + denial certificate. ============================================================ */ const PROBLEMS = [ { title: "An agent deleted production in 9 seconds", problem: "A coding agent found an API token that, by accident, had blanket authority across every environment. One call, no confirmation. Database and backups gone in under ten seconds.", failFace: "policy", failCell: 5, // row B, cell 6 -> action_class denyCode: "DENY_POLICY", seam: "Identity ↔ Policy", theorem: "Ramen V1.19.1 · #14 / 23", cert: "policy.B.action_class · 'destructive ops require human approval'", color: T.red, faces: { identity: arr9(true), lineage: arr9(true), policy: arr9WithFail(5), context: arr9(null), runtime: arr9(null), outcome: arr9(null), }, }, { title: "A staging task reached production", problem: "The agent was working in staging. The token's scope wasn't bound to environment. Without a topology check, the request slipped through to a prod target.", failFace: "runtime", failCell: 8, denyCode: "DENY_TOPOLOGY", seam: "Context ↔ Runtime", theorem: "CubieBridge V1.40 · #5 / 6", cert: "runtime.C.host_alive · 'caller env=staging, target pool=prod-A100'", color: T.violetSoft, faces: { identity: arr9(true), lineage: arr9(true), policy: arr9(true), context: arr9(true), runtime: arr9WithFail(8), outcome: arr9(null), }, }, { title: "Two thirds of compute is wasted", problem: "Context bombs and retry loops pass every credential check but will never produce useful output. The dashboard reports the GPU as busy and healthy.", failFace: "outcome", failCell: 0, denyCode: "DENY_OR_SHAPE_GPU", seam: "Runtime ↔ Outcome", theorem: "Track C · waste corollary 41 / 54", cert: "outcome.C.goodput_positive · 'expected goodput ≤ 0, throttle 5s'", color: T.teal, faces: { identity: arr9(true), lineage: arr9(true), policy: arr9(true), context: arr9(true), runtime: arr9(true), outcome: arr9WithFail(0), }, }, { title: "Backups stored in the same blast radius", problem: "Provider sold volume backups as resilience. Backups were on the same volume. Volume deleted, backups gone with it. Most recent recoverable backup was three months old.", failFace: "outcome", failCell: 7, denyCode: "DENY_POLICY", seam: "Policy ↔ Outcome", theorem: "Ramen V1.19.1 · #23 / 23", cert: "outcome.C.blast_radius · 'irreversible op without out-of-band recovery'", color: T.amber, faces: { identity: arr9(true), lineage: arr9(true), policy: arr9(true), context: arr9(true), runtime: arr9(true), outcome: arr9WithFail(7), }, }, ]; function Problem() { return (
02 · Typed denial certificates

When the cube can't solve,
it tells you which cell broke.

Real incidents. Each one names a single cell — face, row, predicate — backed by a numbered theorem in the verification stack. Denial isn't an opinion; it's an explainable certificate the auditor can replay.

{PROBLEMS.map((p, i) => (
{String(i + 1).padStart(2, "0")} / INCIDENT

{p.title}

{p.problem}

{p.seam.toUpperCase()}
{String(i + 1).padStart(2, "0")} / DENIAL CERTIFICATE
{p.denyCode} req-{(0xa1c30b + i*7).toString(16)}
cell {p.cert}
theorem ⊢ {p.theorem}
epoch policy=2841 · telem=11929
Denied before prefill
))}
System prompts are advisory.{" "} Compiled bundles are enforcing. The verdict lives in bytecode tied to a theorem hash, not in a paragraph the model is supposed to obey.
); } /* ============================================================ CUBE — show the 6 faces, the 3-row schema, and how they collapse into 2 corners. ============================================================ */ function CubeSection() { const [af, setAf] = uS("identity"); const active = FACES.find((f) => f.id === af); // Build state where the active face is fully on, others dim const state = {}; FACES.forEach((f) => { state[f.id] = f.id === af ? Array(9).fill(true) : Array(9).fill(null); }); return (
03 · The 54-check lattice

Six faces. Three rows each.
Proof. Binding. Freshness.

Each face answers one of six questions — who, what, where, how, why, when. Each face has the same three rows: row A is presence (does the proof exist?), row B is binding (does it match?), row C is freshness (is it still valid?). 6 × 3 × 3 = 54 finite checks. Pick a face.

{FACES.map((f) => ( ))}
{active.label.toUpperCase()} · {active.q}
{active.corner === "deploy" ? "DEPLOYMENT △" : "COMPUTE △"} · 9 cells

{{ identity: "Who is acting, and is it still them?", lineage: "Where did this code come from?", policy: "Why is this allowed, right now?", context: "What does the request actually look like?", runtime: "How will this fit the hardware?", outcome: "When is this worth burning a cycle?", }[active.id]}

{/* 3x3 schema table */}
{[ { row: "A", label: "presence", desc: "is the proof there?" }, { row: "B", label: "binding", desc: "does it match?" }, { row: "C", label: "freshness",desc: "is it still valid?" }, ].map((r, ri) => (
{r.row}
{r.label}
{active.rows[ri].map((cell, ci) => (
{active.id}.{r.row}.{ci+1}
{cell}
))} ))}
One cell red ⇒ face fails ⇒ corner fails ⇒ DENY (before prefill).
{/* Two-corner decomposition */}
The two-corner theorem

Six faces collapse to a single line of math.

The cube has eight corners; only two carry decisions. The Deployment corner unites identity, lineage and policy — it asks "is the right software running with the right permission?" The Compute corner unites context, runtime and outcome — it asks "is it worth a GPU cycle?" Both must pass. Neither is sufficient alone.

∧
WriteOK
= D ∧ G ∧ T ∧ P
CubieBridge V1.40
theorems #1–#6
); } function CornerPanel({ kind }) { const isDeploy = kind === "deploy"; const color = isDeploy ? T.violetSoft : T.teal; const faces = FACES.filter((f) => f.corner === (isDeploy ? "deploy" : "compute")); return (
{isDeploy ? "DEPLOYMENT △" : "COMPUTE △"}
{isDeploy ? "right software, right source, right permission" : "fits the hardware, won't waste a cycle"}
{faces.map((f) => (
{f.label} {f.id}.A · {f.id}.B · {f.id}.C
))}
{isDeploy ? "id_ok ∧ attest_ok ∧ prov_ok ∧ lin_ok" : "time_ok ∧ scope_ok ∧ waste_ok"}
); } /* ============================================================ HOT PATH — sub-1ms timeline ============================================================ */ function HotPath() { const [t, setT] = uS(0); // 0..100 progress uE(() => { let raf; let start = performance.now(); const tick = (now) => { const elapsed = (now - start) / 1000; // seconds const cycle = (elapsed % 5) / 5; // 0..1 every 5s setT(cycle * 100); raf = requestAnimationFrame(tick); }; raf = requestAnimationFrame(tick); return () => cancelAnimationFrame(raf); }, []); const stages = [ { label: "envelope parse", sub: "headers + signed metadata", ns: "100µs", at: 0, w: 18, color: T.violetSoft }, { label: "5VID + PoP cache", sub: "no TLS handshake, cached", ns: "20µs", at: 18, w: 8, color: T.sky }, { label: "SeamFacts build", sub: "bitsets, epochs, hashes", ns: "80µs", at: 26, w: 14, color: T.amber }, { label: "bytecode VM", sub: "branch-light Boolean predicates", ns: "120µs", at: 40, w: 22, color: T.mint }, { label: "telem snapshot lookup",sub: "RCU shared-mem · no syscall", ns: "70µs", at: 62, w: 12, color: T.teal }, { label: "corner reduce", sub: "D ∧ G ∧ T ∧ P", ns: "50µs", at: 74, w: 10, color: T.violet }, { label: "lease / cert mint", sub: "HMAC + EdDSA, 8-byte tag", ns: "60µs", at: 84, w: 12, color: T.fg }, { label: "forward", sub: "to scheduler / GPU prefill", ns: "30µs", at: 96, w: 4, color: T.mint }, ]; return (
04 · Sub-1ms hot path

From request to lease
in less than a millisecond.

The cube is not built from a free-form prompt. The hot path takes a bounded envelope, joins it against locally-cached snapshots — registry, attestation epoch, telemetry epoch, signed policy bundle — and runs branch-light bytecode against fixed-size fact tables. Anything slow lives in the cold path and arrives via signed bundles.

{/* timeline */}
{/* axis */}
{/* progress bar */}
{/* head */}
{/* stage blocks */} {stages.map((s, i) => { const reached = t >= s.at; return (
{s.ns}
{s.label}
{s.sub}
); })} {/* rail labels */}
T = 0
T < 1ms · admission lease emitted
{/* explicitly excluded */}
Explicitly excluded from hot path
    {[ "Live DCGM polling", "Fresh TPM/Sigstore verification", "Full prompt semantic scan", "New TLS handshake", "Remote OPA bundle pull", "Transparency log lookup", ].map((x) => (
  • {x}
    • ))}
These run on the cold path and are pre-baked into signed bundles + epoch snapshots before requests land.
Read-only inputs the hot path uses
    {[ "Signed bundle (policy + theorem hash)", "Attestation epoch (TPM/TDX cached)", "Telemetry epoch (rack-state hash)", "5VID identity cache (PoP-bound)", "Model + route registry snapshot", "Replay window + nonce ring", ].map((x) => (
  • {x}
    • ))}
Same request × same epoch ⇒ same verdict. Determinism is a theorem, not a test.
{/* Energy arbitrage callout */}
Energy arbitrage
It costs 1.75 J to evaluate the cube. A wasted GPU prefill burns 43,750 J.
25,000×
); } /* ============================================================ SEAMS — same cross-corner spirit, but now showing seams as the actual edges between corner-incident faces. ============================================================ */ function SeamSection() { const [active, setActive] = uS(0); const examples = [ { title: "Two requests look identical to monitoring", faces: ["identity","policy"], scenario: "Same route, model, telemetry, health, token count, service. Dashboards see them as twins.", seam: "But A has fresh PoP-bound SVID and current policy epoch. B has a replayed nonce and a stale telemetry snapshot. The identity↔policy seam diverges. A admits in 240µs. B emits DENY_BYPASS.", thm: "V1.31 corner spoofing #2", color: T.amber, }, { title: "Compute that looks productive but isn't", faces: ["context","outcome"], scenario: "24,000-token context. Runtime has KV headroom. GPU shows 92% utilization.", seam: "Context↔outcome seam: same caller hash + payload hash three times in five minutes; goodput estimate ≤ 0. The runtime face is fine. The seam fails. THROTTLE for 5s, denial cert ⊢ Track C #41.", thm: "Track C corollary 41", color: T.teal, }, { title: "Right token, wrong target", faces: ["policy","runtime"], scenario: "Admin token, valid permission, valid route. Identity green. Policy green.", seam: "But the action targets pool prod-A100 while the caller's tenant binding only allows pool dev-A10. Topology check fails: nonce unique, target mismatch. DENY_TOPOLOGY before scheduler sees it.", thm: "V1.30 ToR admission #3", color: T.violetSoft, }, ]; const ex = examples[active]; return (
05 · Seams ≠ faces

Faces are facts.
Seams are where they have to agree.

A face check asks "is this credential valid?" A seam check asks "is this credential consistent with that other one, in this epoch, on this topology?" Two requests can have identical face projections and still differ on a seam — proven by the corner-spoofing separation theorem. Faces are what the attacker can spoof. Seams are what they can't.

{examples.map((e, i) => ( ))}
{ const s = {}; FACES.forEach((f) => { s[f.id] = ex.faces.includes(f.id) ? Array(9).fill(true) : Array(9).fill(null); }); return s; })()} />
SEAM ⊢ {ex.thm}
{ex.title}
WHAT MONITORING SEES

{ex.scenario}

WHAT THE SEAM SEES

{ex.seam}
); } /* ============================================================ PROOF STACK — replaces "Delegation" The 7-deliverable / 163-theorem stack mapped to runtime. ============================================================ */ function ProofStack() { const tracks = [ { v: "V1.19.2", name: "Ramen", theorems: 53, role: "23 single-failure modes + diagnostics + denial counting", anchors: "explainable denial codes", color: T.violetSoft, status: "delivered" }, { v: "V1.30", name: "ToR Admission", theorems: 5, role: "host verifier + stale-epoch + goodput containment", anchors: "no-bypass at host", color: T.sky, status: "delivered" }, { v: "V1.31", name: "Corner Spoofing", theorems: 2, role: "same surface, different seams — separation", anchors: "spoof immunity", color: T.amber, status: "delivered" }, { v: "V1.40", name: "CubieBridge", theorems: 6, role: "WriteOK = D ∧ G ∧ T ∧ P, independence witnesses", anchors: "two-corner gate", color: T.violet, status: "delivered" }, { v: "V1.50", name: "Face Promotion", theorems: 17, role: "54-check face promotion + spoofing separation", anchors: "cell-level denial", color: T.mint, status: "delivered" }, { v: "V2.0-A", name: "Per-Predicate", theorems: 54, role: "1 corollary per face cell, 1 theorem per face check", anchors: "every cell carries proof", color: T.teal, status: "delivered" }, { v: "V2.0-C", name: "Track C Canonical",theorems: 26, role: "lease integrity · bypass · epoch · HA split-brain fail-closed", anchors: "lease lifecycle + HA", color: T.red, status: "delivered" }, ]; const total = tracks.reduce((a, b) => a + b.theorems, 0); return (
06 · The proof stack

{total} theorems. Seven deliverables.
Every runtime decision points back at a number.

The runtime doesn't re-prove anything in flight — it verifies signed bundles whose bytecode is the compiled image of these theorems. When a request denies, the certificate carries the theorem reference. Auditors replay the bytecode against the same epoch and reproduce the same verdict, bit-for-bit.

VERSIONTRACKTHEOREMSWHAT IT PROVESRUNTIME ANCHOR
{tracks.map((t, i) => (
{t.v}
{t.name}
{t.status.toUpperCase()}
{t.theorems} {t.role} {t.anchors}
))}
The cube is the math, made physical.{" "} Every edge of the cube is a theorem. Every cell is a corollary. Every denial is a proof, attached.
); } function KPI({ v, l, s, c }) { return (
{v}
{l}
{s}
); } /* exports */ Object.assign(window, { Hero, Problem, CubeSection, HotPath, SeamSection, ProofStack });