universal-physics-tensor 8.0.0 → 10.0.0

package/dist/dimensional/curvature.js.map

@@ -1 +1 @@
-{"version":3,"file":"curvature.js","sourceRoot":"","sources":["../../src/dimensional/curvature.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"curvature.js","sourceRoot":"","sources":["../../src/dimensional/curvature.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Curvature-derived helpers — Ricci and Einstein (v0.5.0 Phase 1d).\n *\n * Module hosts the layer of GR objects derived by contraction of a\n * `RiemannTensorNode`:\n *\n *   - `ricci(R)`    → R_μν = R^λ_{λμν}\n *   - `einstein(R)` → G_μν = R_μν − ½ g_μν R\n *\n * The Bianchi validator stays here. `bianchiResidual`, the evaluator that\n * calls `evaluateNumerical`, lives in `numerical/bianchi-residual.ts` so\n * this module does not import `numerical`.\n *\n * Separation rationale (Design §3 Task 1d): the bare `RiemannTensorNode`\n * stays in `connection-validators.ts` next to `CovariantDerivativeNode`\n * (both are *primary* curvature objects: connection + first-derivative).\n * Everything *contracted from* Riemann lives here — keeps the module\n * graph: tensor → metric → connection-validators → curvature.\n *\n * @module dimensional/curvature\n */\n\nimport type { Dimension } from './types.js';\n// Node/index types + ExprNode now live in the leaf `ast-types.ts` — no longer\n// imported from validator.ts (that back-edge formed a type-only cycle). The\n// curvature node types are re-exported below for existing importers.\nimport type {\n  ExprNode,\n  CovariantIndex,\n  RiemannTensorNode,\n  MetricTensorNode,\n  RicciTensorNode,\n  EinsteinTensorNode,\n  BianchiResidualNode,\n} from './ast-types.js';\nimport { IndexLabelCollisionError } from './errors.js';\n\nexport type { RicciTensorNode, EinsteinTensorNode, BianchiResidualNode } from './ast-types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Shared pattern-B callback type\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Shared callback shape used by every pattern-B validator (`validate\n * RicciTensor`, `validateEinsteinTensor`, `validateBianchiResidual`).\n *\n * The callback re-enters the Riemann validator for an embedded\n * `RiemannTensorNode`, returning the validated `{dim, freeIndices}`\n * pair without the surrounding validator-result envelope (the caller\n * is responsible for merging or discarding the free-index map per\n * the contraction it is performing).\n *\n * Co-located here with the three consumer functions (rather than in\n * `validator-registry.ts`) to avoid a `curvature.ts ↔ validator-\n * registry.ts` import cycle — the registry imports the validators\n * from this module, so this module must own the callback type.\n *\n * @internal\n */\nexport type RiemannChildCallback = (child: RiemannTensorNode) => {\n  dim: Dimension;\n  freeIndices: Map<string, { upper: number; lower: number }>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// RicciTensorNode — new ExprNode kind\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * v0.5.0 Task 7: Ricci tensor AST node R_μν.\n *\n * Internally wraps a RiemannTensorNode and represents the contraction\n *\n *     R_μν = R^λ_{μλν}     (Carroll Eq. 3.91)\n *\n * Index-map on the wrapped Riemann (R^ρ_σμν per RiemannTensorNode):\n *\n *     R^ρ    σ    μ    ν\n *     │     │   │   │\n *     │     │   └── lowerIndices[1] = the dummy contraction slot (λ)\n *     │     │       contracts against upperIndex.label (ρ ↔ λ)\n *     │     └── lowerIndices[0] = free output index #1 (μ_out, lower)\n *     └── upperIndex (ρ) — contracts against lowerIndices[1]\n *                              lowerIndices[2] = free output index #2 (ν_out, lower)\n *\n * After contraction: R_μν free indices = {μ_out: lower, ν_out: lower}, dim {L: -2}.\n *\n * NOTE (post-S1 correction, commit `76628c4`): prior to v0.5.0 Task 7 this\n * docstring incorrectly said `lowerIndices[0]` was the dummy slot. Carroll\n * Eq. 3.91 contracts on the SECOND lower (the μ slot in R^ρ_σμν), giving\n * R_σν after the contraction. The implementation in `validateRicciTensor`\n * below (lines ~87-101) is the authoritative reference. See memory entry\n * `feedback_v0_5_0_ricci_contraction_bug.md` for the bug history.\n *\n * The node is its own validation arm in validator.ts and its own lowering\n * arm in numerical/lowering.ts — same pattern as RiemannTensorNode (no\n * AST-rewrite; the contraction is a single primitive walked directly).\n *\n * @public\n */\n/**\n * v0.6.0 Task 3.10b: RicciTensorNode expressed via CurvatureCompositeNode<K, S>.\n * The runtime shape is identical — pure type-alias migration.\n */\n/**\n * Result of validating a RicciTensorNode.\n * @public\n */\ninterface RicciTensorValidationResult {\n  readonly dim: Dimension;\n  readonly freeIndices: Map<string, { upper: number; lower: number }>;\n}\n\n/**\n * Validate a `ricci-tensor` node.\n *\n * Throws:\n *   - IndexLabelCollisionError if the embedded Riemann's two free output\n *     labels (the σ slot — lowerIndices[0] — and the ν slot —\n *     lowerIndices[2]) collide. (The contracted middle slot\n *     lowerIndices[1] is invisible to this check; any label is allowed\n *     there because it's a dummy.)\n *\n * The Riemann sub-node is validated structurally by re-entering its own\n * validator via the `validateRiemannChild` callback (so its signature\n * checks fire), but its free indices are NOT propagated — the ρ slot\n * collapses into the contraction with the μ slot (Carroll Eq. 3.91:\n * `R_μν = R^λ_{μλν}`), and the surviving σ / ν slots become the new\n * free indices of the Ricci tensor.\n */\nexport function validateRicciTensor(\n  node: RicciTensorNode,\n  validateRiemannChild: RiemannChildCallback,\n): RicciTensorValidationResult {\n  // Re-validate the embedded Riemann so its signature checks (upperIndex /\n  // lowerIndices variance, gLower / gInverse signature, free-index\n  // disjointness) fire here too. We discard its freeIndices map: the ρ slot\n  // and the μ slot (lowerIndices[1]) are the contraction; the surviving σ\n  // (lowerIndices[0]) and ν (lowerIndices[2]) are reconstructed below from\n  // the authoritative axis source.\n  const rResult = validateRiemannChild(node.riemann);\n\n  // Dim is inherited 1:1 from the Riemann (contraction does not change\n  // per-component units — multiplying by δ^ρ_μ is dimensionless).\n  const dim = rResult.dim;\n\n  // Surviving free indices: Ricci's μ_out ← lowerIndices[0] (σ slot),\n  // Ricci's ν_out ← lowerIndices[2] (ν slot). Contracted middle slot\n  // (lowerIndices[1]) is dummied and not surfaced as free.\n  const muOutIdx: CovariantIndex = node.riemann.lowerIndices[0];\n  const nuOutIdx: CovariantIndex = node.riemann.lowerIndices[2];\n  if (muOutIdx.label === nuOutIdx.label) {\n    throw new IndexLabelCollisionError(muOutIdx.label, 2, ['ricci-tensor']);\n  }\n\n  const freeIndices = new Map<string, { upper: number; lower: number }>();\n  freeIndices.set(muOutIdx.label, { upper: 0, lower: 1 });\n  freeIndices.set(nuOutIdx.label, { upper: 0, lower: 1 });\n\n  return { dim, freeIndices };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// ricci() — user-facing constructor\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Build the Ricci tensor R_μν = R^λ_{μλν} as a composite ExprNode.\n *\n * **Convention (Carroll Eq. 3.91).** Contract upper-ρ against the SECOND\n * lower slot — the μ position in R^ρ_σμν, i.e., `lowerIndices[1]` in the\n * RiemannTensorNode storage. The surviving free indices are the σ slot\n * (`lowerIndices[0]`) → Ricci's first free output μ_out, and the ν slot\n * (`lowerIndices[2]`) → Ricci's second free output ν_out.\n *\n * Index mapping after contraction:\n *   - upperIndex (ρ) → contracted with lowerIndices[1] (the μ slot, λ dummy)\n *   - lowerIndices[0] (σ) → Ricci's free output index 0 (μ_out)\n *   - lowerIndices[2] (ν) → Ricci's free output index 1 (ν_out)\n *   Result: R_μν with free indices {σ_label: lower, ν_label: lower}\n *\n * Index-map diagram:\n *   R^ρ  _  σ  _  μ  _  ν       (RiemannTensorNode slots)\n *       ↑           ↑\n *   upper        lower[1]   <- contract these two (ρ = μ = λ)\n *            lower[0]    lower[2]  <- become R_μν free indices\n *\n * **Why not \"upper ↔ lowerIndices[0]\" (the first-lower trace)?** The trace\n * `R^λ_{λμν}` over the first pair (ρ ↔ σ) is identically zero by the\n * first-pair antisymmetry of the (lowered) Riemann tensor — for any\n * metric, including non-vacuum solutions like de Sitter. The\n * constant-curvature identity `R_μν = (n-1) K g_μν` (Carroll §8.1,\n * `R = 4Λ` in n=4) only matches the upper↔second-lower contraction.\n * The de-Sitter Ricci-scalar test in `tests/dimensional/ricci.test.ts`\n * is the discriminating fixture that pins this convention.\n *\n * The returned tree is a single `ricci-tensor` node wrapping the supplied\n * Riemann. Validator and numerical lowering each have a dedicated arm —\n * no AST rewrite into a `tensor-product`-of-Riemann happens here (the\n * RiemannTensorNode is not contractable in the v0.3.5 tensor-product\n * einsum sense; the contraction is a primitive operation walked directly).\n *\n * @public\n */\nexport function ricci(R: RiemannTensorNode): ExprNode {\n  return { kind: 'ricci-tensor', riemann: R };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// EinsteinTensorNode — new ExprNode kind (Task 8)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * v0.5.0 Task 8: Einstein tensor AST node G_μν = R_μν − ½ R g_μν.\n *\n * Wraps a `RiemannTensorNode` (contracted via the same Carroll-Eq.-3.91\n * convention as `RicciTensorNode` — see ricci()'s JSDoc) plus the metric\n * pair needed for the scalar trace `R = g^μν R_μν` and the `½ R g_μν`\n * subtraction term. Storage mirrors the `RicciTensorNode` pattern: own\n * validator + lowering arms, no AST rewrite into op('-', ricci, scale·g).\n *\n * Free indices match `R.lowerIndices[0]` and `R.lowerIndices[2]` — same as\n * ricci(R), with the same Carroll-Eq.-3.91 contraction; the embedded\n * Riemann's middle slot lowerIndices[1] is the dummy λ.\n *\n * Dim: {L: -2} — inherited from Riemann/Ricci (both `R_μν` and `R · g_μν`\n * carry 1/L²; subtraction preserves dim).\n *\n * @public\n */\n/**\n * v0.6.0 Task 3.10b: EinsteinTensorNode expressed via CurvatureCompositeNode<K, S>.\n * The runtime shape is identical — pure type-alias migration.\n */\n/**\n * Result of validating an EinsteinTensorNode.\n * @public\n */\ninterface EinsteinTensorValidationResult {\n  readonly dim: Dimension;\n  readonly freeIndices: Map<string, { upper: number; lower: number }>;\n}\n\n/**\n * Validate an `einstein-tensor` node.\n *\n * Delegates structural checks to the embedded Riemann via the\n * `validateRiemannChild` callback (same pattern as `validateRicciTensor`)\n * and reuses `validateRicciTensor` for the surviving free-index labels —\n * an Einstein tensor's free indices are exactly the Ricci tensor's free\n * indices (subtracting `½ R g_μν` with matching {μ_out, ν_out} labels\n * preserves the index structure).\n *\n * The `gLower` / `gInverse` sub-nodes are deliberately NOT propagated as\n * free indices — they are consumed internally by the scalar-trace\n * contraction and the `½ R g_μν` multiplication (same H1 discipline as\n * RiemannTensorNode for its gLower/gInverse fields).\n *\n * Throws:\n *   - Everything `validateRicciTensor` throws (IndexLabelCollisionError on\n *     surviving free-index collision; MetricSignatureError /\n *     PartialDerivativeIndexVarianceError from the inner Riemann).\n */\nexport function validateEinsteinTensor(\n  node: EinsteinTensorNode,\n  validateRiemannChild: RiemannChildCallback,\n): EinsteinTensorValidationResult {\n  // Delegate to Ricci validation — the surviving free-index labels and dim\n  // are identical (R_μν has the same {μ_out, ν_out} as G_μν, dim {L:-2}).\n  const ricciNode: RicciTensorNode = { kind: 'ricci-tensor', riemann: node.riemann };\n  const r = validateRicciTensor(ricciNode, validateRiemannChild);\n\n  // Defense in depth: the `½ R g_μν` term involves g_μν, but its free\n  // indices are NOT propagated — they are the same {μ_out, ν_out} as Ricci\n  // by construction (we contract them down to a 4×4 in the same axis order\n  // during lowering). Mirrors H1: gLower / gInverse on RiemannTensorNode.\n  return { dim: r.dim, freeIndices: r.freeIndices };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// einstein() — user-facing constructor\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Build the Einstein tensor G_μν = R_μν − ½ R g_μν as a composite ExprNode.\n *\n * **Convention.** The Einstein tensor adds the scalar-trace subtraction\n * term `½ R g_μν` to Ricci — it does NOT introduce a new contraction\n * convention. The inner Ricci `R_μν` inherits Carroll Eq. 3.91 from\n * `ricci(R)` (contraction on `lowerIndices[1]`, the middle/μ slot in\n * R^ρ_σμν; see RicciTensorNode JSDoc for the index-map diagram). The\n * scalar trace is `R = g^μν R_μν`. The result `G_μν` shares free indices\n * {μ_out, ν_out} with `ricci(R)`.\n *\n * **Algebra (sanity check).**\n *   - de Sitter (n=4): `R_μν = Λ g_μν`, `R = 4Λ` ⇒\n *     `G_μν = Λ g_μν − ½·4Λ·g_μν = −Λ g_μν`. Vacuum Einstein equation\n *     `G_μν + Λ g_μν = 0` holds.\n *   - Schwarzschild (vacuum): `R_μν ≡ 0`, `R = 0` ⇒ `G_μν ≡ 0`.\n *   - Trace identity (any metric, n=4): `g^μν G_μν = R − ½·R·4 = −R`.\n *\n * **AST shape.** Single `einstein-tensor` node wrapping `R`, `gLower`,\n * `gInverse`. Validator and numerical lowering each have a dedicated arm;\n * no AST rewrite into `ricci(R) − ½ R g_μν` happens (the subtraction term\n * would need a tensor-valued scalar-multiply that the v0.3.5 tensor-product\n * einsum does not support directly). Same walk-directly pattern as Ricci.\n *\n * **Matter coupling is out of scope.** The vacuum / cosmological-constant\n * tests pin G_μν only; `G_μν = κ T_μν` (Einstein field equations with a\n * stress-energy source) is deferred to v0.6.0+.\n *\n * @public\n */\nexport function einstein(\n  R: RiemannTensorNode,\n  g: MetricTensorNode,\n  gInverse: MetricTensorNode,\n): ExprNode {\n  return { kind: 'einstein-tensor', riemann: R, gLower: g, gInverse };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// BianchiResidualNode — new ExprNode kind (Task 9)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * v0.5.0 Task 9: Second-Bianchi-identity residual AST node.\n *\n * Represents the cyclic-over-first-three-indices sum that vanishes by the\n * second Bianchi identity (Carroll Eq. 3.95):\n *\n *   B_{λμνρσ} = ∇_λ R_{μνρσ} + ∇_μ R_{νλρσ} + ∇_ν R_{λμρσ} ≡ 0\n *\n * Storage: wraps the originating RiemannTensorNode. Lowering computes B\n * numerically by:\n *   1. Lowering the upper-ρ of the Riemann tensor JS-side via g_{aρ}.\n *   2. Computing ∂_λ R_{αβγδ} via a 4th-order centered FD (one MORE layer\n *      on top of the Riemann lowering's already-FD-laden Γ + ∂Γ stack).\n *   3. Adding Christoffel-correction terms to form ∇_λ R_{μνρσ} (Approach 1:\n *      canonical, not partial-only).\n *   4. Summing cyclically over (λ, μ, ν) with (ρ, σ) fixed.\n *\n * **Dim L⁻³.** R_{μνρσ} has dim L⁻² (inherited from R^ρ_{σμν}, since lowering\n * with the dimensionless metric preserves dim per our convention). One ∂/∂x\n * divides by L, giving L⁻³ on ∇R and on the cyclic sum B.\n *\n * **Free indices (5 lower):** λ, μ, ν, ρ, σ — taken from the same axis\n * convention as RiemannTensorNode.lowerIndices plus a fresh λ slot. To avoid\n * label collisions we synthesise `lambda` as the 5th index and reuse\n * R.lowerIndices[0..2] for {μ_out, ν_out, ρ_out}; the 4th wrapped slot\n * surfaces as `sigma_out`. (See `validateBianchiResidual` below for the\n * label-collision rule.)\n *\n * **Why not lower via the v0.3.0 `lower()` AST function?** lower() returns a\n * `tensor-product` node referencing the metric and operand by label/free-\n * index merge, intended for compositional expressions. The lowered Riemann\n * here is consumed point-wise by the FD stencil; building an AST product +\n * re-validating + re-lowering on every of the 25 FD samples is needless\n * machinery for a closed JS-side contraction. Matches the walk-directly\n * philosophy of Tasks 6, 7, 8.\n *\n * @public\n */\n/**\n * v0.6.0 Task 3.10c: BianchiResidualNode expressed via CurvatureCompositeNode<K, S>.\n * The runtime shape is identical — pure type-alias migration.\n */\n/**\n * Result of validating a BianchiResidualNode.\n * @public\n */\ninterface BianchiResidualValidationResult {\n  readonly dim: Dimension;\n  readonly freeIndices: Map<string, { upper: number; lower: number }>;\n}\n\n/**\n * Validate a `bianchi-residual` node.\n *\n * Inherits all structural checks from the embedded Riemann via\n * `validateRiemannChild`. The output freeIndices are 5 lower labels:\n *\n *   - `lambda` — the synthesised FIRST cyclic-derivative axis (a new label;\n *     must not collide with the wrapped Riemann's free labels)\n *   - The Riemann's `lowerIndices[0]` label → μ_out\n *   - The Riemann's `lowerIndices[1]` label → ν_out\n *   - The Riemann's `lowerIndices[2]` label → ρ_out\n *   - A synthesised `sigma_out` — the fourth Riemann index after lowering ρ.\n *\n * Throws:\n *   - IndexLabelCollisionError if the synthesised `lambda` / `sigma_out`\n *     labels collide with any wrapped-Riemann label.\n */\nexport function validateBianchiResidual(\n  node: BianchiResidualNode,\n  validateRiemannChild: RiemannChildCallback,\n): BianchiResidualValidationResult {\n  // Re-validate the embedded Riemann for its own signature/index checks.\n  validateRiemannChild(node.riemann);\n\n  // Build the 5 free-index labels. The Riemann's lowerIndices[0..2] become\n  // the μ_out, ν_out, ρ_out of the all-lower Riemann (after lowering ρ to a\n  // synthesised 'sigma_out'... wait — the convention here is:\n  //   ∇_λ R_{αβγδ} has 5 indices: λ + 4 from the lowered Riemann.\n  //   The 4 from the lowered Riemann are: the freshly-lowered ρ (renamed\n  //   from `upperIndex.label`) + lowerIndices[0..2].\n  // We use literal label `lambda` for the cyclic-deriv axis. The freshly-\n  // lowered ρ takes a literal `alpha_lower` label.\n  //\n  // Collision rule: `lambda` and `alpha_lower` must not collide with any of\n  // {upperIndex.label, lowerIndices[0..2].label}.\n  const wrappedLabels = new Set<string>([\n    node.riemann.upperIndex.label,\n    node.riemann.lowerIndices[0].label,\n    node.riemann.lowerIndices[1].label,\n    node.riemann.lowerIndices[2].label,\n  ]);\n  const synthesised = ['lambda', 'alpha_lower'];\n  for (const s of synthesised) {\n    if (wrappedLabels.has(s)) {\n      throw new IndexLabelCollisionError(s, 2, ['bianchi-residual']);\n    }\n  }\n\n  // Per Design §3 Task 1f / F8 / I3: Bianchi residual carries 1/L³ (one\n  // covariant derivative on R, which is 1/L²).\n  const dim: Dimension = { L: -3, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0 };\n\n  // 5 free indices, all lower.\n  const freeIndices = new Map<string, { upper: number; lower: number }>();\n  freeIndices.set('lambda', { upper: 0, lower: 1 });\n  freeIndices.set('alpha_lower', { upper: 0, lower: 1 });\n  freeIndices.set(node.riemann.lowerIndices[0].label, { upper: 0, lower: 1 });\n  freeIndices.set(node.riemann.lowerIndices[1].label, { upper: 0, lower: 1 });\n  freeIndices.set(node.riemann.lowerIndices[2].label, { upper: 0, lower: 1 });\n\n  return { dim, freeIndices };\n}\n"]}

package/dist/dimensional/dimension-inference.js.map

@@ -1 +1 @@
-{"version":3,"file":"dimension-inference.js","sourceRoot":"","sources":["../../src/dimensional/dimension-inference.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dimension-inference.js","sourceRoot":"","sources":["../../src/dimensional/dimension-inference.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Single-unknown dimensional inference.\n *\n * Given a parsed scalar `ExprNode` (e.g. the RHS of a user equation) in which\n * exactly one symbol's dimension is unknown, and the known dimension the whole\n * expression must equal (the target), recover the unknown's dimension from\n * dimensional homogeneity — or abstain (`null`) when it is not uniquely pinned\n * (the unknown is sum-constrained, absent, or appears non-cleanly).\n *\n * Method (no symbolic differentiation): probe the unknown with two dimensions\n * and read off its net power. With the unknown set to `DIMENSIONLESS` the\n * expression has dimension `D0`; set to `LENGTH` it has `D1`. The unknown enters\n * the dimension as a single power `p`, so `D1 / D0 = LENGTH^p`; if that quotient\n * is a clean power of the probe (only the `L` component nonzero), then from\n * `target = D0 · unknown^p` we get `unknown = (target / D0)^(1/p)`. Pure; reuses\n * the dimensional `algebra`.\n *\n * @module dimensional/dimension-inference\n */\n\nimport type { Dimension } from './types.js';\nimport { DIMENSIONLESS, LENGTH } from './types.js';\nimport { divide, power, EXPONENT_TOL } from './algebra.js';\nimport type { ExprNode } from './validator.js';\nimport { validate } from './validator.js';\n\nconst BASES: ReadonlyArray<keyof Dimension> = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'];\n\n/**\n * Rebuild `node`, replacing the dimension of every `symbol` named `name` with\n * `dim`. Walks the scalar arms (`symbol`/`op`/`transcendental`/`abs`); other\n * arms are returned unchanged (they do not occur in parsed scalar expressions).\n *\n * @public\n */\nexport function substituteSymbolDim(node: ExprNode, name: string, dim: Dimension): ExprNode {\n  switch (node.kind) {\n    case 'symbol':\n      return node.name === name ? { ...node, dim } : node;\n    case 'op':\n      return { ...node, args: node.args.map((a) => substituteSymbolDim(a, name, dim)) };\n    case 'transcendental':\n      return { ...node, arg: substituteSymbolDim(node.arg, name, dim) };\n    case 'abs':\n      return { ...node, arg: substituteSymbolDim(node.arg, name, dim) };\n    default:\n      return node;\n  }\n}\n\n/** Homogeneous dimension of `node`, or `null` if it is not well-formed. */\nfunction dimensionOrNull(node: ExprNode): Dimension | null {\n  const r = validate(node);\n  return r.ok && r.inferredDimension !== null ? r.inferredDimension : null;\n}\n\n/**\n * Infer the dimension of `unknown` in `expr` such that `expr` has dimension\n * `targetDim`, or `null` when it is not uniquely determined.\n *\n * @public\n */\nexport function inferUnknownDimension(\n  expr: ExprNode,\n  unknown: string,\n  targetDim: Dimension,\n): Dimension | null {\n  const d0 = dimensionOrNull(substituteSymbolDim(expr, unknown, DIMENSIONLESS));\n  const d1 = dimensionOrNull(substituteSymbolDim(expr, unknown, LENGTH));\n  if (d0 === null || d1 === null) return null;\n\n  // D1 / D0 must be a clean power of the probe (LENGTH): only the L exponent.\n  const quotient = divide(d1, d0);\n  const p = quotient.L;\n  if (p === 0) return null; // the unknown does not affect the dimension\n  for (const base of BASES) {\n    if (base !== 'L' && quotient[base] !== 0) return null; // not a clean power\n  }\n  const result = power(divide(targetDim, d0), 1 / p);\n  // Snap each exponent to its nearest integer within tolerance, then abstain if\n  // any is GENUINELY fractional (e.g. x^2 = [length] ⟹ [length]^½ is not a real\n  // physical dimension). The tolerance absorbs FP round-off that arrives in the\n  // target from a v0.20 fractional-power computation, so a real integer answer\n  // (L = 2 + ε) is not spuriously rejected — consistent with `equals` (bb15432).\n  const snapped = { ...result };\n  for (const base of BASES) {\n    const rounded = Math.round(result[base]);\n    if (Math.abs(result[base] - rounded) > EXPONENT_TOL) return null;\n    snapped[base] = rounded;\n  }\n  return snapped;\n}\n"]}

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

@@ -3,9 +3,14 @@
  * so CLI users can declare a quantity's dimensions without TypeScript.
  *
  * Accepts (in priority order):
- *   1. a named dimension — `length`, `time`, `mass`, `velocity`,
- *      `acceleration`, `force`, `energy`, `power`, `action`, `frequency`,
- *      `temperature`, `entropy`, `charge`, `area`, `dimensionless`;
+ *   1. a named dimension — the `types.ts` constants (`length`, `time`,
+ *      `mass`, `velocity`, `acceleration`, `force`, `energy`, `power`,
+ *      `action`, `frequency`, `temperature`, `entropy`, `charge`, `area`,
+ *      `dimensionless`, `density`) and the dimensions of the SI units
+ *      `m^3`, `Pa`, `Pa*s`, `ohm`, `T`, `H/m`, `A`, `mol`, `cd` under the
+ *      names `volume`, `pressure`, `viscosity`, `resistance`,
+ *      `magnetic-field`, `permeability`, `current`, `amount` (or
+ *      `amount-of-substance`), `luminous-intensity`;
  *   2. a fundamental constant by name — `hbar`/`ℏ`, `c`, `G`, `k_B`/`kB`,
  *      `e` (its SI dimension);
  *   3. a product/quotient of named dimensions or constants — `power/area`,
@@ -18,6 +23,16 @@
  *      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 `^` unless the letters and
+ * the digit together spell a registered atom (`mu0`, `eps0`), 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 +41,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAyB5C,4BAA4B;AAC5B,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAqCD;;;;;;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;AAkI1F,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAkB1D"}

package/dist/dimensional/dimension-spec.js

@@ -3,9 +3,14 @@
  * so CLI users can declare a quantity's dimensions without TypeScript.
  *
  * Accepts (in priority order):
- *   1. a named dimension — `length`, `time`, `mass`, `velocity`,
- *      `acceleration`, `force`, `energy`, `power`, `action`, `frequency`,
- *      `temperature`, `entropy`, `charge`, `area`, `dimensionless`;
+ *   1. a named dimension — the `types.ts` constants (`length`, `time`,
+ *      `mass`, `velocity`, `acceleration`, `force`, `energy`, `power`,
+ *      `action`, `frequency`, `temperature`, `entropy`, `charge`, `area`,
+ *      `dimensionless`, `density`) and the dimensions of the SI units
+ *      `m^3`, `Pa`, `Pa*s`, `ohm`, `T`, `H/m`, `A`, `mol`, `cd` under the
+ *      names `volume`, `pressure`, `viscosity`, `resistance`,
+ *      `magnetic-field`, `permeability`, `current`, `amount` (or
+ *      `amount-of-substance`), `luminous-intensity`;
  *   2. a fundamental constant by name — `hbar`/`ℏ`, `c`, `G`, `k_B`/`kB`,
  *      `e` (its SI dimension);
  *   3. a product/quotient of named dimensions or constants — `power/area`,
@@ -18,10 +23,24 @@
  *      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 `^` unless the letters and
+ * the digit together spell a registered atom (`mu0`, `eps0`), 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 { DIMENSIONLESS, LENGTH, AREA, TIME, FREQUENCY, MASS, MASS_DENSITY, 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 { unitDimension } from './units.js';
+import { parseFormulaPNode } from '../numerical/formula-dimension.js';
 /** A bad dimension spec. */
 export class DimensionSpecError extends Error {
     constructor(message) {
@@ -29,15 +48,20 @@ 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 });
-/** Named dimensions — matched case-insensitively. */
+/**
+ * Named dimensions — matched case-insensitively. Each is a `types.ts`
+ * constant or the dimension of an SI unit read by the one unit reader; no
+ * exponent tuple is typed here.
+ */
 const NAMED_DIMS = {
     dimensionless: DIMENSIONLESS,
     length: LENGTH,
     area: AREA,
+    volume: unitDimension('m^3'),
     time: TIME,
     frequency: FREQUENCY,
     mass: MASS,
+    density: MASS_DENSITY,
     velocity: VELOCITY,
     acceleration: ACCELERATION,
     force: FORCE,
@@ -47,30 +71,25 @@ const NAMED_DIMS = {
     temperature: TEMPERATURE,
     entropy: ENTROPY,
     charge: CHARGE,
-    pressure: d(-1, 1, -2),
-    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),
+    current: unitDimension('A'),
+    electric_current: unitDimension('A'),
+    amount: unitDimension('mol'),
+    amount_of_substance: unitDimension('mol'),
+    luminous_intensity: unitDimension('cd'),
+    pressure: unitDimension('Pa'),
+    viscosity: unitDimension('Pa*s'),
+    resistance: unitDimension('ohm'),
+    magnetic_field: unitDimension('T'),
+    permeability: unitDimension('H/m'),
 };
 /**
- * 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,164 +103,135 @@ 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;
 }
 function baseAtom(id) {
-    const baseKey = BASES[id.toUpperCase()] ?? BASES[id];
+    // A single base letter is read in its own case: `m` is the metre's symbol, not mass,
+    // and `t`, `i`, `n`, `j` are not bases either (Tom's second round; it read `m^3` as M³).
+    // `Theta`/`THETA`/`Θ` are the one multi-letter base and stay case-insensitive.
+    if (id.length === 1 && /[a-z]/.test(id)) {
+        const upper = id.toUpperCase();
+        if (BASES[upper] !== undefined) {
+            throw new DimensionSpecError(`'${id}' is not a base letter: the bases are L M T I Θ N J in that case (mass is M, length is L); a unit symbol is not a dimension`);
+        }
+        return null;
+    }
+    const baseKey = id.length > 1 ? BASES[id.toUpperCase()] ?? BASES[id] : BASES[id];
     if (!baseKey)
         return null;
-    const dim = d();
-    dim[baseKey] = 1;
-    return dim;
+    const out = dim();
+    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`. The letters and the digit
+        // together may spell a registered atom (`mu0`, `eps0`, `mu_0`); that
+        // token is a name, not a base with an exponent.
+        .replace(/([A-Za-zΘ_]+)([+-]?\d)/g, (token, word, digit) => resolveAtom(token) !== null ? token : `${word}^${digit}`)
+        // 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 dim();
+            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

package/dist/dimensional/dimension-spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"dimension-spec.js","sourceRoot":"","sources":["../../src/dimensional/dimension-spec.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"dimension-spec.js","sourceRoot":"","sources":["../../src/dimensional/dimension-spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dimension-spec parser — turns a human string into a {@link Dimension},\n * so CLI users can declare a quantity's dimensions without TypeScript.\n *\n * Accepts (in priority order):\n *   1. a named dimension — the `types.ts` constants (`length`, `time`,\n *      `mass`, `velocity`, `acceleration`, `force`, `energy`, `power`,\n *      `action`, `frequency`, `temperature`, `entropy`, `charge`, `area`,\n *      `dimensionless`, `density`) and the dimensions of the SI units\n *      `m^3`, `Pa`, `Pa*s`, `ohm`, `T`, `H/m`, `A`, `mol`, `cd` under the\n *      names `volume`, `pressure`, `viscosity`, `resistance`,\n *      `magnetic-field`, `permeability`, `current`, `amount` (or\n *      `amount-of-substance`), `luminous-intensity`;\n *   2. a fundamental constant by name — `hbar`/`ℏ`, `c`, `G`, `k_B`/`kB`,\n *      `e` (its SI dimension);\n *   3. a product/quotient of named dimensions or constants — `power/area`,\n *      `length*temperature` (persona finding L1); parentheses group a\n *      denominator or factor (`power/(area*temperature^4)`), a name may\n *      carry an exponent (`mass/length^3`), and a single base letter works\n *      in a quotient (`M/L^3`). A slash that is only the bar of a fractional\n *      exponent (`T^1/2`) stays on the explicit-base path;\n *   4. explicit base exponents — `L^3.M^-1.T^-2` (bases L M T I Theta/Θ N J,\n *      separated by `.`, `*`, or spaces; `^` optional; fractional exponents\n *      like `T^1/2` allowed).\n *\n * Forms 3 and 4 are one grammar, the formula grammar MathTS parses\n * ({@link parseFormulaPNode}). The dimension notation differs from a formula\n * only in spelling, and {@link formulaSyntax} rewrites those spellings\n * before the parse: a `.` between factors is `*`, a space between factors is\n * `*`, a glued exponent (`L2`, `T-2`) takes its `^` unless the letters and\n * the digit together spell a registered atom (`mu0`, `eps0`), a fractional\n * exponent (`T^1/2`) is parenthesized, and a hyphen inside a name\n * (`magnetic-field`) is `_`. There is no subtraction in a dimension, so `-`\n * after a name is always an exponent's sign.\n *\n * @module dimensional/dimension-spec\n */\n\nimport type { Dimension } from './types.js';\nimport {\n  DIMENSIONLESS,\n  LENGTH,\n  AREA,\n  TIME,\n  FREQUENCY,\n  MASS,\n  MASS_DENSITY,\n  VELOCITY,\n  ACCELERATION,\n  FORCE,\n  ENERGY,\n  POWER,\n  ACTION,\n  TEMPERATURE,\n  ENTROPY,\n  CHARGE,\n} from './types.js';\nimport { divide, multiply, power } from './algebra.js';\nimport { dim } from './ast-builders.js';\nimport { CONSTANT_REGISTRY } from './symbolic-constants.js';\nimport { unitDimension } from './units.js';\nimport { parseFormulaPNode, type FormulaPNode } from '../numerical/formula-dimension.js';\n\n/** A bad dimension spec. */\nexport class DimensionSpecError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'DimensionSpecError';\n  }\n}\n\n/**\n * Named dimensions — matched case-insensitively. Each is a `types.ts`\n * constant or the dimension of an SI unit read by the one unit reader; no\n * exponent tuple is typed here.\n */\nconst NAMED_DIMS: Readonly<Record<string, Dimension>> = {\n  dimensionless: DIMENSIONLESS,\n  length: LENGTH,\n  area: AREA,\n  volume: unitDimension('m^3'),\n  time: TIME,\n  frequency: FREQUENCY,\n  mass: MASS,\n  density: MASS_DENSITY,\n  velocity: VELOCITY,\n  acceleration: ACCELERATION,\n  force: FORCE,\n  energy: ENERGY,\n  power: POWER,\n  action: ACTION,\n  temperature: TEMPERATURE,\n  entropy: ENTROPY,\n  charge: CHARGE,\n  current: unitDimension('A'),\n  electric_current: unitDimension('A'),\n  amount: unitDimension('mol'),\n  amount_of_substance: unitDimension('mol'),\n  luminous_intensity: unitDimension('cd'),\n  pressure: unitDimension('Pa'),\n  viscosity: unitDimension('Pa*s'),\n  resistance: unitDimension('ohm'),\n  magnetic_field: unitDimension('T'),\n  permeability: unitDimension('H/m'),\n};\n\n/**\n * One constant's exact-case spellings, projected from the constant registry.\n * The first name is the formula name the equation path rewrites the others\n * to. `upt eval` binds the same names. A dimension term reads this record.\n *\n * @internal\n */\nexport const CONSTANT_SPELLINGS: readonly { readonly names: readonly string[]; readonly dim: Dimension }[] =\n  CONSTANT_REGISTRY.map((row) => ({ names: [row.name, ...row.spellings], dim: row.dim }));\n\n/** Fundamental constants by their SI dimension — matched EXACT-case, so\n *  `G` (Newton's constant) is never confused with `g` (acceleration). */\nconst CONST_DIMS: Readonly<Record<string, Dimension>> = Object.fromEntries(\n  CONSTANT_SPELLINGS.flatMap(({ names, dim }) => names.map((name) => [name, dim])),\n);\n\nconst BASES: Record<string, keyof Dimension> = {\n  L: 'L',\n  M: 'M',\n  T: 'T',\n  I: 'I',\n  THETA: 'Theta',\n  'Θ': 'Theta',\n  N: 'N',\n  J: 'J',\n};\n\n/** Resolve one atom: constant (exact case, `_` or `-`) or named dimension (case-insensitive). */\nfunction resolveAtom(raw: string): Dimension | null {\n  const s = raw.trim();\n  if (!s) return null;\n  const constant = CONST_DIMS[s] ?? CONST_DIMS[s.replaceAll('_', '-')];\n  if (constant) return constant;\n  const key = s.toLowerCase().replace(/[\\s-]+/g, '_');\n  return NAMED_DIMS[key] ?? NAMED_DIMS[s.toLowerCase()] ?? null;\n}\n\nfunction baseAtom(id: string): Dimension | null {\n  // A single base letter is read in its own case: `m` is the metre's symbol, not mass,\n  // and `t`, `i`, `n`, `j` are not bases either (Tom's second round; it read `m^3` as M³).\n  // `Theta`/`THETA`/`Θ` are the one multi-letter base and stay case-insensitive.\n  if (id.length === 1 && /[a-z]/.test(id)) {\n    const upper = id.toUpperCase();\n    if (BASES[upper] !== undefined) {\n      throw new DimensionSpecError(`'${id}' is not a base letter: the bases are L M T I Θ N J in that case (mass is M, length is L); a unit symbol is not a dimension`);\n    }\n    return null;\n  }\n  const baseKey = id.length > 1 ? BASES[id.toUpperCase()] ?? BASES[id] : BASES[id];\n  if (!baseKey) return null;\n  const out = dim();\n  out[baseKey] = 1;\n  return out;\n}\n\n/**\n * The dimension notation in formula syntax. Each rewrite is a spelling the\n * notation allows and a formula does not; none adds an operator a reader\n * did not write.\n */\nfunction formulaSyntax(spec: string): string {\n  return (\n    spec\n      // A hyphen inside a name: `magnetic-field` is `magnetic_field`.\n      .replace(/(?<=[A-Za-zΘ])-(?=[A-Za-zΘ])/g, '_')\n      // Spaces around an operator carry nothing; between two factors they multiply.\n      .replace(/\\s*([*/^().])\\s*/g, '$1')\n      .replace(/\\s+/g, '*')\n      // A glued exponent: `L2`, `T-2`, `T-2.5`. The letters and the digit\n      // together may spell a registered atom (`mu0`, `eps0`, `mu_0`); that\n      // token is a name, not a base with an exponent.\n      .replace(/([A-Za-zΘ_]+)([+-]?\\d)/g, (token, word: string, digit: string) =>\n        resolveAtom(token) !== null ? token : `${word}^${digit}`,\n      )\n      // A fractional exponent: `T^1/2` is `T^(1/2)`.\n      .replace(/\\^([+-]?\\d+(?:\\.\\d+)?)\\/(\\d+(?:\\.\\d+)?)/g, '^($1/$2)')\n      // A dot between factors is a product; a dot before a digit is a decimal point.\n      .replace(/\\.(?!\\d)/g, '*')\n  );\n}\n\n/** A numeric exponent: a number, a signed number, or a quotient or product of numbers. */\nfunction exponentOf(node: FormulaPNode, spec: string): number {\n  switch (node.kind) {\n    case 'num':\n      return node.value;\n    case 'neg':\n      return -exponentOf(node.arg, spec);\n    case 'op': {\n      const values = node.args.map((arg) => exponentOf(arg, spec));\n      if (node.op === '/') return values.reduce((a, b) => a / b);\n      if (node.op === '*') return values.reduce((a, b) => a * b, 1);\n      if (node.op === '+') return values.reduce((a, b) => a + b, 0);\n      return values.length === 1 ? -values[0]! : values.reduce((a, b) => a - b);\n    }\n    default:\n      throw new DimensionSpecError(`bad exponent in '${spec}'`);\n  }\n}\n\nfunction unknownTerm(id: string): DimensionSpecError {\n  return new DimensionSpecError(\n    `unknown base dimension '${id}' (use L M T I Theta N J, a named dimension, a constant name, ` +\n      'or a named product/quotient like power/area)',\n  );\n}\n\n/** The dimension a parsed spec states. */\nfunction dimensionOf(node: FormulaPNode, spec: string): Dimension {\n  switch (node.kind) {\n    case 'sym': {\n      const found = resolveAtom(node.name) ?? baseAtom(node.name);\n      if (found === null) throw unknownTerm(node.name);\n      return { ...found };\n    }\n    case 'num':\n      // A literal 1 is the dimensionless numerator: `1/time`.\n      if (node.value === 1) return dim();\n      throw new DimensionSpecError(`a number is not a dimension term ('${node.value}' in '${spec}')`);\n    case 'pow': {\n      const exponent = exponentOf(node.exp, spec);\n      if (!Number.isFinite(exponent)) throw new DimensionSpecError(`bad exponent in '${spec}'`);\n      return { ...power(dimensionOf(node.base, spec), exponent) };\n    }\n    case 'op': {\n      if (node.op !== '*' && node.op !== '/') {\n        throw new DimensionSpecError(`unrecognized dimension term '${spec}' (a dimension has no '${node.op}')`);\n      }\n      const [first, ...rest] = node.args.map((arg) => dimensionOf(arg, spec));\n      return { ...rest.reduce((acc, next) => (node.op === '*' ? multiply(acc, next) : divide(acc, next)), first!) };\n    }\n    case 'neg':\n      throw new DimensionSpecError(`unrecognized dimension term '${spec}' (a dimension has no sign)`);\n    case 'call':\n      throw new DimensionSpecError(`unrecognized dimension term '${node.fn}' in '${spec}'`);\n  }\n}\n\n/** Parse a dimension spec string into a {@link Dimension}. @internal */\nexport function parseDimensionSpec(spec: string): Dimension {\n  const s = spec.trim();\n  if (!s) throw new DimensionSpecError('empty dimension spec');\n  // A whole name: a constant (exact case, so G is not g) or a named dimension.\n  const whole = resolveAtom(s);\n  if (whole) return whole;\n  let node: FormulaPNode;\n  try {\n    node = parseFormulaPNode(formulaSyntax(s));\n  } catch (error) {\n    throw new DimensionSpecError(\n      `unrecognized dimension spec '${s}' (${error instanceof Error ? error.message : String(error)})`,\n    );\n  }\n  const out = dimensionOf(node, s);\n  // A zero exponent raised to a negative power is -0; a dimension has no signed zero.\n  for (const key of Object.keys(out) as (keyof Dimension)[]) if (out[key] === 0) out[key] = 0;\n  return out;\n}\n"]}