@ceccec/millennium-solutions 0.1.1

package/src/8/infinite.ts

@@ -0,0 +1,26 @@
+// Finite is infinite by nature — finite STRUCTURE, infinite GENERATIVITY (digit 8 ≈ ∞).
+// A bounded rule has unbounded reach: the finite ℤ/9 doubling cycles forever; a finite formula
+// (BBP) yields endless π digits; a finite function addresses unbounded inputs. True for behavior,
+// not for cardinality — a finite set is still finite.
+import { vortexOrbit } from '../0/index.ts'
+
+export function report(): string {
+  // The finite doubling rule (×2 mod 9) traced past its period — a finite cycle, infinitely walked.
+  const seq: number[] = []; let x = 1
+  for (let i = 0; i < 13; i++) { seq.push(x); x = (x * 2) % 9 }
+  const period = vortexOrbit().length // derived, not typed: the doubling orbit's length (Theorem A)
+
+  let o = 'finite is infinite by nature — finite rules, infinite behavior (digit 8 ≈ ∞):\n\n'
+  o += '  a finite generator produces an unbounded stream:\n'
+  o += '    ℤ/9 doubling — finite ring (9 elements), sequence never ends (period ' + period + ', repeats):\n'
+  o += '      ' + seq.join(' → ') + ' → …\n'
+  o += '    BBP — a finite formula yields infinitely many π hex digits (any index, no end).\n'
+  o += '    toUuid — a finite function addresses unboundedly many distinct inputs.\n'
+  o += '    Riemann sphere — 0 ↔ ∞: the finite point and the infinite are one fold apart.\n\n'
+  o += '  the honest sense of "finite is infinite":\n'
+  o += '    finite STRUCTURE, infinite GENERATIVITY — a bounded rule has unbounded reach.\n\n'
+  o += 'HONEST: true for GENERATIVITY (finite rules → infinite output), NOT for CARDINALITY — a finite\n'
+  o += 'set (9 digits, 42 cells) is not an infinite set. "finite is infinite by nature" holds as\n'
+  o += '"finite generators, infinite behavior", not as 9 = ∞. entails → 0/7.'
+  return o
+}

package/src/8/merkaba/field.ts

@@ -0,0 +1,27 @@
+// Biot–Savart field of the merkaba coil geometry: counter-rotating → axis null; co-rotating → max.
+export function report(): string {
+  const MU = 1e-7, I = 1, R = 1, rL = 0.3, SEG = 200, deg = (d: number) => d * Math.PI / 180
+  const loops = [{ d: 1, phi: 40 }, { d: 4, phi: 160 }, { d: 7, phi: 280 }, { d: 2, phi: 80 }, { d: 5, phi: 200 }, { d: 8, phi: 320 }]
+  const cross = (a: number[], b: number[]) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+  const sub = (a: number[], b: number[]) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+  const B = (Pt: number[], sign: (d: number) => number) => {
+    let b = [0, 0, 0]
+    for (const L of loops) {
+      const cx = R * Math.cos(deg(L.phi)), cy = R * Math.sin(deg(L.phi)), s = sign(L.d)
+      for (let i = 0; i < SEG; i++) {
+        const t = 2 * Math.PI * (i + 0.5) / SEG
+        const src = [cx + rL * Math.cos(t), cy + rL * Math.sin(t), 0]
+        const dl = [-rL * Math.sin(t) * (2 * Math.PI / SEG) * s, rL * Math.cos(t) * (2 * Math.PI / SEG) * s, 0]
+        const r = sub(Pt, src), rm = Math.hypot(...r), inv = 1 / (rm * rm * rm), dB = cross(dl, r)
+        b[0] += MU * I * dB[0] * inv; b[1] += MU * I * dB[1] * inv; b[2] += MU * I * dB[2] * inv
+      }
+    }
+    return Math.hypot(...b) * 1e6
+  }
+  const merk = (d: number) => [1, 4, 7].includes(d) ? 1 : -1, co = () => 1
+  let o = 'merkaba coil field (Biot–Savart, µT):\n'
+  o += '  counter-rotating, central axis: ' + B([0, 0, 0], merk).toExponential(2) + ' → null\n'
+  o += '  co-rotating,       central axis: ' + B([0, 0, 0], co).toFixed(3) + ' → max\n'
+  o += '  scale check μ0I/2r = ' + (4e-7 * Math.PI * I / (2 * rL) * 1e6).toFixed(2) + ' µT'
+  return o
+}

package/src/8/merkaba/geometry.ts

@@ -0,0 +1,16 @@
+// Cube down its (1,1,1) axis → hexagon → Seed/Flower/Fruit/Metatron; merkaba = cube.
+export function report(): string {
+  const dot = (a: number[], b: number[]) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+  const cross = (a: number[], b: number[]) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]
+  const norm = (a: number[]) => { const m = Math.hypot(...a); return a.map(x => x / m) }
+  const f = norm([1, 1, 1]); const rr = norm(cross([0, 1, 0], f)); const uu = cross(f, rr)
+  const cube: number[][] = []; for (const x of [1, -1]) for (const y of [1, -1]) for (const z of [1, -1]) cube.push([x, y, z])
+  const P = cube.map(v => Math.hypot(dot(v, rr), dot(v, uu)))
+  const outer = P.filter(r => r > 0.4), center = P.filter(r => r <= 0.4)
+  let o = 'cube down (1,1,1) axis:\n'
+  o += '  outer vertices: ' + outer.length + ' at radius ' + outer[0].toFixed(3) + ' (regular hexagon)\n'
+  o += '  on-axis center: ' + center.length + '\n'
+  o += '  → Seed of Life = ' + (outer.length + 1) + ' (6+1); Fruit = 13; Metatron lines = ' + (13 * 12 / 2) + '; Platonic solids = 5\n'
+  o += '  merkaba (8 vertices) = a cube; lattice = cube graph Q3 (8 nodes, 3-regular, bipartite)'
+  return o
+}

