@cortex-js/compute-engine 0.55.4 → 0.55.6

package/dist/core.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.4 */
+/** Compute Engine 0.55.6 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -11037,10 +11037,6 @@ var DEFINITIONS_CORE = [
   // Lagrange notation
   {
     name: "Derivative",
-    // @todo: Leibniz notation: {% latex " \\frac{d^n}{dx^n} f(x)" %}
-    // @todo: Euler modified notation: This notation is used by Mathematica. The Euler notation uses `D` instead of
-    // `\partial`: `\partial_{x} f`,  `\partial_{x,y} f`
-    // Newton notation (\dot{v}, \ddot{v}) is implemented below
     serialize: (serializer, expr2) => {
       const degree = machineValue(operand(expr2, 2)) ?? 1;
       const base = serializer.serialize(operand(expr2, 1));
@@ -12078,14 +12074,18 @@ var DEFINITIONS_SETS = [
       return ["Complement", lhs];
     }
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
   },
   {
     name: "Complement",
     latexTrigger: ["^", "<{>", "\\complement", "<}>"],
-    kind: "postfix"
+    kind: "postfix",
     // precedence: 240,
-    // @todo: serialize for the multiple argument case
+    serialize: (serializer, expr2) => {
+      return joinLatex([
+        serializer.serialize(operand(expr2, 1)),
+        "^\\complement"
+      ]);
+    }
   },
   {
     name: "Intersection",
@@ -12172,7 +12172,6 @@ var DEFINITIONS_SETS = [
   // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: "Multiple",
-    // @todo: parse
     serialize: serializeSet
   },
   {
@@ -12181,14 +12180,28 @@ var DEFINITIONS_SETS = [
     kind: "infix",
     precedence: 350
   },
+  // \mid as a separator/operator (used in set-builder notation: {x \mid x > 0})
+  // Low precedence so it binds loosely — everything on each side is parsed first
+  {
+    name: "Divides",
+    latexTrigger: ["\\mid"],
+    kind: "infix",
+    precedence: 160
+  },
   {
     name: "Set",
     kind: "matchfix",
     openTrigger: "{",
     closeTrigger: "}",
-    // @todo: the set syntax can also include conditions...
     parse: (_parser, body) => {
       if (isEmptySequence(body)) return "EmptySet";
+      const h = operator(body);
+      if (h === "Divides" || h === "Colon") {
+        const expr2 = operand(body, 1);
+        const condition = operand(body, 2);
+        if (expr2 !== null && condition !== null)
+          return ["Set", expr2, ["Condition", condition]];
+      }
       if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
         body = operand(body, 1);
       }
@@ -12196,6 +12209,17 @@ var DEFINITIONS_SETS = [
       return ["Set", ...operands(body)];
     },
     serialize: (serializer, expr2) => {
+      if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
+        const condition = operand(expr2, 2);
+        return joinLatex([
+          "\\lbrace",
+          serializer.serialize(operand(expr2, 1)),
+          "\\mid",
+          // Serialize the inner expression of the Condition wrapper
+          serializer.serialize(operand(condition, 1)),
+          "\\rbrace"
+        ]);
+      }
       return joinLatex([
         "\\lbrace",
         operands(expr2).map((x) => serializer.serialize(x)).join(", "),
@@ -12362,23 +12386,6 @@ function serializeSet(serializer, expr2) {
   if (expr2 === null) return "";
   const h = operator(expr2);
   if (!h) return "";
-  if (h === "Set") {
-    if (nops(expr2) === 0) return "\\emptyset";
-    if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
-      return joinLatex([
-        "\\left\\lbrace",
-        serializer.serialize(operand(expr2, 1)),
-        "\\middle\\mid",
-        serializer.serialize(operand(expr2, 2)),
-        "\\right\\rbrace"
-      ]);
-    }
-    return joinLatex([
-      "\\left\\lbrace",
-      ...operands(expr2).map((x) => serializer.serialize(x) + " ,"),
-      "\\right\\rbrace"
-    ]);
-  }
   if (h === "Multiple") {
   }
   if (h === "Range") {
@@ -13526,11 +13533,13 @@ var DEFINITIONS_ARITHMETIC = [
       if (!parser.match("_")) return null;
       const base = parser.parseGroup();
       if (operator(base) !== "To") return null;
-      const expr2 = parser.parseArguments("implicit");
+      const expr2 = parser.parseExpression({
+        minPrec: MULTIPLICATION_PRECEDENCE
+      });
       if (!expr2) return null;
       return [
         "Limit",
-        ["Function", expr2[0], operand(base, 1)],
+        ["Function", expr2, operand(base, 1)],
         operand(base, 2)
       ];
     },
@@ -15827,12 +15836,52 @@ var DEFINITIONS_UNITS = [
 ];
 
 // src/compute-engine/latex-syntax/dictionary/definitions-other.ts
+var TEX_UNITS = [
+  "pt",
+  "em",
+  "mu",
+  "ex",
+  "mm",
+  "cm",
+  "in",
+  "bp",
+  "sp",
+  "dd",
+  "cc",
+  "pc",
+  "nc",
+  "nd"
+];
+function skipTexDimension(parser) {
+  parser.skipSpace();
+  if (parser.peek === "-" || parser.peek === "+") parser.nextToken();
+  while (/^[\d.]$/.test(parser.peek)) parser.nextToken();
+  for (const unit of TEX_UNITS) {
+    if (parser.matchAll([...unit])) return;
+  }
+}
 function parseSingleArg(cmd) {
   return (parser) => {
     const arg = parser.parseGroup();
     return arg === null ? [cmd] : [cmd, arg];
   };
 }
+function parseMathStyleSwitch(mathStyle) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { mathStyle } }];
+    return "Nothing";
+  };
+}
+function parseSizeSwitch(size) {
+  return (parser) => {
+    const body = parser.parseExpression();
+    if (body !== null && !isEmptySequence(body))
+      return ["Annotated", body, { dict: { size } }];
+    return "Nothing";
+  };
+}
 var DEFINITIONS_OTHERS = [
   {
     name: "Overscript",
@@ -16072,80 +16121,71 @@ var DEFINITIONS_OTHERS = [
   },
   {
     latexTrigger: ["\\displaystyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("normal")
   },
   {
     latexTrigger: ["\\textstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("compact")
   },
   {
     latexTrigger: ["\\scriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("script")
   },
   {
     latexTrigger: ["\\scriptscriptstyle"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseMathStyleSwitch("scriptscript")
   },
   {
     latexTrigger: ["\\color"],
     parse: (parser) => {
-      parser.parseGroup();
+      const color = parser.parseStringGroup();
+      if (color !== null) {
+        const body = parser.parseExpression();
+        if (body !== null && !isEmptySequence(body))
+          return ["Annotated", body, { dict: { color } }];
+      }
       return "Nothing";
     }
   },
   {
     latexTrigger: ["\\tiny"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(1)
   },
   {
     latexTrigger: ["\\scriptsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(2)
   },
   {
     latexTrigger: ["\\footnotesize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(3)
   },
   {
     latexTrigger: ["\\small"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(4)
   },
   {
     latexTrigger: ["\\normalsize"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(5)
   },
   {
     latexTrigger: ["\\large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(6)
   },
   {
     latexTrigger: ["\\Large"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(7)
   },
   {
     latexTrigger: ["\\LARGE"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(8)
   },
   {
     latexTrigger: ["\\huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(9)
   },
   {
     latexTrigger: ["\\Huge"],
-    parse: () => "Nothing"
-    // @todo: parse as ['Annotated'...]
+    parse: parseSizeSwitch(10)
   },
   {
     name: "Annotated",
@@ -16157,6 +16197,10 @@ var DEFINITIONS_OTHERS = [
         result = joinLatex(["{\\displaystyle", result, "}"]);
       else if (dict.dict.mathStyle === "compact")
         result = joinLatex(["{\\textstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "script")
+        result = joinLatex(["{\\scriptstyle", result, "}"]);
+      else if (dict.dict.mathStyle === "scriptscript")
+        result = joinLatex(["{\\scriptscriptstyle", result, "}"]);
       const v = dict.dict.size;
       if (v !== null && v >= 1 && v <= 10) {
         result = joinLatex([
@@ -16244,6 +16288,28 @@ var DEFINITIONS_OTHERS = [
     latexTrigger: ["\\enspace"],
     parse: () => ["HorizontalSpacing", 9]
   },
+  {
+    latexTrigger: ["\\hspace"],
+    parse: (parser) => {
+      if (parser.peek === "*") parser.nextToken();
+      parser.parseStringGroup();
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\hskip"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
+  {
+    latexTrigger: ["\\kern"],
+    parse: (parser) => {
+      skipTexDimension(parser);
+      return ["HorizontalSpacing", 0];
+    }
+  },
   {
     latexTrigger: ["\\phantom"],
     parse: (parser) => {
@@ -16294,7 +16360,17 @@ var DEFINITIONS_OTHERS = [
     // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
     serialize: (serializer, expr2) => {
       if (operand(expr2, 2) !== null) {
-        return serializer.serialize(operand(expr2, 1));
+        const cls = stringValue(operand(expr2, 2));
+        const inner = serializer.serialize(operand(expr2, 1));
+        if (cls === "bin") return `\\mathbin{${inner}}`;
+        if (cls === "op") return `\\mathop{${inner}}`;
+        if (cls === "rel") return `\\mathrel{${inner}}`;
+        if (cls === "ord") return `\\mathord{${inner}}`;
+        if (cls === "open") return `\\mathopen{${inner}}`;
+        if (cls === "close") return `\\mathclose{${inner}}`;
+        if (cls === "punct") return `\\mathpunct{${inner}}`;
+        if (cls === "inner") return `\\mathinner{${inner}}`;
+        return inner;
       }
       const v = machineValue(operand(expr2, 1));
       if (v === null) return "";
@@ -16685,25 +16761,47 @@ function makeIndexedEntry(entry, onError) {
     result.arguments = entry.arguments;
   return result;
 }
+function serializeTabularBody(serializer, body) {
+  if (!body) return "";
+  if (operator(body) !== "List") return serializer.serialize(body);
+  const rows = operands(body);
+  if (rows.length === 0) return "";
+  if (!rows.every((row) => operator(row) === "List"))
+    return serializer.serialize(body);
+  return rows.map(
+    (row) => operands(row).map((cell) => serializer.serialize(cell)).join(" & ")
+  ).join(" \\\\\n");
+}
 function makeSerializeHandler(entry, latexTrigger, idTrigger) {
   if (typeof entry.serialize === "function") return entry.serialize;
   const kind = entry["kind"] ?? "expression";
   if (kind === "environment") {
     const envName = entry["symbolTrigger"] ?? entry.name ?? "unknown";
-    return (serializer, expr2) => joinLatex([
-      `\\begin{${envName}}`,
-      serializer.serialize(operand(expr2, 1)),
-      `\\end{${envName}}`
-    ]);
+    return (serializer, expr2) => {
+      const body = operand(expr2, 1);
+      return joinLatex([
+        `\\begin{${envName}}`,
+        serializeTabularBody(serializer, body),
+        `\\end{${envName}}`
+      ]);
+    };
   }
   if (isMatchfixEntry(entry)) {
     const openDelim = typeof entry.openTrigger === "string" ? DEFAULT_DELIMITER[entry.openTrigger] : tokensToString(entry.openTrigger);
     const closeDelim = typeof entry.closeTrigger === "string" ? DEFAULT_DELIMITER[entry.closeTrigger] : tokensToString(entry.closeTrigger);
-    return (serializer, expr2) => joinLatex([
-      openDelim,
-      serializer.serialize(operand(expr2, 1)),
-      closeDelim
-    ]);
+    return (serializer, expr2) => {
+      const style = serializer.groupStyle(expr2, serializer.level + 1);
+      const inner = serializer.serialize(operand(expr2, 1));
+      if (style === "scaled")
+        return joinLatex([`\\left${openDelim}`, inner, `\\right${closeDelim}`]);
+      if (style === "big")
+        return joinLatex([
+          `\\Bigl${openDelim}`,
+          inner,
+          `\\Bigr${closeDelim}`
+        ]);
+      return joinLatex([openDelim, inner, closeDelim]);
+    };
   }
   let latex = entry.serialize;
   if (latex === void 0 && latexTrigger) latex = tokensToString(latexTrigger);
@@ -17588,6 +17686,16 @@ function parseNumber(parser, fmt) {
 }
 
 // src/compute-engine/latex-syntax/parse.ts
+var _symbolToUnicode = null;
+function getSymbolToUnicode() {
+  if (!_symbolToUnicode) {
+    _symbolToUnicode = /* @__PURE__ */ new Map();
+    for (const [, latex, codepoint] of SYMBOLS2) {
+      _symbolToUnicode.set(latex, String.fromCodePoint(codepoint));
+    }
+  }
+  return _symbolToUnicode;
+}
 var DELIMITER_SHORTHAND2 = {
   "(": ["\\lparen", "("],
   ")": ["\\rparen", ")"],
@@ -18035,6 +18143,35 @@ var _Parser = class __Parser {
       this.nextToken();
       this.skipVisualSpace();
     }
+    if (this.match("\\hspace")) {
+      this.match("*");
+      this.parseStringGroup();
+      this.skipVisualSpace();
+    }
+    if (this.match("\\hskip") || this.match("\\kern")) {
+      this.skipSpace();
+      this.match("-") || this.match("+");
+      while (/^[\d.]$/.test(this.peek)) this.nextToken();
+      for (const unit of [
+        "pt",
+        "em",
+        "mu",
+        "ex",
+        "mm",
+        "cm",
+        "in",
+        "bp",
+        "sp",
+        "dd",
+        "cc",
+        "pc",
+        "nc",
+        "nd"
+      ]) {
+        if (this.matchAll([...unit])) break;
+      }
+      this.skipVisualSpace();
+    }
     this.skipSpace();
   }
   match(token) {
@@ -18372,7 +18509,8 @@ var _Parser = class __Parser {
       } else if (token === "<space>") {
         result += " ";
       } else if (token[0] === "\\") {
-        result += token;
+        const unicode = getSymbolToUnicode().get(token);
+        result += unicode ?? token;
       } else {
         result += token;
       }
@@ -19732,7 +19870,7 @@ var STYLE_MODIFIERS = {
   sansserif: (s) => `\\mathsf{${s}}`,
   monospace: (s) => `\\mathtt{${s}}`
 };
-var Serializer4 = class {
+var Serializer5 = class {
   options;
   dictionary;
   level = -1;
@@ -19747,11 +19885,18 @@ var Serializer4 = class {
   /**
    * Serialize the expression, and if the expression is an operator
    * of precedence less than or equal to prec, wrap it in some parens.
-   * @todo: don't wrap Abs, Floor, Ceil, Delimiter
+   *
+   * Skip wrapping for matchfix operators (Abs, Floor, Ceil, Norm, etc.)
+   * and Delimiter since they already have visible delimiters.
    */
   wrap(expr2, prec) {
     if (expr2 === null || expr2 === void 0) return "";
     if (prec === void 0) {
+      const name2 = operator(expr2);
+      if (name2) {
+        const def = this.dictionary.ids.get(name2);
+        if (def?.kind === "matchfix") return this.serialize(expr2);
+      }
       return this.wrapString(
         this.serialize(expr2),
         this.options.groupStyle(expr2, this.level + 1)
@@ -20045,7 +20190,7 @@ function serializeSymbol2(s, style = "auto") {
   return body;
 }
 function serializeLatex(expr2, dict, options) {
-  const serializer = new Serializer4(dict, options);
+  const serializer = new Serializer5(dict, options);
   return serializer.serialize(expr2);
 }
 
@@ -42084,12 +42229,14 @@ var CONTROL_STRUCTURES_LIBRARY = [
       canonical: canonicalBlock,
       evaluate: evaluateBlock
     },
-    // A condition expression tests for one or more conditions of an expression
-    // ['Condition', value, "positive"]
+    // A condition expression tests for one or more conditions of an expression.
+    // Two forms:
+    //   ['Condition', value, "positive"]  — tests value against named condition(s)
+    //   ['Condition', predicate]          — set-builder predicate (e.g. x > 0)
     Condition: {
       description: "Test whether a value satisfies one or more conditions.",
       lazy: true,
-      signature: "(value, symbol) -> boolean",
+      signature: "(expression, symbol?) -> boolean",
       evaluate: ([value, conds], { engine }) => {
         let conditions = [];
         if (isSymbol2(conds)) {
@@ -61263,33 +61410,6 @@ 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],
@@ -61373,13 +61493,6 @@ 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) => {
@@ -61875,32 +61988,12 @@ var GPU_FUNCTIONS = {
     if (c === null || maxIter === null)
       throw new Error("Mandelbrot: missing arguments");
     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 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
@@ -62498,200 +62591,6 @@ 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);
@@ -62735,188 +62634,6 @@ 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;
@@ -63355,7 +63072,6 @@ 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];
@@ -63394,65 +63110,12 @@ var GPUShaderTarget = class {
     if (code.includes("_gpu_besselJ"))
       preamble += this.languageId === "wgsl" ? GPU_BESSELJ_PREAMBLE_WGSL : GPU_BESSELJ_PREAMBLE_GLSL;
     if (code.includes("_fractal_")) {
-      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;
-      }
+      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 = {}) {
@@ -68435,7 +68098,7 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/core.ts
-var version = "0.55.4";
+var version = "0.55.6";
 export {
   ComputeEngine,
   N,