universal-physics-tensor 7.0.0 → 9.0.0

package/dist/dimensional/constant-rows.js

@@ -0,0 +1,111 @@
+/**
+ * The constant registry's rows as written: name, spellings, SI value, SI unit
+ * text, meaning, source and flags, one row per physical constant a formula or
+ * the unit table may name.
+ *
+ * `symbolic-constants.ts` derives each row's dimension from its unit with
+ * `parseUnit` and owns every projection. The rows live here, apart from that
+ * derivation, because the unit table reads constants too: `data/units.json`
+ * names `c`, `e`, `m_u`, `M_sun`, `Msun_iau` and `ln2` by these spellings, and
+ * the unit parser cannot import a module that imports the unit parser. This
+ * module imports only `core/constants.ts`, the owner of every value, so the
+ * unit loader and the registry read one set of spellings with no cycle.
+ *
+ * INTERNAL — not on the public surface.
+ *
+ * @module dimensional/constant-rows
+ */
+import { B_WIEN_SI, C_SI, E_SI, EPS0_SI, FARADAY_SI, G_SI, GM_SUN_SI, H_SI, HBAR_CODATA_DISPLAY, HBAR_SI, K_B_SI, LANE_EMDEN_OMEGA3, M_E_SI, M_PROTON_SI, M_SUN_IAU_SI, M_SUN_SI, M_U_SI, MU0_SI, N_A_SI, SIGMA_SB_SI, THOMSON_CROSS_SECTION_SI, } from '../core/constants.js';
+const row = (input) => ({
+    ...input,
+    spellings: input.spellings ?? [],
+    canonical: input.canonical ?? false,
+});
+const OWNER = 'core/constants.ts';
+/** Every registered constant as written. Order is the order the tables print. @internal */
+export const CONSTANT_ROWS = [
+    // ── universal constants a canonical equation may bake ──────────────────
+    row({ name: 'hbar', spellings: ['ℏ'], value: HBAR_SI, unit: 'J*s', canonical: true, mathts: 'reducedPlanckConstant', exact: true,
+        meaning: 'reduced Planck constant h/(2π)', source: `exact H_SI/(2π) (${OWNER} HBAR_SI)`,
+        note: `hbar is HBAR_SI = H_SI/(2π), the exact reduced Planck constant. The CODATA display ${HBAR_CODATA_DISPLAY} ` +
+            `is that quotient truncated (relative difference ${(Math.abs(HBAR_CODATA_DISPLAY - HBAR_SI) / HBAR_SI).toExponential(3)}).` }),
+    row({ name: 'h', quantity: 'planck-constant', value: H_SI, unit: 'J*s', canonical: true, mathts: 'planckConstant', exact: true,
+        meaning: 'Planck constant', source: `exact SI, 2019 redefinition (${OWNER} H_SI)` }),
+    row({ name: 'c', value: C_SI, unit: 'm/s', canonical: true, mathts: 'speedOfLight', exact: true,
+        meaning: 'speed of light in vacuum', source: `exact SI (${OWNER} C_SI)` }),
+    row({ name: 'G', value: G_SI, unit: 'm^3/(kg*s^2)', canonical: true, mathts: 'gravitationConstant',
+        meaning: 'Newtonian gravitational constant', source: `CODATA 2018 (${OWNER} G_SI)` }),
+    row({ name: 'k_B', spellings: ['kB', 'boltzmann'], quantity: 'boltzmann-constant', value: K_B_SI, unit: 'J/K', canonical: true, mathts: 'boltzmann', exact: true,
+        meaning: 'Boltzmann constant', source: `exact SI, 2019 redefinition (${OWNER} K_B_SI)` }),
+    row({ name: 'ln2', value: Math.LN2, unit: '1', canonical: true, irrational: true,
+        meaning: 'natural logarithm of 2', source: 'mathematical constant (Math.LN2)' }),
+    row({ name: '8pi', value: 8 * Math.PI, unit: '1', canonical: true, irrational: true,
+        meaning: '8π', source: 'mathematical constant (8·Math.PI)' }),
+    row({ name: '4pi', value: 4 * Math.PI, unit: '1', canonical: true, irrational: true,
+        meaning: '4π', source: 'mathematical constant (4·Math.PI)' }),
+    row({ name: '2pi', value: 2 * Math.PI, unit: '1', canonical: true, irrational: true,
+        meaning: '2π', source: 'mathematical constant (2·Math.PI)' }),
+    // 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.
+    row({ name: 'e', spellings: ['e_charge'], value: E_SI, unit: 'C', canonical: true, mathts: 'elementaryCharge', exact: true,
+        meaning: 'elementary charge', source: `exact SI, 2019 redefinition (${OWNER} E_SI)` }),
+    row({ name: 'epsilon_0', spellings: ['epsilon0', 'eps0'], value: EPS0_SI, unit: 'F/m', canonical: true,
+        meaning: 'vacuum permittivity', source: `CODATA 2018 (${OWNER} EPS0_SI)` }),
+    row({ name: 'sigma_sb', spellings: ['stefan-boltzmann-constant'], value: SIGMA_SB_SI, unit: 'W/(m^2*K^4)', canonical: true, mathts: 'stefanBoltzmann',
+        meaning: 'Stefan–Boltzmann constant', source: `CODATA 2018 (${OWNER} SIGMA_SB_SI)` }),
+    row({ name: 'b', spellings: ['wien-constant'], value: B_WIEN_SI, unit: 'm*K', canonical: true, mathts: 'wienDisplacement',
+        meaning: 'Wien displacement constant', source: `CODATA 2018 (${OWNER} B_WIEN_SI)` }),
+    // IAU 2015 nominal solar parameter. M_sun in eval stays the rounded kilogram M_SUN_SI.
+    row({ name: 'GM_sun', value: GM_SUN_SI, unit: 'm^3/s^2', canonical: true,
+        meaning: 'IAU nominal solar gravitational parameter (GM)☉', source: `IAU 2015 Resolution B3 (${OWNER} GM_SUN_SI)` }),
+    row({ name: 'Msun_iau', value: M_SUN_IAU_SI, unit: 'kg', canonical: true,
+        meaning: 'IAU solar mass (GM)☉/G, the mass that reproduces GM_sun with G_SI', source: `GM_SUN_SI/G_SI (${OWNER} M_SUN_IAU_SI)` }),
+    row({ name: 'm_u', value: M_U_SI, unit: 'kg', canonical: true, mathts: 'atomicMass',
+        meaning: 'unified atomic mass unit (atomic mass constant)', source: `CODATA 2018 (${OWNER} M_U_SI)` }),
+    row({ name: 'm_e', spellings: ['electron_mass'], value: M_E_SI, unit: 'kg', canonical: true, mathts: 'electronMass',
+        meaning: 'electron mass', source: `CODATA 2018 (${OWNER} M_E_SI)` }),
+    // ── overlay names for `upt eval` and the dimensional assignment only ────
+    row({ name: 'mu_0', spellings: ['mu0'], value: MU0_SI, unit: 'H/m', mathts: 'magneticConstant',
+        meaning: 'vacuum permeability 1/(ε₀ c²)', source: `1/(EPS0_SI·C_SI²) (${OWNER} MU0_SI)` }),
+    row({ name: 'm_p', spellings: ['m_proton'], value: M_PROTON_SI, unit: 'kg', mathts: 'protonMass',
+        meaning: 'proton mass', source: `CODATA 2018 (${OWNER} M_PROTON_SI)` }),
+    row({ name: 'N_A', value: N_A_SI, unit: 'mol^-1', mathts: 'avogadro', exact: true,
+        meaning: 'Avogadro constant', source: `exact SI, 2019 redefinition (${OWNER} N_A_SI)` }),
+    row({ name: 'F', value: FARADAY_SI, unit: 'C/mol', mathts: 'faraday', exact: true,
+        meaning: 'Faraday constant N_A e', source: `N_A_SI·E_SI (${OWNER} FARADAY_SI)` }),
+    // R = N_A k_B, the molar gas constant the thermochemical records state in their titles.
+    row({ name: 'R', value: N_A_SI * K_B_SI, unit: 'J/(mol*K)', mathts: 'gasConstant', exact: true,
+        meaning: 'molar gas constant N_A k_B', source: `N_A_SI·K_B_SI (${OWNER})` }),
+    row({ name: 'M_sun', value: M_SUN_SI, unit: 'kg',
+        meaning: 'solar mass, the repo-conventional kilogram value', source: `${OWNER} M_SUN_SI` }),
+    // `curvature_k` and `scale_factor` are the Friedmann curvature extension
+    // (the frozen `CE-friedmann` entry is the flat term).
+    row({ name: 'curvature_k', value: 0, unit: '1',
+        meaning: 'Friedmann curvature index, flat by default', source: 'this registry (flat default 0)' }),
+    row({ name: 'scale_factor', value: 1, unit: 'm',
+        meaning: 'Friedmann scale factor, unit by default', source: 'this registry (default 1)' }),
+    row({ name: 'sigma_T', value: THOMSON_CROSS_SECTION_SI, unit: 'm^2', mathts: 'thomsonCrossSection',
+        meaning: 'Thomson cross section', source: `CODATA 2018 (${OWNER} THOMSON_CROSS_SECTION_SI)` }),
+    row({ name: 'lane_emden_omega_3', quantity: 'lane-emden-omega-3', value: LANE_EMDEN_OMEGA3, unit: '1',
+        meaning: 'Lane–Emden n = 3 dimensionless radius', source: `${OWNER} LANE_EMDEN_OMEGA3` }),
+    // GRW mass amplification: λ = λ₀ · (m / m₀), with λ₀ a rate and m₀ a mass.
+    // The two numbers are the catalog expression's, so the rate is unchanged.
+    row({ name: 'grw_lambda0', value: 1e-16, unit: 'Hz',
+        meaning: 'GRW localization rate λ₀', source: 'catalog expression (Ghirardi–Rimini–Weber 1986)' }),
+    row({ name: 'grw_m0', value: 1.67e-27, unit: 'kg',
+        meaning: 'GRW reference mass m₀ (a nucleon)', source: 'catalog expression (Ghirardi–Rimini–Weber 1986)' }),
+];
+const BY_SPELLING = new Map();
+for (const constant of CONSTANT_ROWS) {
+    for (const spelling of [constant.name, ...constant.spellings]) {
+        if (BY_SPELLING.has(spelling))
+            throw new Error(`constant registry: '${spelling}' is spelled twice`);
+        BY_SPELLING.set(spelling, constant);
+    }
+}
+/** The registered constant row `spelling` names, or undefined. @internal */
+export function constantRow(spelling) {
+    return BY_SPELLING.get(spelling);
+}
+//# sourceMappingURL=constant-rows.js.map