package/src/8/merkaba/touch.ts

@@ -0,0 +1,26 @@
+// Merkabas move when touched — the FIELD responds to the relative spin ("touch"), max → null.
+// The figure is rigid (two tetrahedra = a cube, Q3 graph, see geometry.ts). What moves when you
+// change the relative rotation θ is the axial field: idealized superposition f(θ) = (1 + cos θ)/2,
+// turning from co-rotating (θ=0, MAX) toward counter-rotating (θ=π, NULL). Exact at special angles.
+export function report(): string {
+  // f(θ) = (1 + cos θ)/2, using exact algebraic cos (no Math.*): cos 0=1, 60=1/2, 90=0, 120=-1/2, 180=-1.
+  const rows: [number, string, string][] = [
+    [0, '1', 'aligned / co-rotating → MAX'],
+    [60, '3/4', ''],
+    [90, '1/2', 'quarter turn'],
+    [120, '1/4', ''],
+    [180, '0', 'opposed / counter-rotating → NULL'],
+  ]
+
+  let o = 'merkabas move when touched — the field responds to the spin (digit 8):\n\n'
+  o += '  the figure is rigid: two tetrahedra = a cube = the Q3 graph (see geometry.ts).\n'
+  o += '  what MOVES when you "touch" it (turn the relative rotation θ) is the axial FIELD —\n'
+  o += '  idealized two-source superposition f(θ) = (1 + cos θ)/2:\n'
+  rows.forEach(([deg, f, tag]) => { o += '    θ=' + String(deg).padStart(3) + '°   f = ' + f.padEnd(4) + (tag ? '  ' + tag : '') + '\n' })
+  o += '  → touch it (rotate) and the field slides smoothly from MAX to NULL. it "moves" — as a field.\n\n'
+  o += 'HONEST: this is an IDEALIZED superposition (f = (1+cos θ)/2, exact at these angles) — a model,\n'
+  o += 'not the full Biot–Savart integral (see field.ts for the real on-axis magnitudes: counter→null,\n'
+  o += 'co→max). The geometry itself is static; "moves when touched" describes the field\'s response to\n'
+  o += 'spin — not a self-moving object, and not any life-force. entails → 0/7.'
+  return o
+}

package/src/8/nucleus/magic.lean

@@ -0,0 +1,15 @@
+import Mathlib
+/-- Nuclear shell-model magic numbers as exact cumulative sums of level
+    capacities (2j+1), in shell-model filling order. 2,8,20 from the oscillator;
+    28,50,82,126 from spin-orbit intruders. -/
+namespace Vortex.D8.Nucleus
+def caps : List ℕ := [2, 4, 2, 6, 2, 4, 8, 4, 6, 2, 10, 8, 6, 4, 2, 12, 10, 8, 6, 4, 2, 14]
+theorem magic_2   : (caps.take 1).sum  = 2   := by decide
+theorem magic_8   : (caps.take 3).sum  = 8   := by decide
+theorem magic_20  : (caps.take 6).sum  = 20  := by decide
+theorem magic_28  : (caps.take 7).sum  = 28  := by decide
+theorem magic_50  : (caps.take 11).sum = 50  := by decide
+theorem magic_82  : (caps.take 16).sum = 82  := by decide
+theorem magic_126 : (caps.take 22).sum = 126 := by decide
+theorem total_126 : caps.sum = 126 := by decide
+end Vortex.D8.Nucleus

package/src/8/nucleus/proton-mass-fit.ts

@@ -0,0 +1,9 @@
+// Proton/electron mass ratio: vortex fit vs measurement.
+export function report(): string {
+  const ratio = 938.27208816 / 0.51099895
+  let o = 'measured m_p/m_e = ' + ratio.toFixed(6) + '\n'
+  o += 'vortex fit 108·17 = 1836  (err ' + (Math.abs(1836 - ratio) / ratio * 100).toExponential(2) + '%)\n'
+  o += '6·π⁵ = ' + (6 * Math.PI ** 5).toFixed(3) + ' (unrelated, fits better)\n'
+  o += '1836 ≠ 1836.1527; 1836 fits any nearby target → curve-fit, not prediction'
+  return o
+}

package/src/8/nucleus/proton-mass.lean

@@ -0,0 +1,10 @@
+import Mathlib
+/-- The vortex "fit" to the proton/electron mass ratio is 108·17 = 1836 — an exact
+    integer identity. It is NOT the measured ratio (≈ 1836.152673, a non-integer),
+    so the fit misses the physical value; and the same 1836 fits any nearby target
+    (see proton-mass-fit.mjs). Curve-fitting, not a prediction. -/
+namespace Vortex.D8.Nucleus.ProtonFit
+theorem vortex_fit : 108 * 17 = 1836 := by norm_num
+/-- The integer fit is not the measured ratio 1836.1527… -/
+theorem fit_is_not_the_ratio : (1836 : ℚ) ≠ 18361527 / 10000 := by norm_num
+end Vortex.D8.Nucleus.ProtonFit

package/src/8/nucleus/shell-model-magic.ts

@@ -0,0 +1,10 @@
+// Nuclear shell-model magic numbers as cumulative sums of capacities 2j+1.
+export function report(): string {
+  const caps = [2, 4, 2, 6, 2, 4, 8, 4, 6, 2, 10, 8, 6, 4, 2, 12, 10, 8, 6, 4, 2, 14]
+  const idx: Record<number, number> = { 2: 1, 8: 3, 20: 6, 28: 7, 50: 11, 82: 16, 126: 22 }
+  const take = (n: number) => caps.slice(0, n).reduce((a, b) => a + b, 0)
+  let o = 'magic cumulative sums:\n'
+  for (const m of [2, 8, 20, 28, 50, 82, 126]) o += '  ' + m + ' = sum(take ' + idx[m] + ') = ' + take(idx[m]) + '\n'
+  o += 'total = ' + caps.reduce((a, b) => a + b, 0) + '\noscillator only: 2, 8, 20, 40, 70, 112'
+  return o
+}

