universal-physics-tensor 10.0.0 → 12.0.0

package/dist/dimensional/exact-scale.js.map

@@ -1 +1 @@
-{"version":3,"file":"exact-scale.js","sourceRoot":"","sources":["../../src/dimensional/exact-scale.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Exact unit scales.\n *\n * A unit's scale to SI is a rational number times one floating factor that\n * holds its irrational part (π for an angle, ln 2 for a bit). Prefixes,\n * products, quotients and integer powers multiply the rationals exactly, so\n * `g/cm^3` is 1000 and `72 mN/m` is 0.072 with no float noise to round away.\n * The one rounding is {@link scaleToNumber}, which rounds the rational\n * correctly and then multiplies by the irrational factor once.\n *\n * A decimal literal is read digit for digit. A JavaScript number is read\n * through its shortest round-trip decimal (`String(x)`), which is the\n * literal a constant was written with.\n *\n * @module dimensional/exact-scale\n * @internal\n */\n\n/** `num / den × irrational`, with `den > 0` and the fraction in lowest terms. @internal */\nexport interface ExactScale {\n  readonly num: bigint;\n  readonly den: bigint;\n  /** The factor no rational states (π, ln 2). 1 for a rational scale. */\n  readonly irrational: number;\n}\n\nfunction gcd(a: bigint, b: bigint): bigint {\n  let x = a < 0n ? -a : a;\n  let y = b < 0n ? -b : b;\n  while (y !== 0n) [x, y] = [y, x % y];\n  return x;\n}\n\nfunction make(num: bigint, den: bigint, irrational: number): ExactScale {\n  if (den === 0n) throw new RangeError('exact scale: zero denominator');\n  if (den < 0n) {\n    num = -num;\n    den = -den;\n  }\n  const g = gcd(num, den);\n  return g > 1n ? { num: num / g, den: den / g, irrational } : { num, den, irrational };\n}\n\n/** The scale 1. @internal */\nexport const UNIT_SCALE: ExactScale = { num: 1n, den: 1n, irrational: 1 };\n\nconst DECIMAL = /^([+-]?)(\\d*)(?:\\.(\\d*))?(?:[eE]([+-]?\\d+))?$/;\n\n/**\n * The exact value of a decimal literal (`72`, `0.45359237`, `1.602176634e-19`),\n * or null when `text` is not one.\n * @internal\n */\nexport function decimalScale(text: string): ExactScale | null {\n  const m = DECIMAL.exec(text.trim());\n  if (m === null) return null;\n  const whole = m[2] ?? '';\n  const fraction = m[3] ?? '';\n  if (whole === '' && fraction === '') return null;\n  const exponent = Number(m[4] ?? '0') - fraction.length;\n  if (!Number.isSafeInteger(exponent) || Math.abs(exponent) > 10_000) return null;\n  let num = BigInt(whole + fraction);\n  if (m[1] === '-') num = -num;\n  return exponent >= 0 ? make(num * 10n ** BigInt(exponent), 1n, 1) : make(num, 10n ** BigInt(-exponent), 1);\n}\n\n/** The exact scale a finite JavaScript number was written as. @internal */\nexport function scaleOf(x: number): ExactScale {\n  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);\n  return decimalScale(String(x))!;\n}\n\n/** `num / den`, exactly. @internal */\nexport function ratioScale(num: number | bigint, den: number | bigint): ExactScale {\n  return make(BigInt(num), BigInt(den), 1);\n}\n\n/** A factor no rational states, such as π or ln 2. @internal */\nexport function irrationalScale(x: number): ExactScale {\n  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);\n  return { num: 1n, den: 1n, irrational: x };\n}\n\n/** `a × b × …`. @internal */\nexport function multiplyScales(...factors: readonly ExactScale[]): ExactScale {\n  let num = 1n;\n  let den = 1n;\n  let irrational = 1;\n  for (const f of factors) {\n    num *= f.num;\n    den *= f.den;\n    irrational *= f.irrational;\n  }\n  return make(num, den, irrational);\n}\n\n/** `a / b`. @internal */\nexport function divideScales(a: ExactScale, b: ExactScale): ExactScale {\n  if (b.num === 0n) throw new RangeError('exact scale: division by zero');\n  return make(a.num * b.den, a.den * b.num, a.irrational / b.irrational);\n}\n\n/**\n * `a ^ n`. An integer power stays exact. A fractional power has no exact\n * rational in general, so it becomes one floating factor.\n * @internal\n */\nexport function powerScale(a: ExactScale, n: number): ExactScale {\n  if (Number.isInteger(n)) {\n    const k = BigInt(Math.abs(n));\n    const up = make(a.num ** k, a.den ** k, a.irrational ** Math.abs(n));\n    return n >= 0 ? up : divideScales(UNIT_SCALE, up);\n  }\n  return irrationalScale(scaleToNumber(a) ** n);\n}\n\n/** `a + b`: exact when both are rational multiples of the same irrational factor. @internal */\nexport function addScales(a: ExactScale, b: ExactScale): ExactScale {\n  if (a.irrational === b.irrational) return make(a.num * b.den + b.num * a.den, a.den * b.den, a.irrational);\n  return irrationalScale(scaleToNumber(a) + scaleToNumber(b));\n}\n\n/** The fewest significant digits kept before the sticky digit; far beyond a double's 17. */\nconst MIN_DIGITS = 40;\n\n/** Decimal places of `1 / den` when it terminates (`den` = 2^a·5^b): max(a, b). Null otherwise. */\nfunction terminatingPlaces(den: bigint): number | null {\n  let d = den;\n  let twos = 0;\n  let fives = 0;\n  while (d % 2n === 0n) {\n    d /= 2n;\n    twos++;\n  }\n  while (d % 5n === 0n) {\n    d /= 5n;\n    fives++;\n  }\n  return d === 1n ? Math.max(twos, fives) : null;\n}\n\n/**\n * The rational `num / den` (`den > 0`), reduced, rounded once to the nearest double.\n *\n * A terminating quotient (`den` = 2^a·5^b) is written out exactly, every digit,\n * and parsed: a tie between two doubles is a dyadic rational, so it always\n * lands here and rounds half to even. Any other quotient is not a tie, and it\n * is at least `1 / (den·2^54)` of its magnitude away from every tie; truncating\n * it to `max(40, digits(den) + 20)` significant digits stays closer than that,\n * and a sticky `1` puts the string strictly inside the truncation interval, so\n * the string rounds the way the quotient does for any denominator.\n */\nfunction rationalToNumber(num: bigint, den: bigint): number {\n  if (num === 0n) return 0;\n  const negative = num < 0n;\n  const g = gcd(num, den);\n  const a = (negative ? -num : num) / g;\n  den /= g;\n  const places = terminatingPlaces(den);\n  if (places !== null) {\n    const value = Number(`${(a * 10n ** BigInt(places)) / den}e-${places}`);\n    return negative ? -value : value;\n  }\n  const digits = Math.max(MIN_DIGITS, den.toString().length + 20);\n  const shift = digits - (a.toString().length - den.toString().length);\n  let q: bigint;\n  if (shift >= 0) {\n    q = (a * 10n ** BigInt(shift)) / den;\n  } else {\n    q = a / (den * 10n ** BigInt(-shift));\n  }\n  // Not terminating, so the remainder is never zero: the sticky digit is always due.\n  const value = Number(`${q.toString()}1e${-(shift + 1)}`);\n  return negative ? -value : value;\n}\n\n/** The scale as a double: the rational rounded once, times the irrational factor. @internal */\nexport function scaleToNumber(s: ExactScale): number {\n  const rational = rationalToNumber(s.num, s.den);\n  return s.irrational === 1 ? rational : rational * s.irrational;\n}\n\nconst FACTOR = /^([^*/^\\s]+)(?:\\^([+-]?\\d+))?$/;\n\n/**\n * The two sides of a unit text or a scale expression under the single-solidus\n * convention of ISO 80000-1: everything after the first `/` is the\n * denominator, so a chain is one denominator (`km/s/Mpc` is km/(s·Mpc), and\n * `W/m*K` is W/(m·K), not (W/m)·K). The denominator comes back as one\n * `*`-joined product, each `/`-part's outer parentheses dropped. `units.ts`\n * and {@link readScaleExpression} both split here, so a unit text and a scale\n * expression in `data/units.json` read a `/` the same way.\n * @internal\n */\nexport function solidusSides(text: string): { readonly numerator: string; readonly denominator: string } {\n  const parts = text.split('/');\n  return {\n    numerator: parts[0]!,\n    denominator: parts\n      .slice(1)\n      .map((part) => part.replace(/^\\((.*)\\)$/, '$1'))\n      .join('*'),\n  };\n}\n\n/**\n * The exact value of a scale expression, the form `data/units.json` stores:\n * factors joined by `*`, then optionally `/` and the denominator's factors,\n * each a decimal literal or a name with an optional integer power\n * (`4.1868*453.59237/1.8`, `pi/180`, `lbf/inch^2`). A `/` follows the unit\n * grammar ({@link solidusSides}): `a/b*c` is a/(b·c). `resolve` gives a name\n * its scale and returns undefined for a name it does not know, which throws\n * here. A decimal literal is read digit for digit, so the result is the\n * rational the text states.\n * @internal\n */\nexport function readScaleExpression(text: string, resolve: (name: string) => ExactScale | undefined): ExactScale {\n  const product = (side: string): ExactScale => {\n    let scale = UNIT_SCALE;\n    for (const part of side.split('*')) {\n      const m = FACTOR.exec(part);\n      if (m === null) throw new RangeError(`exact scale: '${text}' is not a product of factors`);\n      const atom = m[1]!;\n      const base = decimalScale(atom) ?? resolve(atom);\n      if (base === undefined) throw new RangeError(`exact scale: '${text}' names '${atom}', which is not a known scale`);\n      scale = multiplyScales(scale, m[2] === undefined ? base : powerScale(base, Number(m[2])));\n    }\n    return scale;\n  };\n  const trimmed = text.trim();\n  const { numerator, denominator } = solidusSides(trimmed);\n  const top = product(numerator);\n  return trimmed.includes('/') ? divideScales(top, product(denominator)) : top;\n}\n"]}
+{"version":3,"file":"exact-scale.js","sourceRoot":"","sources":["../../src/dimensional/exact-scale.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Exact unit scales.\n *\n * A unit's scale to SI is a rational number times one floating factor that\n * holds its irrational part (π for an angle, ln 2 for a bit). Prefixes,\n * products, quotients and integer powers multiply the rationals exactly, so\n * `g/cm^3` is 1000 and `72 mN/m` is 0.072 with no float noise to round away.\n * The one rounding is {@link scaleToNumber}, which rounds the rational\n * correctly and then multiplies by the irrational factor once.\n *\n * A decimal literal is read digit for digit. A JavaScript number is read\n * through its shortest round-trip decimal (`String(x)`), which is the\n * literal a constant was written with.\n *\n * The arithmetic is MathTS's (`@danielsimonjr/mathts-core`); the UPT\n * {@link ExactScale} shape and function names are the thin layer over it, and\n * a scale expression (`data/units.json`) reads through MathTS\n * `readScaleExpression` under this module's UPT-facing signature.\n *\n * @module dimensional/exact-scale\n * @internal\n */\nimport {\n  addExactScales,\n  decimalExactScale,\n  divideExactScales,\n  exactScaleOf,\n  exactScaleToNumber,\n  LN2_EXACT_SCALE,\n  multiplyExactScales,\n  PI_EXACT_SCALE,\n  powerExactScale,\n  ratioExactScale,\n  readScaleExpression as mathtsReadScaleExpression,\n  type ExactScale as CoreExactScale,\n} from '@danielsimonjr/mathts-core';\nimport { gcd } from '@danielsimonjr/mathts-functions';\nimport { bigintFrom } from '../core/mathts-read.js';\n\n\n/** `num / den × irrational`, with `den > 0` and the fraction in lowest terms. @internal */\nexport interface ExactScale {\n  readonly num: bigint;\n  readonly den: bigint;\n  /** The factor no rational states (π, ln 2). 1 for a rational scale. */\n  readonly irrational: number;\n}\n\n/** The bigint gcd, MathTS `gcd` on its `bigint, bigint` signature, read back as the bigint it is. */\nfunction bigGcd(a: bigint, b: bigint): bigint {\n  const g = bigintFrom('gcd', gcd(a, b));\n  return g < 0n ? -g : g;\n}\n\nfunction make(num: bigint, den: bigint, irrational: number): ExactScale {\n  if (den === 0n) throw new RangeError('exact scale: zero denominator');\n  if (den < 0n) {\n    num = -num;\n    den = -den;\n  }\n  const g = bigGcd(num, den);\n  return g > 1n ? { num: num / g, den: den / g, irrational } : { num, den, irrational };\n}\n\nfunction irrationalFactor(irrationals: CoreExactScale['irrationals']): number {\n  let factor = 1;\n  const pi = irrationals.pi ?? 0;\n  const ln2 = irrationals.ln2 ?? 0;\n  if (pi !== 0) factor *= Math.PI ** pi;\n  if (ln2 !== 0) factor *= Math.LN2 ** ln2;\n  return factor;\n}\n\nfunction fromCore(s: CoreExactScale): ExactScale {\n  return make(s.num, s.den, irrationalFactor(s.irrationals));\n}\n\n/** UPT {@link ExactScale} to the MathTS core shape. @internal */\nexport function coreExactScaleFromUpt(s: ExactScale): CoreExactScale {\n  return toCore(s);\n}\n\n/** MathTS core exact scale to UPT {@link ExactScale}. @internal */\nexport function uptExactScaleFromCore(s: CoreExactScale): ExactScale {\n  return fromCore(s);\n}\n\n/** When `x / base` is a nonzero integer, that integer; otherwise null. */\nfunction integerMultiple(x: number, base: number): bigint | null {\n  if (!Number.isFinite(x) || !Number.isFinite(base) || base === 0 || x === 0) return null;\n  const q = x / base;\n  if (!Number.isFinite(q)) return null;\n  const n = Math.trunc(q);\n  if (n === 0 || q !== n) return null;\n  if (Math.abs(n * base - x) > Math.max(1e-12, Math.abs(x) * 1e-14)) return null;\n  return BigInt(n);\n}\n\n/**\n * When `x` is `base` raised to a small integer power (π⁻¹ for a parsec-scale,\n * ln 2 for a bit), that integer; otherwise null. The factor is compared\n * exactly: `irrationalFactor` built it as `base ** n`, so the same expression\n * reads it back.\n */\nfunction irrationalExponent(x: number, base: number): number | null {\n  if (!Number.isFinite(x) || x <= 0 || !Number.isFinite(base) || base <= 0) return null;\n  for (let n = -8; n <= 8; n++) {\n    if (x === base ** n) return n;\n  }\n  return null;\n}\n\nfunction toCore(s: ExactScale): CoreExactScale {\n  let core = ratioExactScale(s.num, s.den);\n  const ir = s.irrational;\n  if (ir === 1) return core;\n  const piPower = irrationalExponent(ir, Math.PI);\n  if (piPower !== null) return multiplyExactScales(core, powerExactScale(PI_EXACT_SCALE, piPower));\n  const ln2Power = irrationalExponent(ir, Math.LN2);\n  if (ln2Power !== null) return multiplyExactScales(core, powerExactScale(LN2_EXACT_SCALE, ln2Power));\n  const piMultiple = integerMultiple(ir, Math.PI);\n  if (piMultiple !== null) {\n    if (piMultiple !== 1n) core = multiplyExactScales(core, ratioExactScale(piMultiple, 1n));\n    return multiplyExactScales(core, PI_EXACT_SCALE);\n  }\n  const ln2Multiple = integerMultiple(ir, Math.LN2);\n  if (ln2Multiple !== null) {\n    if (ln2Multiple !== 1n) core = multiplyExactScales(core, ratioExactScale(ln2Multiple, 1n));\n    return multiplyExactScales(core, LN2_EXACT_SCALE);\n  }\n  return multiplyExactScales(core, exactScaleOf(ir));\n}\n\n/** The scale 1. @internal */\nexport const UNIT_SCALE: ExactScale = { num: 1n, den: 1n, irrational: 1 };\n\n/**\n * The exact value of a decimal literal (`72`, `0.45359237`, `1.602176634e-19`),\n * or null when `text` is not one.\n * @internal\n */\nexport function decimalScale(text: string): ExactScale | null {\n  const scaled = decimalExactScale(text.trim());\n  return scaled === null ? null : fromCore(scaled);\n}\n\n/** The exact scale a finite JavaScript number was written as. @internal */\nexport function scaleOf(x: number): ExactScale {\n  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);\n  return fromCore(exactScaleOf(x));\n}\n\n/** `num / den`, exactly. @internal */\nexport function ratioScale(num: number | bigint, den: number | bigint): ExactScale {\n  return fromCore(ratioExactScale(num, den));\n}\n\n/** A factor no rational states, such as π or ln 2. @internal */\nexport function irrationalScale(x: number): ExactScale {\n  if (!Number.isFinite(x)) throw new RangeError(`exact scale: ${x} is not finite`);\n  return { num: 1n, den: 1n, irrational: x };\n}\n\n/** `a × b × …`. @internal */\nexport function multiplyScales(...factors: readonly ExactScale[]): ExactScale {\n  if (factors.length === 0) return UNIT_SCALE;\n  return fromCore(multiplyExactScales(...factors.map(toCore)));\n}\n\n/** `a / b`. @internal */\nexport function divideScales(a: ExactScale, b: ExactScale): ExactScale {\n  return fromCore(divideExactScales(toCore(a), toCore(b)));\n}\n\n/**\n * `a ^ n`. An integer power stays exact. A fractional power has no exact\n * rational in general and throws.\n * @internal\n */\nexport function powerScale(a: ExactScale, n: number): ExactScale {\n  if (!Number.isInteger(n)) throw new RangeError(`exact scale: power ${n} is not an integer`);\n  return fromCore(powerExactScale(toCore(a), n));\n}\n\n/** `a + b`: exact when both are rational multiples of the same irrational factor. @internal */\nexport function addScales(a: ExactScale, b: ExactScale): ExactScale {\n  const sum = addExactScales(toCore(a), toCore(b));\n  if (sum === null) throw new RangeError('exact scale: unlike irrational factors');\n  return fromCore(sum);\n}\n\n/** The scale as a double: the rational rounded once, times the irrational factor. @internal */\nexport function scaleToNumber(s: ExactScale): number {\n  return exactScaleToNumber(toCore(s));\n}\n\n/**\n * The two sides of a unit text under the single-solidus convention of\n * ISO 80000-1: everything after the first `/` is the denominator, so a chain\n * is one denominator (`km/s/Mpc` is km/(s·Mpc), and `W/m*K` is W/(m·K), not\n * (W/m)·K). The denominator comes back as one `*`-joined product, each\n * `/`-part's outer parentheses dropped. `units.ts` splits here, so a unit text\n * reads a `/` the same way a scale expression does. MathTS states the same\n * rule inside its `readScaleExpression` and does not export the split.\n * @internal\n */\nexport function solidusSides(text: string): { readonly numerator: string; readonly denominator: string } {\n  const parts = text.split('/');\n  return {\n    numerator: parts[0]!,\n    denominator: parts\n      .slice(1)\n      .map((part) => part.replace(/^\\((.*)\\)$/, '$1'))\n      .join('*'),\n  };\n}\n\n/**\n * The exact value of a scale expression, the form `data/units.json` stores:\n * factors joined by `*`, then optionally `/` and the denominator's factors,\n * each a decimal literal or a name with an optional integer power\n * (`4.1868*453.59237/1.8`, `pi/180`, `lbf/inch^2`). A `/` follows the unit\n * grammar ({@link solidusSides}): `a/b*c` is a/(b·c). `resolve` gives a name\n * its scale and returns undefined for a name it does not know, which throws.\n * A decimal literal is read digit for digit, so the result is the rational the\n * text states.\n *\n * MathTS's `readScaleExpression` is the reader; this is the UPT-facing\n * signature over it, the one adapter between its exact scale and UPT's.\n * @internal\n */\nexport function readScaleExpression(text: string, resolve: (name: string) => ExactScale | undefined): ExactScale {\n  return uptExactScaleFromCore(\n    mathtsReadScaleExpression(text.trim(), (name) => {\n      const scale = resolve(name);\n      return scale === undefined ? undefined : coreExactScaleFromUpt(scale);\n    }),\n  );\n}\n"]}