package/dist/dimensional/constant-rows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constant-rows.js","sourceRoot":"","sources":["../../src/dimensional/constant-rows.ts"],"names":[],"mappings":"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"}

package/dist/dimensional/constants.d.ts

@@ -1,20 +1,11 @@
 /**
- * SI dimensional signatures of fundamental physical constants.
- *
- * These are *dimensions only* — numerical values for the constants themselves
- * live in `src/core/types.ts` (`PhysicalConstants`). The split is intentional:
- *   - `core/types.ts` owns numeric values (CODATA 2018) for runtime computation.
- *   - this module owns the SI dimensional signatures for the validator.
- *
- * Sources for the dimensional signatures:
- *   - CODATA 2018 / NIST CODATA values: https://physics.nist.gov/cuu/Constants/
- *   - BIPM SI Brochure 9th ed. (2019)
- *   - Planck-unit derivations: Planck (1899); see Wald, "General Relativity"
- *     (1984), §G for the canonical Planck-length / Planck-time relations.
+ * SI dimensional signatures of fundamental physical constants, projected
+ * from the constant registry (`symbolic-constants.ts`), which derives each
+ * dimension from the constant's SI unit. Values live in `core/constants.ts`.
  *
  * @module dimensional/constants
  */
-import { Dimension } from './types.js';
+import { type Dimension } from './types.js';
 /** Reduced Planck constant ℏ — action [M L^2 T^-1]. */
 export declare const hbar: Dimension;
 /** Speed of light c — velocity [L T^-1]. */

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/dimensional/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,SAAS,EAKV,MAAM,YAAY,CAAC;AAEpB,uDAAuD;AACvD,eAAO,MAAM,IAAI,EAAE,SAAkB,CAAC;AAEtC,4CAA4C;AAC5C,eAAO,MAAM,CAAC,EAAE,SAAoB,CAAC;AAErC,2DAA2D;AAC3D,eAAO,MAAM,CAAC,EAAE,SAA8D,CAAC;AAE/E,uEAAuE;AACvE,eAAO,MAAM,GAAG,EAAE,SAA8D,CAAC;AAEjF,8CAA8C;AAC9C,eAAO,MAAM,CAAC,EAAE,SAAkB,CAAC;AAInC,+BAA+B;AAC/B,eAAO,MAAM,GAAG,EAAE,SAAkB,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/dimensional/constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAKpD,uDAAuD;AACvD,eAAO,MAAM,IAAI,EAAE,SAAsB,CAAC;AAE1C,4CAA4C;AAC5C,eAAO,MAAM,CAAC,EAAE,SAAmB,CAAC;AAEpC,2DAA2D;AAC3D,eAAO,MAAM,CAAC,EAAE,SAAmB,CAAC;AAEpC,uEAAuE;AACvE,eAAO,MAAM,GAAG,EAAE,SAAqB,CAAC;AAExC,8CAA8C;AAC9C,eAAO,MAAM,CAAC,EAAE,SAAmB,CAAC;AAEpC,+BAA+B;AAC/B,eAAO,MAAM,GAAG,EAAE,SAAkB,CAAC"}