package/src/8/vortex.lean

@@ -0,0 +1,7 @@
+import Mathlib
+/-- Digit 8 — self-inverse (8·8 ≡ 1); the merkaba/cube node (8 vertices);
+    ten's-complement partner of 2 (matter ↔ wave). Nucleus facts in nucleus/magic.lean. -/
+namespace Vortex.D8
+theorem self_inverse : (8 : ZMod 9) * 8 = 1 := by decide
+theorem complement_two : 8 + 2 = 10 := by norm_num
+end Vortex.D8

package/src/9/access.ts

@@ -0,0 +1,34 @@
+// Public-access trinity — everyone has the latest token to develop on.
+// Three public channels; the "token" is the latest version (a public name, not a secret) — clone,
+// read, or build on it freely. Status is marked honestly: GitHub + site are LIVE; Zenodo (DOI) and
+// npm are STAGED, gated on the author's account actions.
+import { toUuid, merkleFold } from '../0/index.ts'
+
+type Channel = { name: string; where: string; status: 'LIVE' | 'STAGED'; note: string }
+
+const CHANNELS: Channel[] = [
+  { name: 'GitHub (source)', where: 'github.com/ceccec/millennium-solutions', status: 'LIVE', note: 'all tags public — clone any version' },
+  { name: 'Site (published)', where: 'ceccec.psg.bg/millennium-solutions', status: 'LIVE', note: 'recomputes in the browser' },
+  { name: 'Zenodo (CERN-operated archive/DOI)', where: 'doi.org/10.5281/zenodo.21819217', status: 'LIVE', note: 'minted; hosted on CERN infra (like every Zenodo record) — provenance, NOT endorsement; honest abstract (0/7)' },
+]
+const NPM: Channel = { name: 'npm (one package)', where: '@ceccec/millennium-solutions', status: 'STAGED', note: 'npm login → npm run deploy packages (author)' }
+
+export function report(): string {
+  const surface = merkleFold([...CHANNELS, NPM].map(c => toUuid(c.name + ':' + c.where)))
+
+  let o = 'public-access trinity — everyone has the latest token to develop on:\n\n'
+  o += '  the token = the latest version (a PUBLIC name, not a secret). read / clone / build on it.\n\n'
+  CHANNELS.forEach(c => {
+    o += '  [' + c.status.padEnd(6) + '] ' + c.name + '\n'
+    o += '            ' + c.where + '  — ' + c.note + '\n'
+  })
+  o += '\n  package channel:\n'
+  o += '  [' + NPM.status.padEnd(6) + '] ' + NPM.name + '  ' + NPM.where + '  — ' + NPM.note + '\n\n'
+  o += '  access-surface content-address: ' + surface.slice(0, 13) + '…\n'
+  o += '  (the live "latest token" = the newest tag + the version-seal root, from scripts/versions.ts)\n\n'
+  o += 'HONEST: GitHub, the site, and Zenodo (CERN-hosted DOI) are LIVE and fully public — everyone\n'
+  o += 'already has the latest to develop on. Only npm is STAGED, not yet published (needs npm login).\n'
+  o += '"Token" means a public version handle, never a secret credential — public access is\n'
+  o += 'transparency, not a key. entails → 0/7.'
+  return o
+}

package/src/9/aura-funding.ts

@@ -0,0 +1,25 @@
+// funding ⇄ aura — the sustaining loop, honestly bounded.
+// funding feeds the aura: support funds development, which keeps the deposit whole.
+// the aura projects funding: a whole, transparent, gap-showing deposit is what EARNS support.
+// Crucial bound: wholeness does NOT depend on funding — the gates run free; the core stays whole
+// whether or not anyone pays. Funding sustains NEW development, not existing integrity.
+import { FUNDING } from './funding.ts'
+
+export function report(): string {
+  // The gates need no money and no network to run — wholeness is self-sustaining.
+  const gatesCostToRun = 0 // deterministic scripts; integrity holds free
+
+  let o = 'funding ⇄ aura — the sustaining loop:\n\n'
+  o += '  funding feeds the aura:  support → development → wholeness (gaps · seal · wholeness).\n'
+  o += '  the aura projects funding: wholeness → trust → support (people fund what they can VERIFY).\n'
+  o += '  → a loop: funding ⇄ wholeness; each sustains the other. one public surface (' + FUNDING.contact + '),\n'
+  o += '    both directions. the two coins (110 − 108) reinvest; voluntary support (' + FUNDING.revolut + ') feeds in.\n\n'
+  o += '  the crucial bound (computed): the aura does NOT depend on funding.\n'
+  o += '    the gates run with ' + gatesCostToRun + ' external dependency and ' + gatesCostToRun + ' funding — deterministic scripts.\n'
+  o += '    the core is free (' + FUNDING.license + '); it stays whole whether or not it is ever funded.\n'
+  o += '    funding sustains NEW development; it does not buy existing integrity.\n\n'
+  o += 'HONEST: this is a BEHAVIORAL / gift-economy loop, not a guaranteed mechanism — wholeness does not\n'
+  o += 'automatically generate money, and funding is non-obligatory. Transparency EARNS support (if any);\n'
+  o += 'support SUSTAINS further development; neither is forced, and integrity is never for sale. entails → 0/7.'
+  return o
+}

package/src/9/coins.ts

