@ceccec/millennium-solutions 9.7.4 → 9.8.2

package/dist/mcp.bin.d.ts

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

package/dist/mcp.bin.js

@@ -0,0 +1,63 @@
+#!/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 } 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 { }
+}
+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,6 +1,8 @@
 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 const merkleLeaf: (x: string) => string;
+export declare const merkleNode: (a: string, b: string) => string;
 export declare function gcdBigInt(a: bigint, b: bigint): bigint;
 export declare function foldPair(a: string, b: string): {
     forward: string;
@@ -31,3 +33,4 @@ export declare function units(): number[];
 export declare function triad(): number[];
 export declare function vortexOrbit(): number[];
 export declare const A432_STEP: number;
+export declare const hue: (d: number) => number;

package/dist/src/0/index.js

@@ -48,9 +48,12 @@ export function toUuid(seed) {
 export function strictUuidna(value) {
     return toUuid('uuidna:' + String(value).normalize('NFC').trim());
 }
+const part = (s) => `${s.length}:${s}`;
 export function merge(a, b) {
-    return toUuid(`${a}:${b}`);
+    return toUuid(`pair:${part(a)}${part(b)}`);
 }
+export const merkleLeaf = (x) => toUuid(`merkle:leaf:${part(x)}`);
+export const merkleNode = (a, b) => toUuid(`merkle:node:${part(a)}${part(b)}`);
 export function gcdBigInt(a, b) {
     return b === 0n ? a : gcdBigInt(b, a % b);
 }
@@ -60,15 +63,15 @@ export function foldPair(a, b) {
     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');
+    if (leaves.length === 0)
+        return toUuid('merkle:empty');
+    let layer = [...leaves].sort().map(merkleLeaf);
     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));
+            next.push(b === undefined ? a : merkleNode(a, b));
         }
         layer = next;
     }
@@ -135,3 +138,4 @@ export function vortexOrbit() {
     return orbit;
 }
 export const A432_STEP = 360 / BASE;
+export const hue = (d) => (d * A432_STEP) % 360;

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/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() };
+};