package/dist/dimensional/constants.js

@@ -1,31 +1,23 @@
 /**
- * SI dimensional signatures of fundamental physical constants.
- *
- * These are *dimensions only* — numerical values for the constants themselves
- * live in `src/core/types.ts` (`PhysicalConstants`). The split is intentional:
- *   - `core/types.ts` owns numeric values (CODATA 2018) for runtime computation.
- *   - this module owns the SI dimensional signatures for the validator.
- *
- * Sources for the dimensional signatures:
- *   - CODATA 2018 / NIST CODATA values: https://physics.nist.gov/cuu/Constants/
- *   - BIPM SI Brochure 9th ed. (2019)
- *   - Planck-unit derivations: Planck (1899); see Wald, "General Relativity"
- *     (1984), §G for the canonical Planck-length / Planck-time relations.
+ * SI dimensional signatures of fundamental physical constants, projected
+ * from the constant registry (`symbolic-constants.ts`), which derives each
+ * dimension from the constant's SI unit. Values live in `core/constants.ts`.
  *
  * @module dimensional/constants
  */
-import { LENGTH, VELOCITY, ACTION, CHARGE, } from './types.js';
+import { LENGTH } from './types.js';
+import { constantRecord } from './symbolic-constants.js';
+const of = (name) => constantRecord(name).dim;
 /** Reduced Planck constant ℏ — action [M L^2 T^-1]. */