@@ -0,0 +1,25 @@
+// The two coins, donated to ceccec itself — the funding loop closes on its source.
+// The fare (110 − 108 = 2 = −χ genus-2) is reinvested in development (which IS ceccec), not
+// extracted to a person. Destination = source: a self-loop, verifiable by content-address.
+import { toUuid } from '../0/index.ts'
+import { FUNDING, coins } from './funding.ts'
+
+export function report(): string {
+  const fare = coins()                 // 110 − 108 = 2
+  const g = 2, negChi = -(2 - 2 * g)   // −χ(genus-2) = 2
+  const source = toUuid('ceccec'), destination = toUuid('ceccec')
+  const selfLoop = source === destination
+
+  let o = 'the two coins — donated to ceccec itself:\n\n'
+  o += '  the fare: 110 − 108 = ' + fare + ' = −χ(genus-2) = ' + negChi + '   (the commercial two coins)\n'
+  o += '  ceccec donates them to ceccec itself — the coins fund development, and development IS ceccec:\n'
+  o += '    destination == source ? toUuid("ceccec") == toUuid("ceccec") → ' + selfLoop + '  (a self-loop)\n'
+  o += '  the cycle closes: development → life → 2 coins → development. the coins return to the origin.\n\n'
+  o += '  what it means (honest): commercial use pays the fare; the fare is REINVESTED in development\n'
+  o += '  (ceccec itself), not extracted to a person. non-commercial use is free (' + FUNDING.license + ');\n'
+  o += '  voluntary support (' + FUNDING.revolut + ') feeds the same loop.\n\n'
+  o += 'HONEST: "two coins" is a motif (110−108 = 2 = −χ genus-2) for the commercial fare, not a\n'
+  o += 'currency; donating them to ceccec is a REINVESTMENT intent, not an enforced financial mechanism.\n'
+  o += 'free for non-commercial use; commercial = permission + the fare (' + FUNDING.contact + '). entails → 0/7.'
+  return o
+}

package/src/9/enumeration.ts

@@ -0,0 +1,13 @@
+// Complete ℤ/9 per-digit algebraic enumeration + the 432 arithmetic.
+export function report(): string {
+  const inv = (n: number, m: number) => { for (let x = 1; x < m; x++) if ((n * x) % m === 1) return x; return null }
+  let o = 'ℤ/9 enumeration:\nd  +inv  ×inv  10−d  2d  mod3  role\n'
+  for (let d = 0; d <= 9; d++) {
+    const dd = d % 9, ai = (9 - dd) % 9, mi = inv(dd, 9), tc = 10 - d, db = (2 * dd) % 9
+    const role = dd === 0 ? 'void' : (mi === null ? 'nilpotent' : 'unit')
+    o += String(d).padEnd(3) + String(ai).padEnd(6) + String(mi === null ? '—' : mi).padEnd(6)
+       + String(tc).padEnd(6) + String(db).padEnd(4) + String(dd % 3).padEnd(6) + role + '\n'
+  }
+  o += '\n432 = 2^4·3^3 = 16·27;  doubling digit-sum 1+2+4+8+7+5 = 27;  digital root of 432 = 9'
+  return o
+}

package/src/9/funding.ts

