universal-physics-tensor 0.20.0 → 0.22.0

package/bin/upt.mjs

@@ -11,13 +11,16 @@
  * Run from a built checkout (`npm run build`) via `npm run upt -- <cmd>`,
  * or as an installed command (`npx universal-physics-tensor <cmd>`).
  */
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join } from 'node:path';
 
 const here = dirname(fileURLToPath(import.meta.url));
-const dist = (...p) => join(here, '..', 'dist', ...p);
+// Return a file:// URL, not a bare path: Node's ESM dynamic import() rejects
+// absolute Windows paths ("protocol 'c:'") — it only accepts file/data/node URLs.
+const dist = (...p) => pathToFileURL(join(here, '..', 'dist', ...p)).href;
 
 let api, analysis, formulaReg, dimSpecMod, prediction, discovery, coverage, simplifyMod;
+let canonicalReg, linkageMod;
 try {
   api = await import(dist('index.js'));
   analysis = await import(dist('composition', 'bridge-analysis.js'));
@@ -27,6 +30,8 @@ try {
   discovery = await import(dist('composition', 'discovery.js'));
   coverage = await import(dist('bridges', 'confrontation-coverage.js'));
   simplifyMod = await import(dist('composition', 'expr-simplify.js'));
+  canonicalReg = await import(dist('canonical', 'registry.js'));
+  linkageMod = await import(dist('canonical', 'linkage.js'));
 } catch (err) {
   console.error('Could not load the built package. Run `npm run build` first.');
   console.error(String(err.message || err));
@@ -42,6 +47,8 @@ const { predictMissingBridges } = prediction;
 const { rankDiscoveries } = discovery;
 const { auditCoverage } = coverage;
 const { simplifyObservable } = simplifyMod;
+const { CANONICAL_EQUATIONS, bridgesWithoutCanonicalPartner } = canonicalReg;
+const { scanLinkages } = linkageMod;
 
 const GRAPH = CATALOG_GRAPH;
 
@@ -97,6 +104,17 @@ Usage:
         data-confronted vs graph-computable vs encoded-only vs thin — to
         target the physicist review. Fabricates nothing.
 
+  upt canonical
+        List the canonical-equation registry — the standard-physics L-layer
+        (textbook "answer key") with each entry's fidelity (L0/L1/L2),
+        domain, and bridge partners, plus the coverage gap.
+
+  upt recover
+        Validate bridges against standard physics: classify each bridge↔
+        canonical link as restates-canonical (F4 circularity — NOT a
+        discovery), recovers (undeclared structural match), or
+        dimensional-only.
+
   upt symbolic [--simplify]
         Compose bridges' SYMBOLIC (AST) forms, not just their numeric
         evaluators (the Observable contract). Shows the CT-1 / CT-1b chains
@@ -373,11 +391,13 @@ function discoverCmd() {
   const ranked = rankDiscoveries(GRAPH);
   const by = (v) => ranked.filter((r) => r.verdict === v);
   const promising = by('promising'), inert = by('inert'), contra = by('contradictory');
+  const clash = by('magnitude-clash');
   console.log('\nDiscovery — link candidates VETTED through the inference suite');
   console.log('⚠ a REVIEW SURFACE: `promising` means "worth a physicist\'s minute", not "true".');
   console.log('  Each candidate hypothesises an identification a≡b and tests its consequences.\n');
   console.log(`  funnel:  ${ranked.length} candidates  →  ${promising.length} promising  ` +
-    `·  ${inert.length} inert  ·  ${contra.length} contradictory (falsified)\n`);
+    `·  ${inert.length} inert  ·  ${clash.length} magnitude-clash  ` +
+    `·  ${contra.length} contradictory (falsified)\n`);
   if (promising.length) {
     console.log('  PROMISING (merges disconnected physics, unlocks quantities, stays consistent):');
     for (const r of promising) {
@@ -387,13 +407,19 @@ function discoverCmd() {
   } else {
     console.log('  no candidate is `promising` from the default {mass} anchor.');
   }
+  if (clash.length) {
+    console.log(`\n  MAGNITUDE-CLASH (representative values differ by > N orders — a falsifier):`);
+    for (const r of clash) {
+      console.log(`    ${(r.a + ' ≟ ' + r.b).padEnd(52)} ~${r.ordersApart.toFixed(1)} orders apart`);
+    }
+  }
   if (contra.length) {
     console.log(`\n  CONTRADICTORY (the identification falsifies itself numerically):`);
     for (const r of contra) {
       console.log(`    ${(r.a + ' ≟ ' + r.b).padEnd(52)} disagreeing node(s): ${r.inconsistentNodes.join(', ')}`);
     }
   }
-  console.log('\n  (numeric check only exercises the anchor-reachable subgraph; weak priors on dimension.)');
+  console.log('\n  (magnitude gate abstains where a representative value is unknown; weak priors on dimension.)');
 }
 
 // ── coverage (empirical-spine audit) ──────────────────────────────────────
@@ -481,6 +507,49 @@ function connectorsCmd() {
   console.log('  docs/research/Orphan-Connector-Analysis.md and proposed in spec Part-IX §9.');
 }
 
+// ── canonical (the standard-physics L-layer registry) ─────────────────────
+function canonicalCmd() {
+  const fidelity = (e) => (e.fieldEquation ? 'L2' : e.scalarAst ? 'L1' : 'L0');
+  console.log('\nCanonical-equation registry — the standard-physics L-layer (Π = L + B + E)');
+  console.log('the textbook "answer key" bridge equations are validated against.\n');
+  console.log(`  ${CANONICAL_EQUATIONS.length} entries:\n`);
+  console.log('   fid  domain               id                       partners');
+  console.log('   ─────────────────────────────────────────────────────────────────');
+  for (const e of CANONICAL_EQUATIONS) {
+    const partners = [...e.partnerBridges, ...(e.restatesBridge ? [`=${e.restatesBridge}`] : [])].join(',') || '—';
+    console.log(`   ${fidelity(e).padEnd(3)}  ${e.domain.padEnd(19)} ${e.id.padEnd(24)} ${partners}`);
+  }
+  const gap = bridgesWithoutCanonicalPartner();
+  console.log(`\n  coverage: ${gap.length} catalog bridges have no canonical partner yet`);
+  console.log(`  (fidelity: L0 dimensional · L1 scalar-AST · L2 field-equation; "=NN" = restatesBridge)`);
+}
+
+// ── recover (bridge↔canonical linkage; the F4 circularity guard) ──────────
+function recoverCmd() {
+  const all = scanLinkages();
+  const by = (c) => all.filter((r) => r.classification === c);
+  const restates = by('restates-canonical'), recovers = by('recovers'), dimOnly = by('dimensional-only');
+  console.log('\nBridge↔canonical recovery — validating bridges against standard physics');
+  console.log('⚠ structural match is "same relation UP TO a dimensionless factor"; that factor');
+  console.log('  may itself be physically substantive (e.g. ⟨e^-βW⟩). A review surface.\n');
+  console.log(`  ${all.length} non-unrelated links  →  ${restates.length} restates-canonical  ` +
+    `·  ${recovers.length} recovers  ·  ${dimOnly.length} dimensional-only\n`);
+  if (restates.length) {
+    console.log('  RESTATES-CANONICAL (the bridge IS the canonical law — F4: NOT a discovery):');
+    for (const r of restates) {
+      const rec = r.recovery && r.recovery.tested ? ` (recovery exact, err ${r.recovery.maxRelErr.toExponential(0)})` : '';
+      console.log(`    ${r.canonicalId.padEnd(26)} ≡ bridge ${r.bridgeId}${rec}`);
+    }
+  }
+  if (recovers.length) {
+    console.log('\n  RECOVERS (undeclared structural correspondence — worth a physicist\'s look):');
+    for (const r of recovers) {
+      console.log(`    ${r.canonicalId.padEnd(26)} ~ bridge ${r.bridgeId}  (same form up to a dimensionless factor)`);
+    }
+  }
+  console.log(`\n  (${dimOnly.length} dimensional-only: same dimension, different form. Run \`upt canonical\` for the registry.)`);
+}
+
 // ── dispatch ──────────────────────────────────────────────────────────────
 const [cmd, ...rest] = process.argv.slice(2);
 switch (cmd) {
@@ -493,6 +562,8 @@ switch (cmd) {
   case 'discover': case 'discovery': discoverCmd(); break;
   case 'connectors': case 'orphans': connectorsCmd(); break;
   case 'coverage': case 'grounding': coverageCmd(); break;
+  case 'canonical': case 'laws': canonicalCmd(); break;
+  case 'recover': case 'recovery': case 'validate': recoverCmd(); break;
   case 'symbolic': case 'compose-symbolic': await symbolicCmd(rest); break;
   case 'eval': case 'calc': await evalCmd(rest); break;
   case 'derive': case 'dim': await derive(rest); break;

package/dist/bridges/equations/be-26-dna-tunneling.d.ts

@@ -35,14 +35,24 @@
  */
 import type { ExprNode, DimensionValidationReport } from '../../dimensional/validator.js';
 /**
- * Lemma AST: the WKB exponent (2/ℏ) · ∫ √(2m(V−E)) dx, exposed for
- * verification that it is dimensionless.
+ * Lemma AST: the WKB exponent (2/ℏ) · ∫_{x₁}^{x₂} √(2m(V−E)) dx, dimensionless.
+ *
+ * v0.21: the integral carries explicit barrier-endpoint bounds x₁, x₂ (a definite
+ * integral) — faithful to this bridge's rectangular-barrier model, since the
+ * integrand √(2m(V−E)) is constant in x (V_minus_E is a constant ENERGY symbol,
+ * not V(x)), so 16-pt Gauss–Legendre is EXACT and equals √(2m(V−E))·(x₂−x₁).
+ * This exposes m, V_minus_E, x₁, x₂ to differentiation (Adam+Eve GREEN). Domain
+ * guards (caller's): V_minus_E ≥ 0, m > 0, x₂ ≥ x₁.
  */
 export declare const DNA_TUNNELING_WKB_ARG: ExprNode;
 /**
- * RHS of the WKB tunneling rate: `ν₀ · ε · f`, where ε is a
- * dimensionless symbol stub for exp(-DNA_TUNNELING_WKB_ARG) and f is the
- * dimensionless f(T, pH, EM) prefactor.
+ * RHS of the WKB tunneling rate: `ν₀ · exp(−WKB) · f`. The Gamow exponential is
+ * encoded faithfully (v0.21) as `transcendental(exp, −1 · DNA_TUNNELING_WKB_ARG)`
+ * — a definite integral under the exp — so m, V_minus_E, and the barrier
+ * endpoints x₁, x₂ are visible to differentiation. `exp` of the DIMENSIONLESS
+ * WKB exponent is DIMENSIONLESS, so the round-trip dimensional_signature
+ * ([frequency]) is unchanged from the former symbol stub. The f(T, pH, EM)
+ * prefactor remains an opaque interpolation stub (no closed form).
  */
 export declare const DNA_TUNNELING_RHS: ExprNode;
 /**

package/dist/bridges/equations/be-26-dna-tunneling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"be-26-dna-tunneling.d.ts","sourceRoot":"","sources":["../../../src/bridges/equations/be-26-dna-tunneling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAY1F;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAgCnC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAO/B,CAAC;AAOF;;GAEG;AACH,UAAU,kBAAkB;IAC1B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAkBtE;AAID;;;GAGG;AACH,gBAAgB;AAChB,wBAAgB,8BAA8B,IAAI,yBAAyB,CAE1E"}
+{"version":3,"file":"be-26-dna-tunneling.d.ts","sourceRoot":"","sources":["../../../src/bridges/equations/be-26-dna-tunneling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAY1F;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAkCnC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAc/B,CAAC;AAOF;;GAEG;AACH,UAAU,kBAAkB;IAC1B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAkBtE;AAID;;;GAGG;AACH,gBAAgB;AAChB,wBAAgB,8BAA8B,IAAI,yBAAyB,CAE1E"}

package/dist/bridges/equations/be-26-dna-tunneling.js

@@ -38,8 +38,14 @@ import { hbar as DIM_hbar } from '../../dimensional/constants.js';
 import { PhysicalConstants } from '../../core/types.js';
 import { sym, validateFiniteInputs, validateBEDimensions } from './_be-helpers.js';
 /**
- * Lemma AST: the WKB exponent (2/ℏ) · ∫ √(2m(V−E)) dx, exposed for
- * verification that it is dimensionless.
+ * Lemma AST: the WKB exponent (2/ℏ) · ∫_{x₁}^{x₂} √(2m(V−E)) dx, dimensionless.
+ *
+ * v0.21: the integral carries explicit barrier-endpoint bounds x₁, x₂ (a definite
+ * integral) — faithful to this bridge's rectangular-barrier model, since the
+ * integrand √(2m(V−E)) is constant in x (V_minus_E is a constant ENERGY symbol,
+ * not V(x)), so 16-pt Gauss–Legendre is EXACT and equals √(2m(V−E))·(x₂−x₁).
+ * This exposes m, V_minus_E, x₁, x₂ to differentiation (Adam+Eve GREEN). Domain
+ * guards (caller's): V_minus_E ≥ 0, m > 0, x₂ ≥ x₁.
  */
 export const DNA_TUNNELING_WKB_ARG = {
     kind: 'op', op: '*',
@@ -53,9 +59,11 @@ export const DNA_TUNNELING_WKB_ARG = {
             ],
         },
         {
-            // ∫ √(2m(V−E)) dx
+            // ∫_{x₁}^{x₂} √(2m(V−E)) dx
             kind: 'integral',
             over: sym('x', LENGTH),
+            lower: sym('x_1', LENGTH),
+            upper: sym('x_2', LENGTH),
             integrand: {
                 // √(2m(V−E)) = (2m(V−E))^{1/2}
                 kind: 'op', op: '^',
@@ -75,15 +83,26 @@ export const DNA_TUNNELING_WKB_ARG = {
     ],
 };
 /**
- * RHS of the WKB tunneling rate: `ν₀ · ε · f`, where ε is a
- * dimensionless symbol stub for exp(-DNA_TUNNELING_WKB_ARG) and f is the
- * dimensionless f(T, pH, EM) prefactor.
+ * RHS of the WKB tunneling rate: `ν₀ · exp(−WKB) · f`. The Gamow exponential is
+ * encoded faithfully (v0.21) as `transcendental(exp, −1 · DNA_TUNNELING_WKB_ARG)`
+ * — a definite integral under the exp — so m, V_minus_E, and the barrier
+ * endpoints x₁, x₂ are visible to differentiation. `exp` of the DIMENSIONLESS
+ * WKB exponent is DIMENSIONLESS, so the round-trip dimensional_signature
+ * ([frequency]) is unchanged from the former symbol stub. The f(T, pH, EM)
+ * prefactor remains an opaque interpolation stub (no closed form).
  */
 export const DNA_TUNNELING_RHS = {
     kind: 'op', op: '*',
     args: [
         sym('nu_0', FREQUENCY),
-        sym('exp(-WKB_arg)', DIMENSIONLESS),
+        {
+            kind: 'transcendental',
+            fn: 'exp',
+            arg: {
+                kind: 'op', op: '*',
+                args: [sym('-1', DIMENSIONLESS), DNA_TUNNELING_WKB_ARG],
+            },
+        },
         sym('f(T,pH,EM)', DIMENSIONLESS),
     ],
 };

package/dist/bridges/equations/be-26-dna-tunneling.js.map

@@ -1 +1 @@
-{"version":3,"file":"be-26-dna-tunneling.js","sourceRoot":"","sources":["../../../src/bridges/equations/be-26-dna-tunneling.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"be-26-dna-tunneling.js","sourceRoot":"","sources":["../../../src/bridges/equations/be-26-dna-tunneling.ts"],"names":[],"mappings":"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"}

package/dist/canonical/canonical-equation.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Canonical (textbook) physics equations — the ground-truth L-layer of the
+ * universal tensor (Π = L + B + E). A `CanonicalEquation` is the *answer key*
+ * that bridge equations (the B-layer) are validated against; it is NOT a
+ * speculative claim.
+ *
+ * Entries carry whichever FIDELITY LEVELS they can:
+ *   - L0 (mandatory) — `dimensional`: target dim + governing vars (+ monomial
+ *     when dimensionally determined). Reproduced by the Buckingham-π engine.
+ *   - L1 (optional)  — `scalarAst`: an `ExprNode` RHS, validated dimensionally.
+ *   - L2 (optional)  — `fieldEquation`: a tensor/PDE predicate node.
+ *
+ * Epistemic honesty (review finding F1): an L0-only entry must never read as
+ * more than "dimensionally consistent". `epistemicStatus` is the highest claim
+ * the entry supports; `freeDimensionlessGroups > 0` means dimensions cannot pin
+ * the form. Consumers must not use an entry above its `epistemicStatus`.
+ *
+ * See `docs/planning/Canonical-Equation-Registry-A-Design.md`.
+ *
+ * @module canonical/canonical-equation
+ */
+import type { ExprNode } from '../dimensional/validator.js';
+import type { DimensionalVariable } from '../dimensional/buckingham.js';
+import type { TensorIndices } from '../core/types.js';
+import type { EinsteinFieldEquationNode } from '../dimensional/einstein-equation.js';
+/** Physics domain — indexes the registry and (later) the discovery kind filter. */
+export type CanonicalDomain = 'mechanics' | 'gravitation' | 'general-relativity' | 'cosmology' | 'electromagnetism' | 'quantum' | 'thermodynamics' | 'statistical' | 'information';
+/**
+ * The strongest claim an entry supports:
+ *   - `dimensional`          — only the dimensional signature (L0).
+ *   - `scalar-up-to-constant`— the algebraic form, leading constant aside (L1).
+ *   - `fully-quantitative`   — the complete relation incl. the constant.
+ */
+export type EpistemicStatus = 'dimensional' | 'scalar-up-to-constant' | 'fully-quantitative';
+/** A field-equation predicate node (L2). Concrete node kinds live in the
+ *  dimensional layer; widen this union as Maxwell/Klein–Gordon nodes land. */
+export type FieldEquationNode = EinsteinFieldEquationNode;
+/** Disambiguators for forms that share a dimensional signature (finding F3). */
+export interface CanonicalForms {
+    /** Bekenstein–Hawking depends on horizon AREA, not radius. */
+    readonly areaOrRadius?: 'area' | 'radius';
+    /** Landauer uses the NATURAL log. */
+    readonly logBase?: 'e' | '2' | '10';
+    /** Stefan–Boltzmann `j=σT⁴` is a FLUX; luminosity `L=σAT⁴` changes σ. */
+    readonly quantityKind?: 'flux' | 'power' | 'energy';
+}
+/** A canonical (textbook) physics equation. */
+export interface CanonicalEquation {
+    /** Stable id, e.g. 'CE-newton-gravitation'. */
+    readonly id: string;
+    readonly name: string;
+    readonly domain: CanonicalDomain;
+    /** LaTeX rendering (display only). */
+    readonly formula_latex: string;
+    readonly epistemicStatus: EpistemicStatus;
+    /** 0 ⇒ the L0 monomial is fully determined; ≥1 ⇒ dimensions can't pin it. */
+    readonly freeDimensionlessGroups: number;
+    readonly dimensional: {
+        readonly target: DimensionalVariable;
+        readonly governing: readonly DimensionalVariable[];
+        /** Textbook monomial exponents, or null when there are free groups. */
+        readonly monomial: Readonly<Record<string, number>> | null;
+    };
+    readonly scalarAst?: ExprNode;
+    readonly fieldEquation?: FieldEquationNode;
+    readonly forms?: CanonicalForms;
+    /** L-layer cell coordinates. */
+    readonly regime: TensorIndices;
+    /** Implicit regime assumptions (e.g. 'blackbody equilibrium'). */
+    readonly assumptions: readonly string[];
+    readonly references: readonly string[];
+    /** Bridges this law is the intended correspondence partner for (advisory;
+     *  the check itself is Sub-project B). */
+    readonly partnerBridges: readonly string[];
+    /** Set when this law is LITERALLY a bridge's own relation (BH≡BE-21, …);
+     *  Sub-project B uses it to discount the trivial X≡X match (finding F4). */
+    readonly restatesBridge?: string;
+}
+//# sourceMappingURL=canonical-equation.d.ts.map

package/dist/canonical/canonical-equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-equation.d.ts","sourceRoot":"","sources":["../../src/canonical/canonical-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAErF,mFAAmF;AACnF,MAAM,MAAM,eAAe,GACvB,WAAW,GACX,aAAa,GACb,oBAAoB,GACpB,WAAW,GACX,kBAAkB,GAClB,SAAS,GACT,gBAAgB,GAChB,aAAa,GACb,aAAa,CAAC;AAElB;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACvB,aAAa,GACb,uBAAuB,GACvB,oBAAoB,CAAC;AAEzB;8EAC8E;AAC9E,MAAM,MAAM,iBAAiB,GAAG,yBAAyB,CAAC;AAE1D,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC1C,qCAAqC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;IACpC,yEAAyE;IACzE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;CACrD;AAED,+CAA+C;AAC/C,MAAM,WAAW,iBAAiB;IAChC,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,sCAAsC;IACtC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAG/B,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,6EAA6E;IAC7E,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IAGzC,QAAQ,CAAC,WAAW,EAAE;QACpB,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;QACrC,QAAQ,CAAC,SAAS,EAAE,SAAS,mBAAmB,EAAE,CAAC;QACnD,uEAAuE;QACvE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;KAC5D,CAAC;IAEF,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAG3C,QAAQ,CAAC,KAAK,CAAC,EAAE,cAAc,CAAC;IAGhC,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC;8CAC0C;IAC1C,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;gFAC4E;IAC5E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC"}

package/dist/canonical/canonical-equation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canonical-equation.js.map

package/dist/canonical/canonical-equation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-equation.js","sourceRoot":"","sources":["../../src/canonical/canonical-equation.ts"],"names":[],"mappings":""}

package/dist/canonical/dimensional-fields.d.ts

@@ -0,0 +1,7 @@
+import type { DimensionalVariable } from '../dimensional/buckingham.js';
+/** L0 dimensional fields derived from the engine. */
+export declare function dimensionalFields(target: DimensionalVariable, governing: readonly DimensionalVariable[]): {
+    monomial: Record<string, number> | null;
+    freeDimensionlessGroups: number;
+};
+//# sourceMappingURL=dimensional-fields.d.ts.map

package/dist/canonical/dimensional-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensional-fields.d.ts","sourceRoot":"","sources":["../../src/canonical/dimensional-fields.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,qDAAqD;AACrD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,mBAAmB,EAC3B,SAAS,EAAE,SAAS,mBAAmB,EAAE,GACxC;IACD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACxC,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAaA"}

package/dist/canonical/dimensional-fields.js

@@ -0,0 +1,31 @@
+/**
+ * Compute the L0 dimensional fields of a canonical entry FROM the Buckingham-π
+ * engine, so `monomial` and `freeDimensionlessGroups` are always mutually
+ * consistent and never hand-asserted (HonestClaude).
+ *
+ * The two are consistent by construction: the target monomial is unique iff the
+ * governing set has no free dimensionless group, so
+ *   `monomial !== null  ⟺  freeDimensionlessGroups === 0`.
+ * Equations whose form dimensions CANNOT pin (Newton `F=Gm₁m₂/r²` — a free
+ * mass-ratio group; Bekenstein–Hawking — a free `c³A/Għ` group) get
+ * `monomial: null, freeDimensionlessGroups ≥ 1`; their scalar-AST (L1) carries
+ * the form dimensions can't.
+ *
+ * @module canonical/dimensional-fields
+ */
+import { dimensionallyDetermines, buckinghamPi, } from '../dimensional/buckingham.js';
+/** L0 dimensional fields derived from the engine. */
+export function dimensionalFields(target, governing) {
+    const det = dimensionallyDetermines(target, governing);
+    const gPi = governing.length > 0 ? buckinghamPi([...governing]).piGroupCount : 0;
+    // Keep the invariant `monomial !== null ⟺ freeDimensionlessGroups === 0`
+    // UNCONDITIONALLY true: when the target is not in the governing span,
+    // `determined` is false yet `gPi` may be 0 — force ≥1 so null monomial always
+    // reports a free group.
+    const freeDimensionlessGroups = det.determined ? gPi : Math.max(1, gPi);
+    return {
+        monomial: det.determined ? { ...det.monomial } : null,
+        freeDimensionlessGroups,
+    };
+}
+//# sourceMappingURL=dimensional-fields.js.map

package/dist/canonical/dimensional-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensional-fields.js","sourceRoot":"","sources":["../../src/canonical/dimensional-fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,uBAAuB,EACvB,YAAY,GACb,MAAM,8BAA8B,CAAC;AAGtC,qDAAqD;AACrD,MAAM,UAAU,iBAAiB,CAC/B,MAA2B,EAC3B,SAAyC;IAKzC,MAAM,GAAG,GAAG,uBAAuB,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACvD,MAAM,GAAG,GACP,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IACvE,yEAAyE;IACzE,sEAAsE;IACtE,8EAA8E;IAC9E,wBAAwB;IACxB,MAAM,uBAAuB,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACxE,OAAO;QACL,QAAQ,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC,QAAS,EAAE,CAAC,CAAC,CAAC,IAAI;QACtD,uBAAuB;KACxB,CAAC;AACJ,CAAC"}

package/dist/canonical/entries/_l1-build.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared builders for L1 (scalar-AST) canonical entries. Keeps the entry files
+ * declarative: `op`/`pow` assemble the `ExprNode`, and `l1` derives the L0
+ * fields from the Buckingham engine so `monomial` and `freeDimensionlessGroups`
+ * are always consistent.
+ *
+ * @module canonical/entries/_l1-build
+ */
+import type { CanonicalEquation } from '../canonical-equation.js';
+import type { ExprNode } from '../../dimensional/validator.js';
+import type { Dimension } from '../../dimensional/types.js';
+import type { DimensionalVariable } from '../../dimensional/buckingham.js';
+/** Dimension builder. Arg order is (L, M, T, **I**, **Θ**) — note I precedes Θ. */
+export declare const dim: (L?: number, M?: number, T?: number, I?: number, Theta?: number) => Dimension;
+export declare const op: (o: "+" | "-" | "*" | "/" | "^", args: ExprNode[]) => ExprNode;
+/** `base` raised to the numeric-literal power `n` (a dimensionless exponent). */
+export declare const pow: (base: ExprNode, n: string) => ExprNode;
+/** Everything an L1 entry declares except the engine-derived L0 fields. */
+export type L1Rest = Omit<CanonicalEquation, 'freeDimensionlessGroups' | 'dimensional'>;
+/** Build an L1 entry; L0 fields are derived from the engine for consistency. */
+export declare const l1: (target: DimensionalVariable, governing: readonly DimensionalVariable[], rest: L1Rest) => CanonicalEquation;
+//# sourceMappingURL=_l1-build.d.ts.map

package/dist/canonical/entries/_l1-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_l1-build.d.ts","sourceRoot":"","sources":["../../../src/canonical/entries/_l1-build.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAK3E,mFAAmF;AACnF,eAAO,MAAM,GAAG,GAAI,UAAK,EAAE,UAAK,EAAE,UAAK,EAAE,UAAK,EAAE,cAAS,KAAG,SAQ1D,CAAC;AAEH,eAAO,MAAM,EAAE,GACb,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,EAC9B,MAAM,QAAQ,EAAE,KACf,QAAyC,CAAC;AAE7C,iFAAiF;AACjF,eAAO,MAAM,GAAG,GAAI,MAAM,QAAQ,EAAE,GAAG,MAAM,KAAG,QACR,CAAC;AAEzC,2EAA2E;AAC3E,MAAM,MAAM,MAAM,GAAG,IAAI,CACvB,iBAAiB,EACjB,yBAAyB,GAAG,aAAa,CAC1C,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,EAAE,GACb,QAAQ,mBAAmB,EAC3B,WAAW,SAAS,mBAAmB,EAAE,EACzC,MAAM,MAAM,KACX,iBAUF,CAAC"}

package/dist/canonical/entries/_l1-build.js

@@ -0,0 +1,26 @@
+import { DIMENSIONLESS } from '../../dimensional/types.js';
+import { sym } from '../../bridges/equations/_be-helpers.js';
+import { dimensionalFields } from '../dimensional-fields.js';
+/** Dimension builder. Arg order is (L, M, T, **I**, **Θ**) — note I precedes Θ. */
+export const dim = (L = 0, M = 0, T = 0, I = 0, Theta = 0) => ({
+    L,
+    M,
+    T,
+    I,
+    Theta,
+    N: 0,
+    J: 0,
+});
+export const op = (o, args) => ({ kind: 'op', op: o, args });
+/** `base` raised to the numeric-literal power `n` (a dimensionless exponent). */
+export const pow = (base, n) => op('^', [base, sym(n, DIMENSIONLESS)]);
+/** Build an L1 entry; L0 fields are derived from the engine for consistency. */
+export const l1 = (target, governing, rest) => {
+    const { monomial, freeDimensionlessGroups } = dimensionalFields(target, governing);
+    return {
+        ...rest,
+        freeDimensionlessGroups,
+        dimensional: { target, governing, monomial },
+    };
+};
+//# sourceMappingURL=_l1-build.js.map

package/dist/canonical/entries/_l1-build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_l1-build.js","sourceRoot":"","sources":["../../../src/canonical/entries/_l1-build.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,GAAG,EAAE,MAAM,wCAAwC,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,mFAAmF;AACnF,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAa,EAAE,CAAC,CAAC;IACxE,CAAC;IACD,CAAC;IACD,CAAC;IACD,CAAC;IACD,KAAK;IACL,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,CAAC;CACL,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,EAAE,GAAG,CAChB,CAA8B,EAC9B,IAAgB,EACN,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;AAE7C,iFAAiF;AACjF,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,IAAc,EAAE,CAAS,EAAY,EAAE,CACzD,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;AAQzC,gFAAgF;AAChF,MAAM,CAAC,MAAM,EAAE,GAAG,CAChB,MAA2B,EAC3B,SAAyC,EACzC,IAAY,EACO,EAAE;IACrB,MAAM,EAAE,QAAQ,EAAE,uBAAuB,EAAE,GAAG,iBAAiB,CAC7D,MAAM,EACN,SAAS,CACV,CAAC;IACF,OAAO;QACL,GAAG,IAAI;QACP,uBAAuB;QACvB,WAAW,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE;KAC7C,CAAC;AACJ,CAAC,CAAC"}

package/dist/canonical/entries/dimensional-classics.d.ts

@@ -0,0 +1,11 @@
+/**
+ * L0 (dimensional) canonical entries — the 9 textbook equations recovered by
+ * the Buckingham-π engine (promoted from the dimensional-derivation benchmark).
+ * Dimensions give the monomial exponents only, never the leading constant, so
+ * every entry here is `epistemicStatus: 'dimensional'`.
+ *
+ * @module canonical/entries/dimensional-classics
+ */
+import type { CanonicalEquation } from '../canonical-equation.js';
+export declare const DIMENSIONAL_CLASSICS: readonly CanonicalEquation[];
+//# sourceMappingURL=dimensional-classics.d.ts.map

package/dist/canonical/entries/dimensional-classics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensional-classics.d.ts","sourceRoot":"","sources":["../../../src/canonical/entries/dimensional-classics.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAiDlE,eAAO,MAAM,oBAAoB,EAAE,SAAS,iBAAiB,EA6K5D,CAAC"}