-export const hbar = ACTION;
+export const hbar = of('hbar');
 /** Speed of light c — velocity [L T^-1]. */
-export const c = VELOCITY;
+export const c = of('c');
 /** Newton's gravitational constant G — [L^3 M^-1 T^-2]. */
-export const G = { L: 3, M: -1, T: -2, I: 0, Theta: 0, N: 0, J: 0 };
+export const G = of('G');
 /** Boltzmann constant k_B — energy / temperature [M L^2 T^-2 Θ^-1]. */
-export const k_B = { L: 2, M: 1, T: -2, I: 0, Theta: -1, N: 0, J: 0 };
+export const k_B = of('k_B');
 /** Elementary charge e — [T I] (coulombs). */
-export const e = CHARGE;
-// --- Planck-unit shorthand (SI dimensions; numerical values not stored here). ---
+export const e = of('e');
 /** Planck length ℓ_P — [L]. */
 export const l_P = LENGTH;
 //# sourceMappingURL=constants.js.map

package/dist/dimensional/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/dimensional/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAEL,MAAM,EACN,QAAQ,EACR,MAAM,EACN,MAAM,GACP,MAAM,YAAY,CAAC;AAEpB,uDAAuD;AACvD,MAAM,CAAC,MAAM,IAAI,GAAc,MAAM,CAAC;AAEtC,4CAA4C;AAC5C,MAAM,CAAC,MAAM,CAAC,GAAc,QAAQ,CAAC;AAErC,2DAA2D;AAC3D,MAAM,CAAC,MAAM,CAAC,GAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAE/E,uEAAuE;AACvE,MAAM,CAAC,MAAM,GAAG,GAAc,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AAEjF,8CAA8C;AAC9C,MAAM,CAAC,MAAM,CAAC,GAAc,MAAM,CAAC;AAEnC,mFAAmF;AAEnF,+BAA+B;AAC/B,MAAM,CAAC,MAAM,GAAG,GAAc,MAAM,CAAC"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/dimensional/constants.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,MAAM,EAAkB,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,MAAM,EAAE,GAAG,CAAC,IAAY,EAAa,EAAE,CAAC,cAAc,CAAC,IAAI,CAAE,CAAC,GAAG,CAAC;AAElE,uDAAuD;AACvD,MAAM,CAAC,MAAM,IAAI,GAAc,EAAE,CAAC,MAAM,CAAC,CAAC;AAE1C,4CAA4C;AAC5C,MAAM,CAAC,MAAM,CAAC,GAAc,EAAE,CAAC,GAAG,CAAC,CAAC;AAEpC,2DAA2D;AAC3D,MAAM,CAAC,MAAM,CAAC,GAAc,EAAE,CAAC,GAAG,CAAC,CAAC;AAEpC,uEAAuE;AACvE,MAAM,CAAC,MAAM,GAAG,GAAc,EAAE,CAAC,KAAK,CAAC,CAAC;AAExC,8CAA8C;AAC9C,MAAM,CAAC,MAAM,CAAC,GAAc,EAAE,CAAC,GAAG,CAAC,CAAC;AAEpC,+BAA+B;AAC/B,MAAM,CAAC,MAAM,GAAG,GAAc,MAAM,CAAC"}