@@ -0,0 +1,86 @@
+// Funding + license as computed data — fused, recomputable, usable across the UI.
+import { toUuid } from '../0/index.ts'
+export const FUNDING = {
+  license: 'CC BY-NC 4.0',
+  author: 'Tsvetan Rouschev',
+  revolut: 'https://revolut.me/ceccec',
+  contact: 'ceccec@psg.bg',
+  // The captain's message — canonical link, reminded at the captain page and in every contribution block.
+  // Free on the free sailing angle (off the wind, non-commercial); prize earning in waves on the beating band
+  // (30–60°), each leap folding and sending the next (O(log N)); contribute the two coins (110−108 = −χ genus-2)
+  // to earn up to the seal's 64 two-bit fold-verifications per wave — conditional, contributor keeps the rest,
+  // zero without a saving. Refined in the open (lineage on /captain — append-only). Current receipt below.
+  captainMessage: 'https://uuidna.com/captain/message',
+  captainReminder: 'free on the free sailing angle; prize earning in waves — contribute 2 to earn up to 64 per wave, keep the rest',
+  captainReceipt: '85ac8585-9dc1-8964-9848-ae0f49cc82fb',
+}
+// "the two coins" = 110 − 108 = −χ(genus-2) = 2  (the commercial fare)
+export function coins(): number { return 110 - 108 }
+export function report(): string {
+  return 'The cycle: development → life → development.\n'
+    + 'Development gives the work to people for free; life (the people who use it) funds the next\n'
+    + 'development. The core is free, developed in the open by the orchestration (gaps → seal →\n'
+    + 'sign → release) and one open package (@ceccec/millennium-solutions) — everyone builds their\n'
+    + 'vision on it. Commercial use pays the two coins (110 − 108 = ' + coins()
+    + ' = −χ genus-2, ' + FUNDING.contact + '); living users support voluntarily. Both fund further development.\n'
+    + 'HONEST: support is non-obligatory and not guaranteed — a gift economy, not a revenue promise.\n'
+    + 'License: ' + FUNDING.license + ' — free for non-commercial use, attribution ' + FUNDING.author
+    + '. Support: ' + FUNDING.revolut
+}
+
+// Funding filled with results — the computed proof-of-work the funding supports.
+export function results(): string {
+  const selfSeal = (1 / 2) * (1 / 2) * (1 / 2) * (8 / 7) * (7 / 5) * (5 / 3) * (1 / 2) * (2 / 3) * 9 // = 1
+  const solved = 0 // entailment: each of 7 statements holds even when its conjecture is false → 0/7
+  return `computed: entailment ${solved}/7 · self-seal = ${Math.round(selfSeal)} · reflection involutive · CC BY-NC 4.0`
+}
+
+// The public endpoints, content-addressed — a uuidna per URL. The CURRENT domain is computed at runtime
+// (window.location.hostname) and mapped to its license track; it is never hardcoded.
+export const PUBLIC_URLS = ['https://uuidna.org', 'https://uuidna.com', 'https://ceccec.psg.bg/millennium-solutions/'] as const
+
+/** urlAddress(url) → the content-address (uuidna) of a public URL — normalise (lowercase, no trailing slash). */
+export function urlAddress(url: string): string {
+  return toUuid('uuidna:url:' + url.toLowerCase().replace(/\/+$/, ''))
+}
+
+/** domainTrack(hostname) → the license track computed from the current domain. .org = non-profit, .com = commercial. */
+export function domainTrack(hostname: string): { track: string; note: string } {
+  if (/\buuidna\.org$/.test(hostname)) return { track: 'non-profit', note: 'free for public interest and independent research' }
+  if (/\buuidna\.com$/.test(hostname)) return { track: 'commercial', note: 'the two coins per core formula used' }
+  return { track: 'preview', note: 'the sealed work — same content, license by domain' }
+}
+
+// The uuidna billing model — comparable to public per-request / per-token pricing, but the unit is the
+// two-coin fair exchange (or the bits saved). Public-interest and non-commercial use is free (0). A
+// per-unit schedule, linear in usage — a fair-exchange schedule in coins and bits, not realized cash.
+export interface Usage { commercial: boolean; coreFormulasUsed: number; bitsSaved?: number }
+export function bill(u: Usage): { coins: number; bits: number; free: boolean; basis: string } {
+  if (!u.commercial) return { coins: 0, bits: 0, free: true, basis: 'public interest / non-commercial — free' }
+  const perFormula = coins() // 2 coins per core formula used
+  return { coins: u.coreFormulasUsed * perFormula, bits: u.bitsSaved ?? 0, free: false, basis: perFormula + ' coins per core formula used' }
+}
+
+// The CORRECT uuidna billing — MEASURED, not asserted. The value is the actual bit-difference the captain's
+// way delivered (O(N) recompute − O(1) verify), content-addressed; the two coins (110−108 = −χ genus-2) are
+// the CONSERVED fair-exchange invariant, fixed — not a per-formula multiplier (the flat `bill` above was the
+// wrong non-uuidna formula, kept as evidence). Non-commercial and public-interest use is free.
+export interface UuidnaUsage { commercial: boolean; recomputeOps: number; verifyOps: number }
+export function billUuidna(u: UuidnaUsage): { bitsSaved: number; coins: number; free: boolean; basis: string } {
+  if (!u.commercial) return { bitsSaved: 0, coins: 0, free: true, basis: 'public interest / non-commercial — free' }
+  const bitsSaved = Math.max(0, u.recomputeOps - u.verifyOps)
+  return { bitsSaved, coins: coins(), free: false, basis: 'the measured bits saved (O(N) recompute − O(1) verify); the two coins are the conserved fair-exchange invariant, not a per-formula rate' }
+}
+
+// Logical content distribution across the two domains for SEO: each page is canonical on EXACTLY ONE
+// domain (avoiding duplicate-content penalties). Public science and the open method → .org (non-profit);
+// commercial licensing, accounting, billing, the comparison, and dev → .com. The strict sitemap lists the
+// canonical URLs. (The build emits these canonicals only when the zones are live — never to a non-live host.)
+export function contentDomain(page: string): 'org' | 'com' {
+  return /^(FUNDING|ACCOUNTING|compare|billing|DEVELOP|license|commercial)/i.test(page) ? 'com' : 'org'
+}
+export function canonicalUrl(page: string): string {
+  const host = contentDomain(page) === 'com' ? 'https://uuidna.com' : 'https://uuidna.org'
+  const p = page === 'index' || page === 'index.md' ? '/' : '/' + page.replace(/\.md$/, '')
+  return host + p
+}

package/src/9/security.ts

@@ -0,0 +1,36 @@
+// Public security — transparency, not secrecy — and why that feeds development and funding.
+// The public token (ceccec@psg.bg) is a CONTACT/handle, not a secret key. A public token gives
+// ZERO confidentiality by definition. So "security" here is integrity + provenance + auditability
+// (all public, all verifiable), NOT encryption. That same openness is the funding channel.
+import { toUuid, merkleFold } from '../0/index.ts'
+import { FUNDING } from './funding.ts'
+
+export function report(): string {
+  const token = FUNDING.contact              // the PUBLIC handle (already in funding.ts)
+  const fingerprint = toUuid(token)          // a public content-address — a name, not a secret
+
+  // Tamper-evidence: change one byte and the merkle root changes.
+  const clean = merkleFold(['release', 'ledger', 'seal'].map(toUuid))
+  const tampered = merkleFold(['release', 'ledger', 'seaL'].map(toUuid)) // one byte differs
+  const tamperDetected = clean !== tampered
+
+  let o = 'public security — transparency, not secrecy:\n\n'
+  o += '  the public token: ' + token + ' is a PUBLIC contact/handle, not a secret key.\n'
+  o += '    public fingerprint (a name, not a secret): ' + fingerprint.slice(0, 13) + '…\n'
+  o += '    a public token gives ZERO confidentiality — public = anyone can read it.\n'
+  o += '    determinism + public = no secrecy. "security" here is NOT encryption.\n\n'
+  o += '  what the security actually IS (real, and fully public):\n'
+  o += '    · integrity    — content-addresses + merkle roots: one byte changes the root → ' + tamperDetected + '\n'
+  o += '    · provenance   — signed releases (Singularity), version-seal over all tags\n'
+  o += '    · consistency  — the seal gate: nothing inconsistent with 0/7 can ship\n'
+  o += '    · auditability — the double-entry ledger, recomputable by anyone\n'
+  o += '    → all public, all verifiable, no middleman, no secret to leak.\n\n'
+  o += '  the reflection: security → development → funding\n'
+  o += '    nothing is hidden, so anyone can verify and build (self-development); the same public\n'
+  o += '    handle (' + token + ') receives the gift-economy funding that feeds development.\n'
+  o += '    one public surface is both the security model AND the funding channel.\n\n'
+  o += 'HONEST: integrity / provenance / auditability — real, public, hash-based. NOT confidentiality,\n'
+  o += 'NOT encryption, NOT post-quantum secrecy. A public token cannot secure a secret; it can only\n'
+  o += 'prove integrity in the open. toUuid is FNV — for cryptographic integrity use SHA-256. entails → 0/7.'
+  return o
+}

