@uuidna/qpu 0.1.1 → 0.1.2

package/CITATION.cff

@@ -10,9 +10,9 @@ authors:
 url: https://qpu.uuidna.com
 repository-code: https://github.com/uuidna/qpu
 license: CC-BY-NC-ND-4.0
-version: 0.1.1
+version: 0.1.2
 identifiers:
-  - description: Archived version 0.1.1 at 4a45563
+  - description: Archived version 0.1.1 at 4a45563 (the host serves v0.1.2)
     type: doi
     value: 10.5281/zenodo.22717782
   - description: All versions

package/README.md

@@ -64,6 +64,8 @@ Seven paths. Eight sealed MCP tools, plus eight cybersecurity morph tools listed
 
 Cybersecurity morph tools. crypto_rsa theorem shor Factor 91. crypto_split theorem crypto Split identity true. Secrecy false.
 
+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.
+
 | Tool | Claim |
 | --- | --- |
 | `crypto_catalog` | theorem shor. theorem crypto. |
@@ -112,6 +114,17 @@ npm test
 
 Run your own: `npx uuidna-install` reads Cloudflare `install.json`, or [![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/qpu).
 
+Learn, in order. Each step teaches one thing and names the invariant to check it against.
+
+| Step | Concept | Request | Expect | Invariant | Theorem |
+| --- | --- | --- | --- | --- | --- |
+| 1 | one gate, exact amplitudes | GET / · qpu_quantum | Bell outcomes 00 and 11 at exactly 1/2 — Gaussian-integer amplitudes, no floats | H·H = I on |0⟩ | theorem qubits |
+| 2 | entanglement is not correlation | POST /mcp · qpu_prove | GHZ true; entangled true, product false — and a product state concentrates too, so concentration alone witnesses nothing | no-cloning and monogamy hold on the served states | theorem entangle |
+| 3 | Shor: a period, then a gcd | POST /mcp · crypto_shor | theorem shor Factor 91 — a = 8, period 4, 7 · 13 | p · q = n, recomputed from the period | theorem shor |
+| 4 | a code corrects one flip | POST /mcp · qpu_prove | bitflip distance 3, syndrome cnot cnot toffoli, logical < physical on this run | distance 3 corrects exactly one error | theorem noise |
+
+Boot on hardware. docker build -t qpu . && docker run --rm -p 8787:8787 qpu. Raspberry Pi: Alpine aarch64: apk add nodejs npm && npm i -g @uuidna/qpu && qpu-boot. The boot's receipt is node dist/quantum/processing/unit/boot.js --prove — the boot passes iff qpu_prove holds inside the machine; a boot that cannot prove itself does not serve. The seat stays empty: a device that fills this seat and disagrees with the simulator is a driver bug, never a physics claim.
+
 Integrate in any harness. One computed block, served on initialize as `install` and printed here from the same function. URL https://qpu.uuidna.com/mcp. none for reads; Authorization: Bearer QPU_WRITE_TOKEN for storage writes.
 
 | Harness | How | File | Config |
@@ -134,6 +147,8 @@ MLA 8, (Rouschev). DOI 10.5281/zenodo.22717782, archive https://zenodo.org/recor
 - Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "src/quantum/processing/unit/index.lean." qpu.uuidna.com, https://qpu.uuidna.com/mcp. doi:10.5281/zenodo.22717782.
 - Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "All Seven Clay Millennium Problems Sealed via Universal σ-Involution." Zenodo, https://zenodo.org/records/21781603. doi:10.5281/zenodo.21781603.
 
+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.
+
 ## License
 
 CC-BY-NC-ND-4.0. Source `LICENSE`. Copyright Tsvetan Rouschev.

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

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+// boot — THE UNIT ON REAL HARDWARE (the captain, 2026-09-12: "make hardware bootable with qpu").
+//
+// The unit is a fetch handler that answers only when named: https scheme, host qpu.uuidna.com. On a machine it has no
+// Cloudflare in front of it, so this adapter presents every local request AS the named origin — same bytes, same unit,
+// no fork — and a Node http server carries the replies. The seat doctrine applies here first: the simulator inside is
+// the reference, and this boot does not serve until the unit has proven itself on this machine (`qpu_prove` holds).
+//
+//   node dist/quantum/processing/unit/boot.js            → prove, then serve on $PORT (8787)
+//   node dist/quantum/processing/unit/boot.js --prove    → prove and exit 0/1 (the boot's receipt; the container's HEALTHCHECK)
+import { createServer } from 'node:http';
+import worker from './index.js';
+const ORIGIN = 'https://qpu.uuidna.com';
+const env = { QPU_HOST: 'qpu.uuidna.com' };
+const bodyOf = (req) => new Promise((resolve) => { const chunks = []; req.on('data', (d) => chunks.push(d)); req.on('end', () => resolve(Buffer.concat(chunks))); });
+const toRequest = async (req) => {
+    const method = req.method ?? 'GET';
+    const headers = {};
+    for (const [k, v] of Object.entries(req.headers))
+        if (typeof v === 'string')
+            headers[k] = v;
+    const body = method === 'GET' || method === 'HEAD' || method === 'OPTIONS' ? undefined : new Uint8Array(await bodyOf(req));
+    return new Request(ORIGIN + (req.url ?? '/'), { method, headers, body });
+};
+const prove = async () => {
+    const r = await worker.fetch(new Request(`${ORIGIN}/mcp`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'qpu_prove', arguments: {} } }) }), env);
+    const j = (await r.json());
+    const holds = j.result?.structuredContent?.holds ?? j.result?.holds;
+    console.log(`qpu boot — ${holds === true ? '✓ qpu_prove holds' : '✗ qpu_prove does not hold'} on ${process.platform}/${process.arch}, node ${process.version}`);
+    return holds === true;
+};
+const proven = await prove();
+if (process.argv.includes('--prove'))
+    process.exit(proven ? 0 : 1);
+if (!proven)
+    process.exit(1);
+const port = Number(process.env.PORT ?? '8787');
+createServer(async (req, res) => {
+    const r = await worker.fetch(await toRequest(req), env);
+    res.writeHead(r.status, Object.fromEntries(r.headers.entries()));
+    res.end(Buffer.from(await r.arrayBuffer()));
+}).listen(port, () => console.log(`qpu boot — serving ${ORIGIN} at http://localhost:${port} (every request presented to the unit as the named origin)`));

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

