solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/{chunk-MVBEL57Q.js → chunk-Y7FT4IQT.js}

@@ -1,10 +1,10 @@
 import { VariableResolver } from './chunk-GCM5JHMX.js';
-import { sharedCurrencyExchange } from './chunk-UKPGSAZW.js';
-import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, rationalCompare, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalAdd, rationalSub, exactIntegerSqrt, surdNode, compareMonomials, COMPLEX_I, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-CYFK5SY2.js';
-import { errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, percentageValue, stringValue, hexValue } from './chunk-BVAR5J2F.js';
-import { getMeasure, convertUnit } from './chunk-WC5FFSHB.js';
-import { UNIT_TABLE } from './chunk-PCPX42KL.js';
-import { ErrorFactory } from './chunk-6RDSQURE.js';
+import { sharedCurrencyExchange } from './chunk-TMA4RCEN.js';
+import { powNode, callNode, simplifySymbolic, sameShape, cancelSymbolic, complexNode, complex, RATIONAL_ZERO, rationalFromNumber, freeVariables, symbolicToEntry, rowMajorToColumnMajor, expandSymbolic, matrixMultiply, inverse, determinant, transpose, matrixPower, constNode, rationalToNumber, toPolynomial, polyDegree, polyCoefficients, rationalNeg, substitute, rationalDiv, isRationalZero, varNode, isRationalOne, RATIONAL_ONE, polyUnivariateVar, rationalMul, fromPolynomial, coefficientGcd, polynomialDivide, isZeroPolynomial, rationalCompare, rationalSub, exactIntegerSqrt, rationalAdd, surdNode, compareMonomials, COMPLEX_I, squareFreePart, exactRationalSqrt, symbolicKey, monomialFromKey, monomialToKey, signedSurdNode, exactIntegerCbrt } from './chunk-O3ANBHSA.js';
+import { faultedOperand, errorValue, symbolicValue, numberValue, bigIntValue, uomValue, matrixValue, percentageValue, stringValue, hexValue } from './chunk-GQCOSXMG.js';
+import { getMeasure, convertUnit } from './chunk-R3PY4G7J.js';
+import { UNIT_TABLE } from './chunk-V4XG5QF6.js';
+import { ErrorFactory } from './chunk-3D7V24DG.js';
 
 // src/symbolic/MultivariateFactor.ts
 function exactRoot(value, degree) {
@@ -92,9 +92,9 @@ function factorBinomial(first, second) {
   return product([linear, termsToNode([squareOf(cubes.a), middle, squareOf(cubes.b)])]);
 }
 function asPowerPair(first, second, degree) {
-  const magnitude = second.coefficient.n < 0n ? rationalNeg(second.coefficient) : second.coefficient;
+  const magnitude2 = second.coefficient.n < 0n ? rationalNeg(second.coefficient) : second.coefficient;
   const firstRoot = exactRoot(first.coefficient, degree);
-  const secondRoot = exactRoot(magnitude, 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);
@@ -119,8 +119,8 @@ function factorPerfectSquare(terms) {
   if (cross.key !== middle.key) return null;
   const twice = rationalMul(cross.coefficient, { n: 2n, d: 1n });
   const negative = middle.coefficient.n < 0n;
-  const magnitude = negative ? rationalNeg(middle.coefficient) : middle.coefficient;
-  if (!isRationalOne(rationalDiv(magnitude, twice))) return null;
+  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) };
 }
@@ -174,13 +174,13 @@ function lcm(a, b) {
   return a / gcd(a, b) * b;
 }
 function divisors(value) {
-  const magnitude = value < 0n ? -value : value;
-  if (magnitude === 0n) return null;
+  const magnitude2 = value < 0n ? -value : value;
+  if (magnitude2 === 0n) return null;
   const found = [];
-  for (let candidate = 1n; candidate * candidate <= magnitude; candidate++) {
-    if (magnitude % candidate !== 0n) continue;
+  for (let candidate = 1n; candidate * candidate <= magnitude2; candidate++) {
+    if (magnitude2 % candidate !== 0n) continue;
     found.push(candidate);
-    const paired = magnitude / candidate;
+    const paired = magnitude2 / candidate;
     if (paired !== candidate) found.push(paired);
     if (found.length > FACTOR_MAX_ROOT_CANDIDATES) return null;
   }
@@ -246,8 +246,8 @@ function coefficientsToNode(descending, variable) {
   const terms = /* @__PURE__ */ new Map();
   descending.forEach((coeff, index) => {
     if (isRationalZero(coeff)) return;
-    const power2 = degree - index;
-    terms.set(power2 === 0 ? "" : power2 === 1 ? variable : `${variable}^${power2}`, coeff);
+    const power3 = degree - index;
+    terms.set(power3 === 0 ? "" : power3 === 1 ? variable : `${variable}^${power3}`, coeff);
   });
   return fromPolynomial({ terms, vars: terms.size > 0 ? [variable] : [] });
 }
@@ -463,10 +463,10 @@ function trigonometricRoots(p, q, shift) {
   const pNumber = rationalToNumber(p);
   const qNumber = rationalToNumber(q);
   const shiftNumber = rationalToNumber(shift);
-  const magnitude = 2 * Math.sqrt(-pNumber / 3);
+  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) => magnitude * Math.cos(angle - 2 * Math.PI * k / 3) + shiftNumber).sort((left, right) => left - right);
+  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));
@@ -535,8 +535,8 @@ function nestedSquareRoots(p, r, discriminant) {
   const roots = [];
   for (const { node, positive } of solutions) {
     const radicand = positive ? node : { kind: "neg", operand: node };
-    const magnitude = { kind: "call", name: "sqrt", args: [radicand] };
-    const square = positive ? magnitude : { kind: "mul", left: magnitude, right: complexNode(COMPLEX_I) };
+    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;
@@ -545,13 +545,11 @@ 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);
-  if (modulus === null) return null;
-  const realPart = rationalDiv(rationalAdd(modulus, rationalDiv(rationalNeg(p), TWO)), TWO);
-  const imaginaryPart = rationalDiv(rationalSub(modulus, rationalDiv(rationalNeg(p), TWO)), TWO);
-  if (rationalCompare(realPart, RATIONAL_ZERO) < 0 || rationalCompare(imaginaryPart, RATIONAL_ZERO) < 0) return null;
-  const re = surdNode(realPart);
-  const im = { kind: "mul", left: surdNode(imaginaryPart), right: complexNode(COMPLEX_I) };
+  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 [
@@ -561,6 +559,10 @@ function complexBiquadraticRoots(p, r) {
     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 },
@@ -585,21 +587,185 @@ function splitQuarticRoots(p, q, r, solveQuadratic2) {
   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;
-var NEWTON_MAX_ITERATIONS = 100;
-var NEWTON_TOLERANCE = 1e-12;
-var NUMERIC_SCAN_STEPS = 2e3;
 function evaluateRational(descending, x) {
   let total = RATIONAL_ZERO;
   for (const coeff of descending) total = rationalAdd(rationalMul(total, x), coeff);
   return total;
 }
-function evaluateNumeric(descending, x) {
-  let total = 0;
-  for (const coeff of descending) total = total * x + rationalToNumber(coeff);
-  return total;
-}
 function divideByRoot2(descending, root) {
   const quotient = [descending[0]];
   for (let i = 1; i < descending.length - 1; i++) {
@@ -629,9 +795,9 @@ function solveQuadratic(a, b, c) {
   return ascending ? [lower, upper] : [upper, lower];
 }
 function complexQuadraticRoots(negatedB, discriminant, twoA) {
-  const magnitude = rationalNeg(discriminant);
-  const rootN = exactIntegerSqrt(magnitude.n);
-  const rootD = exactIntegerSqrt(magnitude.d);
+  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);
@@ -641,7 +807,7 @@ function complexQuadraticRoots(negatedB, discriminant, twoA) {
     ];
   }
   const real = rationalDiv(negatedB, twoA);
-  const scaledRadicand = rationalDiv(magnitude, rationalMul(twoA, 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];
@@ -657,44 +823,8 @@ function rational2() {
 function rational4() {
   return { n: 4n, d: 1n };
 }
-function numericRoots(descending) {
-  const leading = rationalToNumber(descending[0]);
-  if (leading === 0) return [];
-  let bound = 0;
-  for (let i = 1; i < descending.length; i++) {
-    const ratio = Math.abs(rationalToNumber(descending[i]) / leading);
-    if (ratio > bound) bound = ratio;
-  }
-  bound += 1;
-  const roots = [];
-  const step = 2 * bound / NUMERIC_SCAN_STEPS;
-  let previousX = -bound;
-  let previousY = evaluateNumeric(descending, previousX);
-  for (let i = 1; i <= NUMERIC_SCAN_STEPS; i++) {
-    const x = -bound + i * step;
-    const y = evaluateNumeric(descending, x);
-    if (previousY === 0) roots.push(previousX);
-    else if (previousY < 0 !== y < 0) roots.push(bisect(descending, previousX, x));
-    previousX = x;
-    previousY = y;
-  }
-  return roots;
-}
-function bisect(descending, low, high) {
-  let left = low;
-  let right = high;
-  let leftValue = evaluateNumeric(descending, left);
-  for (let i = 0; i < NEWTON_MAX_ITERATIONS && right - left > NEWTON_TOLERANCE; i++) {
-    const middle = (left + right) / 2;
-    const middleValue = evaluateNumeric(descending, middle);
-    if (leftValue < 0 === middleValue < 0) {
-      left = middle;
-      leftValue = middleValue;
-    } else {
-      right = middle;
-    }
-  }
-  return (left + right) / 2;
+function realApproximation(value) {
+  return { re: value, im: 0 };
 }
 function solveForVariable(lhs, rhs, variable) {
   const polynomial = toPolynomial({ kind: "sub", left: lhs, right: rhs });
@@ -763,38 +893,76 @@ function closedFormRoots(descending) {
   }
   return null;
 }
-function solveUnivariate(descending) {
-  const exact = [];
+function extractRationalRoots(descending) {
+  const roots = [];
   let remaining = [...descending];
-  let roots = [...rationalRoots(remaining)].sort(rationalCompare);
-  while (roots.length > 0 && remaining.length > 1) {
-    for (const root of roots) {
+  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++;
       }
-      exact.push(constNode(root));
+      if (multiplicity > 0) roots.push(root);
     }
-    roots = remaining.length > 1 ? [...rationalRoots(remaining)].sort(rationalCompare) : [];
   }
+  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 { kind: "roots", exact, approximate: [] };
+    return finish(exact, approximate, solvedDegree + 1, 0, "");
   }
   if (leftoverDegree === 2) {
-    const quadratic = solveQuadratic(remaining[0], remaining[1], remaining[2]);
-    return { kind: "roots", exact: [...exact, ...quadratic], approximate: [] };
-  }
-  if (leftoverDegree <= 0) {
-    return exact.length > 0 ? { kind: "roots", exact, approximate: [] } : { kind: "no-real-solutions", reason: "there is no value that satisfies this equation" };
+    exact.push(...solveQuadratic(remaining[0], remaining[1], remaining[2]));
+    return finish(exact, approximate, solvedDegree + 2, 0, "");
   }
   const closedForm = closedFormRoots(remaining);
   if (closedForm !== null) {
-    return { kind: "roots", exact: [...exact, ...closedForm.exact], approximate: closedForm.approximate };
-  }
-  const approximate = numericRoots(remaining);
-  if (exact.length === 0 && approximate.length === 0) {
-    return { kind: "no-real-solutions", reason: "no real root was found within the polynomial's root bound" };
+    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 };
 }
@@ -871,7 +1039,8 @@ function symbolicNeg(v) {
 function symbolicBuiltin(index, args) {
   const nodes = [];
   for (const arg of args) {
-    if (arg.type === 13 /* Error */) return arg;
+    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);
@@ -888,19 +1057,28 @@ function rootToValue(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 "no-real-solutions":
-      return stringValue(`no real solutions (${outcome.reason})`);
     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(numberValue(approximate));
+      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()));
@@ -945,6 +1123,65 @@ function unifyUom(l, r) {
   }
   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 (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 };
+}
+function incomparableUnitsError(l, r) {
+  const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
+  const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
+  return errorValue("INCOMPATIBLE_UNITS", `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 binaryOp(l, r, op, bigOp, symbolicOp) {
   if (l.type === 13 /* Error */) return l;
   if (r.type === 13 /* Error */) return r;
@@ -966,14 +1203,13 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
     return numberValue(op(l.value, r.value));
   }
   if (l.type === 2 /* BigInt */ || r.type === 2 /* BigInt */) {
-    const lb = l.type === 2 /* BigInt */ ? l.value : BigInt(l.toNumber());
-    const rb = r.type === 2 /* BigInt */ ? r.value : BigInt(r.toNumber());
+    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 */) {
     const { lv, rv, unit, sameMeasure } = unifyUom(l, r);
-    if (isNaN(lv) || isNaN(rv)) return numberValue(0);
     if (!sameMeasure) {
       const lUnit = l.type === 6 /* Uom */ ? l.unit : void 0;
       const rUnit = r.type === 6 /* Uom */ ? r.unit : void 0;
@@ -1003,10 +1239,7 @@ function binaryOp(l, r, op, bigOp, symbolicOp) {
     const result = rm.data.map((v) => op(scalar, v));
     return matrixValue(rm.rows, rm.cols, result);
   }
-  const lNum = l.toNumber();
-  const rNum = r.toNumber();
-  if (isNaN(lNum) || isNaN(rNum)) return numberValue(0);
-  return numberValue(op(lNum, rNum));
+  return numberValue(op(l.toNumber(), r.toNumber()));
 }
 
 // src/vm/OpRegistry.ts
@@ -1057,7 +1290,7 @@ var sharedOpRegistry = new OpRegistry();
 
 // src/symbolic/PartialFractions.ts
 var APART_MAX_DEGREE = 12;
-function multiply(a, b) {
+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) => {
@@ -1067,9 +1300,9 @@ function multiply(a, b) {
   });
   return product2;
 }
-function power(base, exponent) {
+function power2(base, exponent) {
   let result = [RATIONAL_ONE];
-  for (let i = 0; i < exponent; i++) result = multiply(result, base);
+  for (let i = 0; i < exponent; i++) result = multiply2(result, base);
   return result;
 }
 function scale(coefficients, factor) {
@@ -1104,12 +1337,12 @@ function enumerateUnknowns(factors) {
   return unknowns;
 }
 function unknownColumn(unknown, factors, denominator) {
-  const divisor = power(factors[unknown.factor].base, unknown.power);
+  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 multiply(quotient, shift);
+  return multiply2(quotient, shift);
 }
 function solveLinearSystem(matrix, target) {
   const size = target.length;
@@ -1289,7 +1522,7 @@ function oneMinusSquare(argument) {
 function onePlusSquare(argument) {
   return { kind: "add", left: one(), right: powNode(argument, constNode(2)) };
 }
-function differentiate(node, variable, order = 1) {
+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.");
   }
@@ -1386,9 +1619,9 @@ function integratePolynomial(node, variable) {
   }
   const ascending = polyCoefficients(polynomial, variable);
   let result = constNode(0);
-  ascending.forEach((coeff, power2) => {
+  ascending.forEach((coeff, power3) => {
     if (isRationalZero(coeff)) return;
-    const nextPower = power2 + 1;
+    const nextPower = power3 + 1;
     const scaled = rationalDiv(coeff, { n: BigInt(nextPower), d: 1n });
     const term = {
       kind: "mul",
@@ -1577,7 +1810,7 @@ function taylorSeries(node, variable, point, degree) {
   let result = constNode(RATIONAL_ZERO);
   for (let order = 0; order <= degree; order++) {
     if (order > 0) factorial *= BigInt(order);
-    const derivative = differentiate(node, variable, order);
+    const derivative = differentiate2(node, variable, order);
     const atPoint = simplifySymbolic(substitute(derivative, variable, pointNode));
     if (atPoint.kind !== "const") {
       throw ErrorFactory.execution(
@@ -1589,13 +1822,13 @@ function taylorSeries(node, variable, point, degree) {
     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 power2 = order === 0 ? constNode(1) : order === 1 ? shifted : powNode(shifted, constNode(order));
-    result = { kind: "add", left: result, right: { kind: "mul", left: constNode(coefficient), right: power2 } };
+    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) => differentiate(fn, variable)));
+  return functions.map((fn) => variables.map((variable) => differentiate2(fn, variable)));
 }
 
 // src/engine/EngineContext.ts
@@ -1709,6 +1942,55 @@ function pluraliseUnit(unit, count) {
   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;
+      return errorValue(
+        "INCOMPATIBLE_UNITS",
+        `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 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
@@ -1722,38 +2004,20 @@ var builtinFunctions = {
   // 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) : numberValue(Math.abs(args[0].toNumber())),
+  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())),
-  6: (args) => numberValue(Math.ceil(args[0].toNumber())),
-  7: (args) => numberValue(Math.floor(args[0].toNumber())),
-  8: (args) => numberValue(Math.round(args[0].toNumber())),
-  // min/max: a plain loop replicating Math.min/Math.max's exact semantics
-  // (NaN poisons the result regardless of position; empty args -> ±Infinity)
-  // avoids the intermediate array .map()+spread allocates on every call.
-  9: (args) => {
-    let result = Infinity;
-    let hasNaN = false;
-    for (const a of args) {
-      const n = a.toNumber();
-      if (Number.isNaN(n)) hasNaN = true;
-      else if (n < result) result = n;
-    }
-    return numberValue(hasNaN ? NaN : result);
-  },
-  10: (args) => {
-    let result = -Infinity;
-    let hasNaN = false;
-    for (const a of args) {
-      const n = a.toNumber();
-      if (Number.isNaN(n)) hasNaN = true;
-      else if (n > result) result = n;
-    }
-    return numberValue(hasNaN ? NaN : result);
-  },
+  // 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) => 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())),
@@ -1779,7 +2043,22 @@ var builtinFunctions = {
   28: (args) => numberValue(Math.log10(args[0].toNumber())),
   29: (args) => numberValue(Math.log1p(args[0].toNumber())),
   30: (args) => numberValue(Math.log2(args[0].toNumber())),
-  31: (args) => numberValue(Math.pow(args[0].toNumber(), args[1].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())),
@@ -1802,32 +2081,37 @@ var builtinFunctions = {
   // gcd(a, b), Euclidean algorithm. Negative inputs are treated by
   // magnitude (gcd is conventionally defined over non-negative integers).
   38: (args) => {
-    let a = Math.trunc(Math.abs(args[0].toNumber()));
-    let b = Math.trunc(Math.abs(args[1].toNumber()));
-    while (b !== 0) {
-      const t = b;
-      b = a % b;
-      a = t;
-    }
-    return numberValue(a);
+    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);
-    let x = a, y = b;
-    while (y !== 0) {
-      const t = y;
-      y = x % y;
-      x = t;
-    }
-    return numberValue(a / x * b);
+    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());
@@ -1835,12 +2119,27 @@ var builtinFunctions = {
       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;
+    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());
@@ -1849,7 +2148,15 @@ var builtinFunctions = {
     }
     const k = Math.min(r, n - r);
     let result = 1;
-    for (let i = 0; i < k; i++) result = result * (n - i) / (i + 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
@@ -2099,7 +2406,7 @@ var builtinFunctions = {
   61: (args) => {
     const n = args[0].toNumber();
     const x = args[1].toNumber();
-    return numberValue(Math.pow(x, 1 / n));
+    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
@@ -2196,7 +2503,7 @@ var builtinFunctions = {
     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(differentiate(expression, variable, orderValue?.toNumber() ?? 1));
+    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
@@ -2311,8 +2618,11 @@ var builtinFunctions = {
   // 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 = args[1].value;
-    const minor = args[2].value;
+    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) {
@@ -2462,6 +2772,26 @@ var builtinFunctions = {
       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) => {
+    const source = args[0];
+    const value = source.toNumber();
+    const places = args[1].toNumber();
+    if (!Number.isFinite(value) || Number.isInteger(value)) return keepUnit(source, value);
+    const scale2 = Math.pow(10, places);
+    const scaled = value * scale2;
+    if (!Number.isFinite(scaled) || Math.abs(scaled) > Number.MAX_SAFE_INTEGER) return keepUnit(source, value);
+    return keepUnit(source, Math.round(scaled) / scale2);
   }
 };
 function applyComplexAccessor(name, value) {
@@ -2612,6 +2942,6 @@ function globalDagKey(name) {
   return `global:${name}`;
 }
 
-export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, binaryOp, builtinFunctions, createEngineContext, defaultEngineContext, globalDagKey, pluginFunctionRegistry, registerAsConverter, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, symbolicBuiltin, symbolicNeg, symbolicPow, unifyUom, unregisterAsConverter };
-//# sourceMappingURL=chunk-MVBEL57Q.js.map
-//# sourceMappingURL=chunk-MVBEL57Q.js.map
+export { CPI_MAX_YEAR, CPI_MIN_YEAR, OpRegistry, SYMBOLIC_NATIVE_BUILTINS, adjustForInflation, allocatePluginFunctionIndex, asConverterRegistry, bigIntDivisionByZero, binaryOp, builtinFunctions, compareBigIntOperands, compareUom, createEngineContext, defaultEngineContext, globalDagKey, incomparableUnitsError, pluginFunctionRegistry, power, registerAsConverter, sharedGlobalVariableStore, sharedOpRegistry, solveEquationValues, symbolicBuiltin, symbolicNeg, symbolicPow, toBigIntOperand, unifyUom, unregisterAsConverter };
+//# sourceMappingURL=chunk-Y7FT4IQT.js.map
+//# sourceMappingURL=chunk-Y7FT4IQT.js.map