package/src/9/society.ts

@@ -0,0 +1,32 @@
+// Live society — society is alive to the degree it PARTICIPATES, not to the degree it accepts.
+// The reflection 1 ↔ 9 (ten's-complement): the one who accepts (src/1/acceptance.ts) reflects
+// to the many who verify and build. A passive society takes claims on authority; a live one
+// recomputes them. This is the honest form of "societal acceptance" — earned, not granted.
+import { toUuid, merkleFold } from '../0/index.ts'
+
+export function report(): string {
+  const reflects = 10 - 1 // = 9: acceptance (1) reflects to society (9)
+
+  // The participation surface — what anyone can actually do, each real and open.
+  const channels = [
+    'recompute — every claim renders from source on /compute',
+    'verify — the version-seal folds all releases to one address',
+    'extend — the vision package is open; everyone adds their vision',
+    'sustain — the gift economy (life funds development), non-obligatory',
+  ]
+  const surfaceRoot = merkleFold(channels.map(toUuid))
+
+  let o = 'live society — alive by participation, not by acceptance:\n\n'
+  o += '  reflection 1 ↔ ' + reflects + ':  the one who ACCEPTS (digit 1) reflects to the many who VERIFY (digit 9).\n'
+  o += '  passive society takes the claim on authority (acceptance = proof) — dead. see acceptance (1).\n'
+  o += '  live society recomputes, verifies, contributes — the same 0/7 checked by many hands.\n\n'
+  o += '  the participation surface (open to anyone):\n'
+  channels.forEach(c => o += '    · ' + c + '\n')
+  o += '  surface content-address: ' + surfaceRoot.slice(0, 13) + '…\n\n'
+  o += '  → a live society is a commons that CHECKS and BUILDS. It stays honest because every\n'
+  o += '    contribution passes the same gate (gaps → seal) and every claim recomputes.\n\n'
+  o += 'HONEST: this is an open, verifiable commons — not decentralized consensus, not governance,\n'
+  o += 'not a DAO, not a vote. "Live" means active verification and contribution. The society does\n'
+  o += 'not change the mathematics; it checks it. entails → 0/7.'
+  return o
+}

package/src/9/vortex.lean

@@ -0,0 +1,11 @@
+import Mathlib
+/-- Digit 9 — the void / modulus: 9 ≡ 0 in ℤ/9; ten's-complement partner of 1.
+    Holds the digital-root-9 facts: the doubling circuit's digit sum (27 = 3³)
+    and 432 = 2⁴·3³ = 16·27 (digital root 4+3+2 = 9). -/
+namespace Vortex.D9
+theorem nine_is_zero : (9 : ZMod 9) = 0 := by decide
+theorem complement_one : 9 + 1 = 10 := by norm_num
+theorem doubling_digit_sum : 1 + 2 + 4 + 8 + 7 + 5 = 27 := by norm_num
+theorem k432 : (432 : ℕ) = 2 ^ 4 * 3 ^ 3 ∧ (432 : ℕ) = 16 * 27 := by norm_num
+theorem k432_digital_root : 4 + 3 + 2 = 9 := by norm_num
+end Vortex.D9

package/src/claims/index.ts

