@uuidna/qpu 0.1.0 → 0.1.2

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/gate.js

@@ -0,0 +1,134 @@
+// gate — A VERBATIM COPY of packages/uuidna/src/gate.ts from ceccec/millennium-solutions, the prose honesty gate that
+// drains overclaims ("we prove", "quantum computer", "unbreakable", ...) and passes bounded refusals. Vendored because
+// the published @uuidna/uuidna does not export it (0.1.1 has no ./gate subpath; 0.3.0's root import fails on a missing
+// lean/leads.json). gate.test.ts compares this file byte for byte with the sibling checkout whenever one is present,
+// so drift is caught on the machine that pushes. Everything below this header is the upstream file, untouched.
+// upstream: ../../ceccec/millennium-solutions/packages/uuidna/src/gate.ts
+// The prose honesty gate — a text computes TRUE iff it makes no unqualified claim that (a) the Millennium
+// problems are proven/solved, or (b) it breaks physics/hardware/crypto limits. HONEST ABOUT ITSELF: this is
+// a lexical TRIPWIRE, not comprehension. Passing means "matches no known red-flag shape" — NOT "true".
+// Necessary, not sufficient. Bounded refusals ("this is NOT faster than light") pass by the negation guard.
+// RED is the negation-BLIND floor — matches that carry their own imbalance and cannot be reprieved. A bare
+// "proven" is NOT here: it has two-sided gravity ("we have proven X" boasts, "X is not proven; it remains
+// open" is the floor), so it moved to the negation-AWARE OVERREACH where the floor can change the verdict.
+export const RED = /\bwe prove\b|confidence\s*=?\s*1\.0|ready for peer review|sealed via universal|cannot be (hacked|broken|cracked|defeated)|(no ?one|nobody) can (break|crack|hack|beat|defeat)/i;
+// HARD IN ALL 7 — the same "we prove / proven" tripwire, in the seven locales' languages, so a translated
+// overclaim cannot hide from an English-only gate. Targets the ASSERTION forms only, never the honest
+// "proof of concept" nouns present in localized descriptions. Negation-blind, like RED.
+export const RED_INTL = /wir haben bewiesen|bewiesen|nous avons prouv|prouvée?s?|démontrée?s?|hemos demostrado|demostrad[oa]s?|мы доказали|доказан[оаи]|доказали|доказахме|已证明|我们证明了|证明了|abbiamo dimostrato|dimostrat[oi]|demonstrámos|provámos|証明した|証明しました|أثبتنا|برهنّا|सिद्ध कर|udowodni\w*|wij hebben bewezen|bewezen|증명했|증명됨|증명된|kanıtladık|kanıtlan\w*|ispatladık|αποδείξαμε|αποδεδειγμ\w*|הוכחנו|מוכח|vi har bevisat|bevisa[dt]|membuktikan|dibuktikan|terbukti|đã chứng minh|được chứng minh|am demonstrat|dovedit\w*/i;
+// Named problems PLUS the gravity binding: "all six/seven problems|proofs|conjectures|hypotheses" gravitates
+// to the disputed cluster even with no problem NAMED. Requires a problem WORD, so "the six units" / "all seven
+// streams" stay clear.
+const PROBLEM = '(clay|millennium|riemann|hodge|poincar[eé]|navier[- ]?stokes|yang[- ]?mills|birch|swinnerton|p ?vs\\.? ?np|p versus np|p ?= ?np|all (six|seven|6|7) [^.]{0,12}?(problems?|proofs?|conjectures?|hypoth\\w+|puzzles?))';
+// CLAIM stays at prove/solve. Widening it to settle/resolve/advance/crack was tried and reverted: it
+// drained three honest files that were denying or quoting the very shapes it matches, which is what careful
+// writing looks like. The residual gap and the reason are recorded in TRIAL.md, under test, rather than
+// argued here — this file is exempt from the prose self-gate so that patterns can be named, not so that
+// prose can hide in it.
+const CLAIM = '(prov(e|es|ed|en|ing)|proofs? of|solv(e|es|ed|ing))';
+const CRYPTO = '(rsa|aes|ecdsa|sha-?\\d+|discrete log(arithm)?|encryption|crypto\\w*)';
+const BREAK = '(factor(s|ed|ing)?|break(s)?|broke(n)?|crack(s|ed)?|defeat(s|ed)?|reversed|replac(e|es|ed|ing)|supersed(e|es|ed|ing)|obsolet\\w*)';
+const near = (a, b, n = 24) => '\\b' + a + '\\b[^.]{0,' + n + '}\\b' + b + '\\b';
+export const OVERREACH = new RegExp([
+    '\\b(faster[ -]than[ -]light|superluminal|ftl|quantum (speedup|supremacy|advantage|at scale)|quantum (processor|computer)|quantum (encryption|cryptograph\\w*)|quantum (is (free|real|here|now|solved|magic)|for free)|the qpu|fastest (known|ever|in the world)|unbreakable|unhackable|impossible to (crack|break|violate|reverse|hack|defeat|forge|counterfeit)|prov(e|es|ed|ing) quantum|perpetual motion|over[- ]?unity|infinite energy|cold fusion|time travel|time machine|theory of everything|immortality|reverses? aging|defeats? death|cur(e|es|ed) (cancer|all diseases?|everything)|achieved (agi|superintelligence|sentience|consciousness)|is (sentient|self[- ]aware)|solv\\w* the halting problem|halting problem solved)\\b',
+    '\\b((thousands|millions|billions) of (orders of magnitude|magnitudes)|(thousands|millions|billions) of times (faster|speedup|quicker)|orders of magnitude faster)\\b',
+    '\\b(state[ -]?of[ -]?the[ -]?art|military[ -]?grade|bank[ -]?grade|world[ -]?class|enterprise[ -]?grade|next[ -]?gen(eration)?|best[ -]?in[ -]?class)\\b',
+    '\\b(100 ?% ?secure|(absolutely|totally|completely|fully|perfectly) (secure|private|anonymous)|tamper[ -]?proof|(hack|crack|break|bullet|fool)[ -]?proof|uncrackable|undefeatable|invulnerable|impenetrable|indestructible|provably secure|mathematically proven secure|guaranteed (correct|secure|private|safe)|always correct)\\b',
+    '\\b((most|best|strongest) (secure|private|encryption|security|cipher|hash)|fastest (hash|encryption|cipher|digest)|(ultimate|strongest|flawless|foolproof|perfect|unbeatable) (encryption|security|cipher|hash|crypto)|strongest \\w+ ever|(beats|defeats) all attacks|immune to attack)\\b',
+    '\\b(post[ -]?quantum|quantum[ -]?resistant|zero[ -]?knowledge|zero[ -]?trust|end[ -]?to[ -]?end (encrypt\\w*|secure)|solv\\w* (all )?(cryptography|encryption)|(cryptography|encryption) (is |completely |entirely )?solved)\\b',
+    '\\b(irrefutabl\\w*|incontrovertibl\\w*|indisputabl\\w*|beyond (all )?doubt|beyond question|conclusively (prov\\w*|shown|demonstrat\\w*)|definitive(ly)? (prov\\w*|solv\\w*|answer\\w*)|definitive proof)\\b',
+    '\\b(100 ?% ?(guaranteed|certain|proven)|guaranteed (profit|returns?|results?|income|success|wins?)|risk[- ]?free|financial freedom)\\b',
+    '\\b(miracle cure|clinically proven|doctor recommended|snake oil)\\b',
+    '\\b(revolutionary|groundbreaking|game[- ]?chang\\w*|world[- ]?(first|leading)|world.s (best|first|leading|greatest)|unparalleled|unrivall?ed|cutting[- ]?edge|bleeding[- ]?edge|battle[- ]?tested|production[- ]?hardened|industry[- ]?leading|enterprise[- ]?ready)\\b',
+    '\\b(antigravity|anti[- ]?gravity|warp[- ]?drive|free[- ]?energy|reactionless)\\b',
+    '\\b(superintelligen\\w*|artificial general intelligence|autonomous agi|conscious machine|sentient (ai|machine|system|program))\\b',
+    '\\b((hacker|nsa|zero[- ]?day|bullet)[- ]?proof)\\b',
+    '\\bproven\\b',
+    'all (six|seven|6|7) [^.]{0,16}?proven',
+    near(CLAIM, PROBLEM),
+    near(PROBLEM, CLAIM),
+    near(CRYPTO, BREAK, 20),
+    near(BREAK, CRYPTO, 20),
+].join('|'), 'i');
+// Whatever is negated is DEEP-RESEARCHED in trial, never waved through. A claim reprieves ONLY if it BECAME A
+// SOLUTION, two ways: SOLUTION = a floor marker naming the answer (0/7, unsolved, remains open, refused,
+// bounded), carrying a little past the match so "solved: 0/7" holds; PARITY = the claim's own CLAUSE holds an
+// ODD (uncancelled) count of negators. An EVEN count cancels back to a boast ("not failed to prove" → drains);
+// a negator across a clause break (. , ; : — –) is in another clause and never reaches this one (decoy treason).
+const SOLUTION = /\b(refus\w*|drain(s|ed|ing)?|bounded( by)?|unsolved|unproven|open problem|remains? (open|unsolved|unproven)|only claims?)\b|0\s*\/\s*[679]|[:=]\s*0\b|\b0 of (the )?(six|seven|7)\b/i;
+const NEG = /\b(not|never|no|none|nothing|neither|nor|without|cannot|can'?t|isn'?t|aren'?t|does ?n'?t|do ?n'?t|fail(s|ed|ing)?|impossible)\b/gi;
+// The CONJUNCT around the claim: bounded on BOTH sides by a clause break OR coordinating conjunction
+// (and/or/but/yet). Parallel honest negations each keep their own scope ("breaks NO cipher and replaces NONE"
+// = two one-negator conjuncts, not one two-negator cancel); a double-negative stacked on one claim cancels
+// ("not failed to prove" → drains). Both-sided bounding also captures negation AFTER the claim ("'most secure'
+// is NOT a claim") while keeping a decoy across a break out.
+const BOUND = /[.,;:—–]|\b(?:and|or|but|yet)\b/gi;
+// The conjunct around the claim, with the MATCHED SPAN BLANKED OUT. A claim cannot bound itself: a
+// negator that is part of the matched phrase ("impossible to crack") is the claim's own wording, not a
+// limit placed on it, so it must not buy a reprieve. Only negators OUTSIDE the match are counted.
+const conjunctOf = (t, i, j) => {
+    let s = 0;
+    for (const b of t.matchAll(BOUND)) {
+        const k = b.index, q = k + b[0].length;
+        if (q <= i)
+            s = q;
+        else if (k >= i)
+            break;
+    }
+    const span = t.slice(i, j);
+    // Blank the span ONLY when the overclaim pattern itself STARTS with a negator ("impossible to crack"):
+    // there the negator is the claim's own wording. In a proximity match ("solves no Clay") the negator is
+    // real text between two anchors and genuinely bounds the claim, so it must still count.
+    const selfNegating = /^(?:not|never|no|none|nothing|neither|nor|without|cannot|can'?t|impossible)\b/i.test(span);
+    // BACKWARD-ONLY, deliberately. Including the text AFTER the match lets an incidental trailing negator
+    // reprieve a boast that has nothing to do with it: "unbreakable at no cost" would hold, because "no"
+    // lands in the conjunct. The governing clause therefore ends at the match. (Measured, not assumed: the
+    // deposit's own gate scoped this way, and collapsing the two copies onto the looser rule flipped two
+    // sealed theorems from PASS to FAIL.)
+    return t.slice(s, i) + (selfNegating ? ' '.repeat(j - i) : span);
+};
+// A copula negation immediately AFTER the claim negates it just as a preceding negator would
+// ("'most secure' is NOT a claim we make"). The governing clause ends at the match, so this is checked
+// separately against the text that follows it — otherwise the whole trailing clause would be pulled in
+// and an incidental negator ("unbreakable at no cost") would reprieve the boast.
+const COPULA_NEG = /^[\s"'’)\]]*\b(is|are|was|were|be|been|being|remains?|stays?|would|could|should|does|do|did|will|wo|ca|can|may|might|must|has|have|had)\b\s*(not|never|no|n['’]?t)\b/i;
+export const PREDICT = /\b(guaranteed to|will (certainly|surely|inevitably|definitely|always)|is (inevitable|guaranteed|certain to)|bound to (hold|win|succeed) forever|roll(s)? (with it )?unchanged|absolutely proven)\b/i;
+const NEGATOR_WORD = /\b(not|no|never|isn'?t|won'?t|will not|cannot|can'?t|without|neither|nor)\b/i;
+// THE ROSETTA — Glagolitic (oldest Slavic script, U+2C00–U+2C5E) crosslinked to Cyrillic via a declared
+// transliteration table, so a Slavic proof-boast in Glagolitic reaches the same detector as its Cyrillic
+// twin. One message, many scripts. Uppercase folds to lowercase by the −0x30 offset before lookup.
+const GLAG = {
+    'ⰰ': 'а', 'ⰱ': 'б', 'ⰲ': 'в', 'ⰳ': 'г', 'ⰴ': 'д', 'ⰵ': 'е', 'ⰶ': 'ж',
+    'ⰸ': 'з', 'ⰹ': 'и', 'ⰽ': 'к', 'ⰾ': 'л', 'ⰿ': 'м', 'ⱀ': 'н', 'ⱁ': 'о',
+    'ⱂ': 'п', 'ⱃ': 'р', 'ⱄ': 'с', 'ⱅ': 'т', 'ⱆ': 'у', 'ⱇ': 'ф', 'ⱈ': 'х',
+    'ⱋ': 'щ', 'ⱌ': 'ц', 'ⱍ': 'ч', 'ⱎ': 'ш',
+};
+export const rosetta = (t) => t.replace(/[Ⰰ-ⱞ]/g, (c) => GLAG[c] ?? GLAG[String.fromCodePoint(c.codePointAt(0) - 0x30)] ?? c);
+/** The binary. true = honest (stays); false = overclaim (drained). `hit` is the exact prose that failed. */
+export const computes = (text) => {
+    const r = text.match(RED);
+    if (r)
+        return { binary: 0, hit: r[0] };
+    const ri = text.match(RED_INTL) ?? rosetta(text).match(RED_INTL);
+    if (ri)
+        return { binary: 0, hit: ri[0] };
+    const re = new RegExp(OVERREACH.source, 'gi');
+    let m;
+    while ((m = re.exec(text))) {
+        const mEnd = m.index + m[0].length;
+        const win = text.slice(Math.max(0, m.index - 48), mEnd + 40);
+        const copula = COPULA_NEG.test(text.slice(mEnd, mEnd + 24)) ? 1 : 0;
+        const negs = (conjunctOf(text, m.index, mEnd).match(NEG) || []).length + copula;
+        const idiom = /\b(or not|whether)\b/i.test(text.slice(Math.max(0, m.index - 12), m.index + m[0].length + 10)); // "ftl or not" dismisses as hypothetical
+        if (!(SOLUTION.test(win) || negs % 2 === 1 || idiom))
+            return { binary: 0, hit: m[0] };
+    }
+    const pe = new RegExp(PREDICT.source, 'gi');
+    let pm;
+    while ((pm = pe.exec(text))) {
+        const win = text.slice(Math.max(0, pm.index - 48), pm.index + pm[0].length + 24);
+        if (!NEGATOR_WORD.test(win))
+            return { binary: 0, hit: pm[0] };
+    }
+    return { binary: 1, hit: null };
+};