@cortex-js/compute-engine 0.53.0 → 0.53.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.53.0 */
+/** Compute Engine 0.53.1 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -11083,7 +11083,7 @@ function parseWhereExpression(parser, lhs, until) {
     condition: (p) => {
       if (until?.condition?.(p)) return true;
       const saved = p.index;
-      p.skipSpace();
+      p.skipVisualSpace();
       const isComma = p.peek === ",";
       p.index = saved;
       return isComma;
@@ -11091,11 +11091,11 @@ function parseWhereExpression(parser, lhs, until) {
   };
   const bindings = [];
   do {
-    parser.skipSpace();
+    parser.skipVisualSpace();
     const binding = parser.parseExpression(bindingTerminator);
     if (!binding) break;
     bindings.push(binding);
-    parser.skipSpace();
+    parser.skipVisualSpace();
   } while (parser.match(","));
   if (bindings.length === 0) return null;
   const block = [];
@@ -11594,14 +11594,11 @@ function* factorial3(n) {
   let loop = n;
   let sum2 = n;
   let val = n;
-  let counter = 0;
   while (loop > 2) {
     loop -= BigInt(2);
     sum2 += loop;
     val *= sum2;
-    counter += 1;
-    if (counter % 5e4 === 0 || counter > 1e4 && counter % 500 === 0)
-      yield val;
+    yield val;
   }
   return val;
 }
@@ -16670,13 +16667,14 @@ function gcd3(a, b) {
 function lcm3(a, b) {
   return a.mul(b).div(gcd3(a, b));
 }
-function factorial23(ce, n) {
+function* factorial23(ce, n) {
   if (!n.isInteger() || n.isNegative()) return ce._BIGNUM_NAN;
   if (n.lessThan(1)) return ce._BIGNUM_ONE;
   let result = n;
   while (n.greaterThan(2)) {
     n = n.minus(2);
     result = result.mul(n);
+    yield result;
   }
   return result;
 }
@@ -20193,24 +20191,30 @@ var COLLECTIONS_LIBRARY = {
       if (initial.type.matches("real") && collection.type.matches(ce.type("collection<real>"))) {
         const compiled = ce._compile(fn);
         if (compiled.calling !== "lambda" || !compiled.run) return void 0;
-        let accumulator2 = initial.re;
-        let first2 = true;
-        for (const item of collection.each()) {
-          if (first2) accumulator2 = item.re;
-          else accumulator2 = compiled.run(accumulator2, item.re);
-          first2 = false;
-        }
-        return ce.box(accumulator2);
+        return run(
+          (function* () {
+            let accumulator = initial.re;
+            let first = true;
+            for (const item of collection.each()) {
+              if (first) accumulator = item.re;
+              else accumulator = compiled.run(accumulator, item.re);
+              first = false;
+              yield;
+            }
+            return ce.box(accumulator);
+          })(),
+          ce._timeRemaining
+        );
       }
       const f = applicable(fn);
-      let accumulator = initial;
-      let first = true;
-      for (const item of collection.each()) {
-        if (first) accumulator = item;
-        else accumulator = f([accumulator, item]) ?? ce.Nothing;
-        first = false;
-      }
-      return accumulator;
+      return run(
+        reduceCollection(
+          collection,
+          (acc, x) => f([acc, x]) ?? ce.Nothing,
+          initial
+        ),
+        ce._timeRemaining
+      );
     }
   },
   Join: {
@@ -21435,12 +21439,10 @@ function tally(collection) {
 }
 function* reduceCollection(collection, fn, initial) {
   let acc = initial;
-  let counter = 0;
   for (const x of collection.each()) {
     const result = fn(acc, x);
     if (result === null) return void 0;
-    counter += 1;
-    if (counter % 1e3 === 0) yield acc;
+    yield acc;
     acc = result;
   }
   return acc;
@@ -22859,12 +22861,10 @@ function* reduceBigOp(body, indexes, fn, initial) {
   const indexingSets = normalizeIndexingSets(indexes);
   const cartesianArray = indexingSetCartesianProduct(indexingSets);
   let result = initial;
-  let counter = 0;
   for (const element of cartesianArray) {
     indexingSets.forEach((x, i) => ce.assign(x.index, element[i]));
     result = fn(result, body) ?? void 0;
-    counter += 1;
-    if (counter % 1e3 === 0) yield result;
+    yield result;
     if (result === void 0) break;
   }
   return result ?? void 0;
@@ -22931,7 +22931,6 @@ function* reduceElementIndexingSets(body, indexes, fn, initial, returnReason = f
     return initial;
   }
   let result = initial;
-  let counter = 0;
   while (true) {
     for (let i = 0; i < elementDomains.length; i++) {
       ce.assign(
@@ -22940,8 +22939,7 @@ function* reduceElementIndexingSets(body, indexes, fn, initial, returnReason = f
       );
     }
     result = fn(result, body) ?? void 0;
-    counter++;
-    if (counter % 1e3 === 0) yield result;
+    yield result;
     if (result === void 0) break;
     let dim = elementDomains.length - 1;
     while (dim >= 0) {
@@ -23911,7 +23909,8 @@ var ARITHMETIC_LIBRARY = [
               ce._timeRemaining
             )
           );
-        } catch {
+        } catch (e) {
+          if (e instanceof CancellationError) throw e;
           return void 0;
         }
       },
@@ -23930,7 +23929,8 @@ var ARITHMETIC_LIBRARY = [
               signal
             )
           );
-        } catch {
+        } catch (e) {
+          if (e instanceof CancellationError) throw e;
           return void 0;
         }
       }
@@ -23948,7 +23948,7 @@ var ARITHMETIC_LIBRARY = [
         if (n === null) return void 0;
         const ce = x.engine;
         if (bignumPreferred(ce))
-          return ce.number(factorial23(ce, ce.bignum(n)));
+          return ce.number(run(factorial23(ce, ce.bignum(n)), ce._timeRemaining));
         return ce.number(factorial22(n));
       }
     },
@@ -33539,7 +33539,7 @@ function* runLoop(body, collection, ce) {
       if (isFunction2(result, "Break")) return result.op1;
       if (result.operator === "Return") return result;
       i2 += 1;
-      if (i2 % 1e3 === 0) yield result;
+      yield result;
       if (i2 > ce.iterationLimit)
         throw new CancellationError({ cause: "iteration-limit-exceeded" });
     }
@@ -33551,7 +33551,7 @@ function* runLoop(body, collection, ce) {
     if (isFunction2(result, "Break")) return result.op1;
     if (result.operator === "Return") return result;
     i += 1;
-    if (i % 1e3 === 0) yield result;
+    yield result;
     if (i > ce.iterationLimit)
       throw new CancellationError({ cause: "iteration-limit-exceeded" });
   }
@@ -48911,9 +48911,11 @@ function withDeadline(engine, fn) {
   return () => {
     if (engine._deadline === void 0) {
       engine._deadline = Date.now() + engine.timeLimit;
-      const result = fn();
-      engine._deadline = void 0;
-      return result;
+      try {
+        return fn();
+      } finally {
+        engine._deadline = void 0;
+      }
     }
     return fn();
   };
@@ -48922,9 +48924,11 @@ function withDeadlineAsync(engine, fn) {
   return async () => {
     if (engine._deadline === void 0) {
       engine._deadline = Date.now() + engine.timeLimit;
-      const result = await fn();
-      engine._deadline = void 0;
-      return result;
+      try {
+        return await fn();
+      } finally {
+        engine._deadline = void 0;
+      }
     }
     return fn();
   };
@@ -50422,6 +50426,13 @@ var BaseCompiler = class _BaseCompiler {
       }
     }
     if (h === "Function") {
+      const fnFn = target.functions?.(h);
+      if (typeof fnFn === "function")
+        return fnFn(
+          args,
+          (expr) => _BaseCompiler.compile(expr, target),
+          target
+        );
       const params = args.slice(1).map((x) => isSymbol2(x) ? x.symbol : "_");
       return `((${params.join(", ")}) => ${_BaseCompiler.compile(
         args[0].canonical,
@@ -50431,15 +50442,26 @@ var BaseCompiler = class _BaseCompiler {
         }
       )})`;
     }
-    if (h === "Declare")
-      return `let ${isSymbol2(args[0]) ? args[0].symbol : "_"}`;
+    if (h === "Declare") {
+      const name = isSymbol2(args[0]) ? args[0].symbol : "_";
+      return target.declare ? target.declare(name) : `let ${name}`;
+    }
     if (h === "Assign")
       return `${isSymbol2(args[0]) ? args[0].symbol : "_"} = ${_BaseCompiler.compile(args[1], target)}`;
     if (h === "Return")
       return `return ${_BaseCompiler.compile(args[0], target)}`;
     if (h === "Break") return "break";
     if (h === "Continue") return "continue";
-    if (h === "Loop") return _BaseCompiler.compileForLoop(args, target);
+    if (h === "Loop") {
+      const loopFn = target.functions?.(h);
+      if (typeof loopFn === "function")
+        return loopFn(
+          args,
+          (expr) => _BaseCompiler.compile(expr, target),
+          target
+        );
+      return _BaseCompiler.compileForLoop(args, target);
+    }
     if (h === "If") {
       if (args.length !== 3) throw new Error("If: wrong number of arguments");
       const fn2 = target.functions?.(h);
@@ -50516,16 +50538,35 @@ var BaseCompiler = class _BaseCompiler {
     if (args.length === 1 && locals.length === 0) {
       return _BaseCompiler.compile(args[0], target);
     }
-    const result = args.filter((a) => !isSymbol2(a, "Nothing")).map(
-      (arg) => _BaseCompiler.compile(arg, {
-        ...target,
-        var: (id) => {
-          if (locals.includes(id)) return id;
-          return target.var(id);
+    const typeHints = {};
+    if (target.declare && target.language) {
+      const isWGSL = target.language === "wgsl";
+      for (const local of locals) {
+        for (const arg of args) {
+          if (isFunction2(arg, "Assign") && isSymbol2(arg.ops[0], local)) {
+            if (_BaseCompiler.isComplexValued(arg.ops[1])) {
+              typeHints[local] = isWGSL ? "vec2f" : "vec2";
+            }
+            break;
+          }
         }
-      })
-    ).filter((s) => s !== "");
+      }
+    }
+    const localTarget = {
+      ...target,
+      var: (id) => {
+        if (locals.includes(id)) return id;
+        return target.var(id);
+      }
+    };
+    const result = args.filter((a) => !isSymbol2(a, "Nothing")).map((arg) => {
+      if (isFunction2(arg, "Declare") && isSymbol2(arg.ops[0]) && target.declare) {
+        return target.declare(arg.ops[0].symbol, typeHints[arg.ops[0].symbol]);
+      }
+      return _BaseCompiler.compile(arg, localTarget);
+    }).filter((s) => s !== "");
     if (result.length === 0) return "";
+    if (target.block) return target.block(result);
     result[result.length - 1] = `return ${result[result.length - 1]}`;
     return `(() => {${target.ws("\n")}${result.join(
       `;${target.ws("\n")}`
@@ -57291,6 +57332,62 @@ var GPU_OPERATORS = {
 function gpuVec2(target) {
   return target?.language === "wgsl" ? "vec2f" : "vec2";
 }
+var GPU_UNROLL_LIMIT = 100;
+function compileGPUSumProduct(kind, args, _compile2, target) {
+  if (!args[0]) throw new Error(`${kind}: no body`);
+  if (!args[1]) throw new Error(`${kind}: no indexing set`);
+  if (BaseCompiler.isComplexValued(args[0]))
+    throw new Error(
+      `${kind}: complex-valued body not supported in GPU targets`
+    );
+  const limitsExpr = args[1];
+  if (!isFunction2(limitsExpr, "Limits"))
+    throw new Error(`${kind}: expected Limits indexing set`);
+  const limitsOps = limitsExpr.ops;
+  const index = isSymbol2(limitsOps[0]) ? limitsOps[0].symbol : "_";
+  const lowerRe = limitsOps[1].re;
+  const upperRe = limitsOps[2].re;
+  const lowerNum = !isNaN(lowerRe) && Number.isFinite(lowerRe) ? Math.floor(lowerRe) : void 0;
+  const upperNum = !isNaN(upperRe) && Number.isFinite(upperRe) ? Math.floor(upperRe) : void 0;
+  const isSum = kind === "Sum";
+  const op = isSum ? "+" : "*";
+  const identity = isSum ? "0.0" : "1.0";
+  const isWGSL = target.language === "wgsl";
+  const bothConstant = lowerNum !== void 0 && upperNum !== void 0;
+  if (bothConstant && lowerNum > upperNum) return identity;
+  if (bothConstant && upperNum - lowerNum + 1 <= GPU_UNROLL_LIMIT) {
+    const terms = [];
+    for (let k = lowerNum; k <= upperNum; k++) {
+      const kStr = formatGPUNumber(k);
+      const innerTarget = {
+        ...target,
+        var: (id) => id === index ? kStr : target.var(id)
+      };
+      terms.push(`(${BaseCompiler.compile(args[0], innerTarget)})`);
+    }
+    return `(${terms.join(` ${op} `)})`;
+  }
+  const acc = BaseCompiler.tempVar();
+  const floatType = isWGSL ? "f32" : "float";
+  const intType = isWGSL ? "i32" : "int";
+  const bodyTarget = {
+    ...target,
+    var: (id) => id === index ? isWGSL ? `f32(${index})` : `float(${index})` : target.var(id)
+  };
+  const body = BaseCompiler.compile(args[0], bodyTarget);
+  const lowerStr = lowerNum !== void 0 ? String(lowerNum) : BaseCompiler.compile(limitsOps[1], target);
+  const upperStr = upperNum !== void 0 ? String(upperNum) : BaseCompiler.compile(limitsOps[2], target);
+  const accDecl = isWGSL ? `var ${acc}: ${floatType}` : `${floatType} ${acc}`;
+  const indexDecl = isWGSL ? `var ${index}: ${intType}` : `${intType} ${index}`;
+  const lines = [
+    `${accDecl} = ${identity};`,
+    `for (${indexDecl} = ${lowerStr}; ${index} <= ${upperStr}; ${index}++) {`,
+    `  ${acc} ${op}= ${body};`,
+    `}`,
+    `return ${acc}`
+  ];
+  return lines.join("\n");
+}
 var GPU_FUNCTIONS = {
   // Variadic arithmetic (for function-call form, e.g., with vectors)
   Add: (args, compile3, target) => {
@@ -57640,6 +57737,27 @@ var GPU_FUNCTIONS = {
     if (x === null) throw new Error("ErfInv: no argument");
     return `_gpu_erfinv(${compile3(x)})`;
   },
+  Heaviside: ([x], compile3) => {
+    if (x === null) throw new Error("Heaviside: no argument");
+    return `_gpu_heaviside(${compile3(x)})`;
+  },
+  Sinc: ([x], compile3) => {
+    if (x === null) throw new Error("Sinc: no argument");
+    return `_gpu_sinc(${compile3(x)})`;
+  },
+  FresnelC: ([x], compile3) => {
+    if (x === null) throw new Error("FresnelC: no argument");
+    return `_gpu_fresnelC(${compile3(x)})`;
+  },
+  FresnelS: ([x], compile3) => {
+    if (x === null) throw new Error("FresnelS: no argument");
+    return `_gpu_fresnelS(${compile3(x)})`;
+  },
+  BesselJ: ([n, x], compile3, target) => {
+    if (n === null || x === null) throw new Error("BesselJ: need two arguments");
+    const intCast = target?.language === "wgsl" ? "i32" : "int";
+    return `_gpu_besselJ(${intCast}(${compile3(n)}), ${compile3(x)})`;
+  },
   // Additional math functions
   Lb: "log2",
   Log: (args, compile3) => {
@@ -57725,7 +57843,45 @@ var GPU_FUNCTIONS = {
   Length: "length",
   Normalize: "normalize",
   Reflect: "reflect",
-  Refract: "refract"
+  Refract: "refract",
+  // Sum/Product — unrolled or for-loop
+  Sum: (args, compile3, target) => compileGPUSumProduct("Sum", args, compile3, target),
+  Product: (args, compile3, target) => compileGPUSumProduct("Product", args, compile3, target),
+  // Loop — GPU for-loop (no IIFE, no let)
+  Loop: (args, _compile2, target) => {
+    if (!args[0]) throw new Error("Loop: no body");
+    if (!args[1]) throw new Error("Loop: no indexing set");
+    const indexing = args[1];
+    if (!isFunction2(indexing, "Element"))
+      throw new Error("Loop: expected Element(index, Range(lo, hi))");
+    const indexExpr = indexing.ops[0];
+    const rangeExpr = indexing.ops[1];
+    if (!isSymbol2(indexExpr))
+      throw new Error("Loop: index must be a symbol");
+    if (!isFunction2(rangeExpr, "Range"))
+      throw new Error("Loop: expected Range(lo, hi)");
+    const index = indexExpr.symbol;
+    const lower = Math.floor(rangeExpr.ops[0].re);
+    const upper = Math.floor(rangeExpr.ops[1].re);
+    if (!Number.isFinite(lower) || !Number.isFinite(upper))
+      throw new Error("Loop: bounds must be finite numbers");
+    const isWGSL = target.language === "wgsl";
+    const intType = isWGSL ? "i32" : "int";
+    const bodyCode = BaseCompiler.compile(args[0], {
+      ...target,
+      var: (id) => id === index ? index : target.var(id)
+    });
+    const indexDecl = isWGSL ? `var ${index}: ${intType}` : `${intType} ${index}`;
+    return `for (${indexDecl} = ${lower}; ${index} <= ${upper}; ${index}++) {
+  ${bodyCode};
+}`;
+  },
+  // Function (lambda) — not supported in GPU
+  Function: () => {
+    throw new Error(
+      "Anonymous functions (Function) are not supported in GPU targets"
+    );
+  }
 };
 function compileGPUMatrix(args, compile3, vecFn, matFn, arrayFn) {
   const body = args[0];
@@ -57806,6 +57962,476 @@ float _gpu_erfinv(float x) {
   return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);
 }
 `;
+var GPU_HEAVISIDE_PREAMBLE_GLSL = `
+float _gpu_heaviside(float x) {
+  if (x < 0.0) return 0.0;
+  if (x > 0.0) return 1.0;
+  return 0.5;
+}
+`;
+var GPU_HEAVISIDE_PREAMBLE_WGSL = `
+fn _gpu_heaviside(x: f32) -> f32 {
+  if (x < 0.0) { return 0.0; }
+  if (x > 0.0) { return 1.0; }
+  return 0.5;
+}
+`;
+var GPU_SINC_PREAMBLE_GLSL = `
+float _gpu_sinc(float x) {
+  if (abs(x) < 1e-10) return 1.0;
+  return sin(x) / x;
+}
+`;
+var GPU_SINC_PREAMBLE_WGSL = `
+fn _gpu_sinc(x: f32) -> f32 {
+  if (abs(x) < 1e-10) { return 1.0; }
+  return sin(x) / x;
+}
+`;
+var GPU_POLEVL_PREAMBLE_GLSL = `
+float _gpu_polevl(float x, float c[12], int n) {
+  float ans = c[0];
+  for (int i = 1; i < n; i++) ans = ans * x + c[i];
+  return ans;
+}
+`;
+var GPU_POLEVL_PREAMBLE_WGSL = `
+fn _gpu_polevl(x: f32, c: array<f32, 12>, n: i32) -> f32 {
+  var ans = c[0];
+  for (var i: i32 = 1; i < n; i++) { ans = ans * x + c[i]; }
+  return ans;
+}
+`;
+var GPU_FRESNELC_PREAMBLE_GLSL = `
+float _gpu_fresnelC(float x_in) {
+  float sgn = x_in < 0.0 ? -1.0 : 1.0;
+  float x = abs(x_in);
+
+  if (x < 1.6) {
+    float x2 = x * x;
+    float t = x2 * x2;
+    float cn[6] = float[6](
+      -4.98843114573573548651e-8, 9.50428062829859605134e-6,
+      -6.45191435683965050962e-4, 1.88843319396703850064e-2,
+      -2.05525900955013891793e-1, 9.99999999999999998822e-1
+    );
+    float cd[7] = float[7](
+      3.99982968972495980367e-12, 9.15439215774657478799e-10,
+      1.25001862479598821474e-7, 1.22262789024179030997e-5,
+      8.68029542941784300606e-4, 4.12142090722199792936e-2, 1.0
+    );
+    return sgn * x * _gpu_polevl(t, cn, 6) / _gpu_polevl(t, cd, 7);
+  }
+
+  if (x < 36.0) {
+    float x2 = x * x;
+    float t = 3.14159265358979 * x2;
+    float u = 1.0 / (t * t);
+    float fn[10] = float[10](
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20
+    );
+    float fd[11] = float[11](
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20
+    );
+    float gn[11] = float[11](
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22
+    );
+    float gd[12] = float[12](
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    float f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    float g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    float z = 1.5707963267948966 * x2;
+    float c = cos(z);
+    float s = sin(z);
+    return sgn * (0.5 + (f * s - g * c) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELC_PREAMBLE_WGSL = `
+fn _gpu_fresnelC(x_in: f32) -> f32 {
+  let sgn: f32 = select(1.0, -1.0, x_in < 0.0);
+  let x = abs(x_in);
+
+  if (x < 1.6) {
+    let x2 = x * x;
+    let t = x2 * x2;
+    var cn = array<f32, 12>(
+      -4.98843114573573548651e-8, 9.50428062829859605134e-6,
+      -6.45191435683965050962e-4, 1.88843319396703850064e-2,
+      -2.05525900955013891793e-1, 9.99999999999999998822e-1,
+      0.0, 0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    var cd = array<f32, 12>(
+      3.99982968972495980367e-12, 9.15439215774657478799e-10,
+      1.25001862479598821474e-7, 1.22262789024179030997e-5,
+      8.68029542941784300606e-4, 4.12142090722199792936e-2, 1.0,
+      0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    return sgn * x * _gpu_polevl(t, cn, 6) / _gpu_polevl(t, cd, 7);
+  }
+
+  if (x < 36.0) {
+    let x2 = x * x;
+    let t = 3.14159265358979 * x2;
+    let u = 1.0 / (t * t);
+    var fn = array<f32, 12>(
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20,
+      0.0, 0.0
+    );
+    var fd = array<f32, 12>(
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20, 0.0
+    );
+    var gn = array<f32, 12>(
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22, 0.0
+    );
+    var gd = array<f32, 12>(
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    let f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    let g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    let z = 1.5707963267948966 * x2;
+    let c = cos(z);
+    let s = sin(z);
+    return sgn * (0.5 + (f * s - g * c) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELS_PREAMBLE_GLSL = `
+float _gpu_fresnelS(float x_in) {
+  float sgn = x_in < 0.0 ? -1.0 : 1.0;
+  float x = abs(x_in);
+
+  if (x < 1.6) {
+    float x2 = x * x;
+    float t = x2 * x2;
+    float sn[6] = float[6](
+      -2.99181919401019853726e3, 7.08840045257738576863e5,
+      -6.29741486205862506537e7, 2.54890880573376359104e9,
+      -4.42979518059697779103e10, 3.18016297876567817986e11
+    );
+    float sd[7] = float[7](
+      1.0, 2.81376268889994315696e2, 4.55847810806532581675e4,
+      5.1734388877009640073e6, 4.19320245898111231129e8, 2.2441179564534092094e10,
+      6.07366389490084914091e11
+    );
+    return sgn * x * x2 * _gpu_polevl(t, sn, 6) / _gpu_polevl(t, sd, 7);
+  }
+
+  if (x < 36.0) {
+    float x2 = x * x;
+    float t = 3.14159265358979 * x2;
+    float u = 1.0 / (t * t);
+    float fn[10] = float[10](
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20
+    );
+    float fd[11] = float[11](
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20
+    );
+    float gn[11] = float[11](
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22
+    );
+    float gd[12] = float[12](
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    float f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    float g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    float z = 1.5707963267948966 * x2;
+    float c = cos(z);
+    float s = sin(z);
+    return sgn * (0.5 - (f * c + g * s) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_FRESNELS_PREAMBLE_WGSL = `
+fn _gpu_fresnelS(x_in: f32) -> f32 {
+  let sgn: f32 = select(1.0, -1.0, x_in < 0.0);
+  let x = abs(x_in);
+
+  if (x < 1.6) {
+    let x2 = x * x;
+    let t = x2 * x2;
+    var sn = array<f32, 12>(
+      -2.99181919401019853726e3, 7.08840045257738576863e5,
+      -6.29741486205862506537e7, 2.54890880573376359104e9,
+      -4.42979518059697779103e10, 3.18016297876567817986e11,
+      0.0, 0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    var sd = array<f32, 12>(
+      1.0, 2.81376268889994315696e2, 4.55847810806532581675e4,
+      5.1734388877009640073e6, 4.19320245898111231129e8, 2.2441179564534092094e10,
+      6.07366389490084914091e11,
+      0.0, 0.0, 0.0, 0.0, 0.0
+    );
+    return sgn * x * x2 * _gpu_polevl(t, sn, 6) / _gpu_polevl(t, sd, 7);
+  }
+
+  if (x < 36.0) {
+    let x2 = x * x;
+    let t = 3.14159265358979 * x2;
+    let u = 1.0 / (t * t);
+    var fn = array<f32, 12>(
+      4.21543555043677546506e-1, 1.43407919780758885261e-1,
+      1.15220955073585758835e-2, 3.450179397825740279e-4,
+      4.63613749287867322088e-6, 3.05568983790257605827e-8,
+      1.02304514164907233465e-10, 1.72010743268161828879e-13,
+      1.34283276233062758925e-16, 3.76329711269987889006e-20,
+      0.0, 0.0
+    );
+    var fd = array<f32, 12>(
+      1.0, 7.51586398353378947175e-1,
+      1.16888925859191382142e-1, 6.44051526508858611005e-3,
+      1.55934409164153020873e-4, 1.8462756734893054587e-6,
+      1.12699224763999035261e-8, 3.60140029589371370404e-11,
+      5.8875453362157841001e-14, 4.52001434074129701496e-17,
+      1.25443237090011264384e-20, 0.0
+    );
+    var gn = array<f32, 12>(
+      5.04442073643383265887e-1, 1.97102833525523411709e-1,
+      1.87648584092575249293e-2, 6.84079380915393090172e-4,
+      1.15138826111884280931e-5, 9.82852443688422223854e-8,
+      4.45344415861750144738e-10, 1.08268041139020870318e-12,
+      1.37555460633261799868e-15, 8.36354435630677421531e-19,
+      1.86958710162783235106e-22, 0.0
+    );
+    var gd = array<f32, 12>(
+      1.0, 1.47495759925128324529,
+      3.37748989120019970451e-1, 2.53603741420338795122e-2,
+      8.14679107184306179049e-4, 1.27545075667729118702e-5,
+      1.04314589657571990585e-7, 4.60680728515232032307e-10,
+      1.10273215066240270757e-12, 1.38796531259578871258e-15,
+      8.39158816283118707363e-19, 1.86958710162783236342e-22
+    );
+    let f = 1.0 - u * _gpu_polevl(u, fn, 10) / _gpu_polevl(u, fd, 11);
+    let g = (1.0 / t) * _gpu_polevl(u, gn, 11) / _gpu_polevl(u, gd, 12);
+    let z = 1.5707963267948966 * x2;
+    let c = cos(z);
+    let s = sin(z);
+    return sgn * (0.5 - (f * c + g * s) / (3.14159265358979 * x));
+  }
+
+  return sgn * 0.5;
+}
+`;
+var GPU_BESSELJ_PREAMBLE_GLSL = `
+float _gpu_factorial(int n) {
+  float f = 1.0;
+  for (int i = 2; i <= n; i++) f *= float(i);
+  return f;
+}
+
+float _gpu_besselJ_series(int n, float x) {
+  float halfX = x / 2.0;
+  float negQ = -(x * x) / 4.0;
+  float term = 1.0;
+  for (int i = 1; i <= n; i++) term /= float(i);
+  float s = term;
+  for (int k = 1; k <= 60; k++) {
+    term *= negQ / (float(k) * float(n + k));
+    s += term;
+    if (abs(term) < abs(s) * 1e-7) break;
+  }
+  return s * pow(halfX, float(n));
+}
+
+float _gpu_besselJ_asymptotic(int n, float x) {
+  float mu = 4.0 * float(n) * float(n);
+  float P = 1.0;
+  float Q = 0.0;
+  float ak = 1.0;
+  float e8x = 8.0 * x;
+  for (int k = 1; k <= 12; k++) {
+    float twokm1 = float(2 * k - 1);
+    ak *= mu - twokm1 * twokm1;
+    float denom = _gpu_factorial(k) * pow(e8x, float(k));
+    float contrib = ak / denom;
+    if (k == 1 || k == 3 || k == 5 || k == 7 || k == 9 || k == 11) {
+      // odd k: contributes to Q
+      if (((k - 1) / 2) % 2 == 0) Q += contrib;
+      else Q -= contrib;
+    } else {
+      // even k: contributes to P
+      if ((k / 2) % 2 == 1) P -= contrib;
+      else P += contrib;
+    }
+    if (abs(contrib) < 1e-7) break;
+  }
+  float chi = x - (float(n) / 2.0 + 0.25) * 3.14159265358979;
+  return sqrt(2.0 / (3.14159265358979 * x)) * (P * cos(chi) - Q * sin(chi));
+}
+
+float _gpu_besselJ(int n, float x) {
+  if (x == 0.0) return n == 0 ? 1.0 : 0.0;
+  float sgn = 1.0;
+  if (n < 0) {
+    n = -n;
+    if (n % 2 != 0) sgn = -1.0;
+  }
+  if (x < 0.0) {
+    x = -x;
+    if (n % 2 != 0) sgn *= -1.0;
+  }
+  if (x > 25.0 + float(n * n) / 2.0) return sgn * _gpu_besselJ_asymptotic(n, x);
+  if (x < 5.0 + float(n)) return sgn * _gpu_besselJ_series(n, x);
+  // Miller's backward recurrence
+  int M = max(n + 20, int(ceil(x)) + 30);
+  if (M > 200) return sgn * _gpu_besselJ_series(n, x);
+  float vals[201];
+  float jp1 = 0.0;
+  float jk = 1.0;
+  vals[M] = jk;
+  for (int k = M; k >= 1; k--) {
+    float jm1 = (2.0 * float(k) / x) * jk - jp1;
+    jp1 = jk;
+    jk = jm1;
+    vals[k - 1] = jk;
+  }
+  float norm = vals[0];
+  for (int k = 2; k <= M; k += 2) norm += 2.0 * vals[k];
+  return sgn * vals[n] / norm;
+}
+`;
+var GPU_BESSELJ_PREAMBLE_WGSL = `
+fn _gpu_factorial(n: i32) -> f32 {
+  var f: f32 = 1.0;
+  for (var i: i32 = 2; i <= n; i++) { f *= f32(i); }
+  return f;
+}
+
+fn _gpu_besselJ_series(n_in: i32, x: f32) -> f32 {
+  let halfX = x / 2.0;
+  let negQ = -(x * x) / 4.0;
+  var term: f32 = 1.0;
+  for (var i: i32 = 1; i <= n_in; i++) { term /= f32(i); }
+  var s = term;
+  for (var k: i32 = 1; k <= 60; k++) {
+    term *= negQ / (f32(k) * f32(n_in + k));
+    s += term;
+    if (abs(term) < abs(s) * 1e-7) { break; }
+  }
+  return s * pow(halfX, f32(n_in));
+}
+
+fn _gpu_besselJ_asymptotic(n_in: i32, x: f32) -> f32 {
+  let mu = 4.0 * f32(n_in) * f32(n_in);
+  var P: f32 = 1.0;
+  var Q: f32 = 0.0;
+  var ak: f32 = 1.0;
+  let e8x = 8.0 * x;
+  for (var k: i32 = 1; k <= 12; k++) {
+    let twokm1 = f32(2 * k - 1);
+    ak *= mu - twokm1 * twokm1;
+    let denom = _gpu_factorial(k) * pow(e8x, f32(k));
+    let contrib = ak / denom;
+    if (k == 1 || k == 3 || k == 5 || k == 7 || k == 9 || k == 11) {
+      if (((k - 1) / 2) % 2 == 0) { Q += contrib; }
+      else { Q -= contrib; }
+    } else {
+      if ((k / 2) % 2 == 1) { P -= contrib; }
+      else { P += contrib; }
+    }
+    if (abs(contrib) < 1e-7) { break; }
+  }
+  let chi = x - (f32(n_in) / 2.0 + 0.25) * 3.14159265358979;
+  return sqrt(2.0 / (3.14159265358979 * x)) * (P * cos(chi) - Q * sin(chi));
+}
+
+fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
+  var n = n_in;
+  var x = x_in;
+  if (x == 0.0) { return select(0.0, 1.0, n == 0); }
+  var sgn: f32 = 1.0;
+  if (n < 0) {
+    n = -n;
+    if (n % 2 != 0) { sgn = -1.0; }
+  }
+  if (x < 0.0) {
+    x = -x;
+    if (n % 2 != 0) { sgn *= -1.0; }
+  }
+  if (x > 25.0 + f32(n * n) / 2.0) { return sgn * _gpu_besselJ_asymptotic(n, x); }
+  if (x < 5.0 + f32(n)) { return sgn * _gpu_besselJ_series(n, x); }
+  // Miller's backward recurrence
+  var M = max(n + 20, i32(ceil(x)) + 30);
+  if (M > 200) { return sgn * _gpu_besselJ_series(n, x); }
+  var vals: array<f32, 201>;
+  var jp1: f32 = 0.0;
+  var jk: f32 = 1.0;
+  vals[M] = jk;
+  for (var k: i32 = M; k >= 1; k--) {
+    let jm1 = (2.0 * f32(k) / x) * jk - jp1;
+    jp1 = jk;
+    jk = jm1;
+    vals[k - 1] = jk;
+  }
+  var norm = vals[0];
+  for (var k2: i32 = 2; k2 <= M; k2 += 2) { norm += 2.0 * vals[k2]; }
+  return sgn * vals[n] / norm;
+}
+`;
 var GPU_FRACTAL_PREAMBLE_GLSL = `
 float _fractal_mandelbrot(vec2 c, int maxIter) {
   vec2 z = vec2(0.0, 0.0);
@@ -58268,6 +58894,16 @@ var GPUShaderTarget = class {
       indent: 0,
       ws: (s) => s ?? "",
       preamble: "",
+      declare: (name, typeHint) => {
+        const type2 = typeHint ?? (this.languageId === "wgsl" ? "f32" : "float");
+        return this.languageId === "wgsl" ? `var ${name}: ${type2}` : `${type2} ${name}`;
+      },
+      block: (stmts) => {
+        if (stmts.length === 0) return "";
+        const last = stmts.length - 1;
+        stmts[last] = `return ${stmts[last]}`;
+        return stmts.join(";\n");
+      },
       ...options
     };
   }
@@ -58302,6 +58938,18 @@ var GPUShaderTarget = class {
     preamble += buildComplexPreamble(code, this.languageId);
     if (code.includes("_gpu_gamma")) preamble += GPU_GAMMA_PREAMBLE;
     if (code.includes("_gpu_erf")) preamble += GPU_ERF_PREAMBLE;
+    if (code.includes("_gpu_heaviside"))
+      preamble += this.languageId === "wgsl" ? GPU_HEAVISIDE_PREAMBLE_WGSL : GPU_HEAVISIDE_PREAMBLE_GLSL;
+    if (code.includes("_gpu_sinc"))
+      preamble += this.languageId === "wgsl" ? GPU_SINC_PREAMBLE_WGSL : GPU_SINC_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnel"))
+      preamble += this.languageId === "wgsl" ? GPU_POLEVL_PREAMBLE_WGSL : GPU_POLEVL_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnelC"))
+      preamble += this.languageId === "wgsl" ? GPU_FRESNELC_PREAMBLE_WGSL : GPU_FRESNELC_PREAMBLE_GLSL;
+    if (code.includes("_gpu_fresnelS"))
+      preamble += this.languageId === "wgsl" ? GPU_FRESNELS_PREAMBLE_WGSL : GPU_FRESNELS_PREAMBLE_GLSL;
+    if (code.includes("_gpu_besselJ"))
+      preamble += this.languageId === "wgsl" ? GPU_BESSELJ_PREAMBLE_WGSL : GPU_BESSELJ_PREAMBLE_GLSL;
     if (code.includes("_fractal_")) {
       preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
     }
@@ -58350,6 +58998,12 @@ var GLSLTarget = class extends GPUShaderTarget {
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
     const params = parameters.map(([name, type2]) => `${type2} ${name}`).join(", ");
+    if (body.includes("\n")) {
+      const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
+      return `${returnType} ${functionName}(${params}) {
+${indented};
+}`;
+    }
     return `${returnType} ${functionName}(${params}) {
   return ${body};
 }`;
@@ -58453,6 +59107,12 @@ var WGSLTarget = class extends GPUShaderTarget {
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
     const params = parameters.map(([name, type2]) => `${name}: ${toWGSLType(type2)}`).join(", ");
+    if (body.includes("\n")) {
+      const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
+      return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
+${indented};
+}`;
+    }
     return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
   return ${body};
 }`;
@@ -67320,10 +67980,10 @@ var ComputeEngine = class _ComputeEngine {
 _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"
 };
 export {
   BaseCompiler,