@ceccec/millennium-solutions 0.1.1

package/speedup.md

@@ -0,0 +1,41 @@
+---
+title: The real uuidna advantage
+description: The measured uuidna advantage — O(N)→O(log N) verification, O(N)→O(1) reuse — in all domains. Not faster compute, not FTL, not quantum. 0/7.
+head:
+  - ['meta', { name: 'robots', content: 'index, follow' }]
+---
+
+# The real uuidna advantage — measured, in all domains
+
+> Generated from the **1864** theorems and **59** domains, recomputed each build. The advantage is
+> real and **measured**, and honestly bounded: a **verification and reuse** complexity reduction — **not**
+> faster original compute, **not** faster than light, **not** quantum. `0/7`.
+
+## Measured — verify and reuse, not recompute
+
+| N | recompute (ops) | verify (⌈log₂N⌉ nodes) | bits (2·⌈log₂N⌉) | saving | ratio |
+|---|---|---|---|---|---|
+| 8 | 8 | 3 | 6 | 5 | 3× |
+| 64 | 64 | 6 | 12 | 58 | 11× |
+| 967 | 967 | 10 | 20 | 957 | 97× |
+| 1,024 | 1,024 | 10 | 20 | 1,014 | 102× |
+| 1,000,000 | 1,000,000 | 20 | 40 | 999,980 | 50,000× |
+
+Computing the N things still costs **N** — the advantage is not there. It is on **verification**: a merkle
+inclusion proof checks membership in `⌈log₂N⌉` nodes (`2·⌈log₂N⌉` bits) instead of re-running all N. And on
+**reuse**: a content-address names a value once, so every re-reference is `O(1)`, and a 36-byte address
+travels, not the payload. Measured on the deposit's own functions, not asserted.
+
+## Why it holds in all 59 domains at once
+
+The advantage is the **fold / merkle-proof structure**, which is **domain-independent** — every domain's
+theorems verify in `⌈log₂N⌉`. So one proof covers the whole [rosetta](/): z9-arithmetic · units-triad · doubling-orbit · inverses · powers · primes · cyclic-groups · boolean-algebra · entanglement · dialectic · games · arts · ….
+
+## Discovery lead — a lead, never a verdict
+
+Grouping the 1864 receipts by the digital root of their address, the **sparsest** region is digit
+**3** (177) — a candidate area to examine, not a finding. The ledger is currently held
+at **1864** (the captain's cap): improving a theorem's name or proof heals the record without changing the
+count; discovering a new one would require lifting the cap.
+
+A content-address proves **integrity, not truth**. `0/7`.

package/src/0/chacha.ts

@@ -0,0 +1,3 @@
+// ChaCha20 + Poly1305 + the AEAD construction (RFC 8439, pure TS, KAT-verified) live canonically in
+// @uuidna/uuidna — one implementation shared by both apps, no re-declared copy.
+export { chachaBlock, chacha20, poly1305, aeadEncrypt, aeadDecrypt } from '@uuidna/uuidna'

package/src/0/crypt.ts

@@ -0,0 +1,4 @@
+// The encryption envelope — ChaCha20-Poly1305 core + PBKDF2-SHA256 KDF + uuidna 7d-fold envelope — lives
+// canonically in @uuidna/uuidna. One implementation shared by both apps; convergent seals, no re-declared copy.
+export { encrypt, decrypt, verifyEnvelope, ITER } from '@uuidna/uuidna'
+export type { Sealed } from '@uuidna/uuidna'

package/src/0/csp.ts

@@ -0,0 +1,10 @@
+// Single source of the Content-Security-Policy — imported by .vitepress/config.ts (head) AND
+// scripts/locale-fold.ts (stubs), so the policy is declared ONCE, never hardcoded twice (no drift).
+// Self-contained: no external scripts/styles/fonts/img/connect. 'unsafe-inline' is required (VitePress
+// injects inline check-dark-mode/check-mac-os scripts + inline style attributes; meta-CSP can't use
+// nonces) — so this hardens RESOURCE ORIGIN, not full anti-XSS. The deterministic guarantee is the
+// external-import gate (scripts/import-gate.ts) + the security gate (scripts/security-gate.ts).
+export const CSP =
+  "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; " +
+  "img-src 'self' data:; font-src 'self'; connect-src 'self'; object-src 'none'; " +
+  "base-uri 'self'; form-action 'self'; frame-ancestors 'none'"

package/src/0/entanglement.ts

@@ -0,0 +1,31 @@
+// Release entanglement (honest sense) — each release cryptographically BOUND to its neighbours.
+// A hash chain: change any release and every downstream address changes (avalanche). This is
+// tamper-evidence — correlation by DERIVATION — not quantum entanglement, and it carries no message.
+import { toUuid, merge, merkleFold } from './index.ts'
+
+export function report(): string {
+  const chain = (rs: string[]) => { let prev = toUuid('genesis'); const out: string[] = []; for (const r of rs) { prev = merge(prev, toUuid(r)); out.push(prev) } return out }
+  const sealOf = (rs: string[]) => merkleFold(chain(rs))
+
+  const releases = ['v1.0.34', 'v1.0.35', 'v1.0.36', 'v1.0.37']
+  const original = sealOf(releases)
+  const flipped = sealOf(['v1.0.34', 'v1.0.35', 'v1.0.36!', 'v1.0.37']) // alter ONE neighbour
+  const changed = original !== flipped
+
+  let o = 'release entanglement — each bound to its neighbours (honest sense):\n\n'
+  o += '  neighbours in the version line — each release folds with its predecessor (a hash chain):\n'
+  o += '    seal over ' + releases.join(', ') + '\n'
+  o += '      original: ' + original.slice(0, 13) + '…\n'
+  o += '      alter one neighbour (v1.0.36 → v1.0.36!): ' + flipped.slice(0, 13) + '…   changed? ' + changed + '\n'
+  o += '  → you cannot alter one release without the chain revealing it. neighbours are BOUND.\n\n'
+  o += '  bound in several computable "dimensions":\n'
+  o += '    · version line — the hash chain above (predecessor ↔ successor)\n'
+  o += '    · the mesh     — 10−d reflects each digit to its partner (4↔6, fixed 5)\n'
+  o += '    · the tree     — a merkle audit path binds each leaf to its siblings (see holographic.ts)\n\n'
+  o += 'HONEST: this is CRYPTOGRAPHIC DEPENDENCY — a hash chain, the basis of tamper-evidence — NOT\n'
+  o += 'quantum entanglement. Correlation by DERIVATION, not action-at-a-distance: altering a release\n'
+  o += 'does not reach out and change its neighbour\'s stored bytes; it makes recomputation reveal the\n'
+  o += 'break. No information travels without payload (no-communication theorem holds). "Entangled" =\n'
+  o += 'bound by the math, not by physics. entails → 0/7.'
+  return o
+}

package/src/0/fusion.ts

@@ -0,0 +1,28 @@
+// Tokens are valid only in the fusion — validity = MEMBERSHIP in the verified whole, not the token.
+// A bare UUID proves nothing (anyone can mint one). The same 64-bit string is valid inside the fused
+// root and meaningless outside it: an orphan token is not in the root, and adding it changes the root.
+import { toUuid, merkleFold } from './index.ts'
+
+export function report(): string {
+  const units = [1, 2, 4, 5, 7, 8], seven = [3, 2, 6, 4, 5, 1, 0]
+  const leaves: string[] = []; for (const u of units) for (const r of seven) leaves.push(toUuid(u + 'x' + r))
+  const root = merkleFold(leaves)                 // the fused whole
+
+  const fused = toUuid('5x0')                     // a real cell of the cross — fused
+  const orphan = toUuid('orphan-token')           // never fused
+  const fusedIn = leaves.includes(fused)
+  const orphanIn = leaves.includes(orphan)
+  const orphanChangesRoot = merkleFold([...leaves, orphan]) !== root
+
+  let o = 'tokens are valid only in the fusion:\n\n'
+  o += '  the fused whole: ' + leaves.length + ' cells → one root ' + root.slice(0, 13) + '…\n\n'
+  o += '  a fused token (a real cell) is a member of the root:   ' + fusedIn + '  → valid\n'
+  o += '  an orphan token (never fused) is NOT a member:         ' + orphanIn + '  → invalid\n'
+  o += '    adding the orphan changes the root (it was not part of the fusion): ' + orphanChangesRoot + '\n'
+  o += '  → the same kind of 64-bit string is valid INSIDE the fusion, meaningless outside it.\n\n'
+  o += 'HONEST: validity here = MEMBERSHIP in the verified whole (it folds to the root; a merkle proof\n'
+  o += 'exists — see holographic.ts), not any property of the token alone. A hash is one-way and a\n'
+  o += 'public token is just a name (see security.ts) — it carries no authority by itself; it is valid\n'
+  o += 'only as a proven part of the fused, sealed deposit. entails → 0/7.'
+  return o
+}

package/src/0/holographic.ts

@@ -0,0 +1,57 @@
+// Holographic verification — the whole checkable from a tiny part (digit 0).
+// A Merkle membership proof is the honest core of "holographic within tiniest resources": any one
+// leaf proves it belongs to the whole with a LOGARITHMIC audit path (⌈log₂ N⌉ sibling hashes), not
+// the full set. The tree is self-similar (fractal); the shared root lives in every part.
+import { merge, merkleFold, toUuid } from './index.ts'
+
+// Rebuild merkleFold's tree (it sorts leaves) as layers, so we can extract an audit path.
+function layers(leaves: readonly string[]): string[][] {
+  let layer = [...leaves].sort()
+  const out = [layer]
+  while (layer.length > 1) {
+    const next: string[] = []
+    for (let i = 0; i < layer.length; i += 2) { const a = layer[i], b = layer[i + 1]; next.push(b === undefined ? a : merge(a, b)) }
+    out.push(next); layer = next
+  }
+  return out
+}
+function proof(leaves: readonly string[], target: string): { hash: string; left: boolean }[] {
+  const L = layers(leaves); let idx = L[0].indexOf(target); const path: { hash: string; left: boolean }[] = []
+  for (let l = 0; l < L.length - 1; l++) {
+    const layer = L[l], isRight = (idx & 1) === 1, sib = isRight ? idx - 1 : idx + 1
+    if (sib < layer.length) path.push({ hash: layer[sib], left: isRight }) // sibling on the left iff target is right
+    idx = idx >> 1
+  }
+  return path
+}
+function verify(target: string, path: { hash: string; left: boolean }[], root: string): boolean {
+  let h = target
+  for (const { hash, left } of path) h = left ? merge(hash, h) : merge(h, hash)
+  return h === root
+}
+
+export function report(): string {
+  // The cross: 42 content-addressed cells (6 units × 7) — one whole, one root.
+  const units = [1, 2, 4, 5, 7, 8], seven = [3, 2, 6, 4, 5, 1, 0]
+  const leaves: string[] = []; for (const u of units) for (const r of seven) leaves.push(toUuid(u + 'x' + r))
+  const root = merkleFold(leaves)
+  const target = toUuid('5x0') // the center × hub cell
+  const p = proof(leaves, target)
+  const ok = verify(target, p, root)
+
+  let o = 'holographic verification — the whole, checkable from a tiny part:\n\n'
+  o += '  the cross: ' + leaves.length + ' content-addressed cells (6 units × 7) → one merkle root (the whole).\n'
+  o += '  a MEMBERSHIP proof for one cell is the audit path — log-few sibling hashes, not all ' + leaves.length + ':\n'
+  o += '    proof size: ' + p.length + ' hashes   (⌈log₂ ' + leaves.length + '⌉)   vs the full set: ' + leaves.length + '\n'
+  o += '    verify one-of-' + leaves.length + ' against the root: ' + ok + '\n'
+  o += '  → any part proves it belongs to the whole with tiny (logarithmic) resources.\n'
+  o += '    holographic: the root lives in every part; a part reconstructs the whole\'s fingerprint.\n\n'
+  o += '  fractal: the tree is self-similar (a fold of folds); the mesh reflects (10−d) at every scale.\n'
+  o += '  scale: log-sized proofs mean ~1 billion leaves verify in ~30 hashes.\n\n'
+  o += 'HONEST: a Merkle proof is EXACTLY logarithmic (⌈log₂ N⌉) — real, the basis of git/blockchain\n'
+  o += 'integrity. "holographic" = a part verifies the whole via the shared root; "fractal" = the binary\n'
+  o += 'tree is self-similar. But it is NOT free and NOT literally infinite: each proof is log(N) real\n'
+  o += 'hashes over a FINITE set. Tiny resources, not zero; huge N, not ∞. Whole signed (Singularity),\n'
+  o += 'parts verifiable. entails → 0/7.'
+  return o
+}

package/src/0/impossible.ts

@@ -0,0 +1,33 @@
+// Prove the impossibilities — so every NOT in the prose is a PROVEN theorem, not an assertion.
+// ℤ/9 is finite, so ∀-claims are decidable by exhaustion (the same rigour as Lean's `decide`).
+// The paradox: "proving X impossible makes it possible." Resolution — two LEVELS: the object
+// (e.g. 0's inverse) stays IMPOSSIBLE; the meta-statement ("0 has no inverse") is a POSSIBLE, true
+// theorem. Impossibility-proofs are positive results; the "possible" is the proof, never the object.
+const m9 = (n: number) => ((n % 9) + 9) % 9
+const hasInverse = (a: number) => [1, 2, 3, 4, 5, 6, 7, 8].some((x) => m9(a * x) === 1)
+
+export function report(): string {
+  // Each is proven by checking ALL of ℤ/9 — a finite, exhaustive impossibility proof.
+  const proofs: [string, boolean][] = [
+    ['0 has NO multiplicative inverse (∀x∈ℤ/9, 0·x ≠ 1)', !hasInverse(0)],
+    ['3,6,9 have NO inverse (the nilradical)', [3, 6, 9].every((d) => !hasInverse(d))],
+    ['3²≡6²≡9²≡0 (nilpotent — collapse into the void)', [3, 6, 9].every((d) => m9(d * d) === 0)],
+    ['division BY 0 is undefined (no inverse exists to define n/0 as a field op)', !hasInverse(0)],
+    ['10 is not a distinct ℤ/9 digit (10 ≡ 1; it wraps)', m9(10) === 1],
+    ['5 is the ONLY self-complement (10−d=d) among 1..9', [1, 2, 3, 4, 5, 6, 7, 8, 9].filter((d) => 10 - d === d).join(',') === '5'],
+  ]
+  const allProven = proofs.every(([, ok]) => ok)
+
+  let o = 'prove the impossibilities — every NOT, verified by exhaustion:\n\n'
+  proofs.forEach(([claim, ok]) => { o += '  ' + (ok ? '✓ PROVEN impossible' : '✗ FAILED') + ' — ' + claim + '\n' })
+  o += '\n  all impossibilities proven? ' + allProven + '  → the prose\'s NOTs are theorems, not assertions.\n\n'
+  o += 'the paradox ("proving them impossible proves them possible") — resolved by two LEVELS:\n'
+  o += '  object level:  0\'s inverse is IMPOSSIBLE. it stays impossible.\n'
+  o += '  meta level:    "0 has no inverse" is a POSSIBLE, true theorem (just proven above).\n'
+  o += '  → both hold at once, no contradiction. what becomes "possible" is the PROOF, never the\n'
+  o += '    impossible object. an impossibility-proof is a positive result (cf. Gödel, halting problem).\n\n'
+  o += 'the one that matters: proving "this framework does NOT solve the Clay problems" (0/7) is a\n'
+  o += 'POSSIBLE, true proof — it does NOT make solving possible. The proof is real; the solving is not.\n'
+  o += 'The floor stands precisely because its impossibility is PROVEN. entails → 0/7.'
+  return o
+}

package/src/0/imprint.ts

@@ -0,0 +1,160 @@
+// Imprint — a REVERSIBLE binary↔uuid codec. Honest naming first: this is NOT reversing the one-way
+// FNV content-address (toUuid), which cannot be undone (see scripts/verify.ts) — and it is NOT
+// encryption (no key, no secrecy). It is a lossless ENCODING: we CONSTRUCT a uuid whose 128 bits
+// directly carry a binary message, and read those bits back out exactly. Integrity/identity layer,
+// never truth. A uuid holds 128 bits; 6 are reserved (4 version + 2 variant, matching toUuid's v8),
+// 7 hold a length header → up to 115 message bits per uuid. Round-trips exactly for L ≤ CAPACITY.
+import { toUuid } from './index.ts'
+
+// Reserved bit positions (big-endian, bit 0 = MSB of byte 0):
+//   version nibble = high nibble of byte 6 → bits 48..51, fixed to 1000 (0x8)
+//   variant        = top 2 bits of byte 8 → bits 64,65, fixed to 10
+const RESERVED = new Set([48, 49, 50, 51, 64, 65])
+const LEN_BITS = 7 // 0..127 fits; the free region minus this header is the message capacity
+const FREE = Array.from({ length: 128 }, (_, i) => i).filter((i) => !RESERVED.has(i))
+export const CAPACITY = FREE.length - LEN_BITS // 122 - 7 = 115 message bits per uuid
+
+const isBits = (s: string): boolean => /^[01]*$/.test(s)
+const num2bits = (n: number, width: number): string => n.toString(2).padStart(width, '0').slice(-width)
+
+/** Pack a 128-bit array into canonical uuid string. */
+function bitsToUuid(bits: readonly number[]): string {
+  let hex = ''
+  for (let byte = 0; byte < 16; byte++) {
+    let v = 0
+    for (let b = 0; b < 8; b++) v = (v << 1) | bits[byte * 8 + b]
+    hex += v.toString(16).padStart(2, '0')
+  }
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+}
+
+/** Unpack a canonical uuid string into a 128-bit array. */
+function uuidToBits(uuid: string): number[] {
+  const hex = uuid.replace(/-/g, '')
+  if (!/^[0-9a-f]{32}$/i.test(hex)) throw new Error('imprint: not a 32-hex uuid')
+  const bits: number[] = []
+  for (const ch of hex) {
+    const nib = parseInt(ch, 16)
+    for (let b = 3; b >= 0; b--) bits.push((nib >> b) & 1)
+  }
+  return bits
+}
+
+/**
+ * imprint(message) → a valid uuid carrying the message in its free bits.
+ * message: a binary string ('0'/'1'), length ≤ CAPACITY. The uuid reads back exactly via readImprint.
+ */
+export function imprint(message: string): string {
+  if (!isBits(message)) throw new Error('imprint: message must be a binary string of 0/1')
+  if (message.length > CAPACITY) throw new Error(`imprint: message ${message.length} bits > capacity ${CAPACITY}`)
+  const bits = new Array(128).fill(0)
+  // reserved: version 8 (1000), variant (10) — matches toUuid's markers so imprints look native.
+  bits[48] = 1; bits[49] = 0; bits[50] = 0; bits[51] = 0
+  bits[64] = 1; bits[65] = 0
+  // free region: [ length header (7 bits) | message bits | zero-fill ]
+  const payload = num2bits(message.length, LEN_BITS) + message
+  for (let i = 0; i < payload.length; i++) bits[FREE[i]] = payload.charCodeAt(i) - 48
+  return bitsToUuid(bits)
+}
+
+/** readImprint(uuid) → the exact binary message imprinted by imprint(). Inverse of imprint. */
+export function readImprint(uuid: string): string {
+  const bits = uuidToBits(uuid)
+  const free = FREE.map((i) => bits[i])
+  let len = 0
+  for (let i = 0; i < LEN_BITS; i++) len = (len << 1) | free[i]
+  if (len > CAPACITY) throw new Error('imprint: length header out of range — uuid was not imprinted by imprint()')
+  return free.slice(LEN_BITS, LEN_BITS + len).join('')
+}
+
+/** Convenience: imprint UTF-8 text (≤ 14 ASCII chars fit) and read it back exactly. */
+export function imprintText(text: string): string {
+  const bytes = [...new TextEncoder().encode(text)]
+  const bits = bytes.map((b) => num2bits(b, 8)).join('')
+  return imprint(bits)
+}
+export function readImprintText(uuid: string): string {
+  const bits = readImprint(uuid)
+  const bytes: number[] = []
+  for (let i = 0; i + 8 <= bits.length; i += 8) bytes.push(parseInt(bits.slice(i, i + 8), 2))
+  return new TextDecoder().decode(new Uint8Array(bytes))
+}
+
+/** roundTrips(message) → true iff readImprint(imprint(message)) === message. The honest, gated fact. */
+export function roundTrips(message: string): boolean {
+  try { return readImprint(imprint(message)) === message } catch { return false }
+}
+
+/**
+ * imprintChain(bits) → a CHAIN of uuids carrying a message of ANY length: split into CAPACITY-bit chunks,
+ * imprint each. One uuid holds ≤115 bits (bounded, pigeonhole); a chain of N holds ≤ N·115 — the collective
+ * scaling, developed. Public, reversible ENCODING (not encryption, no secrecy). readImprintChain reverses it.
+ */
+export function imprintChain(bits: string): string[] {
+  if (!/^[01]*$/.test(bits)) throw new Error('imprintChain: message must be a binary string')
+  if (bits.length === 0) return [imprint('')]
+  const out: string[] = []
+  for (let i = 0; i < bits.length; i += CAPACITY) out.push(imprint(bits.slice(i, i + CAPACITY)))
+  return out
+}
+
+/** readImprintChain(uuids) → recover the full message: read each carrier and concatenate, exactly. */
+export function readImprintChain(uuids: readonly string[]): string {
+  return uuids.map((u) => readImprint(u)).join('')
+}
+
+/** imprintTextChain(text) → a uuid chain carrying arbitrary UTF-8 text of any length (built on imprintChain). */
+export function imprintTextChain(text: string): string[] {
+  const bytes = [...new TextEncoder().encode(text)]
+  return imprintChain(bytes.map((b) => num2bits(b, 8)).join(''))
+}
+
+/** readImprintTextChain(uuids) → recover the full text from its uuid chain, exactly. */
+export function readImprintTextChain(uuids: readonly string[]): string {
+  const bits = readImprintChain(uuids)
+  const bytes: number[] = []
+  for (let i = 0; i + 8 <= bits.length; i += 8) bytes.push(parseInt(bits.slice(i, i + 8), 2))
+  return new TextDecoder().decode(new Uint8Array(bytes))
+}
+
+/**
+ * skill(message) → how skilful the clown is at juggling this message through a uuid: imprint throws the
+ * bits, readImprint catches them; fidelity = fraction caught. A skilful clown catches every bit (1.0);
+ * a dropped bit lowers the score. Over-capacity is a fumble (fidelity 0) — respect the floor. Computed.
+ */
+export function skill(message: string): { imprinted: number; recovered: number; fidelity: number; skilful: boolean } {
+  let recovered = 0
+  try {
+    const back = readImprint(imprint(message))
+    for (let i = 0; i < message.length; i++) if (back[i] === message[i]) recovered++
+    if (back.length !== message.length) recovered = message.length ? 0 : 0
+  } catch { recovered = 0 }
+  const fidelity = message.length === 0 ? 1 : recovered / message.length
+  return { imprinted: message.length, recovered, fidelity, skilful: fidelity === 1 }
+}
+
+/**
+ * coin64(text) → the shared currency: a 64-bit coin (16 hex digits) minted from any content — the top
+ * 64 bits of its 128-bit content-address. Adopted by all with no exception: every module, every string,
+ * mints the SAME coin every time (deterministic). This is the common denominator the harmony gate folds.
+ * Integrity, not value: a coin proves the bytes, not their worth.
+ */
+export function coin64(text: string): string {
+  return toUuid(text).replace(/-/g, '').slice(0, 16)
+}
+
+export function report(): string {
+  const demo = '01001000' + '01101001' // "Hi" in ASCII bits
+  const u = imprint(demo)
+  const back = readImprint(u)
+  const txt = imprintText('Hi'), txtBack = readImprintText(txt)
+  let o = 'imprint — reversible binary↔uuid codec (NOT hash-reversal, NOT encryption):\n\n'
+  o += '  capacity:            ' + CAPACITY + ' message bits per uuid (128 − 6 reserved − 7 length header)\n'
+  o += '  imprint("' + demo + '")\n'
+  o += '    → ' + u + '\n'
+  o += '  readImprint(uuid)  → ' + back + '   round-trips: ' + (back === demo) + '\n'
+  o += '  imprintText("Hi")  → ' + txt + '  → readImprintText → "' + txtBack + '"\n\n'
+  o += '  HONEST: this CONSTRUCTS a uuid from a message and reads it back — a lossless codec (integrity).\n'
+  o += '  It does NOT undo the one-way FNV toUuid, and it is not encryption (no key, no secrecy). entails → 0/7.'
+  return o
+}

package/src/0/index.ts

@@ -0,0 +1,253 @@
+/**
+ * Quantum Proofs — Core Kernel (Minimal)
+ * Licensed under CC BY-NC 4.0
+ * Attribution: Tsvetan Rouschev (ceccec@psg.bg)
+ *
+ * Dependency-free primitives for all proofs.
+ * - UUID/hash: content-addressed identity
+ * - Fold: merge two addresses into one
+ * - Merkle: contract leaves to root
+ * - Memoization: cache computation by matrix root
+ * - Hash: exact 32-bit integer arithmetic (algebraic only, no Math.*)
+ */
+
+const BYTE_MASK = 0xff
+const MASK_32 = 0xffffffffn
+
+/** Exact 32-bit unsigned integer multiply (algebraic; replaces Math.imul) */
+function mul32(a: number, b: number): number {
+  return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32)
+}
+
+/** FNV-1a hash — 32-bit seed-based (exact integer arithmetic, no Math.*) */
+function hash32(input: string, seed: number): number {
+  let h = (0x811c9dc5 ^ seed) >>> 0
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i)
+    h = mul32(h, 0x01000193) >>> 0
+    h ^= h >>> 13
+  }
+  h = mul32(h ^ (h >>> 16), 0x85ebca6b) >>> 0
+  h = mul32(h ^ (h >>> 13), 0xc2b2ae35) >>> 0
+  return (h ^ (h >>> 16)) >>> 0
+}
+
+function hexByte(value: number): string {
+  return value.toString(16).padStart(2, '0')
+}
+
+function bytesFromSeed(seed: string): number[] {
+  const words = [
+    hash32(seed, 0),
+    hash32(seed, 0x9e3779b9),
+    hash32(seed, 0x243f6a88),
+    hash32(seed, 0xb7e15162),
+  ]
+  return words.flatMap((word) => [
+    (word >>> (8 * 3)) & BYTE_MASK,
+    (word >>> 16) & BYTE_MASK,
+    (word >>> 8) & BYTE_MASK,
+    word & BYTE_MASK,
+  ])
+}
+
+const _uuidCache = new Map<string, string>()
+
+/** Deterministic UUID from seed (content-addressed) */
+export function toUuid(seed: string): string {
+  const cached = _uuidCache.get(seed)
+  if (cached !== undefined) return cached
+  const bytes = bytesFromSeed(seed)
+  bytes[6] = (bytes[6] & 0x0f) | 0x80
+  bytes[8] = (bytes[8] & 0x3f) | 0x80
+  const hex = bytes.map(hexByte).join('')
+  const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`
+  _uuidCache.set(seed, uuid)
+  return uuid
+}
+
+/** strictUuidna(value) → a STRICT, canonical mint: coerce to string, normalize (NFC), trim — so the SAME
+ *  logical value always mints the SAME address. Minting flaws (toUuid(3) vs toUuid('3'), stray whitespace,
+ *  a decomposed vs composed unicode form) mint inconsistent addresses and silently break integrity — real
+ *  damage. Strict minting closes them. Canonicalisation is a discipline that must stay consistent, not truth. */
+export function strictUuidna(value: unknown): string {
+  return toUuid('uuidna:' + String(value).normalize('NFC').trim())
+}
+
+/** Fold two addresses into one */
+export function merge(a: string, b: string): string {
+  return toUuid(`${a}:${b}`)
+}
+
+/** GCD for rational reduction */
+export function gcdBigInt(a: bigint, b: bigint): bigint {
+  return b === 0n ? a : gcdBigInt(b, a % b)
+}
+
+/** Deterministic seed from text */
+export function seedFromText(text: string, length = 6): number {
+  return Number.parseInt(toUuid(text).replace(/[^0-9a-f]/g, '').slice(0, length) || '0', 16)
+}
+
+/** Bidirectional fold */
+export function foldPair(a: string, b: string): { forward: string; reverse: string; bidirectional: boolean; merged: string } {
+  const forward = merge(a, b)
+  const reverse = merge(b, a)
+  return { forward, reverse, bidirectional: forward !== reverse, merged: merge(forward, reverse) }
+}
+
+/** Merkle fold — contract set of leaves to root */
+export function merkleFold(leaves: readonly string[]): string {
+  let layer = [...leaves].sort()
+  if (layer.length === 0) return toUuid('empty-mind')
+  while (layer.length > 1) {
+    const next: string[] = []
+    for (let i = 0; i < layer.length; i += 2) {
+      const a = layer[i]
+      const b = layer[i + 1]
+      next.push(b === undefined ? a : merge(a, b))
+    }
+    layer = next
+  }
+  return layer[0]
+}
+
+/** Seal facets with content-address receipts */
+export function sealFacets<F extends { facet: string; on: boolean }>(
+  tag: string,
+  facets: readonly F[],
+): { ok: boolean; count: number; facets: (F & { receipt: string })[]; root: string } {
+  const stamped = facets.map((f) => ({ ...f, receipt: toUuid(`${tag}:${f.facet}:${f.on}`) }))
+  return {
+    ok: stamped.every((f) => f.on),
+    count: stamped.length,
+    facets: stamped,
+    root: merkleFold(stamped.map((f) => f.receipt)),
+  }
+}
+
+/** Memoization by matrix root */
+const reportMemo = new Map<string, unknown>()
+const reportComputing = new Set<string>()
+
+export function memoByRoot<T>(name: string, matrix: { root: string }, compute: () => T): T {
+  const key = `${name}:${matrix.root}`
+  if (reportMemo.has(key)) return reportMemo.get(key) as T
+  if (reportComputing.has(key)) return {} as T
+  reportComputing.add(key)
+  try {
+    const value = compute()
+    reportMemo.set(key, value)
+    return value
+  } finally {
+    reportComputing.delete(key)
+  }
+}
+
+/** Digital root (sum digits until single) */
+export function digitalRoot(n: number): number {
+  const r = ((n % 9) + 9) % 9
+  return r === 0 ? 9 : r
+}
+
+// ── Canonical number-theory primitives — the algorithms the ledger's Euclid/Wilson/Carmichael
+// theorems are about, hoisted here so they are stated ONCE (a theorem computes; a copy drifts). ──
+
+/** Euclid's algorithm — the greatest common divisor. */
+export function gcd(a: number, b: number): number {
+  while (b) { const t = a % b; a = b; b = t }
+  return a
+}
+
+/** Primality by trial division up to √n — decidable, exact. */
+export function isPrime(n: number): boolean {
+  if (n < 2) return false
+  for (let d = 2; d * d <= n; d++) if (n % d === 0) return false
+  return true
+}
+
+/** Modular exponentiation bᵉ mod n by square-and-multiply. */
+export function modpow(b: number, e: number, n: number): number {
+  let r = 1
+  b %= n
+  while (e > 0) { if (e & 1) r = (r * b) % n; b = (b * b) % n; e >>= 1 }
+  return r
+}
+
+// ── Vortex primitives — DERIVED from a SINGLE axiom. The base of the ring is the one irreducible
+// constant; the residues [1..BASE], the units, the triad, the orbit and the a432 step all COMPUTE
+// from it — no residue list is ever typed as a literal. A constant states; a theorem computes.
+// (Theorem A: the doubling orbit is a permutation of the units, covers each once, and closes —
+// verified exhaustively in scripts/lean-claims.ts.) ──
+
+/** The one irreducible axiom: the trinity. Everything below derives — BASE is TRINITY², the residues
+ *  are [1..BASE], the units/triad/orbit/step all compute. This is the LAST constant, and it cannot be
+ *  removed: a zero-axiom system computes nothing. The axiom floor — you cannot derive from nothing,
+ *  the same boundary as 0/7 (you cannot prove the unprovable) and "not every statement is a theorem." */
+export const TRINITY = 3
+export const BASE = TRINITY ** 2 // 9 — derived, not typed
+
+/** The residues [1..BASE] — derived from the axiom, never typed as a literal. */
+export function digits(): number[] {
+  return Array.from({ length: BASE }, (_, i) => i + 1)
+}
+
+/** The units of ℤ/9 — residues coprime to the base. Derived: gcd(d,BASE)=1 → [1,2,4,5,7,8]. */
+export function units(): number[] {
+  return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) === 1n)
+}
+
+/** The triad {3,6,9} — non-units (share a factor with the base). Derived as the complement. */
+export function triad(): number[] {
+  return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) !== 1n)
+}
+
+/** The vortex doubling circuit — the orbit of n→2n (mod BASE) from 1: computed [1,2,4,8,7,5]. */
+export function vortexOrbit(): number[] {
+  const orbit: number[] = []
+  let x = 1
+  do { orbit.push(x); x = (x * 2) % BASE } while (x !== 1)
+  return orbit
+}
+
+/** a432 angular quantum — one BASE-th of the circle: 360/9 = 40°, derived. */
+export const A432_STEP = 360 / BASE
+
+/** Animation engine interface */
+export interface AnimationEngine {
+  readonly running: boolean
+  start(): void
+  stop(): void
+  sync(active: boolean): void
+  tick(): void
+  runWhile(active: () => boolean): void
+  dispose(): void
+}
+
+export function createAnimationEngine(draw: (time: number) => void): AnimationEngine {
+  let raf = 0, once = 0, spin = 0, running = false
+  const schedule = (fn: (t: number) => void): number =>
+    typeof requestAnimationFrame === 'function' ? requestAnimationFrame(fn) : 0
+  const cancel = (id: number): void => {
+    if (id && typeof cancelAnimationFrame === 'function') cancelAnimationFrame(id)
+  }
+  function loop(time: number): void {
+    if (!running) return
+    draw(time)
+    raf = schedule(loop)
+  }
+  return {
+    get running() { return running },
+    start() { if (!running) { running = true; raf = schedule(loop) } },
+    stop() { running = false; cancel(raf); raf = 0 },
+    tick() { cancel(once); once = schedule((t) => { once = 0; draw(t) }) },
+    sync(active: boolean) { active ? this.start() : (this.stop(), this.tick()) },
+    runWhile(active: () => boolean) {
+      if (running || spin) return
+      const step = (time: number): void => { draw(time); spin = active() ? schedule(step) : 0 }
+      spin = schedule(step)
+    },
+    dispose() { running = false; cancel(raf); raf = 0; cancel(once); once = 0; cancel(spin); spin = 0 },
+  }
+}
+

package/src/0/ledger.ts

@@ -0,0 +1,25 @@
+// Content-addressed, double-entry, merkle-audited ledger (tamper-evident log).
+// INTEGRITY/AUDIT via hashing — NOT encryption, NOT post-quantum, NOT reversible messaging.
+import { toUuid, merge, merkleFold } from './index.ts'
+type Tx = { debit: string; credit: string; amount: number }
+export function report(): string {
+  const txs: Tx[] = [
+    { debit: 'funding',     credit: 'development', amount: 2 }, // the two coins
+    { debit: 'development', credit: 'research',    amount: 1 },
+  ]
+  const debits = txs.reduce((s, t) => s + t.amount, 0)
+  const credits = txs.reduce((s, t) => s + t.amount, 0) // each tx balances 1:1
+  let prev = toUuid('genesis'); const chain: string[] = []
+  for (const t of txs) { prev = merge(prev, toUuid(t.debit + '|' + t.credit + '|' + t.amount)); chain.push(prev) }
+  const root = merkleFold(chain)
+  // audit: recompute → detect any change (deterministic, zero-marginal-cost re-verify)
+  const root2 = merkleFold(chain)
+  let o = 'content-addressed double-entry ledger (tamper-evident):\n'
+  txs.forEach((t, i) => o += '  ' + t.debit.padEnd(12) + '→ ' + t.credit.padEnd(12) + t.amount + '   addr ' + chain[i].slice(0, 13) + '…\n')
+  o += '  balance: debits ' + debits + ' = credits ' + credits + '  (' + (debits === credits) + ')\n'
+  o += '  merkle root (audit anchor): ' + root.slice(0, 13) + '…   recompute stable? ' + (root === root2) + '\n'
+  o += '\nHONEST: integrity/audit via hashing — transparent, recomputable, holographic (root in every part).\n'
+  o += 'NOT encryption, NOT post-quantum, NOT a reversible message stream. toUuid is FNV (non-crypto,\n'
+  o += '~2^61) — for real integrity use SHA-256; for real PQC use a vetted lattice/hash scheme (ML-KEM, SPHINCS+).'
+  return o
+}