universal-physics-tensor 9.0.0 → 11.0.0

package/dist/composition/axis-audit.js

@@ -1,31 +1,102 @@
+/**
+ * Axis-discrimination audit — the anti-inert-metadata gate for the extensible
+ * axis registry (`axes.ts`).
+ *
+ * A classification axis is only load-bearing when it actually SEPARATES real
+ * candidates. This audit runs the discovery link-candidate enumeration and, for
+ * EVERY registry axis (gated or not), measures how often the axis FIRES (both
+ * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at
+ * least one endpoint lacks the attribute), and is CHECKED (both carry it).
+ *
+ * Beside the firing count, each axis carries EVIDENCE: Fisher's exact test (MathTS
+ * `fisherExact`) of its fires against the clashes of the INDEPENDENT magnitude falsifier
+ * (`discovery.ts`, `magnitudeGate`) over the candidates where both gates ran, and an `earned`
+ * flag at {@link AUDIT_ALPHA}. Firing is activity; agreeing with an independent falsifier more
+ * often than chance is evidence. The `discriminates` flag (fires > 0) is the registry's current
+ * criterion and is not changed by the evidence; `GATE_AXES` reads the registry, not this audit.
+ *
+ * Use: an axis stays `gated: false` in the registry until this audit shows it
+ * fires; an axis that only ever abstains is inert and must not be gated. As the
+ * catalog grows into new branches of physics, re-run this and flip the gates the
+ * measurement earns. Rank grows on evidence, not vision.
+ *
+ * @module composition/axis-audit
+ */
+import { fisherExact } from '@danielsimonjr/mathts-functions';
 import { AXES } from './axes.js';
 import { proposeLinkCandidates } from './bridge-analysis.js';
 import { effectiveAttributes, QUANTITY_IDENTIFICATIONS } from './compose.js';
