@cortex-js/compute-engine 0.53.0 → 0.54.0

package/dist/{compute-engine.umd.js → compute-engine.umd.cjs}

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.0 */
+/** Compute Engine 0.54.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -11144,7 +11144,7 @@ var ComputeEngine = (() => {
       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;
@@ -11152,11 +11152,11 @@ var ComputeEngine = (() => {
     };
     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 = [];
@@ -11655,14 +11655,11 @@ var ComputeEngine = (() => {
     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;
   }
@@ -12354,6 +12351,18 @@ var ComputeEngine = (() => {
   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;
@@ -12669,6 +12678,34 @@ var ComputeEngine = (() => {
     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)) {
@@ -16128,10 +16165,14 @@ ${lines.join("\n")}`;
     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;
@@ -16731,13 +16772,14 @@ ${lines.join("\n")}`;
   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;
   }
@@ -20254,24 +20296,30 @@ ${lines.join("\n")}`;
         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: {
@@ -21496,12 +21544,10 @@ ${lines.join("\n")}`;
   }
   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;
@@ -22920,12 +22966,10 @@ ${lines.join("\n")}`;
     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;
@@ -22992,7 +23036,6 @@ ${lines.join("\n")}`;
       return initial;
     }
     let result = initial;
-    let counter = 0;
     while (true) {
       for (let i = 0; i < elementDomains.length; i++) {
         ce.assign(
@@ -23001,8 +23044,7 @@ ${lines.join("\n")}`;
         );
       }
       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) {
@@ -23972,7 +24014,8 @@ ${lines.join("\n")}`;
                 ce._timeRemaining
               )
             );
-          } catch {
+          } catch (e) {
+            if (e instanceof CancellationError) throw e;
             return void 0;
           }
         },
@@ -23991,7 +24034,8 @@ ${lines.join("\n")}`;
                 signal
               )
             );
-          } catch {
+          } catch (e) {
+            if (e instanceof CancellationError) throw e;
             return void 0;
           }
         }
@@ -24009,7 +24053,9 @@ ${lines.join("\n")}`;
           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));
         }
       },
@@ -26410,6 +26456,268 @@ ${e.message}
     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;
@@ -27233,6 +27541,13 @@ ${e.message}
           )
         );
       }
+      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();
     }
@@ -27371,267 +27686,49 @@ ${e.message}
       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);
+  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 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 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) {
+        for (const sign3 of [1, -1]) {
+          const val = sign3 * p / q;
+          if (!seen.has(val)) {
+            seen.add(val);
+            candidates.push(val);
           }
         }
-        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 (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);
     }
-    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 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
@@ -33600,7 +33697,7 @@ ${e.message}
         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" });
       }
@@ -33612,7 +33709,7 @@ ${e.message}
       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" });
     }
@@ -38275,7 +38372,107 @@ ${e.message}
       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);
@@ -38283,6 +38480,8 @@ ${e.message}
     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);
   }
@@ -38328,6 +38527,257 @@ ${e.message}
     }
     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) {
@@ -38402,7 +38852,7 @@ ${e.message}
         }
       },
       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]) => {
@@ -38411,7 +38861,7 @@ ${e.message}
           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: {
@@ -38467,6 +38917,85 @@ ${e.message}
           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);
+        }
       }
     }
   ];
@@ -46465,7 +46994,7 @@ Error in definition of "${name}"`,
     };
     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;
@@ -47450,6 +47979,15 @@ Error in definition of "${name}"`,
       } 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;
@@ -47747,8 +48285,8 @@ Error in definition of "${name}"`,
         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);
@@ -47777,8 +48315,8 @@ Error in definition of "${name}"`,
             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);
@@ -47952,17 +48490,140 @@ Error in definition of "${name}"`,
       }
     }
   }
+  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
@@ -48818,7 +49479,7 @@ Error in definition of "${name}"`,
   };
   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);
@@ -48848,7 +49509,7 @@ Error in definition of "${name}"`,
         (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;
@@ -48972,9 +49633,11 @@ Error in definition of "${name}"`,
     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();
     };
@@ -48983,9 +49646,11 @@ Error in definition of "${name}"`,
     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();
     };
@@ -50483,6 +51148,9 @@ Error in definition of "${name}"`,
         }
       }
       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,
@@ -50492,15 +51160,26 @@ Error in definition of "${name}"`,
           }
         )})`;
       }
-      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);
@@ -50577,16 +51256,38 @@ Error in definition of "${name}"`,
       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")}`
@@ -51072,6 +51773,9 @@ Error in definition of "${name}"`,
   _setSerializeJson(serializeJson);
   _setProduct(Product);
   _setCompile(compile);
+  _setGetPolynomialCoefficients(getPolynomialCoefficients);
+  _setGetPolynomialDegree(polynomialDegree);
+  _setFindUnivariateRoots(findUnivariateRoots);
 
   // src/compute-engine/symbolic/simplify-logic.ts
   function simplifyLogicFunction(x) {
@@ -54010,6 +54714,27 @@ Error in definition of "${name}"`,
       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) => {
@@ -57352,6 +58077,62 @@ Error in definition of "${name}"`,
   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) => {
@@ -57701,6 +58482,28 @@ Error in definition of "${name}"`,
       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) => {
@@ -57786,7 +58589,44 @@ Error in definition of "${name}"`,
     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];
@@ -57866,6 +58706,476 @@ float _gpu_erfinv(float x) {
   float x9 = x7 * x2;
   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) {
@@ -58329,6 +59639,16 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
         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
       };
     }
@@ -58363,6 +59683,18 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       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;
       }
@@ -58411,6 +59743,12 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       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};
 }`;
@@ -58514,6 +59852,14 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       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};
 }`;
@@ -59158,7 +60504,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     ];
     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);
@@ -59810,7 +61156,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     factorial: factorial5,
     factorial2: factorial24,
     binomial: binomial2,
-    gcd: gcd4,
+    gcd: gcd5,
     lcm: lcm4,
     chop: chop4,
     erf: erf2,
@@ -63589,6 +64935,11 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       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 = [];
@@ -65693,9 +67044,9 @@ ${code}`;
     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) {
@@ -67381,10 +68732,10 @@ ${code}`;
   _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"
   };
   return __toCommonJS(compute_engine_exports);
 })();