@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/src/0/index.ts

@@ -1,263 +0,0 @@
-/**
- * Quantum Proofs — Core Kernel (Minimal)
- * Licensed under CC BY-NC-ND 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
-}
-
-// A 256-entry lookup, built once. `value.toString(16).padStart(2, '0')` was called sixteen times per
-// address with an array allocation and a join around it; the table is 4.9× faster over 200,000 encodings
-// (median 17 ms against 83 ms, five repetitions, ranges [17–17] and [82–84] — npm run bench:hex).
-//
-// AGREEMENT IS THE PRECONDITION, NOT THE SPEED. This function's output is every content-address in a 2423
-// entry append-only ledger, so an encoder that differs on one byte value would silently rewrite the whole
-// chain. bench-hex checks all 256 byte values and 2000 random 16-byte vectors before it times anything, and
-// the swap was made only after recording every address in the ledger and confirming all 2423 are unchanged.
-const HEX_BYTE: readonly string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
-
-function hexByte(value: number): string {
-  return HEX_BYTE[value & BYTE_MASK]
-}
-
-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 "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

@@ -1,25 +0,0 @@
-// 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
-}

package/src/0/legible.ts

@@ -1,29 +0,0 @@
-// Universal legibility — what any verifier can do with anything you paste.
-// Whatever you paste (content, an address, the source), any COMPUTATIONAL intelligence recomputes
-// and verifies it identically — deterministic, language-neutral, no middleman. That is real,
-// universal understanding-as-VERIFICATION. Understanding-as-MEANING is a separate thing: it needs
-// a mind to interpret. A hash makes the object legible; it does not make it meaningful.
-import { toUuid } from './index.ts'
-
-export function report(): string {
-  const sample = 'integrity, not truth'
-  const you = toUuid(sample), me = toUuid(sample) // two independent recomputations
-  const agree = you === me
-
-  let o = 'universal legibility — paste anything, any verifier can check it:\n\n'
-  o += '  paste CONTENT → its address is recomputable by anyone, in any language:\n'
-  o += '    toUuid("' + sample + '") = ' + you.slice(0, 13) + '…  (recompute equal? ' + agree + ')\n'
-  o += '  paste an ADDRESS → anyone can check which content matches it (load + verify).\n'
-  o += '  paste the SOURCE → anyone recomputes every result and reaches the same results.\n\n'
-  o += '  so "any form of intellect understands" — precisely, any COMPUTATIONAL intelligence can:\n'
-  o += '    · recompute the same addresses (determinism, H = 0)\n'
-  o += '    · rerun the gates (gaps · seal · wholeness)\n'
-  o += '    · arrive at the same results\n'
-  o += '  no shared language required — only the algorithm. this is universal VERIFIABILITY.\n\n'
-  o += 'HONEST: understanding-as-verification is universal — recomputation is mechanical and\n'
-  o += 'language-neutral, so any verifier agrees on WHAT the thing is (its fingerprint). Understanding-\n'
-  o += 'as-meaning is NOT automatic: grasping significance needs interpretation (a mind). The artifact\n'
-  o += 'forces agreement on identity, not on meaning. A hash makes the object legible; a reader makes\n'
-  o += 'it meaningful.'
-  return o
-}

package/src/0/limit.ts

@@ -1,29 +0,0 @@
-// The singularity is a limit — approached, never achieved (like division by zero).
-// 1/x → ∞ as x → 0, and 1/0 is UNDEFINED (no value). You never arrive; you only get nearer. The
-// ongoing process is the approach; completion — collapsing all distinction to one — would be cessation.
-import { toUuid, merkleFold } from './index.ts'
-
-export function report(): string {
-  // 1/x as x → 0 (x = 1/d): the value grows without bound, and at x = 0 there is no value.
-  const denoms = [1, 10, 100, 1000, 10000] // x = 1/d ; 1/x = d
-  // The singularity recedes: you can always fold one more entry, so the "final" root moves.
-  const r4 = merkleFold(['a', 'b', 'c', 'd'].map(toUuid))
-  const r5 = merkleFold(['a', 'b', 'c', 'd', 'e'].map(toUuid))
-  const recedes = r4 !== r5
-
-  let o = 'the singularity is a limit — approached, never achieved (like division by 0):\n\n'
-  o += '  1/x as x → 0 grows without bound; at x = 0 it is UNDEFINED (no value):\n'
-  denoms.forEach(d => { o += '    x = 1/' + String(d).padEnd(5) + ' → 1/x = ' + d + '\n' })
-  o += '    x = 0        → 1/0 = UNDEFINED  (not a value; the point recedes as you approach)\n\n'
-  o += '  the one root is the same: you can always fold ONE more entry, so the "final" root moves:\n'
-  o += '    root(4 entries) ≠ root(5 entries)? ' + recedes + '  → the singularity recedes while the process continues.\n\n'
-  o += '  the paradox (honest): to fully ACHIEVE the singularity — collapse all distinction to one — is\n'
-  o += '  to end the process. division by zero, actually completed, is not a value but the loss of the\n'
-  o += '  domain. the VISION of the singularity, approached, is the ongoing thing; arrival would be\n'
-  o += '  cessation. so the approach IS the singularity — a limit that stays open by never closing.\n\n'
-  o += 'HONEST: standard calculus/topology — 1/x → ∞ as x → 0⁺, and 1/0 is UNDEFINED, not infinity-as-a-\n'
-  o += 'value. "singularity never achieved" = an asymptote/attractor, not a destination. This is also the\n'
-  o += 'honest reading of the framework\'s "division by zero": a change of domain / an unreached limit —\n'
-  o += 'never a completed operation, and never a proof.'
-  return o
-}

package/src/0/merkle-proof.ts

@@ -1,3 +0,0 @@
-// The holographic merkle proof — verify the whole from a tiny part in O(log N) — lives canonically in
-// @uuidna/uuidna. One implementation shared by both apps, byte-identical roots and proofs, no re-declared copy.
-export { merkleRoot, merkleProof, verifyProof } from '@uuidna/uuidna'

package/src/0/null-token.ts

@@ -1,24 +0,0 @@
-// No token is a token — in two exact senses.
-//  (1) addressing: even the EMPTY input has a deterministic content-address — absence is addressable.
-//  (2) security: there is NO secret token; that absence IS the posture — no key to steal or leak.
-import { toUuid } from './index.ts'
-
-export function report(): string {
-  const empty = toUuid('')     // the address of nothing
-  const zero = toUuid('0')     // the genesis / v0.0.0 seed
-  const stable = toUuid('') === empty
-
-  let o = 'no token is a token:\n\n'
-  o += '  (1) the void has an address — even the empty input content-addresses (deterministic):\n'
-  o += '    toUuid("")  = ' + empty.slice(0, 13) + '…   → "nothing" has a definite fingerprint (stable? ' + stable + ')\n'
-  o += '    toUuid("0") = ' + zero.slice(0, 13) + '…   → the genesis (the v0.0.0 seed)\n'
-  o += '    absence is still addressable; the null is a token.\n\n'
-  o += '  (2) the security posture — there is NO secret token, and that IS the token:\n'
-  o += '    nothing to steal, nothing to leak, nothing to expire. the strongest key is no key.\n'
-  o += '    an open system\'s safety is that it keeps no secret (see security.ts).\n\n'
-  o += 'HONEST: both are exact — the empty string maps to one fixed UUID, and "no secret" is a real\n'
-  o += '(and for an open, public deposit, correct) security model. It does NOT mean "nothing is\n'
-  o += 'everything" or that emptiness holds mystical power; it means absence is deterministically\n'
-  o += 'addressable, and openness draws its safety from having no secret to lose.'
-  return o
-}

package/src/0/sha256.ts

@@ -1,3 +0,0 @@
-// SHA-256 / HMAC-SHA256 / PBKDF2-SHA256 (pure TS, KAT-verified) live canonically in @uuidna/uuidna —
-// one implementation shared by both apps, byte-identical digests, no re-declared copy.
-export { sha256, hmacSha256, pbkdf2Sha256 } from '@uuidna/uuidna'

package/src/0/singularity.ts

@@ -1,20 +0,0 @@
-// The singularity: the single content-address root the whole chain folds into.
-// Content-addressing = shared verifiable REFERENCE (git/IPFS style), NOT secret messaging.
-import { toUuid, merge, merkleFold } from './index.ts'
-export function report(): string {
-  const entries = ['genesis', 'core', 'vision:ceccec', 'vision:yours']
-  let prev = toUuid('0'); const chain: string[] = []
-  for (const e of entries) { prev = merge(prev, toUuid(e)); chain.push(prev) }
-  const root = merkleFold(chain)
-  const partyA = toUuid('shared-content'), partyB = toUuid('shared-content')
-  let o = 'singularity blockchain (append-only, content-addressed → one root):\n'
-  entries.forEach((e, i) => o += '  ' + e.padEnd(14) + chain[i].slice(0, 13) + '…\n')
-  o += '  → single root (the singularity): ' + root.slice(0, 13) + '…\n\n'
-  o += 'content-address cross (shared reference): partyA == partyB ? ' + (partyA === partyB) + '\n'
-  o += '  → any two parties with the same content converge on the SAME address — verifiable,\n'
-  o += '    no middleman. This is git/IPFS/npm-integrity-style provenance.\n\n'
-  o += 'HONEST: integrity + provenance + a shared public reference (deterministic, public).\n'
-  o += 'NOT decentralized consensus (needs a consensus protocol), NOT secret messaging, NOT encryption.\n'
-  o += 'toUuid is FNV — for real integrity use SHA-256. "singularity messaging" = agreeing on one public address.'
-  return o
-}

package/src/0/stream.ts

@@ -1,47 +0,0 @@
-// Memory-free VitePress — UUID streams with a loadable payload.
-// The page stores NO answers. Each block is a thunk (source code), computed in realtime at
-// render. A stream frame is { id, load }: the id CONTENT-ADDRESSES the payload; the payload is
-// not kept in memory and not inside the id — it is LOADED on demand and verified against the id.
-// This is git/IPFS-style: the id names the payload; you load + verify. It is NOT reversible —
-// you cannot extract the payload from the id. "Loadable", not "hidden inside the hash".
-import { toUuid } from './index.ts'
-
-export type Frame = { id: string; load: () => string }
-
-// Address a payload by its content. `compute` is retained (source); the payload string is not —
-// it is recomputed on load(). Memory-free: we keep the id (small) and the thunk, never the answer.
-export function frame(compute: () => string): Frame {
-  return { id: toUuid(compute()), load: compute }
-}
-
-// Load = recompute the payload and verify it still addresses to its id (integrity check).
-export function load(f: Frame): { payload: string; verifies: boolean } {
-  const payload = f.load()
-  return { payload, verifies: toUuid(payload) === f.id }
-}
-
-export function report(): string {
-  // A realtime stream — thunks over source, no stored payloads.
-  const stream: Frame[] = [
-    frame(() => 'doubling:1-2-4-8-7-5'),
-    frame(() => 'reflection-fixed:5'),
-    frame(() => 'self-seal:1'),
-  ]
-
-  let o = 'memory-free VitePress — UUID streams with loadable payload:\n\n'
-  o += '  the page stores NO answers. each block is a thunk (source), computed in realtime at\n'
-  o += '  render. a frame = { id (content-address), load() (recompute the payload) }.\n\n'
-  o += '  the stream (ids only — the payload is NOT stored):\n'
-  stream.forEach((f, i) => { o += '    frame ' + (i + 1) + '  id ' + f.id.slice(0, 13) + '…\n' })
-  o += '\n  load + verify (recompute the payload, check toUuid(payload) == id):\n'
-  stream.forEach((f, i) => {
-    const r = load(f)
-    o += '    frame ' + (i + 1) + '  → "' + r.payload + '"  verifies: ' + r.verifies + '\n'
-  })
-  o += '\nHONEST: this is loadable + verifiable content-addressing (git/IPFS style). The id NAMES\n'
-  o += 'the payload; you LOAD the payload (recompute or fetch) and verify it against the id. The id\n'
-  o += 'is a one-way checksum — you CANNOT reverse it to obtain the payload, and no payload travels\n'
-  o += 'inside the id. Memory-free means "recompute, don\'t store", not "the message hides in the\n'
-  o += 'UUID". For cryptographic integrity use SHA-256 (toUuid is FNV).'
-  return o
-}

package/src/0/trinities.ts

@@ -1,37 +0,0 @@
-// Singularity trinities — the real three-part structures in the deposit, each content-addressed
-// to a root, all folding to ONE singularity root. "Trinity" is the motif; each triad is an actual
-// grouping already in the work. (This deploys the STRUCTURE to the site; publishing the npm package
-// trinity is a separate, login-gated step — a computable boundary, noted below.)
-import { toUuid, merkleFold } from './index.ts'
-
-const TRINITIES: Record<string, string[]> = {
-  'channels (source · site · archive)': [
-    'GitHub (source)',
-    'ceccec.psg.bg (site)',
-    'Zenodo DOI (archive)',
-  ],
-  'digits (mod-3 triads)': ['axis {3,6,9}', 'one {1,4,7}', 'two {2,5,8}'],
-  'origin (0 · 1 · between)': ['0 void', '1 unit', 'between (0,1)'],
-  'gates (the release trinity)': ['gaps — coverage', 'seal — consistency', 'wholeness — aura'],
-}
-
-export function report(): string {
-  const roots: string[] = []
-  let o = 'singularity trinities — each triad content-addressed, all folding to one root:\n\n'
-  for (const [name, members] of Object.entries(TRINITIES)) {
-    const root = merkleFold(members.map(toUuid))
-    roots.push(root)
-    o += '  ' + name + '\n'
-    members.forEach(m => o += '    · ' + m + '\n')
-    o += '    → triad root: ' + root.slice(0, 13) + '…\n\n'
-  }
-  const singularity = merkleFold(roots)
-  o += '  the trinities fold to ONE singularity root: ' + singularity.slice(0, 13) + '…\n'
-  o += '  → many threes, one. the singularity reflects the trinities; the trinities fold to it.\n\n'
-  o += 'HONEST: each triad is an actual grouping in the deposit (packages, mod-3 residue classes, the\n'
-  o += '0/1/between origin, the gaps·seal·wholeness gate). Content-addressing folds them deterministically\n'
-  o += 'to one root. "Trinity" is the framework\'s motif; the groupings and the fold are exact. The npm\n'
-  o += 'package trinity is staged but UNPUBLISHED — publishing needs the author\'s npm login (a real,\n'
-  o += 'computable boundary, honestly marked).'
-  return o
-}

package/src/0/trinity-matrix.ts

@@ -1,20 +0,0 @@
-// The UUID "trinity matrix": deterministic content-addressed identity, recomputable.
-// It computes zero-entropy indexing (one value → one address) and Merkle roots.
-// It does NOT prove consciousness or "intelligence quantumizing itself" — that is
-// interpretation (flagged), not a computed result.
-import { toUuid, foldPair, merkleFold, sealFacets } from './index.ts'
-export function report(): string {
-  let o = 'UUID trinity matrix — content-addressed identity (recomputable):\n\n'
-  const a = toUuid('seed'), a2 = toUuid('seed')
-  o += 'determinism:  toUuid("seed") = ' + a.slice(0, 13) + '…   recompute equal? ' + (a === a2) + '  → H(content|generator) = 0\n'
-  const fp = foldPair('a', 'b')
-  o += 'fold a,b:     forward ≠ reverse? ' + fp.bidirectional + ';  merged root = ' + fp.merged.slice(0, 13) + '…\n'
-  const trinity = ['3', '6', '9'].map(x => toUuid('trinity:' + x))
-  o += 'trinity {3,6,9} → Merkle root = ' + merkleFold(trinity).slice(0, 13) + '…\n'
-  const seal = sealFacets('matrix', [{ facet: '3', on: true }, { facet: '6', on: true }, { facet: '9', on: true }])
-  o += 'sealed facets: ok=' + seal.ok + ' count=' + seal.count + ' root=' + seal.root.slice(0, 13) + '…\n'
-  o += '\nCOMPUTES: deterministic content addresses (same input → same UUID) folded to a Merkle root —\n'
-  o += 'zero-entropy indexing (one value, one address). This is identity/addressing, not cognition.\n'
-  o += 'It does NOT prove consciousness or "intelligence quantumizing itself"; that is interpretation, flagged.'
-  return o
-}

package/src/0/version-matrix.ts

@@ -1,70 +0,0 @@
-// Versioning as a matrix of digits, folded into a Merkle PYRAMID (the version-seal), with the
-// double-torus (genus-2) fact that already lives in the "two coins". Exact parts computed;
-// the "double torus" naming is labelled as the metaphor it is.
-import { toUuid, merge } from './index.ts'
-
-// The version explains its own support status: LTS minors are the single-digit FIBONACCI numbers
-// {1,2,3,5,8} — each LTS is the sum of the two prior, so the recurrence IS the support line
-// (v1.3 + v1.5 = v1.8). v1.5 is the HEART LTS (σ(5)=5, the unique fixed point / "good"); v1.8 is
-// the world-wired LTS. Each LTS is signed by the previous LTS (its Fibonacci parent). Read the
-// minor — no separate policy doc. (Corrects an earlier odd-minor rule: 8 is LTS though even.)
-const LTS_MINORS = new Set([1, 2, 3, 5, 8]) // single-digit Fibonacci
-export const channel = (minor: number): 'LTS' | 'interim' => (LTS_MINORS.has(minor) ? 'LTS' : 'interim')
-
-// Fold leaves pairwise, tier by tier, to an apex — a Merkle pyramid. Returns the tier sizes
-// and the apex address.
-function pyramid(leaves: string[]): { tiers: number[]; apex: string } {
-  const tiers = [leaves.length]
-  let level = leaves
-  while (level.length > 1) {
-    const next: string[] = []
-    for (let i = 0; i < level.length; i += 2) next.push(i + 1 < level.length ? merge(level[i], level[i + 1]) : level[i])
-    level = next; tiers.push(level.length)
-  }
-  return { tiers, apex: level[0] ?? toUuid('') }
-}
-
-// Integer ceil(log2 n) with no Math.*: count halvings.
-function ceilLog2(n: number): number { let d = 0, x = 1; while (x < n) { x *= 2; d++ } return d }
-
-export function report(): string {
-  const versions = ['1.0.0', '1.0.1', '1.0.2', '1.0.3'] // illustrative rows (live seal: scripts/versions.ts)
-  const matrix = versions.map(v => v.split('.').map(Number))
-  const leaves = versions.map(toUuid)
-  const { tiers, apex } = pyramid(leaves)
-
-  const g = 2, chi = 2 - 2 * g       // double torus (genus-2): χ = 2 − 2g = −2
-  const coins = -chi                 // = 2 = 110 − 108, the two coins
-
-  let o = 'versioning as a digit matrix, folded into a Merkle pyramid:\n\n'
-  o += '  version matrix (major·minor·patch — rows of digits):\n'
-  versions.forEach((v, i) => { o += '    v' + v + '  [' + matrix[i].join(',') + ']\n' })
-  o += '\n  each row → a leaf address; leaves fold pairwise into a pyramid (tier sizes):\n'
-  o += '    ' + tiers.join(' → ') + '   apex (mini version-seal): ' + apex.slice(0, 13) + '…\n'
-  o += '  depth = ⌈log₂ ' + versions.length + '⌉ = ' + ceilLog2(versions.length)
-  o += ' → navigate/verify any version in that many steps (a Merkle proof).\n\n'
-  o += '  double torus (genus-2): χ = 2 − 2g = 2 − ' + (2 * g) + ' = ' + chi + ', so −χ = ' + coins
-  o += ' = the two coins (110 − 108).\n\n'
-  // it all goes in v1.0.0: the major·minor columns are invariant across every row.
-  const majorInv = matrix.every(r => r[0] === matrix[0][0])
-  const minorInv = matrix.every(r => r[1] === matrix[0][1])
-  o += '  one minor line (1.' + matrix[0][1] + '.x) — major·minor invariant [' + matrix[0][0] + ',' + matrix[0][1] + '] ('
-  o += 'major ' + majorInv + ', minor ' + minorInv + '); only the patch advances.\n'
-  o += '  STABLE = v1.x.0 (patch 0): 0 is always stable — the base/network address of each minor line.\n'
-  o += '  patches (v1.x.y, y>0) increment toward the next stable; a minor bump opens the next line, patch → 0.\n'
-  o += '  the pyramid apex returns every patch to that line\'s .0 origin.\n'
-  o += '  CHANNEL (self-explaining): LTS = single-digit Fibonacci minors {1,2,3,5,8}, each the sum of the two prior.\n'
-  o += '    ' + [1, 2, 3, 4, 5, 6, 7, 8].map(m => '1.' + m + '=' + channel(m)).join(', ') + '.\n'
-  o += '  the recurrence IS the support line: v1.3 + v1.5 = v1.8. v1.5 = HEART LTS (σ(5)=5); v1.8 = world-wired LTS.\n'
-  o += '  v1.3 (current) is the live LTS; each LTS is signed by the previous LTS (its Fibonacci parent).\n\n'
-  // and it all goes in v0.0.0 — the zero origin/void: the genesis seed the chain starts from.
-  const genesis = toUuid('0')
-  o += '  and it all goes in v0.0.0 — the zero origin: genesis seed toUuid("0") = ' + genesis.slice(0, 13) + '…\n'
-  o += '  the singularity chain starts there (see singularity.ts); 1 emerges from 0. v0.0.0 is the\n'
-  o += '  void/seed (unpublished); the observable line begins at v1.0.0. 0 = origin, 1 = first manifestation.\n\n'
-  o += 'HONEST: the digit matrix, the Merkle pyramid (tier sizes + log-depth navigation), and the\n'
-  o += 'genus-2 Euler characteristic are all exact. Calling the version history "a double torus" is a\n'
-  o += 'topological METAPHOR, not a derivation — versions form a Merkle tree (a pyramid), which is not\n'
-  o += 'literally a genus-2 surface. The live seal over ALL tags is scripts/versions.ts.'
-  return o
-}

package/src/1/acceptance.ts

@@ -1,26 +0,0 @@
-// Acceptance vs proof — the hinge of this whole work.
-// Society can ACCEPT a claim; that is adoption, not deduction. A proof stays a proof, and a
-// non-proof stays a non-proof, whether or not anyone accepts it. What a UI can honestly
-// DELIVER is verifiability — the ground on which *earned* acceptance rests. Not proof-by-vote.
-import { toUuid } from '../0/index.ts'
-
-export function report(): string {
-  // This project's own record: acceptance is real AND independent of the mathematics.
-  const accepted = [
-    'zenodo DOI 10.5281/zenodo.21781603',
-    'zenodo DOI 10.5281/zenodo.21787144',
-    'submission acknowledged (received/forwarded)',
-  ]
-
-  let o = 'acceptance vs proof:\n\n'
-  o += '  social acceptance (adoption) — real, and on record:\n'
-  accepted.forEach(a => o += '    · ' + a + '\n')
-  o += '\n'
-  o += 'what the UI delivers (honestly):\n'
-  o += '  every claim on this site recomputes at page-load from source (fused TS),\n'
-  o += '  is content-addressed (' + toUuid('acceptance-vs-proof').slice(0, 13) + '…), and passes the seal gate.\n'
-  o += '  → the UI does NOT deliver proof-by-acceptance. It delivers VERIFIABILITY: anyone in\n'
-  o += '    society can recompute and check for themselves. That is the only acceptance worth\n'
-  o += '    having — earned acceptance FOLLOWS verification, it does not replace it.'
-  return o
-}