package/dist/dimensional/gauge-field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gauge-field.d.ts","sourceRoot":"","sources":["../../src/dimensional/gauge-field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,yBAAyB;IACxC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CA0B7D;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,yBAAyB,GAC9B,qCAAqC,CAkDvC"}
+{"version":3,"file":"gauge-field.d.ts","sourceRoot":"","sources":["../../src/dimensional/gauge-field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQ5C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,yBAAyB;IACxC,kDAAkD;IAClD,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAyB7D;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IACpD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,yBAAyB,GAC9B,qCAAqC,CAkDvC"}

package/dist/dimensional/gauge-field.js

@@ -38,6 +38,7 @@
  * @see docs/architecture/archive/v0.7-be-x-reencoding-design-note.md §BE-50
  * @module dimensional/gauge-field
  */
+import { BASES } from './algebra.js';
 import { validateComponentDimension } from './field-equation-helpers.js';
 // ---------------------------------------------------------------------------
 // Validators
@@ -66,8 +67,7 @@ export function validateGaugeField(node) {
             `or 'symmetric' (got ${JSON.stringify(node.arrowOfTime)}).`);
     }
     const dim = node.dim;
-    const axes = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'];
-    for (const ax of axes) {
+    for (const ax of BASES) {
         if (typeof dim[ax] !== 'number' || !Number.isFinite(dim[ax])) {
             throw new Error(`GaugeFieldNode: gauge-field dim.${ax} must be a finite number ` +
                 `(got ${JSON.stringify(dim[ax])} for field '${node.name}').`);

package/dist/dimensional/gauge-field.js.map

@@ -1 +1 @@
-{"version":3,"file":"gauge-field.js","sourceRoot":"","sources":["../../src/dimensional/gauge-field.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gauge-field AST primitives for Wheeler-Feynman absorber-theory\n * time-symmetric electrodynamics.\n *\n * Wheeler-Feynman absorber theory (Wheeler & Feynman 1945\n * Rev. Mod. Phys. 17:157; Wheeler & Feynman 1949\n * Rev. Mod. Phys. 21:425) uses TIME-SYMMETRIC electrodynamics:\n * radiation reaction arises from the half-retarded +\n * half-advanced potential combination\n *\n *   A_μ(x) = (1/2) [A_μ^ret(x) + A_μ^adv(x)].\n *\n * Under the absorber boundary condition (every emitted disturbance\n * is fully absorbed by future matter), this symmetric form is\n * physically equivalent to retarded-only Maxwell.\n *\n * Two primitives are provided:\n *\n *   1. `GaugeFieldNode` — tags an EM gauge field with its\n *      \"arrow of time\": retarded (Liénard-Wiechert advanced\n *      Green's function), advanced (retarded Green's function\n *      — past-directed), or symmetric (half-half combination).\n *      The consumer supplies the dimension (SI: V·s/m =\n *      { L:1, M:1, T:-2, I:-1 }) or works with the ratio which\n *      is dimensionless.\n *\n *   2. `TimeSymmetryPredicateNode` — asserts that the\n *      dimensionless time-symmetry residual\n *      |A_ret − A_adv| / |A_ret + A_adv| is bounded by ε.\n *      Identically 0 under the absorber boundary condition.\n *      This is a PREDICATE node (like `EinsteinFieldEquationNode`)\n *      — not a value-producing expression.\n *\n * Phase 1 demonstrator pattern: follows\n * `src/dimensional/klein-gordon-equation.ts` (field-equation-helpers\n * pattern, Phase 1 of TensorEquationNode generalization).\n *\n * @see docs/architecture/archive/v0.7-be-x-reencoding-design-note.md §BE-50\n * @module dimensional/gauge-field\n */\n\nimport type { Dimension } from './types.js';\nimport { validateComponentDimension } from './field-equation-helpers.js';\n\n// ---------------------------------------------------------------------------\n// GaugeFieldNode\n// ---------------------------------------------------------------------------\n\n/**\n * Arrow-of-time tag for an electromagnetic gauge potential.\n *\n * - `'retarded'`  — propagator uses the retarded Green's function\n *   (∝ Liénard-Wiechert advanced solution); causal, future-directed.\n * - `'advanced'`  — propagator uses the advanced Green's function\n *   (∝ Liénard-Wiechert retarded solution); anti-causal, past-directed.\n * - `'symmetric'` — half-retarded + half-advanced combination\n *   (Wheeler-Feynman's A_μ = (1/2)[A_μ^ret + A_μ^adv]).\n *\n * @public\n */\nexport type ArrowOfTime = 'retarded' | 'advanced' | 'symmetric';\n\n/**\n * AST node for an electromagnetic gauge potential A_μ with an explicit\n * arrow-of-time tag.\n *\n * The `dim` field carries the SI dimension of the gauge field. For the\n * Wheeler-Feynman time-symmetry ratio, the dimension of the numerator\n * and denominator cancel, yielding a dimensionless result — but the\n * `dim` field is required so the validator can confirm that both the\n * retarded and advanced fields in a `TimeSymmetryPredicateNode` share\n * the same dimension (the ratio is well-defined only if they do).\n *\n * Canonical SI dim of the magnetic vector potential A_μ:\n *   [A] = V·s/m = kg·m/(A·s²) = { L: 1, M: 1, T: -2, I: -1 }\n *\n * @public\n */\nexport interface GaugeFieldNode {\n  /** Discriminator: `'gauge-field'`. */\n  readonly kind: 'gauge-field';\n  /** Human-readable field name (e.g., `'A_ret'`, `'A_adv'`, `'A_mu'`). */\n  readonly name: string;\n  /**\n   * Arrow-of-time tag. Documents whether this field was computed using\n   * the retarded Green's function, the advanced Green's function, or\n   * the symmetric half-half combination.\n   */\n  readonly arrowOfTime: ArrowOfTime;\n  /**\n   * SI dimension of the gauge field. Both retarded and advanced fields\n   * must share the same dimension for the time-symmetry ratio to be\n   * well-defined (dimensionless by cancellation).\n   */\n  readonly dim: Dimension;\n}\n\n// ---------------------------------------------------------------------------\n// TimeSymmetryPredicateNode\n// ---------------------------------------------------------------------------\n\n/**\n * AST predicate node for the Wheeler-Feynman time-symmetry condition.\n *\n * Asserts that the dimensionless time-symmetry residual\n *\n *   |A_ret − A_adv| / |A_ret + A_adv| ≤ ε\n *\n * is bounded by `epsilon`. Under the absorber boundary condition\n * (Wheeler & Feynman 1945), this residual is identically 0 on\n * physical states. A non-zero `epsilon` documents the allowable\n * deviation (e.g., a Cramer 1986 experimental bound of 10⁻²).\n *\n * This is a PREDICATE node (like `EinsteinFieldEquationNode`) —\n * not a value-producing expression. Numerical evaluation of the\n * residual for specific field amplitudes is out of scope; the catalog\n * relation be-50 that consumes this node has no numerical evaluator.\n *\n * @public\n */\nexport interface TimeSymmetryPredicateNode {\n  /** Discriminator: `'time-symmetry-predicate'`. */\n  readonly kind: 'time-symmetry-predicate';\n  /**\n   * The retarded gauge potential A_μ^ret.\n   * Must have `arrowOfTime: 'retarded'`.\n   */\n  readonly retarded: GaugeFieldNode;\n  /**\n   * The advanced gauge potential A_μ^adv.\n   * Must have `arrowOfTime: 'advanced'`.\n   */\n  readonly advanced: GaugeFieldNode;\n  /**\n   * Bound on the time-symmetry residual: |A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.\n   * Must be strictly positive and finite.\n   * Set to a small value (e.g., 1e-3) to encode an experimental bound,\n   * or to `Number.EPSILON` to assert near-exact absorber-theory symmetry.\n   */\n  readonly epsilon: number;\n}\n\n// ---------------------------------------------------------------------------\n// Validators\n// ---------------------------------------------------------------------------\n\n/**\n * Validate a `GaugeFieldNode`.\n *\n * Three predicates:\n *   1. `name` must be a non-empty string.\n *   2. `arrowOfTime` must be one of `'retarded'`, `'advanced'`, `'symmetric'`.\n *   3. `dim` must be a valid `Dimension` object (all 7 SI exponents present\n *      as finite numbers).\n *\n * Throws `Error` with `'gauge-field'` in the message on any failure.\n *\n * @public\n */\nexport function validateGaugeField(node: GaugeFieldNode): void {\n  if (typeof node.name !== 'string' || node.name.trim().length === 0) {\n    throw new Error(\n      `GaugeFieldNode: gauge-field name must be a non-empty string ` +\n      `(got ${JSON.stringify(node.name)}).`,\n    );\n  }\n\n  const validArrows: ReadonlyArray<ArrowOfTime> = ['retarded', 'advanced', 'symmetric'];\n  if (!validArrows.includes(node.arrowOfTime)) {\n    throw new Error(\n      `GaugeFieldNode: gauge-field arrowOfTime must be 'retarded', 'advanced', ` +\n      `or 'symmetric' (got ${JSON.stringify(node.arrowOfTime)}).`,\n    );\n  }\n\n  const dim = node.dim;\n  const axes: ReadonlyArray<keyof Dimension> = ['L', 'M', 'T', 'I', 'Theta', 'N', 'J'];\n  for (const ax of axes) {\n    if (typeof dim[ax] !== 'number' || !Number.isFinite(dim[ax])) {\n      throw new Error(\n        `GaugeFieldNode: gauge-field dim.${ax} must be a finite number ` +\n        `(got ${JSON.stringify(dim[ax])} for field '${node.name}').`,\n      );\n    }\n  }\n}\n\n/**\n * Result of validating a `TimeSymmetryPredicateNode`.\n *\n * @public\n */\nexport interface TimeSymmetryPredicateValidationResult {\n  /**\n   * The shared dimension of the retarded and advanced gauge fields.\n   * The ratio |A_ret − A_adv| / |A_ret + A_adv| is dimensionless\n   * because this dimension cancels.\n   */\n  readonly fieldDim: Dimension;\n  /** The validated epsilon bound (> 0, finite). */\n  readonly epsilon: number;\n}\n\n/**\n * Validate a `TimeSymmetryPredicateNode`.\n *\n * Four predicates (following the field-equation-helpers pattern):\n *\n *   1. **Arrow-of-time tags** — `retarded.arrowOfTime` must be\n *      `'retarded'`; `advanced.arrowOfTime` must be `'advanced'`.\n *   2. **Per-field validity** — both `GaugeFieldNode`s pass\n *      `validateGaugeField`.\n *   3. **Dimension equality** — `retarded.dim` and `advanced.dim`\n *      must match (so the ratio is dimensionless by cancellation).\n *      Uses `validateComponentDimension` from field-equation-helpers.\n *   4. **Epsilon bound** — `epsilon` must be strictly positive and\n *      finite (`epsilon > 0` and `Number.isFinite(epsilon)`).\n *\n * Error messages contain `'symmetry'` for arrow-of-time mismatches\n * and `'dimension'` for dim-equality failures (error-keyword\n * discipline shared with EinsteinFieldEquationNode and\n * KleinGordonEquationNode).\n *\n * @public\n */\nexport function validateTimeSymmetryPredicate(\n  node: TimeSymmetryPredicateNode,\n): TimeSymmetryPredicateValidationResult {\n  // Predicate 1a: retarded field's arrow-of-time must be 'retarded'.\n  if (node.retarded.arrowOfTime !== 'retarded') {\n    throw new Error(\n      `TimeSymmetryPredicateNode: symmetry mismatch — retarded field ` +\n      `'${node.retarded.name}' must have arrowOfTime: 'retarded' ` +\n      `(got '${node.retarded.arrowOfTime}'). The time-symmetry predicate ` +\n      `requires A_ret to carry the retarded arrow-of-time tag.`,\n    );\n  }\n\n  // Predicate 1b: advanced field's arrow-of-time must be 'advanced'.\n  if (node.advanced.arrowOfTime !== 'advanced') {\n    throw new Error(\n      `TimeSymmetryPredicateNode: symmetry mismatch — advanced field ` +\n      `'${node.advanced.name}' must have arrowOfTime: 'advanced' ` +\n      `(got '${node.advanced.arrowOfTime}'). The time-symmetry predicate ` +\n      `requires A_adv to carry the advanced arrow-of-time tag.`,\n    );\n  }\n\n  // Predicate 2: both GaugeFieldNodes pass individual validation.\n  validateGaugeField(node.retarded);\n  validateGaugeField(node.advanced);\n\n  // Predicate 3: retarded.dim and advanced.dim must match.\n  // Uses validateComponentDimension from field-equation-helpers — same\n  // helper used by KleinGordonEquationNode and EinsteinFieldEquationNode.\n  validateComponentDimension(\n    'TimeSymmetryPredicateNode',\n    `advanced field '${node.advanced.name}' dim`,\n    node.advanced.dim,\n    node.retarded.dim,\n    `A_ret and A_adv must share the same dimension so that the ratio ` +\n    `|A_ret − A_adv| / |A_ret + A_adv| is dimensionless by cancellation.`,\n  );\n\n  // Predicate 4: epsilon must be strictly positive and finite.\n  if (!Number.isFinite(node.epsilon) || node.epsilon <= 0) {\n    throw new Error(\n      `TimeSymmetryPredicateNode: epsilon must be a strictly positive finite ` +\n      `number (got ${node.epsilon}). epsilon bounds the time-symmetry residual ` +\n      `|A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.`,\n    );\n  }\n\n  return {\n    fieldDim: node.retarded.dim,\n    epsilon: node.epsilon,\n  };\n}\n"]}
+{"version":3,"file":"gauge-field.js","sourceRoot":"","sources":["../../src/dimensional/gauge-field.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Gauge-field AST primitives for Wheeler-Feynman absorber-theory\n * time-symmetric electrodynamics.\n *\n * Wheeler-Feynman absorber theory (Wheeler & Feynman 1945\n * Rev. Mod. Phys. 17:157; Wheeler & Feynman 1949\n * Rev. Mod. Phys. 21:425) uses TIME-SYMMETRIC electrodynamics:\n * radiation reaction arises from the half-retarded +\n * half-advanced potential combination\n *\n *   A_μ(x) = (1/2) [A_μ^ret(x) + A_μ^adv(x)].\n *\n * Under the absorber boundary condition (every emitted disturbance\n * is fully absorbed by future matter), this symmetric form is\n * physically equivalent to retarded-only Maxwell.\n *\n * Two primitives are provided:\n *\n *   1. `GaugeFieldNode` — tags an EM gauge field with its\n *      \"arrow of time\": retarded (Liénard-Wiechert advanced\n *      Green's function), advanced (retarded Green's function\n *      — past-directed), or symmetric (half-half combination).\n *      The consumer supplies the dimension (SI: V·s/m =\n *      { L:1, M:1, T:-2, I:-1 }) or works with the ratio which\n *      is dimensionless.\n *\n *   2. `TimeSymmetryPredicateNode` — asserts that the\n *      dimensionless time-symmetry residual\n *      |A_ret − A_adv| / |A_ret + A_adv| is bounded by ε.\n *      Identically 0 under the absorber boundary condition.\n *      This is a PREDICATE node (like `EinsteinFieldEquationNode`)\n *      — not a value-producing expression.\n *\n * Phase 1 demonstrator pattern: follows\n * `src/dimensional/klein-gordon-equation.ts` (field-equation-helpers\n * pattern, Phase 1 of TensorEquationNode generalization).\n *\n * @see docs/architecture/archive/v0.7-be-x-reencoding-design-note.md §BE-50\n * @module dimensional/gauge-field\n */\n\nimport type { Dimension } from './types.js';\nimport { BASES } from './algebra.js';\nimport { validateComponentDimension } from './field-equation-helpers.js';\n\n// ---------------------------------------------------------------------------\n// GaugeFieldNode\n// ---------------------------------------------------------------------------\n\n/**\n * Arrow-of-time tag for an electromagnetic gauge potential.\n *\n * - `'retarded'`  — propagator uses the retarded Green's function\n *   (∝ Liénard-Wiechert advanced solution); causal, future-directed.\n * - `'advanced'`  — propagator uses the advanced Green's function\n *   (∝ Liénard-Wiechert retarded solution); anti-causal, past-directed.\n * - `'symmetric'` — half-retarded + half-advanced combination\n *   (Wheeler-Feynman's A_μ = (1/2)[A_μ^ret + A_μ^adv]).\n *\n * @public\n */\nexport type ArrowOfTime = 'retarded' | 'advanced' | 'symmetric';\n\n/**\n * AST node for an electromagnetic gauge potential A_μ with an explicit\n * arrow-of-time tag.\n *\n * The `dim` field carries the SI dimension of the gauge field. For the\n * Wheeler-Feynman time-symmetry ratio, the dimension of the numerator\n * and denominator cancel, yielding a dimensionless result — but the\n * `dim` field is required so the validator can confirm that both the\n * retarded and advanced fields in a `TimeSymmetryPredicateNode` share\n * the same dimension (the ratio is well-defined only if they do).\n *\n * Canonical SI dim of the magnetic vector potential A_μ:\n *   [A] = V·s/m = kg·m/(A·s²) = { L: 1, M: 1, T: -2, I: -1 }\n *\n * @public\n */\nexport interface GaugeFieldNode {\n  /** Discriminator: `'gauge-field'`. */\n  readonly kind: 'gauge-field';\n  /** Human-readable field name (e.g., `'A_ret'`, `'A_adv'`, `'A_mu'`). */\n  readonly name: string;\n  /**\n   * Arrow-of-time tag. Documents whether this field was computed using\n   * the retarded Green's function, the advanced Green's function, or\n   * the symmetric half-half combination.\n   */\n  readonly arrowOfTime: ArrowOfTime;\n  /**\n   * SI dimension of the gauge field. Both retarded and advanced fields\n   * must share the same dimension for the time-symmetry ratio to be\n   * well-defined (dimensionless by cancellation).\n   */\n  readonly dim: Dimension;\n}\n\n// ---------------------------------------------------------------------------\n// TimeSymmetryPredicateNode\n// ---------------------------------------------------------------------------\n\n/**\n * AST predicate node for the Wheeler-Feynman time-symmetry condition.\n *\n * Asserts that the dimensionless time-symmetry residual\n *\n *   |A_ret − A_adv| / |A_ret + A_adv| ≤ ε\n *\n * is bounded by `epsilon`. Under the absorber boundary condition\n * (Wheeler & Feynman 1945), this residual is identically 0 on\n * physical states. A non-zero `epsilon` documents the allowable\n * deviation (e.g., a Cramer 1986 experimental bound of 10⁻²).\n *\n * This is a PREDICATE node (like `EinsteinFieldEquationNode`) —\n * not a value-producing expression. Numerical evaluation of the\n * residual for specific field amplitudes is out of scope; the catalog\n * relation be-50 that consumes this node has no numerical evaluator.\n *\n * @public\n */\nexport interface TimeSymmetryPredicateNode {\n  /** Discriminator: `'time-symmetry-predicate'`. */\n  readonly kind: 'time-symmetry-predicate';\n  /**\n   * The retarded gauge potential A_μ^ret.\n   * Must have `arrowOfTime: 'retarded'`.\n   */\n  readonly retarded: GaugeFieldNode;\n  /**\n   * The advanced gauge potential A_μ^adv.\n   * Must have `arrowOfTime: 'advanced'`.\n   */\n  readonly advanced: GaugeFieldNode;\n  /**\n   * Bound on the time-symmetry residual: |A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.\n   * Must be strictly positive and finite.\n   * Set to a small value (e.g., 1e-3) to encode an experimental bound,\n   * or to `Number.EPSILON` to assert near-exact absorber-theory symmetry.\n   */\n  readonly epsilon: number;\n}\n\n// ---------------------------------------------------------------------------\n// Validators\n// ---------------------------------------------------------------------------\n\n/**\n * Validate a `GaugeFieldNode`.\n *\n * Three predicates:\n *   1. `name` must be a non-empty string.\n *   2. `arrowOfTime` must be one of `'retarded'`, `'advanced'`, `'symmetric'`.\n *   3. `dim` must be a valid `Dimension` object (all 7 SI exponents present\n *      as finite numbers).\n *\n * Throws `Error` with `'gauge-field'` in the message on any failure.\n *\n * @public\n */\nexport function validateGaugeField(node: GaugeFieldNode): void {\n  if (typeof node.name !== 'string' || node.name.trim().length === 0) {\n    throw new Error(\n      `GaugeFieldNode: gauge-field name must be a non-empty string ` +\n      `(got ${JSON.stringify(node.name)}).`,\n    );\n  }\n\n  const validArrows: ReadonlyArray<ArrowOfTime> = ['retarded', 'advanced', 'symmetric'];\n  if (!validArrows.includes(node.arrowOfTime)) {\n    throw new Error(\n      `GaugeFieldNode: gauge-field arrowOfTime must be 'retarded', 'advanced', ` +\n      `or 'symmetric' (got ${JSON.stringify(node.arrowOfTime)}).`,\n    );\n  }\n\n  const dim = node.dim;\n  for (const ax of BASES) {\n    if (typeof dim[ax] !== 'number' || !Number.isFinite(dim[ax])) {\n      throw new Error(\n        `GaugeFieldNode: gauge-field dim.${ax} must be a finite number ` +\n        `(got ${JSON.stringify(dim[ax])} for field '${node.name}').`,\n      );\n    }\n  }\n}\n\n/**\n * Result of validating a `TimeSymmetryPredicateNode`.\n *\n * @public\n */\nexport interface TimeSymmetryPredicateValidationResult {\n  /**\n   * The shared dimension of the retarded and advanced gauge fields.\n   * The ratio |A_ret − A_adv| / |A_ret + A_adv| is dimensionless\n   * because this dimension cancels.\n   */\n  readonly fieldDim: Dimension;\n  /** The validated epsilon bound (> 0, finite). */\n  readonly epsilon: number;\n}\n\n/**\n * Validate a `TimeSymmetryPredicateNode`.\n *\n * Four predicates (following the field-equation-helpers pattern):\n *\n *   1. **Arrow-of-time tags** — `retarded.arrowOfTime` must be\n *      `'retarded'`; `advanced.arrowOfTime` must be `'advanced'`.\n *   2. **Per-field validity** — both `GaugeFieldNode`s pass\n *      `validateGaugeField`.\n *   3. **Dimension equality** — `retarded.dim` and `advanced.dim`\n *      must match (so the ratio is dimensionless by cancellation).\n *      Uses `validateComponentDimension` from field-equation-helpers.\n *   4. **Epsilon bound** — `epsilon` must be strictly positive and\n *      finite (`epsilon > 0` and `Number.isFinite(epsilon)`).\n *\n * Error messages contain `'symmetry'` for arrow-of-time mismatches\n * and `'dimension'` for dim-equality failures (error-keyword\n * discipline shared with EinsteinFieldEquationNode and\n * KleinGordonEquationNode).\n *\n * @public\n */\nexport function validateTimeSymmetryPredicate(\n  node: TimeSymmetryPredicateNode,\n): TimeSymmetryPredicateValidationResult {\n  // Predicate 1a: retarded field's arrow-of-time must be 'retarded'.\n  if (node.retarded.arrowOfTime !== 'retarded') {\n    throw new Error(\n      `TimeSymmetryPredicateNode: symmetry mismatch — retarded field ` +\n      `'${node.retarded.name}' must have arrowOfTime: 'retarded' ` +\n      `(got '${node.retarded.arrowOfTime}'). The time-symmetry predicate ` +\n      `requires A_ret to carry the retarded arrow-of-time tag.`,\n    );\n  }\n\n  // Predicate 1b: advanced field's arrow-of-time must be 'advanced'.\n  if (node.advanced.arrowOfTime !== 'advanced') {\n    throw new Error(\n      `TimeSymmetryPredicateNode: symmetry mismatch — advanced field ` +\n      `'${node.advanced.name}' must have arrowOfTime: 'advanced' ` +\n      `(got '${node.advanced.arrowOfTime}'). The time-symmetry predicate ` +\n      `requires A_adv to carry the advanced arrow-of-time tag.`,\n    );\n  }\n\n  // Predicate 2: both GaugeFieldNodes pass individual validation.\n  validateGaugeField(node.retarded);\n  validateGaugeField(node.advanced);\n\n  // Predicate 3: retarded.dim and advanced.dim must match.\n  // Uses validateComponentDimension from field-equation-helpers — same\n  // helper used by KleinGordonEquationNode and EinsteinFieldEquationNode.\n  validateComponentDimension(\n    'TimeSymmetryPredicateNode',\n    `advanced field '${node.advanced.name}' dim`,\n    node.advanced.dim,\n    node.retarded.dim,\n    `A_ret and A_adv must share the same dimension so that the ratio ` +\n    `|A_ret − A_adv| / |A_ret + A_adv| is dimensionless by cancellation.`,\n  );\n\n  // Predicate 4: epsilon must be strictly positive and finite.\n  if (!Number.isFinite(node.epsilon) || node.epsilon <= 0) {\n    throw new Error(\n      `TimeSymmetryPredicateNode: epsilon must be a strictly positive finite ` +\n      `number (got ${node.epsilon}). epsilon bounds the time-symmetry residual ` +\n      `|A_ret − A_adv| / |A_ret + A_adv| ≤ epsilon.`,\n    );\n  }\n\n  return {\n    fieldDim: node.retarded.dim,\n    epsilon: node.epsilon,\n  };\n}\n"]}

package/dist/dimensional/hyphen-names.d.ts

@@ -1,13 +1,23 @@
 /**
  * Kebab catalog names are one token. A parser that treats `-` as subtraction
- * splits them. Longest match first, so a longer declared name wins over a
- * shorter one that is its suffix.
+ * splits them. Leftmost longest match, so a longer declared name or constant
+ * spelling wins over a shorter one inside it.
  *
  * @module dimensional/hyphen-names
  */
+/** `s` with every regular-expression metacharacter escaped, so it matches itself. @internal */
+export declare function escapeRegExp(s: string): string;
 /**
  * Rewrite declared kebab-case names to underscores. Names without a hyphen
  * stay. A hyphen that is not a declared name stays subtraction.
+ *
+ * Each hyphenated word is scanned left to right, segment by segment; at each
+ * segment the longest run of segments that is a declared name (written with
+ * underscores) or a registered constant's hyphenated spelling (written as the
+ * constant's primary name: `speed-of-light` is `c`) is taken, a declared name
+ * before a constant spelling of the same length. So a declared name inside a
+ * longer constant spelling does not win: `reduced-planck-constant` is `hbar`,
+ * not `reduced - planck_constant`.
  */
 export declare function rewriteCatalogHyphens(text: string, catalogNames: ReadonlySet<string> | Iterable<string>): string;
 //# sourceMappingURL=hyphen-names.d.ts.map

package/dist/dimensional/hyphen-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hyphen-names.d.ts","sourceRoot":"","sources":["../../src/dimensional/hyphen-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAQH;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GACnD,MAAM,CAkBR"}
+{"version":3,"file":"hyphen-names.d.ts","sourceRoot":"","sources":["../../src/dimensional/hyphen-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,GACnD,MAAM,CAGR"}

package/dist/dimensional/hyphen-names.js

@@ -1,35 +1,60 @@
 /**
  * Kebab catalog names are one token. A parser that treats `-` as subtraction
- * splits them. Longest match first, so a longer declared name wins over a
- * shorter one that is its suffix.
+ * splits them. Leftmost longest match, so a longer declared name or constant
+ * spelling wins over a shorter one inside it.
  *
  * @module dimensional/hyphen-names
  */
 import { constantRecord } from './symbolic-constants.js';
-function escapeRegExp(s) {
+/** `s` with every regular-expression metacharacter escaped, so it matches itself. @internal */
+export function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/** A hyphenated spelling a registered constant could have: letters and digits, no underscore. */
+const CONSTANT_SPELLING = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+$/;
 /**
  * Rewrite declared kebab-case names to underscores. Names without a hyphen
  * stay. A hyphen that is not a declared name stays subtraction.
+ *
+ * Each hyphenated word is scanned left to right, segment by segment; at each
+ * segment the longest run of segments that is a declared name (written with
+ * underscores) or a registered constant's hyphenated spelling (written as the
+ * constant's primary name: `speed-of-light` is `c`) is taken, a declared name
+ * before a constant spelling of the same length. So a declared name inside a
+ * longer constant spelling does not win: `reduced-planck-constant` is `hbar`,
+ * not `reduced - planck_constant`.
  */
 export function rewriteCatalogHyphens(text, catalogNames) {
-    const names = [...catalogNames]
-        .filter((n) => n.includes('-'))
-        .sort((a, b) => b.length - a.length || a.localeCompare(b));
-    let out = text;
-    for (const name of names) {
-        const underscored = name.replace(/-/g, '_');
-        const re = new RegExp(`(?<![A-Za-z0-9_])${escapeRegExp(name)}(?![A-Za-z0-9_])`, 'g');
-        out = out.replace(re, underscored);
+    const declared = new Set([...catalogNames].filter((n) => n.includes('-')));
+    return text.replace(/[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)+/g, (word) => rewriteWord(word, declared));
+}
+/** One hyphenated word, rewritten by the leftmost-longest segment scan. */
+function rewriteWord(word, declared) {
+    const segments = word.split('-');
+    const out = [];
+    let i = 0;
+    while (i < segments.length) {
+        let taken;
+        for (let end = segments.length; end > i + 1 && taken === undefined; end--) {
+            const candidate = segments.slice(i, end).join('-');
+            if (declared.has(candidate)) {
+                taken = { end, token: candidate.replace(/-/g, '_') };
+            }
+            else if (CONSTANT_SPELLING.test(candidate)) {
+                const record = constantRecord(candidate);
+                if (record !== undefined)
+                    taken = { end, token: record.name };
+            }
+        }
+        if (taken === undefined) {
+            out.push(segments[i]);
+            i += 1;
+        }
+        else {
+            out.push(taken.token);
+            i = taken.end;
+        }
     }
-    // A hyphenated spelling of a registered constant (`speed-of-light`) is that constant, by its
-    // primary name (`c`), whether or not the caller declared it: the formula then reads the baked
-    // value, and the hyphens are not subtractions.
-    out = out.replace(/(?<![A-Za-z0-9_])[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+(?![A-Za-z0-9_])/g, (word) => {
-        const record = constantRecord(word);
-        return record === undefined ? word : record.name;
-    });
-    return out;
+    return out.join('-');
 }
 //# sourceMappingURL=hyphen-names.js.map

package/dist/dimensional/hyphen-names.js.map

@@ -1 +1 @@
-{"version":3,"file":"hyphen-names.js","sourceRoot":"","sources":["../../src/dimensional/hyphen-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY,EACZ,YAAoD;IAEpD,MAAM,KAAK,GAAG,CAAC,GAAG,YAAY,CAAC;SAC5B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;SAC9B,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,GAAG,GAAG,IAAI,CAAC;IACf,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC5C,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,oBAAoB,YAAY,CAAC,IAAI,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;QACrF,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IACD,6FAA6F;IAC7F,8FAA8F;IAC9F,+CAA+C;IAC/C,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,0EAA0E,EAAE,CAAC,IAAI,EAAE,EAAE;QACrG,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;QACpC,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC;IACnD,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * Kebab catalog names are one token. A parser that treats `-` as subtraction\n * splits them. Longest match first, so a longer declared name wins over a\n * shorter one that is its suffix.\n *\n * @module dimensional/hyphen-names\n */\n\nimport { constantRecord } from './symbolic-constants.js';\n\nfunction escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Rewrite declared kebab-case names to underscores. Names without a hyphen\n * stay. A hyphen that is not a declared name stays subtraction.\n */\nexport function rewriteCatalogHyphens(\n  text: string,\n  catalogNames: ReadonlySet<string> | Iterable<string>,\n): string {\n  const names = [...catalogNames]\n    .filter((n) => n.includes('-'))\n    .sort((a, b) => b.length - a.length || a.localeCompare(b));\n  let out = text;\n  for (const name of names) {\n    const underscored = name.replace(/-/g, '_');\n    const re = new RegExp(`(?<![A-Za-z0-9_])${escapeRegExp(name)}(?![A-Za-z0-9_])`, 'g');\n    out = out.replace(re, underscored);\n  }\n  // A hyphenated spelling of a registered constant (`speed-of-light`) is that constant, by its\n  // primary name (`c`), whether or not the caller declared it: the formula then reads the baked\n  // value, and the hyphens are not subtractions.\n  out = out.replace(/(?<![A-Za-z0-9_])[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+(?![A-Za-z0-9_])/g, (word) => {\n    const record = constantRecord(word);\n    return record === undefined ? word : record.name;\n  });\n  return out;\n}\n"]}
+{"version":3,"file":"hyphen-names.js","sourceRoot":"","sources":["../../src/dimensional/hyphen-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,+FAA+F;AAC/F,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED,iGAAiG;AACjG,MAAM,iBAAiB,GAAG,0CAA0C,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY,EACZ,YAAoD;IAEpD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAC3E,OAAO,IAAI,CAAC,OAAO,CAAC,mCAAmC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;AAClG,CAAC;AAED,2EAA2E;AAC3E,SAAS,WAAW,CAAC,IAAY,EAAE,QAA6B;IAC9D,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAmE,CAAC;QACxE,KAAK,IAAI,GAAG,GAAG,QAAQ,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,KAAK,KAAK,SAAS,EAAE,GAAG,EAAE,EAAE,CAAC;YAC1E,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACnD,IAAI,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC5B,KAAK,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;YACvD,CAAC;iBAAM,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;gBAC7C,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC;gBACzC,IAAI,MAAM,KAAK,SAAS;oBAAE,KAAK,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;YAChE,CAAC;QACH,CAAC;QACD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAE,CAAC,CAAC;YACvB,CAAC,IAAI,CAAC,CAAC;QACT,CAAC;aAAM,CAAC;YACN,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtB,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC;QAChB,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACvB,CAAC","sourcesContent":["/**\n * Kebab catalog names are one token. A parser that treats `-` as subtraction\n * splits them. Leftmost longest match, so a longer declared name or constant\n * spelling wins over a shorter one inside it.\n *\n * @module dimensional/hyphen-names\n */\n\nimport { constantRecord } from './symbolic-constants.js';\n\n/** `s` with every regular-expression metacharacter escaped, so it matches itself. @internal */\nexport function escapeRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/** A hyphenated spelling a registered constant could have: letters and digits, no underscore. */\nconst CONSTANT_SPELLING = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+$/;\n\n/**\n * Rewrite declared kebab-case names to underscores. Names without a hyphen\n * stay. A hyphen that is not a declared name stays subtraction.\n *\n * Each hyphenated word is scanned left to right, segment by segment; at each\n * segment the longest run of segments that is a declared name (written with\n * underscores) or a registered constant's hyphenated spelling (written as the\n * constant's primary name: `speed-of-light` is `c`) is taken, a declared name\n * before a constant spelling of the same length. So a declared name inside a\n * longer constant spelling does not win: `reduced-planck-constant` is `hbar`,\n * not `reduced - planck_constant`.\n */\nexport function rewriteCatalogHyphens(\n  text: string,\n  catalogNames: ReadonlySet<string> | Iterable<string>,\n): string {\n  const declared = new Set([...catalogNames].filter((n) => n.includes('-')));\n  return text.replace(/[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)+/g, (word) => rewriteWord(word, declared));\n}\n\n/** One hyphenated word, rewritten by the leftmost-longest segment scan. */\nfunction rewriteWord(word: string, declared: ReadonlySet<string>): string {\n  const segments = word.split('-');\n  const out: string[] = [];\n  let i = 0;\n  while (i < segments.length) {\n    let taken: { readonly end: number; readonly token: string } | undefined;\n    for (let end = segments.length; end > i + 1 && taken === undefined; end--) {\n      const candidate = segments.slice(i, end).join('-');\n      if (declared.has(candidate)) {\n        taken = { end, token: candidate.replace(/-/g, '_') };\n      } else if (CONSTANT_SPELLING.test(candidate)) {\n        const record = constantRecord(candidate);\n        if (record !== undefined) taken = { end, token: record.name };\n      }\n    }\n    if (taken === undefined) {\n      out.push(segments[i]!);\n      i += 1;\n    } else {\n      out.push(taken.token);\n      i = taken.end;\n    }\n  }\n  return out.join('-');\n}\n"]}

package/dist/dimensional/mathts-unit-delegation.d.ts

@@ -0,0 +1,29 @@
+import { type ExactScale } from './exact-scale.js';
+import type { Dimension } from './types.js';
+/** Every factor base in `text` is admitted in UPT and present in MathTS. */
+export declare function everySymbolInBothTables(text: string): boolean;
+/** True when `Unit.exactScale` matches the local scale and `bit` is excluded. */
+export declare function mathtsExactScaleAgreed(text: string, localScale: number, _localExact: ExactScale): boolean;
+/**
+ * The sub-kilo parsec spellings, UPT's by policy: MathTS 0.21.0 admits only the
+ * k-and-up prefixes on `pc` (its row is `SHORT_UP_ONLY`), while UPT's prefix table
+ * applies to every prefixable row in `data/units.json`. Those readings stay local.
+ */
+export declare function isSubKiloParsec(text: string): boolean;
+/** True when the full unit text may take exact scale and dimension from MathTS (A4). */
+export declare function unitExactScaleViaMathts(text: string, localScale: number, localExact: ExactScale, localDim: Dimension): boolean;
+/** True when `Unit.parse` may replace the local grammar for `text` (A5). */
+export declare function unitParserViaMathts(text: string, localScale: number, localExact: ExactScale, localDim: Dimension): boolean;
+/** Map MathTS unit dimensions to the UPT seven-base record. */
+export declare function mathtsParsedDimension(text: string, localDim: Dimension): Dimension;
+/**
+ * Raise a dimension to an integer power (test-only).
+ * @internal
+ */
+export declare function _powerDim(dim: Dimension, exp: number): Dimension;
+/**
+ * Multiply two dimensions (test-only).
+ * @internal
+ */
+export declare function _multiplyDim(a: Dimension, b: Dimension): Dimension;
+//# sourceMappingURL=mathts-unit-delegation.d.ts.map

package/dist/dimensional/mathts-unit-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathts-unit-delegation.d.ts","sourceRoot":"","sources":["../../src/dimensional/mathts-unit-delegation.ts"],"names":[],"mappings":"AAiBA,OAAO,EAA+B,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEhF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAuC5C,4EAA4E;AAC5E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgB7D;AAaD,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,CAIzG;AA+BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQrD;AAED,wFAAwF;AACxF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,GAAG,OAAO,CAU9H;AAGD,4EAA4E;AAC5E,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,SAAS,GAClB,OAAO,CAST;AAED,+DAA+D;AAC/D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,CAGlF;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAEhE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,GAAG,SAAS,CAElE"}

package/dist/dimensional/mathts-unit-delegation.js

@@ -0,0 +1,187 @@
+/**
+ * MathTS unit delegation predicates (Part A steps A4–A5).
+ *
+ * A text enters the MathTS path only when the predicate is true up front; a
+ * MathTS failure is not caught and routed back to the local reader.
+ *
+ * @module dimensional/mathts-unit-delegation
+ * @internal
+ */
+import { Unit, exactScaleToNumber, getUnitRow, toSiDimensionVector, } from '@danielsimonjr/mathts-core';
+import { symmetricRelDiff } from '../core/compare.js';
+import { equals, multiply, power } from './algebra.js';
+import { scaleToNumber, solidusSides } from './exact-scale.js';
+import { UNIT_DATA } from './unit-data.js';
+const DIMENSIONLESS = { L: 0, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0 };
+const UNITS = UNIT_DATA.units;
+const PREFIXES = UNIT_DATA.prefixes;
+const REFUSED = UNIT_DATA.refused;
+const SUPERSCRIPT = { '¹': 1, '²': 2, '³': 3, '⁻¹': -1, '⁻²': -2, '⁻³': -3 };
+function trySymbol(sym) {
+    if (UNITS.has(sym))
+        return { base: sym };
+    for (const [prefix] of PREFIXES) {
+        if (!sym.startsWith(prefix) || sym.length === prefix.length)
+            continue;
+        const base = sym.slice(prefix.length);
+        const row = UNITS.get(base);
+        if (row !== undefined && row.prefixable)
+            return { base };
+    }
+    return null;
+}
+function tryOneFactorBase(token) {
+    let base = token;
+    const caret = /^(.+)\^([+-]?\d+)$/.exec(token);
+    if (caret !== null)
+        base = caret[1];
+    else {
+        const uni = /^(.*?)(⁻?[¹²³])$/.exec(token);
+        if (uni !== null && SUPERSCRIPT[uni[2]] !== undefined && uni[1].length > 0)
+            base = uni[1];
+        else {
+            const glued = /^(.*?)([1-9]\d*)$/.exec(token);
+            if (glued !== null && glued[1].length > 0 && trySymbol(glued[1]) !== null)
+                base = glued[1];
+        }
+    }
+    return trySymbol(base)?.base ?? null;
+}
+function sideTokens(text) {
+    return text.split(/[*·\s]+|(?<=[A-Za-zµμΩ])\.(?=[A-Za-zµμΩ])/).filter((part) => part.length > 0);
+}
+/** Every factor base in `text` is admitted in UPT and present in MathTS. */
+export function everySymbolInBothTables(text) {
+    const t = text.trim();
+    if (t === '' || t === '1')
+        return true;
+    if (REFUSED.has(t))
+        return false;
+    if (UNIT_DATA.affine.some((row) => row.symbols.includes(t)))
+        return getUnitRow(t) !== undefined;
+    const { numerator, denominator } = solidusSides(t);
+    const tokens = [...sideTokens(numerator), ...sideTokens(denominator)];
+    if (tokens.length === 0)
+        return false;
+    for (const token of tokens) {
+        if (token === '1')
+            continue;
+        const base = tryOneFactorBase(token);
+        if (base === null)
+            return false;
+        if (!UNITS.has(base))
+            return false;
+        if (getUnitRow(base) === undefined)
+            return false;
+    }
+    return true;
+}
+function mathtsScaleNumber(text) {
+    if (!everySymbolInBothTables(text))
+        return null;
+    if (text.trim() === 'bit')
+        return null;
+    try {
+        const core = Unit.exactScale(text.trim());
+        return core === null ? null : exactScaleToNumber(core);
+    }
+    catch {
+        return null;
+    }
+}
+/** True when `Unit.exactScale` matches the local scale and `bit` is excluded. */
+export function mathtsExactScaleAgreed(text, localScale, _localExact) {
+    if (text.trim() === 'bit')
+        return false;
+    const mt = mathtsScaleNumber(text);
+    return mt !== null && (mt === localScale || symmetricRelDiff(localScale, mt) < 1e-15);
+}
+function siNumber(entry) {
+    return typeof entry === 'number' ? entry : entry.toNumber();
+}
+function dimensionFromMathtsVector(dimensions, localDim) {
+    try {
+        const v = toSiDimensionVector(dimensions);
+        return { L: siNumber(v[0]), M: siNumber(v[1]), T: siNumber(v[2]), I: siNumber(v[3]), Theta: siNumber(v[4]), N: siNumber(v[5]), J: siNumber(v[6]) };
+    }
+    catch {
+        const ignored = toSiDimensionVector(dimensions, { ignoreExtra: true });
+        if (equals(localDim, DIMENSIONLESS)) {
+            return DIMENSIONLESS;
+        }
+        return {
+            L: siNumber(ignored[0]),
+            M: siNumber(ignored[1]),
+            T: siNumber(ignored[2]),
+            I: siNumber(ignored[3]),
+            Theta: siNumber(ignored[4]),
+            N: siNumber(ignored[5]),
+            J: siNumber(ignored[6]),
+        };
+    }
+}
+/**
+ * The sub-kilo parsec spellings, UPT's by policy: MathTS 0.21.0 admits only the
+ * k-and-up prefixes on `pc` (its row is `SHORT_UP_ONLY`), while UPT's prefix table
+ * applies to every prefixable row in `data/units.json`. Those readings stay local.
+ */
+export function isSubKiloParsec(text) {
+    const t = text.trim();
+    if (!t.endsWith('pc'))
+        return false;
+    const prefix = t.slice(0, -2);
+    if (prefix === '')
+        return false;
+    const base = UNITS.get('pc');
+    const factor = PREFIXES.get(prefix);
+    return base !== undefined && base.prefixable && factor !== undefined && scaleToNumber(factor) < 1000;
+}
+/** True when the full unit text may take exact scale and dimension from MathTS (A4). */
+export function unitExactScaleViaMathts(text, localScale, localExact, localDim) {
+    if (isSubKiloParsec(text))
+        return false;
+    if (!mathtsExactScaleAgreed(text, localScale, localExact))
+        return false;
+    try {
+        const u = Unit.parse(text.trim());
+        const dim = dimensionFromMathtsVector(u.dimensions, localDim);
+        return equals(dim, localDim);
+    }
+    catch {
+        return false;
+    }
+}
+/** True when `Unit.parse` may replace the local grammar for `text` (A5). */
+export function unitParserViaMathts(text, localScale, localExact, localDim) {
+    if (isSubKiloParsec(text))
+        return false;
+    if (!unitExactScaleViaMathts(text, localScale, localExact, localDim))
+        return false;
+    try {
+        Unit.parse(text.trim());
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** Map MathTS unit dimensions to the UPT seven-base record. */
+export function mathtsParsedDimension(text, localDim) {
+    const u = Unit.parse(text.trim());
+    return dimensionFromMathtsVector(u.dimensions, localDim);
+}
+/**
+ * Raise a dimension to an integer power (test-only).
+ * @internal
+ */
+export function _powerDim(dim, exp) {
+    return power(dim, exp);
+}
+/**
+ * Multiply two dimensions (test-only).
+ * @internal
+ */
+export function _multiplyDim(a, b) {
+    return multiply(a, b);
+}
+//# sourceMappingURL=mathts-unit-delegation.js.map

package/dist/dimensional/mathts-unit-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathts-unit-delegation.js","sourceRoot":"","sources":["../../src/dimensional/mathts-unit-delegation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MathTS unit delegation predicates (Part A steps A4–A5).\n *\n * A text enters the MathTS path only when the predicate is true up front; a\n * MathTS failure is not caught and routed back to the local reader.\n *\n * @module dimensional/mathts-unit-delegation\n * @internal\n */\nimport {\n  Unit,\n  exactScaleToNumber,\n  getUnitRow,\n  toSiDimensionVector,\n} from '@danielsimonjr/mathts-core';\nimport { symmetricRelDiff } from '../core/compare.js';\nimport { equals, multiply, power } from './algebra.js';\nimport { scaleToNumber, solidusSides, type ExactScale } from './exact-scale.js';\nimport { UNIT_DATA } from './unit-data.js';\nimport type { Dimension } from './types.js';\n\nconst DIMENSIONLESS: Dimension = { L: 0, M: 0, T: 0, I: 0, Theta: 0, N: 0, J: 0 };\nconst UNITS = UNIT_DATA.units;\nconst PREFIXES = UNIT_DATA.prefixes;\nconst REFUSED = UNIT_DATA.refused;\n\nconst SUPERSCRIPT: Readonly<Record<string, number>> = { '¹': 1, '²': 2, '³': 3, '⁻¹': -1, '⁻²': -2, '⁻³': -3 };\n\nfunction trySymbol(sym: string): { readonly base: string } | null {\n  if (UNITS.has(sym)) return { base: sym };\n  for (const [prefix] of PREFIXES) {\n    if (!sym.startsWith(prefix) || sym.length === prefix.length) continue;\n    const base = sym.slice(prefix.length);\n    const row = UNITS.get(base);\n    if (row !== undefined && row.prefixable) return { base };\n  }\n  return null;\n}\n\nfunction tryOneFactorBase(token: string): string | null {\n  let base = token;\n  const caret = /^(.+)\\^([+-]?\\d+)$/.exec(token);\n  if (caret !== null) base = caret[1]!;\n  else {\n    const uni = /^(.*?)(⁻?[¹²³])$/.exec(token);\n    if (uni !== null && SUPERSCRIPT[uni[2]!] !== undefined && uni[1]!.length > 0) base = uni[1]!;\n    else {\n      const glued = /^(.*?)([1-9]\\d*)$/.exec(token);\n      if (glued !== null && glued[1]!.length > 0 && trySymbol(glued[1]!) !== null) base = glued[1]!;\n    }\n  }\n  return trySymbol(base)?.base ?? null;\n}\n\nfunction sideTokens(text: string): string[] {\n  return text.split(/[*·\\s]+|(?<=[A-Za-zµμΩ])\\.(?=[A-Za-zµμΩ])/).filter((part) => part.length > 0);\n}\n\n/** Every factor base in `text` is admitted in UPT and present in MathTS. */\nexport function everySymbolInBothTables(text: string): boolean {\n  const t = text.trim();\n  if (t === '' || t === '1') return true;\n  if (REFUSED.has(t)) return false;\n  if (UNIT_DATA.affine.some((row) => row.symbols.includes(t))) return getUnitRow(t) !== undefined;\n  const { numerator, denominator } = solidusSides(t);\n  const tokens = [...sideTokens(numerator), ...sideTokens(denominator)];\n  if (tokens.length === 0) return false;\n  for (const token of tokens) {\n    if (token === '1') continue;\n    const base = tryOneFactorBase(token);\n    if (base === null) return false;\n    if (!UNITS.has(base)) return false;\n    if (getUnitRow(base) === undefined) return false;\n  }\n  return true;\n}\n\nfunction mathtsScaleNumber(text: string): number | null {\n  if (!everySymbolInBothTables(text)) return null;\n  if (text.trim() === 'bit') return null;\n  try {\n    const core = Unit.exactScale(text.trim());\n    return core === null ? null : exactScaleToNumber(core);\n  } catch {\n    return null;\n  }\n}\n\n/** True when `Unit.exactScale` matches the local scale and `bit` is excluded. */\nexport function mathtsExactScaleAgreed(text: string, localScale: number, _localExact: ExactScale): boolean {\n  if (text.trim() === 'bit') return false;\n  const mt = mathtsScaleNumber(text);\n  return mt !== null && (mt === localScale || symmetricRelDiff(localScale, mt) < 1e-15);\n}\n\n\n/** A MathTS SI-dimension entry: 0.20.0 states exact rational exponents, so a number or a `Fraction`. */\ntype SiEntry = number | { readonly toNumber: () => number };\n\nfunction siNumber(entry: SiEntry): number {\n  return typeof entry === 'number' ? entry : entry.toNumber();\n}\n\nfunction dimensionFromMathtsVector(dimensions: readonly number[], localDim: Dimension): Dimension {\n  try {\n    const v = toSiDimensionVector(dimensions);\n    return { L: siNumber(v[0]!), M: siNumber(v[1]!), T: siNumber(v[2]!), I: siNumber(v[3]!), Theta: siNumber(v[4]!), N: siNumber(v[5]!), J: siNumber(v[6]!) };\n  } catch {\n    const ignored = toSiDimensionVector(dimensions, { ignoreExtra: true });\n    if (equals(localDim, DIMENSIONLESS)) {\n      return DIMENSIONLESS;\n    }\n    return {\n      L: siNumber(ignored[0]!),\n      M: siNumber(ignored[1]!),\n      T: siNumber(ignored[2]!),\n      I: siNumber(ignored[3]!),\n      Theta: siNumber(ignored[4]!),\n      N: siNumber(ignored[5]!),\n      J: siNumber(ignored[6]!),\n    };\n  }\n}\n\n/**\n * The sub-kilo parsec spellings, UPT's by policy: MathTS 0.21.0 admits only the\n * k-and-up prefixes on `pc` (its row is `SHORT_UP_ONLY`), while UPT's prefix table\n * applies to every prefixable row in `data/units.json`. Those readings stay local.\n */\nexport function isSubKiloParsec(text: string): boolean {\n  const t = text.trim();\n  if (!t.endsWith('pc')) return false;\n  const prefix = t.slice(0, -2);\n  if (prefix === '') return false;\n  const base = UNITS.get('pc');\n  const factor = PREFIXES.get(prefix);\n  return base !== undefined && base.prefixable && factor !== undefined && scaleToNumber(factor) < 1000;\n}\n\n/** True when the full unit text may take exact scale and dimension from MathTS (A4). */\nexport function unitExactScaleViaMathts(text: string, localScale: number, localExact: ExactScale, localDim: Dimension): boolean {\n  if (isSubKiloParsec(text)) return false;\n  if (!mathtsExactScaleAgreed(text, localScale, localExact)) return false;\n  try {\n    const u = Unit.parse(text.trim());\n    const dim = dimensionFromMathtsVector(u.dimensions, localDim);\n    return equals(dim, localDim);\n  } catch {\n    return false;\n  }\n}\n\n\n/** True when `Unit.parse` may replace the local grammar for `text` (A5). */\nexport function unitParserViaMathts(\n  text: string,\n  localScale: number,\n  localExact: ExactScale,\n  localDim: Dimension,\n): boolean {\n  if (isSubKiloParsec(text)) return false;\n  if (!unitExactScaleViaMathts(text, localScale, localExact, localDim)) return false;\n  try {\n    Unit.parse(text.trim());\n  } catch {\n    return false;\n  }\n  return true;\n}\n\n/** Map MathTS unit dimensions to the UPT seven-base record. */\nexport function mathtsParsedDimension(text: string, localDim: Dimension): Dimension {\n  const u = Unit.parse(text.trim());\n  return dimensionFromMathtsVector(u.dimensions, localDim);\n}\n\n/**\n * Raise a dimension to an integer power (test-only).\n * @internal\n */\nexport function _powerDim(dim: Dimension, exp: number): Dimension {\n  return power(dim, exp);\n}\n\n/**\n * Multiply two dimensions (test-only).\n * @internal\n */\nexport function _multiplyDim(a: Dimension, b: Dimension): Dimension {\n  return multiply(a, b);\n}\n"]}

package/dist/dimensional/mathts-unit-wrapper.d.ts

@@ -0,0 +1,33 @@
+import { type ExactScale } from './exact-scale.js';
+import type { Dimension } from './types.js';
+/** Agreed spellings that fully parse through MathTS (Part A step A5). The 0.21.0
+ * core adds the day symbol, the angstrom spellings, and SI prefixes on `psi` and
+ * `torr`; the k-and-up parsec spellings agree with the table double for double.
+ * The 0.22.0 core adds the glued products `m2K`, `Vs`, `cm^2/Vs` and `W/m2K`. */
+export declare const A5_DELEGATED_TEXTS: readonly ['km', 'degC', 'g/cm^3', 'mN/m', 'kohm', 'GeV', 'km/s/Mpc', 'd', 'day', 'Angstrom', 'angstrom', 'Å', 'psi', 'torr', 'kpsi', 'Mpsi', 'mtorr', 'utorr', 'kpc', 'Mpc', 'Gpc', 'm2K', 'Vs', 'cm^2/Vs', 'W/m2K'];
+/** Tokens whose spelling carries a refusal reason: UPT policy rows first, then MathTS's registry. */
+export declare function refusedTokensIn(text: string): readonly string[];
+/** Refusal message: UPT policy (`ton`) first, then the MathTS registry (`dB` and friends). Null when the text is not denied. */
+export declare function uptRefusalReason(text: string): string | null;
+/** Whether `text` is on the Part A step A5 delegated spelling list. */
+export declare function isA5DelegatedText(text: string): boolean;
+/** Whether MathTS `Unit.parse` accepts `text`. */
+export declare function mathtsWouldParse(text: string): boolean;
+/** Keep `bit` at ln 2 nat on the 7-vector (A11a). */
+export declare function applyBitScaleOverride(text: string, exact: ExactScale, scale: number): {
+    readonly exact: ExactScale;
+    readonly scale: number;
+};
+/** Scale, dimension, and cycles for one A5 in-set text read through MathTS. */
+export interface MathtsDelegatedReading {
+    readonly exact: ExactScale;
+    readonly scale: number;
+    readonly dim: Dimension;
+    readonly cycles: number;
+}
+/**
+ * Scale and dimension for an A5 in-set text through MathTS only (A12 partial).
+ * Returns null when the text is not on the A5 list or MathTS rejects it.
+ */
+export declare function tryMathtsA5Reading(text: string): MathtsDelegatedReading | null;
+//# sourceMappingURL=mathts-unit-wrapper.d.ts.map

package/dist/dimensional/mathts-unit-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathts-unit-wrapper.d.ts","sourceRoot":"","sources":["../../src/dimensional/mathts-unit-wrapper.ts"],"names":[],"mappings":"AA2BA,OAAO,EAAsD,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGvG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAO5C;;;iFAGiF;AACjF,eAAO,MAAM,kBAAkB,YAC7B,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,MAAM,EACN,MAAM,EACN,KAAK,EACL,UAAU,EACV,GAAG,EACH,KAAK,EACL,UAAU,EACV,UAAU,EACV,GAAG,EACH,KAAK,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,IAAI,EACJ,SAAS,EACT,OAAO,CACC,CAAC;AAyCX,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAiB/D;AAED,gIAAgI;AAChI,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAK5D;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOtD;AAED,qDAAqD;AACrD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAM5I;AAED,+EAA+E;AAC/E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAOD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAiB9E"}