-import { REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';
+import { buildDiscoveryContext, magnitudeGate, REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';
+/**
+ * The level at which an axis is `earned`: 0.05, the conventional two-sided level, fixed before
+ * any table was read. Six axes are audited at once, so a reader who wants a family-wise level
+ * divides by six (0.0083); the flag is per axis and says so here rather than hiding a
+ * correction. Small tables (about twenty magnitude clashes on the catalog) are why the test is
+ * exact and not a χ².
+ *
+ * @internal
+ */
+export const AUDIT_ALPHA = 0.05;
+/** The one Fisher call, read back for what MathTS returns: a number or `null` odds ratio, a number p. */
+function fisher(table) {
+    const r = fisherExact([[...table[0]], [...table[1]]]);
+    const oddsRatio = r.oddsRatio;
+    const pValue = r.pValue;
+    if (typeof pValue !== 'number' || !(pValue >= 0 && pValue <= 1)) {
+        throw new TypeError(`fisherExact returned p = ${String(pValue)} for ${JSON.stringify(table)}`);
+    }
+    return { oddsRatio: typeof oddsRatio === 'number' && Number.isFinite(oddsRatio) ? oddsRatio : null, pValue };
+}
 /**
- * Audit every registry axis's discrimination over the discovery candidate funnel.
+ * Audit every registry axis's discrimination over the discovery candidate funnel, with Fisher
+ * evidence against the magnitude falsifier. The magnitude gate runs once per candidate from one
+ * discovery context (`buildDiscoveryContext`), not the whole funnel.
  *
  * @internal
  */
-export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRIBUTES_BY_NAME, identifications = QUANTITY_IDENTIFICATIONS) {
+export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRIBUTES_BY_NAME, identifications = QUANTITY_IDENTIFICATIONS, options = {}) {
     const candidates = proposeLinkCandidates(edges);
+    const ctx = buildDiscoveryContext(edges, { ...options, identifications, quantityAttributes: attributesByName });
+    const magnitudes = candidates.map((c) => magnitudeGate(c, ctx));
     return AXES.map((spec) => {
         let checked = 0;
         let fires = 0;
         let abstains = 0;
-        for (const c of candidates) {
-            const attrsA = effectiveAttributes(c.a, attributesByName, identifications);
-            const attrsB = effectiveAttributes(c.b, attributesByName, identifications);
+        // The 2×2 table over candidates where both gates ran.
+        let a = 0; // fires ∧ clash
+        let b = 0; // fires ∧ no clash
+        let c = 0; // silent ∧ clash
+        let d = 0; // silent ∧ no clash
+        candidates.forEach((cand, i) => {
+            const attrsA = effectiveAttributes(cand.a, attributesByName, identifications);
+            const attrsB = effectiveAttributes(cand.b, attributesByName, identifications);
             const av = attrsA[spec.name];
             const bv = attrsB[spec.name];
             if (av === undefined || bv === undefined) {
                 abstains++;
-                continue;
+                return;
             }
             checked++;
-            if (av !== bv)
+            const fired = av !== bv;
+            if (fired)
                 fires++;
-        }
+            const gate = magnitudes[i];
+            if (!gate.checked)
+                return; // the falsifier abstained: no row for this candidate
+            if (fired && gate.clash)
+                a++;
+            else if (fired)
+                b++;
+            else if (gate.clash)
+                c++;
+            else
+                d++;
+        });
+        const table = [
+            [a, b],
+            [c, d],
+        ];
+        const { oddsRatio, pValue } = fisher(table);
         return {
             axis: spec.name,
             gated: spec.gated,
@@ -34,6 +105,8 @@ export function auditAxisDiscrimination(edges, attributesByName = REGISTRY_ATTRI
             abstains,
             clashRate: checked > 0 ? fires / checked : 0,
             discriminates: fires > 0,
+            evidence: { table, oddsRatio, pValue, n: a + b + c + d },
+            earned: pValue < AUDIT_ALPHA && a * d > b * c,
         };
     });
 }

package/dist/composition/axis-audit.js.map

@@ -1 +1 @@
-{"version":3,"file":"axis-audit.js","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAsB7D;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAA4B,EAC5B,gBAAgB,GAA0C,2BAA2B,EACrF,eAAe,GAAsC,wBAAwB;IAE7E,MAAM,UAAU,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QACvB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,KAAK,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAGxE,CAAC;YACF,MAAM,MAAM,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAGxE,CAAC;YACF,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7B,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7B,IAAI,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACzC,QAAQ,EAAE,CAAC;gBACX,SAAS;YACX,CAAC;YACD,OAAO,EAAE,CAAC;YACV,IAAI,EAAE,KAAK,EAAE;gBAAE,KAAK,EAAE,CAAC;QACzB,CAAC;QACD,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO;YACP,KAAK;YACL,QAAQ;YACR,SAAS,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC5C,aAAa,EAAE,KAAK,GAAG,CAAC;SACzB,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"axis-audit.js","sourceRoot":"","sources":["../../src/composition/axis-audit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Axis-discrimination audit — the anti-inert-metadata gate for the extensible\n * axis registry (`axes.ts`).\n *\n * A classification axis is only load-bearing when it actually SEPARATES real\n * candidates. This audit runs the discovery link-candidate enumeration and, for\n * EVERY registry axis (gated or not), measures how often the axis FIRES (both\n * endpoints carry the attribute and they differ → an axis-clash), ABSTAINS (at\n * least one endpoint lacks the attribute), and is CHECKED (both carry it).\n *\n * Beside the firing count, each axis carries EVIDENCE: Fisher's exact test (MathTS\n * `fisherExact`) of its fires against the clashes of the INDEPENDENT magnitude falsifier\n * (`discovery.ts`, `magnitudeGate`) over the candidates where both gates ran, and an `earned`\n * flag at {@link AUDIT_ALPHA}. Firing is activity; agreeing with an independent falsifier more\n * often than chance is evidence. The `discriminates` flag (fires > 0) is the registry's current\n * criterion and is not changed by the evidence; `GATE_AXES` reads the registry, not this audit.\n *\n * Use: an axis stays `gated: false` in the registry until this audit shows it\n * fires; an axis that only ever abstains is inert and must not be gated. As the\n * catalog grows into new branches of physics, re-run this and flip the gates the\n * measurement earns. Rank grows on evidence, not vision.\n *\n * @module composition/axis-audit\n */\nimport { fisherExact } from '@danielsimonjr/mathts-functions';\nimport type { BridgeEdge } from './edge.js';\nimport type { RegimeAttributes } from './quantity.js';\nimport type { QuantityIdentification } from './compose.js';\nimport { AXES } from './axes.js';\nimport { proposeLinkCandidates } from './bridge-analysis.js';\nimport { effectiveAttributes, QUANTITY_IDENTIFICATIONS } from './compose.js';\nimport { buildDiscoveryContext, magnitudeGate, REGISTRY_ATTRIBUTES_BY_NAME } from './discovery.js';\nimport type { DiscoveryOptions } from './discovery.js';\n\n/**\n * The level at which an axis is `earned`: 0.05, the conventional two-sided level, fixed before\n * any table was read. Six axes are audited at once, so a reader who wants a family-wise level\n * divides by six (0.0083); the flag is per axis and says so here rather than hiding a\n * correction. Small tables (about twenty magnitude clashes on the catalog) are why the test is\n * exact and not a χ².\n *\n * @internal\n */\nexport const AUDIT_ALPHA = 0.05;\n\n/**\n * Fisher's exact evidence of one axis against the magnitude falsifier, over the candidates\n * where BOTH gates ran (both endpoints carry the axis, and both have a magnitude).\n *\n * @internal\n */\nexport interface AxisEvidence {\n  /**\n   * `[[fires ∧ clash, fires ∧ no clash], [silent ∧ clash, silent ∧ no clash]]`: rows are the\n   * axis's verdict, columns the magnitude falsifier's.\n   */\n  readonly table: readonly [readonly [number, number], readonly [number, number]];\n  /** Sample odds ratio `ad/bc`, as MathTS reports it; `null` when a zero cell leaves it undefined. */\n  readonly oddsRatio: number | null;\n  /** Two-sided Fisher exact p; 1 when a margin is zero (only one table is possible). */\n  readonly pValue: number;\n  /** Candidates where both gates ran (the table's total). */\n  readonly n: number;\n}\n\n/** Per-axis discrimination measurement over the candidate funnel. @internal */\nexport interface AxisDiscrimination {\n  readonly axis: string;\n  /** The registry's current gate flag for this axis. */\n  readonly gated: boolean;\n  /** Candidate pairs where BOTH endpoints carry the attribute. */\n  readonly checked: number;\n  /** Of the checked pairs, how many DIFFER (the axis fires → a clash). */\n  readonly fires: number;\n  /** Pairs where at least one endpoint lacks the attribute (the axis abstains). */\n  readonly abstains: number;\n  /** fires / checked (0 when nothing is checked). */\n  readonly clashRate: number;\n  /**\n   * The registry's criterion: a gate is EARNED when the axis fires at all. `false` here on an\n   * ungated axis = inert (do not gate); `false` on a gated axis = a regression to investigate.\n   * Not changed by `evidence`.\n   */\n  readonly discriminates: boolean;\n  /** Fisher's exact test of the axis's fires against the magnitude falsifier's clashes. */\n  readonly evidence: AxisEvidence;\n  /**\n   * The axis's fires coincide with the independent falsifier's clashes more often than chance:\n   * `evidence.pValue < AUDIT_ALPHA` AND the association is positive (`a·d > b·c`; an axis whose\n   * fires avoid the clashes is not earned, however small its p). Reported beside\n   * `discriminates`; it changes no gate.\n   */\n  readonly earned: boolean;\n}\n\n/** The inputs of the magnitude gate an audit may override (a synthetic table for a test). @internal */\nexport type AxisAuditOptions = Pick<DiscoveryOptions, 'representativeValues' | 'groundTruth' | 'maxOrdersOfMagnitude'>;\n\n/** The one Fisher call, read back for what MathTS returns: a number or `null` odds ratio, a number p. */\nfunction fisher(table: AxisEvidence['table']): Pick<AxisEvidence, 'oddsRatio' | 'pValue'> {\n  const r = fisherExact([[...table[0]], [...table[1]]]);\n  const oddsRatio: unknown = r.oddsRatio;\n  const pValue: unknown = r.pValue;\n  if (typeof pValue !== 'number' || !(pValue >= 0 && pValue <= 1)) {\n    throw new TypeError(`fisherExact returned p = ${String(pValue)} for ${JSON.stringify(table)}`);\n  }\n  return { oddsRatio: typeof oddsRatio === 'number' && Number.isFinite(oddsRatio) ? oddsRatio : null, pValue };\n}\n\n/**\n * Audit every registry axis's discrimination over the discovery candidate funnel, with Fisher\n * evidence against the magnitude falsifier. The magnitude gate runs once per candidate from one\n * discovery context (`buildDiscoveryContext`), not the whole funnel.\n *\n * @internal\n */\nexport function auditAxisDiscrimination(\n  edges: readonly BridgeEdge[],\n  attributesByName: ReadonlyMap<string, RegimeAttributes> = REGISTRY_ATTRIBUTES_BY_NAME,\n  identifications: readonly QuantityIdentification[] = QUANTITY_IDENTIFICATIONS,\n  options: AxisAuditOptions = {},\n): AxisDiscrimination[] {\n  const candidates = proposeLinkCandidates(edges);\n  const ctx = buildDiscoveryContext(edges, { ...options, identifications, quantityAttributes: attributesByName });\n  const magnitudes = candidates.map((c) => magnitudeGate(c, ctx));\n  return AXES.map((spec) => {\n    let checked = 0;\n    let fires = 0;\n    let abstains = 0;\n    // The 2×2 table over candidates where both gates ran.\n    let a = 0; // fires ∧ clash\n    let b = 0; // fires ∧ no clash\n    let c = 0; // silent ∧ clash\n    let d = 0; // silent ∧ no clash\n    candidates.forEach((cand, i) => {\n      const attrsA = effectiveAttributes(cand.a, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const attrsB = effectiveAttributes(cand.b, attributesByName, identifications) as Record<\n        string,\n        string | undefined\n      >;\n      const av = attrsA[spec.name];\n      const bv = attrsB[spec.name];\n      if (av === undefined || bv === undefined) {\n        abstains++;\n        return;\n      }\n      checked++;\n      const fired = av !== bv;\n      if (fired) fires++;\n      const gate = magnitudes[i];\n      if (!gate.checked) return; // the falsifier abstained: no row for this candidate\n      if (fired && gate.clash) a++;\n      else if (fired) b++;\n      else if (gate.clash) c++;\n      else d++;\n    });\n    const table: AxisEvidence['table'] = [\n      [a, b],\n      [c, d],\n    ];\n    const { oddsRatio, pValue } = fisher(table);\n    return {\n      axis: spec.name,\n      gated: spec.gated,\n      checked,\n      fires,\n      abstains,\n      clashRate: checked > 0 ? fires / checked : 0,\n      discriminates: fires > 0,\n      evidence: { table, oddsRatio, pValue, n: a + b + c + d },\n      earned: pValue < AUDIT_ALPHA && a * d > b * c,\n    };\n  });\n}\n"]}

package/dist/composition/bridge-analysis.d.ts

@@ -31,17 +31,20 @@ import type { BridgeEdge } from './edge.js';
  */
 export declare function dimensionalFreedom(e: BridgeEdge): number;
 /**
- * CODATA fine-structure constant, from the owner. `μ0 = 2 α h / (e² c)`
- * rewrites a vacuum factor as a number times a monomial in `{ℏ, c, e}`.
- */
-/**
- * True when a derived prefactor on `{ℏ, c, e}` times `α` is a recognized
- * constant. That factor is `μ0` rewritten through `α`. It is not an empirical
- * scale. The printed prefactor is not itself the recognized constant, so
- * `cleanPrefactor` stays false.
+ * The exact form of a clean dimensionless prefactor, or `undefined` when
+ * the number is not one. A prefactor `r` is clean when `r = p / (π^a · ln2^b)`
+ * for `a ∈ −2..2`, `b ∈ −1..1` and a rational `p` with denominator at most
+ * 720, and numerator at most 720, that reproduces it to the relative 1e-9 the
+ * derivation fit uses; or
+ * when `r²` is, which names `√π`, `√(2π)` and their kin. The simplest
+ * `(a, b)` that fits is the one reported, so `2` is `2` and not `2π/π`.
+ * The rule replaces a list of seventeen constants matched at 1e-3; `9/8`
+ * (be-80) and `π/ln 2` (be-84) were not on it, and `π²/60`, the
+ * Stefan–Boltzmann closed form, is a hit under this rule.
+ *
  * @internal
  */
-export declare function vacuumConstantThroughAlpha(subset: readonly string[] | undefined, prefactor: number | undefined): boolean;
+export declare function cleanPrefactorForm(p: number): string | undefined;
 /**
  * The outcome of trying to derive a bridge dimensionally + verify it.
  * `not-a-monomial` means the encoded formula adds dimensionful terms, so a
@@ -55,18 +58,14 @@ interface DerivationResult {
     readonly prefactor?: number;
     /** True when derived AND the prefactor is a recognizable constant. */
     readonly cleanPrefactor?: boolean;
+    /** The exact form of a clean prefactor (`9/8`, `π/ln 2`); absent when it is not clean. */
+    readonly prefactorForm?: string;
 }
 /**
  * Attempt to derive a bridge: the first constant-subset that dimensionally
  * closes the target AND reproduces the evaluator up to a constant ratio.
  */
 export declare function attemptDerivation(e: BridgeEdge): DerivationResult;
-/**
- * Graph distance from a bridge's quantities to the established-confidence
- * core (BFS over quantity co-occurrence). 0 = shares a quantity with an
- * established edge; Infinity = structurally isolated from it.
- */
-export declare function anchoringDistance(edges: readonly BridgeEdge[], e: BridgeEdge): number;
 /** How grounded the equation is, as a structural signal. */
 type Grounding = 'grounded' | 'empirical' | 'decoy' | 'open';
 /** Review-priority tier (1 = highest structural decidability). */

package/dist/composition/bridge-analysis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bridge-analysis.d.ts","sourceRoot":"","sources":["../../src/composition/bridge-analysis.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bridge-analysis.d.ts","sourceRoot":"","sources":["../../src/composition/bridge-analysis.ts"],"names":[],"mappings":"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"}

package/dist/composition/bridge-analysis.js

@@ -23,18 +23,23 @@
  *
  * @module composition/bridge-analysis
  */
-import { ALPHA } from '../core/constants.js';
 import { constantRecord } from '../dimensional/symbolic-constants.js';
+import { constantRatio, fixedPoint } from '../canonical/fixed-points.js';
+import { rationalize } from './rational-exponent.js';
 import { buckinghamPi, dimensionallyDetermines } from '../dimensional/buckingham.js';
 import { DIMENSIONLESS } from '../dimensional/types.js';
 import { equals, format } from '../dimensional/algebra.js';
 import { formulaShape } from './formula-shape.js';
 import { BRIDGE_EQUATIONS } from '../bridges/index.js';
-import { QUANTITY_IDENTIFICATIONS } from './compose.js';
 import { enumerateCompositions } from './enumerate.js';
 import { DATA_CONFRONTED_IDS } from '../bridges/confrontation-coverage.js';
+import { clusterBySharedKeys, quantityCanonicalizer } from './quantity-clusters.js';
 /** ℏ, c, G, k_B, e — the constants the audit/triage may invoke, from the registry. */
-const FUNDAMENTAL_CONSTANTS = ['ℏ', 'c', 'G', 'k_B', 'e'].map((name) => {
+// The constants a canonical or catalog relation bakes: a closure is searched over every subset.
+// `epsilon_0` and `m_e` joined on 2026-10-09, when the canonical entries that spelled them as
+// governing inputs (`vacuum-permittivity`, `electron-mass`) started baking them like every other
+// constant; without them CE-plasma-frequency read as a reconstruction mismatch.
+const FUNDAMENTAL_CONSTANTS = ['ℏ', 'c', 'G', 'k_B', 'e', 'epsilon_0', 'm_e'].map((name) => {
     const record = constantRecord(name);
     return { name, dim: record.dim, si: record.value };
 });
@@ -94,74 +99,149 @@ export function dimensionalFreedom(e) {
     }
     return Infinity;
 }
-/** Deterministic, domain-valid input sets with per-source variation. */
+/**
+ * Deterministic, domain-valid input sets with per-source variation.
+ *
+ * Each magnitude set is tried with every source positive first, then with
+ * each single source negated: a domain that holds only for a negative input
+ * (a signed charge, a potential below zero) once got positives only and was
+ * reported `no-samples` (9.0.0 audit §4 Low). The first sign pattern the
+ * domain admits is kept for that magnitude set, so a domain that admits the
+ * positives is sampled exactly as before.
+ */
 function makeInputs(e) {
     if (e.sources.length === 0)
         return [{}];
     const sets = [];
-    for (let j = 0; j < 3; j++) {
-        const inp = {};
-        e.sources.forEach((s, i) => {
-            inp[s.name] = Math.pow(1.6 + i, 1 + 0.27 * j);
-        });
+    const inDomain = (inp) => {
         try {
-            if (e.domain.predicate(inp) && Number.isFinite(e.evaluate(inp)))
-                sets.push(inp);
+            return e.domain.predicate(inp);
         }
         catch {
-            /* skip */
+            return false;
         }
+    };
+    const finite = (inp) => {
+        try {
+            return Number.isFinite(e.evaluate(inp));
+        }
+        catch {
+            return false;
+        }
+    };
+    for (let j = 0; j < 3; j++) {
+        // Source i takes (1.6 + i)^(1 + 0.27 j): this audit's own scheme, stated here.
+        const magnitudes = fixedPoint(e.sources.map((s) => s.name), 1 + 0.27 * j, { base: 1.6, step: 1 });
+        // A negated source is tried only when the DOMAIN refuses the positive point (a carrier
+        // charge that must be negative). A positive point the domain admits but the evaluator
+        // cannot finish (an exponential that overflows, be-82) is a degenerate sample and not a
+        // reason to look for a sign at which the function happens to be flat: a monomial fitted
+        // on a saturated regime is not a derivation.
+        if (inDomain(magnitudes)) {
+            if (finite(magnitudes))
+                sets.push(magnitudes);
+            continue;
+        }
+        const negated = e.sources
+            .map((s) => ({ ...magnitudes, [s.name]: -magnitudes[s.name] }))
+            .find((inp) => inDomain(inp) && finite(inp));
+        if (negated !== undefined)
+            sets.push(negated);
     }
     return sets;
 }
-/** Recognizable dimensionless prefactors (small rationals, 1/nπ, √, π). */
-const CLEAN_PREFACTORS = [
-    1, 2, 3, 4, 0.5, 0.25, Math.log(2),
-    1 / (2 * Math.PI), 1 / (4 * Math.PI), 1 / (8 * Math.PI),
-    Math.sqrt(2 * Math.PI), Math.sqrt(Math.PI),
-    Math.PI, 2 * Math.PI, 4 * Math.PI, 6 * Math.PI, 1 / (6 * Math.PI),
-];
-const isCleanPrefactor = (p) => CLEAN_PREFACTORS.some((c) => Math.abs(Math.abs(p) - c) < 1e-3 * c);
-/**
- * CODATA fine-structure constant, from the owner. `μ0 = 2 α h / (e² c)`
- * rewrites a vacuum factor as a number times a monomial in `{ℏ, c, e}`.
- */
+/** The denominator cap of a clean rational: the Buckingham enumerator's. */
+const CLEAN_MAX_DENOMINATOR = 720;
+/** The relative tolerance of a clean hit: the one the derivation fit uses. */
+const CLEAN_TOLERANCE = 1e-9;
+/** The (a, b) pairs of π^a · ln2^b, the simplest first. */
+const CLEAN_EXPONENT_PAIRS = (() => {
+    const pairs = [];
+    for (let a = -2; a <= 2; a++)
+        for (let b = -1; b <= 1; b++)
+            pairs.push([a, b]);
+    pairs.sort((x, y) => Math.abs(x[0]) + Math.abs(x[1]) - (Math.abs(y[0]) + Math.abs(y[1])) || Math.abs(x[0]) - Math.abs(y[0]));
+    return pairs;
+})();
+/** `π`, `π²`, `ln 2`, `(ln 2)²`, as a product string. */
+function symbolicFactor(a, b) {
+    const parts = [];
+    if (a === 1)
+        parts.push('π');
+    else if (a === 2)
+        parts.push('π²');
+    if (b === 1)
+        parts.push('ln 2');
+    else if (b === 2)
+        parts.push('(ln 2)²');
+    return parts.join(' ');
+}
+/** `r = p / (π^a · ln2^b)`, with `p = n/d`, as the exact form string. */
+function renderCleanForm(n, d, a, b, root) {
+    // Negative exponents put the symbol in the numerator.
+    const numSym = symbolicFactor(a < 0 ? -a : 0, b < 0 ? -b : 0);
+    const denSym = symbolicFactor(a > 0 ? a : 0, b > 0 ? b : 0);
+    const numParts = [...(n === 1n && numSym !== '' ? [] : [n.toString()]), ...(numSym === '' ? [] : [numSym])];
+    const denParts = [...(d === 1n ? [] : [d.toString()]), ...(denSym === '' ? [] : [denSym])];
+    // `2π` stays joined; a number before `ln 2` is spaced (`2 ln 2`), as `π ln 2` is.
+    const join = (parts) => parts.reduce((acc, part) => (acc === '' ? part : part.startsWith('ln') || part.startsWith('(ln') ? `${acc} ${part}` : acc + part), '');
+    const numerator = join(numParts);
+    if (denParts.length === 0)
+        return root ? (numerator === 'π' ? '√π' : /^[0-9]+$/.test(numerator) && numParts.length === 1 ? `√${numerator}` : `√(${numerator})`) : numerator;
+    const denominator = denParts.length === 1 ? denParts[0] : `(${join(denParts)})`;
+    const form = `${numerator}/${denominator}`;
+    return root ? `√(${form})` : form;
+}
 /**
- * True when a derived prefactor on `{ℏ, c, e}` times `α` is a recognized
- * constant. That factor is `μ0` rewritten through `α`. It is not an empirical
- * scale. The printed prefactor is not itself the recognized constant, so
- * `cleanPrefactor` stays false.
+ * The exact form of a clean dimensionless prefactor, or `undefined` when
+ * the number is not one. A prefactor `r` is clean when `r = p / (π^a · ln2^b)`
+ * for `a ∈ −2..2`, `b ∈ −1..1` and a rational `p` with denominator at most
+ * 720, and numerator at most 720, that reproduces it to the relative 1e-9 the
+ * derivation fit uses; or
+ * when `r²` is, which names `√π`, `√(2π)` and their kin. The simplest
+ * `(a, b)` that fits is the one reported, so `2` is `2` and not `2π/π`.
+ * The rule replaces a list of seventeen constants matched at 1e-3; `9/8`
+ * (be-80) and `π/ln 2` (be-84) were not on it, and `π²/60`, the
+ * Stefan–Boltzmann closed form, is a hit under this rule.
+ *
  * @internal
  */
-export function vacuumConstantThroughAlpha(subset, prefactor) {
-    if (subset === undefined || prefactor === undefined || !Number.isFinite(prefactor))
-        return false;
-    if (subset.length !== 3 || !subset.includes('ℏ') || !subset.includes('c') || !subset.includes('e'))
-        return false;
-    return isCleanPrefactor(Math.abs(prefactor) * ALPHA);
+export function cleanPrefactorForm(p) {
+    if (!Number.isFinite(p) || p === 0)
+        return undefined;
+    const sign = p < 0 ? '-' : '';
+    const r = Math.abs(p);
+    for (const root of [false, true]) {
+        const value = root ? r * r : r;
+        for (const [a, b] of CLEAN_EXPONENT_PAIRS) {
+            const scaled = value * Math.pow(Math.PI, a) * Math.pow(Math.LN2, b);
+            const q = rationalize(scaled, { maxDenominator: CLEAN_MAX_DENOMINATOR, tolerance: CLEAN_TOLERANCE });
+            // The cap bounds the numerator too. With it free, every integer-valued double
+            // (a G-closure of 3.6e21) is a rational over 1, and 21791/563 reproduced the
+            // BCS ratio 1.7639 to 1e-9 by chance: a small rational has a small numerator.
+            if (q !== undefined && (q.numerator < 0n ? -q.numerator : q.numerator) <= BigInt(CLEAN_MAX_DENOMINATOR)) {
+                return sign + renderCleanForm(q.numerator, q.denominator, a, b, root);
+            }
+        }
+    }
+    return undefined;
 }
+const isCleanPrefactor = (p) => cleanPrefactorForm(p) !== undefined;
 /**
  * A canonical closure more than ten times away from 1 is not a recovered
- * prefactor. Stefan–Boltzmann (≈0.1645) and Wien (≈1.265) stay inside that
- * window and keep the empirical/tuned mark. A G-closure of an atomic law
- * (10^21–10^25) and the ℏ, c, e stand-in for the field energy density
- * (≈10.9) do not. After the sourced ½ is applied, the same stand-in sits
- * near 5.45, inside the window, and times α is 1/(8π). That is μ0 rewritten
- * through α. A larger subset that still contains {ℏ, c, e} is the same
- * rewrite, so it is still not derived. A catalog id is not a canonical id,
- * so be-74 stays where the catalog audit put it.
- * A recognized constant (2π, ln 2, 4π, 1/(6π), …) stays even when it sits
- * outside the window. `ALPHA` is the fine-structure constant declared above.
+ * prefactor. Wien (≈1.265, 2π over the root of a transcendental equation)
+ * stays inside that window and keeps the empirical/tuned mark;
+ * Stefan–Boltzmann's π²/60 is a clean form under `cleanPrefactorForm`. A
+ * G-closure of an atomic law (10^21–10^25) does not pass. A recognized
+ * constant (2π, ln 2, 4π, 1/(6π), …) stays even when it sits outside the
+ * window. The search includes ε₀, so the
+ * field energy density derives on {ε₀} with its sourced ½; the {ℏ, c, e}
+ * stand-in it once closed on, μ0 rewritten through α, no longer arises, and
+ * the guard that rejected it is gone (it changed no row of either graph).
  */
-function recoveredCanonicalPrefactor(id, prefactor, subset) {
+function recoveredCanonicalPrefactor(id, prefactor) {
     if (!id.startsWith('CE-') || isCleanPrefactor(prefactor))
         return true;
-    if (subset.includes('ℏ') &&
-        subset.includes('c') &&
-        subset.includes('e') &&
-        isCleanPrefactor(Math.abs(prefactor) * ALPHA)) {
-        return false;
-    }
     const mag = Math.abs(prefactor);
     if (!(mag > 0) || !Number.isFinite(mag))
         return false;
@@ -207,16 +287,17 @@ export function attemptDerivation(e) {
                 cand *= Math.pow(i[name], exp);
             return e.evaluate(i) / cand;
         });
-        const mean = ratios.reduce((a, b) => a + b, 0) / ratios.length;
-        const cv = Math.sqrt(ratios.reduce((a, b) => a + (b - mean) ** 2, 0) / ratios.length) /
-            Math.abs(mean);
-        if (cv < 1e-9 && recoveredCanonicalPrefactor(e.id, mean, S.map((x) => x.name))) {
+        // The coefficient of variation under 1e-9: this audit's own statistic and tolerance.
+        const decided = constantRatio(ratios, 1e-9, { statistic: 'cv' });
+        if (decided.constant && recoveredCanonicalPrefactor(e.id, decided.value)) {
+            const form = cleanPrefactorForm(decided.value);
             return {
                 status: 'derived',
                 subset: S.map((x) => x.name),
                 monomial: r.monomial,
-                prefactor: mean,
-                cleanPrefactor: isCleanPrefactor(mean),
+                prefactor: decided.value,
+                cleanPrefactor: form !== undefined,
+                ...(form === undefined ? {} : { prefactorForm: form }),
             };
         }
     }
@@ -227,9 +308,10 @@ export function attemptDerivation(e) {
 /**
  * Graph distance from a bridge's quantities to the established-confidence
  * core (BFS over quantity co-occurrence). 0 = shares a quantity with an
- * established edge; Infinity = structurally isolated from it.
+ * established edge; Infinity = structurally isolated from it. Read by
+ * `bridgePriority` only; it was exported with no caller outside this file.
  */
-export function anchoringDistance(edges, e) {
+function anchoringDistance(edges, e) {
     const adj = new Map();
     const link = (a, b) => {
         mapGetOrInsert(adj, a, () => new Set()).add(b);
@@ -317,17 +399,10 @@ export function bridgePriority(edges) {
 // ---------------------------------------------------------------------------
 // Catalog linkage map — how the equations connect via shared quantities.
 // ---------------------------------------------------------------------------
-/**
- * Quantity-name canonicalizer honoring `QUANTITY_IDENTIFICATIONS`: maps each
- * name to its identified representative (e.g. hawking-temperature →
- * temperature). The shared linkage substrate for `linkageMap` /
- * `proposeLinkCandidates`. NOTE: `anchoringDistance` deliberately does NOT
- * use this — it links on raw names (its distance-0/∞ contract is pinned).
- */
-function quantityCanonicalizer() {
-    const alias = new Map(QUANTITY_IDENTIFICATIONS.map((id) => [id.from, id.to]));
-    return (n) => alias.get(n) ?? n;
-}
+// The quantity-name canonicalizer (`QUANTITY_IDENTIFICATIONS`) and the component partition are
+// `quantity-clusters.ts`, the one owner shared with the visual map and the discovery funnel.
+// NOTE: `anchoringDistance` deliberately does NOT canonicalize — it links on raw names (its
+// distance-0/∞ contract is pinned).
 /** An edge's distinct (canonical) quantity names — sources ∪ target. */
 function quantitiesOf(e, canon) {
     return [...new Set([...e.sources.map((s) => canon(s.name)), canon(e.target.name)])];
@@ -346,26 +421,9 @@ function quantitiesOf(e, canon) {
 function clusterMap(edges) {
     const statusOf = new Map(BRIDGE_EQUATIONS.map((b) => [b.id, b.status]));
     const canon = quantityCanonicalizer();
-    // Union-find over edges sharing a (canonical) quantity.
-    const parent = edges.map((_, i) => i);
-    const find = (x) => (parent[x] === x ? x : (parent[x] = find(parent[x])));
-    const union = (a, b) => { parent[find(a)] = find(b); };
-    const qToEdges = new Map();
-    edges.forEach((e, i) => {
-        for (const q of quantitiesOf(e, canon)) {
-            mapGetOrInsert(qToEdges, q, () => []).push(i);
-        }
-    });
-    for (const idxs of qToEdges.values()) {
-        for (let k = 1; k < idxs.length; k++)
-            union(idxs[0], idxs[k]);
-    }
-    const groups = new Map();
-    edges.forEach((_, i) => {
-        mapGetOrInsert(groups, find(i), () => []).push(i);
-    });
-    const clusters = [...groups.values()].map((idxs) => {
-        const es = idxs.map((i) => edges[i]);
+    // Edges sharing a (canonical) quantity are one cluster: the shared partition, already in
+    // the order this map always had (largest first, then by first edge id; input order inside).
+    const clusters = clusterBySharedKeys(edges, (e) => quantitiesOf(e, canon), (e) => e.id).map((es) => {
         const statusMix = {};
         const qcount = {};
         for (const e of es) {
@@ -382,7 +440,6 @@ function clusterMap(edges) {
             hubs: Object.entries(qcount).filter(([, c]) => c >= 2).map(([q]) => q).sort(),
         };
     });
-    clusters.sort((a, b) => b.size - a.size || a.edges[0].localeCompare(b.edges[0]));
     return {
         clusters,
         componentCount: clusters.length,