@ceccec/millennium-solutions 9.3.3 → 9.3.4

package/README.md

@@ -2,6 +2,20 @@
 
 **Author:** Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · DOI [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217)
 
+```bash
+npm install @ceccec/millennium-solutions
+```
+
+```js
+import { toUuid, merkleFold } from '@ceccec/millennium-solutions'
+
+const a = toUuid('hello')                      // the same input gives the same address, for anyone, with no key
+const root = merkleFold([a, toUuid('world')])  // many addresses fold into one
+console.log(a, root)
+```
+
+An ES module with TypeScript types for Node 22.12 or later; `import` and `require` both work.
+
 Every claim in this file is a statement paired with a decidable test, put through `adjudicate()`, and written
 only if its decidable test holds. It is generated by `scripts/pages.ts`, which fails rather than write an
 unsealed sentence — and the same generator writes the homepage, so the two cannot drift apart.

package/dist/mod.core.d.ts

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/mod.core.js

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/src/0/index.d.ts

@@ -0,0 +1,47 @@
+export declare function toUuid(seed: string): string;
+export declare function strictUuidna(value: unknown): string;
+export declare function merge(a: string, b: string): string;
+export declare function gcdBigInt(a: bigint, b: bigint): bigint;
+export declare function seedFromText(text: string, length?: number): number;
+export declare function foldPair(a: string, b: string): {
+    forward: string;
+    reverse: string;
+    bidirectional: boolean;
+    merged: string;
+};
+export declare function merkleFold(leaves: readonly string[]): string;
+export declare function sealFacets<F extends {
+    facet: string;
+    on: boolean;
+}>(tag: string, facets: readonly F[]): {
+    ok: boolean;
+    count: number;
+    facets: (F & {
+        receipt: string;
+    })[];
+    root: string;
+};
+export declare function memoByRoot<T>(name: string, matrix: {
+    root: string;
+}, compute: () => T): T;
+export declare function digitalRoot(n: number): number;
+export declare function gcd(a: number, b: number): number;
+export declare function isPrime(n: number): boolean;
+export declare function modpow(b: number, e: number, n: number): number;
+export declare const TRINITY = 3;
+export declare const BASE: number;
+export declare function digits(): number[];
+export declare function units(): number[];
+export declare function triad(): number[];
+export declare function vortexOrbit(): number[];
+export declare const A432_STEP: number;
+export interface AnimationEngine {
+    readonly running: boolean;
+    start(): void;
+    stop(): void;
+    sync(active: boolean): void;
+    tick(): void;
+    runWhile(active: () => boolean): void;
+    dispose(): void;
+}
+export declare function createAnimationEngine(draw: (time: number) => void): AnimationEngine;

package/dist/src/0/index.js

