@cortex-js/compute-engine 0.55.5 → 0.56.0

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.5 */
+/** Compute Engine 0.56.0 */
 
 // src/compute-engine/numerics/richardson.ts
 function extrapolate(f, x0, options = {}) {
@@ -1511,6 +1511,7 @@ var SCALAR_TYPES = [
 ];
 var VALUE_TYPES = [
   "value",
+  "color",
   ...COLLECTION_TYPES,
   ...SCALAR_TYPES
 ];
@@ -3206,6 +3207,7 @@ var PRIMITIVE_SUBTYPES = {
   symbol: [],
   boolean: [],
   string: [],
+  color: [],
   expression: EXPRESSION_TYPES
 };
 function isPrimitiveSubtype(lhs, rhs) {
@@ -6240,10 +6242,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, expr) => {
       const degree = machineValue(operand(expr, 2)) ?? 1;
       const base = serializer.serialize(operand(expr, 1));
@@ -7281,14 +7279,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, expr) => {
+      return joinLatex([
+        serializer.serialize(operand(expr, 1)),
+        "^\\complement"
+      ]);
+    }
   },
   {
     name: "Intersection",
@@ -7375,7 +7377,6 @@ var DEFINITIONS_SETS = [
   // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: "Multiple",
-    // @todo: parse
     serialize: serializeSet
   },
   {
@@ -7384,14 +7385,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 expr = operand(body, 1);
+        const condition = operand(body, 2);
+        if (expr !== null && condition !== null)
+          return ["Set", expr, ["Condition", condition]];
+      }
       if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
         body = operand(body, 1);
       }
