@ceccec/millennium-solutions 9.7.6 → 9.8.3

package/dist/mcp.bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp.bin.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline';
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { run, served, withLedger, withFormulas, withBake } from './src/mcp/serve.js';
+const here = dirname(fileURLToPath(import.meta.url));
+for (const p of [join(here, 'data', 'discovered.json'), join(here, '..', 'src', 'proof', 'discovered.json')]) {
+    if (!existsSync(p))
+        continue;
+    try {
+        withLedger(JSON.parse(readFileSync(p, 'utf8')));
+        break;
+    }
+    catch { }
+}
+for (const p of [join(here, 'data', 'formulas.jsonld'), join(here, '..', 'public', 'formulas.jsonld')]) {
+    if (!existsSync(p))
+        continue;
+    try {
+        const j = JSON.parse(readFileSync(p, 'utf8'));
+        const rows = (j.itemListElement ?? []).map((e) => {
+            const i = (e.item ?? e);
+            return { name: i.name, statement: i.description, key: i.identifier, source: i.source, wing: i.wing, proof: i.proof };
+        }).filter((r) => r.name);
+        if (rows.length) {
+            withFormulas(rows);
+            break;
+        }
+    }
+    catch { }
+}
+for (const dir of [join(here, 'data', 'baked')]) {
+    const idx = join(dir, 'index.json');
+    if (!existsSync(idx))
+        continue;
+    try {
+        const j = JSON.parse(readFileSync(idx, 'utf8'));
+        const answers = {};
+        for (const n of j.baked) {
+            const p = join(dir, n + '.json');
+            if (existsSync(p))
+                answers[n] = JSON.parse(readFileSync(p, 'utf8')).answer;
+        }
+        withBake({ stamp: j.stamp, answers, notBaked: j.notBaked });
+        break;
+    }
+    catch { }
+}
+const send = (m) => process.stdout.write(JSON.stringify(m) + '\n');
+const rl = createInterface({ input: process.stdin });
+rl.on('line', (line) => {
+    if (!line.trim())
+        return;
+    let id = null;
+    try {
+        const req = JSON.parse(line);
+        id = req.id ?? null;
+        const ok = (result) => send({ jsonrpc: '2.0', id, result });
+        if (req.method === 'initialize') {
+            return ok({ protocolVersion: '2024-11-05', capabilities: { tools: {} },
+                serverInfo: { name: 'millennium-solutions (self-sufficient entry)', version: 'from the published package' } });
+        }
+        if (req.method === 'tools/list') {
+            return ok({ tools: [
+                    { name: 'list_tools', description: 'What this entry serves, and what each tool it does not serve needs instead.', inputSchema: { type: 'object', properties: { name: { type: 'string' } } } },
+                    { name: 'call_tool', description: 'Call one of the served tools.', inputSchema: { type: 'object', properties: { name: { type: 'string', enum: served() }, arguments: { type: 'object' } }, required: ['name'] } },
+                ] });
+        }
+        if (req.method === 'tools/call') {
+            return ok({ content: [{ type: 'text', text: run(String(req.params?.name ?? ''), req.params?.arguments ?? {}) }] });
+        }
+        if (req.method?.startsWith('notifications/'))
+            return;
+        send({ jsonrpc: '2.0', id, error: { code: -32601, message: `method not found: ${String(req.method)}` } });
+    }
+    catch (e) {
+        send({ jsonrpc: '2.0', id, error: { code: -32603, message: e instanceof Error ? e.message : String(e) } });
+    }
+});

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

@@ -1,3 +1,4 @@
+export declare const SEEDS: readonly number[];
 export declare function toUuid(seed: string): string;
 export declare function strictUuidna(value: unknown): string;
 export declare function merge(a: string, b: string): string;

package/dist/src/0/index.js

@@ -1,7 +1,7 @@
 const BYTE_MASK = 0xff;