@@ -3770,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') &&
@@ -3794,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 &&
@@ -3826,6 +3827,8 @@ export const qpuGlossaryOf = () => ({
     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();
@@ -9086,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 = [];
@@ -10096,6 +10336,8 @@ export const qpuReadmeOf = (m = qpuMcpOf()) => {
         '',
         `Cybersecurity morph tools. crypto_rsa theorem shor ${shorFactorOf()}. crypto_split theorem crypto ${cryptoClaimOf()}.`,
         '',
+        `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.`,
+        '',
         row('Tool', 'Claim'),
         row('---', '---'),
         ...m.cybersecurity.tools.map((t) => row(`\`${t.name}\``, t.man.description)),
@@ -10137,6 +10379,14 @@ export const qpuReadmeOf = (m = qpuMcpOf()) => {
         '',
         `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.',
+        '',
+        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}`)),
+        '',
+        `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}.`,
+        '',
         `Integrate in any harness. One computed block, served on initialize as \`install\` and printed here from the same function. URL ${harness.url}. ${harness.auth}.`,
         '',
         row('Harness', 'How', 'File', 'Config'),
@@ -10150,6 +10400,8 @@ export const qpuReadmeOf = (m = qpuMcpOf()) => {
         ...cite.rows.map((r) => `- ${r.works}`),
         `- ${cite.prior.works}`,
         '',
+        qpuSeatOf().acronym,
+        '',
         '## License',
         '',
         'CC-BY-NC-ND-4.0. Source `LICENSE`. Copyright Tsvetan Rouschev.',
@@ -10275,15 +10527,19 @@ export const qpuServedMemoOf = () => ({ entries: servedMemo.size, cap: servedCap
 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));
-export default {
+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 });
+        // 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, etag: row.etag } });
-            return new Response(row.body, { status: found, headers: { ...headers, etag: 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);
@@ -10291,12 +10547,20 @@ export default {
         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') {
                 let parsed;
                 try {
@@ -10305,7 +10569,22 @@ export default {
                 catch {
                     return jsonOf(rpcErrorOf(null, rpcCodes.parse, 'Parse error: the body is not JSON'), badRequest);
                 }
-                if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                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;
@@ -10357,6 +10636,19 @@ export default {
             return servedResponse(servedOf(`/${unit.path}`, () => qpuLeanOf()));
         if (path === '/cite')
             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(() => ({})));
@@ -10424,3 +10716,4 @@ export default {
         return jsonOf(JSON.parse(dead), lost);
     }
 };
+export default worker;

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

@@ -0,0 +1,69 @@
+// publish — THE VERDICT A PUSH DESERVES, as a pure function. The network lives in scripts/post-push.mjs; the law
+// lives here so the receipted suite can test it against crafted rows instead of a live forge.
+//
+// WHY THIS EXISTS (measured 2026-09-13). Publishing this unit was verified by hand with `gh run list --limit 1`,
+// which is a WINDOW over the newest runs, not the runs of a commit. The run for the pushed commit did not exist
+// yet, so the newest row belonged to the PREVIOUS push, it read `success`, and a deploy that had not happened was
+// reported as verified — the live doors then answered with the old bytes. Asking by head sha is exact, and an
+// absent run is UNMEASURED, never a pass. The sibling tree met this conflation four times before naming it; this
+// is the same law carried across rather than invented a second time.
+const PASSED = new Set(['success', 'neutral']);
+const DID_NOT_JUDGE = new Set(['skipped', 'cancelled']);
+/** pushVerdictOf(sha, runs) → what the forge says about THIS commit. Pure; the caller fetches the rows. */
+export const pushVerdictOf = (sha, runs) => {
+    if (sha.length < 7)
+        throw new Error(`post-push: "${sha}" is too short to name a commit — seven hex characters is git's own floor`);
+    const onSha = runs.filter((r) => r.headSha === sha || r.headSha.startsWith(sha));
+    // ONLY A PUSH JUDGES A PUSH. A schedule or a manual dispatch can sit on the same commit and answer something else.
+    const mine = onSha.filter((r) => r.event === 'push');
+    const notThisPush = onSha.filter((r) => r.event !== 'push').map((r) => `${r.workflowName} (${r.event}: ${r.conclusion ?? r.status})`).sort();
+    const pending = mine.filter((r) => r.status !== 'completed').map((r) => r.workflowName).sort();
+    const done = mine.filter((r) => r.status === 'completed');
+    const failing = done.filter((r) => !PASSED.has(r.conclusion ?? '') && !DID_NOT_JUDGE.has(r.conclusion ?? ''))
+        .map((r) => `${r.workflowName} (${r.conclusion ?? 'no conclusion'})`).sort();
+    const didNotJudge = done.filter((r) => DID_NOT_JUDGE.has(r.conclusion ?? '')).map((r) => `${r.workflowName} (${r.conclusion})`).sort();
+    const passed = done.filter((r) => PASSED.has(r.conclusion ?? '')).map((r) => r.workflowName).sort();
+    // A VERDICT NEEDS A JUDGE: absence of failure over a set where nothing judged is not a pass.
+    const measured = passed.length > 0 || failing.length > 0;
+    const settled = mine.length > 0 && pending.length === 0;
+    const ok = settled && passed.length > 0 && failing.length === 0;
+    const short = sha.slice(0, 9);
+    const aside = (didNotJudge.length ? ` — and did NOT judge: ${didNotJudge.join(', ')}` : '')
+        + (notThisPush.length ? ` — and NOT this push: ${notThisPush.join(', ')}` : '');
+    const reason = pending.length
+        ? `still running for ${short}: ${pending.join(', ')}${aside}`
+        : failing.length
+            ? `FAILED for ${short}: ${failing.join(', ')}${aside}`
+            : !onSha.length
+                ? `UNMEASURED: the forge reports no run at all for ${short} — this is NOT a pass. It may not be queued yet; wait, never conclude.`
+                : !mine.length
+                    ? `UNMEASURED: ${onSha.length} run(s) sit on ${short} and none was a push — ${notThisPush.join(', ')}. Another event answers another question.`
+                    : !passed.length
+                        ? `UNMEASURED: every run on ${short} declined to judge${aside}`
+                        : `green for ${short}: ${passed.join(', ')}${aside}`;
+    return { sha, ok, settled, measured, passed, failing, pending, didNotJudge, notThisPush, reason };
+};
+/** value + predicate: a verdict may never be ok without a run that actually passed, and never ok while one fails. */
+export const pushVerdictHolds = (v) => (!v.ok || (v.settled && v.passed.length > 0 && v.failing.length === 0)) &&
+    (!v.ok || v.measured) && v.reason.length > 0;
+/** THE FORGE CANNOT ANSWER, versus THE FORGE ANSWERED "NOTHING". Asking for the runs of a commit the forge has not
+ *  indexed returns 422 and the tool exits non-zero, so an arm that does not catch it DIES where the honest answer is
+ *  UNMEASURED — and the seconds after a push are exactly when that happens. Only a refusal that names the commit may
+ *  become an empty row set; a missing credential or an absent tool must stay loud, because reading those as "no runs"
+ *  is the conflation this whole law refuses. A bare "Not Found" is NOT the pattern: `command not found` contains it. */
+export const isUnknownCommit = (message) => /No commit found for SHA|\(HTTP (?:404|422)\)/i.test(String(message));
+/** THE PUSH THAT REPORTED SUCCESS AND LANDED NOTHING. git can exit 0 while the remote branch sits elsewhere — a
+ *  concurrent push, a protected ref, a retry that went to another branch. The forge is then asked about a commit
+ *  the remote does not carry, and "no run yet" reads as patience when the truth is that nothing landed. The sibling
+ *  tree compares the remote's head against the sha it pushed and refuses; the same guard belongs here. */
+export const landedVerdictOf = (pushed, remoteHead) => {
+    if (pushed.length < 7)
+        throw new Error(`post-push: "${pushed}" is too short to name a commit — seven hex characters is git's own floor`);
+    const landed = remoteHead.trim() === pushed.trim();
+    return {
+        landed,
+        reason: landed
+            ? `origin carries ${pushed.slice(0, 9)}`
+            : `NOTHING LANDED: origin is ${remoteHead.trim().slice(0, 9) || 'unreadable'}, not ${pushed.slice(0, 9)} — the push reported success and the remote is elsewhere`,
+    };
+};

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

@@ -1,2 +1,2 @@
 /** GENERATED by scripts/embed-lean.mjs from package.json. Do not edit; bump package.json and rerun `npm run lean:embed`. */
-export const packageVersion = "0.1.1";
+export const packageVersion = "0.1.2";

package/install.json

@@ -2,12 +2,81 @@
   "command": "npx uuidna-install",
   "yes": "npx uuidna-install --yes",
   "prompt": "Enter seats all. Type 1 3 saas — or all.",
-  "packages": ["qpu-mcp", "payload-mcp", "vitepress-payload"],
-  "occupancies": ["personal", "business", "corporate", "saas", "paas"],
+  "packages": [
+    "qpu-mcp",
+    "payload-mcp",
+    "vitepress-payload"
+  ],
+  "occupancies": [
+    "personal",
+    "business",
+    "corporate",
+    "saas",
+    "paas"
+  ],
   "cloudflare": {
     "button": "https://deploy.workers.cloudflare.com/button",
     "qpu": "https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/qpu",
     "uuidna": "https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/uuidna",
     "payload": "https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/uuidna-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": {
+      "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": {
+        "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
+      },
+      "holds": true
+    }
+  },
+  "holds": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uuidna/qpu",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },
@@ -35,7 +35,13 @@
   "exports": {
     ".": {
       "types": "./qpu.d.ts",
-      "import": "./dist/quantum/processing/unit/index.js"
+      "import": "./dist/quantum/processing/unit/index.js",
+      "default": "./dist/quantum/processing/unit/index.js"
+    },
+    "./boot": {
+      "types": "./dist/quantum/processing/unit/boot.d.ts",
+      "import": "./dist/quantum/processing/unit/boot.js",
+      "default": "./dist/quantum/processing/unit/boot.js"
     }
   },
   "files": [
@@ -74,11 +80,16 @@
     "verify:live": "node scripts/verify-live.mjs https://qpu.uuidna.com",
     "test:live": "QPU_LIVE=https://qpu.uuidna.com node --test --test-reporter=spec dist/quantum/processing/unit/live.test.js",
     "proof": "git diff --exit-code -- test-receipt.json",
-    "examine": "node scripts/examine.mjs https://qpu.uuidna.com"
+    "examine": "node scripts/examine.mjs https://qpu.uuidna.com",
+    "post-push": "node scripts/post-push.mjs",
+    "land": "npm test && git push && node scripts/post-push.mjs --wait && npm run verify:live"
   },
   "devDependencies": {
     "@types/node": "26.5.1",
     "typescript": "7.0.2",
     "wrangler": "4.131.0"
+  },
+  "bin": {
+    "qpu-boot": "./dist/quantum/processing/unit/boot.js"
   }
 }