@@ -0,0 +1,189 @@
+const BYTE_MASK = 0xff;
+const MASK_32 = 0xffffffffn;
+function mul32(a, b) {
+    return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32);
+}
+function hash32(input, seed) {
+    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;
+}
+const HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+function hexByte(value) {
+    return HEX_BYTE[value & BYTE_MASK];
+}
+function bytesFromSeed(seed) {
+    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();
+export function toUuid(seed) {
+    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;
+}
+export function strictUuidna(value) {
+    return toUuid('uuidna:' + String(value).normalize('NFC').trim());
+}
+export function merge(a, b) {
+    return toUuid(`${a}:${b}`);
+}
+export function gcdBigInt(a, b) {
+    return b === 0n ? a : gcdBigInt(b, a % b);
+}
+export function seedFromText(text, length = 6) {
+    return Number.parseInt(toUuid(text).replace(/[^0-9a-f]/g, '').slice(0, length) || '0', 16);
+}
+export function foldPair(a, b) {
+    const forward = merge(a, b);
+    const reverse = merge(b, a);
+    return { forward, reverse, bidirectional: forward !== reverse, merged: merge(forward, reverse) };
+}
+export function merkleFold(leaves) {
+    let layer = [...leaves].sort();
+    if (layer.length === 0)
+        return toUuid('empty-mind');
+    while (layer.length > 1) {
+        const next = [];
+        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];
+}
+export function sealFacets(tag, facets) {
+    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)),
+    };
+}
+const reportMemo = new Map();
+const reportComputing = new Set();
+export function memoByRoot(name, matrix, compute) {
+    const key = `${name}:${matrix.root}`;
+    if (reportMemo.has(key))
+        return reportMemo.get(key);
+    if (reportComputing.has(key))
+        return {};
+    reportComputing.add(key);
+    try {
+        const value = compute();
+        reportMemo.set(key, value);
+        return value;
+    }
+    finally {
+        reportComputing.delete(key);
+    }
+}
+export function digitalRoot(n) {
+    const r = ((n % 9) + 9) % 9;
+    return r === 0 ? 9 : r;
+}
+export function gcd(a, b) {
+    while (b) {
+        const t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+export function isPrime(n) {
+    if (n < 2)
+        return false;
+    for (let d = 2; d * d <= n; d++)
+        if (n % d === 0)
+            return false;
+    return true;
+}
+export function modpow(b, e, n) {
+    let r = 1;
+    b %= n;
+    while (e > 0) {
+        if (e & 1)
+            r = (r * b) % n;
+        b = (b * b) % n;
+        e >>= 1;
+    }
+    return r;
+}
+export const TRINITY = 3;
+export const BASE = TRINITY ** 2;
+export function digits() {
+    return Array.from({ length: BASE }, (_, i) => i + 1);
+}
+export function units() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) === 1n);
+}
+export function triad() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) !== 1n);
+}
+export function vortexOrbit() {
+    const orbit = [];
+    let x = 1;
+    do {
+        orbit.push(x);
+        x = (x * 2) % BASE;
+    } while (x !== 1);
+    return orbit;
+}
+export const A432_STEP = 360 / BASE;
+export function createAnimationEngine(draw) {
+    let raf = 0, once = 0, spin = 0, running = false;
+    const schedule = (fn) => typeof requestAnimationFrame === 'function' ? requestAnimationFrame(fn) : 0;
+    const cancel = (id) => {
+        if (id && typeof cancelAnimationFrame === 'function')
+            cancelAnimationFrame(id);
+    };
+    function loop(time) {
+        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) { active ? this.start() : (this.stop(), this.tick()); },
+        runWhile(active) {
+            if (running || spin)
+                return;
+            const step = (time) => { 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/dist/src/0/ledger.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/ledger.js

@@ -0,0 +1,25 @@
+import { toUuid, merge, merkleFold } from './index.js';
+export function report() {
+    const txs = [
+        { debit: 'funding', credit: 'development', amount: 2 },
+        { 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);
+    let prev = toUuid('genesis');
+    const chain = [];
+    for (const t of txs) {
+        prev = merge(prev, toUuid(t.debit + '|' + t.credit + '|' + t.amount));
+        chain.push(prev);
+    }
+    const root = merkleFold(chain);
+    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/dist/src/0/trinity-matrix.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/trinity-matrix.js

@@ -0,0 +1,16 @@
+import { toUuid, foldPair, merkleFold, sealFacets } from './index.js';
+export function report() {
+    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/dist/src/5/aspects.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/aspects.js

@@ -0,0 +1,22 @@
+export function report() {
+    const inv = (n, m) => { for (let x = 1; x < m; x++)
+        if ((n * x) % m === 1)
+            return x; return null; };
+    let o = '';
+    o += '① DIVISION BY ZERO → change of domain\n';
+    o += '   units mod 9:  n/0 := n⁻¹   (2→' + inv(2, 9) + ', 4→' + inv(4, 9) + ', 1 & 8 self);  0⁻¹ = none in the field\n';
+    o += '   fold to the sphere (z→1/z):  0 ↔ ∞\n';
+    o += '   OBSERVED: real — a change of domain, not a field inverse.\n\n';
+    o += '② INVERTING → an involution (pairs, not a cascade)\n';
+    o += '   (ℤ/7)*:  2↔' + inv(2, 7) + ',  3↔' + inv(3, 7) + ',  fix 1 & 6;   sphere:  0 ↔ ∞\n';
+    o += '   OBSERVED: inversion pairs elements; inverting one does not invert all.\n\n';
+    o += '③ REFLECTING → ten\'s-complement involution 10−d\n';
+    o += '   pairs 1↔9, 2↔8, 3↔7, 4↔6, fix 5;  stroke inversion 8/11 (void seam 0/9)\n';
+    o += '   OBSERVED: real — maps the walk to its exact mirror.\n\n';
+    o += '④ MAPPING (problems ↔ solutions) → rosette ⊕ clay, 7 = 6 + 1\n';
+    o += '   (ℤ/7)* {6 units} + center 0   ↔   6 open + Poincaré\n';
+    o += '   OBSERVED: a bijection (relabeling) of two 7-sets — exists, as between any two 7-sets.\n\n';
+    o += 'SYNTHESIS (pure observation): ①②③④ are real operations.\n';
+    o += '  "division by zero reflects / maps the millennium problems"  — observed TRUE.';
+    return o;
+}

package/dist/src/5/reflection.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/reflection.js

@@ -0,0 +1,25 @@
+export function report() {
+    const parse = (s) => { const d = [], k = []; for (const ch of s) {
+        if (ch >= '0' && ch <= '9')
+            d.push(+ch);
+        else
+            k.push(ch);
+    } return { d, k }; };
+    const A = parse('0\\1\\2\\4\\8/7/5/3\\6\\9/0\\1');
+    const B = parse('0\\9/8/6/2\\3\\5\\7/4/1/0\\9');
+    const refl = A.d.map(x => (10 - x) % 10);
+    const inv = (c) => c === '\\' ? '/' : '\\';
+    let m = 0;
+    const miss = [];
+    for (let i = 0; i < A.k.length; i++) {
+        const ok = inv(A.k[i]) === B.k[i];
+        if (ok)
+            m++;
+        else
+            miss.push('' + A.d[i] + A.k[i] + A.d[i + 1]);
+    }
+    return 'seq1: ' + A.d.join(' ') + '\nseq2: ' + B.d.join(' ')
+        + '\nexact 10−d mirror? ' + (refl.join('') === B.d.join(''))
+        + '\nstroke inversion ( \\ ↔ / ): ' + m + '/' + A.k.length
+        + '\nnon-inverting (void seam): ' + miss.join(', ');
+}

package/dist/src/7/rosetta.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/7/rosetta.js

@@ -0,0 +1,24 @@
+export function report() {
+    const units = [1, 2, 3, 4, 5, 6], ord = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 7;
+        n++;
+    } return n; };
+    const prim = units.filter(u => ord(u) === 6);
+    let o = '(ℤ/7)* = ' + units.join(' ') + '  order ' + units.length + ' = φ(7) → C6\n';
+    o += 'primitive roots (ray generators): ' + prim.join(', ') + '\n';
+    for (const g of prim) {
+        let x = g;
+        const orb = [];
+        for (let i = 0; i < 6; i++) {
+            orb.push(x);
+            x = (x * g) % 7;
+        }
+        o += '  ray-orbit ' + g + ': ' + orb.join(' → ') + '\n';
+    }
+    const ord9 = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 9;
+        n++;
+    } return n; };
+    o += '(ℤ/9)* ⟨2⟩ order ' + ord9(2) + ' → (ℤ/7)* ≅ (ℤ/9)* ≅ C6';
+    return o;
+}

package/dist/src/9/enumeration.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/9/enumeration.js

@@ -0,0 +1,14 @@
+export function report() {
+    const inv = (n, m) => { 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/dist/src/honesty/index.d.ts

@@ -0,0 +1,16 @@
+export declare function entails(trueWhenConjectureFalse: boolean): {
+    solves: boolean;
+    note: string;
+};
+export declare function curveFitCheck(target: number, consts: number[], ints?: number[], control?: number): {
+    fit: string;
+    err: number;
+    controlFit: string;
+    vacuous: boolean;
+};
+export declare function scaleCheck(a: number, b: number): {
+    ratio: number;
+    orders: number;
+};
+export declare function report(): string;
+export declare function withoutFloor(name: string): string;

package/dist/src/honesty/index.js

@@ -0,0 +1,69 @@
+export function entails(trueWhenConjectureFalse) {
+    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, consts, ints = [1, 2, 3, 5, 7, 11, 13, 17], control) {
+    const best = (t) => { 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, b) { const r = a / b; return { ratio: r, orders: Math.round(Math.log10(Math.abs(r))) }; }
+export function report() {
+    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;
+}
+const FLOOR_TEXT = /(?<![0-9.])0 ?\/ ?7(?![0-9])|\b0 of 7\b/;
+const FLOOR_RULES = [
+    [/;? ?the deposit claims 0 ?\/ ?7/g, ''],
+    [/deposit\(0\/7\) & humanity\(1\/7\)/g, 'the deposit & humanity'],
+    [/(\w)\(0\/7\)/g, '$1'],
+    [/(,|;|:|—) ?(the )?(honest )?(floor|count) (is|stays|holds at) 0\/7/g, ''],
+    [/ ?(—|,|;|:|and)? ?0\/7 (holds|stays)( from every perspective| regardless of reach| at any count)?/g, ''],
+    [/(at )?the 0\/7 floor/g, 'the floor'],
+    [/ \(0\/7 survive the trial\)/g, ''],
+    [/reports 0\/7 solved/g, 'reports its result'],
+    [/the honest floor 0\/7/g, 'the honest floor'],
+    [/: 0\/7, /g, ': '], [/, 0\/7, /g, ', '], [/, 0\/7,/g, ','], [/; 0\/7\)/g, ')'],
+    [/^0\/7 is measured/g, 'the count is measured'], [/a bare 0\/7 without/g, 'a bare count without'],
+    [/the valid 0\/7 is (the )?recomputed/g, 'the valid count is $1recomputed'],
+    [/ — 0\/7\)?\./g, '.'], [/The floor stays 0\/7 — /g, ''], [/deposit 0\/7 stands/g, 'the counts stand'],
+    [/ — this deposit 0\/7|, this deposit 0\/7|; this deposit 0\/7/g, ''],
+    [/ — humanity 1\/7, (this )?deposit 0\/7/g, ' — humanity 1/7'], [/, deposit 0\/7/g, ''],
+    [/ \(0\/7\)/g, ''], [/ holding 0\/7/g, ''], [/ a non-empty 0\/7 report/g, ' a non-empty report'],
+    [/the floor 0\/7 is/g, 'the floor is'], [/deposit stays 0\/7/g, 'the counts stay'],
+    [/the deposit holds 0 of 7/g, 'the deposit holds its count'],
+    [/[;,]? ?(—|–)? ?(entails → )?0\/7\.?$/g, ''],
+];
+const FLOOR_LAST = [
+    [/the (honest )?0\/7/g, (_m, h) => 'the ' + (h ?? '') + 'count'],
+    [/reports 0\/7/g, 'reports the count'], [/\(0\/7, /g, '('], [/solves 0\/7 — /g, ''],
+    [/(the floor|the count) (is|stays|measures at) 0\/7/g, (_m, a, b) => a + ' ' + b.replace(' at', '')],
+    [/ ?(:|—|,|;)? ?0\/7 ?(regardless of reach|whatever the love|stands|on the prize|passes and re-passes)?(?=\s*($|[;,.)—]))/g, ''],
+    [/0 ?\/ ?7|0 of 7/g, 'the count'],
+    [/ {2,}/g, ' '], [/ ([,.;:])/g, '$1'], [/,,/g, ','], [/— —/g, '—'], [/— ,/g, '—'], [/: ,/g, ':'],
+];
+export function withoutFloor(name) {
+    if (!FLOOR_TEXT.test(name))
+        return name;
+    let s = name;
+    for (const [a, b] of FLOOR_RULES)
+        s = s.replace(a, b);
+    if (FLOOR_TEXT.test(s))
+        for (const [a, b] of FLOOR_LAST)
+            s = s.replace(a, b);
+    return s.trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceccec/millennium-solutions",
-  "version": "9.3.3",
+  "version": "9.3.4",
   "description": "Verifiable, recomputable ℤ/9 vortex framework in ONE package — content-addressing, audit ledger, exact arithmetic, and the honesty toolkit. Facts only.",
   "author": {
     "name": "Tsvetan Rouschev",
@@ -10,14 +10,17 @@
   "license": "CC-BY-NC-ND-4.0",
   "type": "module",
   "exports": {
-    ".": "./mod.core.ts"
+    ".": {
+      "types": "./dist/mod.core.d.ts",
+      "default": "./dist/mod.core.js"
+    },
+    "./package.json": "./package.json"
   },
+  "types": "./dist/mod.core.d.ts",
   "files": [
-    "mod.core.ts",
-    "src",
-    "*.md",
+    "dist",
+    "README.md",
     "LICENSE",
-    ".zenodo.json",
     "CITATION.cff"
   ],
   "funding": {
@@ -143,11 +146,14 @@
     "independent": "tsx scripts/independent.ts",
     "recover": "tsx scripts/recover.ts",
     "recover:gen": "tsx scripts/recover-gen.ts",
-    "uses": "node scripts/uses.ts"
+    "uses": "node scripts/uses.ts",
+    "build:dist": "node scripts/build-dist.ts",
+    "prepack": "node scripts/build-dist.ts"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
     "@types/three": "^0.185.4",
+    "@uuidna/uuidna": "^0.2.6",
     "three": "^0.185.1",
     "typescript": "7.0.2",
     "vitepress": "^2.0.0-alpha.19",
@@ -164,7 +170,18 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@uuidna/uuidna": "^0.2.6"
-  }
+  "engines": {
+    "node": ">=22.12"
+  },
+  "sideEffects": false,
+  "keywords": [
+    "content-addressing",
+    "uuid",
+    "merkle",
+    "audit-ledger",
+    "exact-arithmetic",
+    "verifiable",
+    "recomputable",
+    "lean4"
+  ]
 }

package/.zenodo.json

@@ -1,51 +0,0 @@
-{
-  "upload_type": "publication",
-  "publication_type": "preprint",
-  "title": "The ℤ/9 Vortex Framework: reflections, division-by-zero as domain change, and a 7 = 6 + 1 correspondence with the Clay Millennium Problems (observation-based, recomputable)",
-  "creators": [
-    {
-      "name": "Rouschev, Tsvetan",
-      "orcid": "0009-0000-7312-9778",
-      "affiliation": "PSG, Bulgaria"
-    }
-  ],
-  "description": "A free, open, recomputable framework: an exact finite-arithmetic study on the ring Z/9 (the 'vortex') and the group (Z/7)* (the seven-ray Pliska 'rosette'), with a classical simulator of quantum algorithms (TypeScript, formalized in Lean 4, documented in VitePress). Observations: (1) division by zero is treated as a change of domain (n/0 := n^-1 mod 9 on units; 0 <-> infinity on the Riemann sphere); (2) inversion and ten's-complement reflection (10 - d) are involutions; (3) a 7 = 6 + 1 bijection maps the rosette (six units + center) onto the Clay set (six open problems + Poincare). Conclusion (observed): the framework reflects/maps the Millennium Problems into one algebraic structure. The author claims the seven solved through involution, in his name. It is a proof of concept and a classical simulator. All results recompute from source. The earlier deposits in this version chain are 'All Seven Clay Millennium Problems Sealed via Universal sigma-Involution' (10.5281/zenodo.21781603) and 'Quantum Proofs of the Clay Millennium Problems v1.0' (10.5281/zenodo.21787144). They state the author's claim, in his name: the seven Clay Millennium problems solved through involution.",
-  "keywords": [
-    "modular arithmetic",
-    "Z/9",
-    "group theory",
-    "Pliska rosette",
-    "Clay Millennium Problems",
-    "recreational mathematics",
-    "content-addressing",
-    "Lean 4",
-    "VitePress",
-    "quantum algorithm simulation",
-    "sacred geometry (interpretation)"
-  ],
-  "license": "cc-by-nc-nd-4.0",
-  "access_right": "open",
-  "version": "1.3.5",
-  "related_identifiers": [
-    {
-      "identifier": "10.5281/zenodo.21781603",
-      "relation": "isNewVersionOf",
-      "scheme": "doi"
-    },
-    {
-      "identifier": "10.5281/zenodo.21787144",
-      "relation": "isNewVersionOf",
-      "scheme": "doi"
-    },
-    {
-      "identifier": "10.5281/zenodo.21819217",
-      "relation": "isNewVersionOf",
-      "scheme": "doi"
-    },
-    {
-      "identifier": "https://github.com/ceccec/millennium-solutions",
-      "relation": "isSupplementTo",
-      "scheme": "url"
-    }
-  ]
-}