package/dist/dimensional/dimension-spec.d.ts

@@ -18,6 +18,15 @@
  *      separated by `.`, `*`, or spaces; `^` optional; fractional exponents
  *      like `T^1/2` allowed).
  *
+ * Forms 3 and 4 are one grammar, the formula grammar MathTS parses
+ * ({@link parseFormulaPNode}). The dimension notation differs from a formula
+ * only in spelling, and {@link formulaSyntax} rewrites those spellings
+ * before the parse: a `.` between factors is `*`, a space between factors is
+ * `*`, a glued exponent (`L2`, `T-2`) takes its `^`, a fractional exponent
+ * (`T^1/2`) is parenthesized, and a hyphen inside a name (`magnetic-field`)
+ * is `_`. There is no subtraction in a dimension, so `-` after a name is
+ * always an exponent's sign.
+ *
  * @module dimensional/dimension-spec
  */
 import type { Dimension } from './types.js';
@@ -26,9 +35,9 @@ export declare class DimensionSpecError extends Error {
     constructor(message: string);
 }
 /**
- * One constant's exact-case spellings. The first name is the formula name
- * the equation path rewrites the others to. `upt eval` binds the same
- * names. A dimension term reads this record; it does not keep a second list.
+ * One constant's exact-case spellings, projected from the constant registry.
+ * The first name is the formula name the equation path rewrites the others
+ * to. `upt eval` binds the same names. A dimension term reads this record.
  *
  * @internal
  */

package/dist/dimensional/dimension-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dimension-spec.d.ts","sourceRoot":"","sources":["../../src/dimensional/dimension-spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAoB5C,4BAA4B;AAC5B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAoCD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;CAAE,EAQvG,CAAC;AAuIF,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CA6B1D"}
+{"version":3,"file":"dimension-spec.d.ts","sourceRoot":"","sources":["../../src/dimensional/dimension-spec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAuB5C,4BAA4B;AAC5B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AA+BD;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;CAAE,EACf,CAAC;AAoH1F,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAkB1D"}

package/dist/dimensional/dimension-spec.js

@@ -18,10 +18,22 @@
  *      separated by `.`, `*`, or spaces; `^` optional; fractional exponents
  *      like `T^1/2` allowed).
  *
+ * Forms 3 and 4 are one grammar, the formula grammar MathTS parses
+ * ({@link parseFormulaPNode}). The dimension notation differs from a formula
+ * only in spelling, and {@link formulaSyntax} rewrites those spellings
+ * before the parse: a `.` between factors is `*`, a space between factors is
+ * `*`, a glued exponent (`L2`, `T-2`) takes its `^`, a fractional exponent
+ * (`T^1/2`) is parenthesized, and a hyphen inside a name (`magnetic-field`)
+ * is `_`. There is no subtraction in a dimension, so `-` after a name is
+ * always an exponent's sign.
+ *
  * @module dimensional/dimension-spec
  */
 import { DIMENSIONLESS, LENGTH, AREA, TIME, FREQUENCY, MASS, VELOCITY, ACCELERATION, FORCE, ENERGY, POWER, ACTION, TEMPERATURE, ENTROPY, CHARGE, } from './types.js';
 import { divide, multiply, power } from './algebra.js';
