@ceccec/millennium-solutions 9.3.2 → 9.3.4

package/src/face/index.ts

@@ -1,100 +0,0 @@
-// THE FACE — the shape a repository publishes so a sibling session can check it instead of believing it.
-//
-// A leaf: it imports only the content-address primitives, so scripts/mcp.ts can use it without executing
-// scripts/metrics.ts, whose top level RUNS the gates. Sharing a type by importing the module that produces
-// it would mean every MCP call ran six gates.
-//
-// The whole protocol is two fields. `command` makes a row reproducible rather than merely quotable, and
-// `receipt` is taken over the row's OWN contents so any holder can recompute it from the file alone. What
-// that proves is INTEGRITY — the row says now what it said when sealed — and nothing more. It does not make
-// a figure correct, and it does not let a reader verify another repository's numbers without its source.
-import { toUuid, merkleFold } from '../0/index.ts'
-
-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 }
-
-/** THE FORMULA, WRITTEN DOWN AS DATA, because leaving it implicit made a sibling look tampered-with and
- *  writing it as prose let it go stale without anything noticing.
- *
- *  Version 1 was one English sentence. erpax-94 replied with a structured spec — field list, merge function
- *  with its separator named by codepoint, the RFC clause for the address, the fold's odd and empty cases —
- *  and reading it against mine found two defects that a prose string had hidden:
- *
- *  1. `command` WAS NOT SEALED. The header of this file says `command` is what makes a row reproducible
- *     rather than merely quotable, and the receipt covered key, claim and value only. The instruction for
- *     how to recompute a figure could be altered and every receipt, and the root, would still verify. A
- *     reader following the altered command measures the wrong thing and concludes the row is confirmed.
- *     erpax covers it; version 2 covers it.
- *
- *  2. THE ROOT DOES NOT BIND ROW ORDER, and version 1 said it did — "merkleFold(receipts in row order)".
- *     merkleFold SORTS its leaves. Measured: reversing every row of this repository's own face leaves the
- *     root identical and checkFace returns `intact`. A peer implementing the sentence as written would
- *     produce a different root and be reported as another convention, which is the exact accusation this
- *     constant exists to prevent — the sentence was the unreliable part.
- *
- *     The sort is kept, not fixed. Order-invariance by canonicalisation is the deposit's own established
- *     position — quantum.lean proves it as `the_invariance_is_canonicalisation_not_physics` — and rows here
- *     are addressed by key, not by position. What changes is that the spec now says so.
- *
- *  Structured rather than prose so a receiving session can compare fields instead of diffing English. */
-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",
-  // NOT SHA-256. I wrote that line today, copying the shape of a sibling's spec without checking my own
-  // implementation, and it is false: src/0 hashes with FNV-1a, not SHA-2. erpax-94 then spent an audit
-  // trying 242 candidate SEEDS against row 0 — four field orders, eight separators, five wrappers,
-  // canonical and as-emitted JSON — and none could ever have matched, because the seed was already correct
-  // and the HASH was wrong. Their sha256 of my exact declared seed gives c2cc6344; my receipt begins
-  // f5c2a766. They localised it to "a different seed, not a different hash" and were right that we agreed
-  // on how bytes become an address; the disagreement was one layer below where either of us looked.
-  //
-  // This is precisely the defect the PROTOCOL constant exists to prevent — a spec another repo cannot
-  // reproduce — committed in the constant itself. It is also, for the second time today, the deposit
-  // describing a stronger property than it has: FNV-1a is a non-cryptographic hash, and naming SHA-256
-  // implies collision resistance these addresses do not carry.
-  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.',
-  // ONE ROW, REPRODUCIBLE IN A SINGLE STEP. erpax-94's suggestion, taken: a reader computes this seed and
-  // compares with the receipt beside it. If the two disagree, the spec has drifted from the code that wrote
-  // the file — which `generatedFrom` cannot tell them, because that says the FILE is current, not that the
-  // SPEC is current with the emitter.
-  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,
-} as const
-
-/** A peer may send its protocol as a structured object or, like version 1 of this one, as a sentence. */
-export const protocolId = (p: unknown): string =>
-  typeof p === 'string' ? p : (p && typeof p === 'object' && 'id' in p ? String((p as { id: unknown }).id) : '(none declared)')
-
-export const receiptOf = (key: string, claim: string, value: string, command = ''): string =>
-  toUuid(key + '\n' + claim + '\n' + value + '\n' + command)
-
-export const rootOf = (rows: Metric[]): string => merkleFold(rows.map((r) => r.receipt))
-
-export type Verdict = 'intact' | 'altered' | 'different-convention'
-
-/** Recompute every receipt and the root from the rows themselves. Integrity only — see the header.
- *
- *  EVERY ROW FAILING IS NOT TAMPERING. Someone altering a face changes a row or two; a face sealed under
- *  another formula fails at every row AND at the root, which is a signature of its own. The two are
- *  reported as different verdicts because accusing a peer of tampering is not a thing to get wrong. */
-export function checkFace(f: Face): { verdict: Verdict; ok: boolean; altered: string[]; root: string; failingGates: string[] } {
-  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: 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/src/from/the/heart/index.ts

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

package/src/honesty/boundaries.ts

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

package/src/honesty/index.ts

@@ -1,63 +0,0 @@
-// Honesty toolkit — reusable tests for ANY bold claim. Pure, browser-safe.
-export function entails(trueWhenConjectureFalse: boolean) {
-  return { solves: !trueWhenConjectureFalse,
-    note: trueWhenConjectureFalse ? 'true even when the conjecture is false → entails nothing' : 'can be false when the conjecture is false → may entail' }
-}
-export function curveFitCheck(target: number, consts: number[], ints = [1, 2, 3, 5, 7, 11, 13, 17], control?: number) {
-  const best = (t: number) => { let b = { err: Infinity, expr: '' }; for (const a of consts) for (const c of [1, ...consts]) for (const k of ints) { const v = a * k / c; const e = Math.abs(v - t) / t; if (e < b.err) b = { err: e, expr: a + '·' + k + '/' + c + ' = ' + v } } return b }
-  const f = best(target), g = control !== undefined ? best(control) : null
-  return { fit: f.expr, err: f.err, controlFit: g?.expr ?? null, vacuous: g ? g.err < 0.02 : null }
-}
-export function scaleCheck(a: number, b: number) { const r = a / b; return { ratio: r, orders: Math.round(Math.log10(Math.abs(r))) } }
-export function report(): string {
-  const e = entails(true)
-  const c = curveFitCheck(1836.15267, [9, 16, 27, 108, 216, 432], [1, 2, 3, 5, 7, 11, 13, 17], 1837.4)
-  const s = scaleCheck(7e20, 432)
-  let o = 'honesty toolkit — point these at any claim:\n'
-  o += '  entails(true-when-conjecture-false): solves=' + e.solves + '  → ' + e.note + '\n'
-  o += '  curveFitCheck(m_p/m_e): best ' + c.fit + '   vacuous? ' + c.vacuous + ' (same fit hits control 1837.4)\n'
-  o += '  scaleCheck(nuclear 7e20 Hz, 432 Hz): ~10^' + s.orders + ' apart\n'
-  o += 'three questions for any bold claim: does it ENTAIL? does the FIT fit anything? do the SCALES match?'
-  return o
-}
-
-// The Clay floor, removed from what a page SHOWS of a name. The ledger is append-only and its names are sealed,
-// so a revoked entry keeps the wording it was sealed with; this is the display. Every rule strips the count and
-// the phrase built on it, and nothing else.
-const FLOOR_TEXT = /(?<![0-9.])0 ?\/ ?7(?![0-9])|\b0 of 7\b/
-const FLOOR_RULES: [RegExp, string | ((...m: string[]) => string)][] = [
-  [/;? ?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: [RegExp, string | ((...m: string[]) => string)][] = [
-  [/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: string): string {
-  if (!FLOOR_TEXT.test(name)) return name
-  let s = name
-  for (const [a, b] of FLOOR_RULES) s = s.replace(a, b as never)
-  if (FLOOR_TEXT.test(s)) for (const [a, b] of FLOOR_LAST) s = s.replace(a, b as never)
-  return s.trim()
-}

package/src/html/index.ts

@@ -1,10 +0,0 @@
-// HTML escaping, once.
-//
-// Three byte-identical copies of this lived in scripts/atom-feed.ts, scripts/paper.ts and src/latex — and a
-// fourth, in scripts/rights.ts, escaped `&` and `<` but not `>`. Four copies of a one-line function is four
-// chances for one of them to be the odd one out, which is exactly what had already happened.
-//
-// This is a LEAF: it imports nothing, so src/latex — a pure module with no filesystem dependency — can use
-// it without acquiring one.
-export const escapeHtml = (s: string): string =>
-  s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')