@cortex-js/compute-engine 0.55.2 → 0.55.3

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.55.2 */
+/** Compile 0.55.3 */
     (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.Compile = {}));})(this, (function (exports) { 'use strict';
 var Compile = (() => {
   var __defProp = Object.defineProperty;
@@ -3969,12 +3969,6 @@ var Compile = (() => {
   function applicable(fn) {
     return makeLambda(fn) ?? ((xs) => fn.engine.function("Apply", [fn, ...xs]).evaluate());
   }
-  function applicableN1(fn) {
-    const lambda = makeLambda(fn);
-    const ce = fn.engine;
-    if (lambda) return (x) => lambda([ce.number(x)])?.re ?? NaN;
-    return (x) => ce.function("Apply", [fn, ce.number(x)]).evaluate().re;
-  }
 
   // src/compute-engine/collection-utils.ts
   function isFiniteIndexedCollection(col) {
@@ -14699,8 +14693,11 @@ ${lines.join("\n")}`;
         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])) {
+              const rhs = arg.ops[1];
+              if (_BaseCompiler.isComplexValued(rhs)) {
                 typeHints[local] = isWGSL ? "vec2f" : "vec2";
+              } else if (_BaseCompiler.isIntegerValued(rhs)) {
+                typeHints[local] = isWGSL ? "i32" : "int";
               }
               break;
             }
@@ -14905,12 +14902,9 @@ ${lines.join("\n")}`;
     /**
      * Determine at compile time whether an expression produces a complex value.
      *
-     * Rules:
-     * - Numbers: complex if im !== 0
-     * - Symbols: ImaginaryUnit is complex; others use expr.isReal
-     *   (undefined is treated as real -- assume-real policy)
-     * - Functions: Abs, Arg, Re, Im always return real.
-     *   All others: complex if any operand is complex.
+     * Uses the expression's declared type (from operator signatures) when
+     * available. Falls back to operand inspection for functions whose
+     * return type is unknown.
      */
     static isComplexValued(expr) {
       if (isNumber(expr)) return expr.im !== 0;
@@ -14921,13 +14915,24 @@ ${lines.join("\n")}`;
         return t.matches("complex") && !t.matches("real");
       }
       if (isFunction2(expr)) {
-        const op = expr.operator;
-        if (op === "Abs" || op === "Arg" || op === "Re" || op === "Im")
-          return false;
+        const t = expr.type;
+        if (t.matches("complex") && !t.matches("real")) return true;
+        if (t.matches("real")) return false;
         return expr.ops.some((arg) => _BaseCompiler.isComplexValued(arg));
       }
       return false;
     }
+    /** True if the expression is provably integer-typed. */
+    static isIntegerValued(expr) {
+      if (isNumber(expr)) return expr.im === 0 && Number.isInteger(expr.re);
+      const t = expr.type;
+      return t ? t.matches("integer") : false;
+    }
+    /** True if the expression is provably non-negative (sign ≥ 0). */
+    static isNonNegative(expr) {
+      if (isNumber(expr)) return expr.im === 0 && expr.re >= 0;
+      return expr.isNonNegative === true;
+    }
     /**
      * Generate a temporary variable name
      */
@@ -15099,20 +15104,113 @@ ${lines.join("\n")}`;
     } catch (e) {
       if (options?.fallback ?? true) {
         console.warn(
-          `Compilation fallback for "${expr.operator}": ${e.message}`
+          `Compilation fallback for "${expr.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
         );
+        const ce = expr.engine;
+        const fallbackRun = ((vars) => {
+          ce.pushScope();
+          try {
+            if (vars && typeof vars === "object") {
+              for (const [k, v] of Object.entries(vars))
+                ce.assign(k, v);
+            }
+            return expr.evaluate().re;
+          } finally {
+            ce.popScope();
+          }
+        });
         return {
           target: options?.to ?? "javascript",
           success: false,
           code: "",
           calling: "expression",
-          run: applicableN1(expr)
+          run: fallbackRun
         };
       }
       throw e;
     }
   }
 
+  // src/compute-engine/compilation/constant-folding.ts
+  function formatFloat(n) {
+    const str = n.toString();
+    if (!str.includes(".") && !str.includes("e") && !str.includes("E")) {
+      return `${str}.0`;
+    }
+    return str;
+  }
+  function tryGetConstant(expr) {
+    if (!isNumber(expr)) return void 0;
+    if (expr.im !== 0) return void 0;
+    const re = expr.re;
+    if (!isFinite(re)) return void 0;
+    return re;
+  }
+  var NUMERIC_LITERAL_RE = /^-?\d+(\.\d+)?$/;
+  function foldTerms(terms, identity, op) {
+    const identityValue = op === "+" ? 0 : 1;
+    let numericAcc = null;
+    const symbolic = [];
+    for (const term of terms) {
+      if (NUMERIC_LITERAL_RE.test(term)) {
+        const val = parseFloat(term);
+        if (op === "*" && val === 0) return "0.0";
+        if (numericAcc === null) {
+          numericAcc = val;
+        } else {
+          numericAcc = op === "+" ? numericAcc + val : numericAcc * val;
+        }
+      } else {
+        symbolic.push(term);
+      }
+    }
+    if (numericAcc !== null && numericAcc !== identityValue) {
+      symbolic.unshift(formatFloat(numericAcc));
+    }
+    if (symbolic.length === 0) {
+      if (numericAcc !== null) return formatFloat(numericAcc);
+      return identity;
+    }
+    if (symbolic.length === 1) return symbolic[0];
+    return symbolic.join(op === "+" ? " + " : " * ");
+  }
+  function tryGetComplexParts(expr, compile2) {
+    if (isSymbol2(expr, "ImaginaryUnit")) {
+      return { re: null, im: "1.0" };
+    }
+    if (isNumber(expr) && expr.im !== 0) {
+      const re = expr.re;
+      const im = expr.im;
+      return {
+        re: re !== 0 ? formatFloat(re) : null,
+        im: formatFloat(im)
+      };
+    }
+    if (isFunction2(expr, "Multiply")) {
+      const ops = expr.ops;
+      const iIndex = ops.findIndex(
+        (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+      );
+      if (iIndex >= 0) {
+        const iFactor = ops[iIndex];
+        const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+        const remaining = ops.filter((_, idx) => idx !== iIndex);
+        if (remaining.length === 0) {
+          return { re: null, im: formatFloat(iScale) };
+        }
+        const compiledFactors = remaining.map((r) => compile2(r));
+        if (iScale !== 1)
+          compiledFactors.unshift(formatFloat(iScale));
+        const imCode = foldTerms(compiledFactors, "1.0", "*");
+        return { re: null, im: imCode };
+      }
+    }
+    if (BaseCompiler.isComplexValued(expr)) {
+      return null;
+    }
+    return { re: compile2(expr), im: null };
+  }
+
   // node_modules/@arnog/colors/dist/index.mjs
   function gammaCorrect(channel) {
     const abs2 = Math.abs(channel);
@@ -19451,12 +19549,21 @@ ${lines.join("\n")}`;
     Abs: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.cabs(${compile2(args[0])})`;
+      if (BaseCompiler.isNonNegative(args[0])) return compile2(args[0]);
       return `Math.abs(${compile2(args[0])})`;
     },
     Add: (args, compile2) => {
       if (args.length === 1) return compile2(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return `(${args.map((x) => compile2(x)).join(" + ")})`;
+      if (!anyComplex) {
+        const constants = args.map(tryGetConstant);
+        if (constants.every((c) => c !== void 0))
+          return String(constants.reduce((a, b) => a + b, 0));
+        const nonZero = args.filter((a) => tryGetConstant(a) !== 0);
+        if (nonZero.length === 0) return "0";
+        if (nonZero.length === 1) return compile2(nonZero[0]);
+        return `(${nonZero.map((x) => compile2(x)).join(" + ")})`;
+      }
       const parts = args.map((a) => {
         const code = compile2(a);
         return { code, isComplex: BaseCompiler.isComplexValued(a) };
@@ -19513,7 +19620,10 @@ ${lines.join("\n")}`;
       return `Math.atan(${compile2(args[0])})`;
     },
     Artanh: "Math.atanh",
-    Ceil: "Math.ceil",
+    Ceil: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `Math.ceil(${compile2(args[0])})`;
+    },
     Chop: "_SYS.chop",
     Cos: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -19556,7 +19666,10 @@ ${lines.join("\n")}`;
         return `_SYS.cexp(${compile2(args[0])})`;
       return `Math.exp(${compile2(args[0])})`;
     },
-    Floor: "Math.floor",
+    Floor: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `Math.floor(${compile2(args[0])})`;
+    },
     Fract: ([x], compile2) => {
       if (x === null) throw new Error("Fract: no argument");
       return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile2(x));
@@ -19652,12 +19765,20 @@ ${lines.join("\n")}`;
       if (BaseCompiler.isComplexValued(base) || BaseCompiler.isComplexValued(exp3)) {
         return `_SYS.cpow(${compile2(base)}, ${compile2(exp3)})`;
       }
-      const expVal = exp3.re;
-      if (expVal === 0.5) return `Math.sqrt(${compile2(base)})`;
-      if (expVal === 1 / 3) return `Math.cbrt(${compile2(base)})`;
-      if (expVal === 1) return compile2(base);
-      if (expVal === -1) return `(1 / (${compile2(base)}))`;
-      if (expVal === -0.5) return `(1 / Math.sqrt(${compile2(base)}))`;
+      const bConst = tryGetConstant(base);
+      const eConst = tryGetConstant(exp3);
+      if (bConst !== void 0 && eConst !== void 0)
+        return String(Math.pow(bConst, eConst));
+      if (eConst === 0) return "1";
+      if (eConst === 1) return compile2(base);
+      if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+        const code = compile2(base);
+        return `(${code} * ${code})`;
+      }
+      if (eConst === -1) return `(1 / (${compile2(base)}))`;
+      if (eConst === 0.5) return `Math.sqrt(${compile2(base)})`;
+      if (eConst === 1 / 3) return `Math.cbrt(${compile2(base)})`;
+      if (eConst === -0.5) return `(1 / Math.sqrt(${compile2(base)}))`;
       return `Math.pow(${compile2(base)}, ${compile2(exp3)})`;
     },
     Range: (args, compile2) => {
@@ -19694,16 +19815,29 @@ ${lines.join("\n")}`;
     Root: ([arg, exp3], compile2) => {
       if (arg === null) throw new Error("Root: no argument");
       if (exp3 === null) return `Math.sqrt(${compile2(arg)})`;
-      if (exp3?.re === 2) return `Math.sqrt(${compile2(arg)})`;
-      if (exp3?.re === 3) return `Math.cbrt(${compile2(arg)})`;
-      if (!isNaN(exp3?.re)) return `Math.pow(${compile2(arg)},  ${1 / exp3.re})`;
+      const aConst = tryGetConstant(arg);
+      const nConst = tryGetConstant(exp3);
+      if (aConst !== void 0 && nConst !== void 0 && nConst !== 0)
+        return String(Math.pow(aConst, 1 / nConst));
+      if (nConst === 2) return `Math.sqrt(${compile2(arg)})`;
+      if (nConst === 3) return `Math.cbrt(${compile2(arg)})`;
+      if (nConst !== void 0) return `Math.pow(${compile2(arg)}, ${1 / nConst})`;
       return `Math.pow(${compile2(arg)}, 1 / (${compile2(exp3)}))`;
     },
     Random: "Math.random",
-    Round: "Math.round",
+    Round: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `Math.round(${compile2(args[0])})`;
+    },
     Square: (args, compile2) => {
       const arg = args[0];
       if (arg === null) throw new Error("Square: no argument");
+      const c = tryGetConstant(arg);
+      if (c !== void 0) return String(c * c);
+      if (isSymbol2(arg)) {
+        const code = compile2(arg);
+        return `(${code} * ${code})`;
+      }
       return `Math.pow(${compile2(arg)}, 2)`;
     },
     Sec: (args, compile2) => {
@@ -19736,6 +19870,8 @@ ${lines.join("\n")}`;
     Sqrt: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.csqrt(${compile2(args[0])})`;
+      const c = tryGetConstant(args[0]);
+      if (c !== void 0) return String(Math.sqrt(c));
       return `Math.sqrt(${compile2(args[0])})`;
     },
     Tan: (args, compile2) => {
@@ -19752,9 +19888,14 @@ ${lines.join("\n")}`;
       if (a === null || b === null) throw new Error("Mod: missing argument");
       const ca = compile2(a);
       const cb = compile2(b);
+      if (BaseCompiler.isIntegerValued(a) && BaseCompiler.isIntegerValued(b) && BaseCompiler.isNonNegative(a))
+        return `(${ca} % ${cb})`;
       return `((${ca} % ${cb}) + ${cb}) % ${cb}`;
     },
-    Truncate: "Math.trunc",
+    Truncate: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `Math.trunc(${compile2(args[0])})`;
+    },
     Remainder: ([a, b], compile2) => {
       if (a === null || b === null)
         throw new Error("Remainder: missing argument");
@@ -19762,25 +19903,20 @@ ${lines.join("\n")}`;
         a
       )} / ${compile2(b)}))`;
     },
-    // Arithmetic operators handled as functions for completeness
-    Subtract: ([a, b], compile2) => {
-      if (a === null || b === null) throw new Error("Subtract: missing argument");
-      const ac = BaseCompiler.isComplexValued(a);
-      const bc = BaseCompiler.isComplexValued(b);
-      if (!ac && !bc) return `(${compile2(a)} - ${compile2(b)})`;
-      const ca = compile2(a);
-      const cb = compile2(b);
-      const reA = ac ? `(${ca}).re` : ca;
-      const imA = ac ? `(${ca}).im` : "0";
-      const reB = bc ? `(${cb}).re` : cb;
-      const imB = bc ? `(${cb}).im` : "0";
-      return `({ re: ${reA} - ${reB}, im: ${imA} - ${imB} })`;
-    },
+    // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+    // The operator entry in JAVASCRIPT_OPERATORS handles any edge cases.
     Divide: ([a, b], compile2) => {
       if (a === null || b === null) throw new Error("Divide: missing argument");
       const ac = BaseCompiler.isComplexValued(a);
       const bc = BaseCompiler.isComplexValued(b);
-      if (!ac && !bc) return `(${compile2(a)} / ${compile2(b)})`;
+      if (!ac && !bc) {
+        const ca = tryGetConstant(a);
+        const cb = tryGetConstant(b);
+        if (ca !== void 0 && cb !== void 0 && cb !== 0)
+          return String(ca / cb);
+        if (cb === 1) return compile2(a);
+        return `(${compile2(a)} / ${compile2(b)})`;
+      }
       if (ac && bc) {
         return `(() => { const _a = ${compile2(a)}, _b = ${compile2(
           b
@@ -19797,13 +19933,26 @@ ${lines.join("\n")}`;
     },
     Negate: ([x], compile2) => {
       if (x === null) throw new Error("Negate: no argument");
-      if (!BaseCompiler.isComplexValued(x)) return `(-${compile2(x)})`;
+      if (!BaseCompiler.isComplexValued(x)) {
+        const c = tryGetConstant(x);
+        if (c !== void 0) return String(-c);
+        return `(-${compile2(x)})`;
+      }
       return `_SYS.cneg(${compile2(x)})`;
     },
     Multiply: (args, compile2) => {
       if (args.length === 1) return compile2(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return `(${args.map((x) => compile2(x)).join(" * ")})`;
+      if (!anyComplex) {
+        if (args.some((a) => tryGetConstant(a) === 0)) return "0";
+        const constants = args.map(tryGetConstant);
+        if (constants.every((c) => c !== void 0))
+          return String(constants.reduce((a, b) => a * b, 1));
+        const nonOne = args.filter((a) => tryGetConstant(a) !== 1);
+        if (nonOne.length === 0) return "1";
+        if (nonOne.length === 1) return compile2(nonOne[0]);
+        return `(${nonOne.map((x) => compile2(x)).join(" * ")})`;
+      }
       if (args.length === 2) {
         const ac = BaseCompiler.isComplexValued(args[0]);
         const bc = BaseCompiler.isComplexValued(args[1]);
@@ -19888,20 +20037,30 @@ ${lines.join("\n")}`;
     AiryAi: "_SYS.airyAi",
     AiryBi: "_SYS.airyBi",
     // Combinatorics
+    Mandelbrot: ([c, maxIter], compile2) => {
+      if (c === null || maxIter === null)
+        throw new Error("Mandelbrot: missing arguments");
+      return `_SYS.mandelbrot(${compile2(c)}, ${compile2(maxIter)})`;
+    },
+    Julia: ([z, c, maxIter], compile2) => {
+      if (z === null || c === null || maxIter === null)
+        throw new Error("Julia: missing arguments");
+      return `_SYS.julia(${compile2(z)}, ${compile2(c)}, ${compile2(maxIter)})`;
+    },
     Binomial: (args, compile2) => `_SYS.binomial(${compile2(args[0])}, ${compile2(args[1])})`,
     Fibonacci: "_SYS.fibonacci",
     // Complex-specific functions
-    Re: (args, compile2) => {
+    Real: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `(${compile2(args[0])}).re`;
       return compile2(args[0]);
     },
-    Im: (args, compile2) => {
+    Imaginary: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `(${compile2(args[0])}).im`;
       return "0";
     },
-    Arg: (args, compile2) => {
+    Argument: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.carg(${compile2(args[0])})`;
       return `(${compile2(args[0])} >= 0 ? 0 : Math.PI)`;
@@ -20237,6 +20396,41 @@ ${lines.join("\n")}`;
     sinc,
     fresnelS,
     fresnelC,
+    mandelbrot: (c, maxIter) => {
+      let zx = 0, zy = 0;
+      const cx = typeof c === "number" ? c : c.re;
+      const cy = typeof c === "number" ? 0 : c.im;
+      const n = Math.round(maxIter);
+      for (let i = 0; i < n; i++) {
+        const newZx = zx * zx - zy * zy + cx;
+        zy = 2 * zx * zy + cy;
+        zx = newZx;
+        const mag2 = zx * zx + zy * zy;
+        if (mag2 > 4) {
+          const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+          return Math.max(0, Math.min(1, smooth));
+        }
+      }
+      return 1;
+    },
+    julia: (z, c, maxIter) => {
+      let zx = typeof z === "number" ? z : z.re;
+      let zy = typeof z === "number" ? 0 : z.im;
+      const cx = typeof c === "number" ? c : c.re;
+      const cy = typeof c === "number" ? 0 : c.im;
+      const n = Math.round(maxIter);
+      for (let i = 0; i < n; i++) {
+        const newZx = zx * zx - zy * zy + cx;
+        zy = 2 * zx * zy + cy;
+        zx = newZx;
+        const mag2 = zx * zx + zy * zy;
+        if (mag2 > 4) {
+          const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+          return Math.max(0, Math.min(1, smooth));
+        }
+      }
+      return 1;
+    },
     binomial: choose,
     fibonacci,
     // Complex helpers
@@ -20582,6 +20776,7 @@ ${lines.join("\n")}`;
     Add: ["+", 11],
     Negate: ["-", 14],
     Subtract: ["-", 11],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["*", 12],
     Divide: ["/", 13],
     Equal: ["==", 8],
@@ -20597,6 +20792,12 @@ ${lines.join("\n")}`;
   function gpuVec2(target) {
     return target?.language === "wgsl" ? "vec2f" : "vec2";
   }
+  function compileIntArg(expr, compile2, target) {
+    const c = tryGetConstant(expr);
+    if (c !== void 0 && Number.isInteger(c)) return c.toString();
+    const intCast = target?.language === "wgsl" ? "i32" : "int";
+    return `${intCast}(${compile2(expr)})`;
+  }
   var GPU_UNROLL_LIMIT = 100;
   function compileGPUSumProduct(kind, args, _compile, target) {
     if (!args[0]) throw new Error(`${kind}: no body`);
@@ -20659,88 +20860,113 @@ ${lines.join("\n")}`;
       if (args.length === 0) return "0.0";
       if (args.length === 1) return compile2(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return args.map((x) => compile2(x)).join(" + ");
-      const v2 = gpuVec2(target);
-      return args.map((a) => {
-        const code = compile2(a);
-        return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-      }).join(" + ");
-    },
-    Multiply: (args, compile2, _target) => {
-      if (args.length === 0) return "1.0";
-      if (args.length === 1) return compile2(args[0]);
-      const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return args.map((x) => compile2(x)).join(" * ");
-      let result = compile2(args[0]);
-      let resultIsComplex = BaseCompiler.isComplexValued(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        const code = compile2(args[i]);
-        const argIsComplex = BaseCompiler.isComplexValued(args[i]);
-        if (!resultIsComplex && !argIsComplex) {
-          result = `(${result} * ${code})`;
-        } else if (resultIsComplex && !argIsComplex) {
-          result = `(${code} * ${result})`;
-        } else if (!resultIsComplex && argIsComplex) {
-          result = `(${result} * ${code})`;
-          resultIsComplex = true;
-        } else {
-          result = `_gpu_cmul(${result}, ${code})`;
-        }
+      if (!anyComplex) {
+        return foldTerms(
+          args.map((x) => compile2(x)),
+          "0.0",
+          "+"
+        );
       }
-      return result;
-    },
-    Subtract: (args, compile2, target) => {
-      if (args.length === 0) return "0.0";
+      const parts = args.map((a) => tryGetComplexParts(a, compile2));
+      if (parts.some((p) => p === null)) {
+        const v2 = gpuVec2(target);
+        return args.map((a) => {
+          const code = compile2(a);
+          return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
+        }).join(" + ");
+      }
+      const reParts = [];
+      const imParts = [];
+      for (const p of parts) {
+        if (p.re !== null) reParts.push(p.re);
+        if (p.im !== null) imParts.push(p.im);
+      }
+      const reSum = foldTerms(reParts, "0.0", "+");
+      const imSum = foldTerms(imParts, "0.0", "+");
+      return `${gpuVec2(target)}(${reSum}, ${imSum})`;
+    },
+    Multiply: (args, compile2, target) => {
+      if (args.length === 0) return "1.0";
       if (args.length === 1) return compile2(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
       if (!anyComplex) {
-        if (args.length === 2) return `${compile2(args[0])} - ${compile2(args[1])}`;
-        let result2 = compile2(args[0]);
-        for (let i = 1; i < args.length; i++) {
-          result2 = `${result2} - ${compile2(args[i])}`;
-        }
-        return result2;
-      }
-      const v2 = gpuVec2(target);
-      const promote = (a) => {
-        const code = compile2(a);
-        return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-      };
-      if (args.length === 2) return `${promote(args[0])} - ${promote(args[1])}`;
-      let result = promote(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `${result} - ${promote(args[i])}`;
+        return foldTerms(
+          args.map((x) => compile2(x)),
+          "1.0",
+          "*"
+        );
       }
+      const iIndex = args.findIndex(
+        (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+      );
+      if (iIndex >= 0) {
+        const iFactor = args[iIndex];
+        const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+        const realFactors = args.filter((_, i) => i !== iIndex);
+        const v2 = gpuVec2(target);
+        if (realFactors.length === 0)
+          return `${v2}(0.0, ${formatFloat(iScale)})`;
+        const factors = realFactors.map((f) => compile2(f));
+        if (iScale !== 1) factors.unshift(formatFloat(iScale));
+        const imCode = foldTerms(factors, "1.0", "*");
+        return `${v2}(0.0, ${imCode})`;
+      }
+      const realCodes = [];
+      const complexCodes = [];
+      for (const a of args) {
+        if (BaseCompiler.isComplexValued(a)) complexCodes.push(compile2(a));
+        else realCodes.push(compile2(a));
+      }
+      const scalarCode = foldTerms(realCodes, "1.0", "*");
+      let result = complexCodes[0];
+      for (let i = 1; i < complexCodes.length; i++) {
+        result = `_gpu_cmul(${result}, ${complexCodes[i]})`;
+      }
+      if (scalarCode !== "1.0") result = `(${scalarCode} * ${result})`;
       return result;
     },
+    // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+    // The operator entry in GPU_OPERATORS handles any edge cases.
     Divide: (args, compile2, target) => {
       if (args.length === 0) return "1.0";
       if (args.length === 1) return compile2(args[0]);
       const ac = BaseCompiler.isComplexValued(args[0]);
       const bc = args.length >= 2 && BaseCompiler.isComplexValued(args[1]);
       if (!ac && !bc) {
-        if (args.length === 2) return `${compile2(args[0])} / ${compile2(args[1])}`;
+        if (args.length === 2) {
+          const a = tryGetConstant(args[0]);
+          const b = tryGetConstant(args[1]);
+          if (a !== void 0 && b !== void 0 && b !== 0)
+            return formatFloat(a / b);
+          if (b === 1) return compile2(args[0]);
+          return `${compile2(args[0])} / ${compile2(args[1])}`;
+        }
         let result = compile2(args[0]);
-        for (let i = 1; i < args.length; i++) {
+        for (let i = 1; i < args.length; i++)
           result = `${result} / ${compile2(args[i])}`;
-        }
         return result;
       }
       if (ac && bc) return `_gpu_cdiv(${compile2(args[0])}, ${compile2(args[1])})`;
-      if (ac && !bc) {
-        return `(${compile2(args[0])} / ${compile2(args[1])})`;
-      }
+      if (ac && !bc) return `(${compile2(args[0])} / ${compile2(args[1])})`;
       const v2 = gpuVec2(target);
       return `_gpu_cdiv(${v2}(${compile2(args[0])}, 0.0), ${compile2(args[1])})`;
     },
-    Negate: ([x], compile2) => {
+    Negate: ([x], compile2, target) => {
       if (x === null) throw new Error("Negate: no argument");
+      const c = tryGetConstant(x);
+      if (c !== void 0) return formatFloat(-c);
+      if (isNumber(x) && x.im !== 0) {
+        return `${gpuVec2(target)}(${formatFloat(-x.re)}, ${formatFloat(-x.im)})`;
+      }
+      if (isSymbol2(x, "ImaginaryUnit"))
+        return `${gpuVec2(target)}(0.0, -1.0)`;
       return `(-${compile2(x)})`;
     },
     // Standard math functions with complex dispatch
     Abs: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `length(${compile2(args[0])})`;
+      if (BaseCompiler.isNonNegative(args[0])) return compile2(args[0]);
       return `abs(${compile2(args[0])})`;
     },
     Arccos: (args, compile2) => {
@@ -20758,7 +20984,10 @@ ${lines.join("\n")}`;
         return `_gpu_catan(${compile2(args[0])})`;
       return `atan(${compile2(args[0])})`;
     },
-    Ceil: "ceil",
+    Ceil: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `ceil(${compile2(args[0])})`;
+    },
     Clamp: "clamp",
     Cos: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -20772,7 +21001,10 @@ ${lines.join("\n")}`;
       return `exp(${compile2(args[0])})`;
     },
     Exp2: "exp2",
-    Floor: "floor",
+    Floor: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `floor(${compile2(args[0])})`;
+    },
     Fract: "fract",
     Ln: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -20794,10 +21026,25 @@ ${lines.join("\n")}`;
         const eCode = BaseCompiler.isComplexValued(exp3) ? compile2(exp3) : `${v2}(${compile2(exp3)}, 0.0)`;
         return `_gpu_cpow(${bCode}, ${eCode})`;
       }
+      const bConst = tryGetConstant(base);
+      const eConst = tryGetConstant(exp3);
+      if (bConst !== void 0 && eConst !== void 0)
+        return formatFloat(Math.pow(bConst, eConst));
+      if (eConst === 0) return "1.0";
+      if (eConst === 1) return compile2(base);
+      if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+        const code = compile2(base);
+        return `(${code} * ${code})`;
+      }
+      if (eConst === -1) return `(1.0 / ${compile2(base)})`;
+      if (eConst === 0.5) return `sqrt(${compile2(base)})`;
       return `pow(${compile2(base)}, ${compile2(exp3)})`;
     },
     Radians: "radians",
-    Round: "round",
+    Round: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `round(${compile2(args[0])})`;
+    },
     Sign: "sign",
     Sin: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -20808,6 +21055,8 @@ ${lines.join("\n")}`;
     Sqrt: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_gpu_csqrt(${compile2(args[0])})`;
+      const c = tryGetConstant(args[0]);
+      if (c !== void 0) return formatFloat(Math.sqrt(c));
       return `sqrt(${compile2(args[0])})`;
     },
     Step: "step",
@@ -20816,17 +21065,20 @@ ${lines.join("\n")}`;
         return `_gpu_ctan(${compile2(args[0])})`;
       return `tan(${compile2(args[0])})`;
     },
-    Truncate: "trunc",
+    Truncate: (args, compile2) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
+      return `trunc(${compile2(args[0])})`;
+    },
     // Complex-specific functions
-    Re: (args, compile2) => {
+    Real: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0])) return `(${compile2(args[0])}).x`;
       return compile2(args[0]);
     },
-    Im: (args, compile2) => {
+    Imaginary: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0])) return `(${compile2(args[0])}).y`;
       return "0.0";
     },
-    Arg: (args, compile2) => {
+    Argument: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0])) {
         const code = compile2(args[0]);
         return `atan(${code}.y, ${code}.x)`;
@@ -21041,13 +21293,20 @@ ${lines.join("\n")}`;
     },
     Square: ([x], compile2) => {
       if (x === null) throw new Error("Square: no argument");
-      const arg = compile2(x);
-      return `(${arg} * ${arg})`;
+      if (isSymbol2(x) || isNumber(x)) {
+        const arg = compile2(x);
+        return `(${arg} * ${arg})`;
+      }
+      return `pow(${compile2(x)}, 2.0)`;
     },
     Root: ([x, n], compile2) => {
       if (x === null) throw new Error("Root: no argument");
       if (n === null || n === void 0) return `sqrt(${compile2(x)})`;
-      if (n?.re === 2) return `sqrt(${compile2(x)})`;
+      const nConst = tryGetConstant(n);
+      if (nConst === 2) return `sqrt(${compile2(x)})`;
+      const xConst = tryGetConstant(x);
+      if (xConst !== void 0 && nConst !== void 0)
+        return formatFloat(Math.pow(xConst, 1 / nConst));
       return `pow(${compile2(x)}, 1.0 / ${compile2(n)})`;
     },
     // Color functions (pure-math, GPU-compilable)
@@ -21089,18 +21348,14 @@ ${lines.join("\n")}`;
     Mandelbrot: ([c, maxIter], compile2, target) => {
       if (c === null || maxIter === null)
         throw new Error("Mandelbrot: missing arguments");
-      const intCast = target?.language === "wgsl" ? "i32" : "int";
-      return `_fractal_mandelbrot(${compile2(c)}, ${intCast}(${compile2(
-        maxIter
-      )}))`;
+      const iterCode = compileIntArg(maxIter, compile2, target);
+      return `_fractal_mandelbrot(${compile2(c)}, ${iterCode})`;
     },
     Julia: ([z, c, maxIter], compile2, target) => {
       if (z === null || c === null || maxIter === null)
         throw new Error("Julia: missing arguments");
-      const intCast = target?.language === "wgsl" ? "i32" : "int";
-      return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${intCast}(${compile2(
-        maxIter
-      )}))`;
+      const iterCode = compileIntArg(maxIter, compile2, target);
+      return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${iterCode})`;
     },
     // Vector/Matrix operations
     Cross: "cross",
@@ -22455,6 +22710,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     Negate: ["-", 14],
     // Unary operator
     Subtract: ["-", 11],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["*", 12],
     Divide: ["/", 13],
     Power: ["**", 15],
@@ -22482,16 +22738,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       if (args.length === 1) return compile2(args[0]);
       return args.map((x) => compile2(x)).join(" * ");
     },
-    Subtract: (args, compile2) => {
-      if (args.length === 0) return "0";
-      if (args.length === 1) return compile2(args[0]);
-      if (args.length === 2) return `${compile2(args[0])} - ${compile2(args[1])}`;
-      let result = compile2(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `${result} - ${compile2(args[i])}`;
-      }
-      return result;
-    },
+    // No Subtract handler — canonicalizes to Add+Negate before compilation.
     Divide: (args, compile2) => {
       if (args.length === 0) return "1";
       if (args.length === 1) return compile2(args[0]);
@@ -24156,6 +24403,7 @@ ${code}`;
     Add: ["_IA.add", 20],
     Negate: ["_IA.negate", 20],
     Subtract: ["_IA.sub", 20],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["_IA.mul", 20],
     Divide: ["_IA.div", 20],
     // Comparisons return BoolInterval
@@ -24180,17 +24428,7 @@ ${code}`;
       }
       return result;
     },
-    Subtract: (args, compile2) => {
-      if (args.length === 0) return "_IA.point(0)";
-      if (args.length === 1) return `_IA.negate(${compile2(args[0])})`;
-      if (args.length === 2)
-        return `_IA.sub(${compile2(args[0])}, ${compile2(args[1])})`;
-      let result = compile2(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `_IA.sub(${result}, ${compile2(args[i])})`;
-      }
-      return result;
-    },
+    // No Subtract handler — canonicalizes to Add+Negate before compilation.
     Multiply: (args, compile2) => {
       if (args.length === 0) return "_IA.point(1)";
       if (args.length === 1) return compile2(args[0]);
@@ -24573,7 +24811,7 @@ ${code}`;
   }
 
   // src/compile.ts
-  var version = "0.55.2";
+  var version = "0.55.3";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information: