@cortex-js/compute-engine 0.55.2 → 0.55.4

package/dist/core.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.2 */
+/** Compute Engine 0.55.4 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -17152,6 +17152,10 @@ function parseSymbolBody(parser) {
         parser.nextToken();
         continue;
       }
+      if (EMOJIS.test(id + token)) {
+        id += parser.nextToken();
+        continue;
+      }
       const next = parseSymbolToken(parser, { toplevel: false });
       if (next === null) return null;
       id += next;
@@ -17191,6 +17195,7 @@ function parseSymbolBody(parser) {
 function matchPrefixedSymbol(parser) {
   const prefix = SYMBOL_PREFIX[parser.peek] ?? null;
   if (prefix === null) return null;
+  const start = parser.index;
   parser.nextToken();
   if (parser.match("<{>")) {
     let body = "";
@@ -17211,17 +17216,48 @@ function matchPrefixedSymbol(parser) {
       parser.nextToken();
     }
     body += parseSymbolBody(parser);
-    if (body === null || !parser.match("<}>")) return null;
+    if (body === null || !parser.match("<}>")) {
+      parser.index = start;
+      return null;
+    }
     if (prefix === "_upright" && body.length > 1) return body;
     return body + prefix;
   }
+  parser.index = start;
   return null;
 }
 function parseInvalidSymbol(parser) {
   const start = parser.index;
   const id = matchPrefixedSymbol(parser);
-  if (id === null || isValidSymbol(id)) return null;
-  return parser.error(["invalid-symbol", { str: validateSymbol(id) }], start);
+  if (id !== null) {
+    if (isValidSymbol(id)) return null;
+    return parser.error(["invalid-symbol", { str: validateSymbol(id) }], start);
+  }
+  parser.index = start;
+  const prefix = SYMBOL_PREFIX[parser.peek] ?? null;
+  if (prefix === null) return null;
+  parser.nextToken();
+  if (!parser.match("<{>")) {
+    parser.index = start;
+    return null;
+  }
+  const bodyStart = parser.index;
+  let level = 0;
+  while (!parser.atEnd && !(level === 0 && parser.peek === "<}>")) {
+    if (parser.peek === "<{>") level += 1;
+    if (parser.peek === "<}>") level -= 1;
+    parser.nextToken();
+  }
+  const bodyText = parser.latex(bodyStart, parser.index);
+  if (isValidSymbol(bodyText)) {
+    parser.index = start;
+    return null;
+  }
+  parser.match("<}>");
+  return parser.error(
+    ["invalid-symbol", { str: validateSymbol(bodyText) }],
+    start
+  );
 }
 function parseSymbol(parser) {
   if (/^[a-zA-Z]$/.test(parser.peek) || /^\p{XIDS}$/u.test(parser.peek)) {
@@ -18176,18 +18212,12 @@ var _Parser = class __Parser {
           this.index = start;
           return false;
         }
-        const matchedToken = this.nextToken();
-        const useLatexCommand = matchedToken.startsWith("\\");
+        this.nextToken();
         if (hasBracedDelimiter && !this.match("<}>")) {
           this.index = start;
           return false;
         }
-        const closeTokens = DELIMITER_SHORTHAND2[close[0]] ?? [
-          close[0]
-        ];
-        const closeToken = closeTokens.find(
-          (t) => useLatexCommand ? t.startsWith("\\") : !t.startsWith("\\")
-        ) ?? closeTokens[0];
+        const closeToken = close[0];
         const closeBoundary3 = closePrefix ? hasBracedDelimiter ? [closePrefix, "<{>", closeToken, "<}>"] : [closePrefix, closeToken] : [closeToken];
         this.addBoundary(closeBoundary3);
         return true;
@@ -30684,8 +30714,7 @@ var ARITHMETIC_LIBRARY = [
       broadcastable: true,
       idempotent: true,
       complexity: 1200,
-      signature: "(number) -> number",
-      type: ([x]) => x.type,
+      signature: "(number) -> real",
       sgn: ([x]) => {
         if (x.isSame(0)) return "zero";
         if (isNumber(x)) return "positive";
@@ -39583,30 +39612,6 @@ var COOLWARM = [
   "#ae2036",
   "#b40426"
 ];
-var OCEAN_BALANCE = [
-  "#00441b",
-  "#006d5b",
-  "#1a8c7d",
-  "#2fa394",
-  "#4fb3a3",
-  "#6fc1b3",
-  "#8dcfc3",
-  "#a6dbd1",
-  "#bfe6de",
-  "#d7f0ea",
-  "#f7f7f7",
-  "#eeeeee",
-  "#ddd8e6",
-  "#c7bcda",
-  "#b3a0d0",
-  "#9f86c7",
-  "#8d6dbd",
-  "#7b56b1",
-  "#6a42a3",
-  "#5a3093",
-  "#4a1f82",
-  "#3b0f70"
-];
 var reversePalette = (palette) => palette.slice().reverse();
 var DIVERGING_PALETTES = {
   roma: ROMA,
@@ -39618,9 +39623,7 @@ var DIVERGING_PALETTES = {
   rdbu: RDBU,
   "rdbu-reversed": reversePalette(RDBU),
   coolwarm: COOLWARM,
-  "coolwarm-reversed": reversePalette(COOLWARM),
-  "ocean-balance": OCEAN_BALANCE,
-  "ocean-balance-reversed": reversePalette(OCEAN_BALANCE)
+  "coolwarm-reversed": reversePalette(COOLWARM)
 };
 var TURBO = [
   "#30123b",
@@ -41704,6 +41707,40 @@ var GREY = [
   "#eeeeee",
   "#ffffff"
 ];
+var CMOCEAN_PHASE = [
+  "#a8780d",
+  "#b3701b",
+  "#be6828",
+  "#c75f35",
+  "#cf5643",
+  "#d54b53",
+  "#db4066",
+  "#de357b",
+  "#df2a93",
+  "#dc25ad",
+  "#d529c4",
+  "#cc34d7",
+  "#c041e5",
+  "#b24fef",
+  "#a25cf3",
+  "#9168f4",
+  "#7d73f0",
+  "#687ce8",
+  "#5285dc",
+  "#3d8bcd",
+  "#2c90bc",
+  "#2093ac",
+  "#19959c",
+  "#12978c",
+  "#0c987c",
+  "#119a69",
+  "#249a52",
+  "#409839",
+  "#5e9420",
+  "#778d12",
+  "#8b860d",
+  "#9b7f0d"
+];
 var reversePalette2 = (palette) => palette.slice().reverse();
 var SEQUENTIAL_PALETTES = {
   turbo: TURBO,
@@ -41727,7 +41764,9 @@ var SEQUENTIAL_PALETTES = {
   "rocket-reversed": reversePalette2(ROCKET),
   mako: MAKO,
   // blue to teal
-  "mako-reversed": reversePalette2(MAKO)
+  "mako-reversed": reversePalette2(MAKO),
+  "cmocean-phase": CMOCEAN_PHASE,
+  "cmocean-phase-reversed": reversePalette2(CMOCEAN_PHASE)
 };
 
 // src/compute-engine/library/colors.ts
@@ -54236,8 +54275,11 @@ var BaseCompiler = class _BaseCompiler {
       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;
           }
@@ -54442,12 +54484,9 @@ var BaseCompiler = class _BaseCompiler {
   /**
    * 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(expr2) {
     if (isNumber(expr2)) return expr2.im !== 0;
@@ -54458,13 +54497,24 @@ var BaseCompiler = class _BaseCompiler {
       return t.matches("complex") && !t.matches("real");
     }
     if (isFunction2(expr2)) {
-      const op = expr2.operator;
-      if (op === "Abs" || op === "Arg" || op === "Re" || op === "Im")
-        return false;
+      const t = expr2.type;
+      if (t.matches("complex") && !t.matches("real")) return true;
+      if (t.matches("real")) return false;
       return expr2.ops.some((arg) => _BaseCompiler.isComplexValued(arg));
     }
     return false;
   }
+  /** True if the expression is provably integer-typed. */
+  static isIntegerValued(expr2) {
+    if (isNumber(expr2)) return expr2.im === 0 && Number.isInteger(expr2.re);
+    const t = expr2.type;
+    return t ? t.matches("integer") : false;
+  }
+  /** True if the expression is provably non-negative (sign ≥ 0). */
+  static isNonNegative(expr2) {
+    if (isNumber(expr2)) return expr2.im === 0 && expr2.re >= 0;
+    return expr2.isNonNegative === true;
+  }
   /**
    * Generate a temporary variable name
    */