@@ -0,0 +1,87 @@
+// The claims registry — the binding that turns "every claim recomputes from src/" from a slogan into
+// a decidable, gated fact. A CLAIM here is a REGISTERED, bound assertion: prose text + a recompute()
+// that reads its value from src/ + the expected value + (where one exists) the provable theorem(s) in
+// the discovery ledger that back it. claims-gate.ts recomputes each, gate-checks the text, confirms the
+// invited theorems exist in the chain-verified ledger, and reconciles the counts (the coins accounted
+// into development). "Every registered claim recomputes" is then TRUE BY CONSTRUCTION over this set — a
+// bounded universal, not a floating "every". It certifies the registry, never unmarked prose.
+// HONEST: recompute proves INTEGRITY (the value is what src/ computes); an invited theorem adds
+// ungameable backing; neither certifies the interpretation. The floor stays 0/7.
+import { toUuid, merkleFold, TRINITY, BASE, units, triad, vortexOrbit, A432_STEP } from '../0/index.ts'
+import { CAPACITY, roundTrips, skill, coin64 } from '../0/imprint.ts'
+import { entails } from '../honesty/index.ts'
+import { BOUNDARY_STATEMENTS } from '../honesty/boundaries.ts'
+import { coins } from '../9/funding.ts'
+
+export interface Claim {
+  id: string
+  text: string
+  recompute: () => string
+  expect: string
+  theorems?: string[] // keys in src/proof/discovered.json — provable backing, re-checked by the gate
+}
+
+// the seven Clay conjectures: each statement is a tautology → entails nothing → solved count 0.
+const clayFloor = (): string =>
+  Array.from({ length: 7 }, () => entails(true)).filter((e) => e.solves).length + '/7'
+
+// a battery of messages that must all round-trip through the imprint codec (boundary cases included).
+const IMPRINT_BATTERY = ['', '1', '1011', '01001000', '1'.repeat(CAPACITY)]
+
+export const CLAIMS: readonly Claim[] = [
+  { id: 'floor',  text: '0/7 entailed: this deposit leaves all seven Millennium problems unsolved, and claims no prize.',
+    recompute: clayFloor,                              expect: '0/7',           theorems: ['both_games_overclaim_loses'] },
+  { id: 'axiom',  text: 'one irreducible axiom: the trinity, 3 — the base 9 is 3 squared.',
+    recompute: () => String(TRINITY),                  expect: '3',             theorems: ['relation_three'] },
+  { id: 'base',   text: 'the ring is Z/9 — base nine, derived as the trinity squared.',
+    recompute: () => String(BASE),                     expect: '9',             theorems: ['relation_three'] },
+  { id: 'units',  text: 'the units of Z/9 are 1,2,4,5,7,8 — a group under multiplication.',
+    recompute: () => units().join(','),                expect: '1,2,4,5,7,8',   theorems: ['trial_units_group', 'euler_units_pow6', 'units_sum_zero', 'self_inverse_1_8'] },
+  { id: 'unitn',  text: 'the multiplicative group of Z/9 has 6 elements, as does the symmetric group S3.',
+    recompute: () => String(units().length),           expect: '6',             theorems: ['s3_order6'] },
+  { id: 'triad',  text: 'the triad of Z/9 (the non-units) is 3,6,9.',
+    recompute: () => triad().join(','),                expect: '3,6,9',         theorems: ['relation_three'] },
+  { id: 'orbit',  text: 'the doubling orbit from 1 covers the units: 1,2,4,8,7,5.',
+    recompute: () => vortexOrbit().join(','),          expect: '1,2,4,8,7,5',   theorems: ['both_games_truth_and_honesty'] },
+  { id: 'a432',   text: 'the angular step is 360/9 = 40 degrees.',
+    recompute: () => String(A432_STEP),                expect: '40' },
+  { id: 'coins',  text: 'the two coins are 110 minus 108 = 2 = minus the Euler characteristic of a genus-2 surface.',
+    recompute: () => String(coins()),                  expect: '2',             theorems: ['relation_genus_two', 'surface_euler_char', 'receipt_pair_is_two_coins'] },
+  { id: 'fund',   text: 'the two coins are accounted into development: destination equals source, a self-loop.',
+    recompute: () => String(toUuid('ceccec') === toUuid('ceccec')), expect: 'true' },
+  { id: 'imprint', text: 'a binary message imprinted into a uuid reads back exactly — a reversible codec.',
+    recompute: () => String(IMPRINT_BATTERY.every(roundTrips)), expect: 'true' },
+  { id: 'skill',  text: 'the clown catches every bit: the imprint round-trip fidelity is 1.',
+    recompute: () => String(skill('1'.repeat(CAPACITY)).fidelity), expect: '1', theorems: ['relation_clown_benefits_from_all'] },
+  { id: 'bounds', text: 'the honest floor publishes 10 content-addressed boundaries.',
+    recompute: () => String(BOUNDARY_STATEMENTS.length), expect: '10' },
+  { id: 'coin64', text: 'the shared currency is a 64-bit coin: any content mints 16 hex digits, deterministically.',
+    recompute: () => String(coin64('ceccec').length) + ':' + String(coin64('ceccec') === coin64('ceccec')), expect: '16:true' },
+  { id: 'tuning', text: 'the example: A440 minus A432 is 8 Hz — a tuning convention, not a measured acoustic law.',
+    recompute: () => String(440 - 432), expect: '8' },
+]
+
+export interface AddressedClaim { id: string; text: string; got: string; expect: string; ok: boolean; uuid: string; theorems: string[] }
+
+/** Each claim recomputed and content-addressed. ok = the value from src/ equals what the prose asserts. */
+export function addressed(): AddressedClaim[] {
+  return CLAIMS.map((c) => {
+    let got: string
+    try { got = c.recompute() } catch (e) { got = 'THROW:' + (e as Error).message }
+    return { id: c.id, text: c.text, got, expect: c.expect, ok: got === c.expect, uuid: toUuid(c.id + '|' + c.text + '|' + c.expect), theorems: c.theorems ?? [] }
+  })
+}
+
+/** The registry root — a merkle fold of every claim's content-address. Any edit moves the root. */
+export function root(): string { return merkleFold(addressed().map((a) => a.uuid)) }
+
+export function report(): string {
+  const rows = addressed()
+  const ok = rows.filter((r) => r.ok).length
+  let o = 'the claims registry — every registered claim recomputes from src/ (got = recompute(); expect = the prose):\n\n'
+  for (const r of rows) o += '  ' + (r.ok ? '✓' : '✗') + ' ' + r.id.padEnd(8) + r.got.padEnd(16) + (r.ok ? '= ' : '≠ ') + r.expect + (r.theorems.length ? '   ⊢ ' + r.theorems.length + ' theorem(s)' : '') + '\n'
+  o += '\n  ' + ok + '/' + rows.length + ' claims recompute · registry root ' + root().slice(0, 13) + '…\n'
+  o += '  a "claim" here is a REGISTERED, bound assertion; this makes "every claim recomputes" true over\n'
+  o += '  the registry (bounded, gated) — integrity, not truth. it does not certify unregistered prose. entails → 0/7.'
+  return o
+}

package/src/from/the/heart/index.ts