-const MASK_32 = 0xffffffffn;
 function mul32(a, b) {
-    return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32);
+    const al = a & 0xffff, ah = a >>> 16, bl = b & 0xffff, bh = b >>> 16;
+    return (al * bl + ((ah * bl + al * bh) & 0xffff) * 0x10000) >>> 0;
 }
 function hash32(input, seed) {
     let h = (0x811c9dc5 ^ seed) >>> 0;
@@ -18,13 +18,9 @@ const HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2
 function hexByte(value) {
     return HEX_BYTE[value & BYTE_MASK];
 }
+export const SEEDS = [0, 0x9e3779b9, 0x243f6a88, 0xb7e15162];
 function bytesFromSeed(seed) {
-    const words = [
-        hash32(seed, 0),
-        hash32(seed, 0x9e3779b9),
-        hash32(seed, 0x243f6a88),
-        hash32(seed, 0xb7e15162),
-    ];
+    const words = SEEDS.map((s) => hash32(seed, s));
     return words.flatMap((word) => [
         (word >>> (8 * 3)) & BYTE_MASK,
         (word >>> 16) & BYTE_MASK,
@@ -33,10 +29,13 @@ function bytesFromSeed(seed) {
     ]);
 }
 const _uuidCache = new Map();
+const CACHE_LIMIT = 1 << 14;
 export function toUuid(seed) {
     const cached = _uuidCache.get(seed);
     if (cached !== undefined)
         return cached;
+    if (_uuidCache.size >= CACHE_LIMIT)
+        _uuidCache.clear();
     const bytes = bytesFromSeed(seed);
     bytes[6] = (bytes[6] & 0x0f) | 0x80;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;

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

@@ -0,0 +1,41 @@
+export type Metric = {
+    key: string;
+    claim: string;
+    value: string;
+    command: string;
+    receipt: string;
+};
+export type Face = {
+    repo: string;
+    definition: string;
+    protocol?: unknown;
+    generatedFrom?: string;
+    specWitness?: {
+        seed: string;
+        receipt: string;
+    };
+    rows: Metric[];
+    root: string;
+};
+export declare const PROTOCOL: {
+    readonly id: 'millennium-solutions/metric-face/2';
+    readonly covers: readonly ['key', 'claim', 'value', 'command'];
+    readonly chained: false;
+    readonly receipt: 'toUuid(key + LF + claim + LF + value + LF + command)';
+    readonly merge: "toUuid(utf8(a + ':' + b))  — COLON U+003A";
+    readonly address: string;
+    readonly specWitness: 'see the specWitness field on the face itself: the verbatim seed of row 0 and its receipt';
+    readonly root: string;
+    readonly orderInvariant: true;
+};
+export declare const protocolId: (p: unknown) => string;
+export declare const receiptOf: (key: string, claim: string, value: string, command?: string) => string;
+export declare const rootOf: (rows: Metric[]) => string;
+export type Verdict = 'intact' | 'altered' | 'different-convention';
+export declare function checkFace(f: Face): {
+    verdict: Verdict;
+    ok: boolean;
+    altered: string[];
+    root: string;
+    failingGates: string[];
+};

package/dist/src/face/index.js

@@ -0,0 +1,32 @@
+import { toUuid, merkleFold } from '../0/index.js';
+export const PROTOCOL = {
+    id: 'millennium-solutions/metric-face/2',
+    covers: ['key', 'claim', 'value', 'command'],
+    chained: false,
+    receipt: 'toUuid(key + LF + claim + LF + value + LF + command)',
+    merge: "toUuid(utf8(a + ':' + b))  — COLON U+003A",
+    address: 'uuidv8 shaped per RFC 9562 §5.8 (version nibble 8, variant 10x) over FNV-1a — NOT SHA-2: '
+        + 'four 32-bit FNV-1a passes over the UTF-16 code units, each starting at the FNV OFFSET BASIS 0x811c9dc5 '
+        + 'XOR the pass seed — seeds 0, 0x9e3779b9, 0x243f6a88, 0xb7e15162, so h begins at (0x811c9dc5 ^ seed) and '
+        + 'NOT at the seed itself, which is the one line an implementer cannot guess. '
+        + 'with an xor-shift-13 per code unit and a two-round murmur finalizer (0x85ebca6b, 0xc2b2ae35, then >>> 16), '
+        + 'concatenated big-endian to 16 octets. Non-cryptographic: integrity against accident, not against an '
+        + 'adversary.',
+    specWitness: 'see the specWitness field on the face itself: the verbatim seed of row 0 and its receipt',
+    root: 'merkleFold: leaves sorted lexicographically, then pairwise merge up the tree; an odd element '
+        + "carries up unchanged; zero rows fold to toUuid('empty-mind')",
+    orderInvariant: true,
+};
+export const protocolId = (p) => typeof p === 'string' ? p : (p && typeof p === 'object' && 'id' in p ? String(p.id) : '(none declared)');
+export const receiptOf = (key, claim, value, command = '') => toUuid(key + '\n' + claim + '\n' + value + '\n' + command);
+export const rootOf = (rows) => merkleFold(rows.map((r) => r.receipt));
+export function checkFace(f) {
+    const altered = f.rows.filter((r) => receiptOf(r.key, r.claim, r.value, r.command) !== r.receipt).map((r) => r.key);
+    const root = rootOf(f.rows);
+    const rootMatches = root === f.root;
+    const wholesale = f.rows.length > 1 && altered.length === f.rows.length && !rootMatches;
+    const stated = f.protocol !== undefined && protocolId(f.protocol) !== PROTOCOL.id;
+    const verdict = altered.length === 0 && rootMatches ? 'intact'
+        : (wholesale || stated) ? 'different-convention' : 'altered';
+    return { verdict, ok: verdict === 'intact', altered, root, failingGates: f.rows.filter((r) => r.value === 'FAIL').map((r) => r.key) };
+}

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

@@ -0,0 +1,58 @@
+export declare const TRIAL_BOUND = 1000000n;
+export declare const RHO_BUDGET = 500000;
+export type Factorisation = {
+    status: 'FACTORED';
+    factors: string[];
+    primality: 'every factor proved prime by trial division or by the deterministic test';
+} | {
+    status: 'PARTIAL';
+    factors: string[];
+    cofactor: string;
+    cofactorDigits: number;
+    cofactorPrimality: 'probable prime by Miller–Rabin, not proved' | 'composite (a witness was found)' | 'composite (split into open pieces, each above the trial bound)';
+    blocking: string;
+} | {
+    status: 'REFUSED';
+    why: string;
+};
+export declare const millerRabin: (n: bigint) => 'PRIME' | 'COMPOSITE';
+export declare const parseInteger: (input: string) => string | null;
+export declare const factor: (input: string) => Factorisation;
+export declare const rho: (n: bigint, budget?: number) => bigint | null;
+export declare const RAYS: readonly number[];
+export declare const renderDigits: (n: bigint, k: number) => number[];
+export declare const parseDigits: (ds: readonly number[], k: number) => bigint;
+export declare const mirrorDigits: (digits: string) => string | null;
+export type WitnessState = {
+    coin: 'integer' | 'mirror';
+    ray: number;
+    radix: number;
+    digits: number;
+    roundTrip: boolean;
+};
+export type Witness = {
+    register: {
+        coins: 2;
+        rays: 7;
+        faces: 14;
+        source: 'qpu.lean — the served register, faces = coins × rays';
+    };
+    coins: {
+        integer: Factorisation & {
+            n: string;
+        };
+        mirror: (Factorisation & {
+            n: string;
+        }) | {
+            status: 'UNDEFINED';
+            why: string;
+        };
+    };
+    states: WitnessState[];
+    agree: boolean;
+    failures: string[];
+};
+export declare const factorWitnessed: (input: string) => (Factorisation & {
+    n?: string;
+    witness?: Witness;
+});

package/dist/src/factor/index.js

@@ -0,0 +1,209 @@
+export const TRIAL_BOUND = 1000000n;
+export const RHO_BUDGET = 500_000;
+const DETERMINISTIC_LIMIT = 3317044064679887385961981n;
+const modPow = (base, exp, mod) => {
+    let result = 1n;
+    let b = base % mod;
+    let e = exp;
+    while (e > 0n) {
+        if (e & 1n)
+            result = (result * b) % mod;
+        b = (b * b) % mod;
+        e >>= 1n;
+    }
+    return result;
+};
+const BASES = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n];
+export const millerRabin = (n) => {
+    if (n < 2n)
+        return 'COMPOSITE';
+    for (const p of BASES) {
+        if (n === p)
+            return 'PRIME';
+        if (n % p === 0n)
+            return 'COMPOSITE';
+    }
+    let d = n - 1n;
+    let r = 0;
+    while ((d & 1n) === 0n) {
+        d >>= 1n;
+        r++;
+    }
+    for (const a of BASES) {
+        let x = modPow(a, d, n);
+        if (x === 1n || x === n - 1n)
+            continue;
+        let composite = true;
+        for (let i = 1; i < r; i++) {
+            x = (x * x) % n;
+            if (x === n - 1n) {
+                composite = false;
+                break;
+            }
+        }
+        if (composite)
+            return 'COMPOSITE';
+    }
+    return 'PRIME';
+};
+export const parseInteger = (input) => {
+    const t = input.trim().replace(/_/g, '');
+    if (/^0b[01]+$/i.test(t))
+        return BigInt(t).toString();
+    if (/^0x[0-9a-f]+$/i.test(t))
+        return BigInt(t).toString();
+    if (/^\d+$/.test(t))
+        return t;
+    return null;
+};
+export const factor = (input) => {
+    const digits = parseInteger(input);
+    if (digits === null)
+        return { status: 'REFUSED', why: 'the input is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    let n = BigInt(digits);
+    if (n < 2n)
+        return { status: 'REFUSED', why: `${n} has no factorisation to give` };
+    const found = [];
+    const divide = (d) => { while (n % d === 0n) {
+        found.push(d.toString());
+        n /= d;
+    } };
+    divide(2n);
+    let d = 3n;
+    for (; d <= TRIAL_BOUND && d * d <= n; d += 2n)
+        divide(d);
+    if (n === 1n)
+        return { status: 'FACTORED', factors: found, primality: 'every factor proved prime by trial division or by the deterministic test' };
+    if (d * d > n)
+        return { status: 'FACTORED', factors: [...found, n.toString()], primality: 'every factor proved prime by trial division or by the deterministic test' };
+    const primes = [];
+    const open = [];
+    splitWithRho(n, primes, open);
+    const all = [...found, ...primes.map((p) => p.toString())];
+    if (open.length === 0)
+        return { status: 'FACTORED', factors: all, primality: 'every factor proved prime by trial division or by the deterministic test' };
+    const cofactor = open.reduce((acc, v) => acc * v, 1n);
+    const cofactorPrimality = open.length > 1
+        ? 'composite (split into open pieces, each above the trial bound)'
+        : millerRabin(cofactor) === 'COMPOSITE' ? 'composite (a witness was found)' : 'probable prime by Miller–Rabin, not proved';
+    return { status: 'PARTIAL', factors: all, cofactor: cofactor.toString(), cofactorDigits: cofactor.toString().length, cofactorPrimality,
+        blocking: `the cofactor has no factor below ${TRIAL_BOUND} and Pollard rho did not split it within ${RHO_BUDGET} steps; no method in this tree factors it` };
+};
+export const rho = (n, budget = RHO_BUDGET) => {
+    if (n % 2n === 0n)
+        return 2n;
+    const gcd = (a, b) => { while (b) {
+        [a, b] = [b, a % b];
+    } return a; };
+    const diff = (a, b) => (a > b ? a - b : b - a);
+    let steps = 0;
+    for (let c = 1n; c < 20n; c++) {
+        const f = (v) => (v * v + c) % n;
+        let y = 2n, x = y, ys = y, g = 1n, q = 1n, r = 1;
+        const m = 128;
+        while (g === 1n) {
+            x = y;
+            for (let i = 0; i < r; i++)
+                y = f(y);
+            let k = 0;
+            while (k < r && g === 1n) {
+                ys = y;
+                for (let i = 0; i < Math.min(m, r - k); i++) {
+                    y = f(y);
+                    q = (q * diff(x, y)) % n;
+                }
+                g = gcd(q, n);
+                k += m;
+            }
+            steps += r;
+            r *= 2;
+            if (steps > budget)
+                return null;
+        }
+        if (g === n) {
+            g = 1n;
+            while (g === 1n) {
+                ys = f(ys);
+                g = gcd(diff(x, ys), n);
+            }
+        }
+        if (g !== n)
+            return g;
+    }
+    return null;
+};
+const splitWithRho = (m, primes, open) => {
+    if (m === 1n)
+        return;
+    const verdict = millerRabin(m);
+    if (m < DETERMINISTIC_LIMIT && verdict === 'PRIME') {
+        primes.push(m);
+        return;
+    }
+    const d = verdict === 'COMPOSITE' || m >= DETERMINISTIC_LIMIT ? rho(m) : null;
+    if (d === null || d === 1n || d === m) {
+        open.push(m);
+        return;
+    }
+    splitWithRho(d, primes, open);
+    splitWithRho(m / d, primes, open);
+};
+export const RAYS = [1, 2, 3, 4, 5, 6, 7];
+const GLYPHS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+export const renderDigits = (n, k) => {
+    const b = 1n << BigInt(k), out = [];
+    let m = n;
+    if (m === 0n)
+        return [0];
+    while (m > 0n) {
+        out.unshift(Number(m % b));
+        m /= b;
+    }
+    return out;
+};
+export const parseDigits = (ds, k) => ds.reduce((acc, d) => (acc << BigInt(k)) + BigInt(d), 0n);
+export const mirrorDigits = (digits) => /0/.test(digits) ? null : digits.split('').map((c) => String(10 - Number(c))).join('');
+export const factorWitnessed = (input) => {
+    const digits = parseInteger(input);
+    const base = factor(input);
+    if (digits === null || base.status === 'REFUSED')
+        return base;
+    const n = BigInt(digits);
+    const m = mirrorDigits(digits);
+    const states = [];
+    const failures = [];
+    const coinsOf = m === null ? [['integer', n]] : [['integer', n], ['mirror', BigInt(m)]];
+    for (const [coin, v] of coinsOf)
+        for (const k of RAYS) {
+            const ds = renderDigits(v, k);
+            const ok = parseDigits(ds, k) === v && ds.every((d) => d >= 0 && d < (1 << k));
+            states.push({ coin, ray: k, radix: 1 << k, digits: ds.length, roundTrip: ok });
+            if (!ok)
+                failures.push(`${coin} does not survive radix ${1 << k}`);
+        }
+    const check = (label, r, v) => {
+        if (r.status === 'FACTORED') {
+            const prod = r.factors.reduce((acc, x) => acc * BigInt(x), 1n);
+            if (prod.toString() !== v)
+                failures.push(`${label}: the factors do not multiply back`);
+        }
+        else if (r.status === 'PARTIAL')
+            failures.push(`${label}: ${r.cofactorDigits}-digit cofactor left open — ${r.cofactorPrimality}`);
+        else
+            failures.push(`${label}: ${r.why}`);
+    };
+    check('integer', base, digits);
+    const mirrorFact = m === null
+        ? { status: 'UNDEFINED', why: 'a digit is 0, and 10 − 0 is not a digit: the mirror coin is undefined, which is stated rather than counted' }
+        : { n: m, ...factor(m) };
+    if (mirrorFact.status !== 'UNDEFINED')
+        check('mirror', mirrorFact, m);
+    return {
+        ...base, n: digits,
+        witness: {
+            register: { coins: 2, rays: 7, faces: 14, source: 'qpu.lean — the served register, faces = coins × rays' },
+            coins: { integer: { n: digits, ...base }, mirror: mirrorFact },
+            states, agree: failures.length === 0, failures,
+        },
+    };
+};

package/dist/src/factor/verify.d.ts

@@ -0,0 +1,18 @@
+export type Verification = {
+    status: 'VERIFIED';
+    n: string;
+    factors: string[];
+    primality: string;
+    why: string;
+} | {
+    status: 'PROBABLE';
+    n: string;
+    factors: string[];
+    primality: string;
+    why: string;
+} | {
+    status: 'REFUSED';
+    n: string;
+    why: string;
+};
+export declare const verifyFactors: (nIn: string, factorsIn: string[]) => Verification;

package/dist/src/factor/verify.js

@@ -0,0 +1,28 @@
+import { millerRabin, parseInteger } from './index.js';
+const DETERMINISTIC_LIMIT = 3317044064679887385961981n;
+export const verifyFactors = (nIn, factorsIn) => {
+    const n = parseInteger(nIn) ?? nIn;
+    if (!/^\d+$/.test(n))
+        return { status: 'REFUSED', n, why: 'the integer is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    if (factorsIn.length === 0)
+        return { status: 'REFUSED', n, why: 'no factors were given' };
+    const factors = factorsIn.map((f) => parseInteger(f) ?? f);
+    if (!factors.every((f) => /^\d+$/.test(f)))
+        return { status: 'REFUSED', n, why: 'a factor is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    const values = factors.map((f) => BigInt(f));
+    if (values.some((v) => v < 2n))
+        return { status: 'REFUSED', n, why: 'a factor is below 2, which proves nothing about a factorisation' };
+    const product = values.reduce((acc, v) => acc * v, 1n);
+    if (product !== BigInt(n))
+        return { status: 'REFUSED', n, why: 'the factors do not multiply to the integer' };
+    const unproved = values.filter((v) => v >= DETERMINISTIC_LIMIT);
+    const bad = values.filter((v) => millerRabin(v) === 'COMPOSITE');
+    if (bad.length)
+        return { status: 'REFUSED', n, why: `${bad.length} factor(s) are composite, by a witness the test found, so they are not prime factors` };
+    const primality = unproved.length === 0
+        ? 'every factor proved prime by the deterministic test'
+        : `${values.length - unproved.length} factor(s) proved prime; ${unproved.length} factor(s) above 3.3e24 only probably prime`;
+    if (unproved.length === 0)
+        return { status: 'VERIFIED', n, factors, primality, why: 'the product holds and every factor is proved prime' };
+    return { status: 'PROBABLE', n, factors, primality, why: 'the product holds; some factor passed a probabilistic test, which is not a proof' };
+};

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

@@ -0,0 +1,9 @@
+export declare const HANDLE_HEX = 4;
+export declare const HANDLE_OFFSET = 0;
+export declare const handleOf: (uuid: string) => string;
+export declare const handle: (message: string) => string;
+export declare const carries: (h: string, message: string) => boolean;
+export declare const resolve: (h: string, message: string) => {
+    uuid: string;
+    carries: boolean;
+};

package/dist/src/handle/index.js

@@ -0,0 +1,10 @@
+import { toUuid } from '../0/index.js';
+export const HANDLE_HEX = 4;
+export const HANDLE_OFFSET = 0;
+export const handleOf = (uuid) => uuid.replace(/-/g, '').slice(HANDLE_OFFSET, HANDLE_OFFSET + HANDLE_HEX);
+export const handle = (message) => handleOf(toUuid(message));
+export const carries = (h, message) => handle(message) === h.toLowerCase();
+export const resolve = (h, message) => {
+    const uuid = toUuid(message);
+    return { uuid, carries: handleOf(uuid) === h.toLowerCase() };
+};