@@ -54718,14 +54768,27 @@ function compile(expr2, options) {
   } catch (e) {
     if (options?.fallback ?? true) {
       console.warn(
-        `Compilation fallback for "${expr2.operator}": ${e.message}`
+        `Compilation fallback for "${expr2.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
       );
+      const ce = expr2.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 expr2.evaluate().re;
+        } finally {
+          ce.popScope();
+        }
+      });
       return {
         target: options?.to ?? "javascript",
         success: false,
         code: "",
         calling: "expression",
-        run: applicableN1(expr2)
+        run: fallbackRun
       };
     }
     throw e;
@@ -59875,6 +59938,86 @@ function resetCommonSymbols(commonSymbols) {
   for (const symbol2 of Object.values(commonSymbols)) symbol2?.reset();
 }
 
+// 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(expr2) {
+  if (!isNumber(expr2)) return void 0;
+  if (expr2.im !== 0) return void 0;
+  const re = expr2.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(expr2, compile3) {
+  if (isSymbol2(expr2, "ImaginaryUnit")) {
+    return { re: null, im: "1.0" };
+  }
+  if (isNumber(expr2) && expr2.im !== 0) {
+    const re = expr2.re;
+    const im = expr2.im;
+    return {
+      re: re !== 0 ? formatFloat(re) : null,
+      im: formatFloat(im)
+    };
+  }
+  if (isFunction2(expr2, "Multiply")) {
+    const ops = expr2.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) => compile3(r));
+      if (iScale !== 1)
+        compiledFactors.unshift(formatFloat(iScale));
+      const imCode = foldTerms(compiledFactors, "1.0", "*");
+      return { re: null, im: imCode };
+    }
+  }
+  if (BaseCompiler.isComplexValued(expr2)) {
+    return null;
+  }
+  return { re: compile3(expr2), im: null };
+}
+
 // src/compute-engine/compilation/javascript-target.ts
 var JAVASCRIPT_OPERATORS = {
   Add: ["+", 11],
@@ -59898,12 +60041,21 @@ var JAVASCRIPT_FUNCTIONS = {
   Abs: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.cabs(${compile3(args[0])})`;
+    if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
     return `Math.abs(${compile3(args[0])})`;
   },
   Add: (args, compile3) => {
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return `(${args.map((x) => compile3(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 compile3(nonZero[0]);
+      return `(${nonZero.map((x) => compile3(x)).join(" + ")})`;
+    }
     const parts = args.map((a) => {
       const code = compile3(a);
       return { code, isComplex: BaseCompiler.isComplexValued(a) };
@@ -59960,7 +60112,10 @@ var JAVASCRIPT_FUNCTIONS = {
     return `Math.atan(${compile3(args[0])})`;
   },
   Artanh: "Math.atanh",
-  Ceil: "Math.ceil",
+  Ceil: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.ceil(${compile3(args[0])})`;
+  },
   Chop: "_SYS.chop",
   Cos: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -60003,7 +60158,10 @@ var JAVASCRIPT_FUNCTIONS = {
       return `_SYS.cexp(${compile3(args[0])})`;
     return `Math.exp(${compile3(args[0])})`;
   },
-  Floor: "Math.floor",
+  Floor: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.floor(${compile3(args[0])})`;
+  },
   Fract: ([x], compile3) => {
     if (x === null) throw new Error("Fract: no argument");
     return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile3(x));
@@ -60099,12 +60257,20 @@ var JAVASCRIPT_FUNCTIONS = {
     if (BaseCompiler.isComplexValued(base) || BaseCompiler.isComplexValued(exp3)) {
       return `_SYS.cpow(${compile3(base)}, ${compile3(exp3)})`;
     }
-    const expVal = exp3.re;
-    if (expVal === 0.5) return `Math.sqrt(${compile3(base)})`;
-    if (expVal === 1 / 3) return `Math.cbrt(${compile3(base)})`;
-    if (expVal === 1) return compile3(base);
-    if (expVal === -1) return `(1 / (${compile3(base)}))`;
-    if (expVal === -0.5) return `(1 / Math.sqrt(${compile3(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 compile3(base);
+    if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+      const code = compile3(base);
+      return `(${code} * ${code})`;
+    }
+    if (eConst === -1) return `(1 / (${compile3(base)}))`;
+    if (eConst === 0.5) return `Math.sqrt(${compile3(base)})`;
+    if (eConst === 1 / 3) return `Math.cbrt(${compile3(base)})`;
+    if (eConst === -0.5) return `(1 / Math.sqrt(${compile3(base)}))`;
     return `Math.pow(${compile3(base)}, ${compile3(exp3)})`;
   },
   Range: (args, compile3) => {
@@ -60141,16 +60307,29 @@ var JAVASCRIPT_FUNCTIONS = {
   Root: ([arg, exp3], compile3) => {
     if (arg === null) throw new Error("Root: no argument");
     if (exp3 === null) return `Math.sqrt(${compile3(arg)})`;
-    if (exp3?.re === 2) return `Math.sqrt(${compile3(arg)})`;
-    if (exp3?.re === 3) return `Math.cbrt(${compile3(arg)})`;
-    if (!isNaN(exp3?.re)) return `Math.pow(${compile3(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(${compile3(arg)})`;
+    if (nConst === 3) return `Math.cbrt(${compile3(arg)})`;
+    if (nConst !== void 0) return `Math.pow(${compile3(arg)}, ${1 / nConst})`;
     return `Math.pow(${compile3(arg)}, 1 / (${compile3(exp3)}))`;
   },
   Random: "Math.random",
-  Round: "Math.round",
+  Round: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.round(${compile3(args[0])})`;
+  },
   Square: (args, compile3) => {
     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 = compile3(arg);
+      return `(${code} * ${code})`;
+    }
     return `Math.pow(${compile3(arg)}, 2)`;
   },
   Sec: (args, compile3) => {
@@ -60183,6 +60362,8 @@ var JAVASCRIPT_FUNCTIONS = {
   Sqrt: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.csqrt(${compile3(args[0])})`;
+    const c = tryGetConstant(args[0]);
+    if (c !== void 0) return String(Math.sqrt(c));
     return `Math.sqrt(${compile3(args[0])})`;
   },
   Tan: (args, compile3) => {
@@ -60199,9 +60380,14 @@ var JAVASCRIPT_FUNCTIONS = {
     if (a === null || b === null) throw new Error("Mod: missing argument");
     const ca = compile3(a);
     const cb = compile3(b);
+    if (BaseCompiler.isIntegerValued(a) && BaseCompiler.isIntegerValued(b) && BaseCompiler.isNonNegative(a))
+      return `(${ca} % ${cb})`;
     return `((${ca} % ${cb}) + ${cb}) % ${cb}`;
   },
-  Truncate: "Math.trunc",
+  Truncate: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.trunc(${compile3(args[0])})`;
+  },
   Remainder: ([a, b], compile3) => {
     if (a === null || b === null)
       throw new Error("Remainder: missing argument");
@@ -60209,25 +60395,20 @@ var JAVASCRIPT_FUNCTIONS = {
       a
     )} / ${compile3(b)}))`;
   },
-  // Arithmetic operators handled as functions for completeness
-  Subtract: ([a, b], compile3) => {
-    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 `(${compile3(a)} - ${compile3(b)})`;
-    const ca = compile3(a);
-    const cb = compile3(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], compile3) => {
     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 `(${compile3(a)} / ${compile3(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 compile3(a);
+      return `(${compile3(a)} / ${compile3(b)})`;
+    }
     if (ac && bc) {
       return `(() => { const _a = ${compile3(a)}, _b = ${compile3(
         b
@@ -60244,13 +60425,26 @@ var JAVASCRIPT_FUNCTIONS = {
   },
   Negate: ([x], compile3) => {
     if (x === null) throw new Error("Negate: no argument");
-    if (!BaseCompiler.isComplexValued(x)) return `(-${compile3(x)})`;
+    if (!BaseCompiler.isComplexValued(x)) {
+      const c = tryGetConstant(x);
+      if (c !== void 0) return String(-c);
+      return `(-${compile3(x)})`;
+    }
     return `_SYS.cneg(${compile3(x)})`;
   },
   Multiply: (args, compile3) => {
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return `(${args.map((x) => compile3(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 compile3(nonOne[0]);
+      return `(${nonOne.map((x) => compile3(x)).join(" * ")})`;
+    }
     if (args.length === 2) {
       const ac = BaseCompiler.isComplexValued(args[0]);
       const bc = BaseCompiler.isComplexValued(args[1]);
@@ -60335,20 +60529,30 @@ var JAVASCRIPT_FUNCTIONS = {
   AiryAi: "_SYS.airyAi",
   AiryBi: "_SYS.airyBi",
   // Combinatorics
+  Mandelbrot: ([c, maxIter], compile3) => {
+    if (c === null || maxIter === null)
+      throw new Error("Mandelbrot: missing arguments");
+    return `_SYS.mandelbrot(${compile3(c)}, ${compile3(maxIter)})`;
+  },
+  Julia: ([z, c, maxIter], compile3) => {
+    if (z === null || c === null || maxIter === null)
+      throw new Error("Julia: missing arguments");
+    return `_SYS.julia(${compile3(z)}, ${compile3(c)}, ${compile3(maxIter)})`;
+  },
   Binomial: (args, compile3) => `_SYS.binomial(${compile3(args[0])}, ${compile3(args[1])})`,
   Fibonacci: "_SYS.fibonacci",
   // Complex-specific functions
-  Re: (args, compile3) => {
+  Real: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `(${compile3(args[0])}).re`;
     return compile3(args[0]);
   },
-  Im: (args, compile3) => {
+  Imaginary: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `(${compile3(args[0])}).im`;
     return "0";
   },
-  Arg: (args, compile3) => {
+  Argument: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.carg(${compile3(args[0])})`;
     return `(${compile3(args[0])} >= 0 ? 0 : Math.PI)`;
@@ -60684,6 +60888,41 @@ var SYS_HELPERS = {
   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
@@ -61024,11 +61263,39 @@ function fibonacci(n) {
   return b;
 }
 
+// src/compute-engine/compilation/fractal-orbit.ts
+function computeReferenceOrbit(center, maxIter, precision) {
+  const prevPrecision = BigDecimal.precision;
+  BigDecimal.precision = precision;
+  try {
+    const cr = new BigDecimal(center[0]);
+    const ci = new BigDecimal(center[1]);
+    let zr = BigDecimal.ZERO;
+    let zi = BigDecimal.ZERO;
+    const ESCAPE = new BigDecimal(256);
+    const points = [];
+    for (let i = 0; i < maxIter; i++) {
+      points.push(zr.toNumber(), zi.toNumber());
+      const zr2 = zr.mul(zr).toPrecision(precision);
+      const zi2 = zi.mul(zi).toPrecision(precision);
+      const mag2 = zr2.add(zi2);
+      if (mag2.cmp(ESCAPE) > 0) break;
+      const new_zi = zr.mul(zi).toPrecision(precision).mul(2).add(ci);
+      zr = zr2.sub(zi2).add(cr);
+      zi = new_zi;
+    }
+    return new Float32Array(points);
+  } finally {
+    BigDecimal.precision = prevPrecision;
+  }
+}
+
 // src/compute-engine/compilation/gpu-target.ts
 var GPU_OPERATORS = {
   Add: ["+", 11],
   Negate: ["-", 14],
   Subtract: ["-", 11],
+  // Subtract canonicalizes to Add+Negate; kept as fallback
   Multiply: ["*", 12],
   Divide: ["/", 13],
   Equal: ["==", 8],
@@ -61044,6 +61311,12 @@ var GPU_OPERATORS = {
 function gpuVec2(target) {
   return target?.language === "wgsl" ? "vec2f" : "vec2";
 }
+function compileIntArg(expr2, compile3, target) {
+  const c = tryGetConstant(expr2);
+  if (c !== void 0 && Number.isInteger(c)) return c.toString();
+  const intCast = target?.language === "wgsl" ? "i32" : "int";
+  return `${intCast}(${compile3(expr2)})`;
+}
 var GPU_UNROLL_LIMIT = 100;
 function compileGPUSumProduct(kind, args, _compile2, target) {
   if (!args[0]) throw new Error(`${kind}: no body`);
@@ -61100,94 +61373,126 @@ function compileGPUSumProduct(kind, args, _compile2, target) {
   ];
   return lines.join("\n");
 }
+function selectFractalStrategy(target) {
+  const radius = target.hints?.viewport?.radius;
+  if (radius === void 0) return "single";
+  if (radius > 1e-6) return "single";
+  if (radius > 1e-14) return "double";
+  return "perturbation";
+}
 var GPU_FUNCTIONS = {
   // Variadic arithmetic (for function-call form, e.g., with vectors)
   Add: (args, compile3, target) => {
     if (args.length === 0) return "0.0";
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return args.map((x) => compile3(x)).join(" + ");
-    const v2 = gpuVec2(target);
-    return args.map((a) => {
-      const code = compile3(a);
-      return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-    }).join(" + ");
-  },
-  Multiply: (args, compile3, _target) => {
-    if (args.length === 0) return "1.0";
-    if (args.length === 1) return compile3(args[0]);
-    const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return args.map((x) => compile3(x)).join(" * ");
-    let result = compile3(args[0]);
-    let resultIsComplex = BaseCompiler.isComplexValued(args[0]);
-    for (let i = 1; i < args.length; i++) {
-      const code = compile3(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) => compile3(x)),
+        "0.0",
+        "+"
+      );
     }
-    return result;
-  },
-  Subtract: (args, compile3, target) => {
-    if (args.length === 0) return "0.0";
+    const parts = args.map((a) => tryGetComplexParts(a, compile3));
+    if (parts.some((p) => p === null)) {
+      const v2 = gpuVec2(target);
+      return args.map((a) => {
+        const code = compile3(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, compile3, target) => {
+    if (args.length === 0) return "1.0";
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
     if (!anyComplex) {
-      if (args.length === 2) return `${compile3(args[0])} - ${compile3(args[1])}`;
-      let result2 = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result2 = `${result2} - ${compile3(args[i])}`;
-      }
-      return result2;
-    }
-    const v2 = gpuVec2(target);
-    const promote = (a) => {
-      const code = compile3(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) => compile3(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) => compile3(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(compile3(a));
+      else realCodes.push(compile3(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, compile3, target) => {
     if (args.length === 0) return "1.0";
     if (args.length === 1) return compile3(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 `${compile3(args[0])} / ${compile3(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 compile3(args[0]);
+        return `${compile3(args[0])} / ${compile3(args[1])}`;
+      }
       let result = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
+      for (let i = 1; i < args.length; i++)
         result = `${result} / ${compile3(args[i])}`;
-      }
       return result;
     }
     if (ac && bc) return `_gpu_cdiv(${compile3(args[0])}, ${compile3(args[1])})`;
-    if (ac && !bc) {
-      return `(${compile3(args[0])} / ${compile3(args[1])})`;
-    }
+    if (ac && !bc) return `(${compile3(args[0])} / ${compile3(args[1])})`;
     const v2 = gpuVec2(target);
     return `_gpu_cdiv(${v2}(${compile3(args[0])}, 0.0), ${compile3(args[1])})`;
   },
-  Negate: ([x], compile3) => {
+  Negate: ([x], compile3, 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 `(-${compile3(x)})`;
   },
   // Standard math functions with complex dispatch
   Abs: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `length(${compile3(args[0])})`;
+    if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
     return `abs(${compile3(args[0])})`;
   },
   Arccos: (args, compile3) => {
@@ -61205,7 +61510,10 @@ var GPU_FUNCTIONS = {
       return `_gpu_catan(${compile3(args[0])})`;
     return `atan(${compile3(args[0])})`;
   },
-  Ceil: "ceil",
+  Ceil: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `ceil(${compile3(args[0])})`;
+  },
   Clamp: "clamp",
   Cos: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -61219,7 +61527,10 @@ var GPU_FUNCTIONS = {
     return `exp(${compile3(args[0])})`;
   },
   Exp2: "exp2",
-  Floor: "floor",
+  Floor: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `floor(${compile3(args[0])})`;
+  },
   Fract: "fract",
   Ln: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -61241,10 +61552,25 @@ var GPU_FUNCTIONS = {
       const eCode = BaseCompiler.isComplexValued(exp3) ? compile3(exp3) : `${v2}(${compile3(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 compile3(base);
+    if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+      const code = compile3(base);
+      return `(${code} * ${code})`;
+    }
+    if (eConst === -1) return `(1.0 / ${compile3(base)})`;
+    if (eConst === 0.5) return `sqrt(${compile3(base)})`;
     return `pow(${compile3(base)}, ${compile3(exp3)})`;
   },
   Radians: "radians",
-  Round: "round",
+  Round: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `round(${compile3(args[0])})`;
+  },
   Sign: "sign",
   Sin: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -61255,6 +61581,8 @@ var GPU_FUNCTIONS = {
   Sqrt: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_gpu_csqrt(${compile3(args[0])})`;
+    const c = tryGetConstant(args[0]);
+    if (c !== void 0) return formatFloat(Math.sqrt(c));
     return `sqrt(${compile3(args[0])})`;
   },
   Step: "step",
@@ -61263,17 +61591,20 @@ var GPU_FUNCTIONS = {
       return `_gpu_ctan(${compile3(args[0])})`;
     return `tan(${compile3(args[0])})`;
   },
-  Truncate: "trunc",
+  Truncate: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `trunc(${compile3(args[0])})`;
+  },
   // Complex-specific functions
-  Re: (args, compile3) => {
+  Real: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).x`;
     return compile3(args[0]);
   },
-  Im: (args, compile3) => {
+  Imaginary: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).y`;
     return "0.0";
   },
-  Arg: (args, compile3) => {
+  Argument: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) {
       const code = compile3(args[0]);
       return `atan(${code}.y, ${code}.x)`;
@@ -61488,13 +61819,20 @@ var GPU_FUNCTIONS = {
   },
   Square: ([x], compile3) => {
     if (x === null) throw new Error("Square: no argument");
-    const arg = compile3(x);
-    return `(${arg} * ${arg})`;
+    if (isSymbol2(x) || isNumber(x)) {
+      const arg = compile3(x);
+      return `(${arg} * ${arg})`;
+    }
+    return `pow(${compile3(x)}, 2.0)`;
   },
   Root: ([x, n], compile3) => {
     if (x === null) throw new Error("Root: no argument");
     if (n === null || n === void 0) return `sqrt(${compile3(x)})`;
-    if (n?.re === 2) return `sqrt(${compile3(x)})`;
+    const nConst = tryGetConstant(n);
+    if (nConst === 2) return `sqrt(${compile3(x)})`;
+    const xConst = tryGetConstant(x);
+    if (xConst !== void 0 && nConst !== void 0)
+      return formatFloat(Math.pow(xConst, 1 / nConst));
     return `pow(${compile3(x)}, 1.0 / ${compile3(n)})`;
   },
   // Color functions (pure-math, GPU-compilable)
@@ -61536,18 +61874,34 @@ var GPU_FUNCTIONS = {
   Mandelbrot: ([c, maxIter], compile3, target) => {
     if (c === null || maxIter === null)
       throw new Error("Mandelbrot: missing arguments");
-    const intCast = target?.language === "wgsl" ? "i32" : "int";
-    return `_fractal_mandelbrot(${compile3(c)}, ${intCast}(${compile3(
-      maxIter
-    )}))`;
+    const iterCode = compileIntArg(maxIter, compile3, target);
+    const strategy = selectFractalStrategy(target);
+    if (strategy === "double") {
+      const cCode = compile3(c);
+      return `_fractal_mandelbrot_dp(vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+    }
+    if (strategy === "perturbation") {
+      const cCode = compile3(c);
+      return `_fractal_mandelbrot_pt(${cCode}, ${iterCode})`;
+    }
+    return `_fractal_mandelbrot(${compile3(c)}, ${iterCode})`;
   },
   Julia: ([z, c, maxIter], compile3, target) => {
     if (z === null || c === null || maxIter === null)
       throw new Error("Julia: missing arguments");
-    const intCast = target?.language === "wgsl" ? "i32" : "int";
-    return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${intCast}(${compile3(
-      maxIter
-    )}))`;
+    const iterCode = compileIntArg(maxIter, compile3, target);
+    const strategy = selectFractalStrategy(target);
+    if (strategy === "double") {
+      const zCode = compile3(z);
+      const cCode = compile3(c);
+      return `_fractal_julia_dp(vec4(${zCode}, vec2(0.0)), vec4(${cCode}, vec2(0.0)), ${iterCode})`;
+    }
+    if (strategy === "perturbation") {
+      const zCode = compile3(z);
+      const cCode = compile3(c);
+      return `_fractal_julia_pt(${zCode}, ${cCode}, ${iterCode})`;
+    }
+    return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
   },
   // Vector/Matrix operations
   Cross: "cross",
@@ -62144,6 +62498,200 @@ fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
   return sgn * vals[n] / norm;
 }
 `;
+var GPU_DS_ARITHMETIC_PREAMBLE_GLSL = `
+// Split a float into high and low parts for exact multiplication
+vec2 ds_split(float a) {
+  const float SPLIT = 4097.0; // 2^12 + 1
+  float t = SPLIT * a;
+  float hi = t - (t - a);
+  float lo = a - hi;
+  return vec2(hi, lo);
+}
+
+// Create a double-single from a single float
+vec2 ds_from(float a) {
+  return vec2(a, 0.0);
+}
+
+// Error-free addition (Knuth TwoSum)
+vec2 ds_add(vec2 a, vec2 b) {
+  float s = a.x + b.x;
+  float v = s - a.x;
+  float e = (a.x - (s - v)) + (b.x - v);
+  float lo = (a.y + b.y) + e;
+  float hi = s + lo;
+  lo = lo - (hi - s);
+  return vec2(hi, lo);
+}
+
+// Double-single subtraction
+vec2 ds_sub(vec2 a, vec2 b) {
+  return ds_add(a, vec2(-b.x, -b.y));
+}
+
+// Error-free multiplication (Dekker TwoProduct)
+vec2 ds_mul(vec2 a, vec2 b) {
+  float p = a.x * b.x;
+  vec2 sa = ds_split(a.x);
+  vec2 sb = ds_split(b.x);
+  float err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
+  err += a.x * b.y + a.y * b.x;
+  float hi = p + err;
+  float lo = err - (hi - p);
+  return vec2(hi, lo);
+}
+
+// Optimized self-multiply
+vec2 ds_sqr(vec2 a) {
+  float p = a.x * a.x;
+  vec2 sa = ds_split(a.x);
+  float err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
+  err += 2.0 * a.x * a.y;
+  float hi = p + err;
+  float lo = err - (hi - p);
+  return vec2(hi, lo);
+}
+
+// Compare magnitude: returns -1, 0, or 1
+float ds_cmp(vec2 a, vec2 b) {
+  float d = a.x - b.x;
+  if (d != 0.0) return sign(d);
+  return sign(a.y - b.y);
+}
+`;
+var GPU_DS_ARITHMETIC_PREAMBLE_WGSL = `
+fn ds_split(a: f32) -> vec2f {
+  const SPLIT: f32 = 4097.0;
+  let t = SPLIT * a;
+  let hi = t - (t - a);
+  let lo = a - hi;
+  return vec2f(hi, lo);
+}
+
+fn ds_from(a: f32) -> vec2f {
+  return vec2f(a, 0.0);
+}
+
+fn ds_add(a: vec2f, b: vec2f) -> vec2f {
+  let s = a.x + b.x;
+  let v = s - a.x;
+  let e = (a.x - (s - v)) + (b.x - v);
+  let lo_t = (a.y + b.y) + e;
+  let hi = s + lo_t;
+  let lo = lo_t - (hi - s);
+  return vec2f(hi, lo);
+}
+
+fn ds_sub(a: vec2f, b: vec2f) -> vec2f {
+  return ds_add(a, vec2f(-b.x, -b.y));
+}
+
+fn ds_mul(a: vec2f, b: vec2f) -> vec2f {
+  let p = a.x * b.x;
+  let sa = ds_split(a.x);
+  let sb = ds_split(b.x);
+  var err = ((sa.x * sb.x - p) + sa.x * sb.y + sa.y * sb.x) + sa.y * sb.y;
+  err += a.x * b.y + a.y * b.x;
+  let hi = p + err;
+  let lo = err - (hi - p);
+  return vec2f(hi, lo);
+}
+
+fn ds_sqr(a: vec2f) -> vec2f {
+  let p = a.x * a.x;
+  let sa = ds_split(a.x);
+  var err = ((sa.x * sa.x - p) + 2.0 * sa.x * sa.y) + sa.y * sa.y;
+  err += 2.0 * a.x * a.y;
+  let hi = p + err;
+  let lo = err - (hi - p);
+  return vec2f(hi, lo);
+}
+
+fn ds_cmp(a: vec2f, b: vec2f) -> f32 {
+  let d = a.x - b.x;
+  if (d != 0.0) { return sign(d); }
+  return sign(a.y - b.y);
+}
+`;
+var GPU_FRACTAL_DP_PREAMBLE_GLSL = `
+float _fractal_mandelbrot_dp(vec4 c, int maxIter) {
+  // c = (re_hi, im_hi, re_lo, im_lo)
+  vec2 cr = vec2(c.x, c.z);  // real part as ds
+  vec2 ci = vec2(c.y, c.w);  // imag part as ds
+  vec2 zr = vec2(0.0, 0.0);
+  vec2 zi = vec2(0.0, 0.0);
+  for (int i = 0; i < maxIter; i++) {
+    vec2 zr2 = ds_sqr(zr);
+    vec2 zi2 = ds_sqr(zi);
+    // |z|^2 > 4.0 ?
+    vec2 mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0)
+      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
+    // z = z^2 + c
+    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci); // 2*zr*zi + ci
+    zr = ds_add(ds_sub(zr2, zi2), cr);                    // zr^2 - zi^2 + cr
+    zi = new_zi;
+  }
+  return 1.0;
+}
+
+float _fractal_julia_dp(vec4 z_in, vec4 c, int maxIter) {
+  vec2 zr = vec2(z_in.x, z_in.z);
+  vec2 zi = vec2(z_in.y, z_in.w);
+  vec2 cr = vec2(c.x, c.z);
+  vec2 ci = vec2(c.y, c.w);
+  for (int i = 0; i < maxIter; i++) {
+    vec2 zr2 = ds_sqr(zr);
+    vec2 zi2 = ds_sqr(zi);
+    vec2 mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0)
+      return clamp((float(i) - log2(log2(mag2.x)) + 4.0) / float(maxIter), 0.0, 1.0);
+    vec2 new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+`;
+var GPU_FRACTAL_DP_PREAMBLE_WGSL = `
+fn _fractal_mandelbrot_dp(c: vec4f, maxIter: i32) -> f32 {
+  let cr = vec2f(c.x, c.z);
+  let ci = vec2f(c.y, c.w);
+  var zr = vec2f(0.0, 0.0);
+  var zi = vec2f(0.0, 0.0);
+  for (var i: i32 = 0; i < maxIter; i++) {
+    let zr2 = ds_sqr(zr);
+    let zi2 = ds_sqr(zi);
+    let mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+
+fn _fractal_julia_dp(z_in: vec4f, c: vec4f, maxIter: i32) -> f32 {
+  var zr = vec2f(z_in.x, z_in.z);
+  var zi = vec2f(z_in.y, z_in.w);
+  let cr = vec2f(c.x, c.z);
+  let ci = vec2f(c.y, c.w);
+  for (var i: i32 = 0; i < maxIter; i++) {
+    let zr2 = ds_sqr(zr);
+    let zi2 = ds_sqr(zi);
+    let mag2 = ds_add(zr2, zi2);
+    if (mag2.x > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2.x)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let new_zi = ds_add(ds_mul(ds_add(zr, zr), zi), ci);
+    zr = ds_add(ds_sub(zr2, zi2), cr);
+    zi = new_zi;
+  }
+  return 1.0;
+}
+`;
 var GPU_FRACTAL_PREAMBLE_GLSL = `
 float _fractal_mandelbrot(vec2 c, int maxIter) {
   vec2 z = vec2(0.0, 0.0);
@@ -62187,6 +62735,188 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
   return 1.0;
 }
 `;
+var GPU_FRACTAL_PT_PREAMBLE_GLSL = `
+uniform sampler2D _refOrbit;
+uniform int _refOrbitLen;
+uniform int _refOrbitTexWidth;
+
+vec2 _pt_fetch_orbit(int i) {
+  int y = i / _refOrbitTexWidth;
+  int x = i - y * _refOrbitTexWidth;
+  return texelFetch(_refOrbit, ivec2(x, y), 0).rg;
+}
+
+float _fractal_mandelbrot_pt(vec2 delta_c, int maxIter) {
+  float dr = 0.0;
+  float di = 0.0;
+  int orbitLen = min(maxIter, _refOrbitLen);
+  for (int i = 0; i < orbitLen; i++) {
+    vec2 Zn = _pt_fetch_orbit(i);
+    // delta_{n+1} = 2*Z_n*delta_n + delta_n^2 + delta_c
+    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    // Full z = Z_{n+1} + delta for escape check
+    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
+    float zr = Zn1.x + dr;
+    float zi = Zn1.y + di;
+    float mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0)
+      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+    // Glitch detection: |delta|^2 > |Z|^2
+    float dmag2 = dr * dr + di * di;
+    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      // Rebase to absolute coordinates and continue with single-float
+      float abs_zr = Zn1.x + dr;
+      float abs_zi = Zn1.y + di;
+      // Reconstruct absolute c from reference + delta
+      // (Use ds_from for the concept, but single-float suffices for fallback)
+      float cx = abs_zr - dr + delta_c.x;
+      float cy = abs_zi - di + delta_c.y;
+      for (int j = i + 1; j < maxIter; j++) {
+        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
+        abs_zi = 2.0 * abs_zr * abs_zi + cy;
+        abs_zr = new_zr;
+        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
+        if (mag2 > 4.0)
+          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+
+float _fractal_julia_pt(vec2 z_delta, vec2 delta_c, int maxIter) {
+  float dr = z_delta.x;
+  float di = z_delta.y;
+  int orbitLen = min(maxIter, _refOrbitLen);
+  for (int i = 0; i < orbitLen; i++) {
+    vec2 Zn = _pt_fetch_orbit(i);
+    float new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    float new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    vec2 Zn1 = (i + 1 < orbitLen) ? _pt_fetch_orbit(i + 1) : vec2(0.0);
+    float zr = Zn1.x + dr;
+    float zi = Zn1.y + di;
+    float mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0)
+      return clamp((float(i) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+    float dmag2 = dr * dr + di * di;
+    float Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      float abs_zr = Zn1.x + dr;
+      float abs_zi = Zn1.y + di;
+      float cx = delta_c.x;
+      float cy = delta_c.y;
+      for (int j = i + 1; j < maxIter; j++) {
+        float new_zr = abs_zr * abs_zr - abs_zi * abs_zi + cx;
+        abs_zi = 2.0 * abs_zr * abs_zi + cy;
+        abs_zr = new_zr;
+        mag2 = abs_zr * abs_zr + abs_zi * abs_zi;
+        if (mag2 > 4.0)
+          return clamp((float(j) - log2(log2(mag2)) + 4.0) / float(maxIter), 0.0, 1.0);
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+`;
+var GPU_FRACTAL_PT_PREAMBLE_WGSL = `
+@group(0) @binding(1) var _refOrbit: texture_2d<f32>;
+var<uniform> _refOrbitLen: i32;
+var<uniform> _refOrbitTexWidth: i32;
+
+fn _pt_fetch_orbit(i: i32) -> vec2f {
+  let y = i / _refOrbitTexWidth;
+  let x = i - y * _refOrbitTexWidth;
+  return textureLoad(_refOrbit, vec2i(x, y), 0).rg;
+}
+
+fn _fractal_mandelbrot_pt(delta_c: vec2f, maxIter: i32) -> f32 {
+  var dr: f32 = 0.0;
+  var di: f32 = 0.0;
+  let orbitLen = min(maxIter, _refOrbitLen);
+  for (var i: i32 = 0; i < orbitLen; i++) {
+    let Zn = _pt_fetch_orbit(i);
+    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    var Zn1 = vec2f(0.0);
+    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
+    let zr = Zn1.x + dr;
+    let zi = Zn1.y + di;
+    var mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let dmag2 = dr * dr + di * di;
+    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      var f_zr = Zn1.x + dr;
+      var f_zi = Zn1.y + di;
+      let cx = delta_c.x;
+      let cy = delta_c.y;
+      for (var j: i32 = i + 1; j < maxIter; j++) {
+        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
+        f_zi = 2.0 * f_zr * f_zi + cy;
+        f_zr = t_zr;
+        mag2 = f_zr * f_zr + f_zi * f_zi;
+        if (mag2 > 4.0) {
+          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+        }
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+
+fn _fractal_julia_pt(z_delta: vec2f, delta_c: vec2f, maxIter: i32) -> f32 {
+  var dr = z_delta.x;
+  var di = z_delta.y;
+  let orbitLen = min(maxIter, _refOrbitLen);
+  for (var i: i32 = 0; i < orbitLen; i++) {
+    let Zn = _pt_fetch_orbit(i);
+    let new_dr = 2.0 * (Zn.x * dr - Zn.y * di) + dr * dr - di * di + delta_c.x;
+    let new_di = 2.0 * (Zn.x * di + Zn.y * dr) + 2.0 * dr * di + delta_c.y;
+    dr = new_dr;
+    di = new_di;
+    var Zn1 = vec2f(0.0);
+    if (i + 1 < orbitLen) { Zn1 = _pt_fetch_orbit(i + 1); }
+    let zr = Zn1.x + dr;
+    let zi = Zn1.y + di;
+    var mag2 = zr * zr + zi * zi;
+    if (mag2 > 4.0) {
+      return clamp((f32(i) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+    }
+    let dmag2 = dr * dr + di * di;
+    let Zmag2 = Zn.x * Zn.x + Zn.y * Zn.y;
+    if (dmag2 > Zmag2 && Zmag2 > 0.0) {
+      var f_zr = Zn1.x + dr;
+      var f_zi = Zn1.y + di;
+      let cx = delta_c.x;
+      let cy = delta_c.y;
+      for (var j: i32 = i + 1; j < maxIter; j++) {
+        let t_zr = f_zr * f_zr - f_zi * f_zi + cx;
+        f_zi = 2.0 * f_zr * f_zi + cy;
+        f_zr = t_zr;
+        mag2 = f_zr * f_zr + f_zi * f_zi;
+        if (mag2 > 4.0) {
+          return clamp((f32(j) - log2(log2(mag2)) + 4.0) / f32(maxIter), 0.0, 1.0);
+        }
+      }
+      return 1.0;
+    }
+  }
+  return 1.0;
+}
+`;
 var GPU_COLOR_PREAMBLE_GLSL = `
 float _gpu_srgb_to_linear(float c) {
   if (c <= 0.04045) return c / 12.92;
@@ -62625,6 +63355,7 @@ var GPUShaderTarget = class {
     const constants = this.getConstants();
     const v2 = this.languageId === "wgsl" ? "vec2f" : "vec2";
     const target = this.createTarget({
+      hints: options.hints,
       functions: (id) => {
         if (userFunctions && id in userFunctions) {
           const fn = userFunctions[id];
@@ -62663,12 +63394,65 @@ var GPUShaderTarget = class {
     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;
+      if (code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) {
+        preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PT_PREAMBLE_WGSL : GPU_FRACTAL_PT_PREAMBLE_GLSL;
+      } else if (code.includes("_fractal_mandelbrot_dp") || code.includes("_fractal_julia_dp")) {
+        preamble += this.languageId === "wgsl" ? GPU_DS_ARITHMETIC_PREAMBLE_WGSL : GPU_DS_ARITHMETIC_PREAMBLE_GLSL;
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_DP_PREAMBLE_WGSL : GPU_FRACTAL_DP_PREAMBLE_GLSL;
+      } else {
+        preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
+      }
     }
     if (code.includes("_gpu_srgb_to") || code.includes("_gpu_oklab") || code.includes("_gpu_oklch") || code.includes("_gpu_color_mix") || code.includes("_gpu_apca")) {
       preamble += this.languageId === "wgsl" ? GPU_COLOR_PREAMBLE_WGSL : GPU_COLOR_PREAMBLE_GLSL;
     }
     if (preamble) result.preamble = preamble;
+    if (code.includes("_fractal_") && options.hints?.viewport) {
+      const strategy = selectFractalStrategy(target);
+      const radius = options.hints.viewport.radius;
+      switch (strategy) {
+        case "single":
+          result.staleWhen = { radiusBelow: 1e-6 };
+          break;
+        case "double":
+          result.staleWhen = { radiusBelow: 1e-14, radiusAbove: 1e-5 };
+          break;
+        case "perturbation":
+          result.staleWhen = {
+            radiusAbove: 1e-5,
+            radiusBelow: radius * 0.01,
+            centerDistance: radius * 2
+          };
+          break;
+      }
+    }
+    if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
+      const viewport = options.hints.viewport;
+      const digits = Math.max(50, Math.ceil(-Math.log10(viewport.radius)) + 10);
+      const maxIter = 1e3;
+      const orbit = computeReferenceOrbit(
+        viewport.center,
+        maxIter,
+        digits
+      );
+      const orbitLen = orbit.length / 2;
+      const texWidth = Math.min(orbitLen, 4096);
+      const texHeight = Math.ceil(orbitLen / texWidth);
+      result.textures = {
+        _refOrbit: {
+          data: orbit,
+          width: texWidth,
+          height: texHeight,
+          format: "rg32f"
+        }
+      };
+      result.uniforms = {
+        ...result.uniforms,
+        _refOrbitLen: orbitLen,
+        _refOrbitTexWidth: texWidth
+      };
+    }
     return result;
   }
   compileToSource(expr2, _options = {}) {
@@ -64179,6 +64963,7 @@ var INTERVAL_JAVASCRIPT_OPERATORS = {
   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
@@ -64203,17 +64988,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     }
     return result;
   },
-  Subtract: (args, compile3) => {
-    if (args.length === 0) return "_IA.point(0)";
-    if (args.length === 1) return `_IA.negate(${compile3(args[0])})`;
-    if (args.length === 2)
-      return `_IA.sub(${compile3(args[0])}, ${compile3(args[1])})`;
-    let result = compile3(args[0]);
-    for (let i = 1; i < args.length; i++) {
-      result = `_IA.sub(${result}, ${compile3(args[i])})`;
-    }
-    return result;
-  },
+  // No Subtract handler — canonicalizes to Add+Negate before compilation.
   Multiply: (args, compile3) => {
     if (args.length === 0) return "_IA.point(1)";
     if (args.length === 1) return compile3(args[0]);
@@ -67187,7 +67962,9 @@ var ComputeEngine = class _ComputeEngine {
       }
       return new ExactNumericValue(value, makeNumericValue);
     }
-    throw Error("Unexpected value");
+    throw Error(
+      `Unexpected value: ${typeof value === "object" ? JSON.stringify(value) : String(value)}`
+    );
   }
   /**
    * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
@@ -67658,7 +68435,7 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/core.ts
-var version = "0.55.2";
+var version = "0.55.4";
 export {
   ComputeEngine,
   N,