+import { dim } from './ast-builders.js';
+import { CONSTANT_REGISTRY } from './symbolic-constants.js';
+import { parseFormulaPNode } from '../numerical/formula-dimension.js';
 /** A bad dimension spec. */
 export class DimensionSpecError extends Error {
     constructor(message) {
@@ -29,7 +41,8 @@ export class DimensionSpecError extends Error {
         this.name = 'DimensionSpecError';
     }
 }
-const d = (L = 0, M = 0, T = 0, Theta = 0, I = 0) => ({ L, M, T, I, Theta, N: 0, J: 0 });
+/** `dim(L, M, T, I, Θ)`, the one builder, from `ast-builders`. */
+const d = dim;
 /** Named dimensions — matched case-insensitively. */
 const NAMED_DIMS = {
     dimensionless: DIMENSIONLESS,
@@ -51,26 +64,18 @@ const NAMED_DIMS = {
     density: d(-3, 1),
     volume: d(3),
     viscosity: d(-1, 1, -1),
-    resistance: d(2, 1, -3, 0, -2),
-    magnetic_field: d(0, 1, -2, 0, -1),
-    permeability: d(1, 1, -2, 0, -2),
+    resistance: d(2, 1, -3, -2, 0),
+    magnetic_field: d(0, 1, -2, -1, 0),
+    permeability: d(1, 1, -2, -2, 0),
 };
 /**
- * One constant's exact-case spellings. The first name is the formula name
- * the equation path rewrites the others to. `upt eval` binds the same
- * names. A dimension term reads this record; it does not keep a second list.
+ * One constant's exact-case spellings, projected from the constant registry.
+ * The first name is the formula name the equation path rewrites the others
+ * to. `upt eval` binds the same names. A dimension term reads this record.
  *
  * @internal
  */
-export const CONSTANT_SPELLINGS = [
-    { names: ['hbar', 'ℏ'], dim: ACTION },
-    { names: ['c'], dim: VELOCITY },
-    { names: ['G'], dim: d(3, -1, -2) },
-    { names: ['k_B', 'kB'], dim: ENTROPY },
-    { names: ['e'], dim: CHARGE },
-    { names: ['mu_0', 'mu0'], dim: d(1, 1, -2, 0, -2) },
-    { names: ['epsilon_0', 'epsilon0', 'eps0'], dim: d(-3, -1, 4, 0, 2) },
-];
+export const CONSTANT_SPELLINGS = CONSTANT_REGISTRY.map((row) => ({ names: [row.name, ...row.spellings], dim: row.dim }));
 /** Fundamental constants by their SI dimension — matched EXACT-case, so
  *  `G` (Newton's constant) is never confused with `g` (acceleration). */
 const CONST_DIMS = Object.fromEntries(CONSTANT_SPELLINGS.flatMap(({ names, dim }) => names.map((name) => [name, dim])));
@@ -84,30 +89,14 @@ const BASES = {
     N: 'N',
     J: 'J',
 };
-function parseExponent(raw) {
-    if (raw === '')
-        return 1;
-    if (raw.includes('/')) {
-        const [n, den] = raw.split('/');
-        const num = Number(n);
-        const dd = Number(den);
-        if (!Number.isFinite(num) || !Number.isFinite(dd) || dd === 0) {
-            throw new DimensionSpecError(`bad exponent '${raw}'`);
-        }
-        return num / dd;
-    }
-    const v = Number(raw);
-    if (!Number.isFinite(v))
-        throw new DimensionSpecError(`bad exponent '${raw}'`);
-    return v;
-}
-/** Resolve one atom: constant (exact case) or named dimension (case-insensitive). */
+/** Resolve one atom: constant (exact case, `_` or `-`) or named dimension (case-insensitive). */
 function resolveAtom(raw) {
     const s = raw.trim();
     if (!s)
         return null;
-    if (CONST_DIMS[s])
-        return CONST_DIMS[s];
+    const constant = CONST_DIMS[s] ?? CONST_DIMS[s.replaceAll('_', '-')];
+    if (constant)
+        return constant;
     const key = s.toLowerCase().replace(/[\s-]+/g, '_');
     return NAMED_DIMS[key] ?? NAMED_DIMS[s.toLowerCase()] ?? null;
 }
@@ -115,133 +104,108 @@ function baseAtom(id) {
     const baseKey = BASES[id.toUpperCase()] ?? BASES[id];
     if (!baseKey)
         return null;
-    const dim = d();
-    dim[baseKey] = 1;
-    return dim;
+    const out = d();
+    out[baseKey] = 1;
+    return out;
 }
 /**
- * Parse a product/quotient of named dims and constants: `power/area`,
- * `length*temperature`, `L*Theta` is NOT this path (bases go to step 4).
- * Only `*` and `/` as top-level operators; no parentheses, no `^` on names.
- * Returns `null` when the string is not this form (so the base-exponent path
- * can try).
- */
-/**
- * A product/quotient with parentheses and exponents: `power/(area*temperature^4)`,
- * `mass/length^3`, `M/L^3`. A slash followed by a digit is a fractional
- * exponent on the explicit-base path (`T^1/2`), not this one.
+ * The dimension notation in formula syntax. Each rewrite is a spelling the
+ * notation allows and a formula does not; none adds an operator a reader
+ * did not write.
  */
-function parseGroupedProduct(s) {
-    let i = 0;
-    const skip = () => {
-        while (s[i] === ' ')
-            i++;
-    };
-    const parseExponentToken = () => {
-        skip();
-        const start = i;
-        if (s[i] === '+' || s[i] === '-')
-            i++;
-        if (!/\d/.test(s[i] ?? ''))
-            throw new DimensionSpecError(`bad exponent in '${s}'`);
-        while (/\d/.test(s[i] ?? ''))
-            i++;
-        if (s[i] === '/' && /\d/.test(s[i + 1] ?? '')) {
-            i++;
-            while (/\d/.test(s[i] ?? ''))
-                i++;
+function formulaSyntax(spec) {
+    return (spec
+        // A hyphen inside a name: `magnetic-field` is `magnetic_field`.
+        .replace(/(?<=[A-Za-zΘ])-(?=[A-Za-zΘ])/g, '_')
+        // Spaces around an operator carry nothing; between two factors they multiply.
+        .replace(/\s*([*/^().])\s*/g, '$1')
+        .replace(/\s+/g, '*')
+        // A glued exponent: `L2`, `T-2`, `T-2.5` (a name's own digits follow `_`, as in `mu_0`).
+        .replace(/(?<=[A-Za-zΘ])([+-]?\d)/g, '^$1')
+        // A fractional exponent: `T^1/2` is `T^(1/2)`.
+        .replace(/\^([+-]?\d+(?:\.\d+)?)\/(\d+(?:\.\d+)?)/g, '^($1/$2)')
+        // A dot between factors is a product; a dot before a digit is a decimal point.
+        .replace(/\.(?!\d)/g, '*'));
+}
+/** A numeric exponent: a number, a signed number, or a quotient or product of numbers. */
+function exponentOf(node, spec) {
+    switch (node.kind) {
+        case 'num':
+            return node.value;
+        case 'neg':
+            return -exponentOf(node.arg, spec);
+        case 'op': {
+            const values = node.args.map((arg) => exponentOf(arg, spec));
+            if (node.op === '/')
+                return values.reduce((a, b) => a / b);
+            if (node.op === '*')
+                return values.reduce((a, b) => a * b, 1);
+            if (node.op === '+')
+                return values.reduce((a, b) => a + b, 0);
+            return values.length === 1 ? -values[0] : values.reduce((a, b) => a - b);
         }
-        return parseExponent(s.slice(start, i));
-    };
-    const parseAtom = () => {
-        skip();
-        if (s[i] === '(') {
-            i++;
-            const inner = parseProduct();
-            skip();
-            if (s[i] !== ')')
-                throw new DimensionSpecError(`unbalanced '(' in '${s}'`);
-            i++;
-            return inner;
+        default:
+            throw new DimensionSpecError(`bad exponent in '${spec}'`);
+    }
+}
+function unknownTerm(id) {
+    return new DimensionSpecError(`unknown base dimension '${id}' (use L M T I Theta N J, a named dimension, a constant name, ` +
+        'or a named product/quotient like power/area)');
+}
+/** The dimension a parsed spec states. */
+function dimensionOf(node, spec) {
+    switch (node.kind) {
+        case 'sym': {
+            const found = resolveAtom(node.name) ?? baseAtom(node.name);
+            if (found === null)
+                throw unknownTerm(node.name);
+            return { ...found };
         }
-        const start = i;
-        while (i < s.length && /[A-Za-zΘ_]/.test(s[i]))
-            i++;
-        const id = s.slice(start, i);
-        if (!id)
-            throw new DimensionSpecError(`unrecognized dimension term '${s.slice(start)}'`);
-        const named = resolveAtom(id);
-        if (named)
-            return named;
-        const base = baseAtom(id);
-        if (base)
-            return base;
-        throw new DimensionSpecError(`unrecognized dimension term '${id}' (use a named dimension, a constant, ` +
-            `or bases L M T I Theta N J)`);
-    };
-    const parsePower = () => {
-        const base = parseAtom();
-        skip();
-        if (s[i] !== '^')
-            return base;
-        i++;
-        return power(base, parseExponentToken());
-    };
-    const parseProduct = () => {
-        let acc = parsePower();
-        while (true) {
-            skip();
-            const op = s[i];
-            if (op !== '*' && op !== '/')
-                break;
-            i++;
-            const rhs = parsePower();
-            acc = op === '*' ? multiply(acc, rhs) : divide(acc, rhs);
+        case 'num':
+            // A literal 1 is the dimensionless numerator: `1/time`.
+            if (node.value === 1)
+                return d();
+            throw new DimensionSpecError(`a number is not a dimension term ('${node.value}' in '${spec}')`);
+        case 'pow': {
+            const exponent = exponentOf(node.exp, spec);
+            if (!Number.isFinite(exponent))
+                throw new DimensionSpecError(`bad exponent in '${spec}'`);
+            return { ...power(dimensionOf(node.base, spec), exponent) };
         }
-        return acc;
-    };
-    const out = parseProduct();
-    skip();
-    if (i !== s.length)
-        throw new DimensionSpecError(`unrecognized dimension term '${s.slice(i)}'`);
-    return out;
-}
-function wantsGroupedProduct(s) {
-    if (/[()]/.test(s))
-        return true;
-    if (/\/\s*[(A-Za-zΘ]/.test(s))
-        return true;
-    return /\*/.test(s) && /[A-Za-z]{2,}/.test(s);
+        case 'op': {
+            if (node.op !== '*' && node.op !== '/') {
+                throw new DimensionSpecError(`unrecognized dimension term '${spec}' (a dimension has no '${node.op}')`);
+            }
+            const [first, ...rest] = node.args.map((arg) => dimensionOf(arg, spec));
+            return { ...rest.reduce((acc, next) => (node.op === '*' ? multiply(acc, next) : divide(acc, next)), first) };
+        }
+        case 'neg':
+            throw new DimensionSpecError(`unrecognized dimension term '${spec}' (a dimension has no sign)`);
+        case 'call':
+            throw new DimensionSpecError(`unrecognized dimension term '${node.fn}' in '${spec}'`);
+    }
 }
 /** Parse a dimension spec string into a {@link Dimension}. @internal */
 export function parseDimensionSpec(spec) {
     const s = spec.trim();
     if (!s)
         throw new DimensionSpecError('empty dimension spec');
-    // (1) fundamental constant — EXACT case (G ≠ g).
-    if (CONST_DIMS[s])
-        return CONST_DIMS[s];
-    // (2) named dimension — case-insensitive.
-    const named = NAMED_DIMS[s.toLowerCase()];
-    if (named)
-        return named;
-    // (3) product/quotient, including parentheses and named exponents.
-    if (wantsGroupedProduct(s))
-        return parseGroupedProduct(s);
-    // (4) explicit base exponents.
-    const out = d();
-    const parts = s.split(/[.*\s]+/).filter(Boolean);
-    for (const part of parts) {
-        const m = /^([A-Za-zΘ]+)\^?(-?\d+(?:\/\d+)?)?$/.exec(part);
-        if (!m)
-            throw new DimensionSpecError(`unrecognized dimension term '${part}'`);
-        const baseKey = BASES[m[1].toUpperCase()] ?? BASES[m[1]];
-        if (!baseKey) {
-            throw new DimensionSpecError(`unknown base dimension '${m[1]}' (use L M T I Theta N J, a named ` +
-                `dimension, a constant name, or a named product/quotient like power/area)`);
-        }
-        out[baseKey] += parseExponent(m[2] ?? '');
+    // A whole name: a constant (exact case, so G is not g) or a named dimension.
+    const whole = resolveAtom(s);
+    if (whole)
+        return whole;
+    let node;
+    try {
+        node = parseFormulaPNode(formulaSyntax(s));
+    }
+    catch (error) {
+        throw new DimensionSpecError(`unrecognized dimension spec '${s}' (${error instanceof Error ? error.message : String(error)})`);
     }
+    const out = dimensionOf(node, s);
+    // A zero exponent raised to a negative power is -0; a dimension has no signed zero.
+    for (const key of Object.keys(out))
+        if (out[key] === 0)
+            out[key] = 0;
     return out;
 }
 //# sourceMappingURL=dimension-spec.js.map