@@ -7399,6 +7414,17 @@ var DEFINITIONS_SETS = [
       return ["Set", ...operands(body)];
     },
     serialize: (serializer, expr) => {
+      if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
+        const condition = operand(expr, 2);
+        return joinLatex([
+          "\\lbrace",
+          serializer.serialize(operand(expr, 1)),
+          "\\mid",
+          // Serialize the inner expression of the Condition wrapper
+          serializer.serialize(operand(condition, 1)),
+          "\\rbrace"
+        ]);
+      }
       return joinLatex([
         "\\lbrace",
         operands(expr).map((x) => serializer.serialize(x)).join(", "),
@@ -7565,23 +7591,6 @@ function serializeSet(serializer, expr) {
   if (expr === null) return "";
   const h = operator(expr);
   if (!h) return "";
-  if (h === "Set") {
-    if (nops(expr) === 0) return "\\emptyset";
-    if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
-      return joinLatex([
-        "\\left\\lbrace",
-        serializer.serialize(operand(expr, 1)),
-        "\\middle\\mid",
-        serializer.serialize(operand(expr, 2)),
-        "\\right\\rbrace"
-      ]);
-    }
-    return joinLatex([
-      "\\left\\lbrace",
-      ...operands(expr).map((x) => serializer.serialize(x) + " ,"),
-      "\\right\\rbrace"
-    ]);
-  }
   if (h === "Multiple") {
   }
   if (h === "Range") {
@@ -8699,11 +8708,13 @@ var DEFINITIONS_ARITHMETIC = [
       if (!parser.match("_")) return null;
       const base = parser.parseGroup();
       if (operator(base) !== "To") return null;
-      const expr = parser.parseArguments("implicit");
+      const expr = parser.parseExpression({
+        minPrec: MULTIPLICATION_PRECEDENCE
+      });
       if (!expr) return null;
       return [
         "Limit",
-        ["Function", expr[0], operand(base, 1)],
+        ["Function", expr, operand(base, 1)],
         operand(base, 2)
       ];
     },
@@ -8784,6 +8795,8 @@ var DEFINITIONS_ARITHMETIC = [
     precedence: DIVISION_PRECEDENCE,
     parse: "Mod"
   },
+  // Function-style alias: `\operatorname{mod}(a, b)`
+  { latexTrigger: "\\operatorname{mod}", parse: "Mod" },
   {
     latexTrigger: "\\pmod",
     kind: "prefix",
@@ -9024,6 +9037,13 @@ var DEFINITIONS_ARITHMETIC = [
       const rhs = serializer.wrap(operand(expr, 2), ADDITION_PRECEDENCE + 3);
       return joinLatex([lhs, "-", rhs]);
     }
+  },
+  // Euclidean distance between two points (tuples of numbers).
+  {
+    name: "Distance",
+    latexTrigger: ["\\operatorname{distance}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{distance}" + serializer.wrapArguments(expr)
   }
 ];
 function getIndexAssignment(expr, upper) {
@@ -10448,7 +10468,9 @@ var DEFINITIONS_STATISTICS = [
       if (!expr || !symbol(expr)) return null;
       return ["Mean", expr];
     }
-  }
+  },
+  // Function-style alias: `\operatorname{var}(...)`
+  { latexTrigger: "\\operatorname{var}", parse: "Variance" }
 ];
 
 // src/compute-engine/numerics/unit-data.ts
@@ -10907,12 +10929,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",
@@ -11152,80 +11214,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",
@@ -11237,6 +11290,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([
@@ -11324,6 +11381,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) => {
@@ -11374,7 +11453,17 @@ var DEFINITIONS_OTHERS = [
     // `["HorizontalSpacing", expr, 'op'|'bin'|rel]` -> indicate a spacing around and expression, i.e. `\mathbin{x}`, etc...
     serialize: (serializer, expr) => {
       if (operand(expr, 2) !== null) {
-        return serializer.serialize(operand(expr, 1));
+        const cls = stringValue(operand(expr, 2));
+        const inner = serializer.serialize(operand(expr, 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(expr, 1));
       if (v === null) return "";
@@ -11389,7 +11478,7 @@ var DEFINITIONS_OTHERS = [
         36: "\\qquad"
       }[v] ?? "";
     }
-  }
+  },
   // if (
   //   [
   //     '\\!',
@@ -11413,6 +11502,121 @@ var DEFINITIONS_OTHERS = [
   //     name: '',
   //     trigger: '\\check',
   // },
+  // ---------------------------------------------------------------------------
+  // Function-style aliases for collection / random operators that some
+  // notations write in lowercase (e.g. `\operatorname{shuffle}(L)`).
+  // The capitalized library entries already exist; these are pure parse
+  // aliases so the lowercase names don't land in `unsupported-operator`.
+  // ---------------------------------------------------------------------------
+  { latexTrigger: "\\operatorname{random}", parse: "Random" },
+  { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
+  { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
+  { latexTrigger: "\\operatorname{join}", parse: "Join" },
+  // ---------------------------------------------------------------------------
+  // Geometric primitive heads. Registered as known typed heads so consumers
+  // can branch on the operator name; CE itself doesn't render them. The
+  // library entries (with no evaluator) live in `library/core.ts`.
+  // ---------------------------------------------------------------------------
+  {
+    name: "Triangle",
+    latexTrigger: ["\\operatorname{triangle}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{triangle}" + serializer.wrapArguments(expr)
+  },
+  // Desmos's geometric `vector(p1, p2)` — a directed segment between two
+  // points. Routed to a dedicated head (not the existing column-vector
+  // `Vector`, which has a narrower `(number+) -> vector` signature).
+  {
+    name: "GeometricVector",
+    latexTrigger: ["\\operatorname{vector}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{vector}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Sphere",
+    latexTrigger: ["\\operatorname{sphere}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{sphere}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Segment",
+    latexTrigger: ["\\operatorname{segment}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{segment}" + serializer.wrapArguments(expr)
+  }
+];
+
+// src/compute-engine/latex-syntax/dictionary/definitions-colors.ts
+var DEFINITIONS_COLORS = [
+  // Color constructors (one per colorspace, preserves space on evaluation)
+  {
+    name: "Rgb",
+    latexTrigger: ["\\operatorname{rgb}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{rgb}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Hsv",
+    latexTrigger: ["\\operatorname{hsv}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{hsv}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Hsl",
+    latexTrigger: ["\\operatorname{hsl}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{hsl}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Oklab",
+    latexTrigger: ["\\operatorname{oklab}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{oklab}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Oklch",
+    latexTrigger: ["\\operatorname{oklch}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{oklch}" + serializer.wrapArguments(expr)
+  },
+  // Conversion functions (color → color in the named space)
+  {
+    name: "AsRgb",
+    latexTrigger: ["\\operatorname{asRgb}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asRgb}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsHsv",
+    latexTrigger: ["\\operatorname{asHsv}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asHsv}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsHsl",
+    latexTrigger: ["\\operatorname{asHsl}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asHsl}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsOklab",
+    latexTrigger: ["\\operatorname{asOklab}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asOklab}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsOklch",
+    latexTrigger: ["\\operatorname{asOklch}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asOklch}" + serializer.wrapArguments(expr)
+  },
+  // Perceptual difference (returns a scalar in [0, ~1])
+  {
+    name: "ColorDelta",
+    latexTrigger: ["\\operatorname{colorDelta}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{colorDelta}" + serializer.wrapArguments(expr)
+  }
 ];
 
 // src/compute-engine/latex-syntax/dictionary/default-dictionary.ts
@@ -11443,7 +11647,8 @@ var LATEX_DICTIONARY = [
   ...DEFINITIONS_STATISTICS,
   ...DEFINITIONS_UNITS,
   ...DEFINITIONS_OTHERS,
-  ...DEFINITIONS_PHYSICS
+  ...DEFINITIONS_PHYSICS,
+  ...DEFINITIONS_COLORS
 ];
 
 // src/math-json/symbols.ts
@@ -15066,8 +15271,7 @@ function compile(expr, options) {
       vars: options?.vars,
       imports: options?.imports,
       preamble: options?.preamble,
-      realOnly: options?.realOnly,
-      hints: options?.hints
+      realOnly: options?.realOnly
     });
   } catch (e) {
     if (options?.fallback ?? true) {
@@ -15079,8 +15283,7 @@ function compile(expr, options) {
         ce.pushScope();
         try {
           if (vars && typeof vars === "object") {
-            for (const [k, v] of Object.entries(vars))
-              ce.assign(k, v);
+            for (const [k, v] of Object.entries(vars)) ce.assign(k, v);
           }
           return expr.evaluate().re;
         } finally {
@@ -15167,8 +15370,7 @@ function tryGetComplexParts(expr, compile2) {
         return { re: null, im: formatFloat(iScale) };
       }
       const compiledFactors = remaining.map((r) => compile2(r));
-      if (iScale !== 1)
-        compiledFactors.unshift(formatFloat(iScale));
+      if (iScale !== 1) compiledFactors.unshift(formatFloat(iScale));
       const imCode = foldTerms(compiledFactors, "1.0", "*");
       return { re: null, im: imCode };
     }
@@ -15233,6 +15435,40 @@ function rgbToHsl(r, g, b) {
   else h = ((r - g) / d + 4) / 6;
   return { h: h * 360, s, l };
 }
+function hsvToRgb(h, s, v) {
+  h = (h % 360 + 360) % 360;
+  s = Math.max(0, Math.min(1, s));
+  v = Math.max(0, Math.min(1, v));
+  const c = v * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - c;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) [r, g, b] = [c, x, 0];
+  else if (h < 120) [r, g, b] = [x, c, 0];
+  else if (h < 180) [r, g, b] = [0, c, x];
+  else if (h < 240) [r, g, b] = [0, x, c];
+  else if (h < 300) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  return { r: (r + m) * 255, g: (g + m) * 255, b: (b + m) * 255 };
+}
+function rgbToHsv(r, g, b) {
+  r /= 255;
+  g /= 255;
+  b /= 255;
+  const max2 = Math.max(r, g, b);
+  const min2 = Math.min(r, g, b);
+  const d = max2 - min2;
+  let h = 0;
+  if (d > 0) {
+    if (max2 === r) h = (g - b) / d % 6;
+    else if (max2 === g) h = (b - r) / d + 2;
+    else h = (r - g) / d + 4;
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  const s = max2 === 0 ? 0 : d / max2;
+  return { h, s, v: max2 };
+}
 function parseHexColor(s) {
   const hex = s.startsWith("#") ? s.substring(1) : s;
   let r, g, b;
@@ -15688,6 +15924,13 @@ var NAMED_COLORS = {
 };
 function parseColor(s, darkMode) {
   const str = s.trim().toLowerCase();
+  const opacityMatch = str.match(/^(.+?)\s*\/\s*(\d+(?:\.\d+)?)%?\s*$/);
+  if (opacityMatch) {
+    const base = parseColor(opacityMatch[1].trim(), darkMode);
+    const opacity = Math.max(0, Math.min(100, parseFloat(opacityMatch[2])));
+    const alpha = Math.round(opacity / 100 * 255);
+    return base & 4294967040 | alpha;
+  }
   if (str.startsWith("#")) {
     const hex = str.substring(1);
     let r, g, b, a = 255;
@@ -15820,14 +16063,6 @@ function parseColor(s, darkMode) {
   console.warn(`parseColor: unrecognized color "${s}"`);
   return 0;
 }
-function parseColorToRgb01(s, darkMode) {
-  const color = parseColor(s, darkMode);
-  return [
-    (color >>> 24 & 255) / 255,
-    (color >>> 16 & 255) / 255,
-    (color >>> 8 & 255) / 255
-  ];
-}
 function apca(bgColor, fgColor) {
   const bgRgb = asRgb(bgColor);
   const fgRgb = asRgb(fgColor);
@@ -15886,6 +16121,12 @@ function contrastingColor(arg) {
   const contrast2 = Math.abs(apca(fg2, bg));
   return contrast1 >= contrast2 ? asColorNumber(fg1) : asColorNumber(fg2);
 }
+function oklabDeltaE(a, b) {
+  const dL = a.L - b.L;
+  const da = a.a - b.a;
+  const db = a.b - b.b;
+  return Math.sqrt(dL * dL + da * da + db * db);
+}
 var TYCHO_11 = [
   "#4e79a7",
   // Blue
@@ -20097,39 +20338,130 @@ var JAVASCRIPT_FUNCTIONS = {
     if (args.length >= 2)
       return `_SYS.colormap(${compile2(args[0])}, ${compile2(args[1])})`;
     return `_SYS.colormap(${compile2(args[0])})`;
+  },
+  // -----------------------------------------------------------------------
+  // Color constructor heads. All compile to OKLCh arrays at runtime — the
+  // canonical color representation in this target. The constructors take
+  // their own colorspace's components and convert internally.
+  // (Mirrors the GPU target's design: color values are vec3 OKLCh.)
+  // -----------------------------------------------------------------------
+  Rgb: (args, compile2) => {
+    if (args.length < 3) throw new Error("Rgb: need 3 components");
+    return `_SYS.rgb(${args.map(compile2).join(", ")})`;
+  },
+  Hsv: (args, compile2) => {
+    if (args.length < 3) throw new Error("Hsv: need 3 components");
+    return `_SYS.hsv(${args.map(compile2).join(", ")})`;
+  },
+  Hsl: (args, compile2) => {
+    if (args.length < 3) throw new Error("Hsl: need 3 components");
+    return `_SYS.hsl(${args.map(compile2).join(", ")})`;
+  },
+  Oklab: (args, compile2) => {
+    if (args.length < 3) throw new Error("Oklab: need 3 components");
+    return `_SYS.oklab(${args.map(compile2).join(", ")})`;
+  },
+  Oklch: (args, compile2) => {
+    if (args.length < 3) throw new Error("Oklch: need 3 components");
+    return `_SYS.oklch(${args.map(compile2).join(", ")})`;
+  },
+  // -----------------------------------------------------------------------
+  // As* converters. Compile-time output convention matches the engine and
+  // the GPU target: each returns components in the named space as a 3- or
+  // 4-element array. `AsRgb` uses 0-1 sRGB channels (consistent across all
+  // layers). `AsOklch` is the identity (canonical form).
+  // -----------------------------------------------------------------------
+  AsRgb: ([c], compile2) => {
+    if (c === null) throw new Error("AsRgb: no argument");
+    return `_SYS.asRgb(${compile2(c)})`;
+  },
+  AsHsv: ([c], compile2) => {
+    if (c === null) throw new Error("AsHsv: no argument");
+    return `_SYS.asHsv(${compile2(c)})`;
+  },
+  AsHsl: ([c], compile2) => {
+    if (c === null) throw new Error("AsHsl: no argument");
+    return `_SYS.asHsl(${compile2(c)})`;
+  },
+  AsOklab: ([c], compile2) => {
+    if (c === null) throw new Error("AsOklab: no argument");
+    return `_SYS.asOklab(${compile2(c)})`;
+  },
+  AsOklch: ([c], compile2) => {
+    if (c === null) throw new Error("AsOklch: no argument");
+    return compile2(c);
+  },
+  // Perceptual color difference (ΔE_OK).
+  ColorDelta: ([a, b], compile2) => {
+    if (a === null || b === null)
+      throw new Error("ColorDelta: need two colors");
+    return `_SYS.colorDelta(${compile2(a)}, ${compile2(b)})`;
+  },
+  // Euclidean distance between two tuples (any positive dimension).
+  // The GPU target maps `Distance` to the GLSL/WGSL `distance()` builtin
+  // (vec-only); this JS handler works on plain arrays of any length.
+  Distance: ([a, b], compile2) => {
+    if (a === null || b === null) throw new Error("Distance: need two points");
+    return `_SYS.distance(${compile2(a)}, ${compile2(b)})`;
   }
 };
 function toRI(c) {
   return { re: c.re, im: c.im };
 }
+function normalizeAlpha(a) {
+  if (a === void 0) return void 0;
+  if (!Number.isFinite(a)) return void 0;
+  if (Math.abs(a - 1) < 1e-9) return void 0;
+  return a;
+}
 function toRgb255(input) {
   if (typeof input === "string") {
     const c = parseColor(input);
-    return {
+    const rgb2 = {
       r: c >>> 24 & 255,
       g: c >>> 16 & 255,
-      b: c >>> 8 & 255,
-      alpha: (c & 255) / 255
+      b: c >>> 8 & 255
     };
+    const alpha = normalizeAlpha((c & 255) / 255);
+    if (alpha !== void 0) rgb2.alpha = alpha;
+    return rgb2;
+  }
+  const rgb = oklchToRgb({ L: input[0], C: input[1], H: input[2] });
+  if (input.length >= 4) {
+    const alpha = normalizeAlpha(input[3]);
+    if (alpha !== void 0) rgb.alpha = alpha;
   }
-  const rgb = {
-    r: input[0] * 255,
-    g: input[1] * 255,
-    b: input[2] * 255
-  };
-  if (input.length >= 4) rgb.alpha = input[3];
   return rgb;
 }
-function packedToArray(c) {
-  const r = (c >>> 24 & 255) / 255;
-  const g = (c >>> 16 & 255) / 255;
-  const b = (c >>> 8 & 255) / 255;
-  const a = (c & 255) / 255;
-  return Math.abs(a - 1) < 1e-4 ? [r, g, b] : [r, g, b, a];
+function toOklch(input) {
+  if (typeof input === "string") {
+    const c = parseColor(input);
+    const r = c >>> 24 & 255;
+    const g = c >>> 16 & 255;
+    const b = c >>> 8 & 255;
+    const oklch2 = rgbToOklch({ r, g, b });
+    const alpha = normalizeAlpha((c & 255) / 255);
+    if (alpha !== void 0) oklch2.alpha = alpha;
+    return oklch2;
+  }
+  return {
+    L: input[0],
+    C: input[1],
+    H: input[2],
+    alpha: input.length >= 4 ? normalizeAlpha(input[3]) : void 0
+  };
+}
+function packedToOklch(c) {
+  const r = c >>> 24 & 255;
+  const g = c >>> 16 & 255;
+  const b = c >>> 8 & 255;
+  const oklch2 = rgbToOklch({ r, g, b });
+  const alpha = normalizeAlpha((c & 255) / 255);
+  return alpha !== void 0 ? [oklch2.L, oklch2.C, oklch2.H, alpha] : [oklch2.L, oklch2.C, oklch2.H];
 }
 var colorHelpers = {
   color(input) {
-    return packedToArray(parseColor(input));
+    return packedToOklch(parseColor(input));
   },
   colorToString(input, format) {
     const rgb = toRgb255(input);
@@ -20140,7 +20472,7 @@ var colorHelpers = {
         const g = Math.round(Math.max(0, Math.min(255, rgb.g)));
         const b = Math.round(Math.max(0, Math.min(255, rgb.b)));
         let hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
-        if (rgb.alpha !== void 0 && Math.abs(rgb.alpha - 1) > 1e-4) {
+        if (rgb.alpha !== void 0) {
           const a = Math.round(Math.max(0, Math.min(255, rgb.alpha * 255)));
           hex += a.toString(16).padStart(2, "0");
         }
@@ -20150,7 +20482,7 @@ var colorHelpers = {
         const r = Math.round(rgb.r);
         const g = Math.round(rgb.g);
         const b = Math.round(rgb.b);
-        if (rgb.alpha !== void 0 && Math.abs(rgb.alpha - 1) > 1e-4)
+        if (rgb.alpha !== void 0)
           return `rgb(${r} ${g} ${b} / ${rgb.alpha})`;
         return `rgb(${r} ${g} ${b})`;
       }
@@ -20159,7 +20491,7 @@ var colorHelpers = {
         const h = Math.round(hsl.h * 10) / 10;
         const s = Math.round(hsl.s * 1e3) / 10;
         const l = Math.round(hsl.l * 1e3) / 10;
-        if (rgb.alpha !== void 0 && Math.abs(rgb.alpha - 1) > 1e-4)
+        if (rgb.alpha !== void 0)
           return `hsl(${h} ${s}% ${l}% / ${rgb.alpha})`;
         return `hsl(${h} ${s}% ${l}%)`;
       }
@@ -20168,7 +20500,7 @@ var colorHelpers = {
         const L = Math.round(c.L * 1e3) / 1e3;
         const C = Math.round(c.C * 1e3) / 1e3;
         const H = Math.round(c.H * 10) / 10;
-        if (rgb.alpha !== void 0 && Math.abs(rgb.alpha - 1) > 1e-4)
+        if (rgb.alpha !== void 0)
           return `oklch(${L} ${C} ${H} / ${rgb.alpha})`;
         return `oklch(${L} ${C} ${H})`;
       }
@@ -20177,29 +20509,29 @@ var colorHelpers = {
     }
   },
   colorMix(input1, input2, ratio = 0.5) {
-    const rgb1 = toRgb255(input1);
-    const rgb2 = toRgb255(input2);
+    const c1 = toOklch(input1);
+    const c2 = toOklch(input2);
     ratio = Math.max(0, Math.min(1, ratio));
-    const c1 = rgbToOklch(rgb1);
-    const c2 = rgbToOklch(rgb2);
-    let dh = c2.H - c1.H;
-    if (dh > 180) dh -= 360;
-    if (dh < -180) dh += 360;
-    let H = c1.H + dh * ratio;
-    if (H < 0) H += 360;
-    if (H >= 360) H -= 360;
-    const mixed = oklchToRgb({
-      L: c1.L + (c2.L - c1.L) * ratio,
-      C: c1.C + (c2.C - c1.C) * ratio,
-      H
-    });
-    const r = mixed.r / 255;
-    const g = mixed.g / 255;
-    const b = mixed.b / 255;
-    const a1 = rgb1.alpha ?? 1;
-    const a2 = rgb2.alpha ?? 1;
-    const alpha = a1 + (a2 - a1) * ratio;
-    return Math.abs(alpha - 1) > 1e-4 ? [r, g, b, alpha] : [r, g, b];
+    const c1Achromatic = c1.C < 1e-6;
+    const c2Achromatic = c2.C < 1e-6;
+    let H;
+    if (c1Achromatic && c2Achromatic) H = c1.H;
+    else if (c1Achromatic) H = c2.H;
+    else if (c2Achromatic) H = c1.H;
+    else {
+      let dh = c2.H - c1.H;
+      if (dh > 180) dh -= 360;
+      if (dh < -180) dh += 360;
+      H = c1.H + dh * ratio;
+      if (H < 0) H += 360;
+      if (H >= 360) H -= 360;
+    }
+    const L = c1.L + (c2.L - c1.L) * ratio;
+    const C = c1.C + (c2.C - c1.C) * ratio;
+    const a1 = c1.alpha ?? 1;
+    const a2 = c2.alpha ?? 1;
+    const alpha = normalizeAlpha(a1 + (a2 - a1) * ratio);
+    return alpha !== void 0 ? [L, C, H, alpha] : [L, C, H];
   },
   colorContrast(bg, fg) {
     return apca(toRgb255(bg), toRgb255(fg));
@@ -20207,11 +20539,11 @@ var colorHelpers = {
   contrastingColor(bg, fg1, fg2) {
     const bgRgb = toRgb255(bg);
     if (fg1 !== void 0 && fg2 !== void 0) {
-      return packedToArray(
+      return packedToOklch(
         contrastingColor({ bg: bgRgb, fg1: toRgb255(fg1), fg2: toRgb255(fg2) })
       );
     }
-    return packedToArray(contrastingColor(bgRgb));
+    return packedToOklch(contrastingColor(bgRgb));
   },
   colorToColorspace(input, space) {
     const rgb = toRgb255(input);
@@ -20240,7 +20572,7 @@ var colorHelpers = {
       default:
         throw new Error(`Unknown color space: ${space}`);
     }
-    if (alpha !== void 0 && Math.abs(alpha - 1) > 1e-4) result.push(alpha);
+    if (alpha !== void 0) result.push(alpha);
     return result;
   },
   colormap(name, arg) {
@@ -20252,7 +20584,7 @@ var colorHelpers = {
     const palette = allPalettes[name];
     if (!palette) throw new Error(`Unknown palette: ${name}`);
     const colors = palette.map(
-      (hex) => parseColorToRgb01(hex)
+      (hex) => packedToOklch(parseColor(hex))
     );
     if (arg === void 0) return colors;
     if (Number.isInteger(arg) && arg >= 2) {
@@ -20276,62 +20608,128 @@ var colorHelpers = {
     const frac = pos - i;
     if (frac === 0 || i >= colors.length - 1)
       return [...colors[Math.min(i, colors.length - 1)]];
-    const rgb1 = {
-      r: colors[i][0] * 255,
-      g: colors[i][1] * 255,
-      b: colors[i][2] * 255
-    };
-    const rgb2 = {
-      r: colors[i + 1][0] * 255,
-      g: colors[i + 1][1] * 255,
-      b: colors[i + 1][2] * 255
-    };
-    const c1 = rgbToOklch(rgb1);
-    const c2 = rgbToOklch(rgb2);
-    let dh = c2.H - c1.H;
-    if (dh > 180) dh -= 360;
-    if (dh < -180) dh += 360;
-    let H = c1.H + dh * frac;
-    if (H < 0) H += 360;
-    if (H >= 360) H -= 360;
-    const mixed = oklchToRgb({
-      L: c1.L + (c2.L - c1.L) * frac,
-      C: c1.C + (c2.C - c1.C) * frac,
-      H
-    });
-    return [mixed.r / 255, mixed.g / 255, mixed.b / 255];
+    const [L1, C1, H1] = colors[i];
+    const [L2, C2, H2] = colors[i + 1];
+    const c1Achromatic = C1 < 1e-6;
+    const c2Achromatic = C2 < 1e-6;
+    let H;
+    if (c1Achromatic && c2Achromatic) H = H1;
+    else if (c1Achromatic) H = H2;
+    else if (c2Achromatic) H = H1;
+    else {
+      let dh = H2 - H1;
+      if (dh > 180) dh -= 360;
+      if (dh < -180) dh += 360;
+      H = H1 + dh * frac;
+      if (H < 0) H += 360;
+      if (H >= 360) H -= 360;
+    }
+    return [L1 + (L2 - L1) * frac, C1 + (C2 - C1) * frac, H];
   },
   colorFromColorspace(components, space) {
     const c0 = components[0];
     const c1 = components[1];
     const c2 = components[2];
     const alpha = components.length >= 4 ? components[3] : void 0;
-    let result;
+    let oklch2;
     switch (space.toLowerCase()) {
       case "rgb":
-        result = [c0, c1, c2];
+        oklch2 = rgbToOklch({ r: c0 * 255, g: c1 * 255, b: c2 * 255 });
         break;
       case "hsl": {
-        const r = hslToRgb(c0, c1, c2);
-        result = [r.r / 255, r.g / 255, r.b / 255];
+        const rgb = hslToRgb(c0, c1, c2);
+        oklch2 = rgbToOklch(rgb);
         break;
       }
-      case "oklch": {
-        const r = oklchToRgb({ L: c0, C: c1, H: c2 });
-        result = [r.r / 255, r.g / 255, r.b / 255];
+      case "oklch":
+        oklch2 = { L: c0, C: c1, H: c2 };
         break;
-      }
       case "oklab":
-      case "lab": {
-        const r = oklabToRgb({ L: c0, a: c1, b: c2 });
-        result = [r.r / 255, r.g / 255, r.b / 255];
+      case "lab":
+        oklch2 = oklabToOklch({ L: c0, a: c1, b: c2 });
         break;
-      }
       default:
         throw new Error(`Unknown color space: ${space}`);
     }
-    if (alpha !== void 0 && Math.abs(alpha - 1) > 1e-4) result.push(alpha);
-    return result;
+    return alpha !== void 0 ? [oklch2.L, oklch2.C, oklch2.H, alpha] : [oklch2.L, oklch2.C, oklch2.H];
+  },
+  // -----------------------------------------------------------------------
+  // Color constructors. Each accepts components in its colorspace's natural
+  // units and returns the canonical OKLCh array `[L, C, H]` (or with alpha).
+  // -----------------------------------------------------------------------
+  rgb(r, g, b, alpha) {
+    const c = rgbToOklch({ r: r * 255, g: g * 255, b: b * 255 });
+    const a = normalizeAlpha(alpha);
+    return a !== void 0 ? [c.L, c.C, c.H, a] : [c.L, c.C, c.H];
+  },
+  hsv(h, s, v, alpha) {
+    const rgb = hsvToRgb(h, s, v);
+    const c = rgbToOklch(rgb);
+    const a = normalizeAlpha(alpha);
+    return a !== void 0 ? [c.L, c.C, c.H, a] : [c.L, c.C, c.H];
+  },
+  hsl(h, s, l, alpha) {
+    const rgb = hslToRgb(h, s, l);
+    const c = rgbToOklch({ r: rgb.r, g: rgb.g, b: rgb.b });
+    const a = normalizeAlpha(alpha);
+    return a !== void 0 ? [c.L, c.C, c.H, a] : [c.L, c.C, c.H];
+  },
+  oklab(L, a, b, alpha) {
+    const c = oklabToOklch({ L, a, b });
+    const al = normalizeAlpha(alpha);
+    return al !== void 0 ? [c.L, c.C, c.H, al] : [c.L, c.C, c.H];
+  },
+  oklch(L, C, H, alpha) {
+    const a = normalizeAlpha(alpha);
+    return a !== void 0 ? [L, C, H, a] : [L, C, H];
+  },
+  // -----------------------------------------------------------------------
+  // As* converters. Inputs are anything `toOklch` accepts (string, packed
+  // int, or OKLCh array). Outputs are 3- or 4-element arrays in the named
+  // space. sRGB-based outputs (asRgb/asHsv/asHsl) use 0-1 channels for
+  // consistency with the GPU target's shader convention.
+  // -----------------------------------------------------------------------
+  asRgb(input) {
+    const rgb = toRgb255(input);
+    const r = rgb.r / 255;
+    const g = rgb.g / 255;
+    const b = rgb.b / 255;
+    return rgb.alpha !== void 0 ? [r, g, b, rgb.alpha] : [r, g, b];
+  },
+  asHsv(input) {
+    const rgb = toRgb255(input);
+    const hsv = rgbToHsv(rgb.r, rgb.g, rgb.b);
+    return rgb.alpha !== void 0 ? [hsv.h, hsv.s, hsv.v, rgb.alpha] : [hsv.h, hsv.s, hsv.v];
+  },
+  asHsl(input) {
+    const rgb = toRgb255(input);
+    const hsl = rgbToHsl(rgb.r, rgb.g, rgb.b);
+    return rgb.alpha !== void 0 ? [hsl.h, hsl.s, hsl.l, rgb.alpha] : [hsl.h, hsl.s, hsl.l];
+  },
+  asOklab(input) {
+    const c = toOklch(input);
+    const lab = oklchToOklab({ L: c.L, C: c.C, H: c.H });
+    return c.alpha !== void 0 ? [lab.L, lab.a, lab.b, c.alpha] : [lab.L, lab.a, lab.b];
+  },
+  // asOklch is identity — handled at compile time as a pass-through
+  // Perceptual color difference (ΔE_OK).
+  colorDelta(a, b) {
+    const labA = oklchToOklab(toOklch(a));
+    const labB = oklchToOklab(toOklch(b));
+    return oklabDeltaE(labA, labB);
+  },
+  // Euclidean distance between two tuples. Plain numeric — not a color
+  // operation despite living in the same helpers block.
+  distance(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b))
+      throw new Error("Distance: expected two arrays");
+    if (a.length !== b.length) throw new Error("Distance: dimension mismatch");
+    let sumSq = 0;
+    for (let i = 0; i < a.length; i++) {
+      const d = a[i] - b[i];
+      sumSq += d * d;
+    }
+    return Math.sqrt(sumSq);
   }
 };
 var SYS_HELPERS = {
@@ -20749,43 +21147,6 @@ function fibonacci(n) {
   return b;
 }
 
-// src/compute-engine/compilation/fractal-orbit.ts
-function toBigDecimal(v) {
-  if (typeof v === "object" && "hi" in v)
-    return new BigDecimal(v.hi).add(new BigDecimal(v.lo));
-  return new BigDecimal(v);
-}
-function hpToNumber(v) {
-  if (typeof v === "number") return v;
-  if (typeof v === "string") return Number(v);
-  return v.hi + v.lo;
-}
-function computeReferenceOrbit(center, maxIter, precision) {
-  const prevPrecision = BigDecimal.precision;
-  BigDecimal.precision = precision;
-  try {
-    const cr = toBigDecimal(center[0]);
-    const ci = toBigDecimal(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],
@@ -20807,6 +21168,13 @@ var GPU_OPERATORS = {
 function gpuVec2(target) {
   return target?.language === "wgsl" ? "vec2f" : "vec2";
 }
+function gpuVec3(target) {
+  return target?.language === "wgsl" ? "vec3f" : "vec3";
+}
+function readStringLiteral(expr) {
+  if (!isString(expr)) return null;
+  return expr.string?.toLowerCase() ?? null;
+}
 function compileIntArg(expr, compile2, target) {
   const c = tryGetConstant(expr);
   if (c !== void 0 && Number.isInteger(c)) return c.toString();
@@ -20865,17 +21233,10 @@ function compileGPUSumProduct(kind, args, _compile, target) {
     `for (${indexDecl} = ${lowerStr}; ${index} <= ${upperStr}; ${index}++) {`,
     `  ${acc} ${op}= ${body};`,
     `}`,
-    `return ${acc}`
+    `return ${acc};`
   ];
   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, compile2, target) => {
@@ -20926,8 +21287,7 @@ var GPU_FUNCTIONS = {
       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)})`;
+      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", "*");
@@ -20980,8 +21340,7 @@ var GPU_FUNCTIONS = {
     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)`;
+    if (isSymbol2(x, "ImaginaryUnit")) return `${gpuVec2(target)}(0.0, -1.0)`;
     return `(-${compile2(x)})`;
   },
   // Standard math functions with complex dispatch
@@ -21354,49 +21713,139 @@ var GPU_FUNCTIONS = {
     }
     const isWGSL = target?.language === "wgsl";
     const v3 = isWGSL ? "vec3f" : "vec3";
-    return `((_gpu_apca(${bg}, ${v3}(0.0)) > 50.0) ? ${v3}(0.0) : ${v3}(1.0))`;
+    const black = `${v3}(0.0)`;
+    const white = `${v3}(1.0, 0.0, 0.0)`;
+    return `((_gpu_apca(${bg}, ${black}) > 50.0) ? ${black} : ${white})`;
   },
   ColorToColorspace: ([color, space], compile2) => {
     if (color === null || space === null)
       throw new Error("ColorToColorspace: need color and space");
-    return `_gpu_srgb_to_oklab(${compile2(color)})`;
+    const spaceName = readStringLiteral(space);
+    if (spaceName === null)
+      throw new Error("ColorToColorspace: space must be a string literal");
+    const c = compile2(color);
+    switch (spaceName) {
+      case "oklch":
+        return c;
+      case "oklab":
+      case "lab":
+        return `_gpu_oklch_to_oklab(${c})`;
+      case "rgb":
+        return `_gpu_oklch_to_srgb(${c})`;
+      case "hsl":
+        return `_gpu_rgb_to_hsl(_gpu_oklch_to_srgb(${c}))`;
+      case "hsv":
+        return `_gpu_rgb_to_hsv(_gpu_oklch_to_srgb(${c}))`;
+      default:
+        throw new Error(
+          `ColorToColorspace: unsupported space "${spaceName}" on GPU target`
+        );
+    }
   },
   ColorFromColorspace: ([components, space], compile2) => {
     if (components === null || space === null)
       throw new Error("ColorFromColorspace: need components and space");
-    return `_gpu_oklab_to_srgb(${compile2(components)})`;
+    const spaceName = readStringLiteral(space);
+    if (spaceName === null)
+      throw new Error("ColorFromColorspace: space must be a string literal");
+    const c = compile2(components);
+    switch (spaceName) {
+      case "oklch":
+        return c;
+      case "oklab":
+      case "lab":
+        return `_gpu_oklab_to_oklch(${c})`;
+      case "rgb":
+        return `_gpu_srgb_to_oklch(${c})`;
+      case "hsl":
+        return `_gpu_srgb_to_oklch(_gpu_hsl_to_rgb(${c}))`;
+      case "hsv":
+        return `_gpu_srgb_to_oklch(_gpu_hsv_to_rgb(${c}))`;
+      default:
+        throw new Error(
+          `ColorFromColorspace: unsupported space "${spaceName}" on GPU target`
+        );
+    }
+  },
+  // ---------------------------------------------------------------------------
+  // Color literals. Each typed head compiles to a canonical OKLCh vec3.
+  // Alpha (4th argument) is dropped — GPU color values are vec3 only. Pass
+  // alpha as a separate uniform if it's needed at the framebuffer boundary.
+  // ---------------------------------------------------------------------------
+  Color: ([s], _compile, target) => {
+    if (s === null) throw new Error("Color: no argument");
+    const str = readStringLiteral(s);
+    if (str === null)
+      throw new Error("Color: argument must be a string literal on GPU target");
+    const packed = parseColor(str);
+    if (packed === 0 && str.trim().toLowerCase() !== "transparent")
+      throw new Error(`Color: invalid color string "${str}"`);
+    const r = packed >>> 24 & 255;
+    const g = packed >>> 16 & 255;
+    const b = packed >>> 8 & 255;
+    const oklch2 = rgbToOklch({ r, g, b });
+    return `${gpuVec3(target)}(${formatFloat(oklch2.L)}, ${formatFloat(oklch2.C)}, ${formatFloat(oklch2.H)})`;
+  },
+  Rgb: (args, compile2, target) => {
+    if (args.length < 3) throw new Error("Rgb: need 3 components");
+    const v3 = gpuVec3(target);
+    return `_gpu_srgb_to_oklch(${v3}(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(args[2])}))`;
+  },
+  Hsv: (args, compile2, target) => {
+    if (args.length < 3) throw new Error("Hsv: need 3 components");
+    const v3 = gpuVec3(target);
+    return `_gpu_srgb_to_oklch(_gpu_hsv_to_rgb(${v3}(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(args[2])})))`;
+  },
+  Hsl: (args, compile2, target) => {
+    if (args.length < 3) throw new Error("Hsl: need 3 components");
+    const v3 = gpuVec3(target);
+    return `_gpu_srgb_to_oklch(_gpu_hsl_to_rgb(${v3}(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(args[2])})))`;
+  },
+  Oklab: (args, compile2, target) => {
+    if (args.length < 3) throw new Error("Oklab: need 3 components");
+    const v3 = gpuVec3(target);
+    return `_gpu_oklab_to_oklch(${v3}(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(args[2])}))`;
+  },
+  Oklch: (args, compile2, target) => {
+    if (args.length < 3) throw new Error("Oklch: need 3 components");
+    const v3 = gpuVec3(target);
+    return `${v3}(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(args[2])})`;
+  },
+  // ---------------------------------------------------------------------------
+  // As* operators. AsOklch is identity (canonical). The other As* return
+  // components in the named space, equivalent to ColorToColorspace(c, 'x').
+  // ---------------------------------------------------------------------------
+  AsOklch: ([c], compile2) => {
+    if (c === null) throw new Error("AsOklch: no argument");
+    return compile2(c);
+  },
+  AsOklab: ([c], compile2) => {
+    if (c === null) throw new Error("AsOklab: no argument");
+    return `_gpu_oklch_to_oklab(${compile2(c)})`;
+  },
+  AsRgb: ([c], compile2) => {
+    if (c === null) throw new Error("AsRgb: no argument");
+    return `_gpu_oklch_to_srgb(${compile2(c)})`;
+  },
+  AsHsv: ([c], compile2) => {
+    if (c === null) throw new Error("AsHsv: no argument");
+    return `_gpu_rgb_to_hsv(_gpu_oklch_to_srgb(${compile2(c)}))`;
+  },
+  AsHsl: ([c], compile2) => {
+    if (c === null) throw new Error("AsHsl: no argument");
+    return `_gpu_rgb_to_hsl(_gpu_oklch_to_srgb(${compile2(c)}))`;
   },
   // Fractal functions
   Mandelbrot: ([c, maxIter], compile2, target) => {
     if (c === null || maxIter === null)
       throw new Error("Mandelbrot: missing arguments");
     const iterCode = compileIntArg(maxIter, compile2, target);
-    const strategy = selectFractalStrategy(target);
-    if (strategy === "double") {
-      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
-      return `_fractal_mandelbrot_dp(${dpCoord}, ${iterCode})`;
-    }
-    if (strategy === "perturbation") {
-      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
-      return `_fractal_mandelbrot_pt(${ptDelta}, ${iterCode})`;
-    }
     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 iterCode = compileIntArg(maxIter, compile2, target);
-    const strategy = selectFractalStrategy(target);
-    if (strategy === "double") {
-      const dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
-      const cCode = compile2(c);
-      return `_fractal_julia_dp(${dpCoord}, vec4(${cCode}, vec2(0.0)), ${iterCode})`;
-    }
-    if (strategy === "perturbation") {
-      const ptDelta = target?.language === "wgsl" ? "_pt_delta(v_uv)" : "_pt_delta()";
-      const cCode = compile2(c);
-      return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
-    }
     return `_fractal_julia(${compile2(z)}, ${compile2(c)}, ${iterCode})`;
   },
   // Vector/Matrix operations
@@ -21994,232 +22443,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 = `
-uniform float _dp_cx_hi;
-uniform float _dp_cx_lo;
-uniform float _dp_cy_hi;
-uniform float _dp_cy_lo;
-uniform float _dp_w;
-uniform float _dp_h;
-
-vec4 _dp_coord() {
-  // Per-pixel offset from center \u2014 small, so float-precise
-  float dx = (v_uv.x - 0.5) * _dp_w;
-  float dy = (v_uv.y - 0.5) * _dp_h;
-  // Combine center (hi+lo) + delta with emulated double precision
-  vec2 cre = ds_add(vec2(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
-  vec2 cim = ds_add(vec2(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
-  return vec4(cre.x, cim.x, cre.y, cim.y);
-}
-
-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 = `
-@group(0) @binding(10) var<uniform> _dp_cx_hi: f32;
-@group(0) @binding(11) var<uniform> _dp_cx_lo: f32;
-@group(0) @binding(12) var<uniform> _dp_cy_hi: f32;
-@group(0) @binding(13) var<uniform> _dp_cy_lo: f32;
-@group(0) @binding(14) var<uniform> _dp_w: f32;
-@group(0) @binding(15) var<uniform> _dp_h: f32;
-
-fn _dp_coord(uv: vec2f) -> vec4f {
-  let dx = (uv.x - 0.5) * _dp_w;
-  let dy = (uv.y - 0.5) * _dp_h;
-  let cre = ds_add(vec2f(_dp_cx_hi, _dp_cx_lo), ds_from(dx));
-  let cim = ds_add(vec2f(_dp_cy_hi, _dp_cy_lo), ds_from(dy));
-  return vec4f(cre.x, cim.x, cre.y, cim.y);
-}
-
-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);
@@ -22263,208 +22486,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;
-uniform float _pt_offset_x;
-uniform float _pt_offset_y;
-uniform float _pt_w;
-uniform float _pt_h;
-
-vec2 _pt_delta() {
-  float dx = _pt_offset_x + (v_uv.x - 0.5) * _pt_w;
-  float dy = _pt_offset_y + (v_uv.y - 0.5) * _pt_h;
-  return vec2(dx, dy);
-}
-
-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;
-var<uniform> _pt_offset_x: f32;
-var<uniform> _pt_offset_y: f32;
-var<uniform> _pt_w: f32;
-var<uniform> _pt_h: f32;
-
-fn _pt_delta(uv: vec2f) -> vec2f {
-  let dx = _pt_offset_x + (uv.x - 0.5) * _pt_w;
-  let dy = _pt_offset_y + (uv.y - 0.5) * _pt_h;
-  return vec2f(dx, dy);
-}
-
-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;
@@ -22505,28 +22526,124 @@ vec3 _gpu_oklab_to_srgb(vec3 lab) {
 
 vec3 _gpu_oklab_to_oklch(vec3 lab) {
   float C = length(lab.yz);
-  float H = atan(lab.z, lab.y);
+  float H = atan(lab.z, lab.y) * (180.0 / 3.14159265359);
+  if (H < 0.0) H += 360.0;
   return vec3(lab.x, C, H);
 }
 
 vec3 _gpu_oklch_to_oklab(vec3 lch) {
-  return vec3(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));
+  float h_rad = lch.z * (3.14159265359 / 180.0);
+  return vec3(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));
 }
 
-vec3 _gpu_color_mix(vec3 rgb1, vec3 rgb2, float t) {
-  vec3 lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));
-  vec3 lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));
+vec3 _gpu_srgb_to_oklch(vec3 rgb) {
+  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));
+}
+
+vec3 _gpu_oklch_to_srgb(vec3 lch) {
+  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));
+}
+
+// HSL conversion. Hue in degrees, saturation/lightness in 0-1.
+vec3 _gpu_hsl_to_rgb(vec3 hsl) {
+  float h = hsl.x;
+  float s = hsl.y;
+  float l = hsl.z;
+  float c = (1.0 - abs(2.0 * l - 1.0)) * s;
+  float h6 = h / 60.0;
+  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));
+  float r = 0.0;
+  float g = 0.0;
+  float b = 0.0;
+  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }
+  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }
+  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }
+  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }
+  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }
+  else               { r = c; g = 0.0; b = x; }
+  float m = l - c / 2.0;
+  return vec3(r + m, g + m, b + m);
+}
+
+vec3 _gpu_rgb_to_hsl(vec3 rgb) {
+  float maxc = max(max(rgb.x, rgb.y), rgb.z);
+  float minc = min(min(rgb.x, rgb.y), rgb.z);
+  float l = (maxc + minc) / 2.0;
+  float d = maxc - minc;
+  if (d < 1e-6) return vec3(0.0, 0.0, l);
+  float s = d / (1.0 - abs(2.0 * l - 1.0));
+  float h;
+  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);
+  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;
+  else                    h = (rgb.x - rgb.y) / d + 4.0;
+  h *= 60.0;
+  if (h < 0.0) h += 360.0;
+  return vec3(h, s, l);
+}
+
+// HSV conversion. Hue in degrees, saturation/value in 0-1.
+vec3 _gpu_hsv_to_rgb(vec3 hsv) {
+  float h = hsv.x;
+  float s = hsv.y;
+  float v = hsv.z;
+  float c = v * s;
+  float h6 = h / 60.0;
+  float x = c * (1.0 - abs(mod(h6, 2.0) - 1.0));
+  float r = 0.0;
+  float g = 0.0;
+  float b = 0.0;
+  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }
+  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }
+  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }
+  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }
+  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }
+  else               { r = c; g = 0.0; b = x; }
+  float m = v - c;
+  return vec3(r + m, g + m, b + m);
+}
+
+vec3 _gpu_rgb_to_hsv(vec3 rgb) {
+  float maxc = max(max(rgb.x, rgb.y), rgb.z);
+  float minc = min(min(rgb.x, rgb.y), rgb.z);
+  float v = maxc;
+  float d = maxc - minc;
+  if (d < 1e-6) return vec3(0.0, 0.0, v);
+  float s = (maxc < 1e-6) ? 0.0 : d / maxc;
+  float h;
+  if (maxc == rgb.x)      h = mod((rgb.y - rgb.z) / d, 6.0);
+  else if (maxc == rgb.y) h = (rgb.z - rgb.x) / d + 2.0;
+  else                    h = (rgb.x - rgb.y) / d + 4.0;
+  h *= 60.0;
+  if (h < 0.0) h += 360.0;
+  return vec3(h, s, v);
+}
+
+vec3 _gpu_color_mix(vec3 lch1, vec3 lch2, float t) {
   float L = mix(lch1.x, lch2.x, t);
   float C = mix(lch1.y, lch2.y, t);
-  float dh = lch2.z - lch1.z;
-  const float PI = 3.14159265359;
-  if (dh > PI) dh -= 2.0 * PI;
-  if (dh < -PI) dh += 2.0 * PI;
-  float H = lch1.z + dh * t;
-  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3(L, C, H)));
+  bool a1 = lch1.y < 1e-6;
+  bool a2 = lch2.y < 1e-6;
+  float H;
+  if (a1 && a2) {
+    H = lch1.z;
+  } else if (a1) {
+    H = lch2.z;
+  } else if (a2) {
+    H = lch1.z;
+  } else {
+    float dh = lch2.z - lch1.z;
+    if (dh > 180.0) dh -= 360.0;
+    if (dh < -180.0) dh += 360.0;
+    H = lch1.z + dh * t;
+    if (H < 0.0) H += 360.0;
+    if (H >= 360.0) H -= 360.0;
+  }
+  return vec3(L, C, H);
 }
 
-float _gpu_apca(vec3 bg, vec3 fg) {
+float _gpu_apca(vec3 lch_bg, vec3 lch_fg) {
+  vec3 bg = _gpu_oklch_to_srgb(lch_bg);
+  vec3 fg = _gpu_oklch_to_srgb(lch_fg);
   float bgR = _gpu_srgb_to_linear(bg.x);
   float bgG = _gpu_srgb_to_linear(bg.y);
   float bgB = _gpu_srgb_to_linear(bg.z);
@@ -22537,9 +22654,7 @@ float _gpu_apca(vec3 bg, vec3 fg) {
   float fgY = 0.2126729 * fgR + 0.7151522 * fgG + 0.0721750 * fgB;
   float bgC = pow(bgY, 0.56);
   float fgC = pow(fgY, 0.57);
-  float contrast = (bgC > fgC)
-    ? (bgC - fgC) * 1.14
-    : (bgC - fgC) * 1.14;
+  float contrast = (bgC - fgC) * 1.14;
   return contrast * 100.0;
 }
 `;
@@ -22583,28 +22698,133 @@ fn _gpu_oklab_to_srgb(lab: vec3f) -> vec3f {
 
 fn _gpu_oklab_to_oklch(lab: vec3f) -> vec3f {
   let C = length(lab.yz);
-  let H = atan2(lab.z, lab.y);
+  var H = atan2(lab.z, lab.y) * (180.0 / 3.14159265359);
+  if (H < 0.0) { H = H + 360.0; }
   return vec3f(lab.x, C, H);
 }
 
 fn _gpu_oklch_to_oklab(lch: vec3f) -> vec3f {
-  return vec3f(lch.x, lch.y * cos(lch.z), lch.y * sin(lch.z));
+  let h_rad = lch.z * (3.14159265359 / 180.0);
+  return vec3f(lch.x, lch.y * cos(h_rad), lch.y * sin(h_rad));
+}
+
+fn _gpu_srgb_to_oklch(rgb: vec3f) -> vec3f {
+  return _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb));
+}
+
+fn _gpu_oklch_to_srgb(lch: vec3f) -> vec3f {
+  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(lch));
+}
+
+fn _gpu_hsl_to_rgb(hsl: vec3f) -> vec3f {
+  let h = hsl.x;
+  let s = hsl.y;
+  let l = hsl.z;
+  let c = (1.0 - abs(2.0 * l - 1.0)) * s;
+  let h6 = h / 60.0;
+  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));
+  var r: f32 = 0.0;
+  var g: f32 = 0.0;
+  var b: f32 = 0.0;
+  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }
+  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }
+  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }
+  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }
+  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }
+  else               { r = c; g = 0.0; b = x; }
+  let m = l - c / 2.0;
+  return vec3f(r + m, g + m, b + m);
+}
+
+fn _gpu_rgb_to_hsl(rgb: vec3f) -> vec3f {
+  let maxc = max(max(rgb.x, rgb.y), rgb.z);
+  let minc = min(min(rgb.x, rgb.y), rgb.z);
+  let l = (maxc + minc) / 2.0;
+  let d = maxc - minc;
+  if (d < 1e-6) { return vec3f(0.0, 0.0, l); }
+  let s = d / (1.0 - abs(2.0 * l - 1.0));
+  var h: f32;
+  if (maxc == rgb.x) {
+    let v = (rgb.y - rgb.z) / d;
+    h = v - 6.0 * floor(v / 6.0);
+  } else if (maxc == rgb.y) {
+    h = (rgb.z - rgb.x) / d + 2.0;
+  } else {
+    h = (rgb.x - rgb.y) / d + 4.0;
+  }
+  h = h * 60.0;
+  if (h < 0.0) { h = h + 360.0; }
+  return vec3f(h, s, l);
+}
+
+fn _gpu_hsv_to_rgb(hsv: vec3f) -> vec3f {
+  let h = hsv.x;
+  let s = hsv.y;
+  let v = hsv.z;
+  let c = v * s;
+  let h6 = h / 60.0;
+  let x = c * (1.0 - abs((h6 - 2.0 * floor(h6 / 2.0)) - 1.0));
+  var r: f32 = 0.0;
+  var g: f32 = 0.0;
+  var b: f32 = 0.0;
+  if (h6 < 1.0)      { r = c; g = x; b = 0.0; }
+  else if (h6 < 2.0) { r = x; g = c; b = 0.0; }
+  else if (h6 < 3.0) { r = 0.0; g = c; b = x; }
+  else if (h6 < 4.0) { r = 0.0; g = x; b = c; }
+  else if (h6 < 5.0) { r = x; g = 0.0; b = c; }
+  else               { r = c; g = 0.0; b = x; }
+  let m = v - c;
+  return vec3f(r + m, g + m, b + m);
+}
+
+fn _gpu_rgb_to_hsv(rgb: vec3f) -> vec3f {
+  let maxc = max(max(rgb.x, rgb.y), rgb.z);
+  let minc = min(min(rgb.x, rgb.y), rgb.z);
+  let v = maxc;
+  let d = maxc - minc;
+  if (d < 1e-6) { return vec3f(0.0, 0.0, v); }
+  var s: f32 = 0.0;
+  if (maxc >= 1e-6) { s = d / maxc; }
+  var h: f32;
+  if (maxc == rgb.x) {
+    let q = (rgb.y - rgb.z) / d;
+    h = q - 6.0 * floor(q / 6.0);
+  } else if (maxc == rgb.y) {
+    h = (rgb.z - rgb.x) / d + 2.0;
+  } else {
+    h = (rgb.x - rgb.y) / d + 4.0;
+  }
+  h = h * 60.0;
+  if (h < 0.0) { h = h + 360.0; }
+  return vec3f(h, s, v);
 }
 
-fn _gpu_color_mix(rgb1: vec3f, rgb2: vec3f, t: f32) -> vec3f {
-  let lch1 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb1));
-  let lch2 = _gpu_oklab_to_oklch(_gpu_srgb_to_oklab(rgb2));
+fn _gpu_color_mix(lch1: vec3f, lch2: vec3f, t: f32) -> vec3f {
   let L = mix(lch1.x, lch2.x, t);
   let C = mix(lch1.y, lch2.y, t);
-  let PI = 3.14159265359;
-  var dh = lch2.z - lch1.z;
-  if (dh > PI) { dh -= 2.0 * PI; }
-  if (dh < -PI) { dh += 2.0 * PI; }
-  let H = lch1.z + dh * t;
-  return _gpu_oklab_to_srgb(_gpu_oklch_to_oklab(vec3f(L, C, H)));
+  let a1 = lch1.y < 1e-6;
+  let a2 = lch2.y < 1e-6;
+  var H: f32;
+  if (a1 && a2) {
+    H = lch1.z;
+  } else if (a1) {
+    H = lch2.z;
+  } else if (a2) {
+    H = lch1.z;
+  } else {
+    var dh = lch2.z - lch1.z;
+    if (dh > 180.0) { dh = dh - 360.0; }
+    if (dh < -180.0) { dh = dh + 360.0; }
+    H = lch1.z + dh * t;
+    if (H < 0.0) { H = H + 360.0; }
+    if (H >= 360.0) { H = H - 360.0; }
+  }
+  return vec3f(L, C, H);
 }
 
-fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
+fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
+  let bg = _gpu_oklch_to_srgb(lch_bg);
+  let fg = _gpu_oklch_to_srgb(lch_fg);
   let bgR = _gpu_srgb_to_linear(bg.x);
   let bgG = _gpu_srgb_to_linear(bg.y);
   let bgB = _gpu_srgb_to_linear(bg.z);
@@ -22892,7 +23112,7 @@ var GPUShaderTarget = class {
         if (stmts.length === 0) return "";
         const last = stmts.length - 1;
         stmts[last] = `return ${stmts[last]}`;
-        return stmts.join(";\n");
+        return stmts.join(";\n") + ";";
       },
       ...options
     };
@@ -22903,7 +23123,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];
@@ -22942,89 +23161,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_dp") || code.includes("_fractal_julia_dp")) && options.hints?.viewport) {
-      const cx = hpToNumber(options.hints.viewport.center[0]);
-      const cy = hpToNumber(options.hints.viewport.center[1]);
-      const size = options.hints.viewport.radius * 2;
-      const cx_hi = Math.fround(cx);
-      const cy_hi = Math.fround(cy);
-      result.uniforms = {
-        ...result.uniforms,
-        _dp_cx_hi: cx_hi,
-        _dp_cx_lo: cx - cx_hi,
-        _dp_cy_hi: cy_hi,
-        _dp_cy_lo: cy - cy_hi,
-        _dp_w: size,
-        _dp_h: size
-      };
-    }
-    if ((code.includes("_fractal_mandelbrot_pt") || code.includes("_fractal_julia_pt")) && options.hints?.viewport) {
-      const viewport = options.hints.viewport;
-      const size = viewport.radius * 2;
-      result.uniforms = {
-        ...result.uniforms,
-        _pt_offset_x: 0,
-        _pt_offset_y: 0,
-        _pt_w: size,
-        _pt_h: size
-      };
-      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(expr, _options = {}) {
@@ -23069,7 +23211,7 @@ var GLSLTarget = class extends GPUShaderTarget {
     if (body.includes("\n")) {
       const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
       return `${returnType} ${functionName}(${params}) {
-${indented};
+${indented}
 }`;
     }
     return `${returnType} ${functionName}(${params}) {
@@ -23180,7 +23322,7 @@ var WGSLTarget = class extends GPUShaderTarget {
       return `fn ${functionName}(${params}) -> ${toWGSLType(
         returnType
       )} {
-${indented};
+${indented}
 }`;
     }
     return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
@@ -25359,7 +25501,7 @@ function compileToIntervalTarget(expr, target) {
 }
 
 // src/compile.ts
-var version = "0.55.5";
+var version = "0.56.0";
 export {
   BaseCompiler,
   GLSLTarget,