solve-engine 1.2.0 → 2.1.0

package/dist/chunk-WMQRJTAO.js

@@ -1,3266 +0,0 @@
-import { VariableResolver } from './chunk-GCM5JHMX.js';
-import { sharedCurrencyExchange } from './chunk-BSPXMGIS.js';
-import { decimalFromInteger, toPolynomial, polyDegree, polyCoefficients, fromPolynomial, constNode, rationalDiv, rationalNeg, powNode, callNode, decimalCompare, isRationalZero, rationalMul, rationalSub, rationalAdd, rationalToNumber, rationalCompare, simplifySymbolic, sameShape, decimalFromNumberIfExact, decimalMultiply, decimalToNumber, decimalAdd, decimalNegate, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, exactIntegerSqrt, surdNode, rational, decimalIsZero, decimalDivide, decimalSubtract, decimalFromLiteral, decimalRound, substitute, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, COMPLEX_I, squareFreePart, makeDecimal, coefficientGcd, polynomialDivide, isZeroPolynomial, exactRationalSqrt, symbolicKey, compareMonomials, signedSurdNode, monomialFromKey, monomialToKey, exactIntegerCbrt } from './chunk-ZNFFTYWH.js';
-import { faultedOperand, errorValue, numberValueRational, numberValueUncertain, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, uomValueExact, splitValue, percentageValue, stringValue, hexValue } from './chunk-5EFKSKMA.js';
-import { getMeasure, convertUnit } from './chunk-MVTOCRV2.js';
-import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
-import { ErrorFactory } from './chunk-N7OA4WPJ.js';
-
-// src/symbolic/MultivariateFactor.ts
-function exactRoot(value, degree) {
-  const rootOf = degree === 2 ? exactIntegerSqrt : exactIntegerCbrt;
-  const numerator = rootOf(value.n);
-  const denominator = rootOf(value.d);
-  return numerator === null || denominator === null ? null : { n: numerator, d: denominator };
-}
-function monomialRoot(key, degree) {
-  const monomial = monomialFromKey(key);
-  const root = /* @__PURE__ */ new Map();
-  for (const [name, exponent] of monomial) {
-    if (exponent % degree !== 0) return null;
-    root.set(name, exponent / degree);
-  }
-  return monomialToKey(root);
-}
-function monomialMul(a, b) {
-  const product2 = monomialFromKey(a);
-  for (const [name, exponent] of monomialFromKey(b)) {
-    product2.set(name, (product2.get(name) ?? 0) + exponent);
-  }
-  return monomialToKey(product2);
-}
-function monomialDiv(a, b) {
-  const quotient = monomialFromKey(a);
-  for (const [name, exponent] of monomialFromKey(b)) {
-    const remaining = (quotient.get(name) ?? 0) - exponent;
-    if (remaining <= 0) quotient.delete(name);
-    else quotient.set(name, remaining);
-  }
-  return monomialToKey(quotient);
-}
-function monomialGcd(a, b) {
-  const left = monomialFromKey(a);
-  const shared = /* @__PURE__ */ new Map();
-  for (const [name, exponent] of monomialFromKey(b)) {
-    const other = left.get(name);
-    if (other !== void 0) shared.set(name, Math.min(other, exponent));
-  }
-  return monomialToKey(shared);
-}
-function namesOf(keys) {
-  const names = /* @__PURE__ */ new Set();
-  for (const key of keys) for (const name of monomialFromKey(key).keys()) names.add(name);
-  return [...names].sort();
-}
-function termsToNode(terms) {
-  const map = /* @__PURE__ */ new Map();
-  for (const term of terms) map.set(term.key, term.coefficient);
-  return fromPolynomial({ terms: map, vars: namesOf(terms.map((term) => term.key)) });
-}
-function product(factors) {
-  let result = factors[0];
-  for (let i = 1; i < factors.length; i++) result = { kind: "mul", left: result, right: factors[i] };
-  return result;
-}
-function orderedTerms(p) {
-  const terms = [...p.terms].map(([key, coefficient]) => ({ key, coefficient }));
-  return terms.sort((a, b) => compareMonomials(a.key, b.key, p.vars));
-}
-function factorMultivariate(p) {
-  if (p.vars.length < 2) return null;
-  const terms = orderedTerms(p);
-  if (terms.length === 2) return factorBinomial(terms[0], terms[1]);
-  if (terms.length === 3) return factorPerfectSquare(terms);
-  if (terms.length === 4) return factorByGrouping(terms);
-  return null;
-}
-function factorBinomial(first, second) {
-  const firstPositive = first.coefficient.n > 0n;
-  const secondPositive = second.coefficient.n > 0n;
-  if (!firstPositive) return null;
-  const squares = asPowerPair(first, second, 2);
-  if (squares !== null && !secondPositive) {
-    return product([
-      termsToNode([squares.a, negated(squares.b)]),
-      termsToNode([squares.a, squares.b])
-    ]);
-  }
-  const cubes = asPowerPair(first, second, 3);
-  if (cubes === null) return null;
-  const linear = secondPositive ? termsToNode([cubes.a, cubes.b]) : termsToNode([cubes.a, negated(cubes.b)]);
-  const middle = secondPositive ? negated(multiplyTerms(cubes.a, cubes.b)) : multiplyTerms(cubes.a, cubes.b);
-  return product([linear, termsToNode([squareOf(cubes.a), middle, squareOf(cubes.b)])]);
-}
-function asPowerPair(first, second, degree) {
-  const magnitude2 = second.coefficient.n < 0n ? rationalNeg(second.coefficient) : second.coefficient;
-  const firstRoot = exactRoot(first.coefficient, degree);
-  const secondRoot = exactRoot(magnitude2, degree);
-  if (firstRoot === null || secondRoot === null) return null;
-  const firstKey = monomialRoot(first.key, degree);
-  const secondKey = monomialRoot(second.key, degree);
-  if (firstKey === null || secondKey === null) return null;
-  return { a: { key: firstKey, coefficient: firstRoot }, b: { key: secondKey, coefficient: secondRoot } };
-}
-function negated(term) {
-  return { key: term.key, coefficient: rationalNeg(term.coefficient) };
-}
-function multiplyTerms(a, b) {
-  return { key: monomialMul(a.key, b.key), coefficient: rationalMul(a.coefficient, b.coefficient) };
-}
-function squareOf(term) {
-  return multiplyTerms(term, term);
-}
-function factorPerfectSquare(terms) {
-  const [first, middle, last] = terms;
-  if (first.coefficient.n < 0n || last.coefficient.n < 0n) return null;
-  const roots = asPowerPair(first, last, 2);
-  if (roots === null) return null;
-  const cross = multiplyTerms(roots.a, roots.b);
-  if (cross.key !== middle.key) return null;
-  const twice = rationalMul(cross.coefficient, { n: 2n, d: 1n });
-  const negative = middle.coefficient.n < 0n;
-  const magnitude2 = negative ? rationalNeg(middle.coefficient) : middle.coefficient;
-  if (!isRationalOne(rationalDiv(magnitude2, twice))) return null;
-  const base = termsToNode([roots.a, negative ? negated(roots.b) : roots.b]);
-  return { kind: "pow", base, exponent: constNode(2) };
-}
-function factorByGrouping(terms) {
-  const pairings = [
-    [[0, 1], [2, 3]],
-    [[0, 2], [1, 3]],
-    [[0, 3], [1, 2]]
-  ];
-  for (const pairing of pairings) {
-    const first = splitPair(terms[pairing[0][0]], terms[pairing[0][1]]);
-    const second = splitPair(terms[pairing[1][0]], terms[pairing[1][1]]);
-    if (first === null || second === null) continue;
-    if (!cofactorsAgree(first.cofactor, second.cofactor)) continue;
-    return product([
-      termsToNode([first.common, second.common]),
-      termsToNode(first.cofactor)
-    ]);
-  }
-  return null;
-}
-function splitPair(first, second) {
-  const shared = monomialGcd(first.key, second.key);
-  const common = { key: shared, coefficient: first.coefficient };
-  const cofactor = [
-    { key: monomialDiv(first.key, shared), coefficient: { n: 1n, d: 1n } },
-    { key: monomialDiv(second.key, shared), coefficient: rationalDiv(second.coefficient, first.coefficient) }
-  ];
-  return cofactor[0].key === cofactor[1].key ? null : { common, cofactor };
-}
-function cofactorsAgree(a, b) {
-  if (a.length !== b.length) return false;
-  return a.every((term, index) => term.key === b[index].key && term.coefficient.n === b[index].coefficient.n && term.coefficient.d === b[index].coefficient.d);
-}
-
-// src/symbolic/Factor.ts
-var FACTOR_MAX_DEGREE = 12;
-var FACTOR_MAX_ROOT_CANDIDATES = 4096;
-function gcd(a, b) {
-  let x = a < 0n ? -a : a;
-  let y = b < 0n ? -b : b;
-  while (y !== 0n) {
-    const remainder = x % y;
-    x = y;
-    y = remainder;
-  }
-  return x;
-}
-function lcm(a, b) {
-  if (a === 0n || b === 0n) return 0n;
-  return a / gcd(a, b) * b;
-}
-function divisors(value) {
-  const magnitude2 = value < 0n ? -value : value;
-  if (magnitude2 === 0n) return null;
-  const found = [];
-  for (let candidate = 1n; candidate * candidate <= magnitude2; candidate++) {
-    if (magnitude2 % candidate !== 0n) continue;
-    found.push(candidate);
-    const paired = magnitude2 / candidate;
-    if (paired !== candidate) found.push(paired);
-    if (found.length > FACTOR_MAX_ROOT_CANDIDATES) return null;
-  }
-  return found;
-}
-function evaluateAt(descending, x) {
-  let total = RATIONAL_ZERO;
-  for (const coeff of descending) total = rationalAdd(rationalMul(total, x), coeff);
-  return total;
-}
-function divideByRoot(descending, root) {
-  const quotient = [descending[0]];
-  for (let i = 1; i < descending.length - 1; i++) {
-    quotient.push(rationalAdd(descending[i], rationalMul(quotient[i - 1], root)));
-  }
-  return quotient;
-}
-function rationalRoots(descending) {
-  if (descending.length < 2) return [];
-  let multiplier = 1n;
-  for (const coeff of descending) multiplier = lcm(multiplier, coeff.d);
-  const integers = descending.map((coeff) => coeff.n * multiplier / coeff.d);
-  const leading = integers[0];
-  const trailing = integers[integers.length - 1];
-  if (trailing === 0n) return [];
-  const numeratorDivisors = divisors(trailing);
-  const denominatorDivisors = divisors(leading);
-  if (numeratorDivisors === null || denominatorDivisors === null) {
-    throw ErrorFactory.execution(
-      "SYMBOLIC_FACTOR_LIMIT_EXCEEDED",
-      "This polynomial's coefficients have too many divisors to search for rational roots.",
-      { limit: FACTOR_MAX_ROOT_CANDIDATES }
-    );
-  }
-  if (numeratorDivisors.length * denominatorDivisors.length > FACTOR_MAX_ROOT_CANDIDATES) {
-    throw ErrorFactory.execution(
-      "SYMBOLIC_FACTOR_LIMIT_EXCEEDED",
-      "This polynomial has too many candidate rational roots to test.",
-      { limit: FACTOR_MAX_ROOT_CANDIDATES }
-    );
-  }
-  const roots = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const p of numeratorDivisors) {
-    for (const q of denominatorDivisors) {
-      for (const sign of [1n, -1n]) {
-        const candidate = { n: sign * p / gcd(p, q), d: q / gcd(p, q) };
-        const key = `${candidate.n}/${candidate.d}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        if (isRationalZero(evaluateAt(descending, candidate))) roots.push(candidate);
-      }
-    }
-  }
-  return roots;
-}
-function linearFactorNode(variable, root) {
-  if (isRationalZero(root)) return varNode(variable);
-  return root.n > 0n ? { kind: "sub", left: varNode(variable), right: constNode(root) } : { kind: "add", left: varNode(variable), right: constNode(rationalNeg(root)) };
-}
-function coefficientsToNode(descending, variable) {
-  const degree = descending.length - 1;
-  const terms = /* @__PURE__ */ new Map();
-  descending.forEach((coeff, index) => {
-    if (isRationalZero(coeff)) return;
-    const power3 = degree - index;
-    terms.set(power3 === 0 ? "" : power3 === 1 ? variable : `${variable}^${power3}`, coeff);
-  });
-  return fromPolynomial({ terms, vars: terms.size > 0 ? [variable] : [] });
-}
-function factorUnivariate(descending, variable) {
-  const factors = [];
-  let remaining = [...descending];
-  let roots = rationalRoots(remaining);
-  while (roots.length > 0 && remaining.length > 2) {
-    for (const root of roots) {
-      let multiplicity = 0;
-      while (remaining.length > 1 && isRationalZero(evaluateAt(remaining, root))) {
-        remaining = divideByRoot(remaining, root);
-        multiplicity++;
-      }
-      if (multiplicity > 0) factors.push({ base: linearFactorNode(variable, root), power: multiplicity });
-    }
-    roots = remaining.length > 2 ? rationalRoots(remaining) : [];
-  }
-  const leftoverDegree = remaining.length - 1;
-  if (leftoverDegree >= 1) {
-    factors.push({ base: coefficientsToNode(remaining, variable), power: 1 });
-    return { content: RATIONAL_ONE, factors };
-  }
-  return { content: remaining.length === 1 ? remaining[0] : RATIONAL_ONE, factors };
-}
-function factorizationToNode(factorization) {
-  const pieces = [];
-  if (!isRationalOne(factorization.content)) pieces.push(constNode(factorization.content));
-  for (const factor of factorization.factors) {
-    pieces.push(factor.power === 1 ? factor.base : powNode(factor.base, constNode({ n: BigInt(factor.power), d: 1n })));
-  }
-  if (pieces.length === 0) return constNode(RATIONAL_ONE);
-  let result = pieces[0];
-  for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
-  return result;
-}
-function contentOf(p) {
-  let numeratorGcd = 0n;
-  let denominatorLcm = 1n;
-  for (const coeff of p.terms.values()) {
-    numeratorGcd = gcd(numeratorGcd, coeff.n);
-    denominatorLcm = lcm(denominatorLcm, coeff.d);
-  }
-  if (numeratorGcd === 0n) return RATIONAL_ONE;
-  return { n: numeratorGcd, d: denominatorLcm };
-}
-function extractCommonMonomial(p) {
-  const common = /* @__PURE__ */ new Map();
-  for (const name of p.vars) {
-    let lowest = Infinity;
-    for (const key of p.terms.keys()) {
-      const exponent = exponentOf(key, name);
-      if (exponent < lowest) lowest = exponent;
-    }
-    if (lowest > 0 && lowest !== Infinity) common.set(name, lowest);
-  }
-  if (common.size === 0) return { monomial: common, reduced: p };
-  const terms = /* @__PURE__ */ new Map();
-  for (const [key, coeff] of p.terms) {
-    const exponents = parseKey(key);
-    for (const [name, shared] of common) exponents.set(name, (exponents.get(name) ?? 0) - shared);
-    terms.set(buildKey(exponents), coeff);
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const key of terms.keys()) for (const name of parseKey(key).keys()) names.add(name);
-  return { monomial: common, reduced: { terms, vars: [...names].sort() } };
-}
-function exponentOf(key, name) {
-  return parseKey(key).get(name) ?? 0;
-}
-function parseKey(key) {
-  const exponents = /* @__PURE__ */ new Map();
-  if (key === "") return exponents;
-  for (const factor of key.split("*")) {
-    const caret = factor.indexOf("^");
-    if (caret === -1) exponents.set(factor, 1);
-    else exponents.set(factor.slice(0, caret), Number(factor.slice(caret + 1)));
-  }
-  return exponents;
-}
-function buildKey(exponents) {
-  const names = [...exponents.keys()].filter((name) => (exponents.get(name) ?? 0) > 0).sort();
-  return names.map((name) => exponents.get(name) === 1 ? name : `${name}^${exponents.get(name)}`).join("*");
-}
-function monomialNode(monomial) {
-  const names = [...monomial.keys()].sort();
-  let result = null;
-  for (const name of names) {
-    const exponent = monomial.get(name);
-    const factor = exponent === 1 ? varNode(name) : powNode(varNode(name), constNode({ n: BigInt(exponent), d: 1n }));
-    result = result === null ? factor : { kind: "mul", left: result, right: factor };
-  }
-  return result;
-}
-function factorSymbolic(node) {
-  const polynomial = toPolynomial(node);
-  if (polynomial === null || polynomial.terms.size === 0) return node;
-  if (polyDegree(polynomial) > FACTOR_MAX_DEGREE) return node;
-  if (polynomial.vars.length === 0) return node;
-  const content = contentOf(polynomial);
-  const primitive = isRationalOne(content) ? polynomial : scaleTerms(polynomial, rationalDiv(RATIONAL_ONE, content));
-  const { monomial, reduced } = extractCommonMonomial(primitive);
-  const monomialFactor = monomialNode(monomial);
-  const variable = polyUnivariateVar(reduced);
-  if (variable === null) {
-    const patterned = factorMultivariate(reduced);
-    if (patterned !== null) return assemble(content, monomialFactor, patterned);
-    const pieces2 = buildPieces(content, monomialFactor, reduced);
-    return pieces2 ?? node;
-  }
-  const descending = [...polyCoefficients(reduced, variable)].reverse();
-  const factorization = factorUnivariate(descending, variable);
-  const combinedContent = rationalMul(content, factorization.content);
-  const isUnchanged = factorization.factors.length <= 1 && (factorization.factors[0]?.power ?? 1) === 1 && monomialFactor === null && isRationalOne(combinedContent);
-  if (isUnchanged) return node;
-  const pieces = [];
-  if (!isRationalOne(combinedContent)) pieces.push(constNode(combinedContent));
-  if (monomialFactor !== null) pieces.push(monomialFactor);
-  pieces.push(factorizationToNode({ content: RATIONAL_ONE, factors: factorization.factors }));
-  let result = pieces[0];
-  for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
-  return result;
-}
-function scaleTerms(p, k) {
-  const terms = /* @__PURE__ */ new Map();
-  for (const [key, coeff] of p.terms) terms.set(key, rationalMul(coeff, k));
-  return { terms, vars: p.vars };
-}
-function assemble(content, monomialFactor, factored) {
-  const pieces = [];
-  if (!isRationalOne(content)) pieces.push(constNode(content));
-  if (monomialFactor !== null) pieces.push(monomialFactor);
-  pieces.push(factored);
-  let result = pieces[0];
-  for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
-  return result;
-}
-function buildPieces(content, monomialFactor, reduced) {
-  if (monomialFactor === null && isRationalOne(content)) return null;
-  const pieces = [];
-  if (!isRationalOne(content)) pieces.push(constNode(content));
-  if (monomialFactor !== null) pieces.push(monomialFactor);
-  pieces.push(fromPolynomial(reduced));
-  let result = pieces[0];
-  for (let i = 1; i < pieces.length; i++) result = { kind: "mul", left: result, right: pieces[i] };
-  return result;
-}
-
-// src/symbolic/CubicQuartic.ts
-var TWO = { n: 2n, d: 1n };
-var THREE = { n: 3n, d: 1n };
-var FOUR = { n: 4n, d: 1n };
-function depressCubic(a, b, c, d) {
-  const shift = rationalNeg(rationalDiv(b, rationalMul(THREE, a)));
-  const p = rationalDiv(
-    rationalSub(rationalMul(THREE, rationalMul(a, c)), rationalMul(b, b)),
-    rationalMul(THREE, rationalMul(a, a))
-  );
-  const twoBCubed = rationalMul(TWO, rationalMul(b, rationalMul(b, b)));
-  const nineABC = rationalMul({ n: 9n, d: 1n }, rationalMul(a, rationalMul(b, c)));
-  const twentySevenAAD = rationalMul({ n: 27n, d: 1n }, rationalMul(rationalMul(a, a), d));
-  const q = rationalDiv(
-    rationalAdd(rationalSub(twoBCubed, nineABC), twentySevenAAD),
-    rationalMul({ n: 27n, d: 1n }, rationalMul(a, rationalMul(a, a)))
-  );
-  return { p, q, shift };
-}
-function solveCubic(a, b, c, d) {
-  const { p, q, shift } = depressCubic(a, b, c, d);
-  const discriminant = rationalNeg(
-    rationalAdd(
-      rationalMul(FOUR, rationalMul(p, rationalMul(p, p))),
-      rationalMul({ n: 27n, d: 1n }, rationalMul(q, q))
-    )
-  );
-  if (rationalCompare(discriminant, RATIONAL_ZERO) > 0) {
-    return { exact: [], approximate: trigonometricRoots(p, q, shift) };
-  }
-  if (isRationalZero(discriminant)) return { exact: repeatedCubicRoots(p, q, shift), approximate: [] };
-  return { exact: cardanoRoots(p, q, shift), approximate: [] };
-}
-function repeatedCubicRoots(p, q, shift) {
-  if (isRationalZero(p)) return [constNode(shift)];
-  const simple = rationalAdd(rationalDiv(rationalMul(THREE, q), p), shift);
-  const repeated = rationalAdd(rationalNeg(rationalDiv(rationalMul(THREE, q), rationalMul(TWO, p))), shift);
-  const ordered = [simple, repeated].sort(rationalCompare);
-  return ordered.map(constNode);
-}
-function cardanoRoots(p, q, shift) {
-  const half = rationalNeg(rationalDiv(q, TWO));
-  const radicand = rationalAdd(
-    rationalMul(rationalDiv(q, TWO), rationalDiv(q, TWO)),
-    rationalMul(rationalDiv(p, THREE), rationalMul(rationalDiv(p, THREE), rationalDiv(p, THREE)))
-  );
-  const inner = surdNode(radicand);
-  const u = { kind: "call", name: "cbrt", args: [{ kind: "add", left: constNode(half), right: inner }] };
-  const v = { kind: "call", name: "cbrt", args: [{ kind: "sub", left: constNode(half), right: inner }] };
-  const sum = { kind: "add", left: u, right: v };
-  const difference = { kind: "sub", left: u, right: v };
-  const real = { kind: "add", left: constNode(shift), right: { kind: "div", left: { kind: "neg", operand: sum }, right: constNode(TWO) } };
-  const imaginary = {
-    kind: "mul",
-    left: { kind: "div", left: { kind: "mul", left: difference, right: surdNode(THREE) }, right: constNode(TWO) },
-    right: complexNode(COMPLEX_I)
-  };
-  return [
-    { kind: "add", left: constNode(shift), right: sum },
-    { kind: "sub", left: real, right: imaginary },
-    { kind: "add", left: real, right: imaginary }
-  ];
-}
-function trigonometricRoots(p, q, shift) {
-  const pNumber = rationalToNumber(p);
-  const qNumber = rationalToNumber(q);
-  const shiftNumber = rationalToNumber(shift);
-  const magnitude2 = 2 * Math.sqrt(-pNumber / 3);
-  const ratio = 3 * qNumber / (2 * pNumber) * Math.sqrt(-3 / pNumber);
-  const angle = Math.acos(Math.min(1, Math.max(-1, ratio))) / 3;
-  return [0, 1, 2].map((k) => magnitude2 * Math.cos(angle - 2 * Math.PI * k / 3) + shiftNumber).sort((left, right) => left - right);
-}
-function depressQuartic(b, c, d, e) {
-  const shift = rationalNeg(rationalDiv(b, FOUR));
-  const bb = rationalMul(b, b);
-  const p = rationalSub(c, rationalDiv(rationalMul(THREE, bb), { n: 8n, d: 1n }));
-  const q = rationalAdd(
-    rationalSub(d, rationalDiv(rationalMul(b, c), TWO)),
-    rationalDiv(rationalMul(bb, b), { n: 8n, d: 1n })
-  );
-  const r = rationalSub(
-    rationalAdd(
-      rationalSub(e, rationalDiv(rationalMul(b, d), FOUR)),
-      rationalDiv(rationalMul(bb, c), { n: 16n, d: 1n })
-    ),
-    rationalDiv(rationalMul(THREE, rationalMul(bb, bb)), { n: 256n, d: 1n })
-  );
-  return { p, q, r, shift };
-}
-function solveQuartic(a, b, c, d, e, solveQuadratic2) {
-  const monic = (value) => rationalDiv(value, a);
-  const { p, q, r, shift } = depressQuartic(monic(b), monic(c), monic(d), monic(e));
-  const roots = isRationalZero(q) ? biquadraticRoots(p, r) : splitQuarticRoots(p, q, r, solveQuadratic2);
-  if (roots === null) return null;
-  const shifted = isRationalZero(shift) ? roots : roots.map((root) => ({ kind: "add", left: constNode(shift), right: root }));
-  return { exact: distinct(shifted), approximate: [] };
-}
-function distinct(roots) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const root of roots) {
-    const key = symbolicKey(simplifySymbolic(root));
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(root);
-  }
-  return unique;
-}
-function biquadraticRoots(p, r) {
-  const discriminant = rationalSub(rationalMul(p, p), rationalMul(FOUR, r));
-  if (rationalCompare(discriminant, RATIONAL_ZERO) < 0) return complexBiquadraticRoots(p, r);
-  const root = exactRationalSqrt(discriminant);
-  if (root !== null) return rationalSquareRoots(rationalNeg(p), root, isRationalZero(discriminant));
-  return nestedSquareRoots(p, r, discriminant);
-}
-function rationalSquareRoots(negatedP, root, repeated) {
-  const values = repeated ? [rationalDiv(negatedP, TWO)] : [rationalDiv(rationalAdd(negatedP, root), TWO), rationalDiv(rationalSub(negatedP, root), TWO)];
-  const roots = [];
-  for (const value of values) {
-    if (isRationalZero(value)) {
-      roots.push(constNode(RATIONAL_ZERO));
-      continue;
-    }
-    const square = signedSurdNode(value);
-    roots.push({ kind: "neg", operand: square }, square);
-  }
-  return roots;
-}
-function nestedSquareRoots(p, r, discriminant) {
-  const negatedP = constNode(rationalNeg(p));
-  const surd = surdNode(discriminant);
-  const negativeP = rationalCompare(p, RATIONAL_ZERO) <= 0;
-  const solutions = [
-    { node: halved({ kind: "add", left: negatedP, right: surd }), positive: negativeP || rationalCompare(r, RATIONAL_ZERO) <= 0 },
-    { node: halved({ kind: "sub", left: negatedP, right: surd }), positive: negativeP && rationalCompare(r, RATIONAL_ZERO) >= 0 }
-  ];
-  const roots = [];
-  for (const { node, positive } of solutions) {
-    const radicand = positive ? node : { kind: "neg", operand: node };
-    const magnitude2 = { kind: "call", name: "sqrt", args: [radicand] };
-    const square = positive ? magnitude2 : { kind: "mul", left: magnitude2, right: complexNode(COMPLEX_I) };
-    roots.push({ kind: "neg", operand: square }, square);
-  }
-  return roots;
-}
-function halved(node) {
-  return { kind: "div", left: node, right: constNode(TWO) };
-}
-function complexBiquadraticRoots(p, r) {
-  const centre = rationalDiv(rationalNeg(p), TWO);
-  const modulus = exactRationalSqrt(r);
-  const re = modulus === null ? nestedSurd(surdNode(r), centre) : surdNode(rationalDiv(rationalAdd(modulus, centre), TWO));
-  const imaginaryMagnitude = modulus === null ? nestedSurd(surdNode(r), rationalNeg(centre)) : surdNode(rationalDiv(rationalSub(modulus, centre), TWO));
-  const im = { kind: "mul", left: imaginaryMagnitude, right: complexNode(COMPLEX_I) };
-  const first = { kind: "add", left: re, right: im };
-  const second = { kind: "sub", left: re, right: im };
-  return [
-    { kind: "neg", operand: first },
-    { kind: "neg", operand: second },
-    second,
-    first
-  ];
-}
-function nestedSurd(surd, offset) {
-  const shifted = offset.n >= 0n ? { kind: "add", left: surd, right: constNode(offset) } : { kind: "sub", left: surd, right: constNode(rationalNeg(offset)) };
-  return { kind: "call", name: "sqrt", args: [halved(shifted)] };
-}
-function splitQuarticRoots(p, q, r, solveQuadratic2) {
-  const resolvent = [
-    { n: 1n, d: 1n },
-    rationalMul(TWO, p),
-    rationalSub(rationalMul(p, p), rationalMul(FOUR, r)),
-    rationalNeg(rationalMul(q, q))
-  ];
-  for (const z of rationalRoots(resolvent)) {
-    if (rationalCompare(z, RATIONAL_ZERO) <= 0) continue;
-    const alpha = exactRationalSqrt(z);
-    if (alpha === null) continue;
-    const sum = rationalAdd(p, z);
-    const difference = rationalDiv(q, alpha);
-    const beta = rationalDiv(rationalSub(sum, difference), TWO);
-    const gamma = rationalDiv(rationalAdd(sum, difference), TWO);
-    const one2 = { n: 1n, d: 1n };
-    return [
-      ...solveQuadratic2(one2, alpha, beta),
-      ...solveQuadratic2(one2, rationalNeg(alpha), gamma)
-    ];
-  }
-  return null;
-}
-
-// src/symbolic/NumericRoots.ts
-var DURAND_KERNER_MAX_ITERATIONS = 200;
-var DURAND_KERNER_TOLERANCE = 1e-14;
-var ROOT_RESIDUAL_TOLERANCE = 1e-10;
-var ROOT_SEPARATION_TOLERANCE = 1e-10;
-var AXIS_SNAP_TOLERANCE = 1e-9;
-var CONJUGATE_PAIR_TOLERANCE = 1e-8;
-var NEWTON_POLISH_STEPS = 4;
-function subtract(a, b) {
-  return { re: a.re - b.re, im: a.im - b.im };
-}
-function multiply(a, b) {
-  return { re: a.re * b.re - a.im * b.im, im: a.re * b.im + a.im * b.re };
-}
-function divide(a, b) {
-  if (Math.abs(b.re) >= Math.abs(b.im)) {
-    const ratio2 = b.im / b.re;
-    const denominator2 = b.re + b.im * ratio2;
-    return { re: (a.re + a.im * ratio2) / denominator2, im: (a.im - a.re * ratio2) / denominator2 };
-  }
-  const ratio = b.re / b.im;
-  const denominator = b.re * ratio + b.im;
-  return { re: (a.re * ratio + a.im) / denominator, im: (a.im * ratio - a.re) / denominator };
-}
-function magnitude(z) {
-  return Math.hypot(z.re, z.im);
-}
-function evaluateAt2(descending, z) {
-  let re = 0;
-  let im = 0;
-  for (const coefficient of descending) {
-    const nextRe = re * z.re - im * z.im + coefficient;
-    im = re * z.im + im * z.re;
-    re = nextRe;
-  }
-  return { re, im };
-}
-function evaluationScale(descending, z) {
-  const radius = magnitude(z);
-  let total = 0;
-  for (const coefficient of descending) total = total * radius + Math.abs(coefficient);
-  return total;
-}
-function differentiate(descending) {
-  const degree = descending.length - 1;
-  const derivative = [];
-  for (let i = 0; i < degree; i++) derivative.push(descending[i] * (degree - i));
-  return derivative;
-}
-function squareFreeDoubles(descending) {
-  const ascending = [...descending].reverse();
-  const squareFree = [...squareFreePart(ascending)].reverse();
-  const doubles = squareFree.map(rationalToNumber);
-  if (doubles.some((value) => !Number.isFinite(value))) return null;
-  return doubles;
-}
-function initialEstimates(monic) {
-  const degree = monic.length - 1;
-  let largest = 0;
-  for (let i = 1; i < monic.length; i++) largest = Math.max(largest, Math.abs(monic[i]));
-  const radius = 1 + largest;
-  const centre = -monic[1] / degree;
-  const estimates = [];
-  for (let k = 0; k < degree; k++) {
-    const angle = 2 * Math.PI * k / degree + Math.PI / (2 * degree);
-    estimates.push({ re: centre + radius * Math.cos(angle), im: radius * Math.sin(angle) });
-  }
-  return estimates;
-}
-function durandKerner(monic) {
-  const degree = monic.length - 1;
-  const estimates = initialEstimates(monic);
-  for (let iteration = 0; iteration < DURAND_KERNER_MAX_ITERATIONS; iteration++) {
-    let largestStep = 0;
-    let largestRoot = 1;
-    for (let i = 0; i < degree; i++) {
-      let denominator = { re: 1, im: 0 };
-      for (let j = 0; j < degree; j++) {
-        if (i !== j) denominator = multiply(denominator, subtract(estimates[i], estimates[j]));
-      }
-      if (denominator.re === 0 && denominator.im === 0) {
-        estimates[i] = { re: estimates[i].re + 1e-6 * (i + 1), im: estimates[i].im + 1e-6 };
-        continue;
-      }
-      const step = divide(evaluateAt2(monic, estimates[i]), denominator);
-      if (!Number.isFinite(step.re) || !Number.isFinite(step.im)) return null;
-      estimates[i] = subtract(estimates[i], step);
-      largestStep = Math.max(largestStep, magnitude(step));
-      largestRoot = Math.max(largestRoot, magnitude(estimates[i]));
-    }
-    if (largestStep <= DURAND_KERNER_TOLERANCE * largestRoot) return estimates;
-  }
-  return null;
-}
-function polish(monic, derivative, start) {
-  let candidate = start;
-  for (let step = 0; step < NEWTON_POLISH_STEPS; step++) {
-    const slope = evaluateAt2(derivative, candidate);
-    if (slope.re === 0 && slope.im === 0) break;
-    const next = subtract(candidate, divide(evaluateAt2(monic, candidate), slope));
-    if (!Number.isFinite(next.re) || !Number.isFinite(next.im)) break;
-    candidate = next;
-  }
-  return candidate;
-}
-function snapToAxes(monic, derivative, z) {
-  const scale2 = Math.max(1, magnitude(z));
-  if (z.im !== 0 && Math.abs(z.im) <= AXIS_SNAP_TOLERANCE * scale2) {
-    const candidate = polish(monic, derivative, { re: z.re, im: 0 });
-    if (isRootWithinTolerance(monic, candidate)) return { re: candidate.re, im: 0 };
-  }
-  if (z.re !== 0 && Math.abs(z.re) <= AXIS_SNAP_TOLERANCE * scale2) {
-    const candidate = polish(monic, derivative, { re: 0, im: z.im });
-    if (isRootWithinTolerance(monic, candidate)) return { re: 0, im: candidate.im };
-  }
-  return z;
-}
-function isRootWithinTolerance(monic, z) {
-  if (!Number.isFinite(z.re) || !Number.isFinite(z.im)) return false;
-  return magnitude(evaluateAt2(monic, z)) <= ROOT_RESIDUAL_TOLERANCE * evaluationScale(monic, z);
-}
-function pairConjugates(roots) {
-  const result = [...roots];
-  const paired = result.map((root) => root.im === 0);
-  for (let i = 0; i < result.length; i++) {
-    if (paired[i]) continue;
-    const wanted = { re: result[i].re, im: -result[i].im };
-    let partner = -1;
-    let closest = Number.POSITIVE_INFINITY;
-    for (let j = i + 1; j < result.length; j++) {
-      if (paired[j]) continue;
-      const distance = magnitude(subtract(result[j], wanted));
-      if (distance < closest) {
-        closest = distance;
-        partner = j;
-      }
-    }
-    if (partner === -1 || closest > CONJUGATE_PAIR_TOLERANCE * Math.max(1, magnitude(result[i]))) continue;
-    const re = (result[i].re + result[partner].re) / 2;
-    const im = (Math.abs(result[i].im) + Math.abs(result[partner].im)) / 2;
-    const sign = result[i].im < 0 ? -1 : 1;
-    result[i] = { re, im: sign * im };
-    result[partner] = { re, im: -sign * im };
-    paired[i] = true;
-    paired[partner] = true;
-  }
-  return result;
-}
-function allSeparated(roots) {
-  for (let i = 0; i < roots.length; i++) {
-    for (let j = i + 1; j < roots.length; j++) {
-      const scale2 = Math.max(1, magnitude(roots[i]), magnitude(roots[j]));
-      if (magnitude(subtract(roots[i], roots[j])) <= ROOT_SEPARATION_TOLERANCE * scale2) return false;
-    }
-  }
-  return true;
-}
-function approximateRoots(descending) {
-  const monic = squareFreeDoubles(descending);
-  if (monic === null) return null;
-  if (monic.length < 2) return [];
-  const converged = durandKerner(monic);
-  if (converged === null) return null;
-  const derivative = differentiate(monic);
-  const roots = pairConjugates(converged).map((root) => snapToAxes(monic, derivative, root));
-  for (const root of roots) {
-    if (!isRootWithinTolerance(monic, root)) return null;
-  }
-  if (!allSeparated(roots)) return null;
-  return [...roots].sort((a, b) => a.re - b.re || a.im - b.im);
-}
-
-// src/symbolic/Solve.ts
-var SOLVE_MAX_DEGREE = 8;
-function evaluateRational(descending, x) {
-  let total = RATIONAL_ZERO;
-  for (const coeff of descending) total = rationalAdd(rationalMul(total, x), coeff);
-  return total;
-}
-function divideByRoot2(descending, root) {
-  const quotient = [descending[0]];
-  for (let i = 1; i < descending.length - 1; i++) {
-    quotient.push(rationalAdd(descending[i], rationalMul(quotient[i - 1], root)));
-  }
-  return quotient;
-}
-function solveQuadratic(a, b, c) {
-  const discriminant = rationalSub(rationalMul(b, b), rationalMul(rational4(), rationalMul(a, c)));
-  const twoA = rationalMul(rational2(), a);
-  if (rationalCompare(discriminant, RATIONAL_ZERO) < 0) {
-    return complexQuadraticRoots(rationalNeg(b), discriminant, twoA);
-  }
-  if (isRationalZero(discriminant)) return [constNode(rationalDiv(rationalNeg(b), twoA))];
-  const rootN = exactIntegerSqrt(discriminant.n);
-  const rootD = exactIntegerSqrt(discriminant.d);
-  if (rootN !== null && rootD !== null) {
-    const root = { n: rootN, d: rootD };
-    const plus = rationalDiv(rationalAdd(rationalNeg(b), root), twoA);
-    const minus = rationalDiv(rationalSub(rationalNeg(b), root), twoA);
-    return rationalCompare(minus, plus) <= 0 ? [constNode(minus), constNode(plus)] : [constNode(plus), constNode(minus)];
-  }
-  const surd = surdNode(discriminant);
-  const ascending = rationalCompare(twoA, RATIONAL_ZERO) > 0;
-  const lower = { kind: "div", left: { kind: "sub", left: constNode(rationalNeg(b)), right: surd }, right: constNode(twoA) };
-  const upper = { kind: "div", left: { kind: "add", left: constNode(rationalNeg(b)), right: surd }, right: constNode(twoA) };
-  return ascending ? [lower, upper] : [upper, lower];
-}
-function complexQuadraticRoots(negatedB, discriminant, twoA) {
-  const magnitude2 = rationalNeg(discriminant);
-  const rootN = exactIntegerSqrt(magnitude2.n);
-  const rootD = exactIntegerSqrt(magnitude2.d);
-  if (rootN !== null && rootD !== null) {
-    const imaginary2 = rationalDiv({ n: rootN, d: rootD }, twoA);
-    const real2 = rationalDiv(negatedB, twoA);
-    return [
-      complexNode(complex(real2, rationalNeg(imaginary2))),
-      complexNode(complex(real2, imaginary2))
-    ];
-  }
-  const real = rationalDiv(negatedB, twoA);
-  const scaledRadicand = rationalDiv(magnitude2, rationalMul(twoA, twoA));
-  const imaginary = { kind: "mul", left: surdNode(scaledRadicand), right: complexNode(COMPLEX_I) };
-  if (isRationalZero(real)) {
-    return [{ kind: "neg", operand: imaginary }, imaginary];
-  }
-  return [
-    { kind: "sub", left: constNode(real), right: imaginary },
-    { kind: "add", left: constNode(real), right: imaginary }
-  ];
-}
-function rational2() {
-  return { n: 2n, d: 1n };
-}
-function rational4() {
-  return { n: 4n, d: 1n };
-}
-function realApproximation(value) {
-  return { re: value, im: 0 };
-}
-function solveForVariable(lhs, rhs, variable) {
-  const polynomial = toPolynomial({ kind: "sub", left: lhs, right: rhs });
-  if (polynomial === null) {
-    return {
-      kind: "unsupported",
-      reason: "this is not a polynomial equation (it divides by an unknown, or calls a function of one)"
-    };
-  }
-  const others = polynomial.vars.filter((name) => name !== variable);
-  const degree = polyDegree(polynomial, variable);
-  if (others.length > 0) {
-    if (degree !== 1) {
-      return {
-        kind: "unsupported",
-        reason: `solving for "${variable}" needs the equation to be linear in it when other unknowns (${others.join(", ")}) are present`
-      };
-    }
-    return solveLinearWithOtherUnknowns(polynomial, variable);
-  }
-  if (degree === 0) {
-    return polynomial.terms.size === 0 ? { kind: "identity" } : { kind: "contradiction" };
-  }
-  if (degree > SOLVE_MAX_DEGREE) {
-    return { kind: "unsupported", reason: `degree ${degree} is above the supported maximum of ${SOLVE_MAX_DEGREE}` };
-  }
-  const descending = [...polyCoefficients(polynomial, variable)].reverse();
-  return solveUnivariate(descending);
-}
-function solveLinearWithOtherUnknowns(polynomial, variable) {
-  const coefficientTerms = /* @__PURE__ */ new Map();
-  const constantTerms = /* @__PURE__ */ new Map();
-  for (const [key, coeff] of polynomial.terms) {
-    const factors = key.split("*").filter((part) => part.length > 0);
-    const index = factors.indexOf(variable);
-    if (index === -1) {
-      constantTerms.set(key, coeff);
-    } else {
-      factors.splice(index, 1);
-      coefficientTerms.set(factors.join("*"), coeff);
-    }
-  }
-  const namesOf2 = (terms) => {
-    const names = /* @__PURE__ */ new Set();
-    for (const key of terms.keys()) {
-      for (const part of key.split("*")) {
-        if (part.length > 0) names.add(part.split("^")[0]);
-      }
-    }
-    return [...names].sort();
-  };
-  const coefficient = fromPolynomial({ terms: coefficientTerms, vars: namesOf2(coefficientTerms) });
-  const constant = fromPolynomial({ terms: constantTerms, vars: namesOf2(constantTerms) });
-  return {
-    kind: "roots",
-    exact: [{ kind: "div", left: { kind: "neg", operand: constant }, right: coefficient }],
-    approximate: []
-  };
-}
-function closedFormRoots(descending) {
-  if (descending.length === 4) {
-    return solveCubic(descending[0], descending[1], descending[2], descending[3]);
-  }
-  if (descending.length === 5) {
-    return solveQuartic(descending[0], descending[1], descending[2], descending[3], descending[4], solveQuadratic);
-  }
-  return null;
-}
-function extractRationalRoots(descending) {
-  const roots = [];
-  let remaining = [...descending];
-  let powersOfX = 0;
-  while (remaining.length > 1 && isRationalZero(remaining[remaining.length - 1])) {
-    remaining = remaining.slice(0, -1);
-    powersOfX++;
-  }
-  if (powersOfX > 0) roots.push(RATIONAL_ZERO);
-  while (remaining.length > 1) {
-    const found = rationalRoots(remaining);
-    if (found.length === 0) break;
-    for (const root of found) {
-      let multiplicity = 0;
-      while (remaining.length > 1 && isRationalZero(evaluateRational(remaining, root))) {
-        remaining = divideByRoot2(remaining, root);
-        multiplicity++;
-      }
-      if (multiplicity > 0) roots.push(root);
-    }
-  }
-  return { roots: roots.sort(rationalCompare), remaining };
-}
-function solveUnivariate(descending) {
-  const { roots, remaining } = extractRationalRoots(descending);
-  const exact = roots.map(constNode);
-  const approximate = [];
-  const leftoverDegree = remaining.length - 1;
-  const solvedDegree = descending.length - remaining.length;
-  if (leftoverDegree <= 0) return finish(exact, approximate, solvedDegree, 0, "");
-  if (leftoverDegree === 1) {
-    exact.push(constNode(rationalDiv(rationalNeg(remaining[1]), remaining[0])));
-    return finish(exact, approximate, solvedDegree + 1, 0, "");
-  }
-  if (leftoverDegree === 2) {
-    exact.push(...solveQuadratic(remaining[0], remaining[1], remaining[2]));
-    return finish(exact, approximate, solvedDegree + 2, 0, "");
-  }
-  const closedForm = closedFormRoots(remaining);
-  if (closedForm !== null) {
-    exact.push(...closedForm.exact);
-    approximate.push(...closedForm.approximate.map(realApproximation));
-    return finish(exact, approximate, solvedDegree + leftoverDegree, 0, "");
-  }
-  const numeric = approximateRoots(remaining);
-  if (numeric !== null) {
-    approximate.push(...numeric);
-    return finish(exact, approximate, solvedDegree + leftoverDegree, 0, "");
-  }
-  return finish(
-    exact,
-    approximate,
-    solvedDegree,
-    leftoverDegree,
-    `a degree-${leftoverDegree} factor of it has no exact solution here and the numerical method did not converge on that factor`
-  );
-}
-function finish(exact, approximate, solvedDegree, unsolvedDegree, reason) {
-  const found = exact.length + approximate.length;
-  const incoherent = solvedDegree >= 1 && (found < 1 || found > solvedDegree);
-  if (unsolvedDegree > 0 || incoherent) {
-    return {
-      kind: "incomplete",
-      exact,
-      approximate,
-      // A distinct root can stand for several equal ones, so the count found
-      // is a lower bound on what it covers. The degree left unsolved is not.
-      missing: incoherent ? Math.max(1, solvedDegree + unsolvedDegree - found) : unsolvedDegree,
-      reason: incoherent ? `${found} root${found === 1 ? "" : "s"} were produced for a degree-${solvedDegree + unsolvedDegree} equation, which does not add up` : reason
-    };
-  }
-  return { kind: "roots", exact, approximate };
-}
-
-// src/vm/SymbolicOps.ts
-var SYMBOLIC_BUILTIN_NAMES = {
-  0: "sqrt",
-  1: "abs",
-  2: "sin",
-  3: "cos",
-  4: "tan",
-  5: "log",
-  6: "ceil",
-  7: "floor",
-  8: "round",
-  11: "asin",
-  12: "acos",
-  13: "atan",
-  14: "atan2",
-  15: "sinh",
-  16: "cosh",
-  17: "tanh",
-  18: "asinh",
-  19: "acosh",
-  20: "atanh",
-  21: "cbrt",
-  23: "expm1",
-  24: "exp",
-  26: "hypot",
-  28: "log10",
-  29: "log1p",
-  30: "log2",
-  33: "sign",
-  34: "trunc",
-  // Spelled exactly as `builtinNameToIndex` accepts them, all lower case. A
-  // `call` node's name is what gets displayed, so a name the parser would not
-  // accept back would render an expression the user cannot retype.
-  35: "degtorad",
-  36: "radtodeg",
-  61: "root",
-  62: "fact"
-};
-var POW_BUILTIN_INDEX = 31;
-var SYMBOLIC_NATIVE_BUILTINS = /* @__PURE__ */ new Set([67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79]);
-function valueToSymbolic(v) {
-  if (v.type === 9 /* Symbolic */) return v.value;
-  if (v.type === 13 /* Error */ || v.type === 12 /* Pending */) return null;
-  const numeric = v.toNumber();
-  if (!Number.isFinite(numeric)) return null;
-  return constNode(rationalFromNumber(numeric));
-}
-function symbolicToValue(node) {
-  const simplified = simplifySymbolic(node);
-  if (simplified.kind === "const") return numberValue(rationalToNumber(simplified.value));
-  return symbolicValue(simplified);
-}
-function unsupported(what) {
-  return errorValue(
-    "SYMBOLIC_UNSUPPORTED_FUNCTION",
-    `"${what}" cannot be applied to an expression that still contains an unknown.`
-  );
-}
-function symbolicPow(l, r) {
-  const base = valueToSymbolic(l);
-  const exponent = valueToSymbolic(r);
-  if (base === null || exponent === null) return unsupported("^");
-  return symbolicToValue(powNode(base, exponent));
-}
-function symbolicNeg(v) {
-  const operand = valueToSymbolic(v);
-  if (operand === null) return unsupported("-");
-  return symbolicToValue({ kind: "neg", operand });
-}
-function symbolicBuiltin(index, args) {
-  const nodes = [];
-  for (const arg of args) {
-    const faulted = faultedOperand(arg);
-    if (faulted) return faulted;
-    const node = valueToSymbolic(arg);
-    if (node === null) return unsupported(SYMBOLIC_BUILTIN_NAMES[index] ?? `builtin ${index}`);
-    nodes.push(node);
-  }
-  if (index === POW_BUILTIN_INDEX && nodes.length === 2) {
-    return symbolicToValue(powNode(nodes[0], nodes[1]));
-  }
-  const name = SYMBOLIC_BUILTIN_NAMES[index];
-  if (name === void 0) return unsupported(`builtin ${index}`);
-  return symbolicToValue(callNode(name, nodes));
-}
-function rootToValue(root) {
-  const value = symbolicToValue(root);
-  if (value.type === 0 /* Number */ && !Number.isInteger(value.toNumber())) return symbolicValue(root);
-  return value;
-}
-function approximateRootToValue(root) {
-  if (root.im === 0) return numberValue(root.re);
-  return symbolicValue(complexNode(complex(rationalFromNumber(root.re), rationalFromNumber(root.im))));
-}
-function solveOutcomeToValue(outcome) {
-  switch (outcome.kind) {
-    case "identity":
-      return stringValue("true for every value");
-    case "contradiction":
-      return stringValue("no solution");
-    case "unsupported":
-      return errorValue("SYMBOLIC_SOLVE_UNSUPPORTED", `Cannot solve this equation: ${outcome.reason}.`);
-    case "incomplete": {
-      const found = outcome.exact.length + outcome.approximate.length;
-      return errorValue(
-        "SYMBOLIC_SOLVE_INCOMPLETE",
-        `Only ${found} of this equation's ${found + outcome.missing} roots could be found: ${outcome.reason}.`
-      );
-    }
-    case "roots": {
-      const values = outcome.exact.map(rootToValue);
-      for (const approximate of outcome.approximate) values.push(approximateRootToValue(approximate));
-      if (values.length === 0) return stringValue("no solution");
-      if (values.length === 1) return values[0];
-      return matrixValue(1, values.length, values.map((v) => v.type === 9 /* Symbolic */ ? v.value : v.toNumber()));
-    }
-  }
-}
-function solveEquationValues(lhsValue, rhsValue, variable) {
-  const lhs = valueToSymbolic(lhsValue);
-  const rhs = valueToSymbolic(rhsValue);
-  if (lhs === null || rhs === null) {
-    return errorValue("SYMBOLIC_NONFINITE_OPERAND", "An equation side has no exact value to solve with.");
-  }
-  return solveOutcomeToValue(solveForVariable(lhs, rhs, variable));
-}
-
-// src/vm/VMConversion.ts
-function unifyUom(l, r) {
-  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */) {
-    if (l.unit === r.unit) {
-      return { lv: l.toNumber(), rv: r.toNumber(), unit: l.unit, sameMeasure: true };
-    }
-    const lMeasure = getMeasure(l.unit);
-    const rMeasure = getMeasure(r.unit);
-    const isCurrency = sharedCurrencyExchange.isCurrency(l.unit) && sharedCurrencyExchange.isCurrency(r.unit);
-    if (lMeasure && lMeasure === rMeasure) {
-      const rvConverted = convertUnit(r.toNumber(), r.unit, l.unit);
-      return { lv: l.toNumber(), rv: rvConverted, unit: l.unit, sameMeasure: true };
-    }
-    if (isCurrency) {
-      const rvConverted = sharedCurrencyExchange.convertSync(r.toNumber(), r.unit, l.unit);
-      if (rvConverted !== null) {
-        return { lv: l.toNumber(), rv: rvConverted, unit: l.unit, sameMeasure: true };
-      }
-    }
-    return { lv: l.toNumber(), rv: r.toNumber(), unit: void 0, sameMeasure: false };
-  }
-  if (l.type === 6 /* Uom */) {
-    return { lv: l.toNumber(), rv: r.toNumber(), unit: l.unit, sameMeasure: true };
-  }
-  if (r.type === 6 /* Uom */) {
-    return { lv: l.toNumber(), rv: r.toNumber(), unit: r.unit, sameMeasure: true };
-  }
-  return { lv: l.toNumber(), rv: r.toNumber(), unit: void 0, sameMeasure: true };
-}
-var UNIFIED_COMPARISON_TOLERANCE = 1e-12;
-function largestFiniteMagnitude(a, b, c) {
-  let scale2 = 0;
-  if (Number.isFinite(a) && Math.abs(a) > scale2) scale2 = Math.abs(a);
-  if (Number.isFinite(b) && Math.abs(b) > scale2) scale2 = Math.abs(b);
-  if (Number.isFinite(c) && Math.abs(c) > scale2) scale2 = Math.abs(c);
-  return scale2;
-}
-function compareUom(l, r) {
-  const { lv, rv, sameMeasure } = unifyUom(l, r);
-  if (!sameMeasure) return { lv, rv, equal: false, sameMeasure: false };
-  if (l.type === 6 /* Uom */ && r.type === 6 /* Uom */ && l.unit !== void 0 && l.unit === r.unit && l.exact !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit)) {
-    return { lv, rv, equal: decimalCompare(l.exact, r.exact) === 0, sameMeasure: true };
-  }
-  if (lv === rv) return { lv, rv, equal: true, sameMeasure: true };
-  if (!Number.isFinite(lv) || !Number.isFinite(rv)) return { lv, rv, equal: false, sameMeasure: true };
-  const scale2 = largestFiniteMagnitude(lv, rv, r.toNumber());
-  return { lv, rv, equal: Math.abs(lv - rv) <= scale2 * UNIFIED_COMPARISON_TOLERANCE, sameMeasure: true };
-}
-var MEASURE_NOUNS = {
-  time: "duration",
-  luminousIntensity: "luminous intensity"
-};
-var UNCOUNTABLE_MEASURES = /* @__PURE__ */ new Set(["money", "data"]);
-var COMBINE_VERBS = {
-  add: "added",
-  sub: "subtracted",
-  mul: "multiplied",
-  div: "divided"
-};
-function describeMeasure(unit) {
-  if (sharedCurrencyExchange.isCurrency(unit)) return "money";
-  const measure = getMeasure(unit);
-  if (measure === void 0) return void 0;
-  return MEASURE_NOUNS[measure] ?? measure;
-}
-function withMeasureArticle(noun) {
-  if (UNCOUNTABLE_MEASURES.has(noun)) return noun;
-  return /^[aeiou]/.test(noun) ? `an ${noun}` : `a ${noun}`;
-}
-function describeMeasureMismatch(lUnit, rUnit, verb) {
-  const left = lUnit === void 0 ? void 0 : describeMeasure(lUnit);
-  const right = rUnit === void 0 ? void 0 : describeMeasure(rUnit);
-  if (left !== void 0 && right !== void 0 && left !== right) {
-    return `${left} and ${right} cannot be ${verb}`;
-  }
-  return void 0;
-}
-function combineVerb(op) {
-  return op !== void 0 ? COMBINE_VERBS[op] ?? "combined" : "combined";
-}
-function describeConversionMismatch(fromUnit, toUnit) {
-  const from = describeMeasure(fromUnit);
-  const to = describeMeasure(toUnit);
-  if (from !== void 0 && to !== void 0 && from !== to) {
-    return `${withMeasureArticle(from)} cannot be converted to ${withMeasureArticle(to)}`;
-  }
-  return void 0;
-}
-function incomparableUnitsError(l, r) {
-  const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
-  const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-  const named = describeMeasureMismatch(lUnit, rUnit, "compared");
-  return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot compare incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
-}
-function toBigIntOperand(v) {
-  if (v.type === 2 /* BigInt */) return v.value;
-  const n = v.toNumber();
-  if (!Number.isInteger(n)) {
-    const shown = Number.isNaN(n) ? "NaN" : String(n);
-    throw ErrorFactory.execution(
-      "BIGINT_INEXACT_OPERAND",
-      `A whole-number (n) value can only be combined with another whole number, and ${shown} is not one`,
-      { operand: shown }
-    );
-  }
-  return BigInt(n);
-}
-function bigIntDivisionByZero() {
-  return ErrorFactory.execution(
-    "BIGINT_DIVISION_BY_ZERO",
-    "Division by zero: a whole-number (n) division is exact integer division, which has no answer at zero, unlike 1 / 0 which is Infinity"
-  );
-}
-function compareBigIntOperands(l, r) {
-  const lb = exactBigInt(l);
-  const rb = exactBigInt(r);
-  if (lb === null || rb === null) return null;
-  if (lb < rb) return -1;
-  if (lb > rb) return 1;
-  return 0;
-}
-function exactBigInt(v) {
-  if (v.type === 2 /* BigInt */) return v.value;
-  const n = v.toNumber();
-  return Number.isInteger(n) ? BigInt(n) : null;
-}
-function power(base, exponent) {
-  if (Number.isFinite(exponent)) return Math.pow(base, exponent);
-  if (base === 1) return 1;
-  if (base === -1 && !Number.isNaN(exponent)) return 1;
-  return Math.pow(base, exponent);
-}
-function operandExactDecimal(v) {
-  if (v.exact !== void 0) return v.exact;
-  return decimalFromNumberIfExact(v.toNumber());
-}
-function exactMoneyOp(l, r, op) {
-  const lMoney = l.type === 6 /* Uom */ && l.unit !== void 0 && l.exact !== void 0 && sharedCurrencyExchange.isCurrency(l.unit);
-  const rMoney = r.type === 6 /* Uom */ && r.unit !== void 0 && r.exact !== void 0 && sharedCurrencyExchange.isCurrency(r.unit);
-  if (!lMoney && !rMoney) return null;
-  let ld;
-  let rd;
-  let unit;
-  if (lMoney && rMoney) {
-    if (l.unit !== r.unit || op === "div") return null;
-    ld = l.exact;
-    rd = r.exact;
-    unit = l.unit;
-  } else if (lMoney && r.type !== 6 /* Uom */) {
-    ld = l.exact;
-    unit = l.unit;
-    rd = operandExactDecimal(r);
-  } else if (rMoney && l.type !== 6 /* Uom */) {
-    rd = r.exact;
-    unit = r.unit;
-    ld = operandExactDecimal(l);
-  } else {
-    return null;
-  }
-  if (ld === null || rd === null) return null;
-  let result;
-  switch (op) {
-    case "add":
-      result = decimalAdd(ld, rd);
-      break;
-    case "sub":
-      result = decimalSubtract(ld, rd);
-      break;
-    case "mul":
-      result = decimalMultiply(ld, rd);
-      break;
-    case "div":
-      if (decimalIsZero(rd)) return null;
-      result = decimalDivide(ld, rd);
-      break;
-  }
-  return uomValueExact(decimalToNumber(result), unit, result);
-}
-function operandRational(v) {
-  if (v.rational !== void 0) return v.rational;
-  if ((v.type === 0 /* Number */ || v.type === 1 /* Hex */) && typeof v.value === "number" && Number.isInteger(v.value)) {
-    return rational(BigInt(v.value));
-  }
-  return null;
-}
-function exactRationalOp(l, r, op) {
-  const lr = operandRational(l);
-  if (lr === null) return null;
-  const rr = operandRational(r);
-  if (rr === null) return null;
-  if (op === "div" && isRationalZero(rr)) return null;
-  let result;
-  try {
-    switch (op) {
-      case "add":
-        result = rationalAdd(lr, rr);
-        break;
-      case "sub":
-        result = rationalSub(lr, rr);
-        break;
-      case "mul":
-        result = rationalMul(lr, rr);
-        break;
-      case "div":
-        result = rationalDiv(lr, rr);
-        break;
-    }
-  } catch {
-    return null;
-  }
-  return numberValueRational(rationalToNumber(result), result);
-}
-function uncertainOp(l, r, op) {
-  if (l.type !== 0 /* Number */ || r.type !== 0 /* Number */) return null;
-  const a = l.value;
-  const b = r.value;
-  const sa = l.uncertainty ?? 0;
-  const sb = r.uncertainty ?? 0;
-  let center;
-  let sigma;
-  switch (op) {
-    case "add":
-      center = a + b;
-      sigma = Math.hypot(sa, sb);
-      break;
-    case "sub":
-      center = a - b;
-      sigma = Math.hypot(sa, sb);
-      break;
-    case "mul":
-      center = a * b;
-      sigma = Math.hypot(b * sa, a * sb);
-      break;
-    case "div":
-      center = a / b;
-      sigma = Math.hypot(sa / b, a * sb / (b * b));
-      break;
-  }
-  return numberValueUncertain(center, sigma);
-}
-function compareRationalOperands(l, r) {
-  const lr = operandRational(l);
-  if (lr === null) return null;
-  const rr = operandRational(r);
-  if (rr === null) return null;
-  return rationalCompare(lr, rr);
-}
-function binaryOp(l, r, op, bigOp, symbolicOp) {
-  if (l.type === 13 /* Error */) return l;
-  if (r.type === 13 /* Error */) return r;
-  if (l.type === 12 /* Pending */) return l;
-  if (r.type === 12 /* Pending */) return r;
-  if (symbolicOp && (l.type === 9 /* Symbolic */ || r.type === 9 /* Symbolic */)) {
-    const left = valueToSymbolic(l);
-    const right = valueToSymbolic(r);
-    if (left === null || right === null) {
-      return errorValue(
-        "SYMBOLIC_NONFINITE_OPERAND",
-        "A symbolic expression cannot combine with a value that has no exact number (NaN or infinity)."
-      );
-    }
-    const node = { kind: symbolicOp, left, right };
-    return symbolicValue(simplifySymbolic(node));
-  }
-  if (l.type === 0 /* Number */ && r.type === 0 /* Number */) {
-    return numberValue(op(l.value, r.value));
-  }
-  if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-    const lb = toBigIntOperand(l);
-    const rb = toBigIntOperand(r);
-    if (bigOp) return bigIntValue(bigOp(lb, rb));
-    return bigIntValue(lb + rb);
-  }
-  if (l.type === 6 /* Uom */ || r.type === 6 /* Uom */) {
-    if (symbolicOp) {
-      const exactMoney = exactMoneyOp(l, r, symbolicOp);
-      if (exactMoney) return exactMoney;
-    }
-    const { lv, rv, unit, sameMeasure } = unifyUom(l, r);
-    if (!sameMeasure) {
-      const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
-      const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
-      const named = describeMeasureMismatch(lUnit, rUnit, combineVerb(symbolicOp));
-      return errorValue("INCOMPATIBLE_UNITS", named ?? `Cannot combine incompatible units: ${lUnit ?? "?"} and ${rUnit ?? "?"}`);
-    }
-    return uomValue(op(lv, rv), unit);
-  }
-  if (l.type === 7 /* Matrix */ && r.type === 7 /* Matrix */) {
-    const lm = l.value;
-    const rm = r.value;
-    if (!sameShape(lm, rm)) {
-      return errorValue("DIMENSION_MISMATCH", `Cannot combine matrices of different shapes: ${lm.rows}x${lm.cols} and ${rm.rows}x${rm.cols}`);
-    }
-    const result = new Array(lm.data.length);
-    for (let i = 0; i < lm.data.length; i++) result[i] = op(lm.data[i], rm.data[i]);
-    return matrixValue(lm.rows, lm.cols, result);
-  }
-  if (l.type === 7 /* Matrix */) {
-    const lm = l.value;
-    const scalar = r.toNumber();
-    const result = lm.data.map((v) => op(v, scalar));
-    return matrixValue(lm.rows, lm.cols, result);
-  }
-  if (r.type === 7 /* Matrix */) {
-    const rm = r.value;
-    const scalar = l.toNumber();
-    const result = rm.data.map((v) => op(scalar, v));
-    return matrixValue(rm.rows, rm.cols, result);
-  }
-  return numberValue(op(l.toNumber(), r.toNumber()));
-}
-
-// src/vm/OpRegistry.ts
-var MAX_OPCODE = 254;
-var DYNAMIC_OPCODE_START = 200;
-var OpRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-    this.nextOpcode = DYNAMIC_OPCODE_START + 1;
-  }
-  register(registration) {
-    this.handlers.set(registration.opcode, registration.handler);
-  }
-  /**
-   * Remove a previously registered opcode handler.
-   * Used by package unregistration to reverse shared-registry contributions.
-   */
-  unregister(opcode) {
-    this.handlers.delete(opcode);
-  }
-  get(opcode) {
-    return this.handlers.get(opcode);
-  }
-  has(opcode) {
-    return this.handlers.has(opcode);
-  }
-  /**
-   * Allocate a unique opcode for a plugin's custom bytecode handler.
-   *
-   * Returns the next available opcode (starting at 201). Each call
-   * returns a distinct value. Plugins should call this once during
-   * registration and store the result.
-   *
-   * @throws If the dynamic opcode pool is exhausted.
-   * @returns A unique opcode number for the calling plugin.
-   */
-  allocateOpcode() {
-    if (this.nextOpcode > MAX_OPCODE) {
-      throw ErrorFactory.config(
-        "OPCODE_POOL_EXHAUSTED",
-        `OpRegistry: dynamic opcode pool exhausted (max ${MAX_OPCODE - DYNAMIC_OPCODE_START} allocations).`
-      );
-    }
-    return this.nextOpcode++;
-  }
-};
-var sharedOpRegistry = new OpRegistry();
-
-// src/vm/MoneyExact.ts
-var ONE_DECIMAL = decimalFromInteger(1);
-function moneyExactMagnitude(operand, unit) {
-  if (!sharedCurrencyExchange.isCurrency(unit)) return null;
-  return operand.exact ?? decimalFromNumberIfExact(operand.toNumber());
-}
-function decimalFromShortDecimal(n) {
-  if (!Number.isFinite(n)) return null;
-  if (Number.isInteger(n)) return decimalFromInteger(BigInt(n));
-  const s = String(n);
-  if (!/^-?\d+\.\d+$/.test(s)) return null;
-  return decimalFromLiteral(s);
-}
-function scaleMoneyExact(amount, factor, unit) {
-  const base = moneyExactMagnitude(amount, unit);
-  const factorDecimal = decimalFromShortDecimal(factor);
-  if (base !== null && factorDecimal !== null) {
-    const result = decimalMultiply(base, factorDecimal);
-    return uomValueExact(decimalToNumber(result), unit, result);
-  }
-  return uomValue(amount.toNumber() * factor, unit);
-}
-function scaleMoneyByPercent(money, unit, percent, sign) {
-  const base = moneyExactMagnitude(money, unit);
-  const percentDecimal = decimalFromShortDecimal(percent);
-  if (base !== null && percentDecimal !== null) {
-    const factor = decimalAdd(ONE_DECIMAL, sign === 1 ? percentDecimal : decimalNegate(percentDecimal));
-    const result = decimalMultiply(base, factor);
-    return uomValueExact(decimalToNumber(result), unit, result);
-  }
-  return uomValue(money.toNumber() * (1 + sign * percent), unit);
-}
-function onePlusRateDecimal(rate) {
-  const rateDecimal = decimalFromShortDecimal(rate);
-  return rateDecimal === null ? null : decimalAdd(ONE_DECIMAL, rateDecimal);
-}
-function removeTaxExact(money, unit, rate) {
-  const base = moneyExactMagnitude(money, unit);
-  const divisor = onePlusRateDecimal(rate);
-  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
-  const quotient = decimalDivide(base, divisor);
-  return uomValueExact(decimalToNumber(quotient), unit, quotient);
-}
-function taxInExact(money, unit, rate) {
-  const base = moneyExactMagnitude(money, unit);
-  const divisor = onePlusRateDecimal(rate);
-  if (base === null || divisor === null || decimalIsZero(divisor)) return null;
-  const tax = decimalSubtract(base, decimalDivide(base, divisor));
-  return uomValueExact(decimalToNumber(tax), unit, tax);
-}
-function splitEachExact(amount, n) {
-  const unit = amount.unit;
-  const cents = unit !== void 0 && sharedCurrencyExchange.isCurrency(unit) ? centsOfMoney(amount, unit) : null;
-  if (cents === null) {
-    return { unit, shares: [{ value: amount.toNumber() / n, count: n }] };
-  }
-  const divisor = BigInt(n);
-  const baseCents = cents / divisor;
-  const remainder = cents - baseCents * divisor;
-  const extraShares = Number(remainder < 0n ? -remainder : remainder);
-  const step = cents < 0n ? -1n : 1n;
-  const base = centShare(baseCents, n - extraShares);
-  if (extraShares === 0) return { unit, shares: [base] };
-  return { unit, shares: [base, centShare(baseCents + step, extraShares)] };
-}
-function centShare(cents, count) {
-  const exact = makeDecimal(cents, 2);
-  return { value: decimalToNumber(exact), exact, count };
-}
-function centsOfMoney(amount, unit) {
-  const base = moneyExactMagnitude(amount, unit);
-  return base === null ? null : decimalRound(base, 2).coef;
-}
-
-// src/symbolic/PartialFractions.ts
-var APART_MAX_DEGREE = 12;
-function multiply2(a, b) {
-  if (a.length === 0 || b.length === 0) return [];
-  const product2 = new Array(a.length + b.length - 1).fill(RATIONAL_ZERO);
-  a.forEach((left, i) => {
-    b.forEach((right, j) => {
-      product2[i + j] = rationalAdd(product2[i + j], rationalMul(left, right));
-    });
-  });
-  return product2;
-}
-function power2(base, exponent) {
-  let result = [RATIONAL_ONE];
-  for (let i = 0; i < exponent; i++) result = multiply2(result, base);
-  return result;
-}
-function scale(coefficients, factor) {
-  return coefficients.map((coefficient) => rationalDiv(coefficient, factor));
-}
-function denominatorFactors(ascending, variable) {
-  const factors = [];
-  let lowest = 0;
-  while (lowest < ascending.length && isRationalZero(ascending[lowest])) lowest++;
-  if (lowest > 0) factors.push({ base: [RATIONAL_ZERO, RATIONAL_ONE], power: lowest });
-  const remaining = ascending.slice(lowest);
-  if (remaining.length > 1) {
-    const factorization = factorUnivariate([...remaining].reverse(), variable);
-    for (const factor of factorization.factors) {
-      const polynomial = toPolynomial(factor.base);
-      if (polynomial === null) return null;
-      factors.push({ base: [...polyCoefficients(polynomial, variable)], power: factor.power });
-    }
-  }
-  return factors.length > 0 ? factors : null;
-}
-function enumerateUnknowns(factors) {
-  const unknowns = [];
-  factors.forEach((factor, index) => {
-    const factorDegree = factor.base.length - 1;
-    for (let p = 1; p <= factor.power; p++) {
-      for (let degree = 0; degree < factorDegree; degree++) {
-        unknowns.push({ factor: index, power: p, degree });
-      }
-    }
-  });
-  return unknowns;
-}
-function unknownColumn(unknown, factors, denominator) {
-  const divisor = power2(factors[unknown.factor].base, unknown.power);
-  const { quotient, remainder } = polynomialDivide(denominator, divisor);
-  if (!isZeroPolynomial(remainder)) return null;
-  const shift = new Array(unknown.degree).fill(RATIONAL_ZERO);
-  shift.push(RATIONAL_ONE);
-  return multiply2(quotient, shift);
-}
-function solveLinearSystem(matrix, target) {
-  const size = target.length;
-  for (let column = 0; column < size; column++) {
-    let pivot = -1;
-    for (let row = column; row < size; row++) {
-      if (!isRationalZero(matrix[row][column])) {
-        pivot = row;
-        break;
-      }
-    }
-    if (pivot === -1) return null;
-    [matrix[column], matrix[pivot]] = [matrix[pivot], matrix[column]];
-    [target[column], target[pivot]] = [target[pivot], target[column]];
-    for (let row = 0; row < size; row++) {
-      if (row === column || isRationalZero(matrix[row][column])) continue;
-      const factor = rationalDiv(matrix[row][column], matrix[column][column]);
-      for (let k = column; k < size; k++) {
-        matrix[row][k] = rationalSub(matrix[row][k], rationalMul(factor, matrix[column][k]));
-      }
-      target[row] = rationalSub(target[row], rationalMul(factor, target[column]));
-    }
-  }
-  return target.map((value, index) => rationalDiv(value, matrix[index][index]));
-}
-function partialFractions(numerator, denominator, variable) {
-  if (denominator.length < 2 || denominator.length - 1 > APART_MAX_DEGREE) return null;
-  const shared = coefficientGcd(numerator, denominator);
-  const reducedNumerator = shared.length > 1 ? polynomialDivide(numerator, shared).quotient : [...numerator];
-  const reducedDenominator = shared.length > 1 ? polynomialDivide(denominator, shared).quotient : [...denominator];
-  if (reducedDenominator.length === 1) {
-    return { polynomial: scale(reducedNumerator, reducedDenominator[0]), terms: [] };
-  }
-  if (reducedDenominator.length === 0) return null;
-  const leading = reducedDenominator[reducedDenominator.length - 1];
-  const monicDenominator = scale(reducedDenominator, leading);
-  const scaledNumerator = scale(reducedNumerator, leading);
-  const { quotient, remainder } = polynomialDivide(scaledNumerator, monicDenominator);
-  if (isZeroPolynomial(remainder)) return { polynomial: quotient, terms: [] };
-  const factors = denominatorFactors(monicDenominator, variable);
-  if (factors === null) return null;
-  const terms = solveForNumerators(factors, monicDenominator, remainder);
-  return terms === null ? null : { polynomial: quotient, terms };
-}
-function solveForNumerators(factors, denominator, remainder) {
-  const unknowns = enumerateUnknowns(factors);
-  const size = denominator.length - 1;
-  if (unknowns.length !== size) return null;
-  const columns = [];
-  for (const unknown of unknowns) {
-    const column = unknownColumn(unknown, factors, denominator);
-    if (column === null) return null;
-    columns.push(column);
-  }
-  const matrix = [];
-  for (let row = 0; row < size; row++) {
-    matrix.push(columns.map((column) => column[row] ?? RATIONAL_ZERO));
-  }
-  const target = [];
-  for (let row = 0; row < size; row++) target.push(remainder[row] ?? RATIONAL_ZERO);
-  const solution = solveLinearSystem(matrix, target);
-  if (solution === null) return null;
-  return groupSolution(unknowns, solution, factors);
-}
-function groupSolution(unknowns, solution, factors) {
-  const grouped = /* @__PURE__ */ new Map();
-  unknowns.forEach((unknown, index) => {
-    const key = `${unknown.factor}:${unknown.power}`;
-    const existing = grouped.get(key) ?? [];
-    existing[unknown.degree] = solution[index];
-    grouped.set(key, existing);
-  });
-  const terms = [];
-  for (const [key, coefficients] of grouped) {
-    const [factorIndex, termPower] = key.split(":").map(Number);
-    const filled = [...coefficients].map((value) => value ?? RATIONAL_ZERO);
-    if (filled.every(isRationalZero)) continue;
-    terms.push({ numerator: filled, base: factors[factorIndex].base, power: termPower });
-  }
-  return terms;
-}
-function coefficientsToNode2(coefficients, variable) {
-  const terms = /* @__PURE__ */ new Map();
-  coefficients.forEach((coefficient, exponent) => {
-    if (isRationalZero(coefficient)) return;
-    terms.set(exponent === 0 ? "" : exponent === 1 ? variable : `${variable}^${exponent}`, coefficient);
-  });
-  if (terms.size === 0) return constNode(RATIONAL_ZERO);
-  return fromPolynomial({ terms, vars: coefficients.length > 1 ? [variable] : [] });
-}
-function apartSymbolic(node) {
-  const parts = asRationalFunction(node);
-  if (parts === null) return node;
-  const decomposition = partialFractions(parts.numerator, parts.denominator, parts.variable);
-  if (decomposition === null || decomposition.terms.length === 0) return node;
-  let result = decomposition.polynomial.length > 0 ? coefficientsToNode2(decomposition.polynomial, parts.variable) : null;
-  for (const term of decomposition.terms) {
-    const base = coefficientsToNode2(term.base, parts.variable);
-    const denominator = term.power === 1 ? base : powNode(base, constNode({ n: BigInt(term.power), d: 1n }));
-    const negative = isNegativeNumerator(term.numerator);
-    const numerator = negative ? term.numerator.map((coefficient) => rationalNeg(coefficient)) : term.numerator;
-    const piece = {
-      kind: "div",
-      left: coefficientsToNode2(numerator, parts.variable),
-      right: denominator
-    };
-    if (result === null) result = negative ? { kind: "neg", operand: piece } : piece;
-    else result = { kind: negative ? "sub" : "add", left: result, right: piece };
-  }
-  return result === null ? node : simplifySymbolic(result);
-}
-function isNegativeNumerator(coefficients) {
-  return coefficients.some((coefficient) => coefficient.n < 0n) && coefficients.every((coefficient) => coefficient.n <= 0n);
-}
-function asRationalFunction(node) {
-  if (node.kind !== "div") return null;
-  const numerator = toPolynomial(node.left);
-  const denominator = toPolynomial(node.right);
-  if (numerator === null || denominator === null) return null;
-  const variable = polyUnivariateVar(denominator);
-  if (variable === null) return null;
-  if (numerator.vars.some((name) => name !== variable)) return null;
-  return {
-    numerator: polyCoefficients(numerator, variable),
-    denominator: polyCoefficients(denominator, variable),
-    variable
-  };
-}
-
-// src/symbolic/Derivative.ts
-var DERIVATIVE_MAX_ORDER = 16;
-function zero() {
-  return constNode(RATIONAL_ZERO);
-}
-function one() {
-  return constNode(RATIONAL_ONE);
-}
-function functionDerivative(name, argument) {
-  switch (name) {
-    case "sin":
-      return callNode("cos", [argument]);
-    case "cos":
-      return { kind: "neg", operand: callNode("sin", [argument]) };
-    case "tan":
-      return { kind: "div", left: one(), right: powNode(callNode("cos", [argument]), constNode(2)) };
-    case "exp":
-      return callNode("exp", [argument]);
-    case "log":
-      return { kind: "div", left: one(), right: argument };
-    case "sqrt":
-      return {
-        kind: "div",
-        left: one(),
-        right: { kind: "mul", left: constNode(2), right: callNode("sqrt", [argument]) }
-      };
-    case "asin":
-      return { kind: "div", left: one(), right: callNode("sqrt", [oneMinusSquare(argument)]) };
-    case "acos":
-      return { kind: "neg", operand: { kind: "div", left: one(), right: callNode("sqrt", [oneMinusSquare(argument)]) } };
-    case "atan":
-      return { kind: "div", left: one(), right: onePlusSquare(argument) };
-    case "sinh":
-      return callNode("cosh", [argument]);
-    case "cosh":
-      return callNode("sinh", [argument]);
-    case "tanh":
-      return { kind: "div", left: one(), right: powNode(callNode("cosh", [argument]), constNode(2)) };
-    case "abs":
-      return callNode("sign", [argument]);
-    default:
-      return null;
-  }
-}
-function oneMinusSquare(argument) {
-  return { kind: "sub", left: one(), right: powNode(argument, constNode(2)) };
-}
-function onePlusSquare(argument) {
-  return { kind: "add", left: one(), right: powNode(argument, constNode(2)) };
-}
-function differentiate2(node, variable, order = 1) {
-  if (order < 0 || !Number.isInteger(order)) {
-    throw ErrorFactory.execution("SYMBOLIC_DERIVATIVE_ORDER_LIMIT", "A derivative order must be a whole number, at least zero.");
-  }
-  if (order > DERIVATIVE_MAX_ORDER) {
-    throw ErrorFactory.execution(
-      "SYMBOLIC_DERIVATIVE_ORDER_LIMIT",
-      `A derivative order above ${DERIVATIVE_MAX_ORDER} is not supported.`,
-      { limit: DERIVATIVE_MAX_ORDER }
-    );
-  }
-  let result = simplifySymbolic(node);
-  for (let i = 0; i < order; i++) result = simplifySymbolic(derive(result, variable));
-  return result;
-}
-function derive(node, variable) {
-  switch (node.kind) {
-    case "const":
-    case "complex":
-      return zero();
-    case "var":
-      return node.name === variable ? one() : zero();
-    case "add":
-      return { kind: "add", left: derive(node.left, variable), right: derive(node.right, variable) };
-    case "sub":
-      return { kind: "sub", left: derive(node.left, variable), right: derive(node.right, variable) };
-    case "neg":
-      return { kind: "neg", operand: derive(node.operand, variable) };
-    case "mul":
-      return {
-        kind: "add",
-        left: { kind: "mul", left: derive(node.left, variable), right: node.right },
-        right: { kind: "mul", left: node.left, right: derive(node.right, variable) }
-      };
-    case "div":
-      return {
-        kind: "div",
-        left: {
-          kind: "sub",
-          left: { kind: "mul", left: derive(node.left, variable), right: node.right },
-          right: { kind: "mul", left: node.left, right: derive(node.right, variable) }
-        },
-        right: powNode(node.right, constNode(2))
-      };
-    case "pow":
-      return derivePow(node, variable);
-    case "call": {
-      if (node.args.length !== 1) return unevaluated(node, variable);
-      const outer = functionDerivative(node.name, node.args[0]);
-      if (outer === null) return unevaluated(node, variable);
-      return { kind: "mul", left: outer, right: derive(node.args[0], variable) };
-    }
-  }
-}
-function derivePow(node, variable) {
-  if (node.exponent.kind === "const") {
-    const reduced = constNode(rationalSub(node.exponent.value, RATIONAL_ONE));
-    return {
-      kind: "mul",
-      left: { kind: "mul", left: node.exponent, right: powNode(node.base, reduced) },
-      right: derive(node.base, variable)
-    };
-  }
-  if (node.base.kind === "const" && node.base.value.n > 0n) {
-    return {
-      kind: "mul",
-      left: { kind: "mul", left: node, right: callNode("log", [node.base]) },
-      right: derive(node.exponent, variable)
-    };
-  }
-  return unevaluated(node, variable);
-}
-function unevaluated(node, variable) {
-  return callNode("der", [node, varNode(variable)]);
-}
-
-// src/symbolic/Integral.ts
-function asLinear(node, variable) {
-  const polynomial = toPolynomial(node);
-  if (polynomial === null) return null;
-  const others = polynomial.vars.filter((name) => name !== variable);
-  if (others.length > 0) return null;
-  if (polyDegree(polynomial, variable) > 1) return null;
-  const ascending = polyCoefficients(polynomial, variable);
-  const intercept = ascending[0] ?? { n: 0n, d: 1n };
-  const slope = ascending[1] ?? { n: 0n, d: 1n };
-  return isRationalZero(slope) ? null : { slope, intercept };
-}
-function integratePolynomial(node, variable) {
-  const polynomial = toPolynomial(node);
-  if (polynomial === null) return null;
-  const others = polynomial.vars.filter((name) => name !== variable);
-  if (others.length > 0) {
-    return { ok: false, reason: `it involves more than one unknown (${others.join(", ")})` };
-  }
-  const ascending = polyCoefficients(polynomial, variable);
-  let result = constNode(0);
-  ascending.forEach((coeff, power3) => {
-    if (isRationalZero(coeff)) return;
-    const nextPower = power3 + 1;
-    const scaled = rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
-    const term = {
-      kind: "mul",
-      left: constNode(scaled),
-      right: nextPower === 1 ? varNode(variable) : powNode(varNode(variable), constNode(nextPower))
-    };
-    result = { kind: "add", left: result, right: term };
-  });
-  return { ok: true, value: simplifySymbolic(result) };
-}
-function integrateStandardForm(node, variable) {
-  if (node.kind !== "call" || node.args.length !== 1) return null;
-  const linear = asLinear(node.args[0], variable);
-  if (linear === null) return null;
-  const inner = node.args[0];
-  const divideBySlope = (value) => simplifySymbolic({ kind: "div", left: value, right: constNode(linear.slope) });
-  switch (node.name) {
-    case "exp":
-      return { ok: true, value: divideBySlope(callNode("exp", [inner])) };
-    case "sin":
-      return { ok: true, value: divideBySlope({ kind: "neg", operand: callNode("cos", [inner]) }) };
-    case "cos":
-      return { ok: true, value: divideBySlope(callNode("sin", [inner])) };
-    case "log":
-      return {
-        ok: true,
-        value: divideBySlope({
-          kind: "sub",
-          left: { kind: "mul", left: inner, right: callNode("log", [inner]) },
-          right: inner
-        })
-      };
-    default:
-      return null;
-  }
-}
-function integrateReciprocalForms(node, variable) {
-  if (node.kind !== "div") return null;
-  if (node.left.kind !== "const" || !isRationalOneNode(node.left.value)) return null;
-  const linear = asLinear(node.right, variable);
-  if (linear !== null) {
-    return {
-      ok: true,
-      value: simplifySymbolic({
-        kind: "div",
-        left: callNode("log", [node.right]),
-        right: constNode(linear.slope)
-      })
-    };
-  }
-  const denominator = toPolynomial(node.right);
-  if (denominator !== null && denominator.vars.length === 1 && denominator.vars[0] === variable) {
-    const ascending = polyCoefficients(denominator, variable);
-    const isOnePlusSquare = ascending.length === 3 && isRationalOneNode(ascending[0]) && isRationalZero(ascending[1]) && isRationalOneNode(ascending[2]);
-    if (isOnePlusSquare) return { ok: true, value: callNode("atan", [varNode(variable)]) };
-  }
-  return null;
-}
-function isRationalOneNode(value) {
-  return value.n === 1n && value.d === 1n;
-}
-function integrateRationalFunction(node, variable) {
-  const parts = asRationalFunction(node);
-  if (parts === null || parts.variable !== variable) return null;
-  const decomposition = partialFractions(parts.numerator, parts.denominator, variable);
-  if (decomposition === null) return null;
-  let result = decomposition.polynomial.length > 0 ? polynomialAntiderivative(decomposition.polynomial, variable) : constNode(0);
-  for (const term of decomposition.terms) {
-    const piece = integrateTerm(term, variable);
-    if (piece === null) {
-      return {
-        ok: false,
-        reason: "its denominator has a repeated irreducible quadratic factor, which needs a reduction formula this does not have"
-      };
-    }
-    result = { kind: "add", left: result, right: piece };
-  }
-  return { ok: true, value: simplifySymbolic(result) };
-}
-function integrateTerm(term, variable) {
-  const baseDegree = term.base.length - 1;
-  const base = coefficientsToNode2(term.base, variable);
-  if (baseDegree === 1) {
-    const coefficient = term.numerator[0] ?? RATIONAL_ZERO;
-    if (term.power === 1) {
-      return { kind: "mul", left: constNode(coefficient), right: callNode("log", [base]) };
-    }
-    const reduced = term.power - 1;
-    const scaled = rationalDiv(coefficient, { n: BigInt(-reduced), d: 1n });
-    return {
-      kind: "div",
-      left: constNode(scaled),
-      right: powNode(base, constNode({ n: BigInt(reduced), d: 1n }))
-    };
-  }
-  if (baseDegree !== 2 || term.power !== 1) return null;
-  return integrateQuadraticTerm(term, variable, base);
-}
-function integrateQuadraticTerm(term, variable, base) {
-  const constant = term.numerator[0] ?? RATIONAL_ZERO;
-  const linear = term.numerator[1] ?? RATIONAL_ZERO;
-  const [q, p] = term.base;
-  const half = { n: 1n, d: 2n };
-  const halfP = rationalMul(p, half);
-  const logarithm = {
-    kind: "mul",
-    left: constNode(rationalMul(linear, half)),
-    right: callNode("log", [base])
-  };
-  const leftover = rationalSub(constant, rationalMul(linear, halfP));
-  if (isRationalZero(leftover)) return logarithm;
-  const width = surdNode(rationalSub(q, rationalMul(halfP, halfP)));
-  const shifted = {
-    kind: "add",
-    left: varNode(variable),
-    right: constNode(halfP)
-  };
-  const arctangent = {
-    kind: "mul",
-    left: { kind: "div", left: constNode(leftover), right: width },
-    right: callNode("atan", [{ kind: "div", left: shifted, right: width }])
-  };
-  return isRationalZero(linear) ? arctangent : { kind: "add", left: logarithm, right: arctangent };
-}
-function polynomialAntiderivative(ascending, variable) {
-  let result = constNode(0);
-  ascending.forEach((coeff, exponent) => {
-    if (isRationalZero(coeff)) return;
-    const nextPower = exponent + 1;
-    const scaled = rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
-    const term = {
-      kind: "mul",
-      left: constNode(scaled),
-      right: nextPower === 1 ? varNode(variable) : powNode(varNode(variable), constNode(nextPower))
-    };
-    result = { kind: "add", left: result, right: term };
-  });
-  return result;
-}
-function integrate(node, variable) {
-  const simplified = simplifySymbolic(node);
-  if (!freeVariables(simplified).has(variable)) {
-    return { ok: true, value: simplifySymbolic({ kind: "mul", left: simplified, right: varNode(variable) }) };
-  }
-  const polynomial = integratePolynomial(simplified, variable);
-  if (polynomial !== null) return polynomial;
-  const standard = integrateStandardForm(simplified, variable);
-  if (standard !== null) return standard;
-  const reciprocal = integrateReciprocalForms(simplified, variable);
-  if (reciprocal !== null) return reciprocal;
-  const rationalFunction = integrateRationalFunction(simplified, variable);
-  if (rationalFunction !== null) return rationalFunction;
-  if (simplified.kind === "add" || simplified.kind === "sub") {
-    const left = integrate(simplified.left, variable);
-    if (!left.ok) return left;
-    const right = integrate(simplified.right, variable);
-    if (!right.ok) return right;
-    return {
-      ok: true,
-      value: simplifySymbolic({ kind: simplified.kind, left: left.value, right: right.value })
-    };
-  }
-  if (simplified.kind === "mul" && simplified.left.kind === "const") {
-    const inner = integrate(simplified.right, variable);
-    if (!inner.ok) return inner;
-    return { ok: true, value: simplifySymbolic({ kind: "mul", left: simplified.left, right: inner.value }) };
-  }
-  return {
-    ok: false,
-    reason: "no elementary antiderivative is known for this expression"
-  };
-}
-
-// src/symbolic/Taylor.ts
-var TAYLOR_MAX_DEGREE = 16;
-function taylorSeries(node, variable, point, degree) {
-  if (degree < 0 || !Number.isInteger(degree) || degree > TAYLOR_MAX_DEGREE) {
-    throw ErrorFactory.execution(
-      "SYMBOLIC_TAYLOR_DEGREE_LIMIT",
-      `A Taylor degree must be a whole number from 0 to ${TAYLOR_MAX_DEGREE}.`,
-      { limit: TAYLOR_MAX_DEGREE }
-    );
-  }
-  const pointNode = constNode(point);
-  let factorial = 1n;
-  let result = constNode(RATIONAL_ZERO);
-  for (let order = 0; order <= degree; order++) {
-    if (order > 0) factorial *= BigInt(order);
-    const derivative = differentiate2(node, variable, order);
-    const atPoint = simplifySymbolic(substitute(derivative, variable, pointNode));
-    if (atPoint.kind !== "const") {
-      throw ErrorFactory.execution(
-        "SYMBOLIC_TAYLOR_INEXACT",
-        `The derivative of order ${order} does not reduce to an exact number at the expansion point, so this series cannot be computed exactly.`,
-        { order }
-      );
-    }
-    const coefficient = rationalDiv(atPoint.value, { n: factorial, d: 1n });
-    if (isRationalZero(coefficient)) continue;
-    const shifted = isRationalZero(point) ? varNode(variable) : { kind: "sub", left: varNode(variable), right: pointNode };
-    const power3 = order === 0 ? constNode(1) : order === 1 ? shifted : powNode(shifted, constNode(order));
-    result = { kind: "add", left: result, right: { kind: "mul", left: constNode(coefficient), right: power3 } };
-  }
-  return simplifySymbolic(result);
-}
-function jacobian(functions, variables) {
-  return functions.map((fn) => variables.map((variable) => differentiate2(fn, variable)));
-}
-
-// src/engine/EngineContext.ts
-function createEngineContext() {
-  return {
-    pluginFunctions: {},
-    opRegistry: new OpRegistry(),
-    variableResolver: new VariableResolver(),
-    pluginFunctionOwners: {}
-  };
-}
-var defaultEngineContext = createEngineContext();
-
-// src/packages/finance/data/CpiTable.ts
-var CPI_TABLE = {
-  1970: 38.8,
-  1971: 40.5,
-  1972: 41.8,
-  1973: 44.4,
-  1974: 49.3,
-  1975: 53.8,
-  1976: 56.9,
-  1977: 60.6,
-  1978: 65.2,
-  1979: 72.6,
-  1980: 82.4,
-  1981: 90.9,
-  1982: 96.5,
-  1983: 99.6,
-  1984: 103.9,
-  1985: 107.6,
-  1986: 109.6,
-  1987: 113.6,
-  1988: 118.3,
-  1989: 124,
-  1990: 130.7,
-  1991: 136.2,
-  1992: 140.3,
-  1993: 144.5,
-  1994: 148.2,
-  1995: 152.4,
-  1996: 156.9,
-  1997: 160.5,
-  1998: 163,
-  1999: 166.6,
-  2e3: 172.2,
-  2001: 177.1,
-  2002: 179.9,
-  2003: 184,
-  2004: 188.9,
-  2005: 195.3,
-  2006: 201.6,
-  2007: 207.3,
-  2008: 215.3,
-  2009: 214.5,
-  2010: 218.1,
-  2011: 224.9,
-  2012: 229.6,
-  2013: 233,
-  2014: 236.7,
-  2015: 237,
-  2016: 240,
-  2017: 245.1,
-  2018: 251.1,
-  2019: 255.7,
-  2020: 258.8,
-  2021: 271,
-  2022: 292.7,
-  2023: 304.7,
-  2024: 313.7,
-  // 2025-2026 were projected from model knowledge and are now derived from
-  // the IMF monthly CPI series (statisticsoftheworld.com,
-  // IMF.CPI.YOY.M?geo=USA), chained forward from the published 2024 figure
-  // using annual mean year-over-year rates. 2026 covers January to June only,
-  // so it remains a partial year and will move.
-  //
-  // The projections were 320.6 and 327.4, low by 0.49% and 1.63%. Everything
-  // from 2021 to 2024 reproduced the same series to within 0.02%, which is
-  // what makes those two the only entries worth changing.
-  2025: 322.2,
-  2026: 332.7
-};
-var CPI_MIN_YEAR = 1970;
-var CPI_MAX_YEAR = 2026;
-function getCpi(year) {
-  return CPI_TABLE[Math.trunc(year)];
-}
-function inflationRatio(fromYear, toYear) {
-  const fromCpi = getCpi(fromYear);
-  const toCpi = getCpi(toYear);
-  if (fromCpi === void 0 || toCpi === void 0 || fromCpi === 0) return void 0;
-  return toCpi / fromCpi;
-}
-function adjustForInflation(amount, fromYear, toYear) {
-  const ratio = inflationRatio(fromYear, toYear);
-  if (ratio === void 0) return void 0;
-  return amount * ratio;
-}
-
-// src/vm/VMBuiltins.ts
-var ANGLE_KIND = 0;
-function angleInRadians(value) {
-  if (value.type === 6 /* Uom */ && value.unit !== void 0) {
-    const entry = UNIT_TABLE[value.unit.toLowerCase()];
-    if (entry !== void 0 && entry[0] === ANGLE_KIND) return value.toNumber() * entry[1];
-  }
-  return value.toNumber();
-}
-function pluraliseUnit(unit, count) {
-  if (count === 1) return unit;
-  const plural = `${unit}s`;
-  return UNIT_TABLE[plural.toLowerCase()] === void 0 ? unit : plural;
-}
-function extremum(args, wantLargest) {
-  let best;
-  let hasNaN = false;
-  for (const a of args) {
-    if (Number.isNaN(a.toNumber())) {
-      hasNaN = true;
-      continue;
-    }
-    if (best === void 0) {
-      best = a;
-      continue;
-    }
-    const { lv, rv, sameMeasure } = unifyUom(best, a);
-    if (!sameMeasure) {
-      const bestUnit = best.type === 6 /* Uom */ ? best.unit : void 0;
-      const otherUnit = a.type === 6 /* Uom */ ? a.unit : void 0;
-      const named = describeMeasureMismatch(bestUnit, otherUnit, "compared");
-      return errorValue(
-        "INCOMPATIBLE_UNITS",
-        named ?? `Cannot compare incompatible units: ${bestUnit ?? "?"} and ${otherUnit ?? "?"}`
-      );
-    }
-    if (wantLargest ? rv > lv : rv < lv) best = a;
-  }
-  if (hasNaN) return numberValue(NaN);
-  if (best === void 0) return numberValue(wantLargest ? -Infinity : Infinity);
-  return best.type === 6 /* Uom */ ? best : numberValue(best.toNumber());
-}
-function keepUnit(operand, magnitude2) {
-  if (operand.type === 6 /* Uom */ && operand.unit !== void 0) return uomValue(magnitude2, operand.unit);
-  return numberValue(magnitude2);
-}
-function roundToPlaces(source, places) {
-  const p = Number.isFinite(places) ? Math.min(100, Math.max(0, Math.trunc(places))) : 0;
-  if (source.exact !== void 0) {
-    const rounded = decimalRound(source.exact, p);
-    return withPlaces(source, decimalToNumber(rounded), p, rounded);
-  }
-  const value = source.toNumber();
-  if (!Number.isFinite(value)) return withPlaces(source, value, p);
-  const scale2 = Math.pow(10, p);
-  const scaled = value * scale2;
-  if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return withPlaces(source, value, p);
-  return withPlaces(source, Math.round(scaled) / scale2, p);
-}
-function withPlaces(source, magnitude2, places, exact) {
-  const result = source.type === 6 /* Uom */ && source.unit !== void 0 ? uomValue(magnitude2, source.unit) : numberValue(magnitude2);
-  result.decimalPlaces = places;
-  if (exact !== void 0) result.exact = exact;
-  return result;
-}
-function nonFiniteEuclidOperand(a, b, name) {
-  if (Number.isFinite(a) && Number.isFinite(b)) return null;
-  const culprit = Number.isFinite(a) ? b : a;
-  return errorValue(
-    "INVALID_INTEGER_OPERAND",
-    `${name} needs two whole numbers, and ${Number.isNaN(culprit) ? "one of them has no value" : "one of them is infinite"}`
-  );
-}
-function euclidGcd(a, b) {
-  let x = a;
-  let y = b;
-  while (y !== 0) {
-    const t = y;
-    y = x % y;
-    x = t;
-  }
-  return x;
-}
-var builtinFunctions = {
-  // ── Populated below ──
-  // sqrt: a negative argument has a complex answer now that there is a complex
-  // number to give, so this no longer quietly returns NaN. The exact path runs
-  // first, so sqrt(-4) is 2i rather than an approximation.
-  0: (args) => {
-    const value = args[0].toNumber();
-    if (value >= 0) return numberValue(Math.sqrt(value));
-    return symbolicToValue(callNode("sqrt", [constNode(value)]));
-  },
-  // abs(a): for a Matrix, "|a|" (Calca's determinant-pipe notation) is a
-  // valid alias for det(a) (index 64), reusing the SAME implementation
-  // not a separate one. Plain-number abs is unaffected.
-  1: (args) => args[0].type === 7 /* Matrix */ ? determinant(args[0].value) : keepUnit(args[0], Math.abs(args[0].toNumber())),
-  // sin/cos/tan accept an angle with a unit; see angleInRadians().
-  2: (args) => numberValue(Math.sin(angleInRadians(args[0]))),
-  3: (args) => numberValue(Math.cos(angleInRadians(args[0]))),
-  4: (args) => numberValue(Math.tan(angleInRadians(args[0]))),
-  5: (args) => numberValue(Math.log(args[0].toNumber())),
-  // round/ceil/floor keep a unit for the same reason abs does; see keepUnit().
-  6: (args) => keepUnit(args[0], Math.ceil(args[0].toNumber())),
-  7: (args) => keepUnit(args[0], Math.floor(args[0].toNumber())),
-  8: (args) => args.length >= 2 ? (
-    // round(x, n): round to n decimal places and display at that precision.
-    roundToPlaces(args[0], args[1].toNumber())
-  ) : (
-    // round(x): nearest whole number, the way it always was.
-    keepUnit(args[0], Math.round(args[0].toNumber()))
-  ),
-  // min/max: see extremum() for why the winner is carried around as a Value
-  // rather than as a running number.
-  9: (args) => extremum(args, false),
-  10: (args) => extremum(args, true),
-  11: (args) => numberValue(Math.asin(args[0].toNumber())),
-  12: (args) => numberValue(Math.acos(args[0].toNumber())),
-  13: (args) => numberValue(Math.atan(args[0].toNumber())),
-  14: (args) => numberValue(Math.atan2(args[0].toNumber(), args[1].toNumber())),
-  15: (args) => numberValue(Math.sinh(args[0].toNumber())),
-  16: (args) => numberValue(Math.cosh(args[0].toNumber())),
-  17: (args) => numberValue(Math.tanh(args[0].toNumber())),
-  18: (args) => numberValue(Math.asinh(args[0].toNumber())),
-  19: (args) => numberValue(Math.acosh(args[0].toNumber())),
-  20: (args) => numberValue(Math.atanh(args[0].toNumber())),
-  21: (args) => numberValue(Math.cbrt(args[0].toNumber())),
-  22: (args) => numberValue(Math.clz32(args[0].toNumber())),
-  23: (args) => numberValue(Math.expm1(args[0].toNumber())),
-  24: (args) => numberValue(Math.exp(args[0].toNumber())),
-  25: (args) => numberValue(Math.fround(args[0].toNumber())),
-  // hypot: left as .map()+spread (unlike min/max above), Math.hypot uses
-  // a numerically-stable scaling algorithm internally to avoid overflow
-  // for very large/small inputs; a naive manual reimplementation risks
-  // silently changing results at the extremes, so the tiny array
-  // allocation here is the safer trade.
-  26: (args) => numberValue(Math.hypot(...args.map((a) => a.toNumber()))),
-  27: (args) => numberValue(Math.imul(args[0].toNumber(), args[1].toNumber())),
-  28: (args) => numberValue(Math.log10(args[0].toNumber())),
-  29: (args) => numberValue(Math.log1p(args[0].toNumber())),
-  30: (args) => numberValue(Math.log2(args[0].toNumber())),
-  // pow(): the spelled-out form of `^`, so a Matrix base means the same
-  // repeated matrix multiplication `^` means. Without this branch
-  // `pow([1,2;3,4], 2)` was Math.pow of a value whose toNumber() is 0, and
-  // came back as the number 0. See vm/MatrixOps.ts's matrixPower().
-  31: (args) => {
-    if (args[0].type === 7 /* Matrix */) {
-      if (args[1].type !== 0 /* Number */) {
-        return errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix's exponent must be a whole number, as in "pow([1,2;3,4], 2)".`);
-      }
-      return matrixPower(args[0].value, args[1].value);
-    }
-    if (args[1].type === 7 /* Matrix */) {
-      return errorValue("MATRIX_POWER_UNSUPPORTED", `pow: a matrix may only be the base, as in "pow([1,2;3,4], 2)".`);
-    }
-    return numberValue(power(args[0].toNumber(), args[1].toNumber()));
-  },
-  32: () => numberValue(Math.random()),
-  // takes no arguments, unlike its neighbours
-  33: (args) => numberValue(Math.sign(args[0].toNumber())),
-  34: (args) => numberValue(Math.trunc(args[0].toNumber())),
-  35: (args) => numberValue(args[0].toNumber() * Math.PI / 180),
-  36: (args) => numberValue(args[0].toNumber() * 180 / Math.PI),
-  // 37: diceRoll(from, to), random integer in range [from, to] inclusive.
-  // A reversed range (from > to) used to silently produce values outside
-  // [to, from] via a negative-length Math.random() spread (e.g.
-  // "roll(6, 1)" returning values like 2-5, never 1 or 6) instead of
-  // erroring on the invalid input.
-  37: (args) => {
-    const from = args[0].toNumber();
-    const to = args[1].toNumber();
-    if (from > to) {
-      return errorValue("INVALID_RANGE", `roll: invalid range, ${from} is greater than ${to}`);
-    }
-    return numberValue(Math.floor(Math.random() * (to - from + 1)) + from);
-  },
-  // gcd(a, b), Euclidean algorithm. Negative inputs are treated by
-  // magnitude (gcd is conventionally defined over non-negative integers).
-  38: (args) => {
-    const a = Math.trunc(Math.abs(args[0].toNumber()));
-    const b = Math.trunc(Math.abs(args[1].toNumber()));
-    const nonFinite = nonFiniteEuclidOperand(a, b, "gcd");
-    if (nonFinite) return nonFinite;
-    return numberValue(euclidGcd(a, b));
-  },
-  // lcm(a, b) = |a*b| / gcd(a, b), via the same Euclidean gcd inline
-  // (a standalone gcd() call site, no shared helper needed for two uses).
-  39: (args) => {
-    const a = Math.trunc(Math.abs(args[0].toNumber()));
-    const b = Math.trunc(Math.abs(args[1].toNumber()));
-    const nonFinite = nonFiniteEuclidOperand(a, b, "lcm");
-    if (nonFinite) return nonFinite;
-    if (a === 0 || b === 0) return numberValue(0);
-    return numberValue(a / euclidGcd(a, b) * b);
-  },
-  // permutation(n, r) = n! / (n-r)!, computed as a running product
-  // rather than two full factorials, so it stays exact for n well
-  // beyond where n! itself would exceed Number.MAX_SAFE_INTEGER.
-  //
-  // The loop stops the moment the product stops being a representable
-  // double, which is both the answer `fact` (index 62) already gives for
-  // the same question and the thing that bounds the loop at all. `r` comes
-  // straight off the stack: `permutation(1000000000000, 1000000000000)`
-  // used to run a trillion iterations, of which the first ~170 computed
-  // something and the rest multiplied Infinity by a number, and it had not
-  // returned after thirty seconds. Every factor here is at least 1 and they
-  // descend from `n`, so a product that is still finite after 170 steps
-  // means the factors are small, which in turn means `r <= n` is small: the
-  // early exit bounds the trip count without a separate estimate, and
-  // without ever refusing a permutation that does have an answer.
-  40: (args) => {
-    const n = Math.trunc(args[0].toNumber());
-    const r = Math.trunc(args[1].toNumber());
-    if (n < 0 || r < 0 || r > n) {
-      return errorValue("INVALID_RANGE", `permutation: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
-    }
-    let result = 1;
-    for (let i = 0; i < r; i++) {
-      result *= n - i;
-      if (!Number.isFinite(result)) {
-        return errorValue(
-          "PERMUTATION_OVERFLOW",
-          `permutation: P(${n}, ${r}) exceeds the maximum representable double (it passed it after ${i + 1} of ${r} factors)`
-        );
-      }
-    }
-    return numberValue(result);
-  },
-  // combination(n, r) = n! / (r! * (n-r)!), multiply-then-divide one
-  // step at a time (standard technique) keeps every intermediate result
-  // an integer, avoiding the overflow a naive factorial-ratio would hit.
-  //
-  // Same early exit, and needed for the same reason: `k = min(r, n-r)`
-  // halves the trip count and bounds nothing, so `combination(1e12, 5e11)`
-  // asked for five hundred billion iterations. The running value is C(n, i),
-  // which grows monotonically to the middle, so once it is past what a
-  // double can hold it never comes back, and the largest run this can now
-  // take is the thousand-odd steps C(n, k) needs to cross that line.
-  41: (args) => {
-    const n = Math.trunc(args[0].toNumber());
-    const r = Math.trunc(args[1].toNumber());
-    if (n < 0 || r < 0 || r > n) {
-      return errorValue("INVALID_RANGE", `combination: invalid n=${n}, r=${r} (require 0 <= r <= n)`);
-    }
-    const k = Math.min(r, n - r);
-    let result = 1;
-    for (let i = 0; i < k; i++) {
-      result = result * (n - i) / (i + 1);
-      if (!Number.isFinite(result)) {
-        return errorValue(
-          "COMBINATION_OVERFLOW",
-          `combination: C(${n}, ${r}) exceeds the maximum representable double (it passed it after ${i + 1} of ${k} steps)`
-        );
-      }
-    }
-    return numberValue(Math.round(result));
-  },
-  // average(...), arithmetic mean of any number of arguments. Backs the
-  // MathPhrases package's "average of X, Y, Z" (packages/mathphrases/).
-  42: (args) => {
-    if (args.length === 0) return numberValue(0);
-    const sum = args.reduce((acc, a) => acc + a.toNumber(), 0);
-    return numberValue(sum / args.length);
-  },
-  // median(...), middle value; average of the two middle values for an
-  // even argument count.
-  43: (args) => {
-    if (args.length === 0) return numberValue(0);
-    const sorted = args.map((a) => a.toNumber()).sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return numberValue(
-      sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid]
-    );
-  },
-  // total(...), sum of any number of arguments.
-  44: (args) => numberValue(args.reduce((acc, a) => acc + a.toNumber(), 0)),
-  // count(...), number of arguments passed.
-  45: (args) => numberValue(args.length),
-  // proportion(a, b, c) -> d such that a:b = c:d, i.e. d = c * (b/a)
-  // "A is to B as C is to what". Unit-aware via unifyUom: "5 km is to
-  // 500m as 5 cm is to what" unifies 5km/500m to a 10:1 ratio (500m ==
-  // 0.5km), so 5cm at the same ratio -> 0.5cm. Falls back to plain
-  // toNumber() ratios when the units aren't the same measure (unifyUom's
-  // own fallback) rather than guessing at an unsupported conversion.
-  46: (args) => {
-    const [a, b, c] = args;
-    const { lv: aNum, rv: bNum } = unifyUom(a, b);
-    if (aNum === 0) {
-      return errorValue("PROPORTION_DIVIDE_BY_ZERO", `Cannot compute proportion: "${a.value}" is zero`);
-    }
-    const result = c.toNumber() * (bNum / aNum);
-    return c.type === 6 /* Uom */ ? uomValue(result, c.unit) : numberValue(result);
-  },
-  // clamp(value, lo, hi), restrict value to [lo, hi]. Backs
-  // "clamp X between Y and Z" / "clamp X from Y to Z".
-  47: (args) => {
-    const value = args[0].toNumber();
-    const lo = args[1].toNumber();
-    const hi = args[2].toNumber();
-    if (lo > hi) {
-      return errorValue("INVALID_RANGE", `clamp: invalid range, ${lo} is greater than ${hi}`);
-    }
-    return numberValue(Math.min(Math.max(value, lo), hi));
-  },
-  // hex(n), Python/JS-style call-syntax hex formatting, e.g. hex(255) ->
-  // "0xFF". Distinct from the Converters package's `255 as hex` (see
-  // packages/converters/parselets/AsConverterParselet.ts): "as hex"
-  // produces a ValueType.Hex (a typed NUMBER that still participates in
-  // arithmetic, formatted specially on display), while hex() is a plain
-  // function call that returns an ordinary String value, matching
-  // Python's hex()/JS convention of a function returning display text,
-  // not a numeric type.
-  48: (args) => hexValue(args[0].toNumber()),
-  // bin(n). Same call-syntax shape as hex() above, e.g. bin(10) -> "0b1010".
-  49: (args) => hexValue(args[0].toNumber(), "bin"),
-  // int(x), coerce ANY value (Number, Percentage, Uom, String, Hex, ...)
-  // to a plain integer Number, truncating any fractional part toward
-  // zero (Math.trunc semantics: int(5.7) -> 5, int(-5.7) -> -5). Distinct
-  // from the Converters package's `x as number` (TO_NUMBER opcode),
-  // which only strips a unit/percentage wrapper and keeps any decimal
-  // part (e.g. "5.7 as number" -> 5.7), int() additionally truncates.
-  50: (args) => numberValue(Math.trunc(args[0].toNumber())),
-  // ── Finance (packages/finance/) ──────────────────────────────────────
-  // All finance builtins preserve the principal/amount argument's Uom
-  // unit (e.g. a currency like "$") onto the result, matching
-  // ProportionParselet's convention (index 46, above), a plain-number
-  // input produces a plain-number result.
-  //
-  // `rate` arguments are always a decimal fraction (e.g. 0.07 for 7%)
-  // this is how "%" already normalizes everywhere else in this codebase
-  // (see packages/percentage/parselets/PercentParselet.ts: "7%" divides
-  // by 100 at parse time, producing a plain Number 0.07, not a distinct
-  // percentage type). Writing "at 7" instead of "at 7%" in a phrase form
-  // passes 7 as-is (not 0.07), the "%" is not implicit.
-  // compoundFutureValue(principal, rate, years) -> FV = P*(1+r)^years.
-  // Backs "compound interest on $P over Y years at R%" and the
-  // compoundInterest(principal, rate, years) function-call form.
-  51: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (1 + rate <= 0) {
-      return errorValue("INVALID_RATE", `compoundInterest: rate ${rate} makes (1 + rate) non-positive`);
-    }
-    const fv = principal * Math.pow(1 + rate, years);
-    return args[0].type === 6 /* Uom */ ? uomValue(fv, args[0].unit) : numberValue(fv);
-  },
-  // compoundInterestEarned(principal, rate, years) -> FV - principal, the
-  // interest-only portion. Backs "interest on $P over Y years at R%" and
-  // the interestEarned(principal, rate, years) function-call form.
-  52: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (1 + rate <= 0) {
-      return errorValue("INVALID_RATE", `interestEarned: rate ${rate} makes (1 + rate) non-positive`);
-    }
-    const interest = principal * (Math.pow(1 + rate, years) - 1);
-    return args[0].type === 6 /* Uom */ ? uomValue(interest, args[0].unit) : numberValue(interest);
-  },
-  // compoundInterestRate(principal, futureValue, years) -> the rate (as a
-  // decimal fraction) needed to grow principal to futureValue over years.
-  // Function-call only, no clean phrase form for a reverse calculation
-  // like this without inventing awkward new keywords, so it's scoped to
-  // compoundInterestRate(...) rather than a natural-language phrase.
-  53: (args) => {
-    const principal = args[0].toNumber();
-    const futureValue = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (principal <= 0 || futureValue <= 0) {
-      return errorValue("INVALID_RANGE", `compoundInterestRate: principal and futureValue must both be positive`);
-    }
-    if (years <= 0) {
-      return errorValue("INVALID_RANGE", `compoundInterestRate: years must be greater than 0`);
-    }
-    return numberValue(Math.pow(futureValue / principal, 1 / years) - 1);
-  },
-  // compoundInterestYears(principal, futureValue, rate) -> the number of
-  // years needed to grow principal to futureValue at a fixed rate.
-  // Function-call only, same reasoning as index 53 above.
-  54: (args) => {
-    const principal = args[0].toNumber();
-    const futureValue = args[1].toNumber();
-    const rate = args[2].toNumber();
-    if (principal <= 0 || futureValue <= 0) {
-      return errorValue("INVALID_RANGE", `compoundInterestYears: principal and futureValue must both be positive`);
-    }
-    if (1 + rate <= 0 || rate === 0) {
-      return errorValue("INVALID_RATE", `compoundInterestYears: rate ${rate} is not usable (must be > -1 and not 0)`);
-    }
-    return numberValue(Math.log(futureValue / principal) / Math.log(1 + rate));
-  },
-  // loanRepayment(principal, rate, years, periodsPerYear), standard
-  // amortizing-loan repayment (mortgage formula), redistributed evenly
-  // across `periodsPerYear` periods/year: 365=daily, 12=monthly, 1=annual,
-  // 0=total over the life of the loan. The loan is ALWAYS amortized
-  // monthly internally (the standard mortgage convention) regardless of
-  // periodsPerYear, "daily"/"annual"/"total" are the same total
-  // repayment redistributed, not separately-amortized loans. Verified
-  // against real worked numbers (principal=$10,000, rate=6%, years=6):
-  // monthly $165.73, annual $1,988.75 (== total/years exactly), daily
-  // $5.45 (== total/(years*365)), total $11,932.48.
-  // Backs "daily/monthly/annual/total repayment on $P over Y years at R%".
-  55: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    const periodsPerYear = args[3].toNumber();
-    if (principal <= 0) return errorValue("INVALID_RANGE", `loanRepayment: principal must be positive`);
-    if (years <= 0) return errorValue("INVALID_RANGE", `loanRepayment: years must be positive`);
-    if (rate < 0) return errorValue("INVALID_RATE", `loanRepayment: rate must not be negative`);
-    if (periodsPerYear < 0) return errorValue("INVALID_RANGE", `loanRepayment: periodsPerYear must not be negative`);
-    const { totalRepayment } = amortizeLoan(principal, rate, years);
-    const result = periodsPerYear === 0 ? totalRepayment : totalRepayment / (years * periodsPerYear);
-    return args[0].type === 6 /* Uom */ ? uomValue(result, args[0].unit) : numberValue(result);
-  },
-  // loanInterest(principal, rate, years, periodsPerYear), the interest
-  // portion of index 55's repayment, same periodsPerYear convention.
-  // Backs "daily/monthly/annual/total interest on $P over Y years at R%".
-  56: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    const periodsPerYear = args[3].toNumber();
-    if (principal <= 0) return errorValue("INVALID_RANGE", `loanInterest: principal must be positive`);
-    if (years <= 0) return errorValue("INVALID_RANGE", `loanInterest: years must be positive`);
-    if (rate < 0) return errorValue("INVALID_RATE", `loanInterest: rate must not be negative`);
-    if (periodsPerYear < 0) return errorValue("INVALID_RANGE", `loanInterest: periodsPerYear must not be negative`);
-    const { totalInterest } = amortizeLoan(principal, rate, years);
-    const result = periodsPerYear === 0 ? totalInterest : totalInterest / (years * periodsPerYear);
-    return args[0].type === 6 /* Uom */ ? uomValue(result, args[0].unit) : numberValue(result);
-  },
-  // monthlyPayment(principal, rate, years), convenience 3-arg wrapper
-  // around index 55's monthly case, for direct function-call use without
-  // the periodsPerYear parameter (the task's minimum-ask function form).
-  57: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (principal <= 0) return errorValue("INVALID_RANGE", `monthlyPayment: principal must be positive`);
-    if (years <= 0) return errorValue("INVALID_RANGE", `monthlyPayment: years must be positive`);
-    if (rate < 0) return errorValue("INVALID_RATE", `monthlyPayment: rate must not be negative`);
-    const { monthlyPayment } = amortizeLoan(principal, rate, years);
-    return args[0].type === 6 /* Uom */ ? uomValue(monthlyPayment, args[0].unit) : numberValue(monthlyPayment);
-  },
-  // taxAdd(amount, rate) -> amount * (1 + rate), the tax-inclusive total.
-  // Backs the taxAdd() function-call form, whose name promises exactly this.
-  // The "tax on $X at R%" PHRASE does NOT use it, see index 86.
-  //
-  // No default rate is baked in anywhere, the caller always supplies one
-  // explicitly, since tax rates vary by region and change over time; this
-  // package makes no assumption about which rate applies.
-  58: (args) => {
-    const amount = args[0].toNumber();
-    const rate = args[1].toNumber();
-    if (args[0].type === 6 /* Uom */) return scaleMoneyByPercent(args[0], args[0].unit, rate, 1);
-    return numberValue(amount * (1 + rate));
-  },
-  // taxRemove(amount, rate) -> amount / (1 + rate), extracts the
-  // pre-tax amount from a tax-INCLUSIVE total. Backs "tax off $X at R%" /
-  // "VAT off $X at R%".
-  59: (args) => {
-    const amount = args[0].toNumber();
-    const rate = args[1].toNumber();
-    if (1 + rate <= 0) {
-      return errorValue("INVALID_RATE", `taxRemove: rate ${rate} makes (1 + rate) non-positive`);
-    }
-    if (args[0].type === 6 /* Uom */) {
-      return removeTaxExact(args[0], args[0].unit, rate) ?? uomValue(amount / (1 + rate), args[0].unit);
-    }
-    return numberValue(amount / (1 + rate));
-  },
-  // inflationAdjust(amount, fromYear, toYear) -- CPI-based inflation
-  // adjustment between two arbitrary years, using the bundled CPI-U
-  // table (packages/finance/data/CpiTable.ts -- see its doc comment for
-  // vintage/accuracy notes). Backs the function-call form
-  // inflationAdjust(...) (FunctionCallParselet's builtinNameToIndex map)
-  // and the "what is $X in fromYear worth in toYear" phrase form
-  // (InflationQueryParselet.ts). The two present-year-relative phrase
-  // forms ("what is $X from year" / "what was $X worth in year" / "$X
-  // in year dollars") and the flat-rate future-value projection ("value
-  // of $X in year assuming N% inflation") are collision-safe
-  // pluginFunctions instead, not indices here -- see
-  // packages/finance/parselets/InflationPluginFunctions.ts.
-  60: (args) => {
-    const amount = args[0].toNumber();
-    const fromYear = args[1].toNumber();
-    const toYear = args[2].toNumber();
-    const ratio = inflationRatio(fromYear, toYear);
-    if (ratio === void 0) {
-      return errorValue(
-        "INFLATION_YEAR_OUT_OF_RANGE",
-        `inflationAdjust: fromYear ${fromYear} or toYear ${toYear} is outside the bundled CPI table's range (${CPI_MIN_YEAR}-${CPI_MAX_YEAR})`
-      );
-    }
-    const result = amount * ratio;
-    return args[0].type === 6 /* Uom */ ? uomValue(result, args[0].unit) : numberValue(result);
-  },
-  // root(n, x) -- the n-th root of x (Numi's `root n (x)` phrasing maps
-  // to this same call-style form; see FunctionCallParselet's name map).
-  // No native Math.root exists (unlike Math.cbrt for n=3 specifically),
-  // so this is Math.pow(x, 1/n) directly -- exact for n=2/n=3 modulo the
-  // usual floating-point pow() rounding, same precision class as every
-  // other builtin here.
-  61: (args) => {
-    const n = args[0].toNumber();
-    const x = args[1].toNumber();
-    return numberValue(power(x, 1 / n));
-  },
-  // fact(n) / factorial(n) -- integer factorial. Deliberately rejects
-  // negative or non-integer input (factorial isn't defined for either
-  // without a gamma-function generalization this engine doesn't need) and
-  // caps at 170 -- Number.MAX_VALUE overflows to Infinity at 171!, so
-  // returning a silently-wrong (or silently-infinite) result past that
-  // point would be worse than a clear error.
-  62: (args) => {
-    const n = args[0].toNumber();
-    if (!Number.isInteger(n) || n < 0) {
-      return errorValue("INVALID_FACTORIAL_INPUT", `fact: ${n} is not a non-negative integer`);
-    }
-    if (n > 170) {
-      return errorValue("FACTORIAL_OVERFLOW", `fact: ${n}! exceeds the maximum representable double (170! is the largest finite factorial)`);
-    }
-    let result = 1;
-    for (let i = 2; i <= n; i++) result *= i;
-    return numberValue(result);
-  },
-  // ── Matrix (packages/matrix/) ────────────────────────────────────────
-  // transpose(a)/det(a)/inv(a)/dot(a,b), reachable both via ordinary
-  // function-call syntax (this map) and via operator syntax (`^T`, `^-1`
-  //. See PrecedenceParser.ts's CARET special-casing, which emits these
-  // SAME indices) and `|a|` (abs()'s Matrix branch, index 1 above).
-  // Real linear-algebra work lives in vm/MatrixOps.ts, shared by both
-  // entry points rather than duplicated.
-  // transpose(a), for a Matrix, swaps rows/cols. A plain Number is its
-  // own transpose (a 1x1 "matrix" transposed is itself), matches this
-  // engine's existing convention of treating a scalar as a trivial 1x1
-  // matrix (see Value.ts's toNumber()/isNaN() 1x1 special case).
-  63: (args) => args[0].type === 7 /* Matrix */ ? transpose(args[0].value) : args[0],
-  // det(a), determinant. A plain Number's "determinant" is itself (the
-  // determinant of a 1x1 matrix [x] is x).
-  64: (args) => args[0].type === 7 /* Matrix */ ? determinant(args[0].value) : numberValue(args[0].toNumber()),
-  // inv(a), matrix inverse for a Matrix; for a plain Number, `1/x`
-  // (byte-identical to `Math.pow(x, -1)`, which is what `x^-1` computed
-  // before this feature existed. See PrecedenceParser.ts's `^-1`
-  // special-case doc comment for why this must stay exact).
-  65: (args) => {
-    if (args[0].type === 7 /* Matrix */) return inverse(args[0].value);
-    return numberValue(1 / args[0].toNumber());
-  },
-  // dot(a, b), matrix product / scalar-broadcast, the SAME dispatch as
-  // the `*` operator between two matrices (vm/VM.ts's MUL case). Plain
-  // Number operands multiply directly; a Number mixed with a Matrix
-  // promotes the Number to a 1x1 Matrix first, so it broadcasts exactly
-  // like matrixMultiply()'s own 1x1-scalar case.
-  66: (args) => {
-    const [a, b] = args;
-    if (a.type === 0 /* Number */ && b.type === 0 /* Number */) {
-      return numberValue(a.toNumber() * b.toNumber());
-    }
-    const toMatrix = (v) => v.type === 7 /* Matrix */ ? v.value : { rows: 1, cols: 1, data: [v.toNumber()], hasSymbolic: false };
-    return matrixMultiply(toMatrix(a), toMatrix(b));
-  },
-  // ── Symbolic algebra (packages/symbolic/) ──
-  // expand(expr), multiplying out every product and power. Reached only
-  // through its own parselet, never the builtinNameToIndex name map, so that
-  // `expand` keeps working as an ordinary variable name; see
-  // packages/symbolic/normalizer/SymbolicCallNormalizerRule.ts.
-  //
-  // A non-symbolic argument has nothing to expand and is returned unchanged,
-  // which is why this does not go through the CALL_BUILTIN symbolic dispatch:
-  // `expand(2+3)` is simply 5.
-  67: (args) => {
-    const [value] = args;
-    if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(expandSymbolic(value.value));
-  },
-  // factor(expr), writing a polynomial as a product of irreducible factors
-  // over the RATIONALS. x^2-2 and x^2+1 come back unchanged, which is the
-  // correct answer over that field rather than a failure; see symbolic/Factor.ts.
-  68: (args) => {
-    const [value] = args;
-    if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(factorSymbolic(value.value));
-  },
-  // solve(equation, variable), emitted by its own parselet as three stack
-  // values: the two sides of the equation, then the variable NAME as a
-  // String. Reading the name as a string rather than compiling it as a
-  // variable read is what lets `solve(x^2-4=0, x)` work without `x` existing.
-  69: (args) => {
-    const [lhsValue, rhsValue, variableValue] = args;
-    if (variableValue?.type !== 3 /* String */) {
-      return errorValue("SOLVE_REQUIRES_VARIABLE_NAME", "solve's second argument must be the name of the unknown.");
-    }
-    return solveEquationValues(lhsValue, rhsValue, variableValue.value);
-  },
-  // der(expr, variable, order), the symbolic derivative. Genuinely symbolic
-  // rather than a finite difference, so it is exact.
-  70: (args) => {
-    const [target, variableValue, orderValue] = args;
-    const variable = symbolicVariableName(variableValue, "der");
-    if (typeof variable !== "string") return variable;
-    const expression = valueToSymbolic(target);
-    if (expression === null) return errorValue("SYMBOLIC_NONFINITE_OPERAND", "der needs an expression with an exact value.");
-    return symbolicToValue(differentiate2(expression, variable, orderValue?.toNumber() ?? 1));
-  },
-  // integral(expr, variable), the indefinite integral without a constant of
-  // integration. Reports what it cannot do rather than approximating; see
-  // symbolic/Integral.ts.
-  71: (args) => {
-    const [target, variableValue] = args;
-    const variable = symbolicVariableName(variableValue, "integral");
-    if (typeof variable !== "string") return variable;
-    const expression = valueToSymbolic(target);
-    if (expression === null) return errorValue("SYMBOLIC_NONFINITE_OPERAND", "integral needs an expression with an exact value.");
-    const result = integrate(expression, variable);
-    if (!result.ok) return errorValue("SYMBOLIC_INTEGRAL_UNSUPPORTED", `Cannot integrate this: ${result.reason}.`);
-    return symbolicToValue(result.value);
-  },
-  // taylor(expr, variable = point, degree).
-  72: (args) => {
-    const [target, variableValue, pointValue, degreeValue] = args;
-    const variable = symbolicVariableName(variableValue, "taylor");
-    if (typeof variable !== "string") return variable;
-    const expression = valueToSymbolic(target);
-    const point = valueToSymbolic(pointValue);
-    if (expression === null || point === null || point.kind !== "const") {
-      return errorValue("SYMBOLIC_NONFINITE_OPERAND", "taylor needs an expression and an exact expansion point.");
-    }
-    return symbolicToValue(taylorSeries(expression, variable, point.value, degreeValue.toNumber()));
-  },
-  // jacobian(f1, f2, ...), variadic. The variables are not named: they come
-  // from the union of the functions' own unknowns, sorted, matching Calca.
-  73: (args) => {
-    const functions = [];
-    for (const arg of args) {
-      const node = valueToSymbolic(arg);
-      if (node === null) return errorValue("SYMBOLIC_NONFINITE_OPERAND", "jacobian needs expressions with exact values.");
-      functions.push(node);
-    }
-    const variables = /* @__PURE__ */ new Set();
-    for (const fn of functions) for (const name of freeVariables(fn)) variables.add(name);
-    const sorted = [...variables].sort();
-    if (sorted.length === 0) return errorValue("SYMBOLIC_JACOBIAN_NO_VARIABLES", "jacobian needs at least one unknown to differentiate against.");
-    const rows = jacobian(functions, sorted);
-    const rowMajor = [];
-    for (const row of rows) {
-      for (const cell of row) rowMajor.push(symbolicToEntry(cell));
-    }
-    return matrixValue(rows.length, sorted.length, rowMajorToColumnMajor(rows.length, sorted.length, rowMajor));
-  },
-  // An imaginary literal, 3i. The parselet pushes the numeric part and this
-  // turns it into an exact imaginary value.
-  74: (args) => symbolicToValue(complexNode(complex(RATIONAL_ZERO, rationalFromNumber(args[0].toNumber())))),
-  // conj(z), re(z) and im(z). Each folds immediately for a literal and stays
-  // symbolic for anything still carrying an unknown.
-  75: (args) => applyComplexAccessor("conj", args[0]),
-  76: (args) => applyComplexAccessor("re", args[0]),
-  77: (args) => applyComplexAccessor("im", args[0]),
-  // cancel(expr), reducing a quotient of polynomials to lowest terms.
-  78: (args) => {
-    const value = args[0];
-    if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(cancelSymbolic(value.value));
-  },
-  // apart(expr), the partial-fraction decomposition of a rational function.
-  79: (args) => {
-    const value = args[0];
-    if (value.type !== 9 /* Symbolic */) return value;
-    return symbolicToValue(apartSymbolic(value.value));
-  },
-  // taxIn(amount, rate) -> amount - amount/(1 + rate), the tax already
-  // contained in a tax-INCLUSIVE total. Backs "tax in/of/from $X at R%".
-  // The complement of taxRemove (index 59): the two sum to the gross amount.
-  85: (args) => {
-    const amount = args[0].toNumber();
-    const rate = args[1].toNumber();
-    if (1 + rate <= 0) {
-      return errorValue("INVALID_RATE", `taxIn: rate ${rate} makes (1 + rate) non-positive`);
-    }
-    const tax = amount - amount / (1 + rate);
-    if (args[0].type === 6 /* Uom */) {
-      return taxInExact(args[0], args[0].unit, rate) ?? uomValue(tax, args[0].unit);
-    }
-    return numberValue(tax);
-  },
-  // taxOn(amount, rate) -> amount * rate, the tax itself.
-  //
-  // The "tax on $X at R%" phrase used to compile to taxAdd (index 58) and
-  // answer $345.00 for "tax on $300 at 15%". Soulver answers $45.00, and
-  // "the tax on $300" is the tax, not the bill. The total is "$300 + 15%",
-  // which reads as a relative increase (see PercentParselet.ts), or
-  // taxAdd(300, 0.15) for the function form.
-  86: (args) => {
-    const amount = args[0].toNumber();
-    const rate = args[1].toNumber();
-    if (args[0].type === 6 /* Uom */) return scaleMoneyExact(args[0], rate, args[0].unit);
-    return numberValue(amount * rate);
-  },
-  // ── Degree-taking trig (sind/cosd/tand and the inverses) ──────────────
-  // The "d" spellings take and return degrees rather than radians, which is
-  // the convention every scientific calculator uses. sin(90 degrees) is the
-  // other way to say the same thing; both exist because both get typed.
-  87: (args) => numberValue(Math.sin(args[0].toNumber() * Math.PI / 180)),
-  88: (args) => numberValue(Math.cos(args[0].toNumber() * Math.PI / 180)),
-  89: (args) => numberValue(Math.tan(args[0].toNumber() * Math.PI / 180)),
-  90: (args) => numberValue(Math.asin(args[0].toNumber()) * 180 / Math.PI),
-  91: (args) => numberValue(Math.acos(args[0].toNumber()) * 180 / Math.PI),
-  92: (args) => numberValue(Math.atan(args[0].toNumber()) * 180 / Math.PI),
-  // daysCount(n) -> n labelled as days. "days in Q3" is a count of days
-  // and should say so; a bare 92 loses what was being counted.
-  93: (args) => uomValue(args[0].toNumber(), "days"),
-  // asTwoUnits(value, majorUnit, minorUnit) -> "12 min 30 s".
-  //
-  // "12.5 minutes in minutes and seconds" asks for one quantity split
-  // across two units, which every other conversion path cannot express:
-  // they each produce a single number in a single unit.
-  //
-  // The whole part goes to the major unit and the remainder to the minor,
-  // so nothing is lost. A pair that is not ordered major-then-minor, or
-  // that spans two different measures, reports rather than guessing.
-  94: (args) => {
-    const major = typeof args[1]?.value === "string" ? args[1].value : void 0;
-    const minor = typeof args[2]?.value === "string" ? args[2].value : void 0;
-    if (major === void 0 || minor === void 0) {
-      return errorValue("UNKNOWN_UNIT", 'both units have to be named, as in "12.5 minutes in minutes and seconds"');
-    }
-    const majorEntry = UNIT_TABLE[major.toLowerCase()];
-    const minorEntry = UNIT_TABLE[minor.toLowerCase()];
-    if (majorEntry === void 0 || minorEntry === void 0) {
-      return errorValue("UNKNOWN_UNIT", `${major} and ${minor}: one of these is not a unit`);
-    }
-    if (majorEntry[0] !== minorEntry[0]) {
-      return errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor} measure different things`);
-    }
-    if (minorEntry[1] >= majorEntry[1]) {
-      return errorValue("INCOMPATIBLE_UNITS", `${major} and ${minor}: name the larger unit first`);
-    }
-    const source = args[0];
-    const sourceEntry = source.type === 6 /* Uom */ && source.unit !== void 0 ? UNIT_TABLE[source.unit.toLowerCase()] : void 0;
-    const inBase = source.toNumber() * (sourceEntry?.[1] ?? majorEntry[1]);
-    const majorCount = Math.floor(inBase / majorEntry[1]);
-    const minorCount = Math.round((inBase - majorCount * majorEntry[1]) / minorEntry[1] * 1e3) / 1e3;
-    return stringValue(`${majorCount} ${major} ${minorCount} ${minor}`);
-  },
-  // makeRate(value, denominatorUnit) -> value per that unit.
-  //
-  // `3 hours / day` is a rate, `3 hours / 3 days` is a division. The
-  // difference is whether a number was written in the denominator, which
-  // is decided at parse time, so this only ever receives the rate case.
-  //
-  // Building the rate directly rather than dividing by an implied 1 is the
-  // whole point: a division makes same-measure units cancel, which turned
-  // `3 hours / day` into 0.125 when that shortcut was tried.
-  95: (args) => {
-    const source = args[0];
-    const denominator = String(args[1].value);
-    const numerator = source.type === 6 /* Uom */ && source.unit !== void 0 ? source.unit : "";
-    if (numerator.includes("/")) {
-      return errorValue("INVALID_RATE_UNIT", `${numerator}/${denominator}: that is already a rate`);
-    }
-    return uomValue(source.toNumber(), `${numerator}/${denominator}`);
-  },
-  // atRate(quantity, rate) -> whichever of the two the question implies.
-  //
-  //   30 hours at $30/hour   $900      a duration at a price per duration
-  //   $500 at $20/hour       25 hours   money at a price per duration
-  //
-  // Both are written with the same word and mean opposite operations. Which
-  // one applies is decided by which half of the rate the left side matches:
-  // match the denominator and you are buying that many, match the numerator
-  // and you are asking how many it buys.
-  96: (args) => {
-    const left = args[0];
-    const rate = args[1];
-    if (rate.type !== 6 /* Uom */ || rate.unit === void 0 || !rate.unit.includes("/")) {
-      return errorValue("INVALID_RATE", 'at: the right-hand side has to be a rate, as in "$30/hour"');
-    }
-    const slash = rate.unit.indexOf("/");
-    const numerator = rate.unit.slice(0, slash);
-    const denominator = rate.unit.slice(slash + 1);
-    const leftUnit = left.type === 6 /* Uom */ ? left.unit : void 0;
-    const denominatorEntry = UNIT_TABLE[denominator.toLowerCase()];
-    const leftEntry = leftUnit === void 0 ? void 0 : UNIT_TABLE[leftUnit.toLowerCase()];
-    if (leftEntry !== void 0 && denominatorEntry !== void 0 && leftEntry[0] === denominatorEntry[0]) {
-      const inDenominator = left.toNumber() * leftEntry[1] / denominatorEntry[1];
-      const total = inDenominator * rate.toNumber();
-      return numerator === "" ? numberValue(total) : uomValue(total, numerator);
-    }
-    if (leftUnit !== void 0 && leftUnit === numerator) {
-      const count = left.toNumber() / rate.toNumber();
-      return uomValue(count, pluraliseUnit(denominator, count));
-    }
-    if (leftUnit === void 0) {
-      const total = left.toNumber() * rate.toNumber();
-      return numerator === "" ? numberValue(total) : uomValue(total, numerator);
-    }
-    return errorValue("INCOMPATIBLE_UNITS", `at: ${leftUnit} matches neither side of ${rate.unit}`);
-  },
-  // ── Investments (packages/finance/) ────────────────────────────────────
-  // compoundFutureValueEvery(principal, rate, years, periodsPerYear)
-  // FV = P(1 + r/n)^(n·y). Index 51 is the same formula with n fixed at 1;
-  // this one backs "compounding monthly"/"quarterly"/"daily"/"weekly".
-  // Kept separate rather than widening 51, because 51 is also the public
-  // compoundInterest(principal, rate, years) call and its arity is part of
-  // that contract.
-  80: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    const perYear = args[3].toNumber();
-    if (perYear <= 0) {
-      return errorValue("INVALID_RATE", `compounding: ${perYear} periods per year is not a period`);
-    }
-    if (1 + rate / perYear <= 0) {
-      return errorValue("INVALID_RATE", `compounding: rate ${rate} makes each period non-positive`);
-    }
-    const fv = principal * Math.pow(1 + rate / perYear, perYear * years);
-    return args[0].type === 6 /* Uom */ ? uomValue(fv, args[0].unit) : numberValue(fv);
-  },
-  // compoundInterestEarnedEvery(principal, rate, years, periodsPerYear)
-  // The interest-only portion of index 80, i.e. FV - P.
-  81: (args) => {
-    const principal = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    const perYear = args[3].toNumber();
-    if (perYear <= 0 || 1 + rate / perYear <= 0) {
-      return errorValue("INVALID_RATE", `compounding: rate ${rate} over ${perYear} periods per year is not usable`);
-    }
-    const interest = principal * (Math.pow(1 + rate / perYear, perYear * years) - 1);
-    return args[0].type === 6 /* Uom */ ? uomValue(interest, args[0].unit) : numberValue(interest);
-  },
-  // presentValue(futureValue, rate, years) -> FV / (1 + r)^y, what a sum
-  // promised in the future is worth today. The inverse of index 51.
-  82: (args) => {
-    const future = args[0].toNumber();
-    const rate = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (1 + rate <= 0) {
-      return errorValue("INVALID_RATE", `presentValue: rate ${rate} makes (1 + rate) non-positive`);
-    }
-    const pv = future / Math.pow(1 + rate, years);
-    return args[0].type === 6 /* Uom */ ? uomValue(pv, args[0].unit) : numberValue(pv);
-  },
-  // returnOnInvestment(invested, returned) -> (returned - invested) /
-  // invested, the gain as a multiple of what was put in. $500 in and $1,500
-  // out is 2x, not 3x: ROI conventionally measures the profit against the
-  // cost, so doubling your money is 1x return and tripling it is 2x. The
-  // money multiple (3x here) is a different figure; `$1,500 / $500` gives it.
-  83: (args) => {
-    const invested = args[0].toNumber();
-    const returned = args[1].toNumber();
-    if (invested === 0) {
-      return errorValue("INVALID_RATE", "roi: nothing was invested, so there is no return on it");
-    }
-    return numberValue((returned - invested) / invested);
-  },
-  // annualisedReturn(invested, returned, years) -> CAGR, the constant
-  // yearly rate that turns `invested` into `returned` over `years`:
-  // (returned/invested)^(1/years) - 1. Returned as a Percentage so it
-  // renders "13.99%" rather than 0.1399.
-  84: (args) => {
-    const invested = args[0].toNumber();
-    const returned = args[1].toNumber();
-    const years = args[2].toNumber();
-    if (invested <= 0) {
-      return errorValue("INVALID_RATE", "annual return: the amount invested must be positive");
-    }
-    if (years <= 0) {
-      return errorValue("INVALID_RATE", "annual return: the period must be longer than zero");
-    }
-    if (returned <= 0) {
-      return errorValue("INVALID_RATE", "annual return: nothing was returned, so there is no annual rate");
-    }
-    return percentageValue(Math.pow(returned / invested, 1 / years) - 1);
-  },
-  // roundToPlaces(value, places) -> value rounded to that many decimal
-  // places, backing `<value> to <n> dp` (converters/parselets/
-  // RoundingParselets.ts).
-  //
-  // It exists because the obvious bytecode for it, "multiply by 10^p, round,
-  // divide by 10^p", is only safe for values small enough that the multiply
-  // is exact. `1e21 to 2 dp` came back as 999999999999999900000: 1e21 has no
-  // fractional part to round at all, and the round trip through 1e23 was
-  // pure loss. Asking for fewer decimal places than a number has cannot
-  // change it, so a value that is already whole is returned untouched.
-  97: (args) => roundToPlaces(args[0], args[1].toNumber()),
-  // splitEach(amount, n): a per-person bill split, `split $180 between 4` and
-  // `$120 + 18% split 3 ways`. Backs both split spellings (see
-  // BillSplitParselets.ts). Money stays exact and the shares add back to the
-  // total to the cent (see splitEachExact in MoneyExact.ts). A bare number
-  // splits to a bare number; the odd penny is named, not rounded away.
-  98: (args) => {
-    const n = args[1].toNumber();
-    if (!Number.isInteger(n) || n < 1) {
-      return errorValue("INVALID_RANGE", `split: the number of shares must be a whole number of at least 1, not ${args[1].toNumber()}.`);
-    }
-    return splitValue(splitEachExact(args[0], n));
-  },
-  // ── Savings goals ──────────────────────────────────────────────
-  // savingsGoalPayment(target, duration, annualRate): the level contribution
-  // per month that reaches `target` over `duration` (months or years), at an
-  // optional annual rate compounded monthly. Backs "how much per month to
-  // save/reach <target> in <duration> [at <rate>]".
-  99: (args) => {
-    const target = args[0].toNumber();
-    const months = monthsOfDuration(args[1]);
-    const annualRate = args[2].toNumber();
-    if (months === null) return errorValue("INVALID_RANGE", `savings goal: the duration must be in months or years, e.g. "in 2 years".`);
-    if (target <= 0) return errorValue("INVALID_RANGE", `savings goal: the target must be positive.`);
-    if (months <= 0) return errorValue("INVALID_RANGE", `savings goal: the duration must be positive.`);
-    if (annualRate < 0) return errorValue("INVALID_RATE", `savings goal: the rate must not be negative.`);
-    const payment = annuityPayment(target, annualRate / 12, months);
-    return args[0].type === 6 /* Uom */ ? uomValue(payment, args[0].unit) : numberValue(payment);
-  },
-  // savingsGoalPeriods(target, contribution, periodsPerYear, annualRate,
-  // periodUnit): how many whole periods of `contribution` reach `target`,
-  // rounded UP, since a part period has not yet reached the goal. Backs
-  // "how long to save <target> at <amount> <period> [at <rate>]".
-  100: (args) => {
-    const target = args[0].toNumber();
-    const contribution = args[1].toNumber();
-    const periodsPerYear = args[2].toNumber();
-    const annualRate = args[3].toNumber();
-    const unit = typeof args[4]?.value === "string" ? args[4].value : "periods";
-    if (target <= 0) return errorValue("INVALID_RANGE", `savings goal: the target must be positive.`);
-    if (contribution <= 0) return errorValue("INVALID_RANGE", `savings goal: the contribution must be positive.`);
-    if (annualRate < 0) return errorValue("INVALID_RATE", `savings goal: the rate must not be negative.`);
-    const periods = annuityPeriods(target, contribution, annualRate / periodsPerYear);
-    return uomValue(periods, unit);
-  }
-};
-function monthsOfDuration(duration) {
-  if (duration.type !== 6 /* Uom */) return null;
-  const unit = duration.unit;
-  if (unit === "months" || unit === "month") return duration.toNumber();
-  if (unit === "years" || unit === "year") return duration.toNumber() * 12;
-  return null;
-}
-function annuityPayment(target, i, months) {
-  return i === 0 ? target / months : target * i / (Math.pow(1 + i, months) - 1);
-}
-function annuityPeriods(target, contribution, i) {
-  const raw = i === 0 ? target / contribution : Math.log(1 + target * i / contribution) / Math.log(1 + i);
-  return Math.ceil(raw - 1e-9);
-}
-function applyComplexAccessor(name, value) {
-  const node = valueToSymbolic(value);
-  if (node === null) return errorValue("SYMBOLIC_NONFINITE_OPERAND", name + " needs a value with an exact number.");
-  return symbolicToValue(callNode(name, [node]));
-}
-function symbolicVariableName(value, verb) {
-  if (value?.type !== 3 /* String */) {
-    return errorValue("SYMBOLIC_REQUIRES_VARIABLE_NAME", `${verb} needs the name of an unknown.`);
-  }
-  return value.value;
-}
-function amortizeLoan(principal, annualRate, years) {
-  const n = years * 12;
-  const rMonthly = annualRate / 12;
-  const monthlyPayment = rMonthly === 0 ? principal / n : principal * rMonthly / (1 - Math.pow(1 + rMonthly, -n));
-  const totalRepayment = monthlyPayment * n;
-  const totalInterest = totalRepayment - principal;
-  return { monthlyPayment, totalRepayment, totalInterest };
-}
-var pluginFunctionRegistry = defaultEngineContext.pluginFunctions;
-var MAX_PLUGIN_FUNCTION_INDEX = 255;
-var nextPluginFunctionIndex = 0;
-function allocatePluginFunctionIndex() {
-  if (nextPluginFunctionIndex > MAX_PLUGIN_FUNCTION_INDEX) {
-    throw ErrorFactory.config(
-      "PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED",
-      `allocatePluginFunctionIndex: pool exhausted (max ${MAX_PLUGIN_FUNCTION_INDEX + 1} allocations).`
-    );
-  }
-  return nextPluginFunctionIndex++;
-}
-var asConverterRegistry = /* @__PURE__ */ new Map();
-function registerAsConverter(name, handler) {
-  const key = name.toLowerCase();
-  const existing = asConverterRegistry.get(key);
-  if (existing && existing !== handler) {
-    console.warn(`[asConverterRegistry] Converter name "${key}" is already registered \u2014 overwriting.`);
-  }
-  asConverterRegistry.set(key, handler);
-}
-function unregisterAsConverter(name) {
-  asConverterRegistry.delete(name.toLowerCase());
-}
-
-// src/vm/GlobalVariableStore.ts
-var _GlobalVariableStore = class _GlobalVariableStore {
-  constructor() {
-    this.values = /* @__PURE__ */ new Map();
-    this.listeners = /* @__PURE__ */ new Set();
-    this.notifyDepth = 0;
-  }
-  get(name) {
-    return this.values.get(name);
-  }
-  has(name) {
-    return this.values.has(name);
-  }
-  /**
-   * Last-write-wins: any document may call this for any name at any time.
-   * Notifies listeners synchronously, within the same call, before
-   * returning, so that ThreeTierEvaluator's dirty-marking (a listener)
-   * and GlobalVariableAsyncResolver's first-write promise (also a
-   * listener) both observe the new value immediately, no microtask delay.
-   *
-   * A write that does not CHANGE the stored value notifies nobody. This
-   * is not just an optimisation, it is what stops a re-evaluation cycle
-   * from sustaining itself. Every listener re-runs work in response to a
-   * write (ThreeTierEvaluator marks dependent lines dirty; the playground
-   * worker refreshes other documents), and those re-runs re-execute the
-   * very STORE_GLOBAL_VAR opcode that produced this write. Re-evaluating
-   * an unchanged `global :x = 5` line therefore used to re-notify, which
-   * re-triggered the listeners, which re-evaluated... bounded only by
-   * MAX_NOTIFY_DEPTH below, and only in DEPTH, so with more than one
-   * writer the work per keystroke grew exponentially. Nothing observable
-   * changed, so there is nothing for a listener to react to.
-   */
-  set(name, value) {
-    const previous = this.values.get(name);
-    this.values.set(name, value);
-    if (previous !== void 0 && sameValue(previous, value)) return;
-    this.notify(name, value);
-  }
-  notify(name, value) {
-    if (this.notifyDepth >= _GlobalVariableStore.MAX_NOTIFY_DEPTH) return;
-    this.notifyDepth++;
-    try {
-      for (const listener of this.listeners) listener(name, value);
-    } finally {
-      this.notifyDepth--;
-    }
-  }
-  /**
-   * Subscribe to every global-variable write (all names, callers filter
-   * for the name(s) they care about). Returns an unsubscribe function;
-   * callers MUST invoke it when disposing (e.g. ThreeTierEvaluator's
-   * terminateWorker()) to avoid leaking listeners for closed documents.
-   */
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  /**
-   * Full reset, test-only. Never called from production code paths;
-   * globals must outlive any single engine's own clear()/dispose cycle.
-   * Tests MUST call this in beforeEach/afterEach since this is a
-   * module-level singleton whose state and listeners otherwise leak
-   * across test cases and files.
-   */
-  clear() {
-    this.values.clear();
-    this.listeners.clear();
-    this.notifyDepth = 0;
-  }
-};
-/**
- * Guards against runaway cross-document write cycles: doc A's write
- * notifies doc B, whose dirty line, once evaluated, writes a global
- * that notifies doc C, ... eventually back to A. Same philosophy as the
- * VM's own instruction-limit safety net: stop propagating past the
- * limit rather than let a genuine cycle recurse unboundedly. The store
- * itself is left in a well-defined state either way. This only bounds
- * *notification* depth, never the value actually stored.
- */
-_GlobalVariableStore.MAX_NOTIFY_DEPTH = 64;
-var GlobalVariableStore = _GlobalVariableStore;
-function sameValue(a, b) {
-  if (a.type !== b.type) return false;
-  if (a.unit !== b.unit) return false;
-  if ((a.timedOut ?? false) !== (b.timedOut ?? false)) return false;
-  const av = a.value;
-  const bv = b.value;
-  if (Array.isArray(av) || Array.isArray(bv)) {
-    if (!Array.isArray(av) || !Array.isArray(bv)) return false;
-    if (av.length !== bv.length) return false;
-    for (let i = 0; i < av.length; i++) {
-      if (!Object.is(av[i], bv[i])) return false;
-    }
-    return true;
-  }
-  return Object.is(av, bv);
-}
-var sharedGlobalVariableStore = new GlobalVariableStore();
-function globalDagKey(name) {
-  return `global:${name}`;
-}
-
-export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareRationalOperands, compareUom, createEngineContext, defaultEngineContext, describeConversionMismatch, exactRationalOp, globalDagKey, incomparableUnitsError, moneyExactMagnitude, pluginFunctionRegistry, power, registerAsConverter, scaleMoneyByPercent, scaleMoneyExact, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, solveForVariable, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, uncertainOp, unifyUom, unregisterAsConverter };
-//# sourceMappingURL=chunk-WMQRJTAO.js.map
-//# sourceMappingURL=chunk-WMQRJTAO.js.map