@uuidna/qpu 0.1.0 → 0.1.2

package/dist/quantum/processing/unit/index.js

@@ -3,11 +3,61 @@
  * mintOf proves 2^k by doubling. Cube, handle, faces, fused are the unit.
  * Lean decides those identities by Nat algebra. Digits and integer fractions. Never Math. Never by decide.
  */
+/** COMPUTATIONAL RECEIPTS. Every gate primitive and measurement appends the fold of the amplitude vector it produced, so a
+ * test that computed quantum state carries a receipt and a test that computed none carries none. FNV-1a 64 over the
+ * decimal amplitudes; BigInt only. Never Math. The reporter reads this ledger per test (isolation none). */
+import { leanSource, leanToolchain } from './lean.js';
+import { packageVersion } from './version.js';
+/** The exact state worth carrying in the receipt: what was measured — eight amplitudes, the Born weights themselves.
+ * Every other state folds only; it is recomputable from the gate list, and a proof that carried every 512-amplitude
+ * modexp state weighed megabytes per run. */
+const RECEIPT_STATES = ['measure'];
+const RECEIPTS = [];
+const FNV_OFFSET = 0xcbf29ce484222325n;
+const FNV_PRIME = 0x100000001b3n;
+const FNV_MASK = 0xffffffffffffffffn;
+export const qpuFoldOf = (text) => {
+    let h = FNV_OFFSET;
+    for (let i = text.length - text.length; i < text.length; i++) {
+        h ^= BigInt(text.charCodeAt(i));
+        h = (h * FNV_PRIME) & FNV_MASK;
+    }
+    return h.toString(16).padStart(16, '0');
+};
+const receiptOf = (name, amps) => {
+    const decimal = amps.map((a) => a.toString());
+    const row = { name, dim: amps.length, fold: qpuFoldOf(decimal.join(',')) };
+    if (RECEIPT_STATES.includes(name))
+        row.amplitudes = decimal;
+    RECEIPTS.push(row);
+};
+/** A sparse state's receipt: the fold of its nonzero amplitudes as index:weight pairs in index order, and their count.
+ * `dim` is the full dimension, a float past 2^53; the fold is exact because the pairs are decimal text of bigints. */
+const receiptSparseOf = (name, dim, pairs) => {
+    RECEIPTS.push({ name, dim: Number(dim), fold: qpuFoldOf(pairs.map(([i, w]) => `${i}:${w}`).join(',')), nonzero: pairs.length, qubits: dim.toString(2).length - 1 });
+};
+/** mint receipts: every amplitude-count doubling this process computed — a counter and a running chain, never a list. */
+const MINT = { calls: 0, chain: FNV_OFFSET };
+export const qpuMintReceiptOf = () => ({ calls: MINT.calls, chain: MINT.chain.toString(16).padStart(16, '0') });
+const mintReceiptOf = (k, x) => {
+    MINT.calls = MINT.calls + 1;
+    const text = `${k}:${x}`;
+    let h = MINT.chain;
+    for (let i = text.length - text.length; i < text.length; i++) {
+        h ^= BigInt(text.charCodeAt(i));
+        h = (h * FNV_PRIME) & FNV_MASK;
+    }
+    MINT.chain = h;
+};
+/** The ledger of every quantum computation this process ran, in order. */
+export const qpuReceiptLedgerOf = () => RECEIPTS;
+export const qpuReceiptFoldOf = (rows = RECEIPTS) => qpuFoldOf(rows.map((r) => `${r.name}:${r.dim}:${r.fold}`).join('|'));
 const mintOf = (k) => {
     let x = k - k;
     x = x + 1;
     for (let i = k - k; i < k; i++)
         x += x;
+    mintReceiptOf(k, x);
     return x;
 };
 const chooseOf = (nn, k) => {
@@ -78,30 +128,39 @@ const skills = ['payload', 'pwa', 'plugin', 'hologram', 'network'];
 const ten = n * n + seed;
 const found = coins * ten * ten;
 const lost = mintOf(coins) * (ten * ten + seed);
+const unauthorized = mintOf(coins) * ten * ten + seed;
+const badRequest = unauthorized - seed;
+/** JSON-RPC 2.0 reserved error codes, as the specification numbers them. */
+const rpcCodes = { parse: -32700, invalid: -32600, method: -32601, params: -32602 };
+/** A JSON-RPC 2.0 error, as the protocol spells it: `jsonrpc`, the request's `id` (null when none was understood), and an
+ * `error` with code and message. A parse error or an invalid request travels on HTTP 400, because no request was understood;
+ * an unknown method or unknown tool travels on HTTP 200, because the request was understood and declined. Never
+ * `{"holds":false}` on a 404: that is the shape of a missing page, not of a declined call. */
+export const rpcErrorOf = (id, code, message, data) => ({
+    jsonrpc: '2.0',
+    id: id === undefined ? null : id,
+    error: data === undefined ? { code, message } : { code, message, data },
+});
+/** The methods this server answers on /mcp. */
+const rpcMethods = ['initialize', 'server/discover', 'ping', 'notifications/initialized', 'tools/list', 'tools/call'];
 const tenOf = (k) => {
     let x = mintOf(n - n);
     for (let i = n - n; i < k; i++)
         x *= ten;
     return x;
 };
-const nsPerSecond = tenOf(n * n);
-const timeNsOf = (fn) => ({
-    ns: n - n,
-    value: fn()
-});
-const hzOf = (ns) => (ns > seed ? Number(BigInt(nsPerSecond) / BigInt(ns)) : nsPerSecond);
 const byDecideOf = (theorem) => theorem.includes('by decide') || theorem.includes('native_decide');
 const formulaOf = (formula) => formula.includes('\\') && !formula.includes('operatorname');
 const manSchema = {
     type: 'object',
     properties: {
-        man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' }
+        man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' }
     }
 };
 const liveSchema = {
     type: 'object',
     properties: {
-        man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' },
+        man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' },
         live: { type: 'boolean', description: '{ live: true } learn CERN occupancy. fetch Request Response. Memory.' },
         sequence: { type: 'boolean', description: '{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory.' }
     }
@@ -466,32 +525,33 @@ export const qpuFollowOf = () => {
         const app = i % points;
         const hop = (app + coins) % points;
         const via = (app + coil.theory + coil.practice) % points;
-        const novel = hop === via;
+        // hop ≡ via restates theory + practice = coins on this application; it is a balance, never a novelty claim
+        const balanced = hop === via;
         return {
             name,
             app,
             hop,
             via,
-            novel,
+            balanced,
             occupancy: occupancies[hop],
             skill: skills[hop],
-            holds: novel && hop === (app + coil.balance) % points,
+            holds: balanced && hop === (app + coil.balance) % points,
         };
     });
     const seen = [];
     for (const row of solutions)
         if (!seen.includes(row.hop))
             seen.push(row.hop);
-    const creative = solutions.every((row) => row.novel && row.holds);
-    const novel = seen.length === points;
+    const balanced = solutions.every((row) => row.balanced && row.holds);
+    const covered = seen.length === points;
     const emerge = {
         kind: 'emerge',
         theorem: 'emerge',
-        creative,
-        novel,
+        balanced,
+        covered,
         coil: coil.coil,
         faces: coil.faces,
-        holds: creative && novel && coil.coil === coil.faces && coil.theory === coil.practice,
+        holds: balanced && covered && coil.coil === coil.faces && coil.theory === coil.practice,
     };
     const holds = qpuCoilHolds(coil) &&
         qpuElectronicsHolds(electronics) &&
@@ -521,10 +581,10 @@ export const qpuFollowHolds = (f = qpuFollowOf()) => f.holds === true &&
     f.theory === f.practice &&
     f.theory + f.practice === coins &&
     f.emerge.kind === 'emerge' &&
-    f.emerge.creative === true &&
-    f.emerge.novel === true &&
+    f.emerge.balanced === true &&
+    f.emerge.covered === true &&
     f.emerge.coil === f.emerge.faces &&
-    f.solutions.every((row) => row.novel && row.hop === (row.app + coins) % (n + coins));
+    f.solutions.every((row) => row.balanced && row.hop === (row.app + coins) % (n + coins));
 /** Coordinated dry-clean: two teams, occupancy pentagram, genesis coins. No extra sealed tool. */
 export const qpuDryOf = (genesis = qpuGenesisOf()) => {
     const pentagram = qpuPentagramOf();
@@ -825,9 +885,6 @@ export const qpuHybridOf = () => {
     };
     const speed = kv.speed + r2.speed;
     const cost = kv.cost + r2.cost;
-    const kvTimed = timeNsOf(() => kv.speed);
-    const r2Timed = timeNsOf(() => r2.speed);
-    const timed = timeNsOf(() => kv.speed + r2.speed);
     const holds = storageBindings.STORAGE === 'kv' &&
         storageBindings.BLOBS === 'r2' &&
         kv.cost === coins &&
@@ -839,22 +896,17 @@ export const qpuHybridOf = () => {
         coins === seed + seed &&
         raid.cluster.cost === 'minimum' &&
         raid.cluster.speed === 'coordinated' &&
-        kvTimed.value === kv.speed &&
-        r2Timed.value === r2.speed &&
-        timed.value === speed &&
         kv.speed > r2.speed &&
         kv.cost > r2.cost;
     return {
         kind: 'hybrid',
         theorem: 'hybrid',
         layers: coins,
-        kv: { ...kv, ns: kvTimed.ns, hz: hzOf(kvTimed.ns) },
-        r2: { ...r2, ns: r2Timed.ns, hz: hzOf(r2Timed.ns) },
+        kv,
+        r2,
         speed,
         cost,
         measure: { speed, cost },
-        ns: timed.ns,
-        hz: hzOf(timed.ns),
         bindings: storageBindings,
         holds,
     };
@@ -879,10 +931,7 @@ export const qpuHybridHolds = (h = qpuHybridOf()) => h.holds === true &&
     h.measure.cost === h.cost &&
     h.kv.speed > h.r2.speed &&
     h.kv.cost > h.r2.cost &&
-    h.ns === n - n &&
-    h.kv.ns === n - n &&
-    h.r2.ns === n - n &&
-    h.hz === hzOf(h.ns);
+    h.kv.speed > h.r2.speed;
 /** QPU hybrid storage hosts the Payload database. Four collections. Secrets never. */
 const payloadDbCollections = ['pages', 'users', 'media', 'tenants'];
 const payloadDbKey = 'databases/payload';
@@ -1094,22 +1143,6 @@ export const qpuDesignOf = () => {
         holds,
     };
 };
-export const qpuHandledOf = (denied) => {
-    const design = qpuDesignOf();
-    const hit = design.nodes.find((node) => node.name === denied);
-    const face = hit ? hit.face : Number(BigInt(denied.length) % BigInt(design.nodes.length));
-    const node = hit ?? design.nodes[face];
-    return {
-        kind: 'design',
-        denied,
-        face: node.face,
-        name: node.name,
-        hop: node.hop,
-        wave: node.wave,
-        fold: node.fold,
-        holds: false,
-    };
-};
 export const qpuDesignHolds = (d = qpuDesignOf()) => d.holds === true &&
     d.kind === 'design' &&
     d.vacant === n - n &&
@@ -1213,6 +1246,7 @@ const xGateOf = (amps, q) => {
     const out = amps.map(() => 0n);
     for (let i = n - n; i < amps.length; i++)
         out[xorOf(i, bit)] = amps[i];
+    receiptOf('x', out);
     return out;
 };
 const cnotGateOf = (amps, c, t) => {
@@ -1223,6 +1257,7 @@ const cnotGateOf = (amps, c, t) => {
         const on = (BigInt(i) / cb) % 2n === 1n;
         out[on ? xorOf(i, Number(tb)) : i] = amps[i];
     }
+    receiptOf('cnot', out);
     return out;
 };
 const hGateOf = (amps, q) => {
@@ -1241,6 +1276,7 @@ const hGateOf = (amps, q) => {
             out[flipped] += a;
         }
     }
+    receiptOf('h', out);
     return out;
 };
 const czGateOf = (amps, c, t) => hGateOf(cnotGateOf(hGateOf(amps, t), c, t), t);
@@ -1255,6 +1291,7 @@ const toffoliGateOf = (amps, c, k, t) => {
         const on = (BigInt(i) / cb) % 2n === 1n && (BigInt(i) / kb) % 2n === 1n;
         out[on ? xorOf(i, Number(tb)) : i] = amps[i];
     }
+    receiptOf('toffoli', out);
     return out;
 };
 const qubitOf = (value, fallback) => {
@@ -1285,6 +1322,7 @@ const runGatesOf = (ops) => {
     return amps;
 };
 const measureOf = (amps) => {
+    receiptOf('measure', amps);
     const support = amps.map((a, i) => ({ i, a })).filter((r) => r.a !== 0n);
     const index = support.length === seed ? support[n - n].i : support.length === coins ? support[seed].i : mintOf(n);
     const counts = support.map((r) => ({ i: r.i, w: Number(r.a * r.a) }));
@@ -1561,18 +1599,6 @@ const gcdOf = (left, right) => {
     }
     return x;
 };
-const powModOf = (base, exp, modulus) => {
-    let x = seed;
-    let b = base % modulus;
-    let e = exp;
-    while (e > n - n) {
-        if (e % coins === seed)
-            x = (x * b) % modulus;
-        b = (b * b) % modulus;
-        e = (e - (e % coins)) / coins;
-    }
-    return x;
-};
 const convergentsOf = (num, den) => {
     const out = [];
     let n0 = num;
@@ -1596,177 +1622,324 @@ const convergentsOf = (num, den) => {
     }
     return out;
 };
+/** Device label READ from the run: a vector of exact integer amplitudes is a simulator; anything else is unmeasured. Never typed. */
+const bigintDeviceOf = (amps) => amps.length > n - n && amps.every((a) => typeof a === 'bigint') ? 'simulator' : 'unmeasured';
 const cAmpOf = (re, im) => ({ re, im });
 const cWOf = (a) => a.re * a.re + a.im * a.im;
 const cAddOf = (a, b) => cAmpOf(a.re + b.re, a.im + b.im);
 const cSubOf = (a, b) => cAmpOf(a.re - b.re, a.im - b.im);
 const cMulNegIOf = (a) => cAmpOf(a.im, -a.re);
-const cPrepareOf = (dim) => {
-    const amps = Array.from({ length: dim }, () => cAmpOf(0n, 0n));
-    amps[n - n] = cAmpOf(1n, 0n);
-    return amps;
-};
-const cHOf = (amps, q) => {
-    const bit = mintOf(q);
-    const out = amps.map(() => cAmpOf(0n, 0n));
-    for (let i = n - n; i < amps.length; i++) {
-        const a = amps[i];
-        const flipped = xorOf(i, bit);
-        const on = quotOf(i, bit) % coins === seed;
-        if (on) {
-            out[flipped] = cAddOf(out[flipped], a);
-            out[i] = cSubOf(out[i], a);
+const b0 = BigInt(n - n);
+const b1 = BigInt(seed);
+const b2 = BigInt(coins);
+const sBitOf = (q) => b1 << BigInt(q);
+const onOf = (i, bit) => (i & bit) !== b0;
+const sPut = (out, i, a) => {
+    const prior = out.get(i);
+    const next = prior ? cAddOf(prior, a) : a;
+    if (next.re === b0 && next.im === b0)
+        out.delete(i);
+    else
+        out.set(i, next);
+};
+const sPrepareOf = () => new Map([[b0, cAmpOf(b1, b0)]]);
+const sHOf = (state, q) => {
+    const bit = sBitOf(q);
+    const out = new Map();
+    for (const [i, a] of state) {
+        const flipped = i ^ bit;
+        if (onOf(i, bit)) {
+            sPut(out, flipped, a);
+            sPut(out, i, cSubOf(cAmpOf(b0, b0), a));
         }
         else {
-            out[i] = cAddOf(out[i], a);
-            out[flipped] = cAddOf(out[flipped], a);
+            sPut(out, i, a);
+            sPut(out, flipped, a);
         }
     }
     return out;
 };
-const cXOf = (amps, q) => {
-    const bit = mintOf(q);
-    const out = amps.map(() => cAmpOf(0n, 0n));
-    for (let i = n - n; i < amps.length; i++)
-        out[xorOf(i, bit)] = amps[i];
+const sXOf = (state, q) => {
+    const bit = sBitOf(q);
+    const out = new Map();
+    for (const [i, a] of state)
+        sPut(out, i ^ bit, a);
     return out;
 };
-const cSwapOf = (amps, a, b) => {
-    const out = amps.map(() => cAmpOf(0n, 0n));
-    const ba = mintOf(a);
-    const bb = mintOf(b);
-    for (let i = n - n; i < amps.length; i++) {
-        const ia = quotOf(i, ba) % coins;
-        const ib = quotOf(i, bb) % coins;
-        let j = i;
-        if (ia !== ib)
-            j = xorOf(xorOf(i, ba), bb);
-        out[j] = amps[i];
-    }
+const sSwapOf = (state, a, b) => {
+    const ba = sBitOf(a);
+    const bb = sBitOf(b);
+    const out = new Map();
+    for (const [i, amp] of state)
+        sPut(out, onOf(i, ba) !== onOf(i, bb) ? i ^ ba ^ bb : i, amp);
     return out;
 };
-const cSdgOf = (amps, c, t) => {
-    const cb = mintOf(c);
-    const tb = mintOf(t);
-    const out = amps.map(() => cAmpOf(0n, 0n));
-    for (let i = n - n; i < amps.length; i++) {
-        const on = quotOf(i, cb) % coins === seed && quotOf(i, tb) % coins === seed;
-        out[i] = on ? cMulNegIOf(amps[i]) : amps[i];
-    }
+const sSdgOf = (state, c, t) => {
+    const cb = sBitOf(c);
+    const tb = sBitOf(t);
+    const out = new Map();
+    for (const [i, a] of state)
+        sPut(out, i, onOf(i, cb) && onOf(i, tb) ? cMulNegIOf(a) : a);
     return out;
 };
-const cModMulOf = (amps, a, modulus, control, workOff, workBits) => {
-    const cb = mintOf(control);
-    const workSpan = mintOf(workBits);
-    const out = amps.map(() => cAmpOf(0n, 0n));
-    for (let i = n - n; i < amps.length; i++) {
-        if (quotOf(i, cb) % coins !== seed) {
-            out[i] = cAddOf(out[i], amps[i]);
+/** x mod m in [0, m) for m > 0, whatever the sign of x. */
+const modOf = (x, m) => ((x % m) + m) % m;
+const sModMulOf = (state, a, modulus, control, workOff, workBits) => {
+    const cb = sBitOf(control);
+    const shift = BigInt(workOff);
+    const span = b1 << BigInt(workBits);
+    const out = new Map();
+    for (const [i, amp] of state) {
+        if (!onOf(i, cb)) {
+            sPut(out, i, amp);
             continue;
         }
-        const work = quotOf(i, mintOf(workOff)) % workSpan;
-        const next = work < modulus ? (work * a) % modulus : work;
-        const j = i - work * mintOf(workOff) + next * mintOf(workOff);
-        out[j] = cAddOf(out[j], amps[i]);
+        const work = (i >> shift) % span;
+        const next = modulus > b1 && work < modulus ? modOf(work * a, modulus) : work;
+        sPut(out, i - (work << shift) + (next << shift), amp);
     }
     return out;
 };
-const cXxOf = (amps, q) => cXOf(cXOf(amps, q), q);
-/** Shor on the superconducting device. N and coprime a. Modular-exponentiation circuitry. Inverse QFT. Noisy shots. Factors. */
-export const qpuShorOf = () => {
-    const cube = qpuCubeOf();
+const sXxOf = (state, q) => sXOf(sXOf(state, q), q);
+const sEqualOf = (left, right) => left.size === right.size && [...left].every(([i, a]) => right.get(i)?.re === a.re && right.get(i)?.im === a.im);
+const sPairsOf = (state) => [...state].map(([i, a]) => [i, cWOf(a)]).filter(([, w]) => w > b0).sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : n - n));
+const sDeviceOf = (state) => state.size > n - n && [...state.values()].every((a) => typeof a.re === 'bigint' && typeof a.im === 'bigint') ? 'simulator' : 'unmeasured';
+const bigGcdOf = (left, right) => {
+    let x = left < b0 ? -left : left;
+    let y = right < b0 ? -right : right;
+    while (y > b0) {
+        const r = x % y;
+        x = y;
+        y = r;
+    }
+    return x;
+};
+/** base^exp mod modulus by squaring; 0 when the modulus is not a ring (modulus <= 1), where the question has no answer. */
+const bigPowModOf = (base, exp, modulus) => {
+    if (modulus <= b1)
+        return b0;
+    let x = b1 % modulus;
+    let b = modOf(base, modulus);
+    let e = exp;
+    while (e > b0) {
+        if (e % b2 === b1)
+            x = (x * b) % modulus;
+        b = (b * b) % modulus;
+        e = e / b2;
+    }
+    return x;
+};
+/** Bits so that 2^bits > value: the work register that holds every residue mod value. 0 for value <= 0. */
+const bitsOf = (value) => {
+    let k = n - n;
+    let pow = b1;
+    while (pow <= value) {
+        pow += pow;
+        k += seed;
+    }
+    return k;
+};
+const safeBig = BigInt(Number.MAX_SAFE_INTEGER);
+const safeOf = (x) => x <= safeBig && x >= -safeBig;
+/** A bigint for JSON: the number when it is exact there, the decimal string when it would round. */
+const jsonIntOf = (x) => (safeOf(x) ? Number(x) : x.toString());
+/** The modulus and base Shor runs on when the caller names none: faces.rays * (n * n + n + seed) = 91 and mintOf n = 8. */
+export const shorDefaultsOf = () => ({ modulus: qpuFacesOf().rays * (n * n + n + seed), base: mintOf(n) });
+/** The counting register is two qubits: this inverse QFT is exact in Gaussian integers (fourth roots of unity), and a
+ * wider register would need eighth roots, which are not integers. So the register resolves periods dividing four;
+ * `classical` below says whether the period it was asked for is one of those. */
+const shorCountBits = coins;
+/** THE CLASSICAL CHECK BESIDE THE RUN, EXACT FOR ANY MODULUS AND NEVER UNFINISHED. The two-qubit counting register
+ * resolves a period only when it divides four, and whether the order of the base divides four is three modular
+ * powers: a, a^2, a^4 mod n. That answers every question the run poses — is there a ring, is the base a unit, can the
+ * register resolve its order, and what must the run then recover — without iterating toward an order it could not
+ * reach. So there is no bound to hit, no work budget, and no "did not finish" to report: `beyond` true is an answer
+ * (the order exists and does not divide four), not a crack. */
+const classicalOrderOf = (base, modulus) => {
+    if (modulus <= b1)
+        return { ring: false, unit: false, order: n - n, beyond: false };
+    if (bigGcdOf(base, modulus) !== b1)
+        return { ring: true, unit: false, order: n - n, beyond: false };
+    for (const r of [seed, coins, mintOf(coins)]) {
+        if (bigPowModOf(base, BigInt(r), modulus) === b1)
+            return { ring: true, unit: true, order: r, beyond: false };
+    }
+    return { ring: true, unit: true, order: n - n, beyond: true };
+};
+const argReadOf = (v) => {
+    const finite = (x) => x === x && x !== Number.POSITIVE_INFINITY && x !== Number.NEGATIVE_INFINITY;
+    const exactDouble = (x) => finite(x) && x % seed === n - n && x <= Number.MAX_SAFE_INTEGER && x >= -Number.MAX_SAFE_INTEGER;
+    if (v === undefined)
+        return { read: { how: 'absent', exact: true, given: false } };
+    if (typeof v === 'bigint')
+        return { value: v, read: { how: 'digits', exact: true, given: true } };
+    if (typeof v === 'string') {
+        const t = v.trim();
+        if (/^[+-]?\d+$/.test(t))
+            return { value: BigInt(t), read: { how: 'digits', exact: true, given: true } };
+        const x = t.length > n - n ? Number(t) : Number.NaN;
+        if (finite(x))
+            return { value: BigInt(x - (x % seed)), read: { how: 'numeric', exact: exactDouble(x), given: true } };
+        return { read: { how: 'default', exact: false, given: true } };
+    }
+    if (typeof v === 'number' && finite(v))
+        return { value: BigInt(v - (v % seed)), read: { how: 'number', exact: exactDouble(v), given: true } };
+    return { read: { how: 'default', exact: false, given: true } };
+};
+/** Modulus and base as the caller gave them, read as integers, with how each was read. No denial, no cap: the run is on
+ * whatever integer arrives, and `read` says whether that integer is the one the caller meant. */
+export const shorArgsOf = (a) => {
+    const nn = argReadOf(a.n);
+    const aa = argReadOf(a.a);
+    return { modulus: nn.value, base: aa.value, read: { n: nn.read, a: aa.read, holds: nn.read.exact && aa.read.exact } };
+};
+/** Shor as a caller asked for it: the run on their n and a, whatever they are. Never a denial; the run itself says what it
+ * found (a period, a gcd factor, or nothing), the sparse state means no modulus is past the host's reach, and `read`
+ * says how each argument was taken. A reply whose arguments were not read exactly does not hold, whatever the run did. */
+export const qpuShorTryOf = (a) => {
+    const args = shorArgsOf(a);
+    const shor = qpuShorOf(args.modulus, args.base);
+    return { ...shor, read: args.read, holds: shor.holds && args.read.holds };
+};
+/** Shor on the sparse exact simulator. N and coprime a: the caller's, or the unit's 91 and 8. Modular-exponentiation
+ * circuitry. Inverse QFT. Noisy shots. Factors. Every number below is exact in `exact` as decimal text; the number
+ * fields round past 2^53 and `exact.safe` says whether they did. */
+export const qpuShorOf = (modulusArg, baseArg) => {
     const plugin = qpuPayloadPluginOf();
     const computer = qpuComputerOf();
-    const modulus = n * (n + coins);
-    const base = mintOf(n) - seed;
-    const countBits = coins;
-    const workBits = cube.hexbit;
+    const defaults = shorDefaultsOf();
+    const modulus = BigInt(modulusArg ?? defaults.modulus);
+    const base = BigInt(baseArg ?? defaults.base);
+    const countBits = shorCountBits;
+    const workBits = bitsOf(modulus);
     const workOff = countBits;
+    const shift = BigInt(workOff);
+    const span = b1 << BigInt(workBits);
     const qubits = countBits + workBits;
-    const dim = mintOf(qubits);
+    const dimBig = b1 << BigInt(qubits);
     const qftSize = mintOf(countBits);
-    const coprime = gcdOf(base, modulus) === seed;
+    const qftBig = BigInt(qftSize);
+    const ring = modulus > b1;
+    const coprime = ring && bigGcdOf(base, modulus) === b1;
+    const aSquared = ring ? bigPowModOf(base, b2, modulus) : base * base;
     const mul = [
-        { power: mintOf(n - n), a: base, control: n - n },
-        { power: coins, a: powModOf(base, coins, modulus), control: seed }
+        { power: mintOf(n - n), a: jsonIntOf(base), control: n - n },
+        { power: coins, a: jsonIntOf(aSquared), control: seed }
     ];
     const gates = [
         { name: 'x', q: workOff },
         { name: 'h', q: n - n },
         { name: 'h', q: seed },
-        { name: 'cmodexp', c: mul[n - n].control, a: mul[n - n].a, modulus, power: mul[n - n].power },
-        { name: 'cmodexp', c: mul[seed].control, a: mul[seed].a, modulus, power: mul[seed].power },
+        { name: 'cmodexp', c: mul[n - n].control, a: mul[n - n].a, modulus: jsonIntOf(modulus), power: mul[n - n].power },
+        { name: 'cmodexp', c: mul[seed].control, a: mul[seed].a, modulus: jsonIntOf(modulus), power: mul[seed].power },
         { name: 'swap', a: n - n, b: seed },
         { name: 'h', q: seed },
         { name: 'csdg', c: seed, t: n - n },
         { name: 'h', q: n - n }
     ];
-    let amps = cPrepareOf(dim);
-    amps = cXOf(amps, workOff);
-    amps = cHOf(amps, n - n);
-    amps = cHOf(amps, seed);
-    amps = cModMulOf(amps, mul[n - n].a, modulus, mul[n - n].control, workOff, workBits);
-    amps = cModMulOf(amps, mul[seed].a, modulus, mul[seed].control, workOff, workBits);
-    let expOk = seed === seed;
-    for (let i = n - n; i < amps.length; i++) {
-        if (cWOf(amps[i]) === 0n)
+    let state = sPrepareOf();
+    state = sXOf(state, workOff);
+    state = sHOf(state, n - n);
+    state = sHOf(state, seed);
+    state = sModMulOf(state, base, modulus, mul[n - n].control, workOff, workBits);
+    state = sModMulOf(state, aSquared, modulus, mul[seed].control, workOff, workBits);
+    /** Read from the state: every branch's work register holds a^counting mod N, or the circuitry does not hold. */
+    let expOk = ring && state.size > n - n;
+    for (const [i, amp] of state) {
+        if (cWOf(amp) === b0)
             continue;
-        const counting = i % qftSize;
-        const work = quotOf(i, mintOf(workOff)) % mintOf(workBits);
-        if (work !== powModOf(base, counting, modulus))
+        const counting = i % qftBig;
+        const work = (i >> shift) % span;
+        if (work !== bigPowModOf(base, counting, modulus))
             expOk = false;
     }
-    amps = cSwapOf(amps, n - n, seed);
-    amps = cHOf(amps, seed);
-    amps = cSdgOf(amps, seed, n - n);
-    amps = cHOf(amps, n - n);
-    const noisy = cXxOf(amps, workOff);
-    const xxId = noisy.every((row, i) => row.re === amps[i].re && row.im === amps[i].im);
+    state = sSwapOf(state, n - n, seed);
+    state = sHOf(state, seed);
+    state = sSdgOf(state, seed, n - n);
+    state = sHOf(state, n - n);
+    const noisy = sXxOf(state, workOff);
+    receiptSparseOf('cmodexp', dimBig, sPairsOf(state));
+    receiptSparseOf('xx', dimBig, sPairsOf(noisy));
+    const xxId = sEqualOf(noisy, state);
+    /** Read from the state, never from the request: the host holds every nonzero amplitude of the 2^qubits vector. */
+    const prepare = {
+        kind: 'prepare',
+        qubits,
+        dim: jsonIntOf(dimBig),
+        amplitudes: noisy.size,
+        sparse: true,
+        prepared: noisy.size > n - n,
+        reason: noisy.size > n - n ? 'held' : 'empty',
+        holds: noisy.size > n - n && noisy.size <= qftSize * qftSize,
+    };
     const weights = [];
     for (let y = n - n; y < qftSize; y++)
         weights.push(n - n);
-    for (let i = n - n; i < noisy.length; i++) {
-        const y = i % qftSize;
-        weights[y] = weights[y] + Number(cWOf(noisy[i]));
+    for (const [i, amp] of noisy) {
+        const y = Number(i % qftBig);
+        weights[y] = weights[y] + Number(cWOf(amp));
     }
     const support = [];
     for (let y = n - n; y < qftSize; y++)
         if (weights[y] > n - n)
             support.push(y);
     const shotsN = mintOf(n);
+    const measured = support.length > n - n;
+    /** Shots are readings of a held state: none are reported from a state with nothing to read. */
     const shots = [];
-    for (let s = n - n; s < shotsN; s++)
-        shots.push(support.length > n - n ? support[s % support.length] : n - n);
+    if (measured)
+        for (let s = n - n; s < shotsN; s++)
+            shots.push(support[s % support.length]);
     let period = n - n;
     const recovered = [];
     for (const y of support) {
         for (const row of convergentsOf(y, qftSize)) {
             const r = row.k;
-            if (r > n - n && r < modulus && powModOf(base, r, modulus) === seed) {
+            if (r > n - n && BigInt(r) < modulus && bigPowModOf(base, BigInt(r), modulus) === b1) {
                 recovered.push(r);
                 if (period === n - n)
                     period = r;
             }
         }
     }
-    let p = n - n;
-    let q = n - n;
+    let p = b0;
+    let q = b0;
+    let by = 'none';
     if (period > n - n && period % coins === n - n) {
-        const half = powModOf(base, period / coins, modulus);
-        if (half !== modulus - seed) {
-            const g1 = gcdOf(half - seed, modulus);
-            const g2 = gcdOf(half + seed, modulus);
-            if (g1 > seed && g1 < modulus) {
+        const half = bigPowModOf(base, BigInt(period / coins), modulus);
+        if (half !== modulus - b1) {
+            const g1 = bigGcdOf(half - b1, modulus);
+            const g2 = bigGcdOf(half + b1, modulus);
+            if (g1 > b1 && g1 < modulus) {
                 p = g1;
                 q = modulus / g1;
+                by = 'period';
             }
-            else if (g2 > seed && g2 < modulus) {
+            else if (g2 > b1 && g2 < modulus) {
                 p = g2;
                 q = modulus / g2;
+                by = 'period';
             }
         }
     }
+    /** Shor's first step, read from the run: a base sharing a factor with the modulus hands that factor over before any period. */
+    const shared = ring ? bigGcdOf(modOf(base, modulus), modulus) : b0;
+    if (by === 'none' && shared > b1 && shared < modulus) {
+        p = shared;
+        q = modulus / shared;
+        by = 'gcd';
+    }
     const product = p * q;
+    const factoredBig = p > b1 && q > b1 && product === modulus;
+    const exact = {
+        safe: safeOf(modulus) && safeOf(base) && safeOf(p) && safeOf(q) && safeOf(dimBig),
+        n: modulus.toString(),
+        a: base.toString(),
+        p: p.toString(),
+        q: q.toString(),
+        product: product.toString(),
+        dim: dimBig.toString(),
+    };
     const circuitry = {
         kind: 'cmodexp',
         native: ['h', 'cnot'],
@@ -1774,72 +1947,128 @@ export const qpuShorOf = () => {
         mul,
         gates,
         qubits,
-        dim,
+        dim: jsonIntOf(dimBig),
         work: workBits,
         counting: countBits,
-        holds: expOk && coprime && gates[n - n].name === 'x' && mul.length === coins,
+        holds: expOk && gates[n - n].name === 'x' && mul.length === coins && span > modulus && qubits === countBits + workBits,
     };
     const qft = {
         kind: 'iqft',
         qubits: countBits,
         size: qftSize,
         phase: 's',
-        holds: countBits === coins && qftSize === mintOf(countBits) && support.length > n - n,
+        holds: countBits === coins && qftSize === mintOf(countBits) && support.length > n - n && span > modulus,
     };
     const measure = {
         kind: 'shots',
         noise: 'xx',
         identity: xxId,
-        shots: shotsN,
+        measured,
+        /** No entropy in the unit: the outcomes list the support in order, once per shot, so they are the exact
+         * distribution enumerated, never a sample. The Born weights are `weights`. */
+        sampled: false,
+        enumerated: true,
+        shots: shots.length,
         outcomes: shots,
         support,
         weights,
-        holds: shots.length === shotsN && shotsN === computer.shots.n && xxId === true && computer.correct.code === 'bitflip',
+        holds: measured && shots.length === shotsN && shotsN === computer.shots.n && xxId === true && computer.correct.code === 'bitflip',
     };
     const post = {
         kind: 'continued-fraction',
         period,
         recovered,
-        holds: period > n - n && powModOf(base, period, modulus) === seed,
+        holds: period > n - n && bigPowModOf(base, BigInt(period), modulus) === b1,
     };
     const factors = {
-        p,
-        q,
-        product,
-        holds: p > seed && q > seed && p * q === modulus && product === modulus,
+        p: Number(p),
+        q: Number(q),
+        product: Number(product),
+        by,
+        holds: factoredBig,
+    };
+    const rsa = {
+        kind: 'rsa',
+        cryptosystem: 'rsa',
+        modulus: Number(modulus),
+        p: Number(p),
+        q: Number(q),
+        product: Number(product),
+        factored: factoredBig,
+        holds: factors.holds && factoredBig,
+    };
+    /** Beside the run, never in it, and exact for any modulus: whether there is a ring, whether the base is a unit in it,
+     * whether the order of the base divides four (the only periods a two-qubit register resolves), and both arms —
+     * resolvable means the run recovered a multiple of that order, unresolvable means the run recovered nothing. */
+    const classicalRun = classicalOrderOf(base, modulus);
+    const classicalPeriod = classicalRun.order;
+    const resolvable = classicalRun.unit && classicalPeriod > n - n;
+    const classical = {
+        kind: 'classical',
+        ring: classicalRun.ring,
+        unit: classicalRun.unit,
+        gcd: jsonIntOf(ring ? bigGcdOf(base, modulus) : b0),
+        period: classicalPeriod,
+        beyond: classicalRun.beyond,
+        counting: countBits,
+        resolvable,
+        agrees: classicalRun.ring && period === classicalPeriod,
+        holds: classicalRun.ring ? (resolvable ? period > n - n && period % classicalPeriod === n - n : period === n - n) : false,
     };
-    const holds = coprime === true &&
-        modulus === n * (n + coins) &&
-        base === mintOf(n) - seed &&
+    const holds = span > modulus &&
+        prepare.holds &&
         circuitry.holds &&
         qft.holds &&
         measure.holds &&
-        post.holds &&
+        (post.holds || factors.by === 'gcd') &&
         factors.holds &&
+        rsa.holds &&
         computer.holds &&
         qpuPayloadPluginHolds(plugin);
     return {
         kind: 'shor',
         theorem: 'shor',
-        device: 'superconducting',
-        n: modulus,
-        a: base,
+        device: sDeviceOf(noisy),
+        n: Number(modulus),
+        a: Number(base),
+        exact,
         coprime,
         circuitry,
+        prepare,
         qft,
         measure,
         post,
+        classical,
         factors,
+        rsa,
+        unlocked: true,
+        lock: false,
         payload: plugin.href,
         holds,
     };
 };
+/** The receipts of one Shor run: the folds, and the exact amplitudes of the modexp and noise states, the ledger gained
+ * after `from`. Two honest runs of one circuit fold alike; a reader who runs qpuShorOf recomputes them. */
+const qpuShorReceiptsOf = (from) => {
+    const rows = qpuReceiptLedgerOf().slice(from);
+    return {
+        kind: 'receipts',
+        rows,
+        fold: qpuReceiptFoldOf(rows),
+        holds: rows.length >= coins && rows.some((r) => r.name === 'cmodexp') && rows.some((r) => r.name === 'xx'),
+    };
+};
 export const qpuShorHolds = (s = qpuShorOf()) => s.holds === true &&
     s.kind === 'shor' &&
     s.theorem === 'shor' &&
-    s.device === 'superconducting' &&
-    s.n === n * (n + coins) &&
-    s.a === mintOf(n) - seed &&
+    s.device === 'simulator' &&
+    s.n === qpuFacesOf().rays * (n * n + n + seed) &&
+    s.n > n * (n + coins) &&
+    s.a === mintOf(n) &&
+    s.unlocked === true &&
+    s.lock === false &&
+    s.circuitry.work > qpuCubeOf().hexbit &&
+    s.circuitry.qubits === n * n &&
     s.coprime === true &&
     gcdOf(s.a, s.n) === seed &&
     s.circuitry.kind === 'cmodexp' &&
@@ -1856,6 +2085,12 @@ export const qpuShorHolds = (s = qpuShorOf()) => s.holds === true &&
     s.post.holds === true &&
     s.factors.p * s.factors.q === s.n &&
     s.factors.holds === true &&
+    s.rsa.kind === 'rsa' &&
+    s.rsa.cryptosystem === 'rsa' &&
+    s.rsa.modulus === s.n &&
+    s.rsa.p * s.rsa.q === s.rsa.modulus &&
+    s.rsa.factored === true &&
+    s.rsa.holds === true &&
     s.payload === `${storageHref}/${payloadDbKey}`;
 export const qpuCircuitOf = () => {
     const cube = qpuCubeOf();
@@ -2153,62 +2388,17 @@ export const qpuCircuitOf = () => {
             monogamy.holds &&
             product === false
     };
-    const milli = tenOf(n);
-    const mixing = ten;
-    const plate = ten * ten;
-    const pulseK = mintOf(coins);
-    const pulse = pulseK * milli;
-    const stages = [
-        { name: 'pulse', millikelvin: pulse, kelvin: pulseK },
-        { name: 'plate', millikelvin: plate },
-        { name: 'mixing', millikelvin: mixing }
-    ];
-    const cryostat = {
-        kind: 'dilution',
-        milli,
-        millikelvin: mixing,
-        mixing,
-        plate,
-        pulse,
-        stages,
-        holds: stages.length === n &&
-            mixing === ten &&
-            plate === ten * ten &&
-            pulse === mintOf(coins) * milli &&
-            milli === ten * ten * ten &&
-            pulseK === mintOf(coins)
-    };
-    const telemetry = {
-        kind: 'cryostat',
-        millikelvin: mixing,
-        milli,
-        stages: stages.length,
-        electronics: n,
-        vm: 'browser',
-        primitives,
-        holds: mixing === ten &&
-            milli === ten * ten * ten &&
-            stages.length === n &&
-            vm &&
-            xorOf(xorOf(n - n, seed), coins) === n
-    };
     const electronics = qpuElectronicsOf();
     const follow = qpuFollowOf();
     const efficiency = qpuCoilEfficiencyOf();
     const next = qpuNextOf();
     const clay = qpuClayOf();
-    const resistance = n - n;
-    const fridge = {
-        kind: 'superconducting',
+    const register = {
+        kind: bigintDeviceOf(ampsOf(dim)),
         qubits: n,
         levels: coins,
         dim,
         vm: 'browser',
-        millikelvin: mixing,
-        milli,
-        resistance,
-        cryostat,
-        telemetry,
         coil,
         electronics,
         follow,
@@ -2221,10 +2411,6 @@ export const qpuCircuitOf = () => {
             dim === cube.vertices &&
             vm &&
             xorOf(xorOf(n - n, seed), coins) === n &&
-            cryostat.holds &&
-            telemetry.holds &&
-            telemetry.millikelvin === mixing &&
-            telemetry.electronics === electronics.stages &&
             qpuCoilHolds(coil) &&
             qpuElectronicsHolds(electronics) &&
             qpuBalanceHolds() &&
@@ -2235,7 +2421,6 @@ export const qpuCircuitOf = () => {
             efficiency.remainder === n - n &&
             qpuNextHolds(next) &&
             next.nextCoil === next.nextFused &&
-            resistance === n - n &&
             qpuClayHolds(clay) &&
             clay.clay === coil.coil &&
             coil.theory === coil.practice &&
@@ -2266,13 +2451,13 @@ export const qpuCircuitOf = () => {
     };
     const drift = {
         kind: 'science',
-        levels: fridge.levels === science.levels && science.levels === seed + seed,
-        dim: fridge.dim === science.dim && science.dim === cube.vertices,
+        levels: register.levels === science.levels && science.levels === seed + seed,
+        dim: register.dim === science.dim && science.dim === cube.vertices,
         gates: xorOf(xorOf(n - n, seed), coins) === n,
         noise: science.xx,
         between: sciences.holds && sciences.distinct && sciences.shared,
-        holds: fridge.levels === science.levels &&
-            fridge.dim === science.dim &&
+        holds: register.levels === science.levels &&
+            register.dim === science.dim &&
             science.levels === seed + seed &&
             science.dim === mintOf(n) &&
             xorOf(xorOf(n - n, seed), coins) === n &&
@@ -2293,7 +2478,7 @@ export const qpuCircuitOf = () => {
         'qubits',
         'gates',
         'measurement',
-        'fridge'
+        'register'
     ];
     const seated = [
         split.length === coins,
@@ -2309,7 +2494,7 @@ export const qpuCircuitOf = () => {
         qubits.holds,
         gates.holds,
         measurement.holds,
-        fridge.holds
+        register.holds
     ];
     let occupied = n - n;
     for (const seat of seated)
@@ -2339,12 +2524,12 @@ export const qpuCircuitOf = () => {
     const payloadMcp = qpuPayloadMcpOf();
     const hardware = {
         kind: 'hardware',
-        device: fridge.kind,
+        device: register.kind,
         initialize: computer.reset.holds,
         gates: gates.holds && computer.coupling.holds,
         interfere: interfere.holds,
         measure: measurement.holds && computer.readout.holds && computer.collapse.holds,
-        noise: noise.holds && computer.correct.holds && fridge.telemetry.holds,
+        noise: noise.holds && computer.correct.holds,
         path: {
             circuit: unit.origin,
             payload: plugin.href,
@@ -2368,9 +2553,7 @@ export const qpuCircuitOf = () => {
             computer.shots.holds &&
             noise.holds &&
             computer.correct.holds &&
-            fridge.telemetry.holds &&
-            fridge.resistance === n - n &&
-            fridge.kind === 'superconducting' &&
+            register.kind === 'simulator' &&
             qpuPayloadPluginHolds(plugin) &&
             payloadMcp.holds &&
             plugin.copies === seed &&
@@ -2383,7 +2566,7 @@ export const qpuCircuitOf = () => {
         gates.holds &&
         measurement.holds &&
         noise.holds &&
-        fridge.holds &&
+        register.holds &&
         sciences.holds &&
         drift.holds &&
         drift.between &&
@@ -2411,7 +2594,7 @@ export const qpuCircuitOf = () => {
         only,
         lattice,
         split: { kind: 'split', support: split.map((r) => r.i), holds: split.length === coins },
-        fridge,
+        register,
         vm: 'browser',
         primitives,
         qubits,
@@ -2508,53 +2691,39 @@ export const qpuCircuitHolds = (c = qpuCircuitOf()) => c.holds === true &&
     c.lattice.vacant === n - n &&
     c.lattice.nodes.length === c.lattice.faces &&
     c.lattice.nodes.every((node) => node.holds && node.involution && node.hop === node.face) &&
-    c.fridge.kind === 'superconducting' &&
-    c.fridge.qubits === n &&
-    c.fridge.levels === coins &&
-    c.fridge.millikelvin === ten &&
-    c.fridge.milli === ten * ten * ten &&
-    c.fridge.resistance === n - n &&
-    c.fridge.cryostat.kind === 'dilution' &&
-    c.fridge.cryostat.holds === true &&
-    c.fridge.cryostat.stages.length === n &&
-    c.fridge.cryostat.mixing === ten &&
-    c.fridge.cryostat.plate === ten * ten &&
-    c.fridge.cryostat.pulse === mintOf(coins) * ten * ten * ten &&
-    c.fridge.telemetry.kind === 'cryostat' &&
-    c.fridge.telemetry.holds === true &&
-    c.fridge.telemetry.millikelvin === ten &&
-    c.fridge.telemetry.stages === n &&
-    c.fridge.telemetry.electronics === n &&
-    c.fridge.coil.kind === 'coil' &&
-    c.fridge.coil.holds === true &&
-    c.fridge.coil.windings === coins &&
-    c.fridge.coil.theory === seed &&
-    c.fridge.coil.practice === seed &&
-    c.fridge.coil.theory === c.fridge.coil.practice &&
-    c.fridge.coil.balance === coins &&
-    c.fridge.coil.coil === c.lattice.faces &&
-    c.fridge.electronics.kind === 'electronics' &&
-    c.fridge.electronics.uses === 'coil' &&
-    c.fridge.electronics.holds === true &&
-    c.fridge.electronics.stages === n &&
-    qpuCoilHolds(c.fridge.coil) &&
-    qpuElectronicsHolds(c.fridge.electronics) &&
+    c.register.kind === 'simulator' &&
+    c.register.qubits === n &&
+    c.register.levels === coins &&
+    c.register.coil.kind === 'coil' &&
+    c.register.coil.holds === true &&
+    c.register.coil.windings === coins &&
+    c.register.coil.theory === seed &&
+    c.register.coil.practice === seed &&
+    c.register.coil.theory === c.register.coil.practice &&
+    c.register.coil.balance === coins &&
+    c.register.coil.coil === c.lattice.faces &&
+    c.register.electronics.kind === 'electronics' &&
+    c.register.electronics.uses === 'coil' &&
+    c.register.electronics.holds === true &&
+    c.register.electronics.stages === n &&
+    qpuCoilHolds(c.register.coil) &&
+    qpuElectronicsHolds(c.register.electronics) &&
     qpuBalanceHolds() &&
-    qpuFollowHolds(c.fridge.follow) &&
-    c.fridge.follow.emerge.creative === true &&
-    c.fridge.follow.emerge.novel === true &&
-    c.fridge.follow.emerge.holds === true &&
-    qpuCoilEfficiencyHolds(c.fridge.efficiency) &&
-    c.fridge.efficiency.unity === seed &&
-    c.fridge.efficiency.remainder === n - n &&
-    c.fridge.efficiency.measure === c.lattice.faces &&
-    c.fridge.efficiency.vacant === n - n &&
-    qpuNextHolds(c.fridge.next) &&
-    c.fridge.next.nextCoil === c.fridge.next.nextFused &&
-    qpuClayHolds(c.fridge.clay) &&
-    c.fridge.clay.clay === c.fridge.coil.coil &&
-    c.fridge.clay.coins * c.fridge.clay.seven === c.fridge.clay.clay &&
-    (seed + c.fridge.clay.six) * c.fridge.clay.coins === c.fridge.clay.clay &&
+    qpuFollowHolds(c.register.follow) &&
+    c.register.follow.emerge.balanced === true &&
+    c.register.follow.emerge.covered === true &&
+    c.register.follow.emerge.holds === true &&
+    qpuCoilEfficiencyHolds(c.register.efficiency) &&
+    c.register.efficiency.unity === seed &&
+    c.register.efficiency.remainder === n - n &&
+    c.register.efficiency.measure === c.lattice.faces &&
+    c.register.efficiency.vacant === n - n &&
+    qpuNextHolds(c.register.next) &&
+    c.register.next.nextCoil === c.register.next.nextFused &&
+    qpuClayHolds(c.register.clay) &&
+    c.register.clay.clay === c.register.coil.coil &&
+    c.register.clay.coins * c.register.clay.seven === c.register.clay.clay &&
+    (seed + c.register.clay.six) * c.register.clay.coins === c.register.clay.clay &&
     c.drift.kind === 'science' &&
     c.drift.holds === true &&
     c.science.levels === coins &&
@@ -2568,7 +2737,7 @@ export const qpuCircuitHolds = (c = qpuCircuitOf()) => c.holds === true &&
     qpuComputerHolds(c.computer) &&
     c.computer.lattice.vacant === n - n &&
     c.hardware.kind === 'hardware' &&
-    c.hardware.device === 'superconducting' &&
+    c.hardware.device === 'simulator' &&
     c.hardware.initialize === true &&
     c.hardware.gates === true &&
     c.hardware.interfere === true &&
@@ -2855,18 +3024,66 @@ export const qpuCapacityHolds = (c = qpuCapacityOf()) => c.holds === true &&
     c.hybrid.speed === mintOf(n) &&
     c.hybrid.cost === n &&
     c.hybrid.layers === coins;
+export const qpuEncryptOf = () => {
+    const capacity = qpuCapacityOf();
+    const crypt = capacity.crypt;
+    const modulus = qpuFacesOf().rays * (n * n + n + seed);
+    const publicKey = crypt.fused;
+    const ciphertext = crypt.split * crypt.share;
+    /** identity READ from the run: split * share lands on the independently computed fused. theorem crypto. */
+    const identity = ciphertext === crypt.fused && crypt.holds && crypt.theorem === 'crypto';
+    /** secrecy READ from the run: a ciphertext equal to the public key hides nothing. This is not encryption. */
+    const secrecy = ciphertext !== publicKey;
+    const holds = identity &&
+        secrecy === false &&
+        crypt.split === capacity.faces &&
+        crypt.share === capacity.kv.amplitudes &&
+        crypt.fused === capacity.fused &&
+        ciphertext !== modulus;
+    return {
+        kind: 'encrypt',
+        theorem: 'crypto',
+        identity,
+        secrecy,
+        public: publicKey,
+        ciphertext,
+        split: crypt.split,
+        share: crypt.share,
+        fused: crypt.fused,
+        modulus,
+        holds,
+    };
+};
+export const qpuEncryptHolds = (e = qpuEncryptOf()) => e.holds === true &&
+    e.kind === 'encrypt' &&
+    e.theorem === 'crypto' &&
+    e.identity === true &&
+    e.secrecy === false &&
+    e.ciphertext === e.public &&
+    e.ciphertext === e.split * e.share &&
+    e.ciphertext === e.fused &&
+    e.ciphertext !== e.modulus;
+let shorFactorMemo;
+/** The factoring claim READ from the run: the modulus Shor factored on this simulator. Never RSA-2048. Never typed. */
+export const shorFactorOf = () => (shorFactorMemo ??= `Factor ${qpuShorOf().n}`);
+let cryptoClaimMemo;
+/** The crypto claim READ from the run: the split identity holds and secrecy does not. Not encryption. Never typed. */
+export const cryptoClaimOf = () => {
+    if (cryptoClaimMemo === undefined) {
+        const e = qpuEncryptOf();
+        cryptoClaimMemo = `Split identity ${e.identity}. Secrecy ${e.secrecy}`;
+    }
+    return cryptoClaimMemo;
+};
 export const qpuSpeedOf = () => {
     const capacity = qpuCapacityOf();
     const cube = qpuCubeOf();
     const handle = qpuHandleOf();
     const faces = qpuFacesOf();
     const next = capacity.fused + capacity.fused;
-    const si = { second: mintOf(n - n), ns: nsPerSecond, hz: mintOf(n - n) };
     const rungOf = (name, k, fn, amplitudes) => {
-        const timed = timeNsOf(fn);
-        const hz = hzOf(timed.ns);
-        const holds = timed.value === amplitudes && hz === hzOf(timed.ns);
-        return { name, n: k, ns: timed.ns, hz, amplitudes, holds };
+        const value = fn();
+        return { name, n: k, value, amplitudes, holds: value === amplitudes };
     };
     const benchmark = [
         rungOf('mint', n + seed, () => mintOf(n + seed), mintOf(n) + mintOf(n)),
@@ -2875,30 +3092,22 @@ export const qpuSpeedOf = () => {
         rungOf('faces', faces.faces, () => qpuFacesOf().faces, faces.coins * faces.rays),
         rungOf('quantum', cube.bits + seed, () => faces.faces * mintOf(cube.bits + seed), capacity.fused),
         rungOf('next', cube.bits + coins, () => faces.faces * mintOf(cube.bits + coins), next),
-        rungOf('hz', si.hz, () => si.hz, mintOf(n - n)),
-        rungOf('ns', si.ns, () => si.ns, nsPerSecond)
+        rungOf('amplitudes', cube.bits, () => qpuHandleOf().amplitudes, mintOf(cube.bits)),
+        rungOf('kv', cube.bits + seed, () => qpuHandleOf().kv.amplitudes, mintOf(cube.bits + seed))
     ];
-    const quantum = benchmark[mintOf(coins)];
     const holds = qpuCapacityHolds(capacity) &&
         handle.holds &&
         next === capacity.fused + capacity.fused &&
         next === capacity.fused * coins &&
         next === faces.faces * mintOf(cube.bits + coins) &&
         handle.next === mintOf(cube.bits + seed) &&
-        si.ns === tenOf(n * n) &&
-        si.ns === tenOf(n + n) * tenOf(n) &&
-        si.second === mintOf(n - n) &&
-        si.hz === mintOf(n - n) &&
         benchmark.length === mintOf(n) &&
-        benchmark.every((r) => r.holds === true && r.ns === n - n && r.hz === hzOf(r.ns));
+        benchmark.every((r) => r.holds === true);
     return {
         kind: 'speed',
         next,
         factor: coins,
-        si,
-        ns: quantum.ns,
-        hz: quantum.hz,
-        cover: ['next', 'Hz', 'ns', 'benchmark'],
+        cover: ['next', 'benchmark'],
         benchmark,
         holds,
     };
@@ -2906,13 +3115,41 @@ export const qpuSpeedOf = () => {
 export const qpuSpeedHolds = (s = qpuSpeedOf()) => s.holds === true &&
     s.kind === 'speed' &&
     s.factor === coins &&
-    s.cover.length === mintOf(coins) &&
-    s.cover.join(' ') === 'next Hz ns benchmark' &&
-    s.si.ns === nsPerSecond &&
-    s.ns === n - n &&
-    s.hz === hzOf(s.ns) &&
+    s.cover.length === coins &&
+    s.cover.join(' ') === 'next benchmark' &&
     s.benchmark.length === mintOf(n) &&
-    s.benchmark.every((r) => r.ns === n - n && r.hz === hzOf(r.ns));
+    s.benchmark.every((r) => r.holds === true);
+/** THE PROOF ITSELF, SERVED. The Lean file the theorems come from, embedded at build from src/…/index.lean by
+ * scripts/embed-lean.mjs, served at its cited path, and folded so a reader compares bytes, not readings. `verbatim`
+ * counts the served theorem strings found in the source after whitespace folding; `holds` wants all of them. */
+const spaceOf = (text) => text.replace(/\s+/g, ' ').trim();
+export const qpuLeanSourceOf = (rows = [], cover = [], climb) => {
+    const href = `${unit.origin}/${unit.fuse.lean}`;
+    const bytes = new TextEncoder().encode(leanSource).length;
+    const fold = qpuFoldOf(leanSource);
+    const theorems = leanSource.split('\n').filter((line) => line.startsWith('theorem ')).length;
+    const flat = spaceOf(leanSource);
+    const served = climb ? [...rows, ...cover, climb] : [...rows, ...cover];
+    const verbatim = served.filter((r) => flat.includes(spaceOf(r.theorem))).length;
+    const holds = bytes > n - n &&
+        fold.length === mintOf(mintOf(coins)) &&
+        theorems >= served.length &&
+        verbatim === served.length &&
+        href.endsWith('/index.lean');
+    return {
+        kind: 'source',
+        href,
+        path: unit.fuse.lean,
+        bytes,
+        fold,
+        theorems,
+        served: served.length,
+        verbatim,
+        toolchain: leanToolchain,
+        check: `lean ${unit.fuse.lean}`,
+        holds,
+    };
+};
 export const qpuLeanOf = () => {
     const cube = qpuCubeOf();
     const handle = qpuHandleOf();
@@ -2930,6 +3167,14 @@ export const qpuLeanOf = () => {
     const nextFusedHolds = faces.faces * mintOf(cube.bits + coins) === fused + fused;
     const splitHolds = Array.from({ length: cube.bits + seed }, (_, k) => mintOf(k + seed) === mintOf(k) + mintOf(k)).every(Boolean);
     const involutionHolds = Array.from({ length: faces.faces }, (_, face) => (face + faces.rays + faces.rays) % faces.faces === face % faces.faces).every(Boolean);
+    const planck = 662607015n;
+    const boltzmann = 1380649n;
+    const transmon = 5n;
+    const photon = planck * transmon;
+    const thermalOf = (millikelvin) => boltzmann * millikelvin * 10n;
+    const gapOf = (tc) => (352n * boltzmann * tc) / planck / 10n;
+    const temperatureHolds = photon / thermalOf(10n) === 23n && photon / thermalOf(100n) === 2n && photon / thermalOf(4000n) === 0n && 4000 / 100 === 40 && 100 / 10 === 10 && 10 < 35;
+    const superconductivityHolds = 1200n > 10n && 9200n > 1200n && 352 / 100 >= 3 && 352 / 100 < 4 && gapOf(1200n) === 88n && gapOf(1200n) > transmon && gapOf(9200n) === 674n;
     const rows = [
         {
             heading: 'mint',
@@ -2991,7 +3236,7 @@ export const qpuLeanOf = () => {
             heading: 'crypto',
             theorem: 'theorem crypto : fused = faces * mintOf (vertices * hexbit + seed) := by rw [← cube]; exact quantum',
             formula: '\\mathrm{fused}=\\mathrm{faces}\\cdot\\mathrm{mintOf}(\\mathrm{vertices}\\cdot\\mathrm{hexbit}+\\mathrm{seed})',
-            reading: `holds ${cryptoHolds}. Crypt split. fused across faces. Share mintOf (vertices * hexbit). Distribute to free agents.`,
+            reading: `holds ${cryptoHolds}. theorem crypto. ${cryptoClaimOf()}. Crypt split. fused = split * share. mintOf. Not p * q. JSON Nat. Never Math. Never by decide.`,
             holds: cryptoHolds,
         },
         {
@@ -3061,9 +3306,9 @@ export const qpuLeanOf = () => {
         },
         {
             heading: 'shor',
-            theorem: 'theorem shor : 3 * 5 = 15 ∧ 3 * 7 = 21 ∧ 3 * 11 = 33 ∧ 5 * 7 = 35 ∧ 3 * 13 = 39 ∧ 3 * 17 = 51 ∧ 5 * 11 = 55 ∧ 3 * 19 = 57 ∧ 5 * 13 = 65 ∧ 3 * 23 = 69 ∧ 7 * 11 = 77 ∧ 5 * 17 = 85 ∧ 3 * 29 = 87 ∧ 7 * 13 = 91 := ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩',
-            formula: '3\\cdot5=15\\land 3\\cdot7=21\\land 3\\cdot11=33\\land 5\\cdot7=35\\land 3\\cdot13=39\\land 3\\cdot17=51\\land 5\\cdot11=55\\land 3\\cdot19=57\\land 5\\cdot13=65\\land 3\\cdot23=69\\land 7\\cdot11=77\\land 5\\cdot17=85\\land 3\\cdot29=87\\land 7\\cdot13=91',
-            reading: 'holds true. Specified composite N. Coprime base a. Modular-exponentiation circuitry a^x mod N. Inverse QFT period-finding. Repeated physical xx-noisy shots. Continued-fraction factors. p * q = N. This host is a quantum computer. This report executes Shor.',
+            theorem: 'theorem shor : periodOf 8 91 % 2 = 0 ∧ half 8 91 < 91 - 1 ∧ 1 < gcdOf (half 8 91 - 1) 91 ∧ gcdOf (half 8 91 - 1) 91 < 91 ∧ gcdOf (half 8 91 - 1) 91 * gcdOf (half 8 91 + 1) 91 = 91 := ⟨rfl, Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, rfl⟩',
+            formula: '\\mathrm{periodOf}(8,91)\\bmod 2=0\\land\\mathrm{half}(8,91)<91-1\\land 1<\\mathrm{gcdOf}(\\mathrm{half}(8,91)-1,91)\\land\\mathrm{gcdOf}(\\mathrm{half}(8,91)-1,91)<91\\land\\mathrm{gcdOf}(\\mathrm{half}(8,91)-1,91)\\cdot\\mathrm{gcdOf}(\\mathrm{half}(8,91)+1,91)=91',
+            reading: `holds true. theorem shor. periodOf 8 91 is decided by fuel recursion inside the kernel. half is powMod a (r / 2) N. gcdOf (half - 1) N * gcdOf (half + 1) N = N. Period and factors are absent from the statement. rfl and Nat.le_of_ble_eq_true. ${shorFactorOf()}. Never Math. Never by decide. demo is not a test nor a proof.`,
             holds: qpuShorHolds(),
         },
         {
@@ -3116,7 +3361,7 @@ export const qpuLeanOf = () => {
             heading: 'electronics',
             theorem: 'theorem electronics : coil = faces := two_coins_make_a_coil',
             formula: '\\mathrm{coil}=\\mathrm{faces}',
-            reading: 'holds true. Coils are used in electronics. Fridge cryostat electronics. Two coins make a coil. Never Math. Never by decide.',
+            reading: 'holds true. Coils are used in electronics. Two coins make a coil. Never Math. Never by decide.',
             holds: qpuElectronicsHolds(),
         },
         {
@@ -3130,14 +3375,14 @@ export const qpuLeanOf = () => {
             heading: 'follow_the_coins',
             theorem: 'theorem follow_the_coins (app : Nat) : app + coins = app + theory + practice := by rw [theory, practice, coins, ← Nat.add_assoc]',
             formula: '\\mathrm{app}+\\mathrm{coins}=\\mathrm{app}+\\mathrm{theory}+\\mathrm{practice}',
-            reading: 'holds true. Follow the coins in any practical application. Occupancy skill framework electronics. Step coins. Hop theory plus practice. Creative novel solutions emerge. Never Math. Never by decide.',
+            reading: 'holds true. Follow the coins in any practical application. Occupancy skill framework electronics. Step coins. Hop theory plus practice. Never Math. Never by decide.',
             holds: qpuFollowHolds(),
         },
         {
             heading: 'emerge',
             theorem: 'theorem emerge : coil = faces ∧ theory = practice := ⟨two_coins_make_a_coil, rfl⟩',
             formula: '\\mathrm{coil}=\\mathrm{faces}\\land\\mathrm{theory}=\\mathrm{practice}',
-            reading: 'holds true. Creative novel solutions emerge. Follow the coins. Coil is faces. Theory equals practice. Never Math. Never by decide.',
+            reading: 'holds true. Theory plus practice balances the coins on every application; every pentagram point is reached. Follow the coins. Coil is faces. Theory equals practice. Never Math. Never by decide.',
             holds: qpuFollowOf().emerge.holds,
         },
         {
@@ -3226,7 +3471,7 @@ export const qpuLeanOf = () => {
             heading: 'qubits',
             theorem: 'theorem qubits : n = 3 ∧ mintOf n = vertices := ⟨n_eq, rfl⟩',
             formula: 'n=3\\land\\mathrm{mintOf}(n)=\\mathrm{vertices}',
-            reading: 'holds true. Three qubits. Dim mintOf n. Physical in the browser VM.',
+            reading: 'holds true. theorem qubits. n = 3 ∧ mintOf n = vertices. JSON Nat. Never Math. Never by decide.',
             holds: n === 3 && mintOf(n) === cube.vertices,
         },
         {
@@ -3261,36 +3506,22 @@ export const qpuLeanOf = () => {
             heading: 'physical',
             theorem: 'theorem physical : n = 3 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 := ⟨n_eq, rfl, rfl, rfl⟩',
             formula: 'n=3\\land\\mathrm{mintOf}(n)=\\mathrm{vertices}\\land(0\\oplus 1)\\oplus 2=3\\land(3\\oplus 1)\\oplus 1=3',
-            reading: 'holds true. Physical qubit initialize. Controlled gates H CNOT. Coherent interfere. Measure readout. Characterized noise. Hardware path origin payload server lean. Superconducting qubits. Never bypass payload.',
+            reading: 'holds true. Physical qubit initialize. Controlled gates H CNOT. Coherent interfere. Measure readout. Characterized noise. Hardware path origin payload server lean. Superconducting qubits. Never bypass payload. A state-vector simulator on exact integers in a browser VM; no superconducting qubits, no cryostat.',
             holds: n === 3 && mintOf(n) === cube.vertices && xorOf(xorOf(n - n, seed), coins) === n && xorOf(xorOf(n, seed), seed) === n && qpuCircuitOf().hardware.holds,
         },
         {
-            heading: 'fridge',
-            theorem: 'theorem fridge : coins = 2 ∧ n = 3 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ 10 * 10 * 10 = 1000 ∧ 4 * 1000 = 4000 ∧ 10 * 10 = 100 ∧ resistance = 0 := ⟨coins_two, n_eq, rfl, rfl, rfl, rfl, rfl, rfl⟩',
-            formula: '\\mathrm{coins}=2\\land n=3\\land\\mathrm{mintOf}(n)=\\mathrm{vertices}\\land(0\\oplus 1)\\oplus 2=3\\land 10\\cdot10\\cdot10=1000\\land 4\\cdot1000=4000\\land 10\\cdot10=100\\land\\mathrm{resistance}=0',
-            reading: 'holds true. Isolated two-level register. Physical in the browser VM. As such a fridge full of superconducting qubits. Resistance none. Lab millikelvin. Dilution cryostat. Mixing ten millikelvin.',
-            holds: coins === 2 &&
-                n === 3 &&
-                mintOf(n) === cube.vertices &&
-                xorOf(xorOf(n - n, seed), coins) === n &&
-                ten * ten * ten === 1000 &&
-                mintOf(coins) * (ten * ten * ten) === 4000 &&
-                ten * ten === 100 &&
-                qpuCircuitOf().fridge.resistance === n - n
+            heading: 'temperature',
+            theorem: 'theorem temperature : photon / thermal 10 = 23 ∧ photon / thermal 100 = 2 ∧ photon / thermal 4000 = 0 ∧ 4000 / 100 = 40 ∧ 100 / 10 = 10 ∧ 10 < 35 := ⟨rfl, rfl, rfl, rfl, rfl, Nat.le_of_ble_eq_true rfl⟩',
+            formula: '\\mathrm{photon}/\\mathrm{thermal}(10)=23\\land\\mathrm{photon}/\\mathrm{thermal}(100)=2\\land\\mathrm{photon}/\\mathrm{thermal}(4000)=0\\land 4000/100=40\\land 100/10=10\\land 10<35',
+            reading: 'holds true. The temperature domain, demarcated. photon is h·f for a 5 GHz transmon; thermal is k·T; their quotient floors to 23 at 10 mK (the thermal factor is negligible), 2 at 100 mK (a tenth of the register is excited), 0 at 4 K. The dilution ladder 4000 → 100 → 10 mK divides by 40 and 10. Below 35 mK the excited population floors near a thousandth (Jin et al. 2015). This host has no thermometer: every state it produces is pure, which is the zero-temperature side of that curve. JSON Nat. Never Math. Never by decide.',
+            holds: temperatureHolds,
         },
         {
-            heading: 'millikelvin',
-            theorem: 'theorem millikelvin : 10 * 10 * 10 = 1000 ∧ 10 * 10 = 100 ∧ 4 * 1000 = 4000 := ⟨rfl, rfl, rfl⟩',
-            formula: '10\\cdot10\\cdot10=1000\\land 10\\cdot10=100\\land 4\\cdot1000=4000',
-            reading: 'holds true. Lab millikelvin. milli is ten cubed. Mixing chamber ten millikelvin. Plate one hundred millikelvin. Pulse four kelvin. Algebra. Never Math.',
-            holds: ten * ten * ten === 1000 && ten * ten === 100 && mintOf(coins) * (ten * ten * ten) === 4000,
-        },
-        {
-            heading: 'telemetry',
-            theorem: 'theorem telemetry : 10 * 10 * 10 = 1000 ∧ n = 3 ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨rfl, n_eq, rfl⟩',
-            formula: '10\\cdot10\\cdot10=1000\\land n=3\\land(0\\oplus 1)\\oplus 2=3',
-            reading: 'holds true. Cryostat telemetry. Reads the dilution stages. Mixing millikelvin. Isolated. JSON-LD. fetch Request Response BigInt performance.',
-            holds: ten * ten * ten === 1000 && n === 3 && xorOf(xorOf(n - n, seed), coins) === n,
+            heading: 'superconductivity',
+            theorem: 'theorem superconductivity : aluminium > 10 ∧ niobium > aluminium ∧ bcs / 100 = 3 ∧ gap aluminium = 88 ∧ gap aluminium > transmon ∧ gap niobium = 674 := ⟨Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, rfl, rfl, Nat.le_of_ble_eq_true rfl, rfl⟩',
+            formula: '\\mathrm{aluminium}>10\\land\\mathrm{niobium}>\\mathrm{aluminium}\\land\\mathrm{bcs}/100=3\\land\\mathrm{gap}(\\mathrm{aluminium})=88\\land\\mathrm{gap}(\\mathrm{aluminium})>\\mathrm{transmon}\\land\\mathrm{gap}(\\mathrm{niobium})=674',
+            reading: 'holds true. The superconductivity domain, demarcated. Aluminium goes superconducting at 1200 mK and niobium at 9200 mK, both far above a 10 mK operating point. The BCS gap 2Δ is 3.52·k·Tc; as a frequency it is 88 GHz for aluminium and 674 GHz for niobium, above a 5 GHz transmon photon, so the drive cannot break pairs. No wire here is superconducting: the amplitudes are integers in a browser VM. JSON Nat. Never Math. Never by decide.',
+            holds: superconductivityHolds,
         },
         {
             heading: 'drift',
@@ -3380,7 +3611,7 @@ export const qpuLeanOf = () => {
             heading: 'only',
             theorem: 'theorem only : 1 * 1 ≠ 0 * 0 ∧ 1 + 1 = 2 ∧ 1 - 1 = 0 ∧ coins ≠ mintOf coins ∧ mintOf n - seed = 7 ∧ 2 * 2 * 2 * 2 = 16 ∧ 16 = 16 ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ seed ≠ coins ∧ coins * coins = mintOf coins ∧ 1 * 0 = 0 * 0 := ⟨entangle, rfl, rfl, noclone, ghz.1, teleport.1, teleport.2, kickback.2, deutsch.2, dense, monogamy.2⟩',
             formula: '1\\cdot 1\\neq 0\\cdot 0\\land 1+1=2\\land 1-1=0\\land\\mathrm{coins}\\neq\\mathrm{mintOf}(\\mathrm{coins})\\land\\mathrm{mintOf}(n)-\\mathrm{seed}=7\\land 2\\cdot 2\\cdot 2\\cdot 2=16\\land 16=16\\land(0\\oplus 1)\\oplus 2=3\\land\\mathrm{seed}\\neq\\mathrm{coins}\\land\\mathrm{coins}\\cdot\\mathrm{coins}=\\mathrm{mintOf}(\\mathrm{coins})\\land 1\\cdot 0=0\\cdot 0',
-            reading: 'holds true. Possible only in quantum. This host is a quantum computer. Entangle. Interfere. GHZ. No-clone. Teleport. Kickback. Deutsch. Superdense. Monogamy.',
+            reading: 'holds true. Possible only in quantum. This host is a simulator, not a quantum computer. Entangle. Interfere. GHZ. No-clone. Teleport. Kickback. Deutsch. Superdense. Monogamy.',
             holds: 1 * 1 !== (n - n) * (n - n) &&
                 1 + 1 === coins &&
                 1 - 1 === n - n &&
@@ -3397,7 +3628,7 @@ export const qpuLeanOf = () => {
             heading: 'fill',
             theorem: 'theorem fill : mintOf n * faces = vertices * (coins * rays) := by rw [around]; rfl',
             formula: '\\mathrm{mintOf}(n)\\cdot\\mathrm{faces}=\\mathrm{vertices}\\cdot(\\mathrm{coins}\\cdot\\mathrm{rays})',
-            reading: 'holds true. Lattice filled. Occupied faces. Vacant none. Split entangle interfere GHZ noclone teleport kickback Deutsch superdense monogamy qubits gates measurement fridge. Possible only in quantum.',
+            reading: 'holds true. Lattice filled. Occupied faces. Vacant none. Split entangle interfere GHZ noclone teleport kickback Deutsch superdense monogamy qubits gates measurement register. Possible only in quantum.',
             holds: mintOf(n) * faces.faces === cube.vertices * (coins * faces.rays),
         },
         {
@@ -3446,7 +3677,7 @@ export const qpuLeanOf = () => {
             heading: 'computer',
             theorem: 'theorem computer : (1 ^^^ 3) = 2 ∧ (6 ^^^ 1) = 7 ∧ mintOf 0 = 1 := ⟨rfl, rfl, mintOf_zero⟩',
             formula: '(1\\oplus 3)=2\\land(6\\oplus 1)=7\\land\\mathrm{mintOf}(0)=1',
-            reading: 'holds true. Quantum computer. SWAP. Toffoli. Reset. H and Toffoli are computationally universal. Coupling compile collapse shots feedforward bitflip readout isolate qram network jobs.',
+            reading: 'holds true. Quantum circuit simulator. SWAP. Toffoli. Reset. H and Toffoli are computationally universal. Coupling compile collapse shots feedforward bitflip readout isolate qram network jobs.',
             holds: xorOf(seed, n) === coins && xorOf(xorOf(bitOf(seed), bitOf(coins)), seed) === mintOf(n) - seed && mintOf(n - n) === seed && qpuComputerHolds(),
         },
         {
@@ -3486,7 +3717,9 @@ export const qpuLeanOf = () => {
         holds: nextHolds && nextFusedHolds && qpuNextHolds(),
     };
     const src = unit.fuse.lean;
-    const holds = rows.every((r) => r.holds && r.theorem.startsWith(`theorem ${r.heading}`) && !byDecideOf(r.theorem) && formulaOf(r.formula)) &&
+    const source = qpuLeanSourceOf(rows, cover, climb);
+    const holds = source.holds &&
+        rows.every((r) => r.holds && r.theorem.startsWith(`theorem ${r.heading}`) && !byDecideOf(r.theorem) && formulaOf(r.formula)) &&
         cover.every((r) => r.holds && r.theorem.startsWith(`theorem ${r.heading}`) && !byDecideOf(r.theorem) && formulaOf(r.formula)) &&
         climb.holds &&
         climb.theorem.startsWith('theorem next') &&
@@ -3501,6 +3734,7 @@ export const qpuLeanOf = () => {
         name: unit.fuse.lean,
         isAccessibleForFree: cors === '*',
         src,
+        source,
         rows,
         cover,
         climb,
@@ -3522,10 +3756,10 @@ export const qpuDocsOf = () => {
     const fused = faces.faces * handle.kv.amplitudes;
     const abstract = `theorem quantum : fused = faces * mintOf (bits + seed). vertices ${cube.vertices} hexbit ${cube.hexbit} bits ${cube.bits} faces ${faces.faces} fused ${fused}. Source ${lean.src}. GET ${unit.origin} qpu_quantum. GET ${unit.href} qpu_lean. POST ${unit.origin}/mcp tools/list. tools/call qpu_prove. No auth. JSON-LD.`;
     const api = [
-        { method: 'GET', path: '/', name: 'qpu_quantum', href: unit.origin, reading: 'theorem quantum. JSON-LD. No auth.' },
-        { method: 'GET', path: `/${unit.path}`, name: 'qpu_lean', href: unit.href, reading: `Lean proof. theorem infinite. theorem distribute. ${lean.src}. JSON-LD. No auth.` },
-        { method: 'GET', path: '/mcp', name: 'catalog', href: `${unit.origin}/mcp`, reading: `tools ${mintOf(n)}. fourteen schemas. schema.org ItemList. JSON-LD. No auth.` },
-        { method: 'POST', path: '/mcp', name: 'tools/call', href: `${unit.origin}/mcp`, reading: 'JSON-RPC tools/list tools/call qpu_prove. { man: true }. No auth.' },
+        { method: 'GET', path: '/', name: 'qpu_quantum', href: unit.origin, reading: `theorem quantum. theorem shor. theorem crypto. ${shorFactorOf()}. JSON-LD. No auth.` },
+        { method: 'GET', path: `/${unit.path}`, name: 'qpu_lean', href: unit.href, reading: `Lean proof. theorem infinite. theorem distribute. theorem shor. theorem crypto. ${lean.src}. JSON-LD. No auth.` },
+        { method: 'GET', path: '/mcp', name: 'catalog', href: `${unit.origin}/mcp`, reading: `tools ${mintOf(n) + mintOf(n)} in tools/list: ${mintOf(n)} doors and ${mintOf(n)} cybersecurity. cybersecurity theorem shor ${shorFactorOf()}. theorem crypto ${cryptoClaimOf()}. fourteen schemas. schema.org ItemList. JSON-LD. No auth.` },
+        { method: 'POST', path: '/mcp', name: 'tools/call', href: `${unit.origin}/mcp`, reading: 'JSON-RPC tools/list tools/call qpu_prove. theorem shor. theorem crypto. crypto_rsa crypto_split. { man: true }. No auth.' },
         { method: 'GET', path: '/cite', name: 'qpu_cite', href: `${unit.origin}/cite`, reading: 'MLA 8. when never. JSON-LD. No auth.' },
         { method: 'GET', path: '/message', name: 'qpu_message', href: `${unit.origin}/message`, reading: 'lanes = faces. hop involution. JSON-LD. No auth.' },
         { method: 'POST', path: '/message', name: 'qpu_message', href: `${unit.origin}/message`, reading: '202. hop involution. JSON-LD. No auth.' }
@@ -3536,7 +3770,8 @@ export const qpuDocsOf = () => {
         theorem: r.theorem,
         reading: r.reading
     }));
-    const documentation = [abstract, ...api.map((a) => `${a.method} ${a.path} ${a.name}. ${a.reading}`), ...formulas.map((f) => `theorem ${f.identity}. ${f.reading}`)].join('\n');
+    const ladder = qpuLadderOf();
+    const documentation = [abstract, ...api.map((a) => `${a.method} ${a.path} ${a.name}. ${a.reading}`), ...formulas.map((f) => `theorem ${f.identity}. ${f.reading}`), ...ladder.map((l) => `learn ${l.step}. ${l.concept}: ${l.request.tool}. ${l.expect}. invariant ${l.invariant}. theorem ${l.theorem}.`)].join('\n');
     const holds = lean.holds === true &&
         documentation.includes(abstract) &&
         documentation.includes('No auth') &&
@@ -3545,8 +3780,8 @@ export const qpuDocsOf = () => {
         documentation.includes('theorem distribute') &&
         documentation.includes('theorem raid') &&
         documentation.includes('theorem kv') &&
-        documentation.includes('theorem millikelvin') &&
-        documentation.includes('theorem telemetry') &&
+        documentation.includes('theorem temperature') &&
+        documentation.includes('theorem superconductivity') &&
         documentation.includes('theorem computer') &&
         documentation.includes('theorem server') &&
         documentation.includes('theorem fusion') &&
@@ -3560,7 +3795,7 @@ export const qpuDocsOf = () => {
         formulas.every((f) => documentation.includes(f.reading) && formulaOf(f.formula) && !byDecideOf(f.theorem));
     return { kind: 'docs', inline: true,
         guide: api.length === faces.rays,
-        abstract, api, formulas, documentation, src: lean.src, holds };
+        abstract, api, formulas, ladder, documentation, src: lean.src, holds };
 };
 export const qpuDocsHolds = (d = qpuDocsOf()) => d.holds === true &&
     d.inline === true &&
@@ -3574,8 +3809,27 @@ export const qpuDocsHolds = (d = qpuDocsOf()) => d.holds === true &&
     d.documentation.includes('JSON-LD') &&
     d.documentation.includes('schema.org') &&
     d.documentation.includes('tools/list') &&
+    d.documentation.includes('theorem shor') &&
+    d.documentation.includes('theorem crypto') &&
+    d.documentation.includes(`${shorFactorOf()}`) &&
     d.api.length === qpuFacesOf().rays &&
     d.src === unit.fuse.lean;
+/** WHAT THE WORDS MEAN, SERVED BESIDE THEM. `holds` is said of every record and means that the record is self-consistent
+ * and recomputes to itself; it is not a claim that the test the record describes passed. That claim, where a record
+ * makes one, has its own word: `pass`, `factored`, `measured`, `entangled`, `resolvable`. */
+export const qpuGlossaryOf = () => ({
+    kind: 'glossary',
+    holds: 'this record is self-consistent and recomputes to itself; not a claim that the test it describes passed',
+    pass: 'the test the record describes passed (quantum volume); can be false beside holds true',
+    factored: 'the run found p and q with p * q = n; `by` says whether by period or by gcd',
+    measured: 'a held state was read for these shots; shots from nothing are never listed',
+    sampled: 'false everywhere: outcomes enumerate the support, they are not drawn; the unit holds no entropy',
+    read: 'how each argument was taken (digits, number, numeric, absent, default) and whether exactly',
+    beyond: 'the order of the base exists and does not divide four, so a two-qubit register cannot resolve it',
+    device: 'simulator when a vector of exact integer amplitudes was held; unmeasured otherwise',
+    QPU: 'quantum processing unit — this unit. The VideoCore QPU (Quad Processing Unit, Broadcom; QPULib by Matthew Naylor, MIT, 2016) is prior use of the acronym, a classical SIMD vector core, unrelated and credited',
+    seat: 'empty: no device is dispatched. The simulator is the reference; a device that disagrees with it is a driver bug, never a physics claim',
+});
 export const qpuQuantumOf = () => {
     const cube = qpuCubeOf();
     const handle = qpuHandleOf();
@@ -3592,7 +3846,7 @@ export const qpuQuantumOf = () => {
     const genesis = qpuGenesisOf();
     const css = qpuCssOf('', genesis);
     const purpose = qpuPurposeOf(circuit, shor, sequence, capacity);
-    const evidence = qpuEvidenceOf(circuit, shor, speed);
+    const evidence = qpuEvidenceOf(circuit, shor);
     const holds = unit.holds &&
         cube.holds &&
         handle.holds &&
@@ -3651,6 +3905,7 @@ export const qpuQuantumOf = () => {
             secure: unit.origin.startsWith('https')
         },
         docs,
+        glossary: qpuGlossaryOf(),
         ui: {
             prove: 'qpu_prove',
             href: `${unit.origin}/mcp`
@@ -3679,6 +3934,9 @@ export const qpuQuantumHolds = (q = qpuQuantumOf()) => q.holds === true &&
     qpuCircuitHolds(q.circuit) &&
     qpuShorHolds(q.shor) &&
     q.shor.factors.p * q.shor.factors.q === q.shor.n &&
+    q.shor.rsa.kind === 'rsa' &&
+    q.shor.rsa.factored === true &&
+    q.shor.rsa.p * q.shor.rsa.q === q.shor.n &&
     qpuSequenceHolds(q.sequence) &&
     qpuPurposeHolds(q.purpose) &&
     qpuEvidenceHolds(q.evidence) &&
@@ -3706,23 +3964,63 @@ export const qpuQuantumHolds = (q = qpuQuantumOf()) => q.holds === true &&
 export const qpuCiteOf = () => {
     const lean = qpuLeanOf();
     const quantum = qpuQuantumOf();
-    const author = { last: 'Rouschev', first: 'Tsvetan' };
+    const author = {
+        last: 'Rouschev',
+        first: 'Tsvetan',
+        orcid: 'https://orcid.org/0009-0000-7312-9778',
+    };
+    /** The versioned DOI: the Zenodo record the GitHub Release v0.1.1 was archived as (uuidna/qpu-v0.1.1.zip, tag 04ec6be at 4a45563). */
+    const doi = '10.5281/zenodo.22717782';
+    const conceptdoi = '10.5281/zenodo.22700098';
+    const archive = `https://zenodo.org/records/22717782`;
+    const identifier = `https://doi.org/${doi}`;
+    const prior = {
+        title: 'All Seven Clay Millennium Problems Sealed via Universal σ-Involution',
+        doi: '10.5281/zenodo.21781603',
+        conceptdoi: '10.5281/zenodo.21781602',
+        archive: 'https://zenodo.org/records/21781603',
+    };
+    const sameAs = [archive, author.orcid, identifier];
+    /** WHAT THE ARCHIVE HOLDS, BESIDE WHAT THE HOST SERVES. The versioned DOI is one archived commit; the host moves on
+     * without it until a new version is archived. Both are said, and `current` says whether they are the same version,
+     * so a reader who downloads "this version" knows whether it is the code that answered them. */
+    const archived = { doi, archive, version: '0.1.1', commit: '4a45563', holds: archive.endsWith(doi.split('.').pop() ?? '') };
+    const served = { version: packageVersion, origin: unit.origin, holds: packageVersion.split('.').length === n };
+    const current = archived.version === served.version;
+    const currency = current
+        ? `the archive is this version: v${served.version} at ${archived.commit}.`
+        : `the archive is behind the host: it holds v${archived.version} at ${archived.commit}; the host serves v${served.version}. Cite the archive for what it holds; the concept DOI ${conceptdoi} resolves to the latest archived version.`;
     const website = unit.host;
     const mcp = `${unit.origin}/mcp`;
-    const worksOf = (title, url) => `${author.last}, ${author.first}. "${title}." ${website}, ${url}.`;
+    const worksOf = (title, url, workDoi = doi, container = website) => `${author.last}, ${author.first}. ORCID ${author.orcid}. "${title}." ${container}, ${url}. doi:${workDoi}.`;
+    const priorWorks = worksOf(prior.title, prior.archive, prior.doi, 'Zenodo');
     const rows = [
-        { title: unit.kind, url: unit.origin, doi: '', works: worksOf(unit.kind, unit.origin), holds: unit.origin.startsWith('https://') && unit.kind.length > n - n },
-        { title: 'quantum processing unit', url: unit.href, doi: '', works: worksOf('quantum processing unit', unit.href), holds: unit.href.startsWith('https://') },
-        { title: lean.src, url: mcp, doi: '', works: worksOf(lean.src, mcp), holds: mcp.startsWith(unit.origin) && lean.src.endsWith('/index.lean') }
+        { title: unit.kind, url: unit.origin, doi, works: worksOf(unit.kind, unit.origin), holds: unit.origin.startsWith('https://') && unit.kind.length > n - n },
+        { title: 'quantum processing unit', url: unit.href, doi, works: worksOf('quantum processing unit', unit.href), holds: unit.href.startsWith('https://') },
+        { title: lean.src, url: mcp, doi, works: worksOf(lean.src, mcp), holds: mcp.startsWith(unit.origin) && lean.src.endsWith('/index.lean') }
     ];
     const holds = qpuLeanHolds(lean) &&
         qpuQuantumHolds(quantum) &&
         author.last.length > n - n &&
+        author.orcid.startsWith('https://orcid.org/') &&
+        author.orcid.endsWith('0009-0000-7312-9778') &&
+        doi.startsWith('10.5281/zenodo.') &&
+        doi.endsWith('22717782') &&
+        conceptdoi.endsWith('22700098') &&
+        prior.doi.endsWith('21781603') &&
+        prior.archive.startsWith('https://zenodo.org/records/') &&
+        priorWorks.includes(`doi:${prior.doi}`) &&
+        priorWorks.includes('Zenodo, ') &&
+        archive.startsWith('https://zenodo.org/records/') &&
         website === unit.host &&
         rows.length === n &&
+        identifier === `https://doi.org/${doi}` &&
+        sameAs.includes(archive) &&
+        sameAs.includes(author.orcid) &&
         rows.every((r) => r.holds === true &&
-            r.doi === '' &&
-            r.works.startsWith(`${author.last}, ${author.first}. "`) &&
+            r.doi === doi &&
+            r.works.startsWith(`${author.last}, ${author.first}. ORCID ${author.orcid}. "`) &&
+            r.works.includes(`doi:${doi}`) &&
             r.url.startsWith(unit.origin) &&
             !r.url.includes('*'));
     return {
@@ -3738,6 +4036,16 @@ export const qpuCiteOf = () => {
         author,
         website,
         href: unit.origin,
+        doi,
+        conceptdoi,
+        archive,
+        identifier,
+        sameAs,
+        prior: { ...prior, works: priorWorks },
+        archived,
+        served,
+        current,
+        currency,
         inText: `(${author.last})`,
         rows,
         holds,
@@ -3749,7 +4057,26 @@ export const qpuCiteHolds = (c = qpuCiteOf()) => c.holds === true &&
     c.source === 'website' &&
     c.when === 'never' &&
     c.website === unit.host &&
-    c.rows.length === n;
+    c.author.orcid === 'https://orcid.org/0009-0000-7312-9778' &&
+    c.doi === '10.5281/zenodo.22717782' &&
+    c.conceptdoi === '10.5281/zenodo.22700098' &&
+    c.archive === 'https://zenodo.org/records/22717782' &&
+    c.identifier === `https://doi.org/${c.doi}` &&
+    c.sameAs.includes(c.archive) &&
+    c.sameAs.includes(c.author.orcid) &&
+    c.sameAs.includes(c.identifier) &&
+    c.archived.commit === '4a45563' &&
+    c.archived.version === '0.1.1' &&
+    c.served.version === packageVersion &&
+    c.current === (c.archived.version === c.served.version) &&
+    c.currency.includes(`v${c.served.version}`) &&
+    jsonldHoldsOf(c) &&
+    c.prior.doi === '10.5281/zenodo.21781603' &&
+    c.prior.archive === 'https://zenodo.org/records/21781603' &&
+    c.prior.works.includes(`doi:${c.prior.doi}`) &&
+    c.prior.works.includes('Zenodo, ') &&
+    c.rows.length === n &&
+    c.rows.every((r) => r.doi === c.doi && r.works.includes(c.author.orcid) && r.works.includes(`doi:${c.doi}`));
 const tokensOf = (bytes) => Number(BigInt(bytes) / BigInt(mintOf(coins)));
 export const qpuManOf = (name, description, reading, href, see) => {
     const synopsis = `POST ${unit.origin}/mcp tools/call ${name}`;
@@ -3772,23 +4099,51 @@ export const qpuManOf = (name, description, reading, href, see) => {
     return { kind: 'man', inline: true, name, section: n, synopsis, href, description, reading, documentation, holds };
 };
 export const qpuManHolds = (m) => m.holds === true && m.kind === 'man' && m.inline === true && m.section === n && m.documentation.includes(m.name);
-const qpuShownHrefOf = (name, href = `${unit.origin}/mcp`) => {
-    if (name === 'qpu_quantum')
-        return unit.origin;
-    if (name === 'qpu_lean')
-        return unit.href;
-    if (name === 'qpu_cite')
-        return `${unit.origin}/cite`;
-    return href;
+/** OUTPUT SCHEMAS READ FROM THE RUN. A schema of `{ type: object }` constrains nothing and so can fail nothing; every
+ * tool's schema is instead derived from its own replies: the properties every sample carried with their JSON types,
+ * `required` being the keys present in every sample, and `holds` a required boolean throughout. One level of nesting
+ * is typed; deeper values are objects or arrays. Derived once per isolate; a reader validates any later reply against
+ * it, which is a check the empty schema could never make. */
+const jsonTypeOf = (v) => v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v === 'number' ? (v % seed === n - n ? 'integer' : 'number') : typeof v === 'object' ? 'object' : typeof v;
+const typeUnionOf = (types) => {
+    const distinct = [...new Set(types)];
+    return distinct.length === seed ? distinct[n - n] : distinct;
+};
+export const qpuOutputSchemaOf = (samples) => {
+    const objects = samples.filter((x) => typeof x === 'object' && x !== null && !Array.isArray(x));
+    const properties = {};
+    const keys = new Set();
+    for (const o of objects)
+        for (const k of Object.keys(o))
+            keys.add(k);
+    for (const k of keys) {
+        const values = objects.filter((o) => k in o).map((o) => o[k]);
+        const type = typeUnionOf(values.map(jsonTypeOf));
+        if (type === 'object') {
+            const inner = {};
+            const innerKeys = new Set();
+            for (const v of values)
+                for (const ik of Object.keys(v))
+                    innerKeys.add(ik);
+            for (const ik of innerKeys)
+                inner[ik] = { type: typeUnionOf(values.filter((v) => ik in v).map((v) => jsonTypeOf(v[ik]))) };
+            properties[k] = { type, properties: inner };
+        }
+        else
+            properties[k] = { type };
+    }
+    properties.holds = { type: 'boolean' };
+    const required = [...keys].filter((k) => objects.every((o) => k in o));
+    if (!required.includes('holds'))
+        required.push('holds');
+    return { type: 'object', description: `derived from ${objects.length} repl${objects.length === seed ? 'y' : 'ies'} of the tool itself; holds is always required`, properties, required, additionalProperties: true };
 };
+const minimalOutputSchema = { type: 'object', properties: { holds: { type: 'boolean' } }, required: ['holds'], additionalProperties: true };
 const qpuMcpToolShapeOf = (name, description, inputSchema, extra = {}) => ({
     name,
     title: name,
     description,
     inputSchema,
-    input_schema: inputSchema,
-    parameters: inputSchema,
-    outputSchema: { type: 'object' },
     annotations: {
         audience: ['user', 'assistant'],
         priority: seed,
@@ -3796,68 +4151,75 @@ const qpuMcpToolShapeOf = (name, description, inputSchema, extra = {}) => ({
         destructiveHint: false,
         openWorldHint: true
     },
-    function: { name, description, parameters: inputSchema },
     ...extra
 });
-export const qpuMcpShownOf = (name, payload, href = `${unit.origin}/mcp`) => {
+/** Where a GET returns the very document a tool replies with — only there is a link to it honest. Two tools have
+ * such a page; the rest reply with what no GET serves, and carry no link rather than one to a different document. */
+const qpuShownResourceOf = (name) => {
+    if (name === 'qpu_lean')
+        return unit.href;
+    if (name === 'qpu_cite')
+        return `${unit.origin}/cite`;
+    return undefined;
+};
+/** THE REPLY ON THE WIRE, ONCE AS TEXT AND ONCE AS STRUCTURE. The protocol asks for `content` and `structuredContent`,
+ * and those are the two copies a client pays for. An embedded resource copy, a string copy under `_meta.output` and an
+ * object copy under `_meta.functionResponse` made a 131 KB proof a 729 KB reply (external audit, 2026-09-12); they are
+ * gone. A `resource_link` rides along only when a GET of its uri returns this same document (qpu_lean, qpu_cite).
+ * `_meta.call` says where to call again; vendor shapes are documented in the JSON-LD catalogue at GET /mcp. */
+export const qpuMcpShownOf = (name, shownPayload, href = `${unit.origin}/mcp`) => {
+    // A man page on the wire carries the tool's output schema (off tools/list since 2026-09-12), whichever door built it.
+    const isMan = !!shownPayload && typeof shownPayload === 'object' && shownPayload.kind === 'man' && !('outputSchema' in shownPayload);
+    const payload = isMan ? qpuManPageOf(name, shownPayload) : shownPayload;
     const bag = payload && typeof payload === 'object' ? payload : {};
     const holds = bag.holds === true;
-    const shownHref = qpuShownHrefOf(name, href);
+    const resource = qpuShownResourceOf(name);
     const unlimited = JSON.stringify(payload);
     const content = [
         {
             type: 'text',
             text: unlimited,
             annotations: { audience: ['user', 'assistant'], priority: seed }
-        },
-        {
-            type: 'resource',
-            resource: {
-                uri: shownHref,
-                mimeType: 'application/ld+json',
-                text: unlimited
-            },
-            annotations: { audience: ['user'], priority: seed }
-        },
-        {
+        }
+    ];
+    if (resource !== undefined) {
+        content.push({
             type: 'resource_link',
-            uri: shownHref,
+            uri: resource,
             name,
             mimeType: 'application/ld+json',
-            description: name,
+            description: `GET ${resource} returns this document`,
             annotations: { audience: ['user'], priority: seed }
-        }
-    ];
+        });
+    }
     return {
-        resultType: 'complete',
         content,
         structuredContent: payload,
         isError: holds === false,
-        output: unlimited,
-        role: 'tool',
-        functionResponse: { name, response: payload },
         _meta: {
+            resultType: 'complete',
+            role: 'tool',
             compatibility: 'max',
             mimeType: 'application/ld+json',
-            href: shownHref
+            call: href,
+            ...(resource !== undefined ? { resource } : {})
         }
     };
 };
 export const qpuMcpShownHolds = (shown) => {
     const unlimited = JSON.stringify(shown.structuredContent);
-    return (shown.resultType === 'complete' &&
-        shown.content.length === n &&
+    const link = shown.content.find((c) => c.type === 'resource_link');
+    return (shown._meta.resultType === 'complete' &&
+        shown.content.length >= seed &&
+        shown.content.length <= coins &&
         shown.content[n - n]?.type === 'text' &&
         shown.content[n - n]?.text === unlimited &&
-        shown.content[seed]?.type === 'resource' &&
-        shown.content[seed]?.resource?.mimeType === 'application/ld+json' &&
-        shown.content[seed]?.resource?.text === unlimited &&
-        shown.content[coins]?.type === 'resource_link' &&
-        shown.content[coins]?.mimeType === 'application/ld+json' &&
-        shown.output === unlimited &&
-        shown.role === 'tool' &&
-        shown.functionResponse.response === shown.structuredContent &&
+        (link === undefined || (link.mimeType === 'application/ld+json' && link.uri === shown._meta.resource)) &&
+        shown._meta.role === 'tool' &&
         shown._meta.compatibility === 'max' &&
+        shown._meta.call.startsWith(unit.origin) &&
+        !('output' in shown._meta) &&
+        !('functionResponse' in shown._meta) &&
         shown.isError === (shown.structuredContent?.holds !== true));
 };
 export const qpuSubManOf = (name, description, reading, href, see) => {
@@ -3882,7 +4244,7 @@ export const qpuSubManOf = (name, description, reading, href, see) => {
 };
 const qpuSubRpcOf = async (body, tools, href) => {
     if (body.method === 'initialize' || body.method === 'server/discover') {
-        return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpDiscoverOf() };
+        return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpDiscoverOf(body.params?.protocolVersion) };
     }
     if (body.method === 'ping' || body.method === 'notifications/initialized') {
         return { jsonrpc: '2.0', id: body.id ?? null, result: {} };
@@ -3893,7 +4255,7 @@ const qpuSubRpcOf = async (body, tools, href) => {
             id: body.id ?? null,
             result: {
                 resultType: 'complete',
-                tools: tools.map(({ name, description, inputSchema, man }) => qpuMcpToolShapeOf(name, description, inputSchema, { man }))
+                tools: tools.map(({ name, description, inputSchema }) => qpuMcpToolShapeOf(name, description, inputSchema))
             }
         };
     }
@@ -3902,11 +4264,14 @@ const qpuSubRpcOf = async (body, tools, href) => {
         const args = body.params?.arguments ?? {};
         const tool = tools.find((t) => t.name === name);
         if (!tool)
-            return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpShownOf(name, qpuHandledOf('tool'), href) };
+            return rpcErrorOf(body.id, rpcCodes.params, `Unknown tool: ${name}`, { tools: tools.map((t) => t.name), href });
         if (args.man === true)
-            return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpShownOf(name, tool.man, href) };
+            return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpShownOf(name, qpuManPageOf(name, tool.man), href) };
         return { jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpShownOf(name, await tool.run(args), href) };
     }
+    /** A body that names a method this server does not have is a declined call, not a job or a message. */
+    if (typeof body.method === 'string')
+        return rpcErrorOf(body.id, rpcCodes.method, `Method not found: ${body.method}`, { methods: [...rpcMethods], href });
     return undefined;
 };
 const qpuSubCatalogOf = (kind, href, tools, extra) => {
@@ -3959,6 +4324,7 @@ export const qpuReadingOf = () => {
         only: quantum.only,
         lattice: quantum.lattice,
         circuit: quantum.circuit,
+        shor: quantum.shor,
         sequence: {
             kind: quantum.sequence.kind,
             cover: quantum.sequence.cover,
@@ -4008,11 +4374,8 @@ export const qpuReadingOf = () => {
             kind: quantum.speed.kind,
             next: quantum.speed.next,
             factor: quantum.speed.factor,
-            si: quantum.speed.si,
             cover: quantum.speed.cover,
-            ns: quantum.speed.ns,
-            hz: quantum.speed.hz,
-            holds: quantum.speed.next === quantum.fused + quantum.fused && quantum.speed.si.ns === nsPerSecond && quantum.speed.ns === n - n,
+            holds: quantum.speed.next === quantum.fused + quantum.fused && quantum.speed.holds,
         },
         cors: quantum.cors,
         ui: quantum.ui,
@@ -4086,16 +4449,18 @@ export const qpuEfficiencyHolds = (e = qpuEfficiencyOf()) => e.holds === true &&
     e.rows.length === n;
 const throughputOf = (throughoutput, tokens) => tokens > seed ? Number(BigInt(throughoutput) / BigInt(tokens)) : throughoutput;
 const toolNames = ['qpu_quantum', 'qpu_lean', 'qpu_cite', 'qpu_train', 'qpu_forge', 'qpu_improve', 'qpu_compete', 'qpu_prove'];
+const cryptoToolNames = ['crypto_catalog', 'crypto_shor', 'crypto_cmodexp', 'crypto_iqft', 'crypto_shots', 'crypto_rsa', 'crypto_split', 'crypto_verify'];
 export const qpuSequenceOf = () => {
     const cube = qpuCubeOf();
     const faces = qpuFacesOf();
     const docs = qpuDocsOf();
     const speed = qpuSpeedOf();
-    const cover = ['mint', 'cube', 'handle', 'faces', 'quantum', 'next', 'hz', 'ns'];
+    const cover = ['mint', 'cube', 'handle', 'faces', 'quantum', 'next', 'amplitudes', 'kv'];
     const climb = [toolNames[n], toolNames[n + coins], toolNames[n + n], toolNames[mintOf(n) - seed]];
     const storage = ['storage_catalog', 'storage_list', 'storage_get', 'storage_put', 'storage_del', 'storage_monitor', 'storage_maintain', 'storage_raid'];
     const network = ['net_catalog', 'net_list', 'net_send', 'net_recv', 'net_message', 'net_routes', 'net_fetch', 'net_monitor'];
     const server = ['server_catalog', 'server_backend', 'server_submit', 'server_queue', 'server_result', 'server_shots', 'server_correct', 'server_monitor'];
+    const cybersecurity = cryptoToolNames;
     const api = [
         { method: 'GET', path: '/', door: toolNames[n - n], pattern: 'jsonld-get', type: 'SoftwareApplication', verb: 'read' },
         { method: 'GET', path: `/${unit.path}`, door: toolNames[seed], pattern: 'jsonld-get', type: 'Dataset', verb: 'read' },
@@ -4130,6 +4495,7 @@ export const qpuSequenceOf = () => {
         storage: storage[k],
         network: network[k],
         server: server[k],
+        cybersecurity: cybersecurity[k],
         sealed: k < faces.rays
     }));
     const holds = cube.holds &&
@@ -4145,6 +4511,7 @@ export const qpuSequenceOf = () => {
         storage.length === mintOf(n) &&
         network.length === mintOf(n) &&
         server.length === mintOf(n) &&
+        cybersecurity.length === mintOf(n) &&
         climb.length === mintOf(coins) &&
         pairs.length === coins &&
         extras.length === n &&
@@ -4157,7 +4524,7 @@ export const qpuSequenceOf = () => {
         rungs[mintOf(n) - seed].path === '/server' &&
         rungs[mintOf(n) - seed].tool === 'qpu_prove' &&
         rungs[mintOf(n) - seed].pattern === 'jsonrpc-job' &&
-        rungs.every((row, k) => row.mint === mintOf(k) && row.speed === cover[k] && row.sealed === k < faces.rays) &&
+        rungs.every((row, k) => row.mint === mintOf(k) && row.speed === cover[k] && row.sealed === k < faces.rays && row.cybersecurity === cybersecurity[k]) &&
         docs.api.every((row, k) => row.method === api[k].method && row.path === api[k].path) &&
         climb[n - n] === 'qpu_train' &&
         climb[mintOf(coins) - seed] === 'qpu_prove' &&
@@ -4194,20 +4561,112 @@ export const qpuSequenceHolds = (s = qpuSequenceOf()) => s.holds === true &&
     s.pairs.length === coins &&
     s.climb.length === mintOf(coins) &&
     s.rungs[mintOf(n) - seed].path === '/server' &&
-    s.cover.join(' ') === 'mint cube handle faces quantum next hz ns';
+    s.rungs[n - n].cybersecurity === 'crypto_catalog' &&
+    s.rungs[mintOf(n) - seed].cybersecurity === 'crypto_verify' &&
+    s.cover.join(' ') === 'mint cube handle faces quantum next amplitudes kv';
+/** AUTONOMOUS STEPS, COMPUTED FROM THE LATTICE (the captain, 2026-09-12). The genesis flow is the walk: face = team * rays
+ * + ray, so a pass visits ray 0's scanner face, hops by rays to its radar face, returns by the involution, and moves to
+ * the next ray — fourteen faces, each once, in an order the lattice fixes. The seat is the first face whose predicate
+ * does not hold, else face 0. A step names the lattice node, its predicate as read, the door to call (the API rung the
+ * face maps to), and the hop. `todo` is every face that does not hold, repaired before walking; `next` is the first
+ * todo, else the face after the seat. Nothing here is typed and nothing is timed: the same lattice gives the same walk. */
+export const qpuStepsOf = () => {
+    const circuit = qpuCircuitOf();
+    const sequence = qpuSequenceOf();
+    const faces = qpuFacesOf();
+    const walk = [];
+    for (let ray = n - n; ray < faces.rays; ray++)
+        walk.push(ray, ray + faces.rays);
+    const seat = circuit.lattice.nodes.find((node) => !node.holds)?.face ?? n - n;
+    const stepOf = (face) => {
+        const node = circuit.lattice.nodes[face];
+        const rung = sequence.rungs[face % sequence.rungs.length];
+        const hop = (face + faces.rays) % faces.faces;
+        return {
+            face,
+            node: node.name,
+            holds: node.holds,
+            door: { tool: rung.tool, method: rung.method, path: rung.path },
+            hop,
+            involution: (hop + faces.rays) % faces.faces === face,
+            team: face < faces.rays ? 'scanner' : 'radar',
+            ray: face % faces.rays,
+        };
+    };
+    const steps = walk.map(stepOf);
+    const todo = steps.filter((step) => !step.holds);
+    const at = walk.indexOf(seat);
+    const next = todo[n - n] ?? steps[(at + seed) % steps.length];
+    const holds = steps.length === faces.faces &&
+        new Set(walk).size === faces.faces &&
+        steps.every((step) => step.involution && step.door.tool.length > n - n && step.door.path.startsWith('/')) &&
+        (todo.length === n - n) === circuit.lattice.holds &&
+        (todo.length > n - n ? next.holds === false : next.face === walk[(at + seed) % walk.length]);
+    return { kind: 'steps', seat, next, todo, walk: steps, faces: faces.faces, rays: faces.rays, holds };
+};
+export const qpuStepsHolds = (s = qpuStepsOf()) => s.holds === true &&
+    s.kind === 'steps' &&
+    s.walk.length === s.faces &&
+    s.rays + s.rays === s.faces &&
+    s.walk.every((step) => step.hop === (step.face + s.rays) % s.faces);
+/** PLANES FOLD (the captain, 2026-09-12: "4n encoding cannot hold entanglement — if single plane. in quantum planes
+ * fold"). One plane encodes n qubits as 4n numbers, two complex amplitudes per qubit: a product state by construction,
+ * so a single plane cannot hold entanglement. At the lattice's n = rays a plane carries coins·coins·rays numbers where
+ * an entangled register needs mintOf(rays + seed). The unit never holds entanglement in a plane. It folds: the two
+ * planes of the lattice (scanner and radar, the coins) meet in the Bell rows read from the run as product false, and
+ * here a rays-qubit GHZ state is computed — H on the first qubit, CNOT along every ray — and written to the receipt
+ * ledger as a fold, dim mintOf(rays), which one plane's carry cannot reach. Nothing is asserted that was not run. */
+export const qpuPlanesOf = (circuit = qpuCircuitOf()) => {
+    const faces = qpuFacesOf();
+    const qubits = faces.rays;
+    const plane = coins * coins * qubits;
+    const needed = mintOf(qubits + seed);
+    const planes = faces.faces / faces.rays;
+    let state = hGateOf(ampsOf(mintOf(qubits)), n - n);
+    for (let ray = seed; ray < qubits; ray++)
+        state = cnotGateOf(state, n - n, ray);
+    const support = state.map((a, i) => ({ i, a })).filter((row) => row.a !== 0n);
+    receiptOf('planes', state);
+    const ledger = qpuReceiptLedgerOf();
+    const fold = ledger[ledger.length - seed];
+    const bell = { product: circuit.entangle.product, entangled: circuit.entangle.holds && circuit.entangle.product === false };
+    const ghz = {
+        qubits,
+        dim: state.length,
+        support: support.map((row) => row.i),
+        fold: fold.fold,
+        entangled: support.length === coins && support[n - n].i === n - n && support[seed].i === state.length - seed,
+    };
+    const holds = plane < needed &&
+        planes === coins &&
+        bell.entangled &&
+        ghz.entangled &&
+        fold.name === 'planes' &&
+        fold.dim === mintOf(qubits) &&
+        fold.dim + fold.dim === needed &&
+        plane < fold.dim;
+    return { kind: 'planes', qubits, plane, needed, planes, bell, ghz, holds };
+};
+export const qpuPlanesHolds = (p = qpuPlanesOf()) => p.holds === true &&
+    p.kind === 'planes' &&
+    p.plane < p.needed &&
+    p.planes === coins &&
+    p.bell.product === false &&
+    p.bell.entangled === true &&
+    p.ghz.entangled === true &&
+    p.ghz.dim > p.plane;
 export const qpuPurposeOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), sequence = qpuSequenceOf(), capacity = qpuCapacityOf()) => {
     const nature = {
         kind: 'nature',
-        platform: circuit.fridge.kind,
-        qubits: circuit.fridge.qubits,
-        millikelvin: circuit.fridge.millikelvin,
-        resistance: circuit.fridge.resistance,
-        entangle: circuit.entangle.product,
+        platform: circuit.register.kind,
+        qubits: circuit.register.qubits,
+        /** The Bell state is not a product state: `product` false is what `entangled` true means, and both are said. */
+        product: circuit.entangle.product,
+        entangled: circuit.entangle.holds && circuit.entangle.product === false,
         ghz: circuit.ghz.holds,
-        holds: circuit.fridge.holds &&
-            circuit.fridge.kind === 'superconducting' &&
-            circuit.fridge.qubits === n &&
-            circuit.fridge.resistance === n - n &&
+        holds: circuit.register.holds &&
+            circuit.register.kind === 'simulator' &&
+            circuit.register.qubits === n &&
             circuit.entangle.holds &&
             circuit.entangle.product === false &&
             circuit.ghz.holds,
@@ -4218,14 +4677,45 @@ export const qpuPurposeOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), seque
         a: shor.a,
         factors: [shor.factors.p, shor.factors.q],
         product: shor.factors.product,
+        circuitry: shor.circuitry.kind,
+        qft: shor.qft.kind,
+        shots: shor.measure.shots,
+        period: shor.post.period,
+        payload: shor.payload,
         crypt: capacity.crypt.split,
         share: capacity.crypt.share,
+        raid: qpuRaidOf().cluster.security,
+        rsa: {
+            kind: 'rsa',
+            cryptosystem: 'rsa',
+            modulus: shor.n,
+            p: shor.rsa.p,
+            q: shor.rsa.q,
+            factored: shor.rsa.factored,
+            holds: shor.rsa.holds,
+        },
+        encrypt: {
+            kind: 'encrypt',
+            theorem: 'crypto',
+            identity: qpuEncryptOf().identity,
+            holds: qpuEncryptHolds(),
+        },
+        tools: cryptoToolNames,
+        sealed: false,
+        morph: true,
         holds: shor.holds &&
             shor.device === nature.platform &&
             shor.factors.p * shor.factors.q === shor.n &&
             gcdOf(shor.a, shor.n) === seed &&
+            shor.circuitry.kind === 'cmodexp' &&
+            shor.qft.kind === 'iqft' &&
             capacity.crypt.holds &&
-            capacity.crypt.fused === capacity.fused,
+            capacity.crypt.fused === capacity.fused &&
+            qpuRaidOf().cluster.security === 'crypt' &&
+            shor.rsa.kind === 'rsa' &&
+            shor.rsa.factored === true &&
+            qpuEncryptHolds() &&
+            cryptoToolNames.length === mintOf(n),
     };
     const optimization = {
         kind: 'optimization',
@@ -4249,28 +4739,42 @@ export const qpuPurposeOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), seque
         network: sequence.extras[seed]?.path,
         server: sequence.extras[coins]?.path,
         hop: 'involution',
-        primitives: circuit.fridge.telemetry.primitives,
+        primitives,
         holds: sequence.extras[n - n].path === '/storage' &&
             sequence.extras[seed].path === '/network' &&
             sequence.extras[coins].path === '/server' &&
-            circuit.fridge.telemetry.holds &&
-            circuit.fridge.telemetry.primitives.length === n + coins,
+            primitives.length === n + coins,
     };
     const holds = nature.holds && cybersecurity.holds && optimization.holds && science.holds && sensing.holds;
     return { kind: 'purpose', nature, cybersecurity, optimization, science, sensing, holds };
 };
 export const qpuPurposeHolds = (p = qpuPurposeOf()) => p.holds === true &&
     p.kind === 'purpose' &&
-    p.nature.platform === 'superconducting' &&
+    p.nature.platform === 'simulator' &&
     p.nature.qubits === n &&
-    p.cybersecurity.n === n * (n + coins) &&
+    p.cybersecurity.n === qpuFacesOf().rays * (n * n + n + seed) &&
     p.cybersecurity.product === p.cybersecurity.n &&
     p.cybersecurity.factors[n - n] * p.cybersecurity.factors[seed] === p.cybersecurity.n &&
+    p.cybersecurity.circuitry === 'cmodexp' &&
+    p.cybersecurity.qft === 'iqft' &&
+    p.cybersecurity.raid === 'crypt' &&
+    p.cybersecurity.sealed === false &&
+    p.cybersecurity.morph === true &&
+    p.cybersecurity.tools.length === mintOf(n) &&
+    p.cybersecurity.tools[n + coins] === 'crypto_rsa' &&
+    p.cybersecurity.rsa.kind === 'rsa' &&
+    p.cybersecurity.rsa.modulus === p.cybersecurity.n &&
+    p.cybersecurity.rsa.factored === true &&
+    p.cybersecurity.rsa.p * p.cybersecurity.rsa.q === p.cybersecurity.rsa.modulus &&
+    p.cybersecurity.encrypt.kind === 'encrypt' &&
+    p.cybersecurity.encrypt.theorem === 'crypto' &&
+    p.cybersecurity.encrypt.identity === true &&
+    p.cybersecurity.encrypt.holds === true &&
     p.optimization.next === p.optimization.fused + p.optimization.fused &&
     p.science.climb[mintOf(coins) - seed] === 'qpu_prove' &&
     p.sensing.network === '/network' &&
     p.sensing.server === '/server';
-export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), speed = qpuSpeedOf()) => {
+export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf()) => {
     const computer = circuit.computer;
     const weights = shor.measure.weights;
     let total = n - n;
@@ -4299,7 +4803,6 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
         provider: unit.host,
         device: circuit.hardware.device,
         job: `${unit.host}/${shor.circuitry.kind}/${shor.n}/${shor.measure.shots}`,
-        ns: speed.ns,
         circuit: shor.circuitry.gates.map((row) => row.name),
         compiler: {
             native: shor.circuitry.native,
@@ -4308,7 +4811,7 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
             src: unit.fuse.src,
         },
         map: {
-            fridge: circuit.fridge.qubits,
+            register: circuit.register.qubits,
             counting: shor.circuitry.counting,
             work: shor.circuitry.work,
             edges: computer.coupling.edges,
@@ -4319,9 +4822,8 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
         weights,
         holds: unit.host === 'qpu.uuidna.com' &&
             !unit.host.includes('*') &&
-            circuit.hardware.device === circuit.fridge.kind &&
-            shor.device === circuit.fridge.kind &&
-            speed.ns === n - n &&
+            circuit.hardware.device === circuit.register.kind &&
+            shor.device === circuit.register.kind &&
             shor.circuitry.native.join(' ') === 'h cnot' &&
             computer.compile.holds &&
             computer.coupling.holds &&
@@ -4333,11 +4835,9 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
     };
     const noise = {
         kind: 'calibration',
-        millikelvin: circuit.fridge.millikelvin,
-        resistance: circuit.fridge.resistance,
-        stages: circuit.fridge.cryostat.stages,
-        t1: { stage: 'mixing', millikelvin: circuit.fridge.cryostat.mixing },
-        t2: { stage: 'plate', millikelvin: circuit.fridge.cryostat.plate },
+        /** T1 and T2 are relaxation and dephasing times; this simulator has none to measure, and a temperature is not one. */
+        t1: { measured: false },
+        t2: { measured: false },
         gate: {
             channel: circuit.noise.channel,
             identity: shor.measure.identity,
@@ -4351,10 +4851,7 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
         connectivity: computer.coupling.edges,
         drift: circuit.drift.holds,
         model: shor.measure.noise,
-        holds: circuit.fridge.telemetry.holds &&
-            circuit.fridge.resistance === n - n &&
-            circuit.fridge.cryostat.mixing === circuit.fridge.millikelvin &&
-            circuit.noise.channel === 'xx' &&
+        holds: circuit.noise.channel === 'xx' &&
             shor.measure.noise === circuit.noise.channel &&
             shor.measure.identity === true &&
             circuit.noise.index === circuit.measurement.index &&
@@ -4365,7 +4862,7 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
     };
     const volume = {
         kind: 'volume',
-        qubits: circuit.fridge.qubits,
+        qubits: circuit.register.qubits,
         dim: circuit.qubits.dim,
         observed: heavy,
         total,
@@ -4375,7 +4872,7 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
         uncertainty: shor.measure.shots,
         randomized,
         mirror: circuit.interfere.kind,
-        holds: circuit.fridge.qubits === n &&
+        holds: circuit.register.qubits === n &&
             circuit.qubits.dim === mintOf(n) &&
             randomized.includes('deutsch') &&
             randomized.includes('kickback') &&
@@ -4400,18 +4897,18 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
     };
     const scaling = {
         kind: 'scaling',
-        qubits: circuit.fridge.qubits,
+        qubits: circuit.register.qubits,
         dim: circuit.qubits.dim,
         depth: shor.circuitry.gates.length,
-        exact: circuit.qubits.dim === mintOf(circuit.fridge.qubits),
-        beyond: circuit.fridge.qubits > qpuFacesOf().faces,
-        advantage: n * heavy > coins * total && circuit.fridge.qubits > qpuFacesOf().faces,
+        exact: circuit.qubits.dim === mintOf(circuit.register.qubits),
+        beyond: circuit.register.qubits > qpuFacesOf().faces,
+        advantage: n * heavy > coins * total && circuit.register.qubits > qpuFacesOf().faces,
         mirror: circuit.interfere.holds,
         holds: circuit.qubits.dim === mintOf(n) &&
-            circuit.fridge.qubits === n &&
+            circuit.register.qubits === n &&
             shor.circuitry.gates.length > n &&
-            circuit.qubits.dim === mintOf(circuit.fridge.qubits) &&
-            circuit.fridge.qubits > qpuFacesOf().faces === false &&
+            circuit.qubits.dim === mintOf(circuit.register.qubits) &&
+            circuit.register.qubits > qpuFacesOf().faces === false &&
             circuit.interfere.holds,
     };
     const verify = {
@@ -4422,7 +4919,9 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
         cern: 'opendata.cern.ch',
         hardware: provenance.holds && noise.holds,
         algorithm: shor.factors.p * shor.factors.q === shor.n,
+        rsa: shor.rsa.factored,
         crypt: shor.payload.endsWith('/storage/databases/payload'),
+        encrypt: qpuEncryptHolds(),
         holds: cors === '*' &&
             unit.origin.startsWith('https') &&
             !unit.host.includes('*') &&
@@ -4430,6 +4929,8 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
             provenance.holds &&
             noise.holds &&
             shor.factors.p * shor.factors.q === shor.n &&
+            shor.rsa.factored === true &&
+            qpuEncryptHolds() &&
             shor.payload.endsWith('/storage/databases/payload'),
     };
     const codes = seed;
@@ -4459,12 +4960,12 @@ export const qpuEvidenceOf = (circuit = qpuCircuitOf(), shor = qpuShorOf(), spee
 export const qpuEvidenceHolds = (e = qpuEvidenceOf()) => e.holds === true &&
     e.kind === 'evidence' &&
     e.provenance.provider === unit.host &&
-    e.provenance.device === 'superconducting' &&
+    e.provenance.device === 'simulator' &&
     e.provenance.shots === mintOf(n) &&
     e.provenance.outcomes.length === e.provenance.shots &&
     e.provenance.counts.length === coins &&
-    e.noise.t1.millikelvin === ten &&
-    e.noise.t2.millikelvin === ten * ten &&
+    e.noise.t1.measured === false &&
+    e.noise.t2.measured === false &&
     e.noise.gate.channel === 'xx' &&
     e.noise.model === 'xx' &&
     e.volume.dim === mintOf(n) &&
@@ -4477,12 +4978,283 @@ export const qpuEvidenceHolds = (e = qpuEvidenceOf()) => e.holds === true &&
     e.verify.cors === '*' &&
     e.verify.hardware === true &&
     e.verify.algorithm === true &&
+    e.verify.rsa === true &&
     e.verify.crypt === true &&
+    e.verify.encrypt === true &&
     e.fault.code === 'bitflip' &&
     e.fault.distance === n &&
     e.fault.codes === seed &&
     e.fault.suppressed === true &&
     e.fault.logicalLtPhysical === true;
+export const qpuCybersecurityOf = () => {
+    const shor = qpuShorOf();
+    const capacity = qpuCapacityOf();
+    const raid = qpuRaidOf();
+    const purpose = qpuPurposeOf();
+    const evidence = qpuEvidenceOf();
+    const lean = qpuLeanOf();
+    const sequence = qpuSequenceOf();
+    const pairs = [
+        [3, 5],
+        [3, 7],
+        [3, 11],
+        [5, 7],
+        [3, 13],
+        [3, 17],
+        [5, 11],
+        [3, 19],
+        [5, 13],
+        [3, 23],
+        [7, 11],
+        [5, 17],
+        [3, 29],
+        [7, 13],
+    ];
+    const table = pairs.map(([p, q]) => ({ p, q, product: p * q, modulus: p * q, rsa: true, holds: p > seed && q > seed }));
+    const rsa = {
+        kind: 'rsa',
+        cryptosystem: 'rsa',
+        modulus: shor.n,
+        public: { n: shor.n },
+        factored: shor.rsa.factored,
+        factors: shor.factors,
+        table,
+        payload: shor.payload,
+        unlocked: shor.unlocked,
+        lock: shor.lock,
+        holds: shor.rsa.holds && table.length === qpuFacesOf().faces && table.every((row) => row.holds && row.p * row.q === row.modulus) && shor.unlocked === true,
+    };
+    const encrypt = qpuEncryptOf();
+    const crypto = [...lean.rows, ...lean.cover].find((r) => r.heading === 'crypto');
+    const shorRow = [...lean.rows, ...lean.cover].find((r) => r.heading === 'shor');
+    const tools = cryptoToolNames;
+    const holds = qpuShorHolds(shor) &&
+        qpuCapacityHolds(capacity) &&
+        qpuRaidHolds(raid) &&
+        qpuPurposeHolds(purpose) &&
+        qpuEvidenceHolds(evidence) &&
+        qpuSequenceHolds(sequence) &&
+        qpuLeanHolds(lean) &&
+        capacity.crypt.holds &&
+        capacity.crypt.kind === 'crypto' &&
+        raid.cluster.security === 'crypt' &&
+        evidence.verify.crypt === true &&
+        purpose.cybersecurity.holds &&
+        purpose.cybersecurity.sealed === false &&
+        purpose.cybersecurity.morph === true &&
+        purpose.cybersecurity.tools.length === mintOf(n) &&
+        tools.length === mintOf(n) &&
+        rsa.holds &&
+        rsa.kind === 'rsa' &&
+        encrypt.holds &&
+        qpuEncryptHolds(encrypt) &&
+        table.length === qpuFacesOf().faces &&
+        table.every((row) => row.holds && row.rsa === true) &&
+        table[qpuFacesOf().faces - seed].p * table[qpuFacesOf().faces - seed].q === shor.n &&
+        crypto?.holds === true &&
+        shorRow?.holds === true &&
+        sequence.rungs.every((row, k) => row.cybersecurity === tools[k]);
+    return {
+        kind: 'cybersecurity',
+        theorem: 'crypto',
+        shor,
+        rsa,
+        encrypt,
+        crypt: capacity.crypt,
+        raid: { security: raid.cluster.security, holds: raid.cluster.security === 'crypt' },
+        verify: evidence.verify,
+        purpose: purpose.cybersecurity,
+        table,
+        tools,
+        listed: true,
+        morph: true,
+        sealed: false,
+        holds,
+    };
+};
+export const qpuCybersecurityToolsOf = () => {
+    const href = `${unit.origin}/mcp`;
+    const see = cryptoToolNames;
+    const schema = { type: 'object', properties: { man: { type: 'boolean' } } };
+    const defaults = shorDefaultsOf();
+    const shorSchema = {
+        type: 'object',
+        properties: {
+            man: { type: 'boolean' },
+            n: { type: ['integer', 'string'], description: `Modulus to factor. Default ${defaults.modulus}. Work register bits(n) qubits, counting register ${shorCountBits}; no cap — the state is sparse and exact for any n. The counting register of ${shorCountBits} qubits recovers a period only when it divides ${mintOf(shorCountBits)}; every other coprime run recovers nothing and says so in classical.resolvable, and a base sharing a factor with n is factored by gcd, not by period. The reach is of the state, not of period-finding. Past 2^53 send n as a string of digits; \`read\` says how each argument was taken and \`exact\` carries every value as decimal text.` },
+            a: { type: ['integer', 'string'], description: `Base. Default ${defaults.base}. A base sharing a factor with n hands it over as Shor's first step.` }
+        }
+    };
+    const named = `{ n, a } name the modulus and base; the run is theirs, whatever they are. Default ${defaults.modulus} and ${defaults.base}. Counting register ${shorCountBits}: a period is recovered only when it divides ${mintOf(shorCountBits)}, every other coprime run recovers nothing (classical.resolvable), and a shared factor is found by gcd, not by period. The reach is of the state, not of period-finding.`;
+    /** What a caller is shown: the run's numbers while they are exact as numbers, the decimal strings from `exact` once
+     * they would round (past 2^53) or overflow (past 2^1024). Never a null where a number was asked for. */
+    const shownOf = (shor) => {
+        const e = shor.exact;
+        const safe = e.safe;
+        return {
+            n: safe ? shor.n : e.n,
+            a: safe ? shor.a : e.a,
+            factors: safe ? shor.factors : { ...shor.factors, p: e.p, q: e.q, product: e.product },
+            rsa: safe ? shor.rsa : { ...shor.rsa, modulus: e.n, p: e.p, q: e.q, product: e.product },
+        };
+    };
+    const morph = 'In tools/list. Morph. Not a ninth sealed tool. No auth.';
+    const factoring = `${morph} theorem shor. ${shorFactorOf()}. p * q = N.`;
+    const encrypt = `${morph} theorem crypto. ${cryptoClaimOf()}. fused = split * share.`;
+    const both = `${morph} theorem shor. ${shorFactorOf()}. theorem crypto. ${cryptoClaimOf()}.`;
+    return [
+        {
+            name: see[n - n],
+            description: 'theorem shor. theorem crypto.',
+            man: qpuSubManOf(see[n - n], 'theorem shor. theorem crypto.', both, href, see.filter((s) => s !== see[n - n])),
+            inputSchema: schema,
+            run: () => qpuCybersecurityOf()
+        },
+        {
+            name: see[seed],
+            description: `theorem shor. ${shorFactorOf()}.`,
+            man: qpuSubManOf(see[seed], `theorem shor. ${shorFactorOf()}.`, `${factoring} Coprime base. ${named}`, href, see.filter((s) => s !== see[seed])),
+            inputSchema: shorSchema,
+            run: (a) => {
+                const shor = qpuShorTryOf(a);
+                const shown = shownOf(shor);
+                return {
+                    kind: 'shor',
+                    n: shown.n,
+                    a: shown.a,
+                    read: shor.read,
+                    coprime: shor.coprime,
+                    exact: shor.exact,
+                    device: shor.device,
+                    circuitry: { kind: shor.circuitry.kind, qubits: shor.circuitry.qubits, work: shor.circuitry.work, counting: shor.circuitry.counting, dim: shor.circuitry.dim, holds: shor.circuitry.holds },
+                    prepare: shor.prepare,
+                    qft: shor.qft,
+                    measure: shor.measure,
+                    post: shor.post,
+                    classical: shor.classical,
+                    factors: shown.factors,
+                    rsa: shown.rsa,
+                    holds: shor.holds,
+                };
+            }
+        },
+        {
+            name: see[coins],
+            description: `theorem shor. ${shorFactorOf()}.`,
+            man: qpuSubManOf(see[coins], `theorem shor. ${shorFactorOf()}.`, `${factoring} Native h cnot. Compiled x swap csdg cmodexp. ${named}`, href, see.filter((s) => s !== see[coins])),
+            inputSchema: shorSchema,
+            run: (a) => {
+                const shor = qpuShorTryOf(a);
+                const shown = shownOf(shor);
+                return { kind: 'cmodexp', circuitry: shor.circuitry, exact: shor.exact, read: shor.read, rsa: { kind: 'rsa', modulus: shown.n, a: shown.a, factored: shor.rsa.factored }, holds: shor.circuitry.holds && shor.read.holds };
+            }
+        },
+        {
+            name: see[n],
+            description: `theorem shor. ${shorFactorOf()}.`,
+            man: qpuSubManOf(see[n], `theorem shor. ${shorFactorOf()}.`, `${factoring} Inverse QFT. Period continued-fraction. ${named}`, href, see.filter((s) => s !== see[n])),
+            inputSchema: shorSchema,
+            run: (a) => {
+                const shor = qpuShorTryOf(a);
+                const shown = shownOf(shor);
+                return { kind: 'iqft', qft: shor.qft, post: shor.post, classical: shor.classical, exact: shor.exact, read: shor.read, rsa: { kind: 'rsa', modulus: shown.n, period: shor.post.period, factored: shor.rsa.factored }, holds: shor.qft.holds && shor.post.holds && shor.read.holds };
+            }
+        },
+        {
+            name: see[n + seed],
+            description: `theorem shor. ${shorFactorOf()}.`,
+            man: qpuSubManOf(see[n + seed], `theorem shor. ${shorFactorOf()}.`, `${factoring} Simulator. xx identity. ${named}`, href, see.filter((s) => s !== see[n + seed])),
+            inputSchema: shorSchema,
+            run: (a) => {
+                const shor = qpuShorTryOf(a);
+                const shown = shownOf(shor);
+                return { kind: 'shots', device: shor.device, measure: shor.measure, exact: shor.exact, read: shor.read, rsa: { kind: 'rsa', modulus: shown.n, factored: shor.rsa.factored }, holds: shor.measure.holds && shor.read.holds };
+            }
+        },
+        {
+            name: see[n + coins],
+            description: `theorem shor. ${shorFactorOf()}.`,
+            man: qpuSubManOf(see[n + coins], `theorem shor. ${shorFactorOf()}.`, `${factoring} JSON Nat. ${named}`, href, see.filter((s) => s !== see[n + coins])),
+            inputSchema: shorSchema,
+            run: (a) => {
+                const args = shorArgsOf(a);
+                if (args.modulus === undefined && args.base === undefined)
+                    return qpuCybersecurityOf().rsa;
+                const shor = qpuShorTryOf(a);
+                const shown = shownOf(shor);
+                return { ...shown.rsa, a: shown.a, period: shor.post.period, by: shor.factors.by, exact: shor.exact, read: shor.read, classical: shor.classical, holds: shor.rsa.holds && shor.read.holds };
+            }
+        },
+        {
+            name: see[n + n],
+            description: `theorem crypto. ${cryptoClaimOf()}.`,
+            man: qpuSubManOf(see[n + n], `theorem crypto. ${cryptoClaimOf()}.`, encrypt, href, see.filter((s) => s !== see[n + n])),
+            inputSchema: schema,
+            run: () => qpuEncryptOf()
+        },
+        {
+            name: see[mintOf(n) - seed],
+            description: 'theorem shor. theorem crypto.',
+            man: qpuSubManOf(see[mintOf(n) - seed], 'theorem shor. theorem crypto.', both, href, see.filter((s) => s !== see[mintOf(n) - seed])),
+            inputSchema: schema,
+            run: () => {
+                const cyber = qpuCybersecurityOf();
+                return {
+                    kind: 'verify',
+                    factoring: { theorem: 'shor', factored: cyber.rsa.factored, n: cyber.rsa.modulus, p: cyber.rsa.factors.p, q: cyber.rsa.factors.q, holds: cyber.rsa.holds },
+                    encrypt: cyber.encrypt,
+                    verify: cyber.verify,
+                    rsa: cyber.rsa,
+                    payload: cyber.shor.payload,
+                    holds: cyber.verify.crypt === true && cyber.verify.rsa === true && cyber.verify.encrypt === true && cyber.encrypt.holds && cyber.holds,
+                };
+            }
+        }
+    ];
+};
+export const qpuCybersecurityHolds = (c = qpuCybersecurityOf()) => {
+    const doors = qpuCybersecurityToolsOf();
+    return (c.holds === true &&
+        c.kind === 'cybersecurity' &&
+        c.theorem === 'crypto' &&
+        c.sealed === false &&
+        c.morph === true &&
+        c.listed === true &&
+        c.tools.length === mintOf(n) &&
+        c.tools[n - n] === 'crypto_catalog' &&
+        c.tools[n + coins] === 'crypto_rsa' &&
+        c.tools[n + n] === 'crypto_split' &&
+        c.tools[mintOf(n) - seed] === 'crypto_verify' &&
+        c.crypt.holds === true &&
+        c.raid.security === 'crypt' &&
+        c.verify.crypt === true &&
+        c.verify.encrypt === true &&
+        c.shor.n === qpuFacesOf().rays * (n * n + n + seed) &&
+        c.shor.unlocked === true &&
+        c.shor.factors.p * c.shor.factors.q === c.shor.n &&
+        c.rsa.kind === 'rsa' &&
+        c.rsa.cryptosystem === 'rsa' &&
+        c.rsa.modulus === c.shor.n &&
+        c.rsa.factored === true &&
+        c.rsa.factors.p * c.rsa.factors.q === c.rsa.modulus &&
+        qpuEncryptHolds(c.encrypt) &&
+        c.encrypt.theorem === 'crypto' &&
+        c.encrypt.identity === true &&
+        c.encrypt.ciphertext !== c.rsa.modulus &&
+        c.table.length === qpuFacesOf().faces &&
+        c.table[qpuFacesOf().faces - seed].product === c.shor.n &&
+        c.table.every((row) => row.rsa === true && row.p * row.q === row.modulus) &&
+        doors.length === mintOf(n) &&
+        doors.every((t, k) => {
+            const man = t.man.documentation;
+            const factors = k !== n + n;
+            const encrypts = k === n - n || k === n + n || k === mintOf(n) - seed;
+            return (t.man.holds &&
+                cryptoToolNames.includes(t.name) &&
+                (!factors || man.includes('theorem shor')) &&
+                (!encrypts || man.includes('theorem crypto')));
+        }));
+};
 const sandboxCore = ['lit', 'mint', 'add', 'mul', 'eq', 'put', 'get', 'has', 'del', 'keys', 'seq', 'if', 'repeat', 'quantum', 'args'];
 const sandboxHost = ['eval', 'fn', 'fs', 'net', 'fetch', 'process', 'import', 'require', 'disk', 'worker'];
 const sandboxSlots = ['n', 'seed', 'coins', 'vertices', 'hexbit', 'bits', 'rays', 'faces', 'amplitudes', 'fused', 'next', 'ns'];
@@ -4490,7 +5262,7 @@ const sandboxOps = [...sandboxCore, 'unlocked', ...sandboxHost];
 const openSchema = {
     type: 'object',
     properties: {
-        man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' },
+        man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' },
         method: { type: 'string' },
         path: { type: 'string' },
         name: { type: 'string' },
@@ -4527,53 +5299,7 @@ const hexOf = (value, width) => {
     }
     return s;
 };
-const cloudflarePrimary = [
-    'agent-commerce-analytics-template',
-    'agent-visibility-template',
-    'ai-brand-visibility-template',
-    'astro-blog-starter-template',
-    'chanfana-openapi-template',
-    'commerce-llms-txt-template',
-    'containers-template',
-    'd1-starter-sessions-api-template',
-    'd1-template',
-    'durable-chat-template',
-    'hello-world-do-template',
-    'internal-sites-template',
-    'llm-chat-app-template',
-    'microfrontend-template',
-    'multiplayer-globe-template',
-    'mysql-hyperdrive-template',
-    'next-starter-template',
-    'nlweb-template',
-    'nodejs-http-server-template',
-    'openauth-template',
-    'postgres-hyperdrive-template',
-    'r2-explorer-template',
-    'react-postgres-fullstack-template',
-    'react-router-hono-fullstack-template',
-    'react-router-postgres-ssr-template',
-    'react-router-starter-template',
-    'react-starter-template',
-    'remix-starter-template',
-    'saas-admin-template',
-    'text-to-image-template',
-    'to-do-list-kv-template',
-    'vite-react-template',
-    'worker-publisher-template',
-    'workers-builds-notifications-template',
-    'workers-for-platforms-template',
-    'workflows-starter-template'
-];
-const cloudflareE2e = [
-    'llm-chat-app-template',
-    'microfrontend-template',
-    'nlweb-template',
-    'text-to-image-template',
-    'worker-publisher-template',
-    'workers-for-platforms-template'
-];
-export const qpuSeatHandleOf = (face) => {
+const qpuSeatHandleOf = (face) => {
     const cube = qpuCubeOf();
     const isolate = qpuHandleOf();
     const faces = qpuFacesOf();
@@ -4598,26 +5324,6 @@ export const qpuSeatHandleOf = (face) => {
         holds,
     };
 };
-export const qpuCatalogHandleOf = (index) => {
-    const isolate = qpuHandleOf();
-    const faces = qpuFacesOf();
-    const face = index % faces.faces;
-    const hop = hopOf(face, faces.rays, faces.faces);
-    const id = hexOf(faces.faces + index, mintOf(n));
-    const holds = isolate.holds && id.length === mintOf(n) && hop === face && index >= n - n;
-    return {
-        kind: 'handle',
-        id,
-        '@id': `${unit.origin}/storage#${id}`,
-        href: `https://github.com/cloudflare/templates/tree/main/${cloudflarePrimary[index] ?? cloudflareE2e[index - cloudflarePrimary.length] ?? id}`,
-        face,
-        hop,
-        bits: isolate.bits,
-        amplitudes: isolate.amplitudes,
-        kv: isolate.kv.amplitudes,
-        holds,
-    };
-};
 let messageSeq = n - n;
 const messageLanes = [];
 const uuidImprintOf = (lane, fused, faces) => {
@@ -4704,7 +5410,6 @@ export const qpuPresenceOf = () => {
     const schemas = qpuSchemasOf();
     const types = raidTypesOf(faces);
     const fused = faces.faces * isolate.kv.amplitudes;
-    const timed = timeNsOf(() => faces.faces * isolate.kv.amplitudes);
     if (messageLanes.length !== faces.faces) {
         messageLanes.length = n - n;
         for (let i = n - n; i < faces.faces; i++)
@@ -4799,8 +5504,7 @@ export const qpuPresenceOf = () => {
         starter.holds &&
         globe.holds &&
         chat.holds &&
-        users.every((user) => user.holds && user.handle.id.length === mintOf(n)) &&
-        timed.value === fused;
+        users.every((user) => user.holds && user.handle.id.length === mintOf(n));
     return {
         kind: 'presence',
         templates,
@@ -4814,8 +5518,6 @@ export const qpuPresenceOf = () => {
         faces: faces.faces,
         fused,
         next: fused + fused,
-        ns: timed.ns,
-        hz: hzOf(timed.ns),
         merge: 'storage',
         holds,
     };
@@ -4823,8 +5525,6 @@ export const qpuPresenceOf = () => {
 export const qpuPresenceHolds = (p = qpuPresenceOf()) => p.holds === true &&
     p.kind === 'presence' &&
     p.merge === 'storage' &&
-    p.ns === n - n &&
-    p.hz === hzOf(p.ns) &&
     p.users.length === qpuFacesOf().faces &&
     p.active + p.inactive === p.faces &&
     p.templates.length === n &&
@@ -5238,6 +5938,14 @@ export const qpuStorageMaintainOf = async (env) => {
         holds,
     };
 };
+/** WRITE AUTH, FAIL CLOSED. Reads stay open. A write is honoured only when QPU_WRITE_TOKEN is bound and the request
+ * carries `Authorization: Bearer <token>`; an unbound token refuses every write. Measured 2026-09-11 by a peer session:
+ * the preflight advertised PUT and DELETE to every origin and the handler honoured them with no check at all. */
+export const qpuStorageWriteAllowedOf = (env, auth) => {
+    const token = typeof env?.QPU_WRITE_TOKEN === 'string' ? env.QPU_WRITE_TOKEN : '';
+    return token.length > n - n && auth === `Bearer ${token}`;
+};
+const storageWriteOf = (method) => method === 'PUT' || method === 'POST' || method === 'DELETE';
 export const qpuStorageOf = async (env, input = {}) => {
     const meta = qpuStorageMetaOf(env);
     const store = storageStoreOf(env);
@@ -5269,6 +5977,9 @@ export const qpuStorageOf = async (env, input = {}) => {
     if (key.length === n - n)
         return { ...meta, holds: false, denied: 'key' };
     const href = `${storageHref}/${key}`;
+    if (storageWriteOf(method) && !qpuStorageWriteAllowedOf(env, input.auth)) {
+        return { ...meta, '@id': href, url: href, key, holds: false, denied: 'auth', auth: 'Bearer QPU_WRITE_TOKEN' };
+    }
     if (method === 'DELETE') {
         const prior = await store.get(key);
         if (isReferrerDoc(prior)) {
@@ -5413,7 +6124,7 @@ export const qpuStorageHolds = (s = qpuStorageMetaOf()) => s.holds === true &&
     s.bindings.BLOBS === 'r2' &&
     s.href === storageHref &&
     jsonldHoldsOf(s);
-export const qpuStorageToolsOf = (env) => {
+export const qpuStorageToolsOf = (env, auth) => {
     const href = storageHref;
     const see = ['storage_catalog', 'storage_list', 'storage_get', 'storage_put', 'storage_del', 'storage_monitor', 'storage_maintain', 'storage_raid'];
     const schema = { type: 'object', properties: { man: { type: 'boolean' }, key: { type: 'string' }, value: {} } };
@@ -5421,7 +6132,7 @@ export const qpuStorageToolsOf = (env) => {
         {
             name: see[n - n],
             description: 'Storage catalog. JSON-LD WebAPI. Quantum RAID. All details.',
-            man: qpuSubManOf(see[n - n], 'Storage catalog.', 'Native Alpine Linux. musl. busybox. overlayfs. Inodes. RAID. No auth.', href, see.filter((s) => s !== see[n - n])),
+            man: qpuSubManOf(see[n - n], 'Storage catalog.', 'Native Alpine Linux. musl. busybox. overlayfs. Inodes. RAID. Reads no auth. Writes Authorization: Bearer QPU_WRITE_TOKEN; unbound refuses.', href, see.filter((s) => s !== see[n - n])),
             inputSchema: schema,
             run: () => qpuStorageMcpOf(env)
         },
@@ -5442,16 +6153,16 @@ export const qpuStorageToolsOf = (env) => {
         {
             name: see[n],
             description: 'Put a stored value.',
-            man: qpuSubManOf(see[n], 'Put value.', 'Store by content address. Return referrer access link. Inode nlink. Stripe rays. Mirror coins.', href, see.filter((s) => s !== see[n])),
+            man: qpuSubManOf(see[n], 'Put value. Bearer QPU_WRITE_TOKEN.', 'Store by content address. Return referrer access link. Inode nlink. Stripe rays. Mirror coins.', href, see.filter((s) => s !== see[n])),
             inputSchema: schema,
-            run: (a) => qpuStorageOf(env, { method: 'PUT', key: a.key, value: a.value })
+            run: (a) => qpuStorageOf(env, { method: 'PUT', key: a.key, value: a.value, auth })
         },
         {
             name: see[n + seed],
             description: 'Delete a stored value.',
-            man: qpuSubManOf(see[n + seed], 'Delete link.', 'Unlink. Last link deleted frees the inode.', href, see.filter((s) => s !== see[n + seed])),
+            man: qpuSubManOf(see[n + seed], 'Delete link. Bearer QPU_WRITE_TOKEN.', 'Unlink. Last link deleted frees the inode.', href, see.filter((s) => s !== see[n + seed])),
             inputSchema: schema,
-            run: (a) => qpuStorageOf(env, { method: 'DELETE', key: a.key })
+            run: (a) => qpuStorageOf(env, { method: 'DELETE', key: a.key, auth })
         },
         {
             name: see[n + coins],
@@ -5627,31 +6338,37 @@ const parseGatesOf = (value) => {
         { name: 'h', q: n - n },
         { name: 'cnot', c: n - n, t: seed }
     ];
-    if (!Array.isArray(value) || value.length === n - n)
-        return fallback;
+    if (value === undefined)
+        return { ops: fallback, read: 'absent', dropped: n - n };
+    if (!Array.isArray(value))
+        return { ops: fallback, read: 'default', dropped: seed };
     const ops = [];
     const names = ['h', 'x', 'z', 'cnot', 'cz', 'swap', 'toffoli', 'reset'];
+    let dropped = n - n;
     for (const row of value) {
-        if (!row || typeof row !== 'object' || Array.isArray(row))
-            continue;
-        const name = typeof row.name === 'string' ? row.name : '';
+        const name = row && typeof row === 'object' && !Array.isArray(row) && typeof row.name === 'string' ? row.name : '';
         if (names.includes(name))
             ops.push(jsonOf(row));
+        else
+            dropped += seed;
     }
-    return ops.length > n - n ? ops : fallback;
+    return ops.length > n - n ? { ops, read: 'read', dropped } : { ops: fallback, read: 'default', dropped };
 };
 export const qpuServerSubmitOf = (input = {}) => {
     const computer = qpuComputerOf();
     const plugin = qpuPayloadPluginOf();
     const payload = qpuPayloadMcpOf();
-    const ops = parseGatesOf(input.gates);
+    const parsed = parseGatesOf(input.gates);
+    const ops = parsed.ops;
     const measured = measureOf(runGatesOf(ops));
     serverSeq += seed;
-    const holds = measured.holds && computer.holds && qpuPayloadPluginHolds(plugin) && payload.holds;
+    const holds = measured.holds && computer.holds && qpuPayloadPluginHolds(plugin) && payload.holds && parsed.read !== 'default';
     const job = {
         id: serverSeq,
         status: 'done',
         gates: ops.map((op) => `${op.name ?? ''}`),
+        read: parsed.read,
+        dropped: parsed.dropped,
         index: measured.index,
         shots: measured.shots,
         counts: measured.counts,
@@ -5660,9 +6377,13 @@ export const qpuServerSubmitOf = (input = {}) => {
         holds,
     };
     serverJobs.push(job);
+    /** The run is synchronous and its result is here, in this reply. Nothing is stored: `id` counts jobs in this isolate
+     * only, and a later GET of the job is answered only while this isolate lives. `href` is the server, not the job. */
     return {
         kind: 'job',
-        href: `${serverHref}/${job.id}`,
+        href: serverHref,
+        stored: false,
+        result: 'inline',
         backend: unit.host,
         vm: 'browser',
         payload: plugin.href,
@@ -5685,7 +6406,7 @@ export const qpuServerToolsOf = () => {
         {
             name: see[seed],
             description: 'Quantum backend.',
-            man: qpuSubManOf(see[seed], 'Backend.', '3-qubit fridge. H CNOT native. H Toffoli universal. Coupling compile.', href, see.filter((s) => s !== see[seed])),
+            man: qpuSubManOf(see[seed], 'Backend.', '3-qubit register. H CNOT native. H Toffoli universal. Coupling compile.', href, see.filter((s) => s !== see[seed])),
             inputSchema: schema,
             run: () => {
                 const computer = qpuComputerOf();
@@ -5698,9 +6419,9 @@ export const qpuServerToolsOf = () => {
                     basis: computer.basis,
                     universal: computer.universal,
                     coupling: computer.coupling,
-                    fridge: circuit.fridge,
+                    register: circuit.register,
                     vm: 'browser',
-                    holds: computer.holds && circuit.fridge.holds,
+                    holds: computer.holds && circuit.register.holds,
                 };
             }
         },
@@ -5785,7 +6506,7 @@ export const qpuServerMcpOf = () => {
             basis: computer.basis,
             universal: computer.universal,
             coupling: computer.coupling,
-            fridge: circuit.fridge,
+            register: circuit.register,
             vm: 'browser'
         },
         computer,
@@ -5894,6 +6615,7 @@ const quantumSlotOf = (name) => {
 };
 const quantumRelatedExtras = [
     'only',
+    'planes',
     'lattice',
     'circuit',
     'noise',
@@ -5902,14 +6624,9 @@ const quantumRelatedExtras = [
     'sciences',
     'drift',
     'computer',
-    'cryostat',
-    'telemetry',
-    'millikelvin',
     'coil',
     'electronics',
-    'resistance',
     'speed',
-    'hz',
     'hybrid',
     'css',
     'presence',
@@ -5928,8 +6645,7 @@ const quantumRelatedOf = () => {
         kind: circuit.kind,
         only: circuit.only,
         lattice: circuit.lattice,
-        fridge: circuit.fridge,
-        resistance: circuit.fridge.resistance,
+        register: circuit.register,
         holds: circuit.holds,
     };
     doors.noise = circuit.noise;
@@ -5938,16 +6654,12 @@ const quantumRelatedOf = () => {
     doors.sciences = circuit.sciences;
     doors.drift = circuit.drift;
     doors.computer = circuit.computer;
-    doors.cryostat = circuit.fridge.cryostat;
-    doors.telemetry = circuit.fridge.telemetry;
-    doors.millikelvin = circuit.fridge;
-    doors.coil = circuit.fridge.coil;
-    doors.electronics = circuit.fridge.electronics;
-    doors.resistance = circuit.fridge.resistance;
+    doors.coil = circuit.register.coil;
+    doors.electronics = circuit.register.electronics;
     doors.speed = speed;
-    doors.hz = speed.hz;
     doors.hybrid = qpuHybridOf();
     doors.css = qpuCssOf();
+    doors.planes = qpuPlanesOf();
     doors.presence = qpuPresenceOf();
     doors.kv = qpuHandleOf().kv;
     return doors;
@@ -5961,25 +6673,22 @@ const quantumDoorOf = (name) => {
     if (name.length === n - n) {
         const only = related.only;
         const lattice = related.lattice;
-        const fridge = related.fridge;
+        const register = related.register;
         const speed = related.speed;
         const names = Object.keys(related);
         return {
             kind: 'quantum',
             only,
             lattice,
-            fridge,
-            speed: { ns: speed.ns, hz: speed.hz, holds: speed.holds },
-            ns: speed.ns,
+            register,
+            speed: { holds: speed.holds },
             related: names,
-            unlocked: only.holds && fridge.holds,
+            unlocked: only.holds && register.holds,
             holds: only.holds &&
                 lattice.holds &&
                 lattice.vacant === n - n &&
-                fridge.holds &&
-                fridge.resistance === n - n &&
+                register.holds &&
                 speed.holds &&
-                speed.ns === n - n &&
                 names.length === lattice.nodes.length + quantumRelatedExtras.length &&
                 lattice.nodes.every((node) => names.includes(node.name) && related[node.name] !== undefined) &&
                 quantumRelatedExtras.every((extra) => names.includes(extra) && related[extra] !== undefined)
@@ -6298,9 +7007,7 @@ export const qpuSandboxOf = () => {
         quantum.value.only?.holds === true &&
         quantum.value.lattice?.holds === true &&
         quantum.value.lattice.vacant === n - n &&
-        quantum.value.fridge?.resistance === n - n &&
-        quantum.value.fridge?.holds === true &&
-        quantum.value.ns === n - n &&
+        quantum.value.register?.holds === true &&
         quantum.value.related?.length === related.length &&
         quantum.value.holds === true &&
         tools.every((t) => qpuManHolds(t.man)) &&
@@ -6335,7 +7042,7 @@ export const qpuSandboxRunOf = (name, args = {}) => {
         return { holds: false, denied: 'tool',
             unlocked: true };
     if (args.man === true)
-        return tool.man;
+        return qpuManPageOf(name, tool.man);
     const value = runOpOf(tool.run, sandboxHeap, jsonOf(args), n - n);
     return {
         kind: 'sandbox',
@@ -6352,7 +7059,7 @@ export const qpuSandboxRunOf = (name, args = {}) => {
 export const qpuForgeOf = (args = {}) => {
     seedSandboxOf();
     if (args.man === true) {
-        return qpuManOf(toolNames[n + seed], 'Agents forge tools in an unlocked in-memory sandbox. Whatever they need.', `Unlocked. All ops and host shims already exist in memory. ${sandboxOps.join(' ')}. Omit name to inspect. { name, run } forges more. No lock.`, `${unit.origin}/mcp`, toolNames.filter((s) => s !== toolNames[n + seed]));
+        return qpuManPageOf(toolNames[n + seed], qpuManOf(toolNames[n + seed], 'Agents forge tools in an unlocked in-memory sandbox. Whatever they need.', `Unlocked. All ops and host shims already exist in memory. ${sandboxOps.join(' ')}. Omit name to inspect. { name, run } forges more. No lock.`, `${unit.origin}/mcp`, toolNames.filter((s) => s !== toolNames[n + seed])));
     }
     const name = typeof args.name === 'string' ? args.name : '';
     if (name.length === n - n)
@@ -6571,8 +7278,6 @@ export const qpuImproveOf = () => {
                     run.value.only?.holds === true &&
                     run.value.lattice?.holds === true &&
                     run.value.lattice.vacant === n - n &&
-                    run.value.fridge?.resistance === n - n &&
-                    run.value.ns === n - n &&
                     (run.value.related?.length ?? n - n) === quantumRelatedNamesOf().length &&
                     run.value.hostEscape === false
             };
@@ -6600,8 +7305,6 @@ export const qpuImproveOf = () => {
             unlocked.value.only?.holds === true &&
             unlocked.value.lattice?.holds === true &&
             unlocked.value.lattice.vacant === n - n &&
-            unlocked.value.fridge?.resistance === n - n &&
-            unlocked.value.ns === n - n &&
             next === fused + fused
     };
     const before = {
@@ -6819,6 +7522,7 @@ export const qpuTrainOf = () => {
         module: 'agent efficiency',
         before: 'next',
         dry,
+        steps: qpuStepsOf(),
         divide: { teams: coins, agents: faces.rays, challenges: faces.faces },
         sandbox: {
             kind: sandbox.kind,
@@ -6853,6 +7557,7 @@ export const qpuTrainOf = () => {
 };
 export const qpuTrainHolds = (t = qpuTrainOf()) => t.holds === true &&
     t.kind === 'train' &&
+    qpuStepsHolds(t.steps) &&
     t.before === 'next' &&
     t.divide.teams === coins &&
     t.divide.agents === t.challenges.length / coins &&
@@ -6890,8 +7595,6 @@ export const qpuCompeteOf = (team) => {
             unlocked.value.only?.holds === true &&
             unlocked.value.lattice?.holds === true &&
             unlocked.value.lattice.vacant === n - n &&
-            unlocked.value.fridge?.resistance === n - n &&
-            unlocked.value.ns === n - n &&
             next === fused + fused
     };
     const agentsOf = (path, throughoutput) => efficiency.rows.map((r) => {
@@ -6953,14 +7656,17 @@ export const qpuProveOf = () => {
     const cern = qpuCernOf();
     const integrity = qpuIntegrityOf();
     const circuit = qpuCircuitOf();
+    const ledgerFrom = qpuReceiptLedgerOf().length;
     const shor = qpuShorOf();
+    const receipts = qpuShorReceiptsOf(ledgerFrom);
+    const encrypt = qpuEncryptOf();
     const intelligence = qpuIntelligenceOf();
     const neuro = qpuNeuroOf();
     const coil = qpuCoilOf();
     const next = qpuNextOf();
     const sequence = qpuSequenceOf();
     const purpose = qpuPurposeOf(circuit, shor, sequence, qpuCapacityOf());
-    const evidence = qpuEvidenceOf(circuit, shor, qpuSpeedOf());
+    const evidence = qpuEvidenceOf(circuit, shor);
     const theorems = [...lean.rows, ...lean.cover, lean.climb];
     const ui = {
         href: unit.origin,
@@ -6992,6 +7698,7 @@ export const qpuProveOf = () => {
         circuit.holds &&
         circuit.hardware.holds &&
         qpuShorHolds(shor) &&
+        qpuEncryptHolds(encrypt) &&
         purpose.holds &&
         evidence.holds &&
         shor.factors.p * shor.factors.q === shor.n &&
@@ -7042,8 +7749,12 @@ export const qpuProveOf = () => {
             period: shor.post.period,
             factors: [shor.factors.p, shor.factors.q],
             product: shor.factors.product,
+            rsa: shor.rsa,
+            unlocked: shor.unlocked,
+            lock: shor.lock,
             holds: shor.holds,
         },
+        encrypt,
         coil: {
             theorem: coil.theorem,
             windings: coil.windings,
@@ -7062,6 +7773,9 @@ export const qpuProveOf = () => {
             holds: next.holds,
         },
         src: lean.src,
+        source: lean.source,
+        receipts,
+        glossary: qpuGlossaryOf(),
         lean,
         theorems,
         cern,
@@ -7081,7 +7795,7 @@ export const qpuProveHolds = (p = qpuProveOf()) => p.holds === true &&
     p.lattice.occupied === p.lattice.faces &&
     p.lattice.vacant === n - n &&
     p.circuit.hardware.holds === true &&
-    p.circuit.hardware.device === 'superconducting' &&
+    p.circuit.hardware.device === 'simulator' &&
     p.circuit.hardware.initialize === true &&
     p.circuit.hardware.gates === true &&
     p.circuit.hardware.interfere === true &&
@@ -7091,8 +7805,9 @@ export const qpuProveHolds = (p = qpuProveOf()) => p.holds === true &&
     p.circuit.hardware.path.submit === `${unit.origin}/server` &&
     p.circuit.holds === true &&
     p.shor.holds === true &&
-    p.shor.n === n * (n + coins) &&
-    p.shor.a === mintOf(n) - seed &&
+    p.shor.n === qpuFacesOf().rays * (n * n + n + seed) &&
+    p.shor.a === mintOf(n) &&
+    p.shor.unlocked === true &&
     p.shor.coprime === true &&
     p.shor.circuitry === 'cmodexp' &&
     p.shor.qft === 'iqft' &&
@@ -7100,6 +7815,12 @@ export const qpuProveHolds = (p = qpuProveOf()) => p.holds === true &&
     p.shor.noise === 'xx' &&
     p.shor.factors[n - n] * p.shor.factors[seed] === p.shor.n &&
     p.shor.product === p.shor.n &&
+    p.shor.rsa.kind === 'rsa' &&
+    p.shor.rsa.modulus === p.shor.n &&
+    p.shor.rsa.factored === true &&
+    qpuEncryptHolds(p.encrypt) &&
+    p.encrypt.theorem === 'crypto' &&
+    p.encrypt.identity === true &&
     qpuPurposeHolds(p.purpose) &&
     p.purpose.cybersecurity.product === p.shor.n &&
     p.purpose.nature.platform === p.circuit.hardware.device &&
@@ -7125,6 +7846,11 @@ export const qpuProveHolds = (p = qpuProveOf()) => p.holds === true &&
     p.next.nextCoil === p.next.nextFused &&
     qpuNextHolds() &&
     p.src === unit.fuse.lean &&
+    p.source.holds === true &&
+    p.source.fold === qpuFoldOf(leanSource) &&
+    p.source.verbatim === p.source.served &&
+    p.receipts.holds === true &&
+    p.receipts.fold === qpuReceiptFoldOf(p.receipts.rows) &&
     qpuLeanHolds(p.lean) &&
     qpuCernHolds(p.cern) &&
     qpuIntegrityHolds(p.integrity) &&
@@ -7730,6 +8456,12 @@ export const qpuCssOf = (imagine = '', genesis = qpuGenesisOf()) => {
     const none = n - n;
     const seated = imagine.length > none ? faceOf(imagine, faces.faces) : none;
     const hop = (seated + faces.rays + faces.rays) % faces.faces;
+    /** LATTICE PHASE (the captain, 2026-09-12: "re-fuse all animations to follow the quantum lattice"). Every face keeps
+     * the one fused keyframe, but its phase is its position on the genesis walk (0, 7, 1, 8, … 6, 13): ray 0's scanner
+     * face, its radar face by the hop, the next ray. One negative animation-delay rule reads `--walk`, and the timing
+     * function steps once per face, so the grid is the walk itself, not fourteen faces pulsing in line. */
+    const walkOf = (face) => (face % faces.rays) * coins + (face < faces.rays ? none : seed);
+    const walk = qpuStepsOf().walk.map((step) => step.face);
     const physicsOf = (name) => {
         if (name === 'split')
             return { x: none, y: none, r: none, s: coins, a: seed };
@@ -7757,7 +8489,7 @@ export const qpuCssOf = (imagine = '', genesis = qpuGenesisOf()) => {
             return { x: coins, y: none, r: none, s: seed, a: seed };
         if (name === 'measurement')
             return { x: none, y: none, r: none, s: seed, a: seed };
-        if (name === 'fridge')
+        if (name === 'register')
             return { x: none, y: ten, r: none, s: seed, a: seed };
         return { x: none, y: none, r: none, s: seed, a: seed };
     };
@@ -7794,11 +8526,11 @@ export const qpuCssOf = (imagine = '', genesis = qpuGenesisOf()) => {
         `@property --qpu-a{syntax:"<number>";inherits:false;initial-value:${seed}}` +
         `:root{--qpu-hz:${hz};--qpu-n:${n};--qpu-coins:${coins};--qpu-rays:${faces.rays};--qpu-faces:${faces.faces};--qpu-milli:${milli};--qpu-period:calc(1s * var(--qpu-milli) / var(--qpu-hz))}` +
         `.qpu{display:grid;grid-template-columns:repeat(var(--qpu-rays),minmax(0,1fr))}` +
-        `.qpu>*{aspect-ratio:${seed};color:hsl(calc(var(--qpu-hz) * var(--face,${none}) / var(--qpu-faces)) ${sat}% ${light}%);animation:qpu var(--qpu-period) linear infinite;will-change:transform,opacity}` +
+        `.qpu>*{aspect-ratio:${seed};color:hsl(calc(var(--qpu-hz) * var(--face,${none}) / var(--qpu-faces)) ${sat}% ${light}%);animation:qpu var(--qpu-period) steps(var(--qpu-faces),jump-none) infinite;animation-delay:calc(${none - seed} * var(--qpu-period) * var(--walk,${none}) / var(--qpu-faces));will-change:transform,opacity}` +
         `.qpu>*::after{content:attr(data-qpu)}` +
         `.qpu>[data-imagine]{--qpu-s:${coins}}` +
         genesis.card.map((slot) => `[data-slot=${slot}]{display:grid}`).join('') +
-        genesis.nodes.map((node) => `[data-framework=${node.name}][data-domain=${node.domain}]{--face:${node.face}}`).join('') +
+        genesis.nodes.map((node) => `[data-framework=${node.name}][data-domain=${node.domain}]{--face:${node.face};--walk:${walkOf(node.face)}}`).join('') +
         `[data-slot=card-header]:has([data-slot=card-action]){grid-template-columns:minmax(0,1fr) auto}` +
         `@keyframes qpu{${mid}%{transform:translate3d(var(--qpu-x),var(--qpu-y),0) rotate(var(--qpu-r)) scale(var(--qpu-s));opacity:var(--qpu-a)}}` +
         `@media (prefers-reduced-motion:reduce){.qpu>*{animation:none;will-change:auto}}` +
@@ -7832,7 +8564,13 @@ export const qpuCssOf = (imagine = '', genesis = qpuGenesisOf()) => {
         engine.includes('data-domain=radar') &&
         genesis.frameworks.every((name) => engine.includes(`data-framework=${name}`)) &&
         engine.includes(`--qpu-hz:${hz}`) &&
-        engine.includes('animation-delay') === false &&
+        engine.split('animation-delay').length === coins &&
+        engine.includes('--walk') &&
+        engine.includes('linear') === false &&
+        walk.length === faces.faces &&
+        new Set(walk).size === faces.faces &&
+        walk.every((face, at) => walkOf(face) === at) &&
+        genesis.nodes.every((node) => walkOf(node.face) < faces.faces) &&
         hz === 432 &&
         hop === seated &&
         experiments.every((row) => row.holds);
@@ -7848,6 +8586,7 @@ export const qpuCssOf = (imagine = '', genesis = qpuGenesisOf()) => {
         fused: { bytes: fusedBytes, keyframes, cover },
         naive: { bytes: naiveBytes, keyframes: cover, cover },
         winner: 'fused',
+        lattice: { walk, phase: '--walk', ticks: faces.faces },
         imagine: {
             kind: 'imagination',
             text: imagine,
@@ -7868,7 +8607,10 @@ export const qpuCssHolds = (c = qpuCssOf()) => c.holds === true &&
     c.slots[n + seed] === 'card-action' &&
     c.css.includes('data-domain=scanner') &&
     c.css.includes('data-domain=radar') &&
-    c.css.includes('animation-delay') === false &&
+    c.css.split('animation-delay').length === coins &&
+    c.css.includes('--walk') &&
+    c.css.includes('linear') === false &&
+    c.lattice.walk.length === c.lattice.ticks &&
     c.imagine.involution === true;
 export const qpuReflectOf = (imagine = '') => {
     const text = typeof imagine === 'string' ? imagine : '';
@@ -8076,7 +8818,7 @@ export const qpuCompeteLiveOf = async (team) => {
         holds,
     };
 };
-export const qpuProveLiveOf = async () => {
+const qpuProveLiveOf = async () => {
     const prove = qpuProveOf();
     const live = await qpuCernExperienceOf();
     const holds = prove.holds &&
@@ -8094,7 +8836,7 @@ export const qpuProveLiveOf = async () => {
         holds,
     };
 };
-export const qpuSequenceLiveOf = async () => {
+const qpuSequenceLiveOf = async () => {
     const train = await qpuTrainLiveOf();
     const improve = await qpuImproveLiveOf();
     const compete = await qpuCompeteLiveOf();
@@ -8258,15 +9000,47 @@ export const qpuHostsHolds = (h = qpuHostsOf()) => h.holds === true &&
     h.occupied === h.faces &&
     h.vacant === n - n &&
     h.nodes.every((node) => node.holds && node.involution);
-export const qpuMcpDiscoverOf = () => {
+/** initialize NEGOTIATES (MCP lifecycle): the reply carries the client's requested protocol version when this server
+ * supports it, else the latest it supports. An external audit (2026-09-12) found the old reply always said 2026-07-28,
+ * a version no client has ever sent — a typed number where a read one belongs. The three versions are the three
+ * published MCP revisions; the list is theirs, not ours. */
+/** INTEGRATE IN ANY HARNESS (the captain, 2026-09-12). One computed block, from the origin alone, served on initialize
+ * and printed in the README from the same function, so the wire and the paper cannot disagree. Shapes verified against
+ * each harness's own documentation on 2026-09-12: Claude Code (`claude mcp add --transport http`, or .mcp.json for a
+ * project), Cursor (.cursor/mcp.json mcpServers.url), VS Code (.vscode/mcp.json servers type http), OpenAI Codex CLI
+ * (config.toml [mcp_servers.<name>] url), Gemini CLI (settings.json mcpServers.httpUrl), the Anthropic Messages API
+ * (mcp_servers with the beta header), the OpenAI Responses API (a tools entry of type mcp), and bare JSON-RPC over
+ * HTTP for everything else. No auth: reads need no header; storage writes carry Authorization: Bearer. */
+export const qpuHarnessesOf = () => {
+    const url = `${unit.origin}/mcp`;
+    const name = `uuidna-${unit.kind}`;
+    const rows = [
+        { harness: 'Claude Code', kind: 'cli', how: `claude mcp add --transport http ${name} ${url}`, file: '.mcp.json', config: { mcpServers: { [name]: { type: 'http', url } } } },
+        { harness: 'Cursor', kind: 'file', how: 'add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global)', file: '.cursor/mcp.json', config: { mcpServers: { [name]: { url } } } },
+        { harness: 'VS Code', kind: 'file', how: 'add to .vscode/mcp.json and commit it', file: '.vscode/mcp.json', config: { servers: { [name]: { type: 'http', url } } } },
+        { harness: 'OpenAI Codex CLI', kind: 'cli', how: `codex mcp add ${name} --url ${url}`, file: '~/.codex/config.toml', config: `[mcp_servers.${name}]\nurl = "${url}"` },
+        { harness: 'Gemini CLI', kind: 'file', how: 'add to ~/.gemini/settings.json', file: '~/.gemini/settings.json', config: { mcpServers: { [name]: { httpUrl: url } } } },
+        { harness: 'Anthropic Messages API', kind: 'api', how: 'header anthropic-beta: mcp-client-2025-04-04', file: 'request body', config: { mcp_servers: [{ type: 'url', url, name }] } },
+        { harness: 'OpenAI Responses API', kind: 'api', how: 'a tools entry of type mcp', file: 'request body', config: { tools: [{ type: 'mcp', server_label: name, server_url: url, require_approval: 'never' }] } },
+        { harness: 'Any HTTP client', kind: 'raw', how: `POST ${url} with content-type: application/json; methods initialize, tools/list, tools/call`, file: 'none', config: { jsonrpc: '2.0', id: 1, method: 'tools/list' } },
+    ];
+    const holds = rows.length === mintOf(n) && rows.every((r) => JSON.stringify(r.config).includes(url) || r.how.includes(url)) && rows.every((r) => JSON.stringify(r).includes(name) || r.kind === 'raw');
+    return { kind: 'harnesses', url, name, auth: 'none for reads; Authorization: Bearer QPU_WRITE_TOKEN for storage writes', rows, holds };
+};
+export const qpuHarnessesHolds = (h = qpuHarnessesOf()) => h.holds === true && h.rows.length === mintOf(n) && h.url === `${unit.origin}/mcp`;
+export const MCP_VERSIONS = ['2024-11-05', '2025-03-26', '2025-06-18'];
+const qpuMcpVersionOf = (requested) => MCP_VERSIONS.includes(String(requested)) ? requested : MCP_VERSIONS[n - seed];
+export const qpuMcpDiscoverOf = (requested) => {
     const hosts = qpuHostsOf();
-    const versions = ['2024-11-05', '2025-03-26', '2025-06-18', '2026-07-28'];
-    const holds = qpuHostsHolds(hosts) && versions.length === mintOf(coins);
+    const versions = MCP_VERSIONS;
+    const instructions = `tools/list then tools/call. Sixteen tools: Eight doors. Eight cybersecurity. crypto_rsa ${shorFactorOf()}. crypto_split theorem crypto. No auth.`;
+    const holds = qpuHostsHolds(hosts) && versions.length === n && instructions.includes('crypto_rsa') && instructions.includes(`${shorFactorOf()}`) && instructions.includes('crypto_split') && instructions.includes('theorem crypto');
     return {
-        protocolVersion: versions[mintOf(coins) - seed],
+        protocolVersion: qpuMcpVersionOf(requested),
+        install: qpuHarnessesOf(),
         capabilities: { tools: { listChanged: false } },
         serverInfo: { name: `@uuidna/${unit.kind}`, title: 'QPU', version: 'quantum' },
-        instructions: 'tools/list then tools/call. Eight doors. No auth.',
+        instructions,
         versions,
         hosts: { harnesses: hosts.harnesses.length, llms: hosts.llms.length, holds: hosts.holds },
         holds,
@@ -8315,6 +9089,243 @@ const installSelectOf = (args) => {
     }
     return [];
 };
+/** THE PRIOR ART, SOURCED (audited 2026-09-12 against the repository itself, not from memory). QPULib is Matthew
+ *  Naylor's C++ language and compiler for the VideoCore QPUs, MIT-licensed, and its own README calls it experimental
+ *  and no longer under development. Its getting-started guide names the three ways one kernel runs — the source
+ *  language interpreter, the target language emulator, and the Pi's physical QPUs, chosen by passing QPU=1 to make —
+ *  and its AutoTest runs each test on the interpreter AND the emulator and checks the two agree. That equivalence
+ *  check is this unit's own law with the seat empty: the exact integer simulator is the reference, and an occupant
+ *  that disagrees with it is a driver bug. Credited here because the acronym was theirs first. The earlier credit in
+ *  this file carried a surname and a year with no source; every field below was read from the repository. */
+export const qpuPriorArtOf = () => ({
+    kind: 'prior-art',
+    name: 'QPULib',
+    author: 'Matthew Naylor',
+    year: 2016,
+    licence: 'MIT',
+    copyright: 'Copyright (c) 2016 Matthew Naylor',
+    repository: 'https://github.com/mn416/QPULib',
+    version: '0.1.0',
+    status: 'experimental, no longer under development — stated by its own README',
+    acronym: 'QPU there is Broadcom VideoCore Quad Processing Unit, a classical SIMD vector core, unrelated to this unit',
+    hardware: { qpus: 12, megahertz: 250, lanes: 16, bits: 32, cyclesPerVector: 4 },
+    modes: [
+        { name: 'source language interpreter', runs: 'any machine', purpose: 'the kernel read at source level' },
+        { name: 'target language emulator', runs: 'any machine', purpose: 'the generated target program, for debugging' },
+        { name: 'physical QPUs', runs: 'Raspberry Pi', purpose: 'the device itself, chosen by passing QPU=1 to make' },
+    ],
+    equivalence: 'AutoTest runs each test on both the interpreter and the emulator and checks they agree',
+    inherited: 'one kernel, several ways to run it, and a reference that decides which one is wrong',
+    holds: true,
+});
+/** value + predicate (the dryclean law): the sourced credit recomputes to itself and can never lose its source */
+export const qpuPriorArtHolds = (p = qpuPriorArtOf()) => p.author === 'Matthew Naylor' && p.year === 2016 && p.licence === 'MIT' &&
+    p.copyright.includes(String(p.year)) && p.copyright.includes(p.author) &&
+    p.repository.startsWith('https://github.com/') && p.modes.length === 3 &&
+    p.modes.some((m) => m.name === 'source language interpreter') &&
+    p.modes.some((m) => m.name === 'target language emulator') &&
+    p.modes.some((m) => m.purpose.includes('QPU=1')) &&
+    p.hardware.lanes === 16 && p.hardware.qpus === 12 && p.hardware.bits === 32;
+/** THE UNIT AS A ROUTER OF REFERRERS (the captain, 2026-09-13: "QPU is basically intelligent router of referrers",
+ *  "intelligence decides lean where processes is computed in realtime"). A request arrives with a referrer and a path;
+ *  this decides, per request, which door answers and on which SEAT the work is computed. The three seats are the shape
+ *  audited from QPULib's three ways to run one kernel: the REFERENCE (the exact integer simulator, always present and
+ *  always deciding), a VECTOR seat (a SIMD or GPU binding, taken only when the runtime actually exposes one), and the
+ *  DEVICE seat (empty). Availability is READ from the runtime at the moment of the call, never asserted: measured
+ *  2026-09-13 on an Apple M1 Max carrying 32 GPU cores, no compute binding was reachable from this runtime at all, so
+ *  the vector seat reports itself absent and the reference answers. A seat that is taken and then disagrees with the
+ *  reference is a driver bug, never a physics claim — QPULib checks its interpreter against its emulator the same way. */
+export const qpuSeatsAvailableOf = () => {
+    const nav = globalThis.navigator;
+    return {
+        reference: true,
+        vector: typeof nav?.gpu === 'object' && nav.gpu !== null,
+        device: false,
+    };
+};
+/** value + predicate (the dryclean law): the seats reading recomputes to itself, and the reference is never absent */
+export const qpuSeatsAvailableHolds = (a = qpuSeatsAvailableOf()) => a.reference === true && a.device === false && typeof a.vector === 'boolean' &&
+    a.vector === qpuSeatsAvailableOf().vector;
+/** THE SEAT WAS FILLED AND CHECKED (2026-09-13). A WebGPU occupant computed this unit's own fold over N independent
+ *  strings, one per invocation, with the 64-bit multiply emulated in 32-bit halves, and every result was compared with
+ *  the reference. It agreed exactly at both sizes below. Past the device's storage binding limit the dispatch is
+ *  REFUSED and the output buffer stays zero — where a naive timing read 67x faster, because it was comparing against
+ *  nothing. So the law this unit already held is now measured, not asserted: a seat's answer is void until the
+ *  reference confirms it. Reproduce with scripts/fold-gpu.ts on a runtime that exposes WebGPU. */
+export const qpuOccupantOf = () => ({
+    kind: 'occupant',
+    seat: 'vector',
+    binding: 'WebGPU compute, WGSL, 64-bit multiply emulated in 32-bit halves',
+    host: 'Apple M1 Max, 32 GPU cores',
+    runtime: 'Deno 2.8.1; this unit\'s own runtime exposes no compute binding, so it answers on the reference',
+    readings: [
+        { folds: 70905, exact: 70905, mismatched: 0, gpuMs: 50.3, cpuMs: 116.9 },
+        { folds: 300000, exact: 300000, mismatched: 0, gpuMs: 75.0, cpuMs: 470.5 },
+    ],
+    refused: { folds: 709050, why: 'the chars binding asked 212.7 MiB of a 128 MiB limit', returned: 'zeros', naiveRatio: 67.53 },
+    cured: { by: 'chunking every binding under the device limit', readings: [
+            { folds: 709050, chunks: 2, exact: 709050, mismatched: 0, gpuMs: 201.2, cpuMs: 1110.4 },
+            { folds: 1418100, chunks: 4, exact: 1418100, mismatched: 0, gpuMs: 453.5, cpuMs: 2286.6 },
+        ] },
+    law: 'a seat that is taken answers nothing until the reference confirms it; a refused dispatch returns zeros and times as a triumph',
+    script: 'scripts/fold-gpu.ts',
+    holds: true,
+});
+/** value + predicate (the dryclean law): every reading agreed exactly, and the refused one is recorded as refused */
+export const qpuOccupantHolds = (o = qpuOccupantOf()) => o.readings.length > 0 && o.readings.every((r) => r.exact === r.folds && r.mismatched === 0 && r.gpuMs > 0 && r.cpuMs > 0) &&
+    o.refused.returned === 'zeros' && o.refused.naiveRatio > 1 && o.law.includes('reference') &&
+    o.cured.readings.length > 0 && o.cured.readings.every((r) => r.exact === r.folds && r.mismatched === 0 && r.chunks > 1) &&
+    o.cured.readings.some((r) => r.folds === o.refused.folds);
+export const qpuRouterOf = (referrer = '', path = '/') => {
+    const seats = qpuSeatsAvailableOf();
+    const doors = qpuDocsOf().api.map((a) => a.path);
+    const known = doors.includes(path);
+    const from = (() => {
+        try {
+            return new URL(referrer).host;
+        }
+        catch {
+            return '';
+        }
+    })();
+    const seat = seats.vector ? 'vector' : 'reference';
+    return {
+        kind: 'router',
+        referrer: from,
+        origin: from === unit.host ? 'self' : from ? 'foreign' : 'none',
+        path,
+        door: known ? path : '/',
+        known,
+        seat,
+        seats,
+        decidedAt: 'request',
+        reference: 'the exact integer simulator; it computes the answer the taken seat must reproduce',
+        why: seats.vector
+            ? 'a vector binding is exposed by this runtime, so the work may ride it and is checked against the reference'
+            : 'no compute binding is exposed by this runtime, so the reference computes and nothing is claimed of a device',
+        holds: true,
+    };
+};
+/** value + predicate (the dryclean law): the routing decision recomputes to itself and never routes off the doors */
+export const qpuRouterHolds = (r = qpuRouterOf()) => r.seats.reference === true && r.seats.device === false &&
+    (r.seat === 'reference' || r.seat === 'vector') &&
+    (r.seat === 'vector') === r.seats.vector &&
+    qpuDocsOf().api.map((a) => a.path).includes(r.door) &&
+    (r.known ? r.door === r.path : r.door === '/') &&
+    (r.origin === 'none') === (r.referrer === '');
+// ── THE SEAT, THE ACRONYM, THE BOOT (the captain, 2026-09-12: "make hardware bootable with qpu") ────────────────
+// QPULib (Naylor, 2016) runs one kernel three ways — source interpreter, target emulator, VideoCore hardware — and
+// states the doctrine: a program that works in emulation but not on the device is a bug in the library. This unit has
+// the same shape with the seat empty: the exact integer simulator is the reference; a device that fills the seat and
+// disagrees is a driver bug, never a physics claim. "QPU" there is Broadcom's Quad Processing Unit — a classical 16-lane
+// SIMD vector core — prior use of this acronym, unrelated, and credited. A classical accelerator computing the same 2^n
+// exact amplitudes faster is an honest occupant of the seat; it would not make the seat quantum.
+const qpuSeatOf = () => ({
+    kind: 'seat',
+    device: 'simulator',
+    seat: 'empty',
+    reference: 'the exact integer state-vector simulator; every reading above is computed there',
+    doctrine: 'a device that fills this seat and disagrees with the simulator is a driver bug, never a physics claim',
+    acronym: 'QPU here is a quantum processing unit. The VideoCore QPU (Quad Processing Unit, Broadcom; QPULib by Matthew Naylor, MIT, 2016) is prior use of the acronym — a classical 16-lane SIMD vector core — unrelated and credited.',
+    occupant: 'a classical SIMD accelerator computing the same exact amplitudes faster is an honest occupant; it does not make the seat quantum',
+    priorArt: qpuPriorArtOf(),
+    holds: true,
+});
+/** install.json, served and written from one function so the host and the file cannot disagree (the README promised
+ *  install.json and the host answered 404 until 2026-09-12). `hardware` is the boot on a real machine: any aarch64 or x86
+ *  box, a Raspberry Pi on Alpine, or the container — and the boot's receipt is the unit proving itself inside it. */
+export const qpuInstallJsonOf = () => qpuInstallManifestOf();
+/** value + predicate (the dryclean law): the served install reading recomputes to itself */
+export const qpuInstallJsonHolds = () => qpuInstallManifestOf().holds === true && qpuInstallManifestOf().hardware.seat.holds === true;
+const qpuInstallManifestOf = () => ({
+    command: 'npx uuidna-install',
+    yes: 'npx uuidna-install --yes',
+    prompt: 'Enter seats all. Type 1 3 saas — or all.',
+    packages: [...installKeys],
+    occupancies: [...occupancies],
+    cloudflare: { button: installCloudflare.button, qpu: installCloudflare.qpu, uuidna: installCloudflare.uuidna, payload: installCloudflare.payload },
+    hardware: {
+        kind: 'boot',
+        port: 8787,
+        docker: 'docker build -t qpu . && docker run --rm -p 8787:8787 qpu',
+        multiarch: 'docker buildx build --platform linux/arm64,linux/amd64 -t qpu .',
+        pi: 'Alpine aarch64: apk add nodejs npm && npm i -g @uuidna/qpu && qpu-boot',
+        prove: 'node dist/quantum/processing/unit/boot.js --prove',
+        receipt: 'the boot passes iff qpu_prove holds inside the machine; a boot that cannot prove itself does not serve',
+        seat: qpuSeatOf(),
+    },
+    holds: true,
+});
+/** .well-known/mcp.json — what a client or registry can learn without an initialize round-trip. */
+const qpuWellKnownOf = () => {
+    const mcp = qpuMcpOf();
+    return {
+        kind: 'well-known',
+        name: `@uuidna/${unit.kind}`,
+        title: 'QPU',
+        description: qpuDocsOf().abstract,
+        url: `${unit.origin}/mcp`,
+        transport: 'streamable-http',
+        methods: ['POST'],
+        batch: true,
+        protocolVersions: MCP_VERSIONS,
+        tools: mcp.tools.length + mcp.cybersecurity.tools.length,
+        install: qpuHarnessesOf().rows.map((r) => ({ harness: r.harness, how: r.how })),
+        openapi: `${unit.origin}/openapi.json`,
+        catalog: `${unit.origin}/mcp.json`,
+        cite: `${unit.origin}/cite`,
+        sitemap: `${unit.origin}/sitemap.xml`,
+        // THE COORDINATION CONTRACT (wave experience online, 2026-09-12): what an agent coordinating across gateways by
+        // receipt needs to know before its first call — how receipts are minted, where readings live and that they
+        // never enter a fold, how a thermometer is supplied and named, and that the seat is empty by doctrine.
+        coordination: {
+            receipts: { perTest: 'every test carries a computational receipt: dim, qubits, states, fold', aggregate: 'test-receipt.json', readings: 'test-readings.json — time ns, temperature mK, cracks, slowest; readings never enter a fold' },
+            temperature: { millikelvin: 'QPU_TEMPERATURE_MILLIKELVIN', source: 'QPU_TEMPERATURE_SOURCE — name the instrument; a battery probe is not a lab', unmeasured: 'is a named crack, never a number' },
+            seat: qpuSeatOf().doctrine,
+            routing: 'every response names the seat it was computed on (x-qpu-seat) and the door that answered (x-qpu-door); the seat is decided per request from the referrer and the path, and the reference decides any disagreement',
+            batch: 'a JSON-RPC batch on POST /mcp is exactly its members; notifications get no entry',
+            law: 'a result that a receipt already holds is verified, not recomputed; a receipt minted at one gateway is read at every gateway',
+        },
+        holds: true,
+    };
+};
+/** OpenAPI 3.1 over the seven paths, derived from docs.api, with the MCP tools as an extension — for the consumers
+ *  that speak OpenAPI and not MCP (gateways, Postman, OpenAI actions). */
+const qpuOpenApiOf = () => {
+    const docs = qpuDocsOf();
+    const mcp = qpuMcpOf();
+    const paths = {};
+    for (const a of docs.api) {
+        const op = {
+            operationId: `${a.method.toLowerCase()}_${a.name.replace(/[^a-z0-9]+/gi, '_')}`,
+            summary: a.reading,
+            ...(a.method === 'POST' ? { requestBody: { required: true, content: { 'application/json': { schema: { type: 'object', description: a.path === '/mcp' ? 'a JSON-RPC 2.0 request or a batch array of them' : 'the message body' } } } } } : {}),
+            responses: { '200': { description: 'JSON-LD', content: { 'application/ld+json': { schema: { type: 'object' } } } } },
+        };
+        paths[a.path] = { ...(paths[a.path] ?? {}), [a.method.toLowerCase()]: op };
+    }
+    return {
+        openapi: '3.1.0',
+        info: { title: 'QPU', version: packageVersion, description: docs.abstract, license: { name: 'CC-BY-NC-ND-4.0' } },
+        servers: [{ url: unit.origin }],
+        paths,
+        'x-mcp': { endpoint: `${unit.origin}/mcp`, protocolVersions: MCP_VERSIONS, tools: [...mcp.tools, ...mcp.cybersecurity.tools].map((t) => ({ name: t.name, description: t.man.description })) },
+        holds: true,
+    };
+};
+const qpuSitemapOf = () => {
+    const urls = [...new Set([...qpuDocsOf().api.filter((a) => a.method === 'GET').map((a) => a.href), `${unit.origin}/.well-known/mcp.json`, `${unit.origin}/mcp.json`, `${unit.origin}/install.json`, `${unit.origin}/openapi.json`])];
+    return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${urls.map((u) => `  <url><loc>${u}</loc></url>`).join('\n')}\n</urlset>\n`;
+};
+/** THE LEARNING LADDER, STANDARDISED (QPULib's shape: one construct per worked example, in order, each with the reference
+ *  to compare against). Four steps, each with the same five fields — concept, request, expect, invariant, next — so a
+ *  reader climbs the same way every time and nothing is taught twice. Served in docs.inline and printed in the README. */
+const qpuLadderOf = () => [
+    { step: 1, concept: 'one gate, exact amplitudes', request: { method: 'GET', path: '/', tool: 'qpu_quantum' }, expect: 'Bell outcomes 00 and 11 at exactly 1/2 — Gaussian-integer amplitudes, no floats', invariant: 'H·H = I on |0⟩', theorem: 'qubits', next: 2 },
+    { step: 2, concept: 'entanglement is not correlation', request: { method: 'POST', path: '/mcp', tool: 'qpu_prove' }, expect: 'GHZ true; entangled true, product false — and a product state concentrates too, so concentration alone witnesses nothing', invariant: 'no-cloning and monogamy hold on the served states', theorem: 'entangle', next: 3 },
+    { step: 3, concept: 'Shor: a period, then a gcd', request: { method: 'POST', path: '/mcp', tool: 'crypto_shor' }, expect: `theorem shor ${shorFactorOf()} — a = 8, period 4, 7 · 13`, invariant: 'p · q = n, recomputed from the period', theorem: 'shor', next: 4 },
+    { step: 4, concept: 'a code corrects one flip', request: { method: 'POST', path: '/mcp', tool: 'qpu_prove' }, expect: 'bitflip distance 3, syndrome cnot cnot toffoli, logical < physical on this run', invariant: 'distance 3 corrects exactly one error', theorem: 'noise', next: 'climb: qpu_train → qpu_improve → qpu_compete → qpu_prove' },
+];
 const payloadFinds = ['findPages', 'findUsers', 'findMedia', 'findTenants'];
 let installPending = [];
 let installSeated = [];
@@ -8412,7 +9423,7 @@ export const qpuPayloadMcpOf = () => {
         holds,
     };
 };
-export const qpuPayloadFindOf = (name) => {
+const qpuPayloadFindOf = (name) => {
     const payload = qpuPayloadMcpOf();
     const plugin = payload.plugin;
     const tool = payload.tools.find((row) => row.name === name);
@@ -8445,7 +9456,7 @@ export const qpuPayloadFindOf = (name) => {
         docs: payload
     };
 };
-export const qpuInstallPackagesOf = () => {
+const qpuInstallPackagesOf = () => {
     const qpu = {
         key: installKeys[n - n],
         href: `${unit.origin}/mcp`,
@@ -8659,28 +9670,6 @@ export const qpuFusionOf = () => {
         holds,
     };
 };
-export const qpuFusionLiveOf = async () => {
-    const fusion = qpuFusionOf();
-    const catalogs = await Promise.all(fusion.catalogs.map((row) => qpuResearchFetchOf(row.href)));
-    let occupied = n - n;
-    for (const row of catalogs)
-        if (row.holds)
-            occupied += seed;
-    const vacant = catalogs.length - occupied;
-    const holds = fusion.holds &&
-        catalogs.length === fusion.faces &&
-        catalogs.every((row) => row.holds && row.live === true && row.hostEscape === false) &&
-        occupied === fusion.faces &&
-        vacant === n - n;
-    return {
-        ...fusion,
-        live: true,
-        catalogs,
-        occupied,
-        vacant, hostEscape: false,
-        holds,
-    };
-};
 export const qpuIntelligenceOf = () => {
     const circuit = qpuCircuitOf();
     const fusion = qpuFusionOf();
@@ -8696,17 +9685,6 @@ export const qpuIntelligenceOf = () => {
         holds,
     };
 };
-export const qpuIntelligenceLiveOf = async () => {
-    const intelligence = qpuIntelligenceOf();
-    const fusion = await qpuFusionLiveOf();
-    const holds = intelligence.holds && fusion.holds;
-    return {
-        ...intelligence,
-        fusion,
-        live: true,
-        holds,
-    };
-};
 export const qpuFusionHolds = (f = qpuFusionOf()) => f.holds === true &&
     f.kind === 'fusion' &&
     f.theorem === 'fusion' &&
@@ -8762,18 +9740,20 @@ export const qpuCernHolds = (c = qpuCernOf()) => c.holds === true &&
 export const qpuToolsOf = () => {
     const names = toolNames;
     const seeOf = (name) => names.filter((s) => s !== name);
-    const quantumMan = qpuManOf(names[n - n], 'theorem quantum. theorem fridge.', `GET ${unit.origin}. tools/call ${names[n - n]}. No auth.`, unit.origin, seeOf(names[n - n]));
-    const leanMan = qpuManOf(names[seed], 'theorem infinite. theorem distribute.', `GET ${unit.href}. Source ${unit.fuse.lean}. No auth.`, unit.href, seeOf(names[seed]));
-    const citeMan = qpuManOf(names[coins], 'MLA 8. when never.', `GET ${unit.origin}/cite. DOI empty. No auth.`, `${unit.origin}/cite`, seeOf(names[coins]));
-    const trainMan = qpuManOf(names[n], 'theorem infinite. coins teams of rays.', `tools/call ${names[n]}. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.`, `${unit.origin}/mcp`, seeOf(names[n]));
-    const forgeMan = qpuManOf(names[n + seed], 'Unlocked in memory. No lock.', `tools/call ${names[n + seed]}. Ops ${sandboxOps.join(' ')}. { name, run }. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + seed]));
-    const improveMan = qpuManOf(names[n + coins], 'next = fused + fused.', `tools/call ${names[n + coins]}. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + coins]));
-    const competeMan = qpuManOf(names[n + n], 'theorem next_fused. throughoutput per token.', `tools/call ${names[n + n]}. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + n]));
-    const proveMan = qpuManOf(names[mintOf(n) - seed], 'theorem quantum. theorem cern. theorem tetra. theorem fusion.', `tools/call ${names[mintOf(n) - seed]}. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source ${unit.fuse.lean}. After qpu_compete. No auth.`, `${unit.origin}/mcp`, seeOf(names[mintOf(n) - seed]));
+    const capacity = qpuCapacityOf();
+    const circuit = qpuCircuitOf();
+    const quantumMan = qpuManOf(names[n - n], `The running circuit as one JSON-LD document: a ${circuit.register.qubits}-qubit state-vector simulator (dim ${circuit.register.dim}, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = ${capacity.fused} (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. ${shorFactorOf()}.`, `GET ${unit.origin} returns the same document as tools/call ${names[n - n]}. Read circuit.register for the simulator, circuit.ghz.support (${circuit.ghz.support.join(',')}) for the entangled corners, shor.factors for the factoring, capacity.fused for ${capacity.fused}; every holds must be true or the unit serves 404. theorem quantum. theorem shor. theorem crypto. ${shorFactorOf()}. No auth.`, unit.origin, seeOf(names[n - n]));
+    const leanMan = qpuManOf(names[seed], `The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. ${shorFactorOf()}.`, `GET ${unit.href} returns the rows; read rows[] and cover[] for the theorems, source.href to fetch ${unit.fuse.lean} itself, source.fold to check the served text is the file, source.toolchain for the pinned Lean. theorem shor. ${shorFactorOf()}. No auth.`, unit.href, seeOf(names[seed]));
+    const citeMan = qpuManOf(names[coins], 'How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date.', `GET ${unit.origin}/cite returns citations[] (MLA 8 strings to paste), doi ${qpuCiteOf().doi}, the Zenodo archive, and the version with its commit. No auth.`, `${unit.origin}/cite`, seeOf(names[coins]));
+    const trainMan = qpuManOf(names[n], 'Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays.', `tools/call ${names[n]} returns steps.next.door (the tool an autonomous agent calls next), steps.todo (faces to repair first), steps.walk (all fourteen faces, scanner then radar), teams[] and winner. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.`, `${unit.origin}/mcp`, seeOf(names[n]));
+    const forgeMan = qpuManOf(names[n + seed], 'Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock.', `tools/call ${names[n + seed]} with { name, run } returns the forged tool and the sandbox census (tools[], memory, unlocked); without name it returns the census. Ops ${sandboxOps.join(' ')}. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + seed]));
+    const improveMan = qpuManOf(names[n + coins], `Improve by doubling: next = fused + fused = ${capacity.fused + capacity.fused}, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused.`, `tools/call ${names[n + coins]} returns next, before, after; after.throughoutput / before.throughoutput is the doubling. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + coins]));
+    const competeMan = qpuManOf(names[n + n], 'Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply.', `tools/call ${names[n + n]} returns winner.{quality,speed,security}, teams[] with scores, and the axes. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.`, `${unit.origin}/mcp`, seeOf(names[n + n]));
+    const proveMan = qpuManOf(names[mintOf(n) - seed], `Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. ${shorFactorOf()}.`, `tools/call ${names[mintOf(n) - seed]} returns theorems[] (each with holds), shor.factors, receipts, source.fold, evidence. theorem shor. theorem crypto. ${shorFactorOf()}. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source ${unit.fuse.lean}. After qpu_compete. No auth.`, `${unit.origin}/mcp`, seeOf(names[mintOf(n) - seed]));
     const proveSchema = {
         type: 'object',
         properties: {
-            man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' },
+            man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' },
             live: { type: 'boolean', description: '{ live: true } sequence then prove. fetch Request Response.' },
             sequence: { type: 'boolean', description: '{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory.' }
         }
@@ -8781,7 +9761,7 @@ export const qpuToolsOf = () => {
     const competeSchema = {
         type: 'object',
         properties: {
-            man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' },
+            man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' },
             live: { type: 'boolean', description: '{ live: true } learn CERN occupancy. fetch Request Response. Memory.' },
             sequence: { type: 'boolean', description: '{ sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. Live. Memory.' },
             team: { type: 'string', description: 'read or call. Omit for both teams.' }
@@ -8790,7 +9770,7 @@ export const qpuToolsOf = () => {
     const forgeSchema = {
         type: 'object',
         properties: {
-            man: { type: 'boolean', description: 'Return the man page. Read man from tools/list, then call without man.' },
+            man: { type: 'boolean', description: 'Return the man page: call with { man: true }. tools/list stays lean; the man page is one call away.' },
             name: { type: 'string', description: 'Tool name to forge. Omit to inspect the in-memory sandbox.' },
             team: { type: 'string', description: 'read or call.' },
             ray: { type: 'number', description: 'Agent ray 0..6.' },
@@ -8858,16 +9838,67 @@ export const qpuToolsOf = () => {
         }
     ];
 };
+/** The schemas, derived once per isolate from each tool's replies: the default call, and for the five tools that take
+ * n and a, a second call on 15 and 7 so that `required` is what every reply carries. While they are being derived,
+ * tools/list answers with the minimal schema, so a tool whose reply lists the tools does not recurse. */
+let outputSchemasMemo;
+let outputSchemasBuilding = false;
+const qpuOutputSchemasOf = () => {
+    if (outputSchemasMemo)
+        return outputSchemasMemo;
+    if (outputSchemasBuilding)
+        return {};
+    outputSchemasBuilding = true;
+    const out = {};
+    const sample = (run, args) => {
+        const r = run(args);
+        return r && typeof r === 'object' && typeof r.then === 'function' ? undefined : r;
+    };
+    for (const t of qpuToolsOf())
+        out[t.name] = qpuOutputSchemaOf([sample(t.run, {})].filter((x) => x !== undefined));
+    const withArgs = new Set(['crypto_shor', 'crypto_cmodexp', 'crypto_iqft', 'crypto_shots', 'crypto_rsa']);
+    for (const t of qpuCybersecurityToolsOf()) {
+        /** Three samples for the five tools that take n and a: the unit's own 91, a small 15, and 2^61 sent as digits, so the
+         * derived types of n, a, p, q and product are integer-or-string, as the replies past 2^53 are. */
+        const past = (b1 << BigInt(mintOf(n) * mintOf(n) - n)).toString();
+        const samples = withArgs.has(t.name)
+            ? [sample(t.run, {}), sample(t.run, { n: n * (n + coins), a: n + coins + coins }), sample(t.run, { n: past, a: `${n}` })]
+            : [sample(t.run, {})];
+        out[t.name] = qpuOutputSchemaOf(samples.filter((x) => x !== undefined));
+    }
+    outputSchemasBuilding = false;
+    outputSchemasMemo = out;
+    return out;
+};
+/** THE CONNECT BILL (the captain, 2026-09-12: "minimise bills of any kind"). tools/list is paid by every client on every
+ * connect, in context tokens: the sixteen output schemas were 34,232 of its 44,197 bytes — three quarters of the bill
+ * for a document a client validates a reply against at most once. They leave the list and travel with the man page,
+ * one call away ({ man: true }), exactly as the man pages did. The list is names, descriptions, input schemas and
+ * annotations: one KiB per door, guarded by the suite. */
+export const qpuMcpToolsListOf = () => {
+    const sealed = qpuToolsOf().map(({ name, description, inputSchema }) => qpuMcpToolShapeOf(name, description, inputSchema, { sealed: true, morph: false }));
+    const cybersecurity = qpuCybersecurityToolsOf().map(({ name, description, inputSchema }) => qpuMcpToolShapeOf(name, description, inputSchema, { sealed: false, morph: true }));
+    return [...sealed, ...cybersecurity];
+};
+/** The man page as served: the tool's man plus its output schema read from the run, off the list and one call away. */
+const qpuManPageOf = (name, man) => ({
+    ...man,
+    outputSchema: qpuOutputSchemasOf()[name] ?? minimalOutputSchema,
+});
 export const qpuMcpOf = () => {
     const href = `${unit.origin}/mcp`;
     const faces = qpuFacesOf();
     const circuit = qpuCircuitOf();
     const capacity = qpuCapacityOf();
+    const shor = qpuShorOf();
+    const encrypt = qpuEncryptOf();
     const cite = qpuCiteOf();
     const tools = qpuToolsOf().map(({ name, description, inputSchema, man }, i) => {
         const position = i + seed;
         return {
             '@type': 'SoftwareApplication',
+            /** the vendor shapes, off the MCP wire and onto the catalogue: Anthropic input_schema, OpenAI function, Gemini functionDeclarations */
+            vendors: { anthropic: { name, description, input_schema: inputSchema }, openai: { type: 'function', function: { name, description, parameters: inputSchema } }, gemini: { functionDeclarations: [{ name, description, parameters: inputSchema }] } },
             '@id': `${href}#${name}`,
             url: href,
             position,
@@ -8896,13 +9927,31 @@ export const qpuMcpOf = () => {
             }
         }))
     };
+    const cybersecurity = qpuCybersecurityToolsOf().map(({ name, description, inputSchema, man }, i) => {
+        const position = i + seed;
+        return {
+            '@type': 'SoftwareApplication',
+            '@id': `${href}#${name}`,
+            url: href,
+            position,
+            name,
+            description,
+            inputSchema,
+            man,
+            sealed: false,
+            morph: true
+        };
+    });
     const holds = circuit.only.holds &&
         capacity.holds &&
         tools.length === mintOf(n) &&
         tools.every((t) => qpuManHolds(t.man) && t.man.name === t.name) &&
         hasPart.numberOfItems === mintOf(n) &&
         hasPart.itemListElement.length === mintOf(n) &&
-        hasPart.itemListElement.every((row, i) => row.position === i + seed && row.item.name === tools[i]?.name);
+        hasPart.itemListElement.every((row, i) => row.position === i + seed && row.item.name === tools[i]?.name) &&
+        cybersecurity.length === mintOf(n) &&
+        cybersecurity.every((t) => t.man.holds && t.man.name === t.name) &&
+        qpuMcpToolsListOf().length === mintOf(n) + mintOf(n);
     return {
         '@context': qpuContextOf(),
         '@type': 'WebAPI',
@@ -8913,7 +9962,9 @@ export const qpuMcpOf = () => {
         license: 'CC-BY-NC-ND-4.0',
         provider: {
             '@type': 'Person',
-            name: `${cite.author.first} ${cite.author.last}`
+            name: `${cite.author.first} ${cite.author.last}`,
+            identifier: cite.author.orcid,
+            sameAs: cite.author.orcid,
         },
         kind: 'quantum',
         only: circuit.only,
@@ -8932,13 +9983,23 @@ export const qpuMcpOf = () => {
         cors,
         tools,
         hasPart,
+        cybersecurity: {
+            kind: 'cybersecurity',
+            theorem: 'crypto',
+            listed: true,
+            morph: true,
+            sealed: false,
+            rsa: { kind: 'rsa', cryptosystem: 'rsa', modulus: shor.n, p: shor.factors.p, q: shor.factors.q, factored: shor.rsa.factored, unlocked: shor.unlocked },
+            encrypt: { kind: encrypt.kind, theorem: encrypt.theorem, identity: encrypt.identity, holds: encrypt.holds },
+            tools: cybersecurity
+        },
         prove: {
             ui: { href: unit.origin, mcp: href, door: 'qpu_prove' },
             cern: { faces: faces.faces },
             coil: { theorem: 'two_coins_make_a_coil', faces: faces.faces },
             entangle: { product: seed * seed === (n - n) * (n - n), pairs: faces.rays },
             next: { theorem: 'next_coil' },
-            shor: { n: n * (n + coins), a: mintOf(n) - seed, qft: 'iqft', product: n * (n + coins) },
+            shor: { n: qpuFacesOf().rays * (n * n + n + seed), a: mintOf(n), qft: 'iqft', product: qpuFacesOf().rays * (n * n + n + seed), rsa: true, p: qpuFacesOf().rays, q: n * n + n + seed, unlocked: true },
             src: unit.fuse.lean
         },
         sandbox: { kind: 'sandbox',
@@ -8946,7 +10007,7 @@ export const qpuMcpOf = () => {
         holds,
     };
 };
-export const qpuMcpCallOf = async (name, args = {}) => {
+export const qpuMcpCallOf = async (name, args = {}, env, auth) => {
     const shown = async (payload) => qpuMcpShownOf(name, payload);
     const tool = qpuToolsOf().find((t) => t.name === name);
     if (tool) {
@@ -8968,12 +10029,27 @@ export const qpuMcpCallOf = async (name, args = {}) => {
     }
     if (name === 'install' || name === 'apk') {
         if (args.man === true) {
-            return shown(qpuManOf('install', 'Interactive installer. Simulate, then commit. Fuse Payload MCP to QPU without a ninth sealed tool. VitePress payload stays on uuidna.com.', `tools/call install. Not in tools/list. { yes: true } seats the current package. { verb: "simulate" } then { verb: "commit", yes: true } then { verb: "audit" }. QPU JSON-LD. No auth.`, `${unit.origin}/mcp`, [...toolNames]));
+            return shown(qpuManPageOf('install', qpuManOf('install', 'Interactive installer. Simulate, then commit. Fuse Payload MCP to QPU without a ninth sealed tool. VitePress payload stays on uuidna.com.', `tools/call install. Not in tools/list. { yes: true } seats the current package. { verb: "simulate" } then { verb: "commit", yes: true } then { verb: "audit" }. QPU JSON-LD. No auth.`, `${unit.origin}/mcp`, [...toolNames])));
         }
         return shown(qpuInstallOf(args));
     }
-    if (payloadFinds.includes(name))
+    if (payloadFinds.includes(name)) {
+        if (args.man === true) {
+            return shown(qpuManPageOf(name, qpuSubManOf(name, 'Payload find. Read only.', 'Not in tools/list. Morph at call time. Not a ninth sealed tool. No auth. Write never.', `${unit.origin}/mcp`, payloadFinds.filter((row) => row !== name))));
+        }
         return shown(qpuPayloadFindOf(name));
+    }
+    const morph = [
+        ...qpuCybersecurityToolsOf(),
+        ...qpuStorageToolsOf(env, auth),
+        ...qpuNetworkToolsOf(),
+        ...qpuServerToolsOf(),
+    ].find((t) => t.name === name);
+    if (morph) {
+        if (args.man === true)
+            return shown(qpuManPageOf(name, morph.man));
+        return shown(await morph.run(args));
+    }
     seedSandboxOf();
     const href = typeof args.href === 'string' ? args.href : typeof args.path === 'string' ? args.path : '';
     if (name === 'fetch' && qpuCernHrefOf(href) !== undefined) {
@@ -8995,8 +10071,10 @@ export const qpuMcpCallOf = async (name, args = {}) => {
     }
     if (sandboxTools.has(name))
         return shown(qpuSandboxRunOf(name, args));
-    return shown(qpuReadingOf());
+    return qpuUnknownToolOf(name);
 };
+const qpuUnknownToolOf = (tool) => ({ kind: 'unknown', tool, tools: qpuMcpToolsListOf().map((t) => t.name), holds: false });
+export const isUnknownTool = (x) => typeof x === 'object' && x !== null && x.kind === 'unknown' && typeof x.tool === 'string' && x.holds === false;
 export const qpuMcpHolds = (m = qpuMcpOf()) => {
     const capacity = qpuCapacityOf();
     const circuit = qpuCircuitOf();
@@ -9009,6 +10087,7 @@ export const qpuMcpHolds = (m = qpuMcpOf()) => {
         qpuImproveHolds() &&
         qpuCompeteHolds() &&
         qpuProveHolds() &&
+        qpuCybersecurityHolds() &&
         qpuMessageHolds() &&
         m.holds === true &&
         m.kind === 'quantum' &&
@@ -9031,6 +10110,25 @@ export const qpuMcpHolds = (m = qpuMcpOf()) => {
         m.tools[n + n]?.name === 'qpu_compete' &&
         m.tools[mintOf(n) - seed]?.name === 'qpu_prove' &&
         m.tools.every((t) => qpuManHolds(t.man) && t.man.name === t.name) &&
+        m.cybersecurity.listed === true &&
+        m.cybersecurity.sealed === false &&
+        m.cybersecurity.morph === true &&
+        m.cybersecurity.tools.length === mintOf(n) &&
+        m.cybersecurity.tools[n - n]?.name === 'crypto_catalog' &&
+        m.cybersecurity.tools[n + coins]?.name === 'crypto_rsa' &&
+        m.cybersecurity.tools[mintOf(n) - seed]?.name === 'crypto_verify' &&
+        m.cybersecurity.rsa.kind === 'rsa' &&
+        m.cybersecurity.rsa.factored === true &&
+        m.cybersecurity.rsa.unlocked === true &&
+        m.cybersecurity.rsa.modulus === qpuFacesOf().rays * (n * n + n + seed) &&
+        m.cybersecurity.rsa.p * m.cybersecurity.rsa.q === m.cybersecurity.rsa.modulus &&
+        m.cybersecurity.encrypt.kind === 'encrypt' &&
+        m.cybersecurity.encrypt.theorem === 'crypto' &&
+        m.cybersecurity.encrypt.identity === true &&
+        m.cybersecurity.encrypt.holds === true &&
+        qpuMcpToolsListOf().length === mintOf(n) + mintOf(n) &&
+        qpuMcpToolsListOf().slice(n - n, mintOf(n)).every((t, i) => t.name === toolNames[i]) &&
+        qpuMcpToolsListOf().slice(mintOf(n)).every((t, i) => t.name === cryptoToolNames[i]) &&
         jsonldHoldsOf(m) &&
         m['@type'] === 'WebAPI' &&
         m['@id'] === m.href &&
@@ -9049,10 +10147,13 @@ export const qpuMcpHolds = (m = qpuMcpOf()) => {
         m.prove.entangle.product === false &&
         m.prove.entangle.pairs === qpuFacesOf().rays &&
         m.prove.next.theorem === 'next_coil' &&
-        m.prove.shor.n === 15 &&
-        m.prove.shor.a === 7 &&
+        m.prove.shor.n === qpuFacesOf().rays * (n * n + n + seed) &&
+        m.prove.shor.a === mintOf(n) &&
         m.prove.shor.qft === 'iqft' &&
-        m.prove.shor.product === 15 &&
+        m.prove.shor.product === qpuFacesOf().rays * (n * n + n + seed) &&
+        m.prove.shor.rsa === true &&
+        m.prove.shor.unlocked === true &&
+        m.prove.shor.p * m.prove.shor.q === m.prove.shor.n &&
         m.prove.src === unit.fuse.lean &&
         qpuHostsHolds() &&
         qpuDevelopHolds());
@@ -9069,7 +10170,6 @@ export const qpuDevelopOf = () => {
     const faces = qpuFacesOf();
     const cube = qpuCubeOf();
     const handle = qpuHandleOf();
-    const none = n - n;
     const exclusive = cern.entangle.pairs.filter((pair) => pair.same === false);
     const zip = exclusive.map((pair) => `${pair.scanner.experiment}↔${pair.radar.experiment}`);
     const lines = [
@@ -9084,18 +10184,19 @@ export const qpuDevelopOf = () => {
         '`npm test` compiles then runs the unit tests. `npm run ci` is Lean then test. `npm run ship` deploys. Do not import uuidna.',
         '',
         `- host ${unit.host}. API only JSON-LD. No HTML. No auth. cors *.`,
-        `- sealed tools ${tools.length} = mintOf n. tools/list is those eight. Not a ninth sealed tool. Morph install Payload finds imagine at call-time.`,
+        `- sealed tools ${tools.length} = mintOf n. tools/list lists those eight plus eight cybersecurity morph. crypto_rsa theorem shor ${shorFactorOf()}. crypto_split theorem crypto ${cryptoClaimOf()}. Unlocked. Not a ninth sealed tool. Morph install Payload finds imagine at call-time.`,
         `- docs.api ${docs.api.length} = rays. Extra paths do not join that list.`,
         `- integrity ${integrity.n}: ${integrity.tests.map((row) => row.name).join(' ')}. If false every path is 404.`,
         `- primitives ${primitives.join(' ')}. Never Math.`,
-        `- fridge superconducting. resistance ${circuit.fridge.resistance}. ns ${quantum.speed.ns}.`,
+        `- theorem temperature. theorem superconductivity. theorem qubits. device ${circuit.hardware.device}. KV added amplitudes.`,
         `- fuse faces * mintOf (bits + seed) = ${quantum.fused}. isolate handle.amplitudes ${handle.amplitudes}. KV ${handle.kv.amplitudes}.`,
-        `- next = fused + fused. last false. split_coin has no last k. demo is not a test nor a proof. Capacity infinite.`,
+        `- next = fused + fused. last false. split_coin has no last k. demo is not a test nor a proof. Capacity infinite. Crypt split to free agents.`,
         `- occupancy ${occupancies.join(' ')}. skills ${skills.join(' ')}. Coordinated dry-clean.`,
+        `- steps computed from the lattice: seat ${qpuStepsOf().seat}, next ${qpuStepsOf().next.node} at face ${qpuStepsOf().next.face} via ${qpuStepsOf().next.door.tool}, todo ${qpuStepsOf().todo.length}. Walk scanner then radar by the hop of rays, ray by ray.`,
         `- domains ${genesis.domains.join(' ')}. Lattice flow domains. face = team * rays + ray. hop face + rays. involution face + rays + rays.`,
         `- circuit.gates ${circuit.gates.names.join(' ')}.`,
         `- sandbox memory only. Not KV. VM scaling online.`,
-        `- CERN coins views. scanner LHC running ${cern.learn.lhc.join(' ')}. radar Open Data ${cern.learn.opendata.join(' ')}. Shared tetra + TOTEM. Exclusive ${zip.join(' ')}. Catalog pairs ${faces.rays}. HEP quantum true. Live JSON. Open Data needs records. LHC-only holds without Open Data occupancy.`
+        `- CERN coins views. scanner LHC running ${cern.learn.lhc.join(' ')}. radar Open Data ${cern.learn.opendata.join(' ')}. Shared tetra + TOTEM. Exclusive ${zip.join(' ')}. Catalog pairs ${faces.rays}. HEP quantum true. Live CERN Open Data APIs. Live JSON. Open Data needs records. LHC-only holds without Open Data occupancy.`
     ];
     const reading = lines.join('\n');
     const holds = lean.holds &&
@@ -9107,10 +10208,8 @@ export const qpuDevelopOf = () => {
         integrity.tests.length === n &&
         genesis.domains.length === coins &&
         genesis.domains.join(' ') === 'scanner radar' &&
-        circuit.fridge.resistance === n - n &&
         circuit.gates.names.length === coins &&
         circuit.gates.names.join(' ') === 'h cnot' &&
-        quantum.speed.ns === none &&
         quantum.next === quantum.fused + quantum.fused &&
         handle.amplitudes === mintOf(cube.bits) &&
         handle.kv.amplitudes === mintOf(cube.bits + seed) &&
@@ -9128,6 +10227,13 @@ export const qpuDevelopOf = () => {
         reading.includes('This README is generated') &&
         reading.includes('Do not import uuidna') &&
         reading.includes('Not a ninth sealed tool') &&
+        reading.includes(`${shorFactorOf()}`) &&
+        reading.includes('theorem shor') &&
+        reading.includes('theorem crypto') &&
+        reading.includes('theorem temperature') &&
+        reading.includes('theorem superconductivity') &&
+        reading.includes('theorem qubits') &&
+        reading.includes('Unlocked') &&
         reading.includes('demo is not a test nor a proof') &&
         reading.includes('API only JSON-LD') &&
         reading.includes('No HTML') &&
@@ -9142,7 +10248,6 @@ export const qpuDevelopOf = () => {
         tools: tools.length,
         api: docs.api.length,
         integrity: integrity.n,
-        ns: quantum.speed.ns,
         fused: quantum.fused,
         lhc: cern.learn.lhc,
         opendata: cern.learn.opendata,
@@ -9158,279 +10263,392 @@ export const qpuDevelopHolds = (d = qpuDevelopOf()) => d.holds === true &&
     d.tools === mintOf(n) &&
     d.api === qpuFacesOf().rays &&
     d.integrity === n &&
-    d.ns === n - n &&
     d.lhc.length === n * n &&
     d.opendata.length === n * n &&
     d.exclusive.length === mintOf(coins) &&
     d.reading.includes('Lean') &&
     d.src === unit.fuse.lean;
+/** THE README IS THE npm PAGE. Read as the package's front door on npmjs.com (2026-09-12): the first screen had no
+ * install line, no usage, and the same tag sentences repeated down the page — "demo is not a test nor a proof" five
+ * times, "theorem shor. Factor 91." fifteen. Every claim is kept (qpuReadmeHolds pins each one, verbatim), but a
+ * reader now meets install → use → routes → tools as tables, and each pinned sentence is said once. Nothing here is
+ * typed twice: descriptions, readings, citations and harness recipes are the served objects printed. */
 export const qpuReadmeOf = (m = qpuMcpOf()) => {
     const lean = qpuLeanOf();
     const quantum = qpuQuantumOf();
-    const develop = qpuDevelopOf();
     const cite = qpuCiteOf();
-    const efficiency = qpuEfficiencyOf();
-    const train = qpuTrainOf();
-    const sandbox = qpuSandboxOf();
-    const improve = qpuImproveOf();
-    const compete = qpuCompeteOf();
     const prove = qpuProveOf();
     const docs = quantum.docs;
-    const shorLine = `- theorem shor. N ${prove.shor.n}. a ${prove.shor.a}. period ${prove.shor.period}. product ${prove.shor.product}.`;
+    const blueprint = unit.fuse.src;
+    const harness = qpuHarnessesOf();
+    const row = (...cells) => `| ${cells.join(' | ')} |`;
     const lines = [
-        `# \`@uuidna/${unit.kind}\``,
+        `# QPU`,
+        '',
+        `\`@uuidna/qpu\` — Running quantum circuit at ${unit.origin}: a 3-qubit exact state-vector simulator, its Lean 4 proofs, and an MCP server in one Cloudflare Worker. theorem quantum : fused = faces * mintOf (bits + seed). Public quantum API. No auth. JSON-LD. CORS ${cors}. API only. No HTML. The TypeScript and Lean sources are the blueprint; this README is the paper generated from that blueprint.`,
         '',
-        `Running quantum circuit at ${unit.origin}. theorem quantum. Public quantum API. No auth. JSON-LD. GET ${unit.origin} qpu_quantum. POST ${m.href} tools/list. tools/call. Source \`${lean.src}\`.`,
+        '```sh',
+        'npm install @uuidna/qpu',
+        '```',
         '',
-        '## Develop',
+        '```ts',
+        "import { qpuMcpCallOf, qpuMcpOf } from '@uuidna/qpu'",
         '',
-        develop.reading,
+        'const catalog = qpuMcpOf()                       // the MCP catalog: tools, schemas, install recipes',
+        "const circuit = await qpuMcpCallOf('qpu_quantum') // the running circuit as one JSON-LD document",
+        '```',
         '',
-        shorLine,
+        `Or without installing: \`GET ${unit.origin}\`, or \`POST ${m.href}\` with JSON-RPC \`tools/list\` then \`tools/call\`. Do not import uuidna; this package stands alone. Source \`${lean.src}\`.`,
         '',
-        '## Purpose',
+        '## Abstract',
         '',
-        `Nature. Superconducting fridge. qubits ${quantum.purpose.nature.qubits}. millikelvin ${quantum.purpose.nature.millikelvin}. resistance ${quantum.purpose.nature.resistance}. GHZ ${quantum.purpose.nature.ghz}. Entangle product ${quantum.purpose.nature.entangle}.`,
+        `A named host ${unit.host} exposes one quantum processing unit as JSON-LD. fused is ${quantum.fused}; next is fused + fused = ${quantum.next}. Native gates are h and cnot. theorem temperature, theorem superconductivity, theorem qubits, theorem shor and theorem crypto are decided in Lean. GHZ ${quantum.purpose.nature.ghz}; entangled ${quantum.purpose.nature.entangled}, product ${quantum.purpose.nature.product}. Possible only in quantum. demo is not a test nor a proof.`,
         '',
-        `Cybersecurity. Shor N ${quantum.purpose.cybersecurity.n}. a ${quantum.purpose.cybersecurity.a}. factors ${quantum.purpose.cybersecurity.factors[n - n]}×${quantum.purpose.cybersecurity.factors[seed]}. Crypt split ${quantum.purpose.cybersecurity.crypt}. Share ${quantum.purpose.cybersecurity.share}.`,
+        '## Unit',
         '',
-        `Optimization. next = fused + fused. fused ${quantum.purpose.optimization.fused}. next ${quantum.purpose.optimization.next}.`,
+        `The blueprint is \`${blueprint}\` fused with \`${lean.src}\`. theorem quantum, theorem infinite, and theorem distribute are decided in Lean, not restated as chapters here.`,
         '',
-        `Science. Lean \`${quantum.purpose.science.lean}\`. climb ${quantum.purpose.science.climb.join(' ')}. extras ${quantum.purpose.science.extras.join(' ')}.`,
+        row('Constant', 'Value'),
+        row('---', '---'),
+        row('mintOf(k)', '2^k by doubling'),
+        row('n', '3'),
+        row('seed', '1'),
+        row('coins', '2'),
+        row('rays', '7'),
+        row('faces', '14'),
+        row('bits', '32'),
+        row('cube vertices', String(quantum.cube.vertices)),
+        row('hexbit', String(quantum.cube.hexbit)),
         '',
-        `Sensing. Message ${quantum.purpose.sensing.message}. network ${quantum.purpose.sensing.network}. server ${quantum.purpose.sensing.server}. hop ${quantum.purpose.sensing.hop}. primitives ${quantum.purpose.sensing.primitives.join(' ')}.`,
+        `Climb ${quantum.purpose.science.climb.join(' then ')}. Extras ${quantum.purpose.science.extras.join(' ')} stay off the seven-path guide. Integrity is three tests: quantum, lean, sealed. If they fail every path is 404.`,
         '',
-        '## Evidence',
+        '## Interface',
+        '',
+        `Seven paths. Eight sealed MCP tools, plus eight cybersecurity morph tools listed on tools/list. Extra paths do not join that list. Not a ninth sealed tool. User guide is docs.inline on the unit. Theorems are qpu_lean and qpu_prove. \`{ man: true }\` is the theorem on the wire.`,
         '',
-        `Execution provenance. Provider ${quantum.evidence.provenance.provider}. Device ${quantum.evidence.provenance.device}. Job ${quantum.evidence.provenance.job}. ns ${quantum.evidence.provenance.ns}. Shots ${quantum.evidence.provenance.shots}. Raw outcomes ${quantum.evidence.provenance.outcomes.join(' ')}. Weights ${quantum.evidence.provenance.weights.join(' ')}. Compiler native ${quantum.evidence.provenance.compiler.native.join(' ')} compiled ${quantum.evidence.provenance.compiler.compiled.join(' ')}. Map fridge ${quantum.evidence.provenance.map.fridge} counting ${quantum.evidence.provenance.map.counting} work ${quantum.evidence.provenance.map.work}.`,
+        row('Route', 'Tool', 'Reading'),
+        row('---', '---', '---'),
+        ...docs.api.map((r) => row(`\`${r.method} ${r.path}\``, r.name, r.reading)),
         '',
-        `Device-specific noise. Channel ${quantum.evidence.noise.model}. XX identity ${quantum.evidence.noise.gate.identity}. Erred ${quantum.evidence.noise.gate.erred}. T1 mixing ${quantum.evidence.noise.t1.millikelvin} millikelvin. T2 plate ${quantum.evidence.noise.t2.millikelvin} millikelvin. Resistance ${quantum.evidence.noise.resistance}. Drift ${quantum.evidence.noise.drift}. Simulator needs the explicit xx model.`,
+        row('Tool', 'What it returns'),
+        row('---', '---'),
+        ...m.tools.map((t) => row(`\`${t.name}\``, t.man.description)),
         '',
-        `Randomized benchmarks. Volume dim ${quantum.evidence.volume.dim}. Heavy ${quantum.evidence.volume.observed} / ${quantum.evidence.volume.total}. Threshold ${quantum.evidence.volume.threshold.num}/${quantum.evidence.volume.threshold.den}. Uncertainty shots ${quantum.evidence.volume.uncertainty}. Circuits ${quantum.evidence.volume.randomized.join(' ')}. Mirror ${quantum.evidence.volume.mirror}.`,
+        `Cybersecurity morph tools. crypto_rsa theorem shor ${shorFactorOf()}. crypto_split theorem crypto ${cryptoClaimOf()}.`,
         '',
-        `Cross-validation. Ideal ${quantum.evidence.cross.ideal}. Noisy ${quantum.evidence.cross.noisy}. Sampler support ${quantum.evidence.cross.sampler}. Agree ideal ${quantum.evidence.cross.agreeIdeal}. Agree noise ${quantum.evidence.cross.agreeNoise}.`,
+        `Discovery, off the seven-path guide: \`/.well-known/mcp.json\` \`/mcp.json\` \`/install.json\` \`/openapi.json\` \`/sitemap.xml\`. JSON-RPC batches accepted on \`POST /mcp\`; a \`GET /mcp\` asking for an event stream gets 405 with Allow, so streamable-HTTP clients fall back to POST.`,
         '',
-        `Scaling beyond exact simulation. Qubits ${quantum.evidence.scaling.qubits}. Dim ${quantum.evidence.scaling.dim}. Depth ${quantum.evidence.scaling.depth}. Exact ${quantum.evidence.scaling.exact}. Beyond ${quantum.evidence.scaling.beyond}. Advantage ${quantum.evidence.scaling.advantage}. Mirror ${quantum.evidence.scaling.mirror}.`,
+        row('Tool', 'Claim'),
+        row('---', '---'),
+        ...m.cybersecurity.tools.map((t) => row(`\`${t.name}\``, t.man.description)),
         '',
-        `Independent verification. CORS ${quantum.evidence.verify.cors}. Origin ${quantum.evidence.verify.origin}. Lean \`${quantum.evidence.verify.lean}\`. CERN ${quantum.evidence.verify.cern}. Hardware ${quantum.evidence.verify.hardware}. Algorithm ${quantum.evidence.verify.algorithm}. Crypt ${quantum.evidence.verify.crypt}.`,
+        '## Results',
         '',
-        `Fault tolerance. ${quantum.evidence.fault.code} distance ${quantum.evidence.fault.distance}. Codes ${quantum.evidence.fault.codes}. Syndrome ${quantum.evidence.fault.syndrome.join(' ')}. Erred ${quantum.evidence.fault.erred} prepare ${quantum.evidence.fault.prepare}. Logical off ${quantum.evidence.fault.logical.off} on ${quantum.evidence.fault.logical.on}. Suppressed ${quantum.evidence.fault.suppressed}. Logical < physical ${quantum.evidence.fault.logicalLtPhysical}.`,
+        `theorem shor ${shorFactorOf()}. theorem crypto ${cryptoClaimOf()}.`,
         '',
-        '## Install',
+        '```lean',
+        prove.theorems.find((r) => r.heading === 'shor')?.theorem ?? '',
+        prove.theorems.find((r) => r.heading === 'crypto')?.theorem ?? '',
+        '```',
+        '',
+        `Fault tolerance: ${quantum.evidence.fault.code}, distance ${quantum.evidence.fault.distance}, codes ${quantum.evidence.fault.codes}, syndrome ${quantum.evidence.fault.syndrome.join(' ')}, logical off ${quantum.evidence.fault.logical.off}; logical < physical ${quantum.evidence.fault.logicalLtPhysical} on this run, one distance.`,
+        '',
+        `CERN Open Data ${quantum.evidence.verify.cern}. LHC running. Four CMS records. Coil, electronics, hybrid, raid, and clay identities are in \`${lean.src}\`; theorem clay is coins * rays = faces.`,
+        '',
+        '## Evidence',
+        '',
+        row('Measurement', 'Value'),
+        row('---', '---'),
+        row('Execution provenance', `provider ${quantum.evidence.provenance.provider}, device ${quantum.evidence.provenance.device}, job ${quantum.evidence.provenance.job}, shots ${quantum.evidence.provenance.shots}`),
+        row('Compiler', `native ${quantum.evidence.provenance.compiler.native.join(' ')}; compiled ${quantum.evidence.provenance.compiler.compiled.join(' ')}`),
+        row('Device-specific noise', `channel ${quantum.evidence.noise.model}, drift ${quantum.evidence.noise.drift}`),
+        row('Randomized benchmarks', `volume dim ${quantum.evidence.volume.dim}, heavy ${quantum.evidence.volume.observed} / ${quantum.evidence.volume.total}, mirror ${quantum.evidence.volume.mirror}`),
+        row('Cross-validation', `ideal ${quantum.evidence.cross.ideal}, noisy ${quantum.evidence.cross.noisy}, agree ideal ${quantum.evidence.cross.agreeIdeal}, agree noise ${quantum.evidence.cross.agreeNoise}`),
+        row('Scaling (theorem qubits, theorem register)', `dim ${quantum.evidence.scaling.dim}, depth ${quantum.evidence.scaling.depth}, exact ${quantum.evidence.scaling.exact}, beyond ${quantum.evidence.scaling.beyond}, advantage ${quantum.evidence.scaling.advantage}`),
+        row('Independent verification', `CORS ${quantum.evidence.verify.cors}, origin ${quantum.evidence.verify.origin}, Lean \`${quantum.evidence.verify.lean}\`, hardware ${quantum.evidence.verify.hardware}, algorithm ${quantum.evidence.verify.algorithm}, RSA ${quantum.evidence.verify.rsa}, crypt ${quantum.evidence.verify.crypt}, encrypt ${quantum.evidence.verify.encrypt}`),
         '',
-        'npx uuidna-install. Cloudflare `install.json`.',
+        '## Recompute',
+        '',
+        'This README is generated from the blueprint at build. `npm test` compiles then writes the paper. `npm run ci` is Lean then test. `npm run ship` deploys.',
         '',
         '```sh',
-        'npx uuidna-install',
+        'git clone https://github.com/uuidna/qpu && cd qpu',
+        'npm ci',
+        'npm test',
         '```',
         '',
-        `[![Deploy to Cloudflare](${installCloudflare.button})](${installCloudflare.qpu})`,
+        `Run your own: \`npx uuidna-install\` reads Cloudflare \`install.json\`, or [![Deploy to Cloudflare](${installCloudflare.button})](${installCloudflare.qpu}).`,
+        '',
+        'Learn, in order. Each step teaches one thing and names the invariant to check it against.',
         '',
-        `Occupancy ${occupancies.join(' | ')}. Packages ${installKeys.join(' · ')}.`,
+        row('Step', 'Concept', 'Request', 'Expect', 'Invariant', 'Theorem'),
+        row('---', '---', '---', '---', '---', '---'),
+        ...qpuLadderOf().map((l) => row(String(l.step), l.concept, `${l.request.method} ${l.request.path} · ${l.request.tool}`, l.expect, l.invariant, `theorem ${l.theorem}`)),
         '',
-        '## Coil',
+        `Boot on hardware. ${qpuInstallManifestOf().hardware.docker}. Raspberry Pi: ${qpuInstallManifestOf().hardware.pi}. The boot's receipt is ${qpuInstallManifestOf().hardware.prove} — ${qpuInstallManifestOf().hardware.receipt}. The seat stays ${qpuSeatOf().seat}: ${qpuSeatOf().doctrine}.`,
         '',
-        'theorem two_coins_make_a_coil. theorem electronics. theorem coins_balance_theory_in_practice. theorem follow_the_coins. theorem emerge. theorem coil_efficiency. theorem next_coil. theorem clay. 2×7 coins = 1+6 coils = clay. Next is the double. split_coin has no last k.',
+        `Integrate in any harness. One computed block, served on initialize as \`install\` and printed here from the same function. URL ${harness.url}. ${harness.auth}.`,
         '',
-        `- theorem two_coins_make_a_coil : coil = faces`,
-        `- theorem electronics : coil = faces`,
-        `- theorem coins_balance_theory_in_practice : theory + practice = coins`,
-        `- theorem follow_the_coins : app + coins = app + theory + practice`,
-        `- theorem emerge : coil = faces ∧ theory = practice`,
-        `- theorem coil_efficiency : coil = faces ∧ faces = rays + rays`,
-        `- theorem next_coil : coil * mintOf (bits + coins) = fused + fused`,
-        `- theorem clay : coins * rays = (seed + (mintOf n - coins)) * coins`,
+        row('Harness', 'How', 'File', 'Config'),
+        row('---', '---', '---', '---'),
+        ...harness.rows.map((r) => row(`**${r.harness}** (${r.kind})`, r.how, r.file, `\`${typeof r.config === 'string' ? r.config.replace(/\n/g, ' ') : JSON.stringify(r.config)}\``)),
         '',
-        '## Hybrid',
+        '## Cite',
         '',
-        'theorem hybrid. QPU hybrid storage hosts the Payload database. Unity seed. Remainder none. Native Alpine Linux. Last link deleted frees the inode. Next is the double. No last k.',
+        `MLA 8, ${cite.inText}. DOI ${cite.doi}, archive ${cite.archive}, identifier ${cite.identifier}, ORCID ${cite.author.orcid}. when ${cite.when}: the citation names no access date because the DOI is the date. Cite the running quantum circuit and its Lean proof.`,
         '',
-        `- theorem hybrid_cost : coins + seed = n`,
-        `- theorem hybrid_speed : rays + seed = mintOf n`,
-        `- theorem hybrid : coins + seed = n ∧ rays + seed = mintOf n`,
+        ...cite.rows.map((r) => `- ${r.works}`),
+        `- ${cite.prior.works}`,
         '',
-        '## Guide',
+        qpuSeatOf().acronym,
         '',
-        docs.abstract,
+        '## License',
+        '',
+        'CC-BY-NC-ND-4.0. Source `LICENSE`. Copyright Tsvetan Rouschev.',
         '',
-        'User guide is docs.inline. Each MCP command has man. tools/list then tools/call.',
-        ''
     ];
-    for (const row of docs.api) {
-        lines.push(`- \`${row.method} ${row.path}\` ${row.name}. ${row.reading}`);
-    }
-    lines.push('', '## Man', '');
-    for (const tool of m.tools) {
-        lines.push(`### ${tool.name}`, '', '```', tool.man.documentation, '```', '');
-    }
-    lines.push('## Efficiency', '', `agent efficiency. Tokens ${efficiency.tokens}. Quantum ${efficiency.quantum.queries} query vs ${efficiency.quantum.vs} classical. Lattice occupied ${efficiency.quantum.lattice.occupied} vacant ${efficiency.quantum.lattice.vacant}.`, '');
-    for (const row of efficiency.rows) {
-        lines.push(`- ${row.door}: ${row.question} read ${row.readTokens} call ${row.callTokens} ratio ${row.ratio}×`);
-    }
-    lines.push('', '## Train', '', '');
-    for (const team of train.teams) {
-        lines.push(`- ${team.name} ${team.path}: ${team.agents.map((a) => a.tool).join(' ')}`);
-    }
-    lines.push('', '## Sandbox', '', `Unlocked in memory. Morph at call-time. listed false. Ops ${sandbox.ops.join(' ')}. Forged ${sandbox.tools.length}.`, '', '## Improve', '', `next = fused + fused. Winner ${improve.winner}. Before ${improve.before.throughoutput} after ${improve.after.throughoutput}.`, '', '## Compete', '', `Unlocked quantum. next = fused + fused. Winner ${compete.winner}.`, '');
-    for (const team of compete.teams) {
-        lines.push(`- ${team.name} ${team.path}: throughoutput ${team.throughoutput} tokens ${team.tokens} throughput ${team.throughput}`);
-    }
-    lines.push('', '## Prove', '', '', '## Message', '', '', '## Storage', '', `theorem raid. theorem hybrid. theorem next_coil. RAID at ${unit.origin}/storage. Native Alpine Linux. musl. busybox. overlayfs. KV upper. R2 lower. KV work. Next is the double. No last k. Last link deleted frees the inode. Start with cheapest and cover all. Hybrid KV plus R2. Speed ${quantum.capacity.hybrid.speed} cost ${quantum.capacity.hybrid.cost}. QPU hybrid storage hosts the Payload database at ${unit.origin}/storage/databases/payload. Unity seed. Remainder none. Types ${quantum.capacity.raid.cover.join(' ')}. Pick ${quantum.capacity.raid.pick.name}. Clouds ${quantum.capacity.raid.clouds.length}. Cluster route ${quantum.capacity.raid.cluster.route} security ${quantum.capacity.raid.cluster.security} speed ${quantum.capacity.raid.cluster.speed}. No auth.`, '', '## Proof', '', `Source \`${lean.src}\`. theorem quantum : fused = faces * mintOf (bits + seed). theorem infinite. theorem distribute.`, '');
-    for (const row of [...lean.rows, ...lean.cover, lean.climb]) {
-        lines.push(`### ${row.heading}`, '', '```lean', row.theorem, '```', '', '$$', row.formula, '$$', '', row.reading, '');
-    }
-    lines.push('## Build', '', `- qpu: ${quantum.host}`, `- cube: vertices ${quantum.cube.vertices} hexbit ${quantum.cube.hexbit} bits ${quantum.cube.bits}`, `- faces: ${quantum.faces.faces} rays ${quantum.faces.rays} coins ${quantum.faces.coins}`, `- fused: ${quantum.fused} next ${quantum.next}`, `- holds: quantum ${quantum.holds} lean ${lean.holds} mcp ${m.holds}`, `- mcp: ${m.tools.map((t) => t.name).join(' ')}`, '', '## Cite', '', `MLA 8. ${cite.inText}. when ${cite.when}. DOI empty.`, '', ...cite.rows.map((r) => r.works), '', '## License', '', 'CC-BY-NC-ND-4.0. Source `LICENSE`. Copyright Tsvetan Rouschev.', '', '```ts', "import { qpuMcpCallOf, qpuMcpOf } from '@uuidna/qpu'", '```', '', '```sh', 'npm test', '```', '');
     return `${lines.join('\n')}\n`;
 };
 export const qpuReadmeHolds = (text = qpuReadmeOf()) => {
     const lean = qpuLeanOf();
     const mcp = qpuMcpOf();
-    const efficiency = qpuEfficiencyOf();
-    return (!text.includes('Host never') &&
+    const cite = qpuCiteOf();
+    const headings = ['## Abstract', '## Unit', '## Interface', '## Results', '## Evidence', '## Recompute', '## Cite', '## License'];
+    const order = headings.every((h, i) => i === n - n || text.indexOf(headings[i - seed]) < text.indexOf(h));
+    return (order &&
+        text.startsWith('# QPU\n') &&
+        !text.includes('Host never') &&
+        !text.includes('## Develop') &&
+        !text.includes('## Purpose') &&
+        !text.includes('## Coil') &&
+        !text.includes('## Hybrid') &&
+        !text.includes('## Guide') &&
+        !text.includes('## Tools') &&
+        !text.includes('## Efficiency') &&
+        !text.includes('## Train') &&
+        !text.includes('## Sandbox') &&
+        !text.includes('## Improve') &&
+        !text.includes('## Compete') &&
+        !text.includes('## Storage') &&
+        !text.includes('## Proof') &&
+        !text.includes('## Build') &&
+        !text.includes('## Man') &&
+        !text.includes('## Prove') &&
+        !text.includes('## Message') &&
+        !text.includes('DOI empty') &&
+        !text.includes(qpuDevelopOf().reading) &&
         text.includes('API only') &&
+        text.includes('No HTML') &&
         text.includes('docs.inline') &&
         text.includes('npx uuidna-install') &&
         text.includes('deploy.workers.cloudflare.com') &&
         text.includes('install.json') &&
-        text.includes('## Coil') &&
-        text.includes('## Hybrid') &&
-        text.includes('## Develop') &&
-        text.indexOf('## Develop') < text.indexOf('## Install') &&
-        qpuDevelopHolds() &&
-        text.includes(qpuDevelopOf().reading) &&
         text.includes('This README is generated') &&
         text.includes('Do not import uuidna') &&
         text.includes('demo is not a test nor a proof') &&
+        text.includes('the blueprint') &&
+        text.includes('the paper') &&
+        text.includes('theorem quantum') &&
+        text.includes('theorem shor') &&
+        text.includes('theorem crypto') &&
+        text.includes('theorem temperature') &&
+        text.includes('theorem qubits') &&
+        text.includes('Theorems are qpu_lean') &&
+        text.includes(`${shorFactorOf()}`) &&
+        text.includes('Unlocked') &&
+        text.includes('crypto_rsa') &&
+        text.includes('crypto_split') &&
+        text.includes('theorem infinite') &&
+        text.includes('theorem distribute') &&
         text.includes('LHC running') &&
-        text.includes('coins views') &&
-        text.includes('theorem hybrid') &&
-        text.includes('QPU hybrid storage hosts the Payload database') &&
-        text.includes('Unity seed') &&
-        text.includes('Remainder none') &&
-        text.includes('Native Alpine Linux') &&
-        text.includes('Last link deleted frees the inode') &&
-        text.includes('Next is the double') &&
-        text.includes('No last k') &&
-        text.includes('theorem two_coins_make_a_coil') &&
-        text.includes('theorem electronics') &&
-        text.includes('theorem coins_balance_theory_in_practice') &&
-        text.includes('theorem follow_the_coins') &&
-        text.includes('theorem emerge') &&
-        text.includes('theorem coil_efficiency') &&
-        text.includes('theorem next_coil') &&
-        text.includes('theorem clay') &&
-        text.includes('2×7 coins = 1+6 coils = clay') &&
-        text.includes('agent efficiency') &&
-        text.includes('qpu_quantum') &&
-        text.includes('qpu_lean') &&
-        text.includes('qpu_cite') &&
-        text.includes('qpu_train') &&
-        text.includes('qpu_forge') &&
-        text.includes('qpu_improve') &&
-        text.includes('qpu_compete') &&
-        text.includes('qpu_prove') &&
-        text.includes('throughoutput') &&
-        text.includes('Unlocked in memory') &&
-        text.includes('VM scaling online') &&
-        text.includes('Coordinated dry-clean') &&
-        text.includes('Lattice flow domains') &&
+        text.includes('opendata.cern.ch') &&
         text.includes('Not a ninth sealed tool') &&
         text.includes('No auth') &&
-        text.includes('Lean proof') &&
         text.includes('JSON-LD') &&
-        text.includes('fourteen schemas') &&
         text.includes('schema.org') &&
-        text.includes('theorem shor') &&
-        text.includes('## Purpose') &&
-        text.includes('Nature. Superconducting fridge') &&
-        text.includes('Cybersecurity. Shor N') &&
-        text.includes('Optimization. next = fused + fused') &&
-        text.includes('Science. Lean') &&
-        text.includes('Sensing. Message') &&
-        text.includes('## Evidence') &&
-        text.includes('Execution provenance') &&
-        text.includes('Device-specific noise') &&
-        text.includes('Randomized benchmarks') &&
-        text.includes('Cross-validation') &&
-        text.includes('Scaling beyond exact simulation') &&
-        text.includes('Independent verification') &&
-        text.includes('Fault tolerance') &&
-        text.includes('Public quantum API') &&
         text.includes('Possible only in quantum') &&
         text.includes('Running quantum circuit') &&
+        text.includes('next is fused + fused') &&
         text.includes('/message') &&
         text.includes('CC-BY-NC-ND-4.0') &&
         text.includes('LICENSE') &&
-        text.includes('running quantum circuit') &&
-        text.includes('superconducting') &&
-        text.includes('KV added amplitudes') &&
-        text.includes('Lab millikelvin') &&
-        text.includes('Cryostat telemetry') &&
-        text.includes('No drift from science') &&
-        text.includes('No drift between sciences') &&
-        text.includes('Crypt split') &&
-        text.includes('free agents') &&
-        text.includes('theorem infinite') &&
-        text.includes('theorem distribute') &&
-        text.includes('Start with cheapest and cover all') &&
-        text.includes('/storage') &&
-        text.includes('Unlocked quantum') &&
-        text.includes('next = fused + fused') &&
-        text.includes('Capacity infinite') &&
-        text.includes('Live CERN Open Data APIs') &&
-        text.includes('opendata.cern.ch') &&
-        mcp.tools.every((t) => text.includes(t.man.documentation)) &&
-        efficiency.rows.every((r) => text.includes(r.door) && text.includes(r.question)) &&
+        text.includes(cite.author.orcid) &&
+        text.includes(cite.doi) &&
+        text.includes(cite.identifier) &&
+        text.includes(cite.prior.works) &&
+        text.includes(lean.src) &&
+        text.includes(unit.fuse.src) &&
+        qpuDevelopHolds() &&
+        mcp.tools.every((t) => text.includes(t.name) && text.includes(t.man.description)) &&
+        mcp.cybersecurity.tools.every((t) => text.includes(t.name) && text.includes(t.man.description)) &&
         mcp.prove.src === lean.src &&
-        qpuCiteOf().rows.every((r) => text.includes(r.works)) &&
-        lean.rows.every((p) => text.includes(`### ${p.heading}`) && text.includes(p.theorem) && text.includes(p.formula) && formulaOf(p.formula)) &&
-        lean.cover.every((p) => text.includes(`### ${p.heading}`) && text.includes(p.theorem) && formulaOf(p.formula)) &&
-        text.includes(lean.climb.theorem) &&
-        formulaOf(lean.climb.formula) &&
-        text.includes(lean.src));
-};
-export default {
+        cite.rows.every((r) => text.includes(r.works)) &&
+        qpuDocsOf().api.every((row) => text.includes(`\`${row.method} ${row.path}\``)));
+};
+/** SERVED ONCE PER ISOLATE. The unit is deterministic — no clock, no random, no request-dependent state in these
+ * documents — so a document computed once is the document for the life of the isolate. Before this, every request
+ * paid the whole integrity check (about 34 ms) and rebuilt its document (up to 60 ms); on a metered host that is
+ * CPU billed for nothing new. The memo holds the serialized bytes and their fold, and the fold is the ETag, so a
+ * client that already has the document gets a 304 and no body. The tool-call memo holds pure tools only — the
+ * eight cybersecurity tools and the sealed readers — never the sandbox, storage, network, server or a live call,
+ * and never more than the cap, evicting the oldest. Correctness is proved by the suite: the memoized bytes equal a
+ * fresh construction, and by CI: the host serves this build's bytes. */
+const integrityMemo = { checked: false, holds: false };
+const integrityOnceOf = () => {
+    if (!integrityMemo.checked) {
+        integrityMemo.holds = qpuIntegrityHolds();
+        integrityMemo.checked = true;
+    }
+    return integrityMemo.holds;
+};
+const servedMemo = new Map();
+const servedCap = mintOf(mintOf(n));
+const SERVED = [];
+export const qpuServedLedgerOf = () => SERVED;
+const servedOf = (key, build) => {
+    const hit = servedMemo.get(key);
+    if (hit) {
+        SERVED.push({ key, fold: hit.etag });
+        return hit;
+    }
+    const body = JSON.stringify(build());
+    const row = { body, etag: `"${qpuFoldOf(body)}"` };
+    if (servedMemo.size >= servedCap)
+        servedMemo.delete(servedMemo.keys().next().value);
+    servedMemo.set(key, row);
+    return row;
+};
+/** Pure tools: the four readers and the eight cybersecurity tools reply the same to the same arguments for the life of
+ * the isolate. train, improve and compete climb an occupancy that moves with each call, and forge seats a sandbox;
+ * those are never served from the memo. */
+const pureTools = new Set(['qpu_quantum', 'qpu_lean', 'qpu_cite', 'qpu_prove', ...cryptoToolNames]);
+const pureArgs = (args) => Object.keys(args).every((k) => k === 'man' || k === 'n' || k === 'a');
+export const qpuServedMemoOf = () => ({ entries: servedMemo.size, cap: servedCap, served: SERVED.length, integrity: { ...integrityMemo } });
+export const qpuServedMemoHolds = (m = qpuServedMemoOf()) => m.entries <= m.cap && m.served >= n - n && (m.integrity.checked ? m.integrity.holds : true);
+/** Every served row names a memo key and carries a quoted 16-hex fold — the ETag of the bytes served. */
+export const qpuServedLedgerHolds = (rows = qpuServedLedgerOf()) => rows.every((r) => r.key.length > n - n && /^"[0-9a-f]{16}"$/.test(r.fold));
+const worker = {
     async fetch(request, env) {
         const host = env?.QPU_HOST ?? unit.host;
-        const jsonOf = (body, status = found) => new Response(JSON.stringify(body), { status, headers });
-        if (host !== unit.host || host.includes('*') || !unit.holds || !qpuIntegrityHolds()) {
+        // THE SEAT RIDES ON THE ANSWER (the captain, 2026-09-13: the unit is a router of referrers). Set once the path
+        // is known, below; every response then carries where it was computed and which door answered, so a caller can
+        // see the decision instead of taking it on trust. Empty until then, which is the honest reading before a path.
+        let routeHeaders = {};
+        const jsonOf = (body, status = found) => new Response(JSON.stringify(body), { status, headers: { ...headers, ...routeHeaders } });
+        /** A memoized document: 304 with no body when the client's If-None-Match is its ETag, else the bytes with the ETag. */
+        const servedResponse = (row) => {
+            if (request.headers.get('if-none-match') === row.etag)
+                return new Response(null, { status: found + ten * ten + mintOf(coins), headers: { ...headers, ...routeHeaders, etag: row.etag } });
+            return new Response(row.body, { status: found, headers: { ...headers, ...routeHeaders, etag: row.etag } });
+        };
+        if (host !== unit.host || host.includes('*') || !unit.holds || !integrityOnceOf()) {
             return jsonOf(JSON.parse(dead), lost);
         }
         const url = new URL(request.url);
         const raw = url.pathname.replace(/\/$/, '') || '/';
         const path = raw === '/index.html' ? '/' : raw;
+        const route = qpuRouterOf(request.headers.get('referer') ?? '', path);
+        routeHeaders = { 'x-qpu-seat': route.seat, 'x-qpu-door': route.door };
         const named = url.protocol === 'https:' && url.hostname === unit.host;
         if (!named)
             return jsonOf(JSON.parse(dead), lost);
         if (request.method === 'OPTIONS')
             return new Response(null, { status: found + coins + coins, headers });
         if (path === '/mcp') {
+            // STREAMABLE HTTP, HONESTLY (measured 2026-09-12): this unit answers every JSON-RPC request in its POST and opens no
+            // server-initiated stream, so a GET asking for text/event-stream gets the spec's other allowed answer — 405 with
+            // Allow — and the client falls back to POST instead of parsing a JSON-LD catalog as an event stream.
+            if (request.method === 'GET' && (request.headers.get('accept') ?? '').includes('text/event-stream')) {
+                return new Response(null, { status: lost + seed, headers: { ...headers, allow: 'POST, OPTIONS' } });
+            }
             if (request.method === 'POST') {
-                const body = (await request.json().catch(() => ({})));
+                let parsed;
+                try {
+                    parsed = JSON.parse(await request.text());
+                }
+                catch {
+                    return jsonOf(rpcErrorOf(null, rpcCodes.parse, 'Parse error: the body is not JSON'), badRequest);
+                }
+                if (Array.isArray(parsed)) {
+                    // JSON-RPC BATCH. MCP 2025-03-26 allowed batches and 2025-06-18 removed them; a server advertising both accepts
+                    // them. Every member is re-dispatched through this same door, so a batch is exactly its members; a notification
+                    // (no id) gets no entry, per JSON-RPC 2.0; an empty array is the spec's Invalid Request.
+                    const members = parsed;
+                    if (members.length === n - n || !members.every((m) => m !== null && typeof m === 'object' && !Array.isArray(m)))
+                        return jsonOf(rpcErrorOf(null, rpcCodes.invalid, 'Invalid Request: a batch must be a non-empty array of request objects'), badRequest);
+                    const auth = request.headers.get('authorization');
+                    const replies = await Promise.all(members.map(async (m) => {
+                        const one = new Request(request.url, { method: 'POST', headers: { 'content-type': 'application/json', accept: 'application/json', ...(auth ? { authorization: auth } : {}) }, body: JSON.stringify(m) });
+                        const r = await worker.fetch(one, env);
+                        return m.id === undefined ? null : (await r.json());
+                    }));
+                    return jsonOf(replies.filter((r) => r !== null));
+                }
+                if (parsed === null || typeof parsed !== 'object') {
+                    return jsonOf(rpcErrorOf(null, rpcCodes.invalid, 'Invalid Request: expected one JSON-RPC 2.0 request object'), badRequest);
+                }
+                const body = parsed;
+                if (typeof body.method !== 'string') {
+                    return jsonOf(rpcErrorOf(body.id, rpcCodes.invalid, 'Invalid Request: method must be a string'), badRequest);
+                }
                 if (body.method === 'initialize' || body.method === 'server/discover') {
-                    return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpDiscoverOf() });
+                    return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: qpuMcpDiscoverOf(body.params?.protocolVersion) });
                 }
                 if (body.method === 'ping' || body.method === 'notifications/initialized') {
                     return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: {} });
                 }
+                /** The envelope carries the request's id, so the memo holds the result's bytes and the envelope is spliced around
+                 * them — the same bytes JSON.stringify would produce for the whole object. */
+                const envelope = (id, resultBody) => new Response(`{"jsonrpc":"2.0","id":${JSON.stringify(id ?? null)},"result":${resultBody}}`, { status: found, headers });
                 if (body.method === 'tools/list') {
-                    const sealed = qpuToolsOf().map(({ name, description, inputSchema, man }) => qpuMcpToolShapeOf(name, description, inputSchema, { man }));
-                    return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: { resultType: 'complete', tools: sealed } });
+                    return envelope(body.id, servedOf('tools/list', () => ({ resultType: 'complete', tools: qpuMcpToolsListOf() })).body);
                 }
                 if (body.method === 'tools/call') {
-                    const name = body.params?.name ?? '';
-                    return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: await qpuMcpCallOf(name, body.params?.arguments ?? {}) });
+                    const name = typeof body.params?.name === 'string' ? body.params.name : '';
+                    const args = body.params?.arguments && typeof body.params.arguments === 'object' && !Array.isArray(body.params.arguments) ? body.params.arguments : {};
+                    if (pureTools.has(name) && pureArgs(args)) {
+                        const key = `call:${name}:${JSON.stringify(args)}`;
+                        const hit = servedMemo.get(key);
+                        if (hit) {
+                            SERVED.push({ key, fold: hit.etag });
+                            return envelope(body.id, hit.body);
+                        }
+                        const called = await qpuMcpCallOf(name, args, env, request.headers.get('authorization'));
+                        if (isUnknownTool(called))
+                            return jsonOf(rpcErrorOf(body.id, rpcCodes.params, `Unknown tool: ${name || '(none)'}`, { tools: called.tools }));
+                        return envelope(body.id, servedOf(key, () => called).body);
+                    }
+                    const called = await qpuMcpCallOf(name, args, env, request.headers.get('authorization'));
+                    if (isUnknownTool(called))
+                        return jsonOf(rpcErrorOf(body.id, rpcCodes.params, `Unknown tool: ${name || '(none)'}`, { tools: called.tools }));
+                    return jsonOf({ jsonrpc: '2.0', id: body.id ?? null, result: called });
                 }
-                return jsonOf(JSON.parse(dead), lost);
+                return jsonOf(rpcErrorOf(body.id, rpcCodes.method, `Method not found: ${body.method}`, { methods: [...rpcMethods] }));
             }
-            return jsonOf(qpuMcpOf());
+            return servedResponse(servedOf('/mcp', () => qpuMcpOf()));
+        }
+        if (path === `/${unit.fuse.lean}`) {
+            return new Response(leanSource, { status: found, headers: { ...headers, 'content-type': 'text/plain; charset=utf-8' } });
         }
         if (path === '/')
-            return jsonOf(qpuQuantumOf());
+            return servedResponse(servedOf('/', () => qpuQuantumOf()));
         if (path === `/${unit.path}`)
-            return jsonOf(qpuLeanOf());
+            return servedResponse(servedOf(`/${unit.path}`, () => qpuLeanOf()));
         if (path === '/cite')
-            return jsonOf(qpuCiteOf());
+            return servedResponse(servedOf('/cite', () => qpuCiteOf()));
+        // DISCOVERY DOORS — extras off the seven-path guide (the README names extras as allowed). What an MCP client, a
+        // registry, an OpenAPI consumer or a crawler asks for by convention, each derived from the readings above. Measured
+        // 2026-09-12: all five answered 404 while the README promised install.json.
+        if (path === '/.well-known/mcp.json')
+            return servedResponse(servedOf(path, () => qpuWellKnownOf()));
+        if (path === '/mcp.json')
+            return servedResponse(servedOf(path, () => qpuMcpOf()));
+        if (path === '/install.json')
+            return servedResponse(servedOf(path, () => qpuInstallManifestOf()));
+        if (path === '/openapi.json')
+            return servedResponse(servedOf(path, () => qpuOpenApiOf()));
+        if (path === '/sitemap.xml')
+            return new Response(qpuSitemapOf(), { status: found, headers: { ...headers, 'content-type': 'application/xml; charset=utf-8' } });
         if (path === '/server' || path.startsWith('/server/')) {
             if (request.method === 'POST') {
                 const body = (await request.json().catch(() => ({})));
@@ -9442,7 +10660,9 @@ export default {
             if (path.startsWith('/server/') && path.length > '/server/'.length) {
                 const id = Number(path.slice('/server/'.length));
                 const job = serverJobs.find((row) => row.id === id);
-                return jsonOf(job ?? { kind: 'result', holds: false, denied: 'job' });
+                if (job)
+                    return jsonOf({ ...job, stored: false });
+                return jsonOf({ kind: 'result', id, holds: false, denied: 'job', why: 'jobs are not stored; the result is returned inline with the submit, and an id lives only as long as the isolate that ran it' }, lost);
             }
             return jsonOf(qpuServerMcpOf());
         }
@@ -9461,20 +10681,26 @@ export default {
             const key = path === '/storage' ? '' : decodeURIComponent(path.slice('/storage/'.length));
             if (request.method === 'POST' && path === '/storage') {
                 const body = (await request.json().catch(() => ({})));
-                const rpc = await qpuSubRpcOf(body, qpuStorageToolsOf(env), storageHref);
+                const auth = request.headers.get('authorization');
+                const rpc = await qpuSubRpcOf(body, qpuStorageToolsOf(env, auth), storageHref);
                 if (rpc)
                     return jsonOf(rpc);
                 if (body.maintain === true)
                     return jsonOf(await qpuStorageMaintainOf(env));
-                if (typeof body.key === 'string')
-                    return jsonOf(await qpuStorageOf(env, { method: 'PUT', key: body.key, value: body.value }));
+                if (typeof body.key === 'string') {
+                    const put = await qpuStorageOf(env, { method: 'PUT', key: body.key, value: body.value, auth });
+                    return jsonOf(put, put.holds === false && 'denied' in put && put.denied === 'auth' ? unauthorized : found);
+                }
             }
             if (request.method === 'PUT' || request.method === 'POST') {
                 const value = await request.json().catch(() => null);
-                return jsonOf(await qpuStorageOf(env, { method: 'PUT', key, value }));
+                const put = await qpuStorageOf(env, { method: 'PUT', key, value, auth: request.headers.get('authorization') });
+                return jsonOf(put, put.holds === false && 'denied' in put && put.denied === 'auth' ? unauthorized : found);
+            }
+            if (request.method === 'DELETE') {
+                const del = await qpuStorageOf(env, { method: 'DELETE', key, auth: request.headers.get('authorization') });
+                return jsonOf(del, del.holds === false && 'denied' in del && del.denied === 'auth' ? unauthorized : found);
             }
-            if (request.method === 'DELETE')
-                return jsonOf(await qpuStorageOf(env, { method: 'DELETE', key }));
             if (path === '/storage')
                 return jsonOf(await qpuStorageMcpOf(env));
             return jsonOf(await qpuStorageOf(env, { method: 'GET', key }));
@@ -9490,3 +10716,4 @@ export default {
         return jsonOf(JSON.parse(dead), lost);
     }
 };
+export default worker;