@cortex-js/compute-engine 0.53.0 → 0.53.1

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

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.0 */
+/** Compute Engine 0.53.1 */
     (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;
   }
@@ -16731,13 +16728,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 +20252,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 +21500,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 +22922,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 +22992,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 +23000,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 +23970,8 @@ ${lines.join("\n")}`;
                 ce._timeRemaining
               )
             );
-          } catch {
+          } catch (e) {
+            if (e instanceof CancellationError) throw e;
             return void 0;
           }
         },
@@ -23991,7 +23990,8 @@ ${lines.join("\n")}`;
                 signal
               )
             );
-          } catch {
+          } catch (e) {
+            if (e instanceof CancellationError) throw e;
             return void 0;
           }
         }
@@ -24009,7 +24009,7 @@ ${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));
         }
       },
@@ -33600,7 +33600,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 +33612,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" });
     }
@@ -48972,9 +48972,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 +48985,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 +50487,13 @@ 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 +50503,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 +50599,35 @@ 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")}`
@@ -57352,6 +57393,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 +57798,27 @@ 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 +57904,45 @@ 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 +58022,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 +58955,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 +58999,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 +59059,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 +59168,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]) => `${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};
 }`;
@@ -67381,10 +68041,10 @@ ${code}`;
   _setComputeEngineClass(ComputeEngine);
 
   // src/compute-engine.ts
-  var version = "0.53.0";
+  var version = "0.53.1";
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.53.0"
+    version: "0.53.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();