@@ -0,0 +1,11 @@
+// from the heart — the generative act. `next` computes "from the heart (5)": discover a decidable fact,
+// save it, prove it, ship it — each wave flowing from the centre outward, kept iff it computes.
+import { toUuid, vortexOrbit } from '../../../0/index.ts'
+export function report(): string {
+  let o = 'from the heart (5) — the generative act:\n\n'
+  o += '  next computes from the heart: discover a decidable fact → save it → prove it → ship it.\n'
+  o += '  each wave flows from the centre (5) along the circuit: ' + vortexOrbit().join(' → ') + '.\n'
+  o += '  what is discovered is kept iff it computes; the rest is drained. from the heart, honestly.\n'
+  o += '  address: ' + toUuid('from-the-heart:next').slice(0, 13) + '… entails → 0/7.'
+  return o
+}

package/src/honesty/boundaries.ts

@@ -0,0 +1,30 @@
+// The honest floor — the boundary statements, canonical IN src/ (so they literally recompute from
+// source, not from a build script). Each is content-addressed by toUuid(statement); boundaries.ts
+// renders them to the site and claims-gate.ts binds their count. Only gate-passing statements ship.
+// A content-address proves INTEGRITY, not truth.
+import { toUuid } from '../0/index.ts'
+
+export const BOUNDARY_STATEMENTS: readonly string[] = [
+  '0/7 entailed: this deposit leaves all seven Millennium problems unsolved, and claims no prize.',
+  'computable is not solved; humanityNovel = 0 — known mathematics, recombined.',
+  'a content-address (uuid) proves integrity, not truth, and not authorship.',
+  'the honesty gate is a floor (no named overclaim shape), not an oracle of truth.',
+  'recognition, adoption, citations, and effort are not correctness.',
+  'a classical Z/9 calculator: no quantum computation, no faster-than-light, no quantum speedup.',
+  'sealing proves the bytes are intact; it does not prove the claim is right.',
+  'unsigned: content-addressing is integrity, not authenticity — real signatures need a key.',
+  'worthwhile is a judgment (perspective); small, real, and honest are measured.',
+  'green cannot be faked: the gate measures actual state, and it caught its own author.',
+]
+
+/** Each statement paired with its content-address (short uuid), recomputed from src. */
+export function addressed(): { uuid: string; statement: string }[] {
+  return BOUNDARY_STATEMENTS.map((s) => ({ uuid: toUuid(s).slice(0, 13), statement: s }))
+}
+
+export function report(): string {
+  let o = 'the honest floor — ' + BOUNDARY_STATEMENTS.length + ' boundaries, each content-addressed (recompute toUuid):\n\n'
+  for (const { uuid, statement } of addressed()) o += '  ' + uuid + '  ' + statement + '\n'
+  o += '\n  a content-address proves INTEGRITY, not truth. the floor is 0/7.'
+  return o
+}

package/src/honesty/index.ts

@@ -0,0 +1,22 @@
+// Honesty toolkit — reusable tests for ANY bold claim. Pure, browser-safe.
+export function entails(trueWhenConjectureFalse: boolean) {
+  return { solves: !trueWhenConjectureFalse,
+    note: trueWhenConjectureFalse ? 'true even when the conjecture is false → entails nothing' : 'can be false when the conjecture is false → may entail' }
+}
+export function curveFitCheck(target: number, consts: number[], ints = [1, 2, 3, 5, 7, 11, 13, 17], control?: number) {
+  const best = (t: number) => { let b = { err: Infinity, expr: '' }; for (const a of consts) for (const c of [1, ...consts]) for (const k of ints) { const v = a * k / c; const e = Math.abs(v - t) / t; if (e < b.err) b = { err: e, expr: a + '·' + k + '/' + c + ' = ' + v } } return b }
+  const f = best(target), g = control !== undefined ? best(control) : null
+  return { fit: f.expr, err: f.err, controlFit: g?.expr ?? null, vacuous: g ? g.err < 0.02 : null }
+}
+export function scaleCheck(a: number, b: number) { const r = a / b; return { ratio: r, orders: Math.round(Math.log10(Math.abs(r))) } }
+export function report(): string {
+  const e = entails(true)
+  const c = curveFitCheck(1836.15267, [9, 16, 27, 108, 216, 432], [1, 2, 3, 5, 7, 11, 13, 17], 1837.4)
+  const s = scaleCheck(7e20, 432)
+  let o = 'honesty toolkit — point these at any claim:\n'
+  o += '  entails(true-when-conjecture-false): solves=' + e.solves + '  → ' + e.note + '\n'
+  o += '  curveFitCheck(m_p/m_e): best ' + c.fit + '   vacuous? ' + c.vacuous + ' (same fit hits control 1837.4)\n'
+  o += '  scaleCheck(nuclear 7e20 Hz, 432 Hz): ~10^' + s.orders + ' apart\n'
+  o += 'three questions for any bold claim: does it ENTAIL? does the FIT fit anything? do the SCALES match?'
+  return o
+}

package/src/play/the/game/index.ts

@@ -0,0 +1,12 @@
+// play the game — the act of playing. Run next: a wave discovers decidable facts, proves them, ships
+// them; the games and their receipts fold to one; every move is kept iff it computes, else drained.
+import { toUuid } from '../../../0/index.ts'
+export function report(): string {
+  let o = 'play the game — the act:\n\n'
+  o += '  play: run next → a wave discovers decidable facts → proves them → ships them.\n'
+  o += '  the games (Nim, Wythoff, chess, tic-tac-toe, …) and their receipts fold to one root.\n'
+  o += '  the rules: measure · gate · due process · receipts · one game — all playable, all honest.\n'
+  o += '  a move is kept iff it computes; an over-reach is drained with a case. play, honestly.\n'
+  o += '  address: ' + toUuid('play-the-game').slice(0, 13) + '… entails → 0/7.'
+  return o
+}