@cortex-js/compute-engine 0.53.0 → 0.54.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.0 */
+/** Compute Engine 0.54.0 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -11083,7 +11083,7 @@ function parseWhereExpression(parser, lhs, until) {
     condition: (p) => {
       if (until?.condition?.(p)) return true;
       const saved = p.index;
-      p.skipSpace();
+      p.skipVisualSpace();
       const isComma = p.peek === ",";
       p.index = saved;
       return isComma;
@@ -11091,11 +11091,11 @@ function parseWhereExpression(parser, lhs, until) {
   };
   const bindings = [];
   do {
-    parser.skipSpace();
+    parser.skipVisualSpace();
     const binding = parser.parseExpression(bindingTerminator);
     if (!binding) break;
     bindings.push(binding);
-    parser.skipSpace();
+    parser.skipVisualSpace();
   } while (parser.match(","));
   if (bindings.length === 0) return null;
   const block = [];
@@ -11594,14 +11594,11 @@ function* factorial3(n) {
   let loop = n;
   let sum2 = n;
   let val = n;
-  let counter = 0;
   while (loop > 2) {
     loop -= BigInt(2);
     sum2 += loop;
     val *= sum2;
-    counter += 1;
-    if (counter % 5e4 === 0 || counter > 1e4 && counter % 500 === 0)
-      yield val;
+    yield val;
   }
   return val;
 }
@@ -12293,6 +12290,18 @@ var _expandForIs;
 function _setExpandForIs(fn) {
   _expandForIs = fn;
 }
+var _getPolynomialCoefficients;
+function _setGetPolynomialCoefficients(fn) {
+  _getPolynomialCoefficients = fn;
+}
+var _getPolynomialDegree;
+function _setGetPolynomialDegree(fn) {
+  _getPolynomialDegree = fn;
+}
+var _findUnivariateRoots;
+function _setFindUnivariateRoots(fn) {
+  _findUnivariateRoots = fn;
+}
 var EXPANDABLE_OPS = ["Multiply", "Power", "Negate", "Divide"];
 function _couldBenefitFromExpand(a, b) {
   if (a.has(EXPANDABLE_OPS)) return true;
@@ -12608,6 +12617,34 @@ var _BoxedExpression = class __BoxedExpression {
   factors() {
     return [this];
   }
+  polynomialCoefficients(variable) {
+    let vars;
+    if (variable === void 0) {
+      const unknowns = this.unknowns;
+      if (unknowns.length !== 1) return void 0;
+      vars = [unknowns[0]];
+    } else if (typeof variable === "string") {
+      vars = [variable];
+    } else {
+      if (variable.length === 0) return void 0;
+      vars = variable;
+    }
+    for (const v of vars) {
+      if (_getPolynomialDegree(this, v) < 0) return void 0;
+    }
+    const coeffs = _getPolynomialCoefficients(this, vars[0]);
+    if (coeffs === null) return void 0;
+    return coeffs.reverse();
+  }
+  polynomialRoots(variable) {
+    if (variable === void 0) {
+      const unknowns = this.unknowns;
+      if (unknowns.length !== 1) return void 0;
+      variable = unknowns[0];
+    }
+    if (_getPolynomialDegree(this, variable) < 0) return void 0;
+    return _findUnivariateRoots(this, variable);
+  }
   is(other, tolerance) {
     if (this.isSame(other)) return true;
     if (_expandForIs && _couldBenefitFromExpand(this, other)) {
@@ -16067,10 +16104,14 @@ function isSqrt(expr) {
   return expr.operator === "Sqrt" || expr.operator === "Power" && expr.op2.im === 0 && expr.op2.re === 0.5 || expr.operator === "Root" && expr.op2.im === 0 && expr.op2.re === 2;
 }
 function asRadical(expr) {
-  if (isSqrt(expr) && isFunction2(expr)) return asRational(expr.op1) ?? null;
+  if (isSqrt(expr) && isFunction2(expr)) {
+    const r = asRational(expr.op1);
+    if (r === void 0 || r[0] < 0 || r[1] < 0) return null;
+    return r;
+  }
   if (isFunction2(expr, "Divide") && expr.op1.isSame(1) && isSqrt(expr.op2)) {
     const n = expr.op2.re;
-    if (!Number.isInteger(n)) return null;
+    if (!Number.isInteger(n) || n <= 0) return null;
     return [1, n];
   }
   return null;
@@ -16670,13 +16711,14 @@ function gcd3(a, b) {
 function lcm3(a, b) {
   return a.mul(b).div(gcd3(a, b));
 }
-function factorial23(ce, n) {
+function* factorial23(ce, n) {
   if (!n.isInteger() || n.isNegative()) return ce._BIGNUM_NAN;
   if (n.lessThan(1)) return ce._BIGNUM_ONE;
   let result = n;
   while (n.greaterThan(2)) {
     n = n.minus(2);
     result = result.mul(n);
+    yield result;
   }
   return result;
 }
@@ -20193,24 +20235,30 @@ var COLLECTIONS_LIBRARY = {
       if (initial.type.matches("real") && collection.type.matches(ce.type("collection<real>"))) {
         const compiled = ce._compile(fn);
         if (compiled.calling !== "lambda" || !compiled.run) return void 0;
-        let accumulator2 = initial.re;
-        let first2 = true;
-        for (const item of collection.each()) {
-          if (first2) accumulator2 = item.re;
-          else accumulator2 = compiled.run(accumulator2, item.re);
-          first2 = false;
-        }
-        return ce.box(accumulator2);
+        return run(
+          (function* () {
+            let accumulator = initial.re;
+            let first = true;
+            for (const item of collection.each()) {
+              if (first) accumulator = item.re;
+              else accumulator = compiled.run(accumulator, item.re);
+              first = false;
+              yield;
+            }
+            return ce.box(accumulator);
+          })(),
+          ce._timeRemaining
+        );
       }
       const f = applicable(fn);
-      let accumulator = initial;
-      let first = true;
-      for (const item of collection.each()) {
-        if (first) accumulator = item;
-        else accumulator = f([accumulator, item]) ?? ce.Nothing;
-        first = false;
-      }
-      return accumulator;
+      return run(
+        reduceCollection(
+          collection,
+          (acc, x) => f([acc, x]) ?? ce.Nothing,
+          initial
+        ),
+        ce._timeRemaining
+      );
     }
   },
   Join: {
@@ -21435,12 +21483,10 @@ function tally(collection) {
 }
 function* reduceCollection(collection, fn, initial) {
   let acc = initial;
-  let counter = 0;
   for (const x of collection.each()) {
     const result = fn(acc, x);
     if (result === null) return void 0;
-    counter += 1;
-    if (counter % 1e3 === 0) yield acc;
+    yield acc;
     acc = result;
   }
   return acc;
@@ -22859,12 +22905,10 @@ function* reduceBigOp(body, indexes, fn, initial) {
   const indexingSets = normalizeIndexingSets(indexes);
   const cartesianArray = indexingSetCartesianProduct(indexingSets);
   let result = initial;
-  let counter = 0;
   for (const element of cartesianArray) {
     indexingSets.forEach((x, i) => ce.assign(x.index, element[i]));
     result = fn(result, body) ?? void 0;
-    counter += 1;
-    if (counter % 1e3 === 0) yield result;
+    yield result;
     if (result === void 0) break;
   }
   return result ?? void 0;
@@ -22931,7 +22975,6 @@ function* reduceElementIndexingSets(body, indexes, fn, initial, returnReason = f
     return initial;
   }
   let result = initial;
-  let counter = 0;
   while (true) {
     for (let i = 0; i < elementDomains.length; i++) {
       ce.assign(
@@ -22940,8 +22983,7 @@ function* reduceElementIndexingSets(body, indexes, fn, initial, returnReason = f
       );
     }
     result = fn(result, body) ?? void 0;
-    counter++;
-    if (counter % 1e3 === 0) yield result;
+    yield result;
     if (result === void 0) break;
     let dim = elementDomains.length - 1;
     while (dim >= 0) {
@@ -23911,7 +23953,8 @@ var ARITHMETIC_LIBRARY = [
               ce._timeRemaining
             )
           );
-        } catch {
+        } catch (e) {
+          if (e instanceof CancellationError) throw e;
           return void 0;
         }
       },
@@ -23930,7 +23973,8 @@ var ARITHMETIC_LIBRARY = [
               signal
             )
           );
-        } catch {
+        } catch (e) {
+          if (e instanceof CancellationError) throw e;
           return void 0;
         }
       }
@@ -23948,7 +23992,9 @@ var ARITHMETIC_LIBRARY = [
         if (n === null) return void 0;
         const ce = x.engine;
         if (bignumPreferred(ce))
-          return ce.number(factorial23(ce, ce.bignum(n)));
+          return ce.number(
+            run(factorial23(ce, ce.bignum(n)), ce._timeRemaining)
+          );
         return ce.number(factorial22(n));
       }
     },
@@ -26349,6 +26395,268 @@ function expandAll(expr) {
   return expand2(result);
 }
 
+// src/compute-engine/boxed-expression/polynomials.ts
+function polynomialDegree(expr, variable) {
+  if (isNumber(expr)) return 0;
+  if (isSymbol2(expr)) {
+    if (expr.symbol === variable) return 1;
+    return 0;
+  }
+  if (!isFunction2(expr)) {
+    if (expr.has(variable)) return -1;
+    return 0;
+  }
+  const op = expr.operator;
+  if (op === "Negate") return polynomialDegree(expr.op1, variable);
+  if (op === "Add" || op === "Subtract") {
+    let maxDeg = 0;
+    for (const arg of expr.ops) {
+      const deg = polynomialDegree(arg, variable);
+      if (deg < 0) return -1;
+      maxDeg = Math.max(maxDeg, deg);
+    }
+    return maxDeg;
+  }
+  if (op === "Multiply") {
+    let totalDeg = 0;
+    for (const arg of expr.ops) {
+      const deg = polynomialDegree(arg, variable);
+      if (deg < 0) return -1;
+      totalDeg += deg;
+    }
+    return totalDeg;
+  }
+  if (op === "Power") {
+    const baseDeg = polynomialDegree(expr.op1, variable);
+    if (baseDeg < 0) return -1;
+    if (baseDeg === 0) {
+      if (expr.op2.has(variable)) return -1;
+      return 0;
+    }
+    const exp3 = asSmallInteger(expr.op2);
+    if (exp3 === null || exp3 < 0) return -1;
+    return baseDeg * exp3;
+  }
+  if (expr.has(variable)) return -1;
+  return 0;
+}
+function getPolynomialCoefficients(expr, variable) {
+  const ce = expr.engine;
+  const degree = polynomialDegree(expr, variable);
+  if (degree < 0) return null;
+  const coeffs = new Array(degree + 1).fill(ce.Zero);
+  const expanded = expand2(expr);
+  const addCoefficient = (coef, deg) => {
+    if (deg > degree) return false;
+    coeffs[deg] = coeffs[deg].add(coef);
+    return true;
+  };
+  const processTerm = (term) => {
+    const termDeg = polynomialDegree(term, variable);
+    if (termDeg < 0) return false;
+    if (termDeg === 0) {
+      return addCoefficient(term, 0);
+    }
+    if (isSymbol2(term, variable)) {
+      return addCoefficient(ce.One, 1);
+    }
+    if (isFunction2(term, "Negate")) {
+      const innerDeg = polynomialDegree(term.op1, variable);
+      if (innerDeg === 0) {
+        return addCoefficient(term, 0);
+      }
+      const innerCoeffs = getPolynomialCoefficients(term.op1, variable);
+      if (!innerCoeffs) return false;
+      for (let i = 0; i < innerCoeffs.length; i++) {
+        if (!innerCoeffs[i].isSame(0)) {
+          addCoefficient(innerCoeffs[i].neg(), i);
+        }
+      }
+      return true;
+    }
+    if (isFunction2(term, "Power")) {
+      if (isSymbol2(term.op1, variable)) {
+        const exp3 = asSmallInteger(term.op2);
+        if (exp3 !== null && exp3 >= 0) {
+          return addCoefficient(ce.One, exp3);
+        }
+      }
+      if (!term.op1.has(variable)) {
+        return addCoefficient(term, 0);
+      }
+      return false;
+    }
+    if (isFunction2(term, "Multiply")) {
+      const factors = term.ops;
+      let coef = ce.One;
+      let varDeg = 0;
+      for (const factor3 of factors) {
+        if (!factor3.has(variable)) {
+          coef = coef.mul(factor3);
+        } else if (isSymbol2(factor3, variable)) {
+          varDeg += 1;
+        } else if (isFunction2(factor3, "Power") && isSymbol2(factor3.op1, variable)) {
+          const exp3 = asSmallInteger(factor3.op2);
+          if (exp3 !== null && exp3 >= 0) {
+            varDeg += exp3;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      }
+      return addCoefficient(coef, varDeg);
+    }
+    return false;
+  };
+  if (isFunction2(expanded, "Add")) {
+    for (const term of expanded.ops) {
+      if (!processTerm(term)) return null;
+    }
+  } else {
+    if (!processTerm(expanded)) return null;
+  }
+  return coeffs;
+}
+function fromCoefficients(coeffs, variable) {
+  if (coeffs.length === 0) return coeffs[0]?.engine.Zero ?? null;
+  const ce = coeffs[0].engine;
+  const x = ce.symbol(variable);
+  const terms = [];
+  for (let i = 0; i < coeffs.length; i++) {
+    const coef = coeffs[i];
+    if (coef.isSame(0)) continue;
+    if (i === 0) {
+      terms.push(coef);
+    } else if (i === 1) {
+      if (coef.isSame(1)) {
+        terms.push(x);
+      } else if (coef.isSame(-1)) {
+        terms.push(x.neg());
+      } else {
+        terms.push(coef.mul(x));
+      }
+    } else {
+      const xPow = ce.box(["Power", variable, i]);
+      if (coef.isSame(1)) {
+        terms.push(xPow);
+      } else if (coef.isSame(-1)) {
+        terms.push(xPow.neg());
+      } else {
+        terms.push(coef.mul(xPow));
+      }
+    }
+  }
+  if (terms.length === 0) return ce.Zero;
+  if (terms.length === 1) return terms[0];
+  return add3(...terms);
+}
+function polynomialDivide(dividend, divisor, variable) {
+  const ce = dividend.engine;
+  const dividendCoeffs = getPolynomialCoefficients(dividend, variable);
+  const divisorCoeffs = getPolynomialCoefficients(divisor, variable);
+  if (!dividendCoeffs || !divisorCoeffs) return null;
+  if (divisorCoeffs.every((c) => c.isSame(0))) return null;
+  const actualDegree = (coeffs) => {
+    for (let i = coeffs.length - 1; i >= 0; i--) {
+      if (!coeffs[i].isSame(0)) return i;
+    }
+    return -1;
+  };
+  const dividendDeg = actualDegree(dividendCoeffs);
+  const divisorDeg = actualDegree(divisorCoeffs);
+  if (divisorDeg < 0) return null;
+  if (dividendDeg < 0) {
+    return [ce.Zero, ce.Zero];
+  }
+  if (dividendDeg < divisorDeg) {
+    return [ce.Zero, dividend];
+  }
+  const remainder2 = dividendCoeffs.map((c) => c);
+  const quotientCoeffs = new Array(
+    dividendDeg - divisorDeg + 1
+  ).fill(ce.Zero);
+  const leadingDivisor = divisorCoeffs[divisorDeg];
+  for (let i = dividendDeg; i >= divisorDeg; i--) {
+    if (remainder2[i].isSame(0)) continue;
+    const quotientCoef = remainder2[i].div(leadingDivisor);
+    quotientCoeffs[i - divisorDeg] = quotientCoef;
+    for (let j = 0; j <= divisorDeg; j++) {
+      const product = quotientCoef.mul(divisorCoeffs[j]);
+      remainder2[i - divisorDeg + j] = remainder2[i - divisorDeg + j].sub(product);
+    }
+  }
+  const quotient = fromCoefficients(quotientCoeffs, variable);
+  const remainderPoly = fromCoefficients(remainder2, variable);
+  return [quotient, remainderPoly];
+}
+function polynomialGCD(a, b, variable) {
+  const ce = a.engine;
+  const degA = polynomialDegree(a, variable);
+  const degB = polynomialDegree(b, variable);
+  if (degA < 0 || degB < 0) return ce.One;
+  const aCoeffs = getPolynomialCoefficients(a, variable);
+  const bCoeffs = getPolynomialCoefficients(b, variable);
+  if (!aCoeffs || aCoeffs.every((c) => c.isSame(0))) {
+    return makeMonic(b, variable);
+  }
+  if (!bCoeffs || bCoeffs.every((c) => c.isSame(0))) {
+    return makeMonic(a, variable);
+  }
+  let p = a;
+  let q = b;
+  while (true) {
+    const qCoeffs = getPolynomialCoefficients(q, variable);
+    if (!qCoeffs || qCoeffs.every((c) => c.isSame(0))) {
+      break;
+    }
+    const divResult = polynomialDivide(p, q, variable);
+    if (!divResult) {
+      return ce.One;
+    }
+    const [, remainder2] = divResult;
+    p = q;
+    q = remainder2;
+  }
+  return makeMonic(p, variable);
+}
+function makeMonic(poly, variable) {
+  const coeffs = getPolynomialCoefficients(poly, variable);
+  if (!coeffs) return poly;
+  let leadingCoef = null;
+  for (let i = coeffs.length - 1; i >= 0; i--) {
+    if (!coeffs[i].isSame(0)) {
+      leadingCoef = coeffs[i];
+      break;
+    }
+  }
+  if (!leadingCoef || leadingCoef.isSame(1)) return poly;
+  const monicCoeffs = coeffs.map((c) => c.div(leadingCoef));
+  return fromCoefficients(monicCoeffs, variable);
+}
+function cancelCommonFactors(expr, variable) {
+  if (!isFunction2(expr, "Divide")) return expr;
+  const numerator = expr.op1;
+  const denominator = expr.op2;
+  const numDeg = polynomialDegree(numerator, variable);
+  const denDeg = polynomialDegree(denominator, variable);
+  if (numDeg < 0 || denDeg < 0) return expr;
+  const gcd7 = polynomialGCD(numerator, denominator, variable);
+  const gcdDeg = polynomialDegree(gcd7, variable);
+  if (gcdDeg <= 0) return expr;
+  const numDivResult = polynomialDivide(numerator, gcd7, variable);
+  const denDivResult = polynomialDivide(denominator, gcd7, variable);
+  if (!numDivResult || !denDivResult) return expr;
+  const [newNumerator] = numDivResult;
+  const [newDenominator] = denDivResult;
+  const denCoeffs = getPolynomialCoefficients(newDenominator, variable);
+  if (denCoeffs && denCoeffs.length === 1 && denCoeffs[0].isSame(1)) {
+    return newNumerator;
+  }
+  return newNumerator.div(newDenominator);
+}
+
 // src/compute-engine/boxed-expression/solve.ts
 function numericApproximation(value) {
   if (typeof value === "number") return value;
@@ -27172,6 +27480,13 @@ function findUnivariateRoots(expr, x) {
         )
       );
     }
+    if (result.length === 0) {
+      const deg = polynomialDegree(originalExpr, x);
+      if (deg >= 3) {
+        const rationalRoots = findRationalRoots(originalExpr, x, ce);
+        if (rationalRoots.length > 0) result = rationalRoots;
+      }
+    }
   } finally {
     ce.popScope();
   }
@@ -27310,267 +27625,49 @@ function filterRootsByType(ce, x, roots) {
     return true;
   });
 }
-
-// src/compute-engine/boxed-expression/polynomials.ts
-function polynomialDegree(expr, variable) {
-  if (isNumber(expr)) return 0;
-  if (isSymbol2(expr)) {
-    if (expr.symbol === variable) return 1;
-    return 0;
-  }
-  if (!isFunction2(expr)) {
-    if (expr.has(variable)) return -1;
-    return 0;
-  }
-  const op = expr.operator;
-  if (op === "Negate") return polynomialDegree(expr.op1, variable);
-  if (op === "Add" || op === "Subtract") {
-    let maxDeg = 0;
-    for (const arg of expr.ops) {
-      const deg = polynomialDegree(arg, variable);
-      if (deg < 0) return -1;
-      maxDeg = Math.max(maxDeg, deg);
-    }
-    return maxDeg;
-  }
-  if (op === "Multiply") {
-    let totalDeg = 0;
-    for (const arg of expr.ops) {
-      const deg = polynomialDegree(arg, variable);
-      if (deg < 0) return -1;
-      totalDeg += deg;
-    }
-    return totalDeg;
-  }
-  if (op === "Power") {
-    const baseDeg = polynomialDegree(expr.op1, variable);
-    if (baseDeg < 0) return -1;
-    if (baseDeg === 0) {
-      if (expr.op2.has(variable)) return -1;
-      return 0;
-    }
-    const exp3 = asSmallInteger(expr.op2);
-    if (exp3 === null || exp3 < 0) return -1;
-    return baseDeg * exp3;
-  }
-  if (expr.has(variable)) return -1;
-  return 0;
-}
-function getPolynomialCoefficients(expr, variable) {
-  const ce = expr.engine;
-  const degree = polynomialDegree(expr, variable);
-  if (degree < 0) return null;
-  const coeffs = new Array(degree + 1).fill(ce.Zero);
-  const expanded = expand2(expr);
-  const addCoefficient = (coef, deg) => {
-    if (deg > degree) return false;
-    coeffs[deg] = coeffs[deg].add(coef);
-    return true;
-  };
-  const processTerm = (term) => {
-    const termDeg = polynomialDegree(term, variable);
-    if (termDeg < 0) return false;
-    if (termDeg === 0) {
-      return addCoefficient(term, 0);
-    }
-    if (isSymbol2(term, variable)) {
-      return addCoefficient(ce.One, 1);
-    }
-    if (isFunction2(term, "Negate")) {
-      const innerDeg = polynomialDegree(term.op1, variable);
-      if (innerDeg === 0) {
-        return addCoefficient(term, 0);
-      }
-      const innerCoeffs = getPolynomialCoefficients(term.op1, variable);
-      if (!innerCoeffs) return false;
-      for (let i = 0; i < innerCoeffs.length; i++) {
-        if (!innerCoeffs[i].isSame(0)) {
-          addCoefficient(innerCoeffs[i].neg(), i);
-        }
-      }
-      return true;
-    }
-    if (isFunction2(term, "Power")) {
-      if (isSymbol2(term.op1, variable)) {
-        const exp3 = asSmallInteger(term.op2);
-        if (exp3 !== null && exp3 >= 0) {
-          return addCoefficient(ce.One, exp3);
-        }
-      }
-      if (!term.op1.has(variable)) {
-        return addCoefficient(term, 0);
-      }
-      return false;
-    }
-    if (isFunction2(term, "Multiply")) {
-      const factors = term.ops;
-      let coef = ce.One;
-      let varDeg = 0;
-      for (const factor3 of factors) {
-        if (!factor3.has(variable)) {
-          coef = coef.mul(factor3);
-        } else if (isSymbol2(factor3, variable)) {
-          varDeg += 1;
-        } else if (isFunction2(factor3, "Power") && isSymbol2(factor3.op1, variable)) {
-          const exp3 = asSmallInteger(factor3.op2);
-          if (exp3 !== null && exp3 >= 0) {
-            varDeg += exp3;
-          } else {
-            return false;
-          }
-        } else {
-          return false;
-        }
+function findRationalRoots(expr, variable, ce) {
+  const coeffs = getPolynomialCoefficients(expr, variable);
+  if (!coeffs) return [];
+  const degree = coeffs.length - 1;
+  if (degree < 1) return [];
+  const constantInt = asSmallInteger(coeffs[0]);
+  const leadingInt = asSmallInteger(coeffs[degree]);
+  if (leadingInt === null || constantInt === null) return [];
+  if (leadingInt === 0 || constantInt === 0) return [];
+  const divisors = (n) => {
+    n = Math.abs(n);
+    const result = [];
+    for (let i = 1; i * i <= n; i++) {
+      if (n % i === 0) {
+        result.push(i);
+        if (i !== n / i) result.push(n / i);
       }
-      return addCoefficient(coef, varDeg);
     }
-    return false;
+    return result;
   };
-  if (isFunction2(expanded, "Add")) {
-    for (const term of expanded.ops) {
-      if (!processTerm(term)) return null;
-    }
-  } else {
-    if (!processTerm(expanded)) return null;
-  }
-  return coeffs;
-}
-function fromCoefficients(coeffs, variable) {
-  if (coeffs.length === 0) return coeffs[0]?.engine.Zero ?? null;
-  const ce = coeffs[0].engine;
-  const x = ce.symbol(variable);
-  const terms = [];
-  for (let i = 0; i < coeffs.length; i++) {
-    const coef = coeffs[i];
-    if (coef.isSame(0)) continue;
-    if (i === 0) {
-      terms.push(coef);
-    } else if (i === 1) {
-      if (coef.isSame(1)) {
-        terms.push(x);
-      } else if (coef.isSame(-1)) {
-        terms.push(x.neg());
-      } else {
-        terms.push(coef.mul(x));
-      }
-    } else {
-      const xPow = ce.box(["Power", variable, i]);
-      if (coef.isSame(1)) {
-        terms.push(xPow);
-      } else if (coef.isSame(-1)) {
-        terms.push(xPow.neg());
-      } else {
-        terms.push(coef.mul(xPow));
+  const pDivisors = divisors(constantInt);
+  const qDivisors = divisors(leadingInt);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of pDivisors) {
+    for (const q of qDivisors) {
+      for (const sign3 of [1, -1]) {
+        const val = sign3 * p / q;
+        if (!seen.has(val)) {
+          seen.add(val);
+          candidates.push(val);
+        }
       }
     }
   }
-  if (terms.length === 0) return ce.Zero;
-  if (terms.length === 1) return terms[0];
-  return add3(...terms);
-}
-function polynomialDivide(dividend, divisor, variable) {
-  const ce = dividend.engine;
-  const dividendCoeffs = getPolynomialCoefficients(dividend, variable);
-  const divisorCoeffs = getPolynomialCoefficients(divisor, variable);
-  if (!dividendCoeffs || !divisorCoeffs) return null;
-  if (divisorCoeffs.every((c) => c.isSame(0))) return null;
-  const actualDegree = (coeffs) => {
-    for (let i = coeffs.length - 1; i >= 0; i--) {
-      if (!coeffs[i].isSame(0)) return i;
-    }
-    return -1;
-  };
-  const dividendDeg = actualDegree(dividendCoeffs);
-  const divisorDeg = actualDegree(divisorCoeffs);
-  if (divisorDeg < 0) return null;
-  if (dividendDeg < 0) {
-    return [ce.Zero, ce.Zero];
-  }
-  if (dividendDeg < divisorDeg) {
-    return [ce.Zero, dividend];
-  }
-  const remainder2 = dividendCoeffs.map((c) => c);
-  const quotientCoeffs = new Array(
-    dividendDeg - divisorDeg + 1
-  ).fill(ce.Zero);
-  const leadingDivisor = divisorCoeffs[divisorDeg];
-  for (let i = dividendDeg; i >= divisorDeg; i--) {
-    if (remainder2[i].isSame(0)) continue;
-    const quotientCoef = remainder2[i].div(leadingDivisor);
-    quotientCoeffs[i - divisorDeg] = quotientCoef;
-    for (let j = 0; j <= divisorDeg; j++) {
-      const product = quotientCoef.mul(divisorCoeffs[j]);
-      remainder2[i - divisorDeg + j] = remainder2[i - divisorDeg + j].sub(product);
-    }
+  if (candidates.length > 100) return [];
+  const roots = [];
+  for (const candidate of candidates) {
+    const root2 = ce.number(candidate);
+    const value = expr.subs({ [variable]: root2 }).N();
+    if (value.isSame(0)) roots.push(root2);
   }
-  const quotient = fromCoefficients(quotientCoeffs, variable);
-  const remainderPoly = fromCoefficients(remainder2, variable);
-  return [quotient, remainderPoly];
-}
-function polynomialGCD(a, b, variable) {
-  const ce = a.engine;
-  const degA = polynomialDegree(a, variable);
-  const degB = polynomialDegree(b, variable);
-  if (degA < 0 || degB < 0) return ce.One;
-  const aCoeffs = getPolynomialCoefficients(a, variable);
-  const bCoeffs = getPolynomialCoefficients(b, variable);
-  if (!aCoeffs || aCoeffs.every((c) => c.isSame(0))) {
-    return makeMonic(b, variable);
-  }
-  if (!bCoeffs || bCoeffs.every((c) => c.isSame(0))) {
-    return makeMonic(a, variable);
-  }
-  let p = a;
-  let q = b;
-  while (true) {
-    const qCoeffs = getPolynomialCoefficients(q, variable);
-    if (!qCoeffs || qCoeffs.every((c) => c.isSame(0))) {
-      break;
-    }
-    const divResult = polynomialDivide(p, q, variable);
-    if (!divResult) {
-      return ce.One;
-    }
-    const [, remainder2] = divResult;
-    p = q;
-    q = remainder2;
-  }
-  return makeMonic(p, variable);
-}
-function makeMonic(poly, variable) {
-  const coeffs = getPolynomialCoefficients(poly, variable);
-  if (!coeffs) return poly;
-  let leadingCoef = null;
-  for (let i = coeffs.length - 1; i >= 0; i--) {
-    if (!coeffs[i].isSame(0)) {
-      leadingCoef = coeffs[i];
-      break;
-    }
-  }
-  if (!leadingCoef || leadingCoef.isSame(1)) return poly;
-  const monicCoeffs = coeffs.map((c) => c.div(leadingCoef));
-  return fromCoefficients(monicCoeffs, variable);
-}
-function cancelCommonFactors(expr, variable) {
-  if (!isFunction2(expr, "Divide")) return expr;
-  const numerator = expr.op1;
-  const denominator = expr.op2;
-  const numDeg = polynomialDegree(numerator, variable);
-  const denDeg = polynomialDegree(denominator, variable);
-  if (numDeg < 0 || denDeg < 0) return expr;
-  const gcd6 = polynomialGCD(numerator, denominator, variable);
-  const gcdDeg = polynomialDegree(gcd6, variable);
-  if (gcdDeg <= 0) return expr;
-  const numDivResult = polynomialDivide(numerator, gcd6, variable);
-  const denDivResult = polynomialDivide(denominator, gcd6, variable);
-  if (!numDivResult || !denDivResult) return expr;
-  const [newNumerator] = numDivResult;
-  const [newDenominator] = denDivResult;
-  const denCoeffs = getPolynomialCoefficients(newDenominator, variable);
-  if (denCoeffs && denCoeffs.length === 1 && denCoeffs[0].isSame(1)) {
-    return newNumerator;
-  }
-  return newNumerator.div(newDenominator);
+  return roots;
 }
 
 // src/compute-engine/symbolic/antiderivative.ts
@@ -33539,7 +33636,7 @@ function* runLoop(body, collection, ce) {
       if (isFunction2(result, "Break")) return result.op1;
       if (result.operator === "Return") return result;
       i2 += 1;
-      if (i2 % 1e3 === 0) yield result;
+      yield result;
       if (i2 > ce.iterationLimit)
         throw new CancellationError({ cause: "iteration-limit-exceeded" });
     }
@@ -33551,7 +33648,7 @@ function* runLoop(body, collection, ce) {
     if (isFunction2(result, "Break")) return result.op1;
     if (result.operator === "Return") return result;
     i += 1;
-    if (i % 1e3 === 0) yield result;
+    yield result;
     if (i > ce.iterationLimit)
       throw new CancellationError({ cause: "iteration-limit-exceeded" });
   }
@@ -38214,7 +38311,107 @@ function factorQuadratic(expr, variable) {
     return ce.box(["Multiply", a.json, factor1.json, factor22.json]);
   }
 }
+function factorByRationalRoots(expr, variable) {
+  const ce = expr.engine;
+  const coeffs = getPolynomialCoefficients(expr, variable);
+  if (!coeffs) return null;
+  const degree = coeffs.length - 1;
+  if (degree < 2) return null;
+  const leadingInt = asSmallInteger(coeffs[degree]);
+  const constantInt = asSmallInteger(coeffs[0]);
+  if (leadingInt === null || constantInt === null) return null;
+  if (leadingInt === 0 || constantInt === 0) return null;
+  const divisors = (n) => {
+    n = Math.abs(n);
+    const result = [];
+    for (let i = 1; i * i <= n; i++) {
+      if (n % i === 0) {
+        result.push(i);
+        if (i !== n / i) result.push(n / i);
+      }
+    }
+    return result;
+  };
+  const pDivisors = divisors(constantInt);
+  const qDivisors = divisors(leadingInt);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of pDivisors) {
+    for (const q of qDivisors) {
+      const pos = p / q;
+      const neg2 = -p / q;
+      if (!seen.has(pos)) {
+        seen.add(pos);
+        candidates.push([p, q]);
+      }
+      if (!seen.has(neg2)) {
+        seen.add(neg2);
+        candidates.push([-p, q]);
+      }
+    }
+  }
+  if (candidates.length > 100) return null;
+  const x = ce.symbol(variable);
+  const factors = [];
+  let remaining = expr;
+  for (const [p, q] of candidates) {
+    const remDeg2 = polynomialDegree(remaining, variable);
+    if (remDeg2 <= 0) break;
+    const root2 = q === 1 ? ce.number(p) : ce.number(p).div(ce.number(q));
+    const value = remaining.subs({ [variable]: root2 }).N();
+    if (!value.isSame(0)) continue;
+    const linearFactor = q === 1 ? x.sub(ce.number(p)) : ce.number(q).mul(x).sub(ce.number(p));
+    const divResult = polynomialDivide(remaining, linearFactor, variable);
+    if (!divResult) continue;
+    factors.push(linearFactor);
+    remaining = divResult[0];
+  }
+  if (factors.length === 0) return null;
+  const remDeg = polynomialDegree(remaining, variable);
+  if (remDeg === 2) {
+    const quadFactored = factorQuadratic(remaining, variable);
+    if (quadFactored !== null) remaining = quadFactored;
+  }
+  factors.push(remaining);
+  if (factors.length === 1) return factors[0];
+  return ce.box(["Multiply", ...factors.map((f) => f.json)]);
+}
+function extractContent(expr, variable) {
+  const ce = expr.engine;
+  const coeffs = getPolynomialCoefficients(expr, variable);
+  if (!coeffs) return null;
+  const intCoeffs = [];
+  for (const c of coeffs) {
+    const n = asSmallInteger(c);
+    if (n === null) return null;
+    intCoeffs.push(n);
+  }
+  const gcd7 = (a, b) => {
+    a = Math.abs(a);
+    b = Math.abs(b);
+    while (b) {
+      [a, b] = [b, a % b];
+    }
+    return a;
+  };
+  let content = 0;
+  for (const c of intCoeffs) {
+    if (c !== 0) content = gcd7(content, c);
+  }
+  if (content <= 1) return null;
+  const primitiveCoeffs = coeffs.map((c) => {
+    const n = asSmallInteger(c);
+    return ce.number(n / content);
+  });
+  const primitive = fromCoefficients(primitiveCoeffs, variable);
+  const factoredPrimitive = factorPolynomial(primitive, variable);
+  return ce.number(content).mul(factoredPrimitive);
+}
 function factorPolynomial(expr, variable) {
+  if (variable !== void 0) {
+    const contentFactored = extractContent(expr, variable);
+    if (contentFactored !== null) return contentFactored;
+  }
   const perfectSquare = factorPerfectSquare(expr);
   if (perfectSquare !== null) return perfectSquare;
   const diffSquares = factorDifferenceOfSquares(expr);
@@ -38222,6 +38419,8 @@ function factorPolynomial(expr, variable) {
   if (variable !== void 0) {
     const quadratic = factorQuadratic(expr, variable);
     if (quadratic !== null) return quadratic;
+    const rationalRoot = factorByRationalRoots(expr, variable);
+    if (rationalRoot !== null) return rationalRoot;
   }
   return factor(expr);
 }
@@ -38267,6 +38466,257 @@ function factor(expr) {
   }
   return Product.from(together(expr)).asExpression();
 }
+function collectFactors(expr, variable) {
+  const rawFactors = [];
+  collectFactorsRaw(expr, variable, rawFactors);
+  const merged = [];
+  for (const f of rawFactors) {
+    let found = false;
+    for (const m of merged) {
+      if (m.factor.isSame(f.factor)) {
+        m.multiplicity += f.multiplicity;
+        found = true;
+        break;
+      }
+    }
+    if (!found) merged.push({ ...f });
+  }
+  return merged;
+}
+function collectFactorsRaw(expr, variable, result) {
+  if (isFunction2(expr, "Multiply")) {
+    for (const op of expr.ops) {
+      collectFactorsRaw(op, variable, result);
+    }
+    return;
+  }
+  if (isFunction2(expr, "Power")) {
+    const base = expr.op1;
+    const exp3 = asSmallInteger(expr.op2);
+    if (exp3 !== null && exp3 > 0 && base.has(variable)) {
+      const deg3 = polynomialDegree(base, variable);
+      result.push({ factor: base, multiplicity: exp3, degree: deg3 });
+      return;
+    }
+    if (!expr.has(variable)) return;
+    const deg2 = polynomialDegree(expr, variable);
+    result.push({ factor: expr, multiplicity: 1, degree: deg2 });
+    return;
+  }
+  if (!expr.has(variable)) return;
+  if (isNumber(expr)) return;
+  const deg = polynomialDegree(expr, variable);
+  result.push({ factor: expr, multiplicity: 1, degree: deg });
+}
+function solveLinearSystem(matrix, numVars) {
+  const rows = matrix.length;
+  const cols = numVars + 1;
+  const m = matrix.map((row) => [...row]);
+  const pivotRow = new Array(numVars).fill(-1);
+  let currentRow = 0;
+  for (let col = 0; col < numVars && currentRow < rows; col++) {
+    let maxVal = 0;
+    let maxRow = -1;
+    for (let row = currentRow; row < rows; row++) {
+      const absVal = Math.abs(m[row][col]);
+      if (absVal > maxVal) {
+        maxVal = absVal;
+        maxRow = row;
+      }
+    }
+    if (maxVal === 0) continue;
+    if (maxRow !== currentRow) {
+      [m[currentRow], m[maxRow]] = [m[maxRow], m[currentRow]];
+    }
+    pivotRow[col] = currentRow;
+    for (let row = 0; row < rows; row++) {
+      if (row === currentRow) continue;
+      if (m[row][col] === 0) continue;
+      const factor3 = m[row][col];
+      const pivotVal = m[currentRow][col];
+      for (let j = 0; j < cols; j++) {
+        m[row][j] = m[row][j] * pivotVal - factor3 * m[currentRow][j];
+      }
+    }
+    currentRow++;
+  }
+  const solution = new Array(numVars);
+  for (let col = 0; col < numVars; col++) {
+    const pr = pivotRow[col];
+    if (pr === -1) {
+      solution[col] = [0, 1];
+      continue;
+    }
+    const num = m[pr][cols - 1];
+    const den = m[pr][col];
+    if (den === 0) return null;
+    const g = gcd4(Math.abs(num), Math.abs(den));
+    const sign3 = den < 0 ? -1 : 1;
+    solution[col] = [sign3 * num / g, sign3 * den / g];
+  }
+  return solution;
+}
+function gcd4(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b) {
+    [a, b] = [b, a % b];
+  }
+  return a || 1;
+}
+function partialFraction(expr, variable) {
+  const ce = expr.engine;
+  if (!isFunction2(expr, "Divide")) return expr;
+  const numer = expr.op1;
+  const denom = expr.op2;
+  const numerDeg = polynomialDegree(numer, variable);
+  const denomDeg = polynomialDegree(denom, variable);
+  if (numerDeg < 0 || denomDeg < 0) return expr;
+  if (denomDeg === 0) return expr;
+  let quotient = null;
+  let remainder2;
+  if (numerDeg >= denomDeg) {
+    const divResult = polynomialDivide(numer, denom, variable);
+    if (!divResult) return expr;
+    quotient = divResult[0];
+    remainder2 = divResult[1];
+    const remCoeffs2 = getPolynomialCoefficients(remainder2, variable);
+    if (remCoeffs2 && remCoeffs2.every((c) => c.isSame(0))) {
+      return quotient;
+    }
+  } else {
+    remainder2 = numer;
+  }
+  const factoredDenom = factorPolynomial(denom, variable);
+  const factors = collectFactors(factoredDenom, variable);
+  if (factors.length === 0) return expr;
+  if (factors.length === 1 && factors[0].multiplicity === 1) {
+    if (quotient) return quotient.add(remainder2.div(denom));
+    return expr;
+  }
+  for (const f of factors) {
+    if (f.degree > 2 || f.degree < 0) return expr;
+  }
+  let totalFactorDeg = 0;
+  for (const f of factors) {
+    totalFactorDeg += f.degree * f.multiplicity;
+  }
+  if (totalFactorDeg !== denomDeg) return expr;
+  const templateTerms = [];
+  let unknownCount = 0;
+  for (const f of factors) {
+    for (let k = 1; k <= f.multiplicity; k++) {
+      if (f.degree === 1) {
+        templateTerms.push({
+          isLinear: true,
+          factor: f.factor,
+          power: k,
+          unknownIndex: unknownCount
+        });
+        unknownCount++;
+      } else {
+        templateTerms.push({
+          isLinear: false,
+          factor: f.factor,
+          power: k,
+          unknownIndex: unknownCount
+        });
+        unknownCount += 2;
+      }
+    }
+  }
+  if (unknownCount !== denomDeg) return expr;
+  const expandedDenom = expand2(denom);
+  const denomCoeffs = getPolynomialCoefficients(expandedDenom, variable);
+  if (!denomCoeffs) return expr;
+  const expandedRemainder = expand2(remainder2);
+  const remCoeffs = getPolynomialCoefficients(expandedRemainder, variable);
+  if (!remCoeffs) return expr;
+  const systemRows = denomDeg;
+  const augMatrix = [];
+  for (let i = 0; i < systemRows; i++) {
+    augMatrix.push(new Array(unknownCount + 1).fill(0));
+  }
+  for (let i = 0; i < systemRows; i++) {
+    const coeff = i < remCoeffs.length ? asSmallInteger(remCoeffs[i]) : 0;
+    if (coeff === null) return expr;
+    augMatrix[i][unknownCount] = coeff;
+  }
+  for (const t of templateTerms) {
+    let termDenom;
+    if (t.power === 1) {
+      termDenom = t.factor;
+    } else {
+      termDenom = ce.box(["Power", t.factor.json, t.power]);
+    }
+    const cofactorResult = polynomialDivide(expandedDenom, termDenom, variable);
+    if (!cofactorResult) return expr;
+    const cofactor = cofactorResult[0];
+    const cofRem = cofactorResult[1];
+    const cofRemCoeffs = getPolynomialCoefficients(cofRem, variable);
+    if (!cofRemCoeffs || !cofRemCoeffs.every((c) => c.isSame(0))) return expr;
+    const expandedCofactor = expand2(cofactor);
+    const cofCoeffs = getPolynomialCoefficients(expandedCofactor, variable);
+    if (!cofCoeffs) return expr;
+    const intCofCoeffs = [];
+    for (let i = 0; i < systemRows; i++) {
+      const c = i < cofCoeffs.length ? asSmallInteger(cofCoeffs[i]) : 0;
+      if (c === null) return expr;
+      intCofCoeffs.push(c);
+    }
+    if (t.isLinear) {
+      for (let i = 0; i < systemRows; i++) {
+        augMatrix[i][t.unknownIndex] += intCofCoeffs[i];
+      }
+    } else {
+      const aIdx = t.unknownIndex;
+      const bIdx = t.unknownIndex + 1;
+      for (let i = 0; i < systemRows; i++) {
+        augMatrix[i][bIdx] += intCofCoeffs[i];
+        if (i > 0) {
+          augMatrix[i][aIdx] += intCofCoeffs[i - 1];
+        }
+      }
+    }
+  }
+  const solution = solveLinearSystem(augMatrix, unknownCount);
+  if (!solution) return expr;
+  const x = ce.symbol(variable);
+  const partialTerms = [];
+  if (quotient) partialTerms.push(quotient);
+  for (const t of templateTerms) {
+    let termDenom;
+    if (t.power === 1) {
+      termDenom = t.factor;
+    } else {
+      termDenom = ce.box(["Power", t.factor.json, t.power]);
+    }
+    let termNumer;
+    if (t.isLinear) {
+      const [num, den] = solution[t.unknownIndex];
+      if (num === 0) continue;
+      termNumer = den === 1 ? ce.number(num) : ce.number(num).div(ce.number(den));
+    } else {
+      const [aNum, aDen] = solution[t.unknownIndex];
+      const [bNum, bDen] = solution[t.unknownIndex + 1];
+      if (aNum === 0 && bNum === 0) continue;
+      const terms = [];
+      if (aNum !== 0) {
+        const aCoeff = aDen === 1 ? ce.number(aNum) : ce.number(aNum).div(ce.number(aDen));
+        terms.push(aCoeff.mul(x));
+      }
+      if (bNum !== 0) {
+        const bCoeff = bDen === 1 ? ce.number(bNum) : ce.number(bNum).div(ce.number(bDen));
+        terms.push(bCoeff);
+      }
+      termNumer = terms.length === 1 ? terms[0] : add3(...terms);
+    }
+    partialTerms.push(termNumer.div(termDenom));
+  }
+  if (partialTerms.length === 0) return ce.Zero;
+  if (partialTerms.length === 1) return partialTerms[0];
+  return add3(...partialTerms);
+}
 
 // src/compute-engine/symbolic/distribute.ts
 function distribute2(lhs, rhs, g, f) {
@@ -38341,7 +38791,7 @@ var POLYNOMIALS_LIBRARY = [
       }
     },
     CoefficientList: {
-      description: "Return the list of coefficients of a polynomial, from lowest to highest degree. Example: CoefficientList(x\xB3 + 2x + 1, x) \u2192 [1, 2, 0, 1]",
+      description: "Return the list of coefficients of a polynomial, from highest to lowest degree. Example: CoefficientList(x\xB3 + 2x + 1, x) \u2192 [1, 0, 2, 1]",
       lazy: true,
       signature: "(value, symbol) -> list<value>",
       evaluate: ([poly, varExpr]) => {
@@ -38350,7 +38800,7 @@ var POLYNOMIALS_LIBRARY = [
         if (!variable) return void 0;
         const coeffs = getPolynomialCoefficients(poly.canonical, variable);
         if (!coeffs) return void 0;
-        return poly.engine.box(["List", ...coeffs]);
+        return poly.engine.box(["List", ...coeffs.reverse()]);
       }
     },
     PolynomialQuotient: {
@@ -38406,6 +38856,85 @@ var POLYNOMIALS_LIBRARY = [
         if (!variable) return void 0;
         return cancelCommonFactors(expr.canonical, variable);
       }
+    },
+    PartialFraction: {
+      description: "Decompose a rational expression into partial fractions. Example: PartialFraction(1/((x+1)(x+2)), x) \u2192 1/(x+1) - 1/(x+2)",
+      lazy: true,
+      signature: "(value, symbol) -> value",
+      evaluate: ([expr, varExpr]) => {
+        if (!expr || !varExpr) return void 0;
+        const variable = sym(varExpr.canonical);
+        if (!variable) return void 0;
+        return partialFraction(expr.canonical, variable);
+      }
+    },
+    Apart: {
+      description: "Alias for PartialFraction. Decompose a rational expression into partial fractions.",
+      lazy: true,
+      signature: "(value, symbol) -> value",
+      evaluate: ([expr, varExpr]) => {
+        if (!expr || !varExpr) return void 0;
+        const variable = sym(varExpr.canonical);
+        if (!variable) return void 0;
+        return partialFraction(expr.canonical, variable);
+      }
+    },
+    PolynomialRoots: {
+      description: "Return the roots of a polynomial expression. Example: PolynomialRoots(x\xB2 - 5x + 6, x) \u2192 {2, 3}",
+      lazy: true,
+      signature: "(value, symbol) -> set<value>",
+      evaluate: ([poly, varExpr]) => {
+        if (!poly || !varExpr) return void 0;
+        const variable = sym(varExpr.canonical);
+        if (!variable) return void 0;
+        const roots = poly.canonical.polynomialRoots(variable);
+        if (!roots || roots.length === 0) return void 0;
+        return poly.engine.box(["Set", ...roots.map((r) => r.json)]);
+      }
+    },
+    Discriminant: {
+      description: "Return the discriminant of a polynomial. Example: Discriminant(x\xB2 - 5x + 6, x) \u2192 1",
+      lazy: true,
+      signature: "(value, symbol) -> value",
+      evaluate: ([poly, varExpr]) => {
+        if (!poly || !varExpr) return void 0;
+        const variable = sym(varExpr.canonical);
+        if (!variable) return void 0;
+        const coeffsAsc = getPolynomialCoefficients(poly.canonical, variable);
+        if (!coeffsAsc) return void 0;
+        const coeffs = [...coeffsAsc].reverse();
+        const degree = coeffs.length - 1;
+        const ce = poly.engine;
+        if (degree === 2) {
+          const [a, b, c] = coeffs;
+          return b.mul(b).sub(ce.number(4).mul(a).mul(c));
+        }
+        if (degree === 3) {
+          const [a, b, c, d] = coeffs;
+          return b.mul(b).mul(c).mul(c).sub(ce.number(4).mul(a).mul(c).mul(c).mul(c)).sub(ce.number(4).mul(b).mul(b).mul(b).mul(d)).add(ce.number(18).mul(a).mul(b).mul(c).mul(d)).sub(ce.number(27).mul(a).mul(a).mul(d).mul(d));
+        }
+        if (degree === 4) {
+          const [a, b, c, d, e] = coeffs;
+          return ce.number(256).mul(a).mul(a).mul(a).mul(e).mul(e).mul(e).sub(ce.number(192).mul(a).mul(a).mul(b).mul(d).mul(e).mul(e)).sub(ce.number(128).mul(a).mul(a).mul(c).mul(c).mul(e).mul(e)).add(ce.number(144).mul(a).mul(a).mul(c).mul(d).mul(d).mul(e)).sub(ce.number(27).mul(a).mul(a).mul(d).mul(d).mul(d).mul(d)).add(ce.number(144).mul(a).mul(b).mul(b).mul(c).mul(e).mul(e)).sub(ce.number(6).mul(a).mul(b).mul(b).mul(d).mul(d).mul(e)).sub(ce.number(80).mul(a).mul(b).mul(c).mul(c).mul(d).mul(e)).add(ce.number(18).mul(a).mul(b).mul(c).mul(d).mul(d).mul(d)).add(ce.number(16).mul(a).mul(c).mul(c).mul(c).mul(c).mul(e)).sub(ce.number(4).mul(a).mul(c).mul(c).mul(c).mul(d).mul(d)).sub(ce.number(27).mul(b).mul(b).mul(b).mul(b).mul(e).mul(e)).add(ce.number(18).mul(b).mul(b).mul(b).mul(c).mul(d).mul(e)).sub(ce.number(4).mul(b).mul(b).mul(b).mul(d).mul(d).mul(d)).sub(ce.number(4).mul(b).mul(b).mul(c).mul(c).mul(c).mul(e)).add(b.mul(b).mul(c).mul(c).mul(d).mul(d));
+        }
+        return void 0;
+      }
+    },
+    Polynomial: {
+      description: "Construct a polynomial from a list of coefficients (highest to lowest degree) and a variable. Example: Polynomial([1, 0, 2, 1], x) \u2192 x\xB3 + 2x + 1",
+      lazy: true,
+      signature: "(list<value>, symbol) -> value",
+      evaluate: ([coeffList, varExpr]) => {
+        if (!coeffList || !varExpr) return void 0;
+        const variable = sym(varExpr.canonical);
+        if (!variable) return void 0;
+        const canonical2 = coeffList.canonical;
+        if (!isFunction2(canonical2, "List")) return void 0;
+        const coeffs = canonical2.ops;
+        if (coeffs.length === 0) return void 0;
+        const ascending = [...coeffs].reverse();
+        return fromCoefficients(ascending, variable);
+      }
     }
   }
 ];
@@ -46404,7 +46933,7 @@ function isLinearInVariables(expr, variables) {
   };
   return checkTerm(expr);
 }
-function solveLinearSystem(equations, variables) {
+function solveLinearSystem2(equations, variables) {
   if (equations.length === 0 || variables.length === 0) return null;
   const ce = equations[0].engine;
   const n = variables.length;
@@ -47389,6 +47918,15 @@ function matchOnce(expr, pattern, substitution, options) {
     } else if (operator2 === expr.operator) {
       const matchPerms = options.matchPermutations ?? true;
       result = pattern.operatorDefinition.commutative && matchPerms ? matchPermutation(expr, pattern, substitution, options) : matchArguments(expr, pattern.ops, substitution, options);
+      if (result === null && options.matchMissingTerms && isFunction2(expr) && isFunction2(pattern) && expr.nops < pattern.nops) {
+        result = matchWithMissingTerms(
+          expr,
+          pattern,
+          substitution,
+          options,
+          ce
+        );
+      }
     }
     if (result === null && useVariations) {
       if (!acceptVariants) return null;
@@ -47686,8 +48224,8 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
       const minCapture = 1;
       const maxCapture2 = remaining.length - countMinNeeded(restWildcards);
       for (let count = maxCapture2; count >= minCapture; count--) {
-        const combinations = getCombinations(remaining.length, count);
-        for (const indices of combinations) {
+        const combinations2 = getCombinations(remaining.length, count);
+        for (const indices of combinations2) {
           const captured = indices.map((i) => remaining[i]);
           const capturedExpr = wrapCaptured(captured);
           const newSub = captureWildcard(wcName, capturedExpr, sub3);
@@ -47716,8 +48254,8 @@ function matchCommutativeWithAnchors(expr, pattern, substitution, options) {
           if (result !== null) return result;
         }
       } else {
-        const combinations = getCombinations(remaining.length, count);
-        for (const indices of combinations) {
+        const combinations2 = getCombinations(remaining.length, count);
+        for (const indices of combinations2) {
           const captured = indices.map((i) => remaining[i]);
           const capturedExpr = wrapCaptured(captured);
           const newSub = captureWildcard(wcName, capturedExpr, sub3);
@@ -47891,17 +48429,140 @@ function matchArguments(expr, patterns, substitution, options) {
     }
   }
 }
+function matchWithMissingTerms(expr, pattern, substitution, options, ce) {
+  if (!isFunction2(expr) || !isFunction2(pattern)) return null;
+  const operator2 = expr.operator;
+  const identity = operator2 === "Add" ? ce.Zero : operator2 === "Multiply" ? ce.One : null;
+  if (!identity) return null;
+  const patOps = pattern.ops;
+  const missing = patOps.length - expr.nops;
+  if (missing <= 0) return null;
+  const combos = combinations(patOps.length, missing);
+  combos.sort((a, b) => {
+    const scoreA = a.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
+    const scoreB = b.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
+    return scoreA - scoreB;
+  });
+  for (const identityIndices of combos) {
+    const activePatOps = patOps.filter((_, i) => !identityIndices.includes(i));
+    const identityPatOps = identityIndices.map((i) => patOps[i]);
+    const subPattern = ce.function(operator2, activePatOps, { form: "raw" });
+    let sub3 = matchPermutation(expr, subPattern, substitution, options);
+    if (sub3 === null) continue;
+    let failed = false;
+    for (const patOp of identityPatOps) {
+      const result = matchIdentityTerm(patOp, identity, sub3, options, ce);
+      if (result === null) {
+        failed = true;
+        break;
+      }
+      sub3 = result;
+    }
+    if (!failed) return sub3;
+  }
+  return null;
+}
+function matchIdentityTerm(patOp, identity, sub3, options, ce) {
+  const result = matchOnce(identity, patOp, sub3, options);
+  if (result !== null) return result;
+  if (identity.isSame(0) && isFunction2(patOp, "Multiply")) {
+    for (const op of patOp.ops) {
+      const wn = wildcardName(op);
+      if (wn && !(wn in sub3)) {
+        return captureWildcard(wn, identity, sub3);
+      }
+    }
+  }
+  if (identity.isSame(1) && isFunction2(patOp, "Power")) {
+    const expOp = patOp.ops[1];
+    if (expOp) {
+      const wn = wildcardName(expOp);
+      if (wn && !(wn in sub3)) {
+        return captureWildcard(wn, ce.Zero, sub3);
+      }
+    }
+  }
+  return null;
+}
+function patternComplexity(expr) {
+  if (isWildcard(expr)) return 0;
+  if (isNumber(expr) || isSymbol2(expr) || isString(expr)) return 1;
+  if (isFunction2(expr))
+    return 1 + expr.ops.reduce((s, op) => s + patternComplexity(op), 0);
+  return 1;
+}
+function combinations(n, k) {
+  const result = [];
+  const combo = [];
+  function backtrack(start) {
+    if (combo.length === k) {
+      result.push([...combo]);
+      return;
+    }
+    for (let i = start; i < n; i++) {
+      combo.push(i);
+      backtrack(i + 1);
+      combo.pop();
+    }
+  }
+  backtrack(0);
+  return result;
+}
 function match(subject, pattern, options) {
-  pattern = pattern.structural;
-  const useVariations = options?.useVariations ?? false;
+  const ce = subject.engine;
+  let autoWildcard = false;
+  let boxedPattern;
+  if (typeof pattern === "string") {
+    autoWildcard = true;
+    boxedPattern = ce.parse(pattern).map(
+      (x) => isSymbol2(x) && x.symbol.length === 1 ? ce.symbol("_" + x.symbol) : x,
+      { canonical: false }
+    );
+  } else if ("engine" in pattern) {
+    boxedPattern = pattern;
+  } else {
+    boxedPattern = ce.box(pattern);
+  }
+  boxedPattern = boxedPattern.structural;
+  const useVariations = options?.useVariations ?? autoWildcard;
   const opts = {
     recursive: options?.recursive ?? false,
     useVariations,
     acceptVariants: useVariations,
-    matchPermutations: options?.matchPermutations ?? true
+    matchPermutations: options?.matchPermutations ?? true,
+    matchMissingTerms: options?.matchMissingTerms ?? autoWildcard
   };
-  const substitution = options?.substitution ?? {};
-  return matchOnce(subject.structural, pattern.structural, substitution, opts);
+  let substitution = options?.substitution ?? {};
+  if (autoWildcard && Object.keys(substitution).length > 0) {
+    const prefixed = {};
+    for (const [k, v] of Object.entries(substitution)) {
+      if (k.startsWith("_")) {
+        prefixed[k] = v;
+      } else {
+        if (!(`_${k}` in substitution)) prefixed[`_${k}`] = v;
+        prefixed[k] = v;
+      }
+    }
+    substitution = prefixed;
+  }
+  const result = matchOnce(
+    subject.structural,
+    boxedPattern.structural,
+    substitution,
+    opts
+  );
+  if (!result) return null;
+  if (autoWildcard) {
+    const clean = {};
+    for (const [k, v] of Object.entries(result)) {
+      if (!k.startsWith("_")) continue;
+      const name = k.slice(1);
+      if (isSymbol2(v) && v.symbol === name) continue;
+      clean[name] = v;
+    }
+    return clean;
+  }
+  return result;
 }
 
 // src/compute-engine/boxed-expression/sgn.ts
@@ -48757,7 +49418,7 @@ var BoxedFunction = class extends _BoxedExpression {
 };
 function solveSystem(ce, equations, varNames) {
   if (equations && equations.every((eq2) => eq2.operator === "Equal")) {
-    const linearResult = solveLinearSystem([...equations], varNames);
+    const linearResult = solveLinearSystem2([...equations], varNames);
     if (linearResult && filterSolutionByTypes(ce, varNames, linearResult))
       return linearResult;
     const polyResult = solvePolynomialSystem([...equations], varNames);
@@ -48787,7 +49448,7 @@ function solveSystem(ce, equations, varNames) {
       (eq2) => inequalityOps.includes(eq2.operator ?? "")
     );
     if (equalities.length > 0 && inequalities.length > 0 && equalities.length + inequalities.length === equations.length) {
-      const linearResult = solveLinearSystem([...equalities], varNames);
+      const linearResult = solveLinearSystem2([...equalities], varNames);
       if (linearResult) {
         if (satisfiesInequalities(linearResult, inequalities))
           return filterSolutionByTypes(ce, varNames, linearResult) ? linearResult : null;
@@ -48911,9 +49572,11 @@ function withDeadline(engine, fn) {
   return () => {
     if (engine._deadline === void 0) {
       engine._deadline = Date.now() + engine.timeLimit;
-      const result = fn();
-      engine._deadline = void 0;
-      return result;
+      try {
+        return fn();
+      } finally {
+        engine._deadline = void 0;
+      }
     }
     return fn();
   };
@@ -48922,9 +49585,11 @@ function withDeadlineAsync(engine, fn) {
   return async () => {
     if (engine._deadline === void 0) {
       engine._deadline = Date.now() + engine.timeLimit;
-      const result = await fn();
-      engine._deadline = void 0;
-      return result;
+      try {
+        return await fn();
+      } finally {
+        engine._deadline = void 0;
+      }
     }
     return fn();
   };
@@ -50422,6 +51087,9 @@ var BaseCompiler = class _BaseCompiler {
       }
     }
     if (h === "Function") {
+      const fnFn = target.functions?.(h);
+      if (typeof fnFn === "function")
+        return fnFn(args, (expr) => _BaseCompiler.compile(expr, target), target);
       const params = args.slice(1).map((x) => isSymbol2(x) ? x.symbol : "_");
       return `((${params.join(", ")}) => ${_BaseCompiler.compile(
         args[0].canonical,
@@ -50431,15 +51099,26 @@ var BaseCompiler = class _BaseCompiler {
         }
       )})`;
     }
-    if (h === "Declare")
-      return `let ${isSymbol2(args[0]) ? args[0].symbol : "_"}`;
+    if (h === "Declare") {
+      const name = isSymbol2(args[0]) ? args[0].symbol : "_";
+      return target.declare ? target.declare(name) : `let ${name}`;
+    }
     if (h === "Assign")
       return `${isSymbol2(args[0]) ? args[0].symbol : "_"} = ${_BaseCompiler.compile(args[1], target)}`;
     if (h === "Return")
       return `return ${_BaseCompiler.compile(args[0], target)}`;
     if (h === "Break") return "break";
     if (h === "Continue") return "continue";
-    if (h === "Loop") return _BaseCompiler.compileForLoop(args, target);
+    if (h === "Loop") {
+      const loopFn = target.functions?.(h);
+      if (typeof loopFn === "function")
+        return loopFn(
+          args,
+          (expr) => _BaseCompiler.compile(expr, target),
+          target
+        );
+      return _BaseCompiler.compileForLoop(args, target);
+    }
     if (h === "If") {
       if (args.length !== 3) throw new Error("If: wrong number of arguments");
       const fn2 = target.functions?.(h);
@@ -50516,16 +51195,38 @@ var BaseCompiler = class _BaseCompiler {
     if (args.length === 1 && locals.length === 0) {
       return _BaseCompiler.compile(args[0], target);
     }
-    const result = args.filter((a) => !isSymbol2(a, "Nothing")).map(
-      (arg) => _BaseCompiler.compile(arg, {
-        ...target,
-        var: (id) => {
-          if (locals.includes(id)) return id;
-          return target.var(id);
+    const typeHints = {};
+    if (target.declare && target.language) {
+      const isWGSL = target.language === "wgsl";
+      for (const local of locals) {
+        for (const arg of args) {
+          if (isFunction2(arg, "Assign") && isSymbol2(arg.ops[0], local)) {
+            if (_BaseCompiler.isComplexValued(arg.ops[1])) {
+              typeHints[local] = isWGSL ? "vec2f" : "vec2";
+            }
+            break;
+          }
         }
-      })
-    ).filter((s) => s !== "");
+      }
+    }
+    const localTarget = {
+      ...target,
+      var: (id) => {
+        if (locals.includes(id)) return id;
+        return target.var(id);
+      }
+    };
+    const result = args.filter((a) => !isSymbol2(a, "Nothing")).map((arg) => {
+      if (isFunction2(arg, "Declare") && isSymbol2(arg.ops[0]) && target.declare) {
+        return target.declare(
+          arg.ops[0].symbol,
+          typeHints[arg.ops[0].symbol]
+        );
+      }
+      return _BaseCompiler.compile(arg, localTarget);
+    }).filter((s) => s !== "");
     if (result.length === 0) return "";
+    if (target.block) return target.block(result);
     result[result.length - 1] = `return ${result[result.length - 1]}`;
     return `(() => {${target.ws("\n")}${result.join(
       `;${target.ws("\n")}`
@@ -51011,6 +51712,9 @@ _setExpandForIs(expand2);
 _setSerializeJson(serializeJson);
 _setProduct(Product);
 _setCompile(compile);
+_setGetPolynomialCoefficients(getPolynomialCoefficients);
+_setGetPolynomialDegree(polynomialDegree);
+_setFindUnivariateRoots(findUnivariateRoots);
 
 // src/compute-engine/symbolic/simplify-logic.ts
 function simplifyLogicFunction(x) {
@@ -53949,6 +54653,27 @@ var SIMPLIFY_RULES = [
     if (result.isSame(x)) return void 0;
     return { value: result, because: "cancel common polynomial factors" };
   },
+  //
+  // Auto partial fraction decomposition for Divide with factored denominator
+  // e.g., 1/((x+1)(x+2)) → 1/(x+1) - 1/(x+2)
+  // Only triggers when denominator is already in factored form (Multiply or Power)
+  //
+  // IMPORTANT: partialFraction must not call .simplify() on its result
+  //
+  (x) => {
+    if (!isFunction2(x, "Divide")) return void 0;
+    const denom = x.op2;
+    const denomOp = denom.operator;
+    if (denomOp !== "Multiply" && denomOp !== "Power") return void 0;
+    const unknowns = x.unknowns;
+    if (unknowns.length !== 1) return void 0;
+    const variable = unknowns[0];
+    const result = partialFraction(x, variable);
+    if (result.isSame(x)) return void 0;
+    const ce = x.engine;
+    if (ce.costFunction(result) >= ce.costFunction(x)) return void 0;
+    return { value: result, because: "partial fraction decomposition" };
+  },
   // Quick a/a -> 1 check for identical numerator/denominator
   // Must run before expand to avoid decomposing the fraction first
   (x) => {
@@ -57291,6 +58016,62 @@ var GPU_OPERATORS = {
 function gpuVec2(target) {
   return target?.language === "wgsl" ? "vec2f" : "vec2";
 }
+var GPU_UNROLL_LIMIT = 100;
+function compileGPUSumProduct(kind, args, _compile2, target) {
+  if (!args[0]) throw new Error(`${kind}: no body`);
+  if (!args[1]) throw new Error(`${kind}: no indexing set`);
+  if (BaseCompiler.isComplexValued(args[0]))
+    throw new Error(
+      `${kind}: complex-valued body not supported in GPU targets`
+    );
+  const limitsExpr = args[1];
+  if (!isFunction2(limitsExpr, "Limits"))
+    throw new Error(`${kind}: expected Limits indexing set`);
+  const limitsOps = limitsExpr.ops;
+  const index = isSymbol2(limitsOps[0]) ? limitsOps[0].symbol : "_";
+  const lowerRe = limitsOps[1].re;
+  const upperRe = limitsOps[2].re;
+  const lowerNum = !isNaN(lowerRe) && Number.isFinite(lowerRe) ? Math.floor(lowerRe) : void 0;
+  const upperNum = !isNaN(upperRe) && Number.isFinite(upperRe) ? Math.floor(upperRe) : void 0;
+  const isSum = kind === "Sum";
+  const op = isSum ? "+" : "*";
+  const identity = isSum ? "0.0" : "1.0";
+  const isWGSL = target.language === "wgsl";
+  const bothConstant = lowerNum !== void 0 && upperNum !== void 0;
+  if (bothConstant && lowerNum > upperNum) return identity;
+  if (bothConstant && upperNum - lowerNum + 1 <= GPU_UNROLL_LIMIT) {
+    const terms = [];
+    for (let k = lowerNum; k <= upperNum; k++) {
+      const kStr = formatGPUNumber(k);
+      const innerTarget = {
+        ...target,
+        var: (id) => id === index ? kStr : target.var(id)
+      };
+      terms.push(`(${BaseCompiler.compile(args[0], innerTarget)})`);
+    }
+    return `(${terms.join(` ${op} `)})`;
+  }
+  const acc = BaseCompiler.tempVar();
+  const floatType = isWGSL ? "f32" : "float";
+  const intType = isWGSL ? "i32" : "int";
+  const bodyTarget = {
+    ...target,
+    var: (id) => id === index ? isWGSL ? `f32(${index})` : `float(${index})` : target.var(id)
+  };
+  const body = BaseCompiler.compile(args[0], bodyTarget);
+  const lowerStr = lowerNum !== void 0 ? String(lowerNum) : BaseCompiler.compile(limitsOps[1], target);
+  const upperStr = upperNum !== void 0 ? String(upperNum) : BaseCompiler.compile(limitsOps[2], target);
+  const accDecl = isWGSL ? `var ${acc}: ${floatType}` : `${floatType} ${acc}`;
+  const indexDecl = isWGSL ? `var ${index}: ${intType}` : `${intType} ${index}`;
+  const lines = [
+    `${accDecl} = ${identity};`,
+    `for (${indexDecl} = ${lowerStr}; ${index} <= ${upperStr}; ${index}++) {`,
+    `  ${acc} ${op}= ${body};`,
+    `}`,
+    `return ${acc}`
+  ];
+  return lines.join("\n");
+}
 var GPU_FUNCTIONS = {
   // Variadic arithmetic (for function-call form, e.g., with vectors)
   Add: (args, compile3, target) => {
@@ -57640,6 +58421,28 @@ var GPU_FUNCTIONS = {
     if (x === null) throw new Error("ErfInv: no argument");
     return `_gpu_erfinv(${compile3(x)})`;
   },
+  Heaviside: ([x], compile3) => {
+    if (x === null) throw new Error("Heaviside: no argument");
+    return `_gpu_heaviside(${compile3(x)})`;
+  },
+  Sinc: ([x], compile3) => {
+    if (x === null) throw new Error("Sinc: no argument");
+    return `_gpu_sinc(${compile3(x)})`;
+  },
+  FresnelC: ([x], compile3) => {
+    if (x === null) throw new Error("FresnelC: no argument");
+    return `_gpu_fresnelC(${compile3(x)})`;
+  },
+  FresnelS: ([x], compile3) => {
+    if (x === null) throw new Error("FresnelS: no argument");
+    return `_gpu_fresnelS(${compile3(x)})`;
+  },
+  BesselJ: ([n, x], compile3, target) => {
+    if (n === null || x === null)
+      throw new Error("BesselJ: need two arguments");
+    const intCast = target?.language === "wgsl" ? "i32" : "int";
+    return `_gpu_besselJ(${intCast}(${compile3(n)}), ${compile3(x)})`;
+  },
   // Additional math functions
   Lb: "log2",
   Log: (args, compile3) => {
@@ -57725,7 +58528,44 @@ var GPU_FUNCTIONS = {
   Length: "length",
   Normalize: "normalize",
   Reflect: "reflect",
-  Refract: "refract"
+  Refract: "refract",
+  // Sum/Product — unrolled or for-loop
+  Sum: (args, compile3, target) => compileGPUSumProduct("Sum", args, compile3, target),
+  Product: (args, compile3, target) => compileGPUSumProduct("Product", args, compile3, target),
+  // Loop — GPU for-loop (no IIFE, no let)
+  Loop: (args, _compile2, target) => {
+    if (!args[0]) throw new Error("Loop: no body");
+    if (!args[1]) throw new Error("Loop: no indexing set");
+    const indexing = args[1];
+    if (!isFunction2(indexing, "Element"))
+      throw new Error("Loop: expected Element(index, Range(lo, hi))");
+    const indexExpr = indexing.ops[0];
+    const rangeExpr = indexing.ops[1];
+    if (!isSymbol2(indexExpr)) throw new Error("Loop: index must be a symbol");
+    if (!isFunction2(rangeExpr, "Range"))
+      throw new Error("Loop: expected Range(lo, hi)");
+    const index = indexExpr.symbol;
+    const lower = Math.floor(rangeExpr.ops[0].re);
+    const upper = Math.floor(rangeExpr.ops[1].re);
+    if (!Number.isFinite(lower) || !Number.isFinite(upper))
+      throw new Error("Loop: bounds must be finite numbers");
+    const isWGSL = target.language === "wgsl";
+    const intType = isWGSL ? "i32" : "int";
+    const bodyCode = BaseCompiler.compile(args[0], {
+      ...target,
+      var: (id) => id === index ? index : target.var(id)
+    });
+    const indexDecl = isWGSL ? `var ${index}: ${intType}` : `${intType} ${index}`;
+    return `for (${indexDecl} = ${lower}; ${index} <= ${upper}; ${index}++) {
+  ${bodyCode};
+}`;
+  },
+  // Function (lambda) — not supported in GPU
+  Function: () => {
+    throw new Error(
+      "Anonymous functions (Function) are not supported in GPU targets"
+    );
+  }
 };
 function compileGPUMatrix(args, compile3, vecFn, matFn, arrayFn) {
   const body = args[0];
@@ -57806,6 +58646,476 @@ float _gpu_erfinv(float x) {
   return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);
 }
 `;
+var GPU_HEAVISIDE_PREAMBLE_GLSL = `
+float _gpu_heaviside(float x) {
+  if (x < 0.0) return 0.0;
+  if (x > 0.0) return 1.0;
+  return 0.5;
+}
+`;
+var GPU_HEAVISIDE_PREAMBLE_WGSL = `
+fn _gpu_heaviside(x: f32) -> f32 {
+  if (x < 0.0) { return 0.0; }
+  if (x > 0.0) { return 1.0; }
+  return 0.5;
+}
+`;
+var GPU_SINC_PREAMBLE_GLSL = `
+float _gpu_sinc(float x) {
+  if (abs(x) < 1e-10) return 1.0;
+  return sin(x) / x;
+}
+`;
+var GPU_SINC_PREAMBLE_WGSL = `
+fn _gpu_sinc(x: f32) -> f32 {
+  if (abs(x) < 1e-10) { return 1.0; }
+  return sin(x) / x;
+}
+`;
+var GPU_POLEVL_PREAMBLE_GLSL = `
+float _gpu_polevl(float x, float c[12], int n) {
+  float ans = c[0];
+  for (int i = 1; i < n; i++) ans = ans * x + c[i];
+  return ans;
+}
+`;
+var GPU_POLEVL_PREAMBLE_WGSL = `
+fn _gpu_polevl(x: f32, c: array<f32, 12>, n: i32) -> f32 {
+  var ans = c[0];
+  for (var i: i32 = 1; i < n; i++) { ans = ans * x + c[i]; }
+  return ans;
+}
+`;
+var GPU_FRESNELC_PREAMBLE_GLSL = `
+float _gpu_fresnelC(float x_in) {
+  float sgn = x_in < 0.0 ? -1.0 : 1.0;
+  float x = abs(x_in);
+
+  if (x < 1.6) {
+    float x2 = x * x;
+    float t = x2 * x2;
+    float cn[6] = float[6](
+      -4.98843114573573548651e-8, 9.50428062829859605134e-6,
+      -6.45191435683965050962e-4, 1.88843319396703850064e-2,
+      -2.05525900955013891793e-1, 9.99999999999999998822e-1
+    );
+    float cd[7] = float[7](
+      3.99982968972495980367e-12, 9.15439215774657478799e-10,
+      1.25001862479598821474e-7, 1.22262789024179030997e-5,
+      8.68029542941784300606e-4, 4.12142090722199792936e-2, 1.0
+    );
+    return sgn * x * _gpu_polevl(t, cn, 6) / _gpu_polevl(t, cd, 7);
+  }
+
+  if (x < 36.0) {
+    float x2 = x * x;
+    float t = 3.14159265358979 * x2;
+    float u = 1.0 / (t * t);
+    float fn[10] = float[10](
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20
+    );
+    float fd[11] = float[11](
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20
+    );
+    float gn[11] = float[11](
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22
+    );
+    float gd[12] = float[12](
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    float f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    float g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    float z = 1.5707963267948966 * x2;
+    float c = cos(z);
+    float s = sin(z);
+    return sgn * (0.5 + (f * s - g * c) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELC_PREAMBLE_WGSL = `
+fn _gpu_fresnelC(x_in: f32) -> f32 {
+  let sgn: f32 = select(1.0, -1.0, x_in < 0.0);
+  let x = abs(x_in);
+
+  if (x < 1.6) {
+    let x2 = x * x;
+    let t = x2 * x2;
+    var cn = array<f32, 12>(
+      -4.98843114573573548651e-8, 9.50428062829859605134e-6,
+      -6.45191435683965050962e-4, 1.88843319396703850064e-2,
+      -2.05525900955013891793e-1, 9.99999999999999998822e-1,
+      0.0, 0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    var cd = array<f32, 12>(
+      3.99982968972495980367e-12, 9.15439215774657478799e-10,
+      1.25001862479598821474e-7, 1.22262789024179030997e-5,
+      8.68029542941784300606e-4, 4.12142090722199792936e-2, 1.0,
+      0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    return sgn * x * _gpu_polevl(t, cn, 6) / _gpu_polevl(t, cd, 7);
+  }
+
+  if (x < 36.0) {
+    let x2 = x * x;
+    let t = 3.14159265358979 * x2;
+    let u = 1.0 / (t * t);
+    var fn = array<f32, 12>(
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20,
+      0.0, 0.0
+    );
+    var fd = array<f32, 12>(
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20, 0.0
+    );
+    var gn = array<f32, 12>(
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22, 0.0
+    );
+    var gd = array<f32, 12>(
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    let f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    let g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    let z = 1.5707963267948966 * x2;
+    let c = cos(z);
+    let s = sin(z);
+    return sgn * (0.5 + (f * s - g * c) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELS_PREAMBLE_GLSL = `
+float _gpu_fresnelS(float x_in) {
+  float sgn = x_in < 0.0 ? -1.0 : 1.0;
+  float x = abs(x_in);
+
+  if (x < 1.6) {
+    float x2 = x * x;
+    float t = x2 * x2;
+    float sn[6] = float[6](
+      -2.99181919401019853726e3, 7.08840045257738576863e5,
+      -6.29741486205862506537e7, 2.54890880573376359104e9,
+      -4.42979518059697779103e10, 3.18016297876567817986e11
+    );
+    float sd[7] = float[7](
+      1.0, 2.81376268889994315696e2, 4.55847810806532581675e4,
+      5.1734388877009640073e6, 4.19320245898111231129e8, 2.2441179564534092094e10,
+      6.07366389490084914091e11
+    );
+    return sgn * x * x2 * _gpu_polevl(t, sn, 6) / _gpu_polevl(t, sd, 7);
+  }
+
+  if (x < 36.0) {
+    float x2 = x * x;
+    float t = 3.14159265358979 * x2;
+    float u = 1.0 / (t * t);
+    float fn[10] = float[10](
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20
+    );
+    float fd[11] = float[11](
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20
+    );
+    float gn[11] = float[11](
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22
+    );
+    float gd[12] = float[12](
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    float f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    float g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    float z = 1.5707963267948966 * x2;
+    float c = cos(z);
+    float s = sin(z);
+    return sgn * (0.5 - (f * c + g * s) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELS_PREAMBLE_WGSL = `
+fn _gpu_fresnelS(x_in: f32) -> f32 {
+  let sgn: f32 = select(1.0, -1.0, x_in < 0.0);
+  let x = abs(x_in);
+
+  if (x < 1.6) {
+    let x2 = x * x;
+    let t = x2 * x2;
+    var sn = array<f32, 12>(
+      -2.99181919401019853726e3, 7.08840045257738576863e5,
+      -6.29741486205862506537e7, 2.54890880573376359104e9,
+      -4.42979518059697779103e10, 3.18016297876567817986e11,
+      0.0, 0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    var sd = array<f32, 12>(
+      1.0, 2.81376268889994315696e2, 4.55847810806532581675e4,
+      5.1734388877009640073e6, 4.19320245898111231129e8, 2.2441179564534092094e10,
+      6.07366389490084914091e11,
+      0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    return sgn * x * x2 * _gpu_polevl(t, sn, 6) / _gpu_polevl(t, sd, 7);
+  }
+
+  if (x < 36.0) {
+    let x2 = x * x;
+    let t = 3.14159265358979 * x2;
+    let u = 1.0 / (t * t);
+    var fn = array<f32, 12>(
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20,
+      0.0, 0.0
+    );
+    var fd = array<f32, 12>(
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20, 0.0
+    );
+    var gn = array<f32, 12>(
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22, 0.0
+    );
+    var gd = array<f32, 12>(
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    let f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    let g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    let z = 1.5707963267948966 * x2;
+    let c = cos(z);
+    let s = sin(z);
+    return sgn * (0.5 - (f * c + g * s) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_BESSELJ_PREAMBLE_GLSL = `
+float _gpu_factorial(int n) {
+  float f = 1.0;
+  for (int i = 2; i <= n; i++) f *= float(i);
+  return f;
+}
+
+float _gpu_besselJ_series(int n, float x) {
+  float halfX = x / 2.0;
+  float negQ = -(x * x) / 4.0;
+  float term = 1.0;
+  for (int i = 1; i <= n; i++) term /= float(i);
+  float s = term;
+  for (int k = 1; k <= 60; k++) {
+    term *= negQ / (float(k) * float(n + k));
+    s += term;
+    if (abs(term) < abs(s) * 1e-7) break;
+  }
+  return s * pow(halfX, float(n));
+}
+
+float _gpu_besselJ_asymptotic(int n, float x) {
+  float mu = 4.0 * float(n) * float(n);
+  float P = 1.0;
+  float Q = 0.0;
+  float ak = 1.0;
+  float e8x = 8.0 * x;
+  for (int k = 1; k <= 12; k++) {
+    float twokm1 = float(2 * k - 1);
+    ak *= mu - twokm1 * twokm1;
+    float denom = _gpu_factorial(k) * pow(e8x, float(k));
+    float contrib = ak / denom;
+    if (k == 1 || k == 3 || k == 5 || k == 7 || k == 9 || k == 11) {
+      // odd k: contributes to Q
+      if (((k - 1) / 2) % 2 == 0) Q += contrib;
+      else Q -= contrib;
+    } else {
+      // even k: contributes to P
+      if ((k / 2) % 2 == 1) P -= contrib;
+      else P += contrib;
+    }
+    if (abs(contrib) < 1e-7) break;
+  }
+  float chi = x - (float(n) / 2.0 + 0.25) * 3.14159265358979;
+  return sqrt(2.0 / (3.14159265358979 * x)) * (P * cos(chi) - Q * sin(chi));
+}
+
+float _gpu_besselJ(int n, float x) {
+  if (x == 0.0) return n == 0 ? 1.0 : 0.0;
+  float sgn = 1.0;
+  if (n < 0) {
+    n = -n;
+    if (n % 2 != 0) sgn = -1.0;
+  }
+  if (x < 0.0) {
+    x = -x;
+    if (n % 2 != 0) sgn *= -1.0;
+  }
+  if (x > 25.0 + float(n * n) / 2.0) return sgn * _gpu_besselJ_asymptotic(n, x);
+  if (x < 5.0 + float(n)) return sgn * _gpu_besselJ_series(n, x);
+  // Miller's backward recurrence
+  int M = max(n + 20, int(ceil(x)) + 30);
+  if (M > 200) return sgn * _gpu_besselJ_series(n, x);
+  float vals[201];
+  float jp1 = 0.0;
+  float jk = 1.0;
+  vals[M] = jk;
+  for (int k = M; k >= 1; k--) {
+    float jm1 = (2.0 * float(k) / x) * jk - jp1;
+    jp1 = jk;
+    jk = jm1;
+    vals[k - 1] = jk;
+  }
+  float norm = vals[0];
+  for (int k = 2; k <= M; k += 2) norm += 2.0 * vals[k];
+  return sgn * vals[n] / norm;
+}
+`;
+var GPU_BESSELJ_PREAMBLE_WGSL = `
+fn _gpu_factorial(n: i32) -> f32 {
+  var f: f32 = 1.0;
+  for (var i: i32 = 2; i <= n; i++) { f *= f32(i); }
+  return f;
+}
+
+fn _gpu_besselJ_series(n_in: i32, x: f32) -> f32 {
+  let halfX = x / 2.0;
+  let negQ = -(x * x) / 4.0;
+  var term: f32 = 1.0;
+  for (var i: i32 = 1; i <= n_in; i++) { term /= f32(i); }
+  var s = term;
+  for (var k: i32 = 1; k <= 60; k++) {
+    term *= negQ / (f32(k) * f32(n_in + k));
+    s += term;
+    if (abs(term) < abs(s) * 1e-7) { break; }
+  }
+  return s * pow(halfX, f32(n_in));
+}
+
+fn _gpu_besselJ_asymptotic(n_in: i32, x: f32) -> f32 {
+  let mu = 4.0 * f32(n_in) * f32(n_in);
+  var P: f32 = 1.0;
+  var Q: f32 = 0.0;
+  var ak: f32 = 1.0;
+  let e8x = 8.0 * x;
+  for (var k: i32 = 1; k <= 12; k++) {
+    let twokm1 = f32(2 * k - 1);
+    ak *= mu - twokm1 * twokm1;
+    let denom = _gpu_factorial(k) * pow(e8x, f32(k));
+    let contrib = ak / denom;
+    if (k == 1 || k == 3 || k == 5 || k == 7 || k == 9 || k == 11) {
+      if (((k - 1) / 2) % 2 == 0) { Q += contrib; }
+      else { Q -= contrib; }
+    } else {
+      if ((k / 2) % 2 == 1) { P -= contrib; }
+      else { P += contrib; }
+    }
+    if (abs(contrib) < 1e-7) { break; }
+  }
+  let chi = x - (f32(n_in) / 2.0 + 0.25) * 3.14159265358979;
+  return sqrt(2.0 / (3.14159265358979 * x)) * (P * cos(chi) - Q * sin(chi));
+}
+
+fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
+  var n = n_in;
+  var x = x_in;
+  if (x == 0.0) { return select(0.0, 1.0, n == 0); }
+  var sgn: f32 = 1.0;
+  if (n < 0) {
+    n = -n;
+    if (n % 2 != 0) { sgn = -1.0; }
+  }
+  if (x < 0.0) {
+    x = -x;
+    if (n % 2 != 0) { sgn *= -1.0; }
+  }
+  if (x > 25.0 + f32(n * n) / 2.0) { return sgn * _gpu_besselJ_asymptotic(n, x); }
+  if (x < 5.0 + f32(n)) { return sgn * _gpu_besselJ_series(n, x); }
+  // Miller's backward recurrence
+  var M = max(n + 20, i32(ceil(x)) + 30);
+  if (M > 200) { return sgn * _gpu_besselJ_series(n, x); }
+  var vals: array<f32, 201>;
+  var jp1: f32 = 0.0;
+  var jk: f32 = 1.0;
+  vals[M] = jk;
+  for (var k: i32 = M; k >= 1; k--) {
+    let jm1 = (2.0 * f32(k) / x) * jk - jp1;
+    jp1 = jk;
+    jk = jm1;
+    vals[k - 1] = jk;
+  }
+  var norm = vals[0];
+  for (var k2: i32 = 2; k2 <= M; k2 += 2) { norm += 2.0 * vals[k2]; }
+  return sgn * vals[n] / norm;
+}
+`;
 var GPU_FRACTAL_PREAMBLE_GLSL = `
 float _fractal_mandelbrot(vec2 c, int maxIter) {
   vec2 z = vec2(0.0, 0.0);
@@ -58268,6 +59578,16 @@ var GPUShaderTarget = class {
       indent: 0,
       ws: (s) => s ?? "",
       preamble: "",
+      declare: (name, typeHint) => {
+        const type2 = typeHint ?? (this.languageId === "wgsl" ? "f32" : "float");
+        return this.languageId === "wgsl" ? `var ${name}: ${type2}` : `${type2} ${name}`;
+      },
+      block: (stmts) => {
+        if (stmts.length === 0) return "";
+        const last = stmts.length - 1;
+        stmts[last] = `return ${stmts[last]}`;
+        return stmts.join(";\n");
+      },
       ...options
     };
   }
@@ -58302,6 +59622,18 @@ var GPUShaderTarget = class {
     preamble += buildComplexPreamble(code, this.languageId);
     if (code.includes("_gpu_gamma")) preamble += GPU_GAMMA_PREAMBLE;
     if (code.includes("_gpu_erf")) preamble += GPU_ERF_PREAMBLE;
+    if (code.includes("_gpu_heaviside"))
+      preamble += this.languageId === "wgsl" ? GPU_HEAVISIDE_PREAMBLE_WGSL : GPU_HEAVISIDE_PREAMBLE_GLSL;
+    if (code.includes("_gpu_sinc"))
+      preamble += this.languageId === "wgsl" ? GPU_SINC_PREAMBLE_WGSL : GPU_SINC_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnel"))
+      preamble += this.languageId === "wgsl" ? GPU_POLEVL_PREAMBLE_WGSL : GPU_POLEVL_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnelC"))
+      preamble += this.languageId === "wgsl" ? GPU_FRESNELC_PREAMBLE_WGSL : GPU_FRESNELC_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnelS"))
+      preamble += this.languageId === "wgsl" ? GPU_FRESNELS_PREAMBLE_WGSL : GPU_FRESNELS_PREAMBLE_GLSL;
+    if (code.includes("_gpu_besselJ"))
+      preamble += this.languageId === "wgsl" ? GPU_BESSELJ_PREAMBLE_WGSL : GPU_BESSELJ_PREAMBLE_GLSL;
     if (code.includes("_fractal_")) {
       preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
     }
@@ -58350,6 +59682,12 @@ var GLSLTarget = class extends GPUShaderTarget {
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
     const params = parameters.map(([name, type2]) => `${type2} ${name}`).join(", ");
+    if (body.includes("\n")) {
+      const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
+      return `${returnType} ${functionName}(${params}) {
+${indented};
+}`;
+    }
     return `${returnType} ${functionName}(${params}) {
   return ${body};
 }`;
@@ -58453,6 +59791,14 @@ var WGSLTarget = class extends GPUShaderTarget {
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
     const params = parameters.map(([name, type2]) => `${name}: ${toWGSLType(type2)}`).join(", ");
+    if (body.includes("\n")) {
+      const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
+      return `fn ${functionName}(${params}) -> ${toWGSLType(
+        returnType
+      )} {
+${indented};
+}`;
+    }
     return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
   return ${body};
 }`;
@@ -59097,7 +60443,7 @@ function binomial2(n, k) {
   ];
   return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
 }
-function gcd4(a, b) {
+function gcd5(a, b) {
   const uA = unwrapOrPropagate(a);
   if (!Array.isArray(uA)) return uA;
   const uB = unwrapOrPropagate(b);
@@ -59749,7 +61095,7 @@ var IntervalArithmetic = {
   factorial: factorial5,
   factorial2: factorial24,
   binomial: binomial2,
-  gcd: gcd4,
+  gcd: gcd5,
   lcm: lcm4,
   chop: chop4,
   erf: erf2,
@@ -63528,6 +64874,11 @@ var _Parser = class __Parser {
     if (this.atEnd) return lhs;
     console.assert(lhs !== null);
     const index = this.index;
+    if (this.options.strict === false && typeof lhs === "string" && lhs.length === 1 && /^[a-zA-Z]$/.test(lhs) && /^[2-9]$/.test(this.peek)) {
+      const digit = parseInt(this.peek);
+      this.index++;
+      return this.parseSupsub(["Power", lhs, digit]);
+    }
     this.skipSpace();
     const superscripts = [];
     const subscripts = [];
@@ -65632,9 +66983,9 @@ function TR12i(expr) {
   return ce._fn("Tan", [tanCArg]).neg();
 }
 function lcm5(a, b) {
-  return Math.abs(a * b) / gcd5(a, b);
+  return Math.abs(a * b) / gcd6(a, b);
 }
-function gcd5(a, b) {
+function gcd6(a, b) {
   a = Math.abs(a);
   b = Math.abs(b);
   while (b) {
@@ -67320,10 +68671,10 @@ var ComputeEngine = class _ComputeEngine {
 _setComputeEngineClass(ComputeEngine);
 
 // src/compute-engine.ts
-var version = "0.53.0";
+var version = "0.54.0";
 globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.53.0"
+  version: "0.54.0"
 };
 export {
   BaseCompiler,