universal-physics-tensor 8.0.0 → 10.0.0

package/dist/dimensional/quantity-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quantity-registry.d.ts","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC;AAEnD,wDAAwD;AACxD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7C,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AA0BD,wDAAwD;AACxD,wBAAgB,kBAAkB,IAAI,SAAS,cAAc,EAAE,CAE9D;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAQ1E"}
+{"version":3,"file":"quantity-registry.d.ts","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C,uDAAuD;AACvD,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,CAAC;AAEnD,wDAAwD;AACxD,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE7C,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B;AAED,qDAAqD;AACrD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAC;CAChD;AAED,uEAAuE;AACvE,eAAO,MAAM,QAAQ,MAAO,MAAM,KAAG,MAA8B,CAAC;AAKpE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,cAAc,EAAE,CAoBhF;AAID;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,SAAS,cAAc,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,cAAc,CAAC,CAY1G;AAID,wDAAwD;AACxD,wBAAgB,kBAAkB,IAAI,SAAS,cAAc,EAAE,CAE9D;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEvE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAQ1E"}

package/dist/dimensional/quantity-registry.js

@@ -1,36 +1,73 @@
 /**
  * The quantity registry. Canonical id, aliases, dimension, and whether an
  * affine temperature is an absolute point or an interval. Synonym groups and
- * the temperature role are projections of this table.
+ * the temperature role are projections of this table. The aliases of a
+ * quantity that is also a registered constant come from the constant registry.
  *
  * @module dimensional/quantity-registry
  */
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const foldName = (s) => s.replace(/_/g, '-');
-function loadQuantities() {
-    const path = join(dirname(fileURLToPath(import.meta.url)), '../../data/quantities.json');
-    const parsed = JSON.parse(readFileSync(path, 'utf8'));
-    return parsed.quantities;
+import { checkedDataFile } from '../core/data-file.js';
+import { CONSTANT_REGISTRY } from './symbolic-constants.js';
+/** `_` written as `-`: the one fold every spelling comparison uses. */
+export const foldName = (s) => s.replace(/_/g, '-');
+const isAffineTemperature = (dimension) => dimension.Theta === 1 && dimension.L === 0 && dimension.M === 0 && dimension.T === 0 && dimension.I === 0 && dimension.N === 0 && dimension.J === 0;
+/**
+ * The rows of a quantity file. A constant that is also a quantity (`k_B` is
+ * `boltzmann-constant`) gives that row its spellings as aliases: the
+ * constant registry owns them and the file does not repeat them. A `kind` is
+ * the role of an affine temperature, so a row whose dimension is not Θ¹ may
+ * not carry one: there it decides nothing and misleads a reader.
+ * @internal
+ */
+export function readQuantityFile(parsed) {
+    for (const row of parsed.quantities) {
+        if (row.kind !== undefined && !isAffineTemperature(row.dimension)) {
+            throw new Error(`data/quantities.json: ${row.id}: kind ${row.kind} on a quantity that is not an affine temperature`);
+        }
+    }
+    const ids = new Set(parsed.quantities.map((row) => row.id));
+    const derived = new Map();
+    for (const constant of CONSTANT_REGISTRY) {
+        if (constant.quantity === undefined)
+            continue;
+        if (!ids.has(constant.quantity)) {
+            throw new Error(`constant '${constant.name}' names quantity '${constant.quantity}', which data/quantities.json does not have`);
+        }
+        derived.set(constant.quantity, [...(derived.get(constant.quantity) ?? []), constant.name, ...constant.spellings]);
+    }
+    return parsed.quantities.map((row) => {
+        const known = new Set([row.id, ...(row.aliases ?? [])].map(foldName));
+        const spellings = (derived.get(row.id) ?? []).filter((spelling) => !known.has(foldName(spelling)));
+        return spellings.length === 0 ? row : { ...row, aliases: [...(row.aliases ?? []), ...spellings] };
+    });
 }
-const QUANTITIES = loadQuantities();
-const BY_KEY = new Map();
-for (const row of QUANTITIES) {
-    BY_KEY.set(row.id, row);
-    BY_KEY.set(foldName(row.id), row);
-    for (const alias of row.aliases ?? []) {
-        BY_KEY.set(alias, row);
-        BY_KEY.set(foldName(alias), row);
+const QUANTITIES = readQuantityFile(checkedDataFile('quantities.json'));
+/**
+ * Folded spelling → row, over every id and alias. Two rows that one folded
+ * spelling names throw: the later row would silently shadow the earlier.
+ * @internal
+ */
+export function quantitySpellingIndex(rows) {
+    const index = new Map();
+    for (const row of rows) {
+        for (const spelling of new Set([row.id, ...(row.aliases ?? [])].map(foldName))) {
+            const other = index.get(spelling);
+            if (other !== undefined) {
+                throw new Error(`data/quantities.json: '${spelling}' spells both '${other.id}' and '${row.id}' (\`_\` and \`-\` are one character)`);
+            }
+            index.set(spelling, row);
+        }
     }
+    return index;
 }
+const BY_KEY = quantitySpellingIndex(QUANTITIES);
 /** Every quantity record, graph nodes and spellings. */
 export function allQuantityRecords() {
     return QUANTITIES;
 }
 /** The record `name` spells, comparing `_` and `-` as the same character. */
 export function quantityRecord(name) {
-    return BY_KEY.get(name) ?? BY_KEY.get(foldName(name));
+    return BY_KEY.get(foldName(name));
 }
 /**
  * Synonym groups projected from declared aliases. The canonical id is first.

package/dist/dimensional/quantity-registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"quantity-registry.js","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAyBzC,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;AAE7D,SAAS,cAAc;IACrB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,4BAA4B,CAAC,CAAC;IACzF,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAiB,CAAC;IACtE,OAAO,MAAM,CAAC,UAAU,CAAC;AAC3B,CAAC;AAED,MAAM,UAAU,GAAG,cAAc,EAAE,CAAC;AAEpC,MAAM,MAAM,GAAG,IAAI,GAAG,EAA0B,CAAC;AACjD,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;IAC7B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;IACxB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAClC,KAAK,MAAM,KAAK,IAAI,GAAG,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;QACtC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACvB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC;IACnC,CAAC;AACH,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,kBAAkB;IAChC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB;IACvC,MAAM,MAAM,GAAe,EAAE,CAAC;IAC9B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;QAClC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,SAAS;QACnC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}
+{"version":3,"file":"quantity-registry.js","sourceRoot":"","sources":["../../src/dimensional/quantity-registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The quantity registry. Canonical id, aliases, dimension, and whether an\n * affine temperature is an absolute point or an interval. Synonym groups and\n * the temperature role are projections of this table. The aliases of a\n * quantity that is also a registered constant come from the constant registry.\n *\n * @module dimensional/quantity-registry\n */\n\nimport { checkedDataFile } from '../core/data-file.js';\nimport type { Dimension } from './types.js';\nimport { CONSTANT_REGISTRY } from './symbolic-constants.js';\n\n/** Declared role of an affine temperature quantity. */\nexport type QuantityKind = 'absolute' | 'interval';\n\n/** A carrier that enters a same-sign transport rule. */\nexport type SignRole = 'charge' | 'mobility';\n\n/** One quantity. `graphNode` is false for a spelling that is not a graph node. */\nexport interface QuantityRecord {\n  readonly id: string;\n  readonly symbol: string;\n  readonly dimension: Dimension;\n  readonly attributes: Readonly<Record<string, string>>;\n  readonly kind?: QuantityKind;\n  readonly aliases?: readonly string[];\n  readonly signRole?: SignRole;\n  readonly graphNode: boolean;\n}\n\n/** The shape of `data/quantities.json`. @internal */\nexport interface QuantityFile {\n  readonly quantities: readonly QuantityRecord[];\n}\n\n/** `_` written as `-`: the one fold every spelling comparison uses. */\nexport const foldName = (s: string): string => s.replace(/_/g, '-');\n\nconst isAffineTemperature = (dimension: Dimension): boolean =>\n  dimension.Theta === 1 && dimension.L === 0 && dimension.M === 0 && dimension.T === 0 && dimension.I === 0 && dimension.N === 0 && dimension.J === 0;\n\n/**\n * The rows of a quantity file. A constant that is also a quantity (`k_B` is\n * `boltzmann-constant`) gives that row its spellings as aliases: the\n * constant registry owns them and the file does not repeat them. A `kind` is\n * the role of an affine temperature, so a row whose dimension is not Θ¹ may\n * not carry one: there it decides nothing and misleads a reader.\n * @internal\n */\nexport function readQuantityFile(parsed: QuantityFile): readonly QuantityRecord[] {\n  for (const row of parsed.quantities) {\n    if (row.kind !== undefined && !isAffineTemperature(row.dimension)) {\n      throw new Error(`data/quantities.json: ${row.id}: kind ${row.kind} on a quantity that is not an affine temperature`);\n    }\n  }\n  const ids = new Set(parsed.quantities.map((row) => row.id));\n  const derived = new Map<string, string[]>();\n  for (const constant of CONSTANT_REGISTRY) {\n    if (constant.quantity === undefined) continue;\n    if (!ids.has(constant.quantity)) {\n      throw new Error(`constant '${constant.name}' names quantity '${constant.quantity}', which data/quantities.json does not have`);\n    }\n    derived.set(constant.quantity, [...(derived.get(constant.quantity) ?? []), constant.name, ...constant.spellings]);\n  }\n  return parsed.quantities.map((row) => {\n    const known = new Set([row.id, ...(row.aliases ?? [])].map(foldName));\n    const spellings = (derived.get(row.id) ?? []).filter((spelling) => !known.has(foldName(spelling)));\n    return spellings.length === 0 ? row : { ...row, aliases: [...(row.aliases ?? []), ...spellings] };\n  });\n}\n\nconst QUANTITIES = readQuantityFile(checkedDataFile('quantities.json') as QuantityFile);\n\n/**\n * Folded spelling → row, over every id and alias. Two rows that one folded\n * spelling names throw: the later row would silently shadow the earlier.\n * @internal\n */\nexport function quantitySpellingIndex(rows: readonly QuantityRecord[]): ReadonlyMap<string, QuantityRecord> {\n  const index = new Map<string, QuantityRecord>();\n  for (const row of rows) {\n    for (const spelling of new Set([row.id, ...(row.aliases ?? [])].map(foldName))) {\n      const other = index.get(spelling);\n      if (other !== undefined) {\n        throw new Error(`data/quantities.json: '${spelling}' spells both '${other.id}' and '${row.id}' (\\`_\\` and \\`-\\` are one character)`);\n      }\n      index.set(spelling, row);\n    }\n  }\n  return index;\n}\n\nconst BY_KEY = quantitySpellingIndex(QUANTITIES);\n\n/** Every quantity record, graph nodes and spellings. */\nexport function allQuantityRecords(): readonly QuantityRecord[] {\n  return QUANTITIES;\n}\n\n/** The record `name` spells, comparing `_` and `-` as the same character. */\nexport function quantityRecord(name: string): QuantityRecord | undefined {\n  return BY_KEY.get(foldName(name));\n}\n\n/**\n * Synonym groups projected from declared aliases. The canonical id is first.\n * A quantity with no alias is not a group.\n */\nexport function synonymGroupsFromRegistry(): readonly (readonly string[])[] {\n  const groups: string[][] = [];\n  for (const row of QUANTITIES) {\n    const aliases = row.aliases ?? [];\n    if (aliases.length === 0) continue;\n    groups.push([row.id, ...aliases]);\n  }\n  return groups;\n}\n"]}

package/dist/dimensional/rg-flow.js.map

@@ -1 +1 @@
-{"version":3,"file":"rg-flow.js","sourceRoot":"","sources":["../../src/dimensional/rg-flow.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rg-flow.js","sourceRoot":"","sources":["../../src/dimensional/rg-flow.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Renormalization-group (RG) flow primitives — `RGCouplingNode` +\n * `BetaFunctionNode` (v0.7 BE-X re-encoding sprint).\n *\n * Encodes the structure of a Wilsonian / functional-RG flow on the\n * space of *dimensionless* couplings. The motivating physics context\n * is the asymptotic-safety program for quantum gravity (Reuter 1998\n * *Phys. Rev. D* 57:971, arXiv:hep-th/9605030; Niedermaier-Reuter 2006\n * *Living Rev. Relativity* 9:5 for the canonical review), in which RG\n * flow on the space of dimensionless couplings `g_n = G_n(k)·k^{d_n}`\n * is governed by polynomial β-functions\n *\n *     β_n(g_1, g_2, …) ≡ k ∂_k g_n\n *\n * and a viable UV-complete theory is signalled by the existence of a\n * non-Gaussian fixed point `(g_1*, g_2*, …)` at which every β_n\n * vanishes simultaneously. The structural distinction made here:\n *\n *   - `RGCouplingNode` represents a single dimensionless coupling\n *     (`g`, `λ`, …) — a labelled handle, dim hardcoded to\n *     DIMENSIONLESS for type-system symmetry with other AST nodes.\n *   - `BetaFunctionNode` represents one β-function of a multi-coupling\n *     flow: it carries the FULL coupling vector (the flow direction),\n *     a `target` selector picking out which coupling's β-function this\n *     node represents, the polynomial expression in those couplings,\n *     and an optional UV / IR fixed-point pin.\n *\n * The polynomial expression is a standard `ExprNode` built from\n * dimensionless symbols + the existing `op (+ * / ^ -)` primitives;\n * `validateBetaFunction` delegates dimensional checking to the existing\n * `validate()` from `validator.ts` and verifies the result reduces to\n * DIMENSIONLESS.\n *\n * These primitives are NOT (yet) added to the `ExprNode` union — they\n * live as a standalone predicate-level structure that callers compose\n * adjacent to the existing AST. BE-39's polynomial RHS continues to be\n * encoded as plain `op`-trees for catalog round-trip; the structural\n * `BetaFunctionNode` wrapper supplies the higher-level RG-flow\n * semantics on top.\n *\n * @module dimensional/rg-flow\n */\n\nimport type { ExprNode } from './validator.js';\nimport { validate } from './validator.js';\nimport type { Dimension } from './types.js';\nimport { DIMENSIONLESS } from './types.js';\nimport { validateComponentDimension } from './field-equation-helpers.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// RGCouplingNode\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * AST node for a single dimensionless RG coupling (e.g. `g`, `λ`).\n *\n * By RG-discipline every coupling appearing in a β-function expression\n * is dimensionless: physical dimensionful couplings `G_n` are made\n * dimensionless via the RG scale `k` (e.g. `g = G·k²`, `λ = Λ/k²`).\n * The `dim` field is therefore hardcoded to `DIMENSIONLESS`; it is\n * exposed for type-system symmetry with `{ kind: 'symbol' }` so a\n * future ExprNode-union integration is mechanical.\n *\n * @public\n */\nexport interface RGCouplingNode {\n  readonly kind: 'rg-coupling';\n  /** Coupling name, e.g. `'g'`, `'lambda'`. Non-empty. */\n  readonly name: string;\n  /** Always `DIMENSIONLESS` — RG-discipline invariant. */\n  readonly dim: Dimension;\n}\n\n/**\n * Construct an `RGCouplingNode` with the dimensionless invariant\n * pre-applied. Convenience helper — callers may also build the node\n * literal directly.\n *\n * @public\n */\nexport function rgCoupling(name: string): RGCouplingNode {\n  return { kind: 'rg-coupling', name, dim: DIMENSIONLESS };\n}\n\n/**\n * Validate an `RGCouplingNode`.\n *\n * Predicates:\n *   1. `name` is a non-empty string (dimension validators reject empty\n *      labels because they make error messages unintelligible).\n *   2. `dim` is `DIMENSIONLESS` (RG-discipline invariant; physical\n *      dimension is absorbed into the running scale `k`).\n *\n * Throws an `Error` with `\"name\"` / `\"dimension\"` in the message on\n * failure.\n *\n * @public\n */\nexport function validateRGCoupling(node: RGCouplingNode): void {\n  if (typeof node.name !== 'string' || node.name.length === 0) {\n    throw new Error(\n      `RGCouplingNode: invalid name — must be a non-empty string ` +\n        `(got ${JSON.stringify(node.name)}).`,\n    );\n  }\n  validateComponentDimension(\n    'RGCouplingNode',\n    `coupling '${node.name}'`,\n    node.dim,\n    DIMENSIONLESS,\n    `must be DIMENSIONLESS by RG-discipline. Physical dimension should be absorbed into the running scale k.`,\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BetaFunctionNode\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * AST node for a single β-function in a multi-coupling RG flow.\n *\n * Fields:\n *   - `couplings` — the full coupling vector `(g_1, g_2, …)`; this is\n *     the flow direction. Every coupling must appear here, even those\n *     that do not enter the polynomialExpansion of this specific\n *     β-function (so that the cross-coupling dependency structure is\n *     captured at the type level).\n *   - `target` — the coupling whose β-function this node represents.\n *     MUST be one of `couplings` (by name).\n *   - `polynomialExpansion` — the explicit β(couplings) expression as\n *     a standard `ExprNode`. Must reduce to `DIMENSIONLESS` via the\n *     existing `validate()`.\n *   - `fixedPoint` — optional UV / IR fixed-point pin, one numeric\n *     value per coupling in the same order as `couplings`. When\n *     present, `fixedPoint.length === couplings.length` is enforced.\n *\n * The polynomial form follows Reuter 1998 + the Niedermaier-Reuter 2006\n * review: each β_n is a polynomial in the dimensionless couplings,\n * truncated at some power dictated by the chosen truncation scheme\n * (e.g. canonical Einstein-Hilbert truncation for gravity).\n *\n * @public\n */\nexport interface BetaFunctionNode {\n  readonly kind: 'beta-function';\n  readonly couplings: ReadonlyArray<RGCouplingNode>;\n  readonly target: RGCouplingNode;\n  readonly polynomialExpansion: ExprNode;\n  readonly fixedPoint?: ReadonlyArray<number>;\n}\n\n/**\n * Result of validating a `BetaFunctionNode`.\n *\n * `dim` is always `DIMENSIONLESS` (a β-function of dimensionless\n * couplings is itself dimensionless: `β = k ∂_k g` with both `g` and\n * `k ∂_k log(k)` dimensionless). `targetName` is the validated target\n * coupling label, useful for downstream RG-flow assembly.\n *\n * @public\n */\nexport interface BetaFunctionValidationResult {\n  readonly dim: Dimension;\n  readonly targetName: string;\n}\n\n/**\n * Validate a `BetaFunctionNode`.\n *\n * Predicates:\n *\n *   1. **Coupling list non-empty**: `couplings.length >= 1`. A flow\n *      with no couplings has no β-function to define.\n *   2. **Every coupling is well-formed**: each entry passes\n *      `validateRGCoupling`. Names must be unique.\n *   3. **Target ∈ couplings**: `target.name` appears in\n *      `couplings.map(c => c.name)`. Throws an Error scoped\n *      `'BetaFunctionNode: target …'` on miss.\n *   4. **Polynomial dimensionless**: `validate(polynomialExpansion)`\n *      succeeds and yields `DIMENSIONLESS`. Anything else throws with\n *      `'dimension'` in the message.\n *   5. **Fixed-point length match** (if `fixedPoint` is set):\n *      `fixedPoint.length === couplings.length`. Each value must be\n *      finite. Throws scoped `'BetaFunctionNode: fixedPoint …'` on\n *      mismatch.\n *\n * @public\n */\nexport function validateBetaFunction(\n  node: BetaFunctionNode,\n): BetaFunctionValidationResult {\n  // ── Predicate 1: coupling list non-empty ───────────────────────────────────\n  if (node.couplings.length === 0) {\n    throw new Error(\n      `BetaFunctionNode: coupling list is empty — an RG flow requires ` +\n        `at least one coupling. Define the flow direction in 'couplings'.`,\n    );\n  }\n\n  // ── Predicate 2: every coupling is well-formed; names unique ──────────────\n  const seen = new Set<string>();\n  for (const c of node.couplings) {\n    validateRGCoupling(c);\n    if (seen.has(c.name)) {\n      throw new Error(\n        `BetaFunctionNode: duplicate coupling name '${c.name}' in ` +\n          `couplings list. Each RGCouplingNode must have a unique name.`,\n      );\n    }\n    seen.add(c.name);\n  }\n\n  // ── Predicate 3: target is one of the couplings ───────────────────────────\n  validateRGCoupling(node.target);\n  if (!seen.has(node.target.name)) {\n    throw new Error(\n      `BetaFunctionNode: target coupling '${node.target.name}' is not in ` +\n        `the couplings list [${[...seen].join(', ')}]. The target must be ` +\n        `one of the flow-direction couplings.`,\n    );\n  }\n\n  // ── Predicate 4: polynomialExpansion validates to DIMENSIONLESS ───────────\n  const polyResult = validate(node.polynomialExpansion);\n  if (!polyResult.ok || polyResult.inferredDimension === null) {\n    const noteSummary = polyResult.violations\n      .map((v) => v.note)\n      .join('; ');\n    throw new Error(\n      `BetaFunctionNode: polynomialExpansion failed dimension inference ` +\n        `for target '${node.target.name}' — ${noteSummary || 'no detail available'}.`,\n    );\n  }\n  validateComponentDimension(\n    'BetaFunctionNode',\n    `polynomialExpansion for target '${node.target.name}'`,\n    polyResult.inferredDimension,\n    DIMENSIONLESS,\n    `must be DIMENSIONLESS (β-function of dimensionless couplings).`,\n  );\n\n  // ── Predicate 5: fixed-point length agrees with couplings count ───────────\n  if (node.fixedPoint !== undefined) {\n    if (node.fixedPoint.length !== node.couplings.length) {\n      throw new Error(\n        `BetaFunctionNode: fixedPoint length mismatch — got ` +\n          `${node.fixedPoint.length} value(s) but couplings list has ` +\n          `${node.couplings.length}. Provide one fixed-point coordinate ` +\n          `per coupling in the same order as 'couplings'.`,\n      );\n    }\n    for (let i = 0; i < node.fixedPoint.length; i++) {\n      const v = node.fixedPoint[i];\n      if (!Number.isFinite(v)) {\n        throw new Error(\n          `BetaFunctionNode: fixedPoint[${i}] (coupling ` +\n            `'${node.couplings[i].name}') is not finite (got ${v}).`,\n        );\n      }\n    }\n  }\n\n  return { dim: DIMENSIONLESS, targetName: node.target.name };\n}\n"]}

package/dist/dimensional/stress-energy-validators.js.map

@@ -1 +1 @@
-{"version":3,"file":"stress-energy-validators.js","sourceRoot":"","sources":["../../src/dimensional/stress-energy-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA2BH;;;;;;;;GAQG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA4B;IAE5B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAC3E,CAAC;IACJ,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,+EAA+E,GAAG,CAAC,QAAQ,IAAI,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4C,CAAC;IACxE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;AACjD,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,IAA8B;IAE9B,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAChF,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;AACnD,CAAC"}
+{"version":3,"file":"stress-energy-validators.js","sourceRoot":"","sources":["../../src/dimensional/stress-energy-validators.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA2BH;;;;;;;;GAQG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA4B;IAE5B,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAC3E,CAAC;IACJ,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,+EAA+E,GAAG,CAAC,QAAQ,IAAI,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,WAAW,GAAG,IAAI,GAAG,EAA4C,CAAC;IACxE,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/D,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;AACjD,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,IAA8B;IAE9B,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,KAAK,CACb,qDAAqD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAChF,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,GAAG,EAAE,EAAE,CAAC;AACnD,CAAC","sourcesContent":["/**\n * Stress-energy tensor and cosmological constant AST nodes (v0.6.0 Phase 2).\n *\n * Locked to lower-lower variance (Decision #2). Symmetry locked as\n * explicit field (Decision #12). Antisymmetric T_μν⁺ (Belinfante-Rosenfeld)\n * deferred to v0.7.0+.\n *\n * @module dimensional/stress-energy-validators\n */\n\nimport type { Dimension } from './types.js';\nimport type {\n  CovariantIndex,\n  StressEnergyTensorNode,\n  CosmologicalConstantNode,\n} from './ast-types.js';\n\n// Node types now live in the leaf `ast-types.ts`; re-exported for compat.\nexport type { StressEnergyTensorNode, CosmologicalConstantNode } from './ast-types.js';\n\n/**\n * AST node for the stress-energy tensor T_μν. Rank-2 lower-lower locked\n * (Decision #2). Symmetric (Decision #12).\n *\n * componentDim is the SI dimension of a single component: [M·L⁻¹·T⁻²]\n * (energy density = Pa = kg·m⁻¹·s⁻²).\n *\n * @public\n */\n// v0.6.1: dropped export — internal-only validation-result shape.\ninterface StressEnergyValidationResult {\n  readonly dim: Dimension;\n  readonly freeIndices: Map<string, { upper: number; lower: number }>;\n}\n\n/**\n * Validate a `stress-energy` node.\n *\n * Throws:\n *   - Error if rank ≠ 2 (T_μν is a rank-2 tensor by definition).\n *   - Error if any index variance ≠ 'lower' (lower-lower locked per Decision #2).\n *\n * Returns `{dim: componentDim, freeIndices: {idx0: {lower:1}, idx1: {lower:1}}}`.\n */\nexport function validateStressEnergyTensor(\n  node: StressEnergyTensorNode,\n): StressEnergyValidationResult {\n  if (node.indices.length !== 2) {\n    throw new Error(\n      `StressEnergyTensorNode: expected rank-2, got rank-${node.indices.length}`,\n    );\n  }\n  for (const idx of node.indices) {\n    if (idx.variance !== 'lower') {\n      throw new Error(\n        `StressEnergyTensorNode: only lower-lower variance supported in v0.6.0 (got '${idx.variance}')`,\n      );\n    }\n  }\n  const freeIndices = new Map<string, { upper: number; lower: number }>();\n  freeIndices.set(node.indices[0].label, { upper: 0, lower: 1 });\n  freeIndices.set(node.indices[1].label, { upper: 0, lower: 1 });\n  return { dim: node.componentDim, freeIndices };\n}\n\n// v0.6.1: dropped export — internal-only validation-result shape.\ninterface CosmologicalConstantValidationResult {\n  readonly dim: Dimension;\n  readonly freeIndices: Map<string, { upper: number; lower: number }>;\n}\n\n/**\n * Validate a `cosmological-constant` node.\n *\n * Throws:\n *   - Error if dim ≠ [L⁻²] (check L === -2 && M === 0 && T === 0).\n *\n * Returns `{dim, freeIndices: empty}` (scalar — no free indices).\n */\nexport function validateCosmologicalConstant(\n  node: CosmologicalConstantNode,\n): CosmologicalConstantValidationResult {\n  if (node.dim.L !== -2 || node.dim.M !== 0 || node.dim.T !== 0) {\n    throw new Error(\n      `CosmologicalConstantNode: expected dim [L⁻²], got ${JSON.stringify(node.dim)}`,\n    );\n  }\n  return { dim: node.dim, freeIndices: new Map() };\n}\n"]}

package/dist/dimensional/symbolic-constants.d.ts

@@ -1,42 +1,89 @@
 /**
- * Symbolic-composition constant registry (v0.12 symbolic composition).
+ * The constant registry: one row per physical constant a formula may name.
  *
- * The physical constants and named numeric factors that a bridge's
- * `symbolic` ExprNode may reference as leaf symbols, with the SI value AND
- * the SI dimension. SI VALUES import from `core/constants.js` — the single
- * source the bridge evaluators also resolve to — so a symbolic form and its
- * numeric evaluator agree bit-for-bit (the drift guard binds this end-to-end;
- * Adam A-7 / Eve EVE-3).
+ * A row (written in `constant-rows.ts`) holds the formula name, its other
+ * exact-case spellings, the SI value (imported from `core/constants.js`, the
+ * one owner of every value), the SI unit in `parseUnit` syntax, the meaning
+ * and the source. The dimension is derived from the unit once, here; no second
+ * table states it. The rows sit in their own module because the unit table
+ * names constants by these spellings, and this module imports the unit parser. Every other
+ * constant table in the library ({@link CONSTANTS}, `FORMULA_NAMED`,
+ * `CONSTANT_SPELLINGS`, {@link CONSTANT_PROVENANCE}, `CANONICAL_CONSTANTS`,
+ * the `upt eval` scope, the binding scope, the gradient constants) is a
+ * projection of this array, so a spelling, a value and a dimension cannot
+ * disagree between two files. A constant that is also a quantity names its
+ * `data/quantities.json` row in `quantity`; the quantity registry derives that
+ * row's aliases from here, so the file states no constant spelling.
  *
- * Numeric-literal leaves (`'2'`, `'3'`) are NOT registered here — `evalExpr`
+ * `canonical` marks a universal constant a canonical equation's `governing`
+ * list may bake as a leaf. A row that is an overlay for `upt eval` and the
+ * dimensional assignment only (`m_p`, `N_A`, the GRW parameters) is not
+ * canonical, so the canonical graph does not bake it.
+ *
+ * Numeric-literal leaves (`'2'`, `'3'`) are NOT registered — `evalExpr`
  * resolves them via `Number(name)` and they are implicitly dimensionless.
- * Non-base-10 tokens (`'8pi'`, `'4pi'`, `'ln2'`) MUST be here (Adam A-1 —
- * `Number('8pi')` is `NaN`).
+ * Non-base-10 tokens (`'8pi'`, `'4pi'`, `'ln2'`) MUST be here (`Number('8pi')`
+ * is `NaN`).
  *
  * INTERNAL — not on the public surface.
  *
  * @module dimensional/symbolic-constants
  */
 import type { Dimension } from './types.js';
+import { type ConstantRow } from './constant-rows.js';
+/** One registered constant: its row, with the dimension derived from its unit. @internal */
+export interface ConstantRecord extends ConstantRow {
+    readonly dim: Dimension;
+}
+/**
+ * Every registered constant, the rows of `constant-rows.ts` with each
+ * dimension derived once from its unit. Order is the order the tables print.
+ * @internal
+ */
+export declare const CONSTANT_REGISTRY: readonly ConstantRecord[];
+/** The registered constant `spelling` names, or undefined. @internal */
+export declare function constantRecord(spelling: string): ConstantRecord | undefined;
+/** A stated value for a registered constant disagrees with the registry. The equations use the registered value. @internal */
+export declare class ConstantDisagreementError extends Error {
+    readonly key: string;
+    readonly constant: string;
+    readonly registered: number;
+    readonly given: number;
+    constructor(key: string, constant: string, registered: number, given: number);
+}
+/**
+ * The registered constant `key` names when `value` agrees with it within
+ * {@link CONSTANT_AGREEMENT}, or null when `key` names no constant. A value
+ * that disagrees throws {@link ConstantDisagreementError}: a constant is not
+ * a graph quantity, so a stated value is checked, never bound.
+ * @internal
+ */
+export declare function constantAgreement(key: string, value: number): string | null;
+/** The notes of the registered constants among `names`, each once, in registry order. @internal */
+export declare function constantNotes(names: Iterable<string>): string[];
+/** Every spelling → SI value, for a numeric scope. `pi` and `tau` are added. @internal */
+export declare function constantScope(): Record<string, number>;
 /** A registered constant leaf: SI value + SI dimension. @internal */
-interface NamedConstantValue {
+export interface NamedConstantValue {
     readonly value: number;
     readonly dim: Dimension;
 }
 /**
- * Constant leaves a `symbolic` ExprNode may reference. Keys are the leaf
- * symbol `name`s; values carry the SI magnitude and dimension. `ln2`/`8pi`/
- * `4pi` reproduce the evaluators' `Math.LN2` / `8*Math.PI` / `4*Math.PI`
- * exactly (same IEEE-754 primitives).
+ * Constant leaves a `symbolic` ExprNode may reference, keyed by formula name:
+ * the canonical rows of {@link CONSTANT_REGISTRY}. `ln2`/`8pi`/`4pi`
+ * reproduce the evaluators' `Math.LN2` / `8*Math.PI` / `4*Math.PI` exactly
+ * (same IEEE-754 primitives).
  */
 export declare const CONSTANTS: Readonly<Record<string, NamedConstantValue>>;
 /** What a registered constant is, its SI unit, and where its value comes from (audit I10). @internal */
 export interface ConstantProvenance {
     readonly meaning: string;
-    /** The SI unit, in the syntax `parseUnit` reads; a test checks it against the registered dimension. */
+    /** The SI unit, in the syntax `parseUnit` reads; the registered dimension is derived from it. */
     readonly unit: string;
     readonly source: string;
 }
+/** One row per {@link CONSTANT_REGISTRY} name. @internal */
+export declare const CONSTANT_PROVENANCE: Readonly<Record<string, ConstantProvenance>>;
 /**
  * A spelled-out multiple of π written as one symbol (`pi`, `6pi`). `2pi`,
  * `4pi` and `8pi` are also registered in {@link CONSTANTS}; this covers the
@@ -47,7 +94,4 @@ export interface ConstantProvenance {
  * @internal
  */
 export declare function piMultipleValue(name: string): number | undefined;
-/** One row per {@link CONSTANTS} key; a test holds the two key sets equal. @internal */
-export declare const CONSTANT_PROVENANCE: Readonly<Record<string, ConstantProvenance>>;
-export {};
 //# sourceMappingURL=symbolic-constants.d.ts.map

package/dist/dimensional/symbolic-constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbolic-constants.d.ts","sourceRoot":"","sources":["../../src/dimensional/symbolic-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAiC5C,qEAAqE;AACrE,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAuBlE,CAAC;AAEF,wGAAwG;AACxG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uGAAuG;IACvG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMhE;AAED,wFAAwF;AACxF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CA6B5E,CAAC"}
+{"version":3,"file":"symbolic-constants.d.ts","sourceRoot":"","sources":["../../src/dimensional/symbolic-constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAA8B,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAElF,4FAA4F;AAC5F,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAGpD,CAAC;AAkBJ,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAG3E;AASD,8HAA8H;AAC9H,qBAAa,yBAA0B,SAAQ,KAAK;IAEhD,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM;IAJxB,YACW,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EAOvB;CACF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO3E;AAED,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAO/D;AAED,0FAA0F;AAC1F,wBAAgB,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAItD;AAED,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAKlE,CAAC;AAEF,wGAAwG;AACxG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,iGAAiG;IACjG,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAK5E,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMhE"}

package/dist/dimensional/symbolic-constants.js

@@ -1,75 +1,128 @@
 /**
- * Symbolic-composition constant registry (v0.12 symbolic composition).
+ * The constant registry: one row per physical constant a formula may name.
  *
- * The physical constants and named numeric factors that a bridge's
- * `symbolic` ExprNode may reference as leaf symbols, with the SI value AND
- * the SI dimension. SI VALUES import from `core/constants.js` — the single
- * source the bridge evaluators also resolve to — so a symbolic form and its
- * numeric evaluator agree bit-for-bit (the drift guard binds this end-to-end;
- * Adam A-7 / Eve EVE-3).
+ * A row (written in `constant-rows.ts`) holds the formula name, its other
+ * exact-case spellings, the SI value (imported from `core/constants.js`, the
+ * one owner of every value), the SI unit in `parseUnit` syntax, the meaning
+ * and the source. The dimension is derived from the unit once, here; no second
+ * table states it. The rows sit in their own module because the unit table
+ * names constants by these spellings, and this module imports the unit parser. Every other
+ * constant table in the library ({@link CONSTANTS}, `FORMULA_NAMED`,
+ * `CONSTANT_SPELLINGS`, {@link CONSTANT_PROVENANCE}, `CANONICAL_CONSTANTS`,
+ * the `upt eval` scope, the binding scope, the gradient constants) is a
+ * projection of this array, so a spelling, a value and a dimension cannot
+ * disagree between two files. A constant that is also a quantity names its
+ * `data/quantities.json` row in `quantity`; the quantity registry derives that
+ * row's aliases from here, so the file states no constant spelling.
  *
- * Numeric-literal leaves (`'2'`, `'3'`) are NOT registered here — `evalExpr`
+ * `canonical` marks a universal constant a canonical equation's `governing`
+ * list may bake as a leaf. A row that is an overlay for `upt eval` and the
+ * dimensional assignment only (`m_p`, `N_A`, the GRW parameters) is not
+ * canonical, so the canonical graph does not bake it.
+ *
+ * Numeric-literal leaves (`'2'`, `'3'`) are NOT registered — `evalExpr`
  * resolves them via `Number(name)` and they are implicitly dimensionless.
- * Non-base-10 tokens (`'8pi'`, `'4pi'`, `'ln2'`) MUST be here (Adam A-1 —
- * `Number('8pi')` is `NaN`).
+ * Non-base-10 tokens (`'8pi'`, `'4pi'`, `'ln2'`) MUST be here (`Number('8pi')`
+ * is `NaN`).
  *
  * INTERNAL — not on the public surface.
  *
  * @module dimensional/symbolic-constants
  */
-import { ACTION, CHARGE, DIMENSIONLESS, MASS, VELOCITY, } from './types.js';
-import { C_SI, E_SI, G_SI, GM_SUN_SI, HBAR_SI, H_SI, K_B_SI, B_WIEN_SI, M_U_SI } from '../core/constants.js';
-const dim = (L = 0, M = 0, T = 0, Theta = 0) => ({
-    L,
-    M,
-    T,
-    I: 0,
-    Theta,
-    N: 0,
-    J: 0,
-});
-/** Newton's constant G — [L³ M⁻¹ T⁻²]. */
-const GRAV = dim(3, -1, -2);
-/** Boltzmann constant k_B — [L² M T⁻² Θ⁻¹] (energy / temperature). */
-const BOLTZMANN = dim(2, 1, -2, -1);
-/** Vacuum permittivity ε₀ — [I² T⁴ M⁻¹ L⁻³] (F/m). Carries a current
- *  dimension, so it cannot use the (L,M,T,Θ) `dim` helper. */
-const PERMITTIVITY = { L: -3, M: -1, T: 4, I: 2, Theta: 0, N: 0, J: 0 };
-/** Stefan–Boltzmann σ — [M T⁻³ Θ⁻⁴] (W m⁻² K⁻⁴). Derived:
- *  σ = 2π⁵k_B⁴ / (15 c² h³). */
-const STEFAN_BOLTZMANN = dim(0, 1, -3, -4);
-/** Wien displacement constant b — [L·Θ] (m·K). */
-const WIEN = dim(1, 0, 0, 1);
+import { parseUnit } from './units.js';
+import { CONSTANT_ROWS, constantRow } from './constant-rows.js';
+/**
+ * Every registered constant, the rows of `constant-rows.ts` with each
+ * dimension derived once from its unit. Order is the order the tables print.
+ * @internal
+ */
+export const CONSTANT_REGISTRY = CONSTANT_ROWS.map((constant) => ({
+    ...constant,
+    dim: parseUnit(constant.unit).dim,
+}));
+const RECORD_OF_ROW = new Map(CONSTANT_ROWS.map((constant, i) => [constant, CONSTANT_REGISTRY[i]]));
+/**
+ * Every spelling → its record; `constant-rows.ts` refuses a spelling written twice. A constant
+ * that is also a quantity (`quantity`, e.g. `k_B` → `boltzmann-constant`) is reachable by that
+ * quantity id too, so a user who writes the quantity's name states the constant, and the value
+ * is checked against the registry rather than bound.
+ */
+const BY_SPELLING = new Map(CONSTANT_REGISTRY.flatMap((record) => [record.name, ...record.spellings, ...(record.quantity === undefined ? [] : [record.quantity])].map((spelling) => [spelling, record])));
+/** The registered constant `spelling` names, or undefined. @internal */
+export function constantRecord(spelling) {
+    const constant = constantRow(spelling);
+    return constant === undefined ? undefined : RECORD_OF_ROW.get(constant);
+}
+/**
+ * Relative tolerance within which a stated constant agrees with the registered
+ * value. Textbook roundings such as `b = 2.9e-3` pass.
+ * @internal
+ */
+const CONSTANT_AGREEMENT = 5e-3;
+/** A stated value for a registered constant disagrees with the registry. The equations use the registered value. @internal */
+export class ConstantDisagreementError extends Error {
+    key;
+    constant;
+    registered;
+    given;
+    constructor(key, constant, registered, given) {
+        super(`'${key}' is the registered constant ${constant} = ${registered}; ` +
+            `${given} disagrees, and the equations use the registered value, so it cannot be rebound.`);
+        this.key = key;
+        this.constant = constant;
+        this.registered = registered;
+        this.given = given;
+        this.name = 'ConstantDisagreementError';
+    }
+}
+/**
+ * The registered constant `key` names when `value` agrees with it within
+ * {@link CONSTANT_AGREEMENT}, or null when `key` names no constant. A value
+ * that disagrees throws {@link ConstantDisagreementError}: a constant is not
+ * a graph quantity, so a stated value is checked, never bound.
+ * @internal
+ */
+export function constantAgreement(key, value) {
+    const record = BY_SPELLING.get(key);
+    if (record === undefined)
+        return null;
+    if (Math.abs(value - record.value) > CONSTANT_AGREEMENT * Math.abs(record.value)) {
+        throw new ConstantDisagreementError(key, record.name, record.value, value);
+    }
+    return record.name;
+}
+/** The notes of the registered constants among `names`, each once, in registry order. @internal */
+export function constantNotes(names) {
+    const seen = new Set();
+    for (const name of names) {
+        const record = BY_SPELLING.get(name);
+        if (record?.note !== undefined)
+            seen.add(record);
+    }
+    return CONSTANT_REGISTRY.filter((record) => seen.has(record)).map((record) => record.note);
+}
+/** Every spelling → SI value, for a numeric scope. `pi` and `tau` are added. @internal */
+export function constantScope() {
+    const scope = { pi: Math.PI, tau: 2 * Math.PI };
+    for (const [spelling, record] of BY_SPELLING)
+        scope[spelling] = record.value;
+    return scope;
+}
 /**
- * Constant leaves a `symbolic` ExprNode may reference. Keys are the leaf
- * symbol `name`s; values carry the SI magnitude and dimension. `ln2`/`8pi`/
- * `4pi` reproduce the evaluators' `Math.LN2` / `8*Math.PI` / `4*Math.PI`
- * exactly (same IEEE-754 primitives).
+ * Constant leaves a `symbolic` ExprNode may reference, keyed by formula name:
+ * the canonical rows of {@link CONSTANT_REGISTRY}. `ln2`/`8pi`/`4pi`
+ * reproduce the evaluators' `Math.LN2` / `8*Math.PI` / `4*Math.PI` exactly
+ * (same IEEE-754 primitives).
  */
-export const CONSTANTS = {
-    hbar: { value: HBAR_SI, dim: ACTION },
-    h: { value: H_SI, dim: ACTION },
-    c: { value: C_SI, dim: VELOCITY },
-    G: { value: G_SI, dim: GRAV },
-    k_B: { value: K_B_SI, dim: BOLTZMANN },
-    ln2: { value: Math.LN2, dim: DIMENSIONLESS },
-    '8pi': { value: 8 * Math.PI, dim: DIMENSIONLESS },
-    '4pi': { value: 4 * Math.PI, dim: DIMENSIONLESS },
-    '2pi': { value: 2 * Math.PI, dim: DIMENSIONLESS },
-    // Extension constants for the canonical-equation L1 entries (Coulomb, Bohr,
-    // Stefan–Boltzmann). CODATA 2018 values.
-    // ISO 80000 / CODATA: a bare e is the elementary charge. Eccentricity is
-    // one_minus_e_sq. The canonical dimension guard still refuses to bake a
-    // dimensionless governing name e.
-    e: { value: E_SI, dim: CHARGE },
-    epsilon_0: { value: 8.8541878128e-12, dim: PERMITTIVITY },
-    sigma_sb: { value: 5.670374419e-8, dim: STEFAN_BOLTZMANN },
-    b: { value: B_WIEN_SI, dim: WIEN },
-    // IAU 2015 nominal solar parameter. M_sun in eval stays the rounded kilogram M_SUN_SI.
-    GM_sun: { value: GM_SUN_SI, dim: dim(3, 0, -2) },
-    Msun_iau: { value: GM_SUN_SI / G_SI, dim: dim(0, 1, 0) },
-    m_u: { value: M_U_SI, dim: MASS },
-};
+export const CONSTANTS = Object.fromEntries(CONSTANT_REGISTRY.filter((record) => record.canonical).map((record) => [
+    record.name,
+    { value: record.value, dim: record.dim },
+]));
+/** One row per {@link CONSTANT_REGISTRY} name. @internal */
+export const CONSTANT_PROVENANCE = Object.fromEntries(CONSTANT_REGISTRY.map((record) => [
+    record.name,
+    { meaning: record.meaning, unit: record.unit, source: record.source },
+]));
 /**
  * A spelled-out multiple of π written as one symbol (`pi`, `6pi`). `2pi`,
  * `4pi` and `8pi` are also registered in {@link CONSTANTS}; this covers the
@@ -88,35 +141,4 @@ export function piMultipleValue(name) {
         return undefined;
     return n * Math.PI;
 }
-/** One row per {@link CONSTANTS} key; a test holds the two key sets equal. @internal */
-export const CONSTANT_PROVENANCE = {
-    hbar: { meaning: 'reduced Planck constant h/(2π)', unit: 'J*s', source: 'exact H_SI/(2π) (core/constants.ts HBAR_SI)' },
-    h: { meaning: 'Planck constant', unit: 'J*s', source: 'exact SI, 2019 redefinition (core/constants.ts H_SI)' },
-    c: { meaning: 'speed of light in vacuum', unit: 'm/s', source: 'exact SI (core/constants.ts C_SI)' },
-    G: { meaning: 'Newtonian gravitational constant', unit: 'm^3/(kg*s^2)', source: 'CODATA 2018 (core/constants.ts G_SI)' },
-    k_B: { meaning: 'Boltzmann constant', unit: 'J/K', source: 'exact SI, 2019 redefinition (core/constants.ts K_B_SI)' },
-    ln2: { meaning: 'natural logarithm of 2', unit: '1', source: 'mathematical constant (Math.LN2)' },
-    '8pi': { meaning: '8π', unit: '1', source: 'mathematical constant (8·Math.PI)' },
-    '4pi': { meaning: '4π', unit: '1', source: 'mathematical constant (4·Math.PI)' },
-    '2pi': { meaning: '2π', unit: '1', source: 'mathematical constant (2·Math.PI)' },
-    e: { meaning: 'elementary charge', unit: 'C', source: 'exact SI, 2019 redefinition (core/constants.ts E_SI)' },
-    epsilon_0: { meaning: 'vacuum permittivity', unit: 'F/m', source: 'CODATA 2018 (this table)' },
-    sigma_sb: { meaning: 'Stefan–Boltzmann constant', unit: 'W/(m^2*K^4)', source: 'CODATA 2018 (this table)' },
-    b: { meaning: 'Wien displacement constant', unit: 'm*K', source: 'CODATA 2018 (core/constants.ts B_WIEN_SI)' },
-    GM_sun: {
-        meaning: 'IAU nominal solar gravitational parameter (GM)☉',
-        unit: 'm^3/s^2',
-        source: 'IAU 2015 Resolution B3 (core/constants.ts GM_SUN_SI)',
-    },
-    Msun_iau: {
-        meaning: 'IAU solar mass (GM)☉/G, the mass that reproduces GM_sun with G_SI',
-        unit: 'kg',
-        source: 'GM_SUN_SI/G_SI (core/constants.ts)',
-    },
-    m_u: {
-        meaning: 'unified atomic mass unit (atomic mass constant)',
-        unit: 'kg',
-        source: 'CODATA 2018 (core/constants.ts M_U_SI)',
-    },
-};
 //# sourceMappingURL=symbolic-constants.js.map

package/dist/dimensional/symbolic-constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"symbolic-constants.js","sourceRoot":"","sources":["../../src/dimensional/symbolic-constants.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"symbolic-constants.js","sourceRoot":"","sources":["../../src/dimensional/symbolic-constants.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The constant registry: one row per physical constant a formula may name.\n *\n * A row (written in `constant-rows.ts`) holds the formula name, its other\n * exact-case spellings, the SI value (imported from `core/constants.js`, the\n * one owner of every value), the SI unit in `parseUnit` syntax, the meaning\n * and the source. The dimension is derived from the unit once, here; no second\n * table states it. The rows sit in their own module because the unit table\n * names constants by these spellings, and this module imports the unit parser. Every other\n * constant table in the library ({@link CONSTANTS}, `FORMULA_NAMED`,\n * `CONSTANT_SPELLINGS`, {@link CONSTANT_PROVENANCE}, `CANONICAL_CONSTANTS`,\n * the `upt eval` scope, the binding scope, the gradient constants) is a\n * projection of this array, so a spelling, a value and a dimension cannot\n * disagree between two files. A constant that is also a quantity names its\n * `data/quantities.json` row in `quantity`; the quantity registry derives that\n * row's aliases from here, so the file states no constant spelling.\n *\n * `canonical` marks a universal constant a canonical equation's `governing`\n * list may bake as a leaf. A row that is an overlay for `upt eval` and the\n * dimensional assignment only (`m_p`, `N_A`, the GRW parameters) is not\n * canonical, so the canonical graph does not bake it.\n *\n * Numeric-literal leaves (`'2'`, `'3'`) are NOT registered — `evalExpr`\n * resolves them via `Number(name)` and they are implicitly dimensionless.\n * Non-base-10 tokens (`'8pi'`, `'4pi'`, `'ln2'`) MUST be here (`Number('8pi')`\n * is `NaN`).\n *\n * INTERNAL — not on the public surface.\n *\n * @module dimensional/symbolic-constants\n */\n\nimport type { Dimension } from './types.js';\nimport { parseUnit } from './units.js';\nimport { CONSTANT_ROWS, constantRow, type ConstantRow } from './constant-rows.js';\n\n/** One registered constant: its row, with the dimension derived from its unit. @internal */\nexport interface ConstantRecord extends ConstantRow {\n  readonly dim: Dimension;\n}\n\n/**\n * Every registered constant, the rows of `constant-rows.ts` with each\n * dimension derived once from its unit. Order is the order the tables print.\n * @internal\n */\nexport const CONSTANT_REGISTRY: readonly ConstantRecord[] = CONSTANT_ROWS.map((constant) => ({\n  ...constant,\n  dim: parseUnit(constant.unit).dim,\n}));\n\nconst RECORD_OF_ROW = new Map<ConstantRow, ConstantRecord>(CONSTANT_ROWS.map((constant, i) => [constant, CONSTANT_REGISTRY[i]!]));\n\n/**\n * Every spelling → its record; `constant-rows.ts` refuses a spelling written twice. A constant\n * that is also a quantity (`quantity`, e.g. `k_B` → `boltzmann-constant`) is reachable by that\n * quantity id too, so a user who writes the quantity's name states the constant, and the value\n * is checked against the registry rather than bound.\n */\nconst BY_SPELLING = new Map<string, ConstantRecord>(\n  CONSTANT_REGISTRY.flatMap((record) =>\n    [record.name, ...record.spellings, ...(record.quantity === undefined ? [] : [record.quantity])].map(\n      (spelling) => [spelling, record] as const,\n    ),\n  ),\n);\n\n/** The registered constant `spelling` names, or undefined. @internal */\nexport function constantRecord(spelling: string): ConstantRecord | undefined {\n  const constant = constantRow(spelling);\n  return constant === undefined ? undefined : RECORD_OF_ROW.get(constant);\n}\n\n/**\n * Relative tolerance within which a stated constant agrees with the registered\n * value. Textbook roundings such as `b = 2.9e-3` pass.\n * @internal\n */\nconst CONSTANT_AGREEMENT = 5e-3;\n\n/** A stated value for a registered constant disagrees with the registry. The equations use the registered value. @internal */\nexport class ConstantDisagreementError extends Error {\n  constructor(\n    readonly key: string,\n    readonly constant: string,\n    readonly registered: number,\n    readonly given: number,\n  ) {\n    super(\n      `'${key}' is the registered constant ${constant} = ${registered}; ` +\n        `${given} disagrees, and the equations use the registered value, so it cannot be rebound.`,\n    );\n    this.name = 'ConstantDisagreementError';\n  }\n}\n\n/**\n * The registered constant `key` names when `value` agrees with it within\n * {@link CONSTANT_AGREEMENT}, or null when `key` names no constant. A value\n * that disagrees throws {@link ConstantDisagreementError}: a constant is not\n * a graph quantity, so a stated value is checked, never bound.\n * @internal\n */\nexport function constantAgreement(key: string, value: number): string | null {\n  const record = BY_SPELLING.get(key);\n  if (record === undefined) return null;\n  if (Math.abs(value - record.value) > CONSTANT_AGREEMENT * Math.abs(record.value)) {\n    throw new ConstantDisagreementError(key, record.name, record.value, value);\n  }\n  return record.name;\n}\n\n/** The notes of the registered constants among `names`, each once, in registry order. @internal */\nexport function constantNotes(names: Iterable<string>): string[] {\n  const seen = new Set<ConstantRecord>();\n  for (const name of names) {\n    const record = BY_SPELLING.get(name);\n    if (record?.note !== undefined) seen.add(record);\n  }\n  return CONSTANT_REGISTRY.filter((record) => seen.has(record)).map((record) => record.note!);\n}\n\n/** Every spelling → SI value, for a numeric scope. `pi` and `tau` are added. @internal */\nexport function constantScope(): Record<string, number> {\n  const scope: Record<string, number> = { pi: Math.PI, tau: 2 * Math.PI };\n  for (const [spelling, record] of BY_SPELLING) scope[spelling] = record.value;\n  return scope;\n}\n\n/** A registered constant leaf: SI value + SI dimension. @internal */\nexport interface NamedConstantValue {\n  readonly value: number;\n  readonly dim: Dimension;\n}\n\n/**\n * Constant leaves a `symbolic` ExprNode may reference, keyed by formula name:\n * the canonical rows of {@link CONSTANT_REGISTRY}. `ln2`/`8pi`/`4pi`\n * reproduce the evaluators' `Math.LN2` / `8*Math.PI` / `4*Math.PI` exactly\n * (same IEEE-754 primitives).\n */\nexport const CONSTANTS: Readonly<Record<string, NamedConstantValue>> = Object.fromEntries(\n  CONSTANT_REGISTRY.filter((record) => record.canonical).map((record) => [\n    record.name,\n    { value: record.value, dim: record.dim },\n  ]),\n);\n\n/** What a registered constant is, its SI unit, and where its value comes from (audit I10). @internal */\nexport interface ConstantProvenance {\n  readonly meaning: string;\n  /** The SI unit, in the syntax `parseUnit` reads; the registered dimension is derived from it. */\n  readonly unit: string;\n  readonly source: string;\n}\n\n/** One row per {@link CONSTANT_REGISTRY} name. @internal */\nexport const CONSTANT_PROVENANCE: Readonly<Record<string, ConstantProvenance>> = Object.fromEntries(\n  CONSTANT_REGISTRY.map((record) => [\n    record.name,\n    { meaning: record.meaning, unit: record.unit, source: record.source },\n  ]),\n);\n\n/**\n * A spelled-out multiple of π written as one symbol (`pi`, `6pi`). `2pi`,\n * `4pi` and `8pi` are also registered in {@link CONSTANTS}; this covers the\n * multiples an encoder spelled out and did not register (`6pi` in\n * CE-perihelion-precession). The structural normal form already drops these.\n * The numeric evaluator has to resolve them too, or a comparison treats `6pi`\n * as a free symbol and never aligns the formula.\n * @internal\n */\nexport function piMultipleValue(name: string): number | undefined {\n  const m = /^(\\d*)pi$/.exec(name);\n  if (m === null) return undefined;\n  const n = m[1] === '' ? 1 : Number(m[1]);\n  if (!Number.isInteger(n) || n < 0) return undefined;\n  return n * Math.PI;\n}\n"]}