@cortex-js/compute-engine 0.55.5 → 0.56.0

package/dist/core.umd.cjs

@@ -1,4 +1,4 @@
-/** ComputeEngineCore 0.55.5 */
+/** ComputeEngineCore 0.56.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngineCore = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngineCore = (() => {
   var __defProp = Object.defineProperty;
@@ -2287,6 +2287,7 @@ var ComputeEngineCore = (() => {
   ];
   var VALUE_TYPES = [
     "value",
+    "color",
     ...COLLECTION_TYPES,
     ...SCALAR_TYPES
   ];
@@ -3986,6 +3987,7 @@ var ComputeEngineCore = (() => {
     symbol: [],
     boolean: [],
     string: [],
+    color: [],
     expression: EXPRESSION_TYPES
   };
   function isPrimitiveSubtype(lhs, rhs) {
@@ -7869,9 +7871,10 @@ var ComputeEngineCore = (() => {
         if (!materialized.isLazyCollection) return materialized.latex;
       }
       const syntax = this.engine._requireLatexSyntax();
-      return syntax.serialize(
-        this.toMathJson({ prettify: true, fractionalDigits: "auto" })
-      );
+      const json = this.toMathJson({ prettify: true, fractionalDigits: "auto" });
+      const latexOpts = this.engine.latexOptions;
+      if (Object.keys(latexOpts).length === 0) return syntax.serialize(json);
+      return syntax.serialize(json, { ...latexOpts });
     }
     /**
      * Return a LaTeX representation of this expression with custom
@@ -7895,9 +7898,13 @@ var ComputeEngineCore = (() => {
         fractionalDigits: "auto"
       });
       const syntax = this.engine._requireLatexSyntax();
-      if (!options || Object.keys(options).length === 0)
-        return syntax.serialize(json);
-      return syntax.serialize(json, options);
+      const latexOpts = this.engine.latexOptions;
+      const haveEngineOpts = Object.keys(latexOpts).length > 0;
+      const haveCallOpts = options && Object.keys(options).length > 0;
+      if (!haveEngineOpts && !haveCallOpts) return syntax.serialize(json);
+      if (!haveEngineOpts) return syntax.serialize(json, options);
+      if (!haveCallOpts) return syntax.serialize(json, { ...latexOpts });
+      return syntax.serialize(json, { ...latexOpts, ...options });
     }
     /** Called by `JSON.stringify()` when serializing to json.
      *
@@ -7941,11 +7948,13 @@ var ComputeEngineCore = (() => {
             "number",
             "dictionary"
           ];
-        }
-        if (Array.isArray(options.shorthands))
+        } else if (Array.isArray(options.shorthands)) {
           defaultOptions.shorthands = options.shorthands;
+        }
         if (typeof options.metadata === "string" && options.metadata === "all" || options.metadata?.includes("all")) {
           defaultOptions.metadata = ["latex", "wikidata"];
+        } else if (Array.isArray(options.metadata)) {
+          defaultOptions.metadata = options.metadata;
         }
         if (options.fractionalDigits === "auto")
           defaultOptions.fractionalDigits = -this.engine.precision;
@@ -11084,10 +11093,6 @@ var ComputeEngineCore = (() => {
     // 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));
@@ -12125,14 +12130,18 @@ var ComputeEngineCore = (() => {
         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",
@@ -12219,7 +12228,6 @@ var ComputeEngineCore = (() => {
     // commands like \rbrack a, b \rbrack which are unambiguous.
     {
       name: "Multiple",
-      // @todo: parse
       serialize: serializeSet
     },
     {
@@ -12228,14 +12236,28 @@ var ComputeEngineCore = (() => {
       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);
         }
@@ -12243,6 +12265,17 @@ var ComputeEngineCore = (() => {
         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(", "),
@@ -12409,23 +12442,6 @@ var ComputeEngineCore = (() => {
     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") {
@@ -13573,11 +13589,13 @@ var ComputeEngineCore = (() => {
         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)
         ];
       },
@@ -13658,6 +13676,8 @@ var ComputeEngineCore = (() => {
       precedence: DIVISION_PRECEDENCE,
       parse: "Mod"
     },
+    // Function-style alias: `\operatorname{mod}(a, b)`
+    { latexTrigger: "\\operatorname{mod}", parse: "Mod" },
     {
       latexTrigger: "\\pmod",
       kind: "prefix",
@@ -13898,6 +13918,13 @@ var ComputeEngineCore = (() => {
         const rhs = serializer.wrap(operand(expr2, 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, expr2) => "\\operatorname{distance}" + serializer.wrapArguments(expr2)
     }
   ];
   function getIndexAssignment(expr2, upper) {
@@ -15322,7 +15349,9 @@ var ComputeEngineCore = (() => {
         if (!expr2 || !symbol(expr2)) return null;
         return ["Mean", expr2];
       }
-    }
+    },
+    // Function-style alias: `\operatorname{var}(...)`
+    { latexTrigger: "\\operatorname{var}", parse: "Variance" }
   ];
 
   // src/compute-engine/numerics/unit-data.ts
@@ -15874,12 +15903,52 @@ var ComputeEngineCore = (() => {
   ];
 
   // 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",
@@ -16119,80 +16188,71 @@ var ComputeEngineCore = (() => {
     },
     {
       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",
@@ -16204,6 +16264,10 @@ var ComputeEngineCore = (() => {
           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([
@@ -16291,6 +16355,28 @@ var ComputeEngineCore = (() => {
       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) => {
@@ -16341,7 +16427,17 @@ var ComputeEngineCore = (() => {
       // `["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 "";
@@ -16356,7 +16452,7 @@ var ComputeEngineCore = (() => {
           36: "\\qquad"
         }[v] ?? "";
       }
-    }
+    },
     // if (
     //   [
     //     '\\!',
@@ -16380,6 +16476,121 @@ var ComputeEngineCore = (() => {
     //     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, expr2) => "\\operatorname{triangle}" + serializer.wrapArguments(expr2)
+    },
+    // 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, expr2) => "\\operatorname{vector}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Sphere",
+      latexTrigger: ["\\operatorname{sphere}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{sphere}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Segment",
+      latexTrigger: ["\\operatorname{segment}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{segment}" + serializer.wrapArguments(expr2)
+    }
+  ];
+
+  // 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, expr2) => "\\operatorname{rgb}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Hsv",
+      latexTrigger: ["\\operatorname{hsv}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{hsv}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Hsl",
+      latexTrigger: ["\\operatorname{hsl}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{hsl}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Oklab",
+      latexTrigger: ["\\operatorname{oklab}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{oklab}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "Oklch",
+      latexTrigger: ["\\operatorname{oklch}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{oklch}" + serializer.wrapArguments(expr2)
+    },
+    // Conversion functions (color → color in the named space)
+    {
+      name: "AsRgb",
+      latexTrigger: ["\\operatorname{asRgb}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{asRgb}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "AsHsv",
+      latexTrigger: ["\\operatorname{asHsv}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{asHsv}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "AsHsl",
+      latexTrigger: ["\\operatorname{asHsl}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{asHsl}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "AsOklab",
+      latexTrigger: ["\\operatorname{asOklab}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{asOklab}" + serializer.wrapArguments(expr2)
+    },
+    {
+      name: "AsOklch",
+      latexTrigger: ["\\operatorname{asOklch}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{asOklch}" + serializer.wrapArguments(expr2)
+    },
+    // Perceptual difference (returns a scalar in [0, ~1])
+    {
+      name: "ColorDelta",
+      latexTrigger: ["\\operatorname{colorDelta}"],
+      kind: "function",
+      serialize: (serializer, expr2) => "\\operatorname{colorDelta}" + serializer.wrapArguments(expr2)
+    }
   ];
 
   // src/compute-engine/latex-syntax/dictionary/default-dictionary.ts
@@ -16410,7 +16621,8 @@ var ComputeEngineCore = (() => {
     ...DEFINITIONS_STATISTICS,
     ...DEFINITIONS_UNITS,
     ...DEFINITIONS_OTHERS,
-    ...DEFINITIONS_PHYSICS
+    ...DEFINITIONS_PHYSICS,
+    ...DEFINITIONS_COLORS
   ];
 
   // src/math-json/symbols.ts
@@ -16575,6 +16787,17 @@ var ComputeEngineCore = (() => {
       } else if (Array.isArray(openTrigger) && openTrigger.length > 0) {
         openTokens.push(openTrigger[0]);
       }
+      const closeTrigger = indexedEntry.closeTrigger;
+      const closeTokens = /* @__PURE__ */ new Set();
+      if (typeof closeTrigger === "string") {
+        const variants = DELIMITER_SHORTHAND[closeTrigger];
+        if (variants) for (const v of variants) closeTokens.add(v);
+        else closeTokens.add(closeTrigger);
+        if (closeTrigger === "||") closeTokens.add("|");
+      } else if (Array.isArray(closeTrigger) && closeTrigger.length > 0) {
+        closeTokens.add(closeTrigger[0]);
+      }
+      indexedEntry.closeTokens = closeTokens;
       for (const token of openTokens) {
         const existing = result.matchfixByOpen.get(token);
         if (existing) {
@@ -16732,25 +16955,43 @@ var ComputeEngineCore = (() => {
       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);
@@ -17635,6 +17876,16 @@ var ComputeEngineCore = (() => {
   }
 
   // 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", ")"],
@@ -18082,6 +18333,35 @@ var ComputeEngineCore = (() => {
         this.nextToken();
         this.skipVisualSpace();
       }
+      if (this.match("\\hspace")) {
+        this.match("*");
+        this.parseStringGroup();
+        this.skipVisualSpace();
+      }
+      if (this.match("\\hskip") || this.match("\\kern")) {
+        this.skipSpace();
+        if (!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) {
@@ -18419,7 +18699,8 @@ var ComputeEngineCore = (() => {
         } else if (token === "<space>") {
           result += " ";
         } else if (token[0] === "\\") {
-          result += token;
+          const unicode = getSymbolToUnicode().get(token);
+          result += unicode ?? token;
         } else {
           result += token;
         }
@@ -18573,6 +18854,19 @@ var ComputeEngineCore = (() => {
       }
       for (const def of defs) {
         this.index = start;
+        if (def.closeTokens.size > 0) {
+          let found = false;
+          const tokens = this._tokens;
+          for (let i = start; i < tokens.length; i++) {
+            if (def.closeTokens.has(tokens[i])) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) continue;
+        }
+        if (typeof def.openTrigger === "string" && def.openTrigger === "." && !OPEN_DELIMITER_PREFIX[currentToken])
+          continue;
         const matched = this.matchDelimiter(def.openTrigger, def.closeTrigger);
         if (!matched) continue;
         const bodyStart = this.index;
@@ -19779,7 +20073,7 @@ var ComputeEngineCore = (() => {
     sansserif: (s) => `\\mathsf{${s}}`,
     monospace: (s) => `\\mathtt{${s}}`
   };
-  var Serializer4 = class {
+  var Serializer5 = class {
     options;
     dictionary;
     level = -1;
@@ -19794,11 +20088,18 @@ var ComputeEngineCore = (() => {
     /**
      * 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)
@@ -20092,7 +20393,7 @@ var ComputeEngineCore = (() => {
     return body;
   }
   function serializeLatex(expr2, dict, options) {
-    const serializer = new Serializer4(dict, options);
+    const serializer = new Serializer5(dict, options);
     return serializer.serialize(expr2);
   }
 
@@ -32128,6 +32429,29 @@ ${lines.join("\n")}`;
         signature: "(value*) -> number | list",
         evaluate: (xs, { engine }) => evaluateMinMax(engine, xs, "Infimum")
       },
+      Distance: {
+        description: "Euclidean distance between two points (tuples of numbers).",
+        complexity: 6e3,
+        signature: "(tuple, tuple) -> number",
+        evaluate: ([a, b], { engine: ce }) => {
+          if (!isFunction2(a) || !isFunction2(b))
+            return ce.error("incompatible-type");
+          if (a.operator !== "Tuple" || b.operator !== "Tuple")
+            return ce.error("incompatible-type");
+          if (a.ops.length !== b.ops.length || a.ops.length === 0)
+            return ce.error("incompatible-type");
+          let sumSq = 0;
+          for (let i = 0; i < a.ops.length; i++) {
+            const ai = a.ops[i].re;
+            const bi = b.ops[i].re;
+            if (!Number.isFinite(ai) || !Number.isFinite(bi))
+              return ce.error("expected-value");
+            const d = ai - bi;
+            sumSq += d * d;
+          }
+          return ce.number(Math.sqrt(sumSq));
+        }
+      },
       Product: {
         description: "`Product(f, a, b)` computes the product of `f` from `a` to `b`",
         wikidata: "Q901718",
@@ -32660,16 +32984,11 @@ ${lines.join("\n")}`;
       );
     let condFn;
     if (typeof condition === "string") {
-      const latex = asLatexString(condition);
-      if (latex) {
-        const condPattern = ce.parse(latex, {
-          form: options?.canonical ? "canonical" : "raw"
-        }) ?? ce.expr("Nothing");
-        condFn = (x, _ce) => {
-          const evaluated = condPattern.subs(x).evaluate();
-          return isSymbol2(evaluated, "True");
-        };
-      }
+      const condPattern = ce.parse(condition) ?? ce.expr("Nothing");
+      condFn = (x, _ce) => {
+        const evaluated = condPattern.subs(x).evaluate();
+        return isSymbol2(evaluated, "True");
+      };
     } else {
       if (condition !== void 0 && typeof condition !== "function")
         throw new Error(
@@ -32771,6 +33090,15 @@ ${e.message}
   function applyRule(rule, expr2, substitution, options) {
     if (!rule) return null;
     let canonical2 = options?.canonical ?? (expr2.isCanonical || expr2.isStructural);
+    let { match: match2, replace: replace2, condition, id, onMatch, onBeforeMatch } = rule;
+    const because = id ?? "";
+    const ce = expr2.engine;
+    if (canonical2 && match2) {
+      const awc = getWildcards(match2);
+      const canonicalMatch = match2.canonical;
+      const bwc = getWildcards(canonicalMatch);
+      if (!awc.every((x) => bwc.includes(x))) return null;
+    }
     let operandsMatched = false;
     if (isFunction2(expr2) && options?.recursive) {
       const newOps = expr2.ops.map((op) => {
@@ -32782,20 +33110,11 @@ ${e.message}
       if (operandsMatched) {
         if (!canonical2 && options?.canonical === void 0 && newOps.every((x) => x.isCanonical))
           canonical2 = true;
-        expr2 = expr2.engine.function(expr2.operator, newOps, {
+        expr2 = ce.function(expr2.operator, newOps, {
           form: canonical2 ? "canonical" : "raw"
         });
       }
     }
-    let { match: match2, replace: replace2, condition, id, onMatch, onBeforeMatch } = rule;
-    const because = id ?? "";
-    if (canonical2 && match2) {
-      const awc = getWildcards(match2);
-      const canonicalMatch = match2.canonical;
-      const bwc = getWildcards(canonicalMatch);
-      if (!awc.every((x) => bwc.includes(x)))
-        return operandsMatched ? { value: expr2, because } : null;
-    }
     const useVariations = rule.useVariations ?? options?.useVariations ?? false;
     const matchPermutations = options?.matchPermutations ?? true;
     onBeforeMatch?.(rule, expr2);
@@ -32814,7 +33133,7 @@ ${e.message}
         ...sub2
       };
       try {
-        if (!condition(conditionSub, expr2.engine))
+        if (!condition(conditionSub, ce))
           return operandsMatched ? { value: expr2, because } : null;
       } catch (e) {
         console.error(
@@ -32829,7 +33148,8 @@ ${e.message}
     if (!canonical2 && options?.canonical === void 0 && replace2 instanceof _BoxedExpression && replace2.isCanonical)
       canonical2 = true;
     const result = typeof replace2 === "function" ? replace2(expr2, sub2) : replace2.subs(sub2, { canonical: canonical2 });
-    if (!result) return null;
+    if (!result)
+      return operandsMatched ? { value: canonical2 ? expr2.canonical : expr2, because } : null;
     onMatch?.(rule, expr2, result);
     if (isRuleStep(result))
       return canonical2 ? { ...result, value: result.value.canonical } : result;
@@ -38403,6 +38723,40 @@ ${e.message}
     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;
@@ -38427,6 +38781,12 @@ ${e.message}
     if (alpha !== void 0) result.alpha = alpha;
     return result;
   }
+  function asOklch(color) {
+    if (typeof color === "string") return rgbToOklch(parseHexColor(color));
+    if ("C" in color) return color;
+    if ("a" in color && "b" in color) return oklabToOklch(color);
+    return rgbToOklch(color);
+  }
   function asRgb(color) {
     if (typeof color === "number") {
       return {
@@ -38858,6 +39218,13 @@ ${e.message}
   };
   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;
@@ -38990,14 +39357,6 @@ ${e.message}
     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);
@@ -39056,6 +39415,12 @@ ${e.message}
     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);
+  }
   function lerpOklch(c1, c2, f) {
     const L = c1.L + (c2.L - c1.L) * f;
     const C = c1.C + (c2.C - c1.C) * f;
@@ -41817,14 +42182,30 @@ ${e.message}
   };
 
   // src/compute-engine/library/colors.ts
-  function colorNumberToTuple(ce, color) {
-    const r = (color >>> 24 & 255) / 255;
-    const g = (color >>> 16 & 255) / 255;
-    const b = (color >>> 8 & 255) / 255;
-    const a = (color & 255) / 255;
-    if (Math.abs(a - 1) < 1e-4)
-      return ce.tuple(ce.number(r), ce.number(g), ce.number(b));
-    return ce.tuple(ce.number(r), ce.number(g), ce.number(b), ce.number(a));
+  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 normalizeColorHead(ce, expr2) {
+    if (!isFunction2(expr2) || !expr2.ops || expr2.ops.length < 4) return expr2;
+    const alphaExpr = expr2.ops[3];
+    if (!isNumber(alphaExpr)) return expr2;
+    if (normalizeAlpha(alphaExpr.re) === void 0) {
+      return ce.function(expr2.operator, [expr2.ops[0], expr2.ops[1], expr2.ops[2]]);
+    }
+    return expr2;
+  }
+  function colorNumberToOklch(ce, color) {
+    const r = color >>> 24 & 255;
+    const g = color >>> 16 & 255;
+    const b = color >>> 8 & 255;
+    const a = normalizeAlpha((color & 255) / 255);
+    const c = rgbToOklch({ r, g, b });
+    const args = [ce.number(c.L), ce.number(c.C), ce.number(c.H)];
+    if (a !== void 0) args.push(ce.number(a));
+    return ce.function("Oklch", args);
   }
   var ALL_PALETTES = {
     ...SEQUENTIAL_PALETTES,
@@ -41835,45 +42216,139 @@ ${e.message}
     t = Math.max(0, Math.min(1, t));
     const n = palette.length;
     if (n === 0) return ce.error("expected-value");
-    if (n === 1) return colorNumberToTuple(ce, parseColor(palette[0]));
+    if (n === 1) return colorNumberToOklch(ce, parseColor(palette[0]));
     const pos = t * (n - 1);
     const i = Math.floor(pos);
     const frac = pos - i;
-    if (i >= n - 1) return colorNumberToTuple(ce, parseColor(palette[n - 1]));
-    if (frac < 1e-9) return colorNumberToTuple(ce, parseColor(palette[i]));
-    const rgb = interpolateOklch(palette[i], palette[i + 1], frac);
-    const r = rgb.r / 255;
-    const g = rgb.g / 255;
-    const b = rgb.b / 255;
-    return ce.tuple(ce.number(r), ce.number(g), ce.number(b));
+    if (i >= n - 1) return colorNumberToOklch(ce, parseColor(palette[n - 1]));
+    if (frac < 1e-9) return colorNumberToOklch(ce, parseColor(palette[i]));
+    return oklchToExpr(
+      ce,
+      asOklch(interpolateOklch(palette[i], palette[i + 1], frac))
+    );
+  }
+  var COLOR_OPERATORS = /* @__PURE__ */ new Set(["Rgb", "Hsv", "Hsl", "Oklab", "Oklch"]);
+  function readColorExpr(arg) {
+    if (!isFunction2(arg)) return null;
+    if (!COLOR_OPERATORS.has(arg.operator)) return null;
+    if (!arg.ops || arg.ops.length < 3) return null;
+    const c0 = arg.ops[0].re;
+    const c1 = arg.ops[1].re;
+    const c2 = arg.ops[2].re;
+    if (!Number.isFinite(c0) || !Number.isFinite(c1) || !Number.isFinite(c2))
+      return null;
+    const alpha = arg.ops.length >= 4 ? normalizeAlpha(arg.ops[3].re) : void 0;
+    return { space: arg.operator, c0, c1, c2, alpha };
+  }
+  function colorExprToRgb(arg) {
+    const c = readColorExpr(arg);
+    if (!c) return null;
+    const withAlpha = (rgb) => c.alpha !== void 0 ? { ...rgb, alpha: c.alpha } : rgb;
+    switch (c.space) {
+      case "Rgb":
+        return withAlpha({ r: c.c0 * 255, g: c.c1 * 255, b: c.c2 * 255 });
+      case "Hsv":
+        return withAlpha(hsvToRgb(c.c0, c.c1, c.c2));
+      case "Hsl":
+        return withAlpha(hslToRgb(c.c0, c.c1, c.c2));
+      case "Oklab":
+        return withAlpha(oklabToRgb({ L: c.c0, a: c.c1, b: c.c2 }));
+      case "Oklch":
+        return withAlpha(oklchToRgb({ L: c.c0, C: c.c1, H: c.c2 }));
+    }
+    return null;
+  }
+  function colorExprToOklch(arg) {
+    const c = readColorExpr(arg);
+    if (!c) return null;
+    switch (c.space) {
+      case "Oklch":
+        return asOklch({ L: c.c0, C: c.c1, H: c.c2, alpha: c.alpha });
+      case "Oklab":
+        return asOklch({ L: c.c0, a: c.c1, b: c.c2, alpha: c.alpha });
+      case "Rgb":
+        return asOklch({
+          r: c.c0 * 255,
+          g: c.c1 * 255,
+          b: c.c2 * 255,
+          alpha: c.alpha
+        });
+      case "Hsv": {
+        const rgb = hsvToRgb(c.c0, c.c1, c.c2);
+        return asOklch({ ...rgb, alpha: c.alpha });
+      }
+      case "Hsl": {
+        const rgb = hslToRgb(c.c0, c.c1, c.c2);
+        return asOklch({ r: rgb.r, g: rgb.g, b: rgb.b, alpha: c.alpha });
+      }
+    }
+    return null;
+  }
+  function toOklch(ce, arg) {
+    const direct = colorExprToOklch(arg);
+    if (direct) return direct;
+    const rgb = extractRgb(ce, arg);
+    return rgb ? asOklch(rgb) : null;
+  }
+  function lerpOklchColor(a, b, t) {
+    const L = a.L + (b.L - a.L) * t;
+    const C = a.C + (b.C - a.C) * t;
+    const aAchromatic = a.C < 1e-6;
+    const bAchromatic = b.C < 1e-6;
+    let H;
+    if (aAchromatic && bAchromatic) H = a.H;
+    else if (aAchromatic) H = b.H;
+    else if (bAchromatic) H = a.H;
+    else {
+      let dH = b.H - a.H;
+      if (dH > 180) dH -= 360;
+      if (dH < -180) dH += 360;
+      H = a.H + dH * t;
+      if (H < 0) H += 360;
+      if (H >= 360) H -= 360;
+    }
+    const alphaA = a.alpha ?? 1;
+    const alphaB = b.alpha ?? 1;
+    return { L, C, H, alpha: normalizeAlpha(alphaA + (alphaB - alphaA) * t) };
+  }
+  function oklchToExpr(ce, c) {
+    const args = [ce.number(c.L), ce.number(c.C), ce.number(c.H)];
+    if (c.alpha !== void 0) args.push(ce.number(c.alpha));
+    return ce.function("Oklch", args);
   }
   function extractRgb(ce, arg) {
     if (isString(arg)) {
       const s = arg.string;
       if (!s) return void 0;
       const color = parseColor(s);
-      return {
+      const rgb = {
         r: color >>> 24 & 255,
         g: color >>> 16 & 255,
-        b: color >>> 8 & 255,
-        alpha: (color & 255) / 255
+        b: color >>> 8 & 255
       };
+      const alpha = normalizeAlpha((color & 255) / 255);
+      if (alpha !== void 0) rgb.alpha = alpha;
+      return rgb;
     }
+    const fromTyped = colorExprToRgb(arg);
+    if (fromTyped) return fromTyped;
     if (arg.operator === "Tuple" && arg.ops && arg.ops.length >= 3) {
       const rgb = {
         r: arg.ops[0].re * 255,
         g: arg.ops[1].re * 255,
         b: arg.ops[2].re * 255
       };
-      if (arg.ops.length >= 4) rgb.alpha = arg.ops[3].re;
+      if (arg.ops.length >= 4) {
+        const alpha = normalizeAlpha(arg.ops[3].re);
+        if (alpha !== void 0) rgb.alpha = alpha;
+      }
       return rgb;
     }
     return void 0;
   }
   function componentsTuple(ce, components, alpha) {
     const args = components.map((v) => ce.number(v));
-    if (alpha !== void 0 && Math.abs(alpha - 1) > 1e-4)
-      args.push(ce.number(alpha));
+    if (alpha !== void 0) args.push(ce.number(alpha));
     return ce.tuple(...args);
   }
   function rgbToHex(rgb) {
@@ -41881,7 +42356,7 @@ ${e.message}
     const g = Math.round(Math.max(0, Math.min(255, rgb.g)));
     const b = Math.round(Math.max(0, Math.min(255, rgb.b)));
     const 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)));
       return hex + a.toString(16).padStart(2, "0");
     }
@@ -41889,22 +42364,29 @@ ${e.message}
   }
   var COLORS_LIBRARY = {
     Color: {
-      description: "Convert a color string to a canonical sRGB tuple",
+      description: "Parse a CSS-style color string to an Oklch color",
       complexity: 8e3,
-      signature: "(string) -> tuple",
+      signature: "(string) -> color",
       evaluate: (ops, { engine: ce }) => {
         const input = isString(ops[0]) ? ops[0].string : void 0;
         if (!input) return ce.error("incompatible-type");
         const color = parseColor(input);
         if (color === 0 && input.trim().toLowerCase() !== "transparent")
           return ce.error("incompatible-type");
-        return colorNumberToTuple(ce, color);
+        const r = color >>> 24 & 255;
+        const g = color >>> 16 & 255;
+        const b = color >>> 8 & 255;
+        const a = normalizeAlpha((color & 255) / 255);
+        const c = rgbToOklch({ r, g, b });
+        const args = [ce.number(c.L), ce.number(c.C), ce.number(c.H)];
+        if (a !== void 0) args.push(ce.number(a));
+        return ce.function("Oklch", args);
       }
     },
     ColorToString: {
       description: "Convert a color to a string in the specified format",
       complexity: 8e3,
-      signature: "(any, string?) -> string",
+      signature: "(color | string | tuple, string?) -> string",
       evaluate: (ops, { engine: ce }) => {
         const rgb = extractRgb(ce, ops[0]);
         if (!rgb) return ce.error("incompatible-type");
@@ -41916,7 +42398,7 @@ ${e.message}
             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 ce.string(`rgb(${r} ${g} ${b} / ${rgb.alpha})`);
             return ce.string(`rgb(${r} ${g} ${b})`);
           }
@@ -41925,17 +42407,17 @@ ${e.message}
             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 ce.string(`hsl(${h} ${s}% ${l}% / ${rgb.alpha})`);
             return ce.string(`hsl(${h} ${s}% ${l}%)`);
           }
           case "oklch": {
-            const c = rgbToOklch(rgb);
+            const c = colorExprToOklch(ops[0]) ?? asOklch(rgb);
             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)
-              return ce.string(`oklch(${L} ${C} ${H} / ${rgb.alpha})`);
+            if (c.alpha !== void 0)
+              return ce.string(`oklch(${L} ${C} ${H} / ${c.alpha})`);
             return ce.string(`oklch(${L} ${C} ${H})`);
           }
           default:
@@ -41946,60 +42428,44 @@ ${e.message}
     ColorMix: {
       description: "Mix two colors in OKLCh space",
       complexity: 8e3,
-      signature: "(any, any, number?) -> tuple",
+      signature: "(color | string | tuple, color | string | tuple, number?) -> color",
       evaluate: (ops, { engine: ce }) => {
-        const rgb1 = extractRgb(ce, ops[0]);
-        const rgb2 = extractRgb(ce, ops[1]);
-        if (!rgb1 || !rgb2) return ce.error("incompatible-type");
         let ratio = 0.5;
         if (ops.length >= 3 && ops[2] !== void 0) {
           ratio = ops[2].re;
           if (!Number.isFinite(ratio)) return ce.error("expected-value");
           ratio = Math.max(0, Math.min(1, ratio));
         }
-        const c1 = rgbToOklch(rgb1);
-        const c2 = rgbToOklch(rgb2);
-        const mixed = oklchToRgb(lerpOklch(c1, c2, ratio));
-        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;
-        if (Math.abs(alpha - 1) > 1e-4)
-          return ce.tuple(
-            ce.number(r),
-            ce.number(g),
-            ce.number(b),
-            ce.number(alpha)
-          );
-        return ce.tuple(ce.number(r), ce.number(g), ce.number(b));
+        const oklch1 = toOklch(ce, ops[0]);
+        const oklch2 = toOklch(ce, ops[1]);
+        if (!oklch1 || !oklch2) return ce.error("incompatible-type");
+        return oklchToExpr(ce, lerpOklchColor(oklch1, oklch2, ratio));
       }
     },
     Colormap: {
       description: "Sample colors from a named palette",
       complexity: 8e3,
-      signature: "(string, number?) -> any",
+      signature: "(string, number?) -> color | list<color>",
       evaluate: (ops, { engine: ce }) => {
         const name = isString(ops[0]) ? ops[0].string : void 0;
         if (!name) return ce.error("incompatible-type");
         const palette = ALL_PALETTES[name];
         if (!palette) return ce.error("expected-value", name);
         if (ops.length < 2 || ops[1] === void 0) {
-          const tuples = palette.map(
-            (hex) => colorNumberToTuple(ce, parseColor(hex))
+          const colors = palette.map(
+            (hex) => colorNumberToOklch(ce, parseColor(hex))
           );
-          return ce.function("List", tuples);
+          return ce.function("List", colors);
         }
         const val = ops[1].re;
         if (!Number.isFinite(val)) return ce.error("expected-value");
         if (Number.isInteger(val) && val >= 2) {
           const n = val;
-          const tuples = [];
+          const colors = [];
           for (let i = 0; i < n; i++) {
-            tuples.push(samplePalette(ce, palette, i / (n - 1)));
+            colors.push(samplePalette(ce, palette, i / (n - 1)));
           }
-          return ce.function("List", tuples);
+          return ce.function("List", colors);
         }
         return samplePalette(ce, palette, val);
       }
@@ -42007,12 +42473,25 @@ ${e.message}
     ColorToColorspace: {
       description: "Convert a color to components in a target color space",
       complexity: 8e3,
-      signature: "(any, string) -> tuple",
+      signature: "(color | string | tuple, string) -> tuple",
       evaluate: (ops, { engine: ce }) => {
-        const rgb = extractRgb(ce, ops[0]);
-        if (!rgb) return ce.error("incompatible-type");
         const space = isString(ops[1]) ? ops[1].string?.toLowerCase() : void 0;
         if (!space) return ce.error("incompatible-type");
+        if (space === "oklch" || space === "oklab" || space === "lab") {
+          const oklch2 = colorExprToOklch(ops[0]);
+          if (oklch2) {
+            if (space === "oklch")
+              return componentsTuple(
+                ce,
+                [oklch2.L, oklch2.C, oklch2.H],
+                oklch2.alpha
+              );
+            const lab = oklchToOklab(oklch2);
+            return componentsTuple(ce, [lab.L, lab.a, lab.b], lab.alpha);
+          }
+        }
+        const rgb = extractRgb(ce, ops[0]);
+        if (!rgb) return ce.error("incompatible-type");
         const alpha = rgb.alpha;
         switch (space) {
           case "rgb":
@@ -42042,17 +42521,27 @@ ${e.message}
     ColorFromColorspace: {
       description: "Convert color space components to a canonical sRGB tuple",
       complexity: 8e3,
-      signature: "(tuple, string) -> tuple",
+      signature: "(color | tuple, string) -> tuple",
       evaluate: (ops, { engine: ce }) => {
-        const tuple = ops[0];
-        if (!isFunction2(tuple) || tuple.operator !== "Tuple" || tuple.ops.length < 3)
-          return ce.error("incompatible-type");
-        const c0 = tuple.ops[0].re;
-        const c1 = tuple.ops[1].re;
-        const c2 = tuple.ops[2].re;
-        const alpha = tuple.ops.length >= 4 ? tuple.ops[3].re : void 0;
         const space = isString(ops[1]) ? ops[1].string?.toLowerCase() : void 0;
         if (!space) return ce.error("incompatible-type");
+        let c0, c1, c2;
+        let alpha;
+        const arg = ops[0];
+        const typed = readColorExpr(arg);
+        if (typed) {
+          c0 = typed.c0;
+          c1 = typed.c1;
+          c2 = typed.c2;
+          alpha = typed.alpha;
+        } else if (isFunction2(arg) && arg.operator === "Tuple" && arg.ops.length >= 3) {
+          c0 = arg.ops[0].re;
+          c1 = arg.ops[1].re;
+          c2 = arg.ops[2].re;
+          alpha = arg.ops.length >= 4 ? arg.ops[3].re : void 0;
+        } else {
+          return ce.error("incompatible-type");
+        }
         let rgb;
         switch (space) {
           case "rgb":
@@ -42088,7 +42577,7 @@ ${e.message}
     ColorContrast: {
       description: "APCA contrast ratio between two colors",
       complexity: 8e3,
-      signature: "(any, any) -> number",
+      signature: "(color | string | tuple, color | string | tuple) -> number",
       evaluate: (ops, { engine: ce }) => {
         const bgRgb = extractRgb(ce, ops[0]);
         const fgRgb = extractRgb(ce, ops[1]);
@@ -42099,19 +42588,186 @@ ${e.message}
     ContrastingColor: {
       description: "Choose the foreground color with better APCA contrast against a background",
       complexity: 8e3,
-      signature: "(any, any?, any?) -> tuple",
+      signature: "(color | string | tuple, (color | string | tuple)?, (color | string | tuple)?) -> color",
       evaluate: (ops, { engine: ce }) => {
         const bgRgb = extractRgb(ce, ops[0]);
         if (!bgRgb) return ce.error("incompatible-type");
+        let packed;
         if (ops.length >= 3 && ops[1] !== void 0 && ops[2] !== void 0) {
           const fg1 = extractRgb(ce, ops[1]);
           const fg2 = extractRgb(ce, ops[2]);
           if (!fg1 || !fg2) return ce.error("incompatible-type");
-          const result2 = contrastingColor({ bg: bgRgb, fg1, fg2 });
-          return colorNumberToTuple(ce, result2);
+          packed = contrastingColor({ bg: bgRgb, fg1, fg2 });
+        } else {
+          packed = contrastingColor(bgRgb);
+        }
+        const r = (packed >>> 24 & 255) / 255;
+        const g = (packed >>> 16 & 255) / 255;
+        const b = (packed >>> 8 & 255) / 255;
+        const alpha = normalizeAlpha((packed & 255) / 255);
+        const args = [ce.number(r), ce.number(g), ce.number(b)];
+        if (alpha !== void 0) args.push(ce.number(alpha));
+        return ce.function("Rgb", args);
+      }
+    },
+    // ---------------------------------------------------------------------------
+    // Color constructors. Each preserves its colorspace on evaluation; the
+    // operator name is the discriminator. Components are interpreted per
+    // colorspace conventions (Rgb channels 0-1, Hsv/Hsl hue in degrees with
+    // sat/value 0-1, Oklab/Oklch L 0-1 with standard a/b/C/H ranges). The
+    // optional 4th argument is alpha in [0, 1]. No clamping at evaluation time.
+    // ---------------------------------------------------------------------------
+    Rgb: {
+      description: "sRGB color (channels 0-1, optional alpha 0-1)",
+      complexity: 8e3,
+      signature: "(number, number, number, number?) -> color"
+    },
+    Hsv: {
+      description: "HSV color (hue degrees, saturation/value 0-1, optional alpha)",
+      complexity: 8e3,
+      signature: "(number, number, number, number?) -> color"
+    },
+    Hsl: {
+      description: "HSL color (hue degrees, saturation/lightness 0-1, optional alpha)",
+      complexity: 8e3,
+      signature: "(number, number, number, number?) -> color"
+    },
+    Oklab: {
+      description: "OKLab color (L 0-1, a/b ~ -0.4..0.4, optional alpha)",
+      complexity: 8e3,
+      signature: "(number, number, number, number?) -> color"
+    },
+    Oklch: {
+      description: "OKLCh color (L 0-1, C 0-~0.4, hue degrees, optional alpha)",
+      complexity: 8e3,
+      signature: "(number, number, number, number?) -> color"
+    },
+    // ---------------------------------------------------------------------------
+    // Color-space conversions. Each accepts any of the five color heads and
+    // returns the same color in the named space. If the input is already in
+    // the target space, returns the input unchanged.
+    // ---------------------------------------------------------------------------
+    AsRgb: {
+      description: "Convert any color to sRGB (channels 0-1)",
+      complexity: 8e3,
+      signature: "(color) -> color",
+      evaluate: (ops, { engine: ce }) => {
+        const arg = ops[0];
+        if (isFunction2(arg) && arg.operator === "Rgb")
+          return normalizeColorHead(ce, arg);
+        const rgb = colorExprToRgb(arg);
+        if (!rgb) return ce.error("incompatible-type");
+        const args = [
+          ce.number(rgb.r / 255),
+          ce.number(rgb.g / 255),
+          ce.number(rgb.b / 255)
+        ];
+        if (rgb.alpha !== void 0) args.push(ce.number(rgb.alpha));
+        return ce.function("Rgb", args);
+      }
+    },
+    AsHsv: {
+      description: "Convert any color to HSV (hue degrees, s/v 0-1)",
+      complexity: 8e3,
+      signature: "(color) -> color",
+      evaluate: (ops, { engine: ce }) => {
+        const arg = ops[0];
+        if (isFunction2(arg) && arg.operator === "Hsv")
+          return normalizeColorHead(ce, arg);
+        const rgb = colorExprToRgb(arg);
+        if (!rgb) return ce.error("incompatible-type");
+        const hsv = rgbToHsv(rgb.r, rgb.g, rgb.b);
+        const args = [ce.number(hsv.h), ce.number(hsv.s), ce.number(hsv.v)];
+        if (rgb.alpha !== void 0) args.push(ce.number(rgb.alpha));
+        return ce.function("Hsv", args);
+      }
+    },
+    AsHsl: {
+      description: "Convert any color to HSL (hue degrees, s/l 0-1)",
+      complexity: 8e3,
+      signature: "(color) -> color",
+      evaluate: (ops, { engine: ce }) => {
+        const arg = ops[0];
+        if (isFunction2(arg) && arg.operator === "Hsl")
+          return normalizeColorHead(ce, arg);
+        const rgb = colorExprToRgb(arg);
+        if (!rgb) return ce.error("incompatible-type");
+        const hsl = rgbToHsl(rgb.r, rgb.g, rgb.b);
+        const args = [ce.number(hsl.h), ce.number(hsl.s), ce.number(hsl.l)];
+        if (rgb.alpha !== void 0) args.push(ce.number(rgb.alpha));
+        return ce.function("Hsl", args);
+      }
+    },
+    AsOklab: {
+      description: "Convert any color to OKLab",
+      complexity: 8e3,
+      signature: "(color) -> color",
+      evaluate: (ops, { engine: ce }) => {
+        const arg = ops[0];
+        if (isFunction2(arg) && arg.operator === "Oklab")
+          return normalizeColorHead(ce, arg);
+        if (isFunction2(arg) && arg.operator === "Oklch") {
+          const c = readColorExpr(arg);
+          if (!c) return ce.error("incompatible-type");
+          const lab2 = oklchToOklab({ L: c.c0, C: c.c1, H: c.c2, alpha: c.alpha });
+          const args2 = [ce.number(lab2.L), ce.number(lab2.a), ce.number(lab2.b)];
+          if (lab2.alpha !== void 0) args2.push(ce.number(lab2.alpha));
+          return ce.function("Oklab", args2);
+        }
+        const rgb = colorExprToRgb(arg);
+        if (!rgb) return ce.error("incompatible-type");
+        const lab = rgbToOklab(rgb);
+        const args = [ce.number(lab.L), ce.number(lab.a), ce.number(lab.b)];
+        if (rgb.alpha !== void 0) args.push(ce.number(rgb.alpha));
+        return ce.function("Oklab", args);
+      }
+    },
+    AsOklch: {
+      description: "Convert any color to OKLCh",
+      complexity: 8e3,
+      signature: "(color) -> color",
+      evaluate: (ops, { engine: ce }) => {
+        const arg = ops[0];
+        if (isFunction2(arg) && arg.operator === "Oklch")
+          return normalizeColorHead(ce, arg);
+        if (isFunction2(arg) && arg.operator === "Oklab") {
+          const c2 = readColorExpr(arg);
+          if (!c2) return ce.error("incompatible-type");
+          const oklch2 = oklabToOklch({
+            L: c2.c0,
+            a: c2.c1,
+            b: c2.c2,
+            alpha: c2.alpha
+          });
+          const args2 = [
+            ce.number(oklch2.L),
+            ce.number(oklch2.C),
+            ce.number(oklch2.H)
+          ];
+          if (oklch2.alpha !== void 0) args2.push(ce.number(oklch2.alpha));
+          return ce.function("Oklch", args2);
         }
-        const result = contrastingColor(bgRgb);
-        return colorNumberToTuple(ce, result);
+        const rgb = colorExprToRgb(arg);
+        if (!rgb) return ce.error("incompatible-type");
+        const c = rgbToOklch(rgb);
+        const args = [ce.number(c.L), ce.number(c.C), ce.number(c.H)];
+        if (rgb.alpha !== void 0) args.push(ce.number(rgb.alpha));
+        return ce.function("Oklch", args);
+      }
+    },
+    // ---------------------------------------------------------------------------
+    // Perceptual difference. Returns ΔE_OK (Euclidean distance in OKLab),
+    // an approximately perceptually uniform scalar.
+    // ---------------------------------------------------------------------------
+    ColorDelta: {
+      description: "Perceptual color difference (\u0394E_OK) between two colors",
+      complexity: 8e3,
+      signature: "(color | string | tuple, color | string | tuple) -> number",
+      evaluate: (ops, { engine: ce }) => {
+        const a = toOklch(ce, ops[0]);
+        const b = toOklch(ce, ops[1]);
+        if (!a || !b) return ce.error("incompatible-type");
+        return ce.number(oklabDeltaE(oklchToOklab(a), oklchToOklab(b)));
       }
     }
   };
@@ -42131,12 +42787,14 @@ ${e.message}
         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)) {
@@ -44589,6 +45247,34 @@ ${e.message}
         signature: "() -> expression",
         evaluate: (_ops, { engine }) => engine.expr(randomExpression())
       }
+    },
+    // ---------------------------------------------------------------------------
+    // Opaque typed heads — registered so the names are in the standard set
+    // (consumers can branch on the operator name); CE itself does not evaluate
+    // them. Geometric primitives `Triangle`/`Sphere`/`Segment` and the action
+    // arrow `To` (`a \to b`).
+    // ---------------------------------------------------------------------------
+    {
+      Triangle: {
+        description: "Triangle primitive \u2014 opaque typed head.",
+        signature: "(any+) -> expression"
+      },
+      GeometricVector: {
+        description: "Geometric vector (directed segment between two points) \u2014 opaque typed head. Distinct from the column-vector `Vector` operator.",
+        signature: "(any, any) -> expression"
+      },
+      Sphere: {
+        description: "Sphere primitive \u2014 opaque typed head.",
+        signature: "(any+) -> expression"
+      },
+      Segment: {
+        description: "Segment primitive \u2014 opaque typed head.",
+        signature: "(any+) -> expression"
+      },
+      To: {
+        description: "Action arrow / mapping (`a \\to b`) \u2014 opaque typed head.",
+        signature: "(any, any) -> nothing"
+      }
     }
   ];
 
@@ -51725,6 +52411,7 @@ Error in definition of "${name}"`,
 
   // src/compute-engine/boxed-expression/cache.ts
   function cachedValue(v, generation, fn) {
+    if (v.generation === generation && v.value !== null) return v.value;
     v.generation = generation;
     v.value = fn();
     return v.value;
@@ -53502,6 +54189,12 @@ Error in definition of "${name}"`,
   function _escapeJsonString(s) {
     return s;
   }
+  function _serializeLatexMetadata(ce, expr2) {
+    const syntax = ce.latexSyntax;
+    const opts = ce.latexOptions;
+    if (Object.keys(opts).length === 0) return syntax.serialize(expr2);
+    return syntax.serialize(expr2, { ...opts });
+  }
   function serializeSubtract(ce, a, b, options, metadata) {
     if (isNumber(a) && a.isNegative) {
       const v = a.numericValue;
@@ -53806,7 +54499,7 @@ Error in definition of "${name}"`,
     ];
     const md = { ...metadata ?? {} };
     if (options.metadata.includes("latex") && ce.latexSyntax) {
-      md.latex = _escapeJsonString(md.latex ?? ce.latexSyntax.serialize(fn));
+      md.latex = _escapeJsonString(md.latex ?? _serializeLatexMetadata(ce, fn));
     } else md.latex = "";
     if (!options.metadata.includes("wikidata")) md.wikidata = "";
     if (!md.latex && !md.wikidata && options.shorthands.includes("function"))
@@ -53831,7 +54524,7 @@ Error in definition of "${name}"`,
     }
     metadata = { ...metadata };
     if (options.metadata.includes("latex") && ce.latexSyntax) {
-      metadata.latex = metadata.latex ?? ce.latexSyntax.serialize(sym2);
+      metadata.latex = metadata.latex ?? _serializeLatexMetadata(ce, sym2);
       if (metadata.latex !== void 0)
         metadata.latex = _escapeJsonString(metadata.latex);
     } else metadata.latex = void 0;
@@ -53993,7 +54686,7 @@ Error in definition of "${name}"`,
         }
       }
       if (options.metadata.includes("latex") && ce.latexSyntax)
-        metadata.latex = metadata.latex ?? ce.latexSyntax.serialize(result2 ?? { num });
+        metadata.latex = metadata.latex ?? _serializeLatexMetadata(ce, result2 ?? { num });
       if (result2) {
         if (metadata.latex !== void 0)
           return { sym: result2, latex: metadata.latex };
@@ -54009,7 +54702,7 @@ Error in definition of "${name}"`,
       if (value.isNaN()) {
         num = "NaN";
         if (options.metadata.includes("latex") && ce.latexSyntax)
-          metadata.latex = metadata.latex ?? ce.latexSyntax.serialize({ num });
+          metadata.latex = metadata.latex ?? _serializeLatexMetadata(ce, { num });
         return metadata.latex !== void 0 ? { num, latex: metadata.latex } : { num };
       }
       return serializeJsonFunction(
@@ -54043,7 +54736,7 @@ Error in definition of "${name}"`,
         value = Number(value);
       } else {
         if (options.metadata.includes("latex") && ce.latexSyntax)
-          metadata.latex = metadata.latex ?? ce.latexSyntax.serialize({
+          metadata.latex = metadata.latex ?? _serializeLatexMetadata(ce, {
             num: value.toString()
           });
         if (metadata.latex !== void 0)
@@ -54057,7 +54750,7 @@ Error in definition of "${name}"`,
       result = value > 0 ? "PositiveInfinity" : "NegativeInfinity";
     else num = serializeRepeatingDecimals(value.toString(), options);
     if (options.metadata.includes("latex") && ce.latexSyntax)
-      metadata.latex = metadata.latex ?? ce.latexSyntax.serialize({ num });
+      metadata.latex = metadata.latex ?? _serializeLatexMetadata(ce, { num });
     if (result) {
       if (metadata.latex !== void 0)
         return { sym: result, latex: metadata.latex };
@@ -54810,8 +55503,7 @@ Error in definition of "${name}"`,
         vars: options?.vars,
         imports: options?.imports,
         preamble: options?.preamble,
-        realOnly: options?.realOnly,
-        hints: options?.hints
+        realOnly: options?.realOnly
       });
     } catch (e) {
       if (options?.fallback ?? true) {
@@ -54823,8 +55515,7 @@ Error in definition of "${name}"`,
           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 expr2.evaluate().re;
           } finally {
@@ -60054,8 +60745,7 @@ Error in definition of "${name}"`,
           return { re: null, im: formatFloat(iScale) };
         }
         const compiledFactors = remaining.map((r) => compile3(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 };
       }
@@ -60659,39 +61349,130 @@ Error in definition of "${name}"`,
       if (args.length >= 2)
         return `_SYS.colormap(${compile3(args[0])}, ${compile3(args[1])})`;
       return `_SYS.colormap(${compile3(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, compile3) => {
+      if (args.length < 3) throw new Error("Rgb: need 3 components");
+      return `_SYS.rgb(${args.map(compile3).join(", ")})`;
+    },
+    Hsv: (args, compile3) => {
+      if (args.length < 3) throw new Error("Hsv: need 3 components");
+      return `_SYS.hsv(${args.map(compile3).join(", ")})`;
+    },
+    Hsl: (args, compile3) => {
+      if (args.length < 3) throw new Error("Hsl: need 3 components");
+      return `_SYS.hsl(${args.map(compile3).join(", ")})`;
+    },
+    Oklab: (args, compile3) => {
+      if (args.length < 3) throw new Error("Oklab: need 3 components");
+      return `_SYS.oklab(${args.map(compile3).join(", ")})`;
+    },
+    Oklch: (args, compile3) => {
+      if (args.length < 3) throw new Error("Oklch: need 3 components");
+      return `_SYS.oklch(${args.map(compile3).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], compile3) => {
+      if (c === null) throw new Error("AsRgb: no argument");
+      return `_SYS.asRgb(${compile3(c)})`;
+    },
+    AsHsv: ([c], compile3) => {
+      if (c === null) throw new Error("AsHsv: no argument");
+      return `_SYS.asHsv(${compile3(c)})`;
+    },
+    AsHsl: ([c], compile3) => {
+      if (c === null) throw new Error("AsHsl: no argument");
+      return `_SYS.asHsl(${compile3(c)})`;
+    },
+    AsOklab: ([c], compile3) => {
+      if (c === null) throw new Error("AsOklab: no argument");
+      return `_SYS.asOklab(${compile3(c)})`;
+    },
+    AsOklch: ([c], compile3) => {
+      if (c === null) throw new Error("AsOklch: no argument");
+      return compile3(c);
+    },
+    // Perceptual color difference (ΔE_OK).
+    ColorDelta: ([a, b], compile3) => {
+      if (a === null || b === null)
+        throw new Error("ColorDelta: need two colors");
+      return `_SYS.colorDelta(${compile3(a)}, ${compile3(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], compile3) => {
+      if (a === null || b === null) throw new Error("Distance: need two points");
+      return `_SYS.distance(${compile3(a)}, ${compile3(b)})`;
     }
   };
   function toRI(c) {
     return { re: c.re, im: c.im };
   }
+  function normalizeAlpha2(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 = normalizeAlpha2((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 = normalizeAlpha2(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 toOklch2(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 = normalizeAlpha2((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 ? normalizeAlpha2(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 = normalizeAlpha2((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);
@@ -60702,7 +61483,7 @@ Error in definition of "${name}"`,
           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");
           }
@@ -60712,7 +61493,7 @@ Error in definition of "${name}"`,
           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})`;
         }
@@ -60721,7 +61502,7 @@ Error in definition of "${name}"`,
           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}%)`;
         }
@@ -60730,7 +61511,7 @@ Error in definition of "${name}"`,
           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})`;
         }
@@ -60739,29 +61520,29 @@ Error in definition of "${name}"`,
       }
     },
     colorMix(input1, input2, ratio = 0.5) {
-      const rgb1 = toRgb255(input1);
-      const rgb2 = toRgb255(input2);
+      const c1 = toOklch2(input1);
+      const c2 = toOklch2(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 = normalizeAlpha2(a1 + (a2 - a1) * ratio);
+      return alpha !== void 0 ? [L, C, H, alpha] : [L, C, H];
     },
     colorContrast(bg, fg) {
       return apca(toRgb255(bg), toRgb255(fg));
@@ -60769,11 +61550,11 @@ Error in definition of "${name}"`,
     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);
@@ -60802,7 +61583,7 @@ Error in definition of "${name}"`,
         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) {
@@ -60814,7 +61595,7 @@ Error in definition of "${name}"`,
       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) {
@@ -60838,62 +61619,128 @@ Error in definition of "${name}"`,
       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 = normalizeAlpha2(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 = normalizeAlpha2(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 = normalizeAlpha2(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 = normalizeAlpha2(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 = normalizeAlpha2(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 = toOklch2(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(toOklch2(a));
+      const labB = oklchToOklab(toOklch2(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 = {
@@ -61311,43 +62158,6 @@ Error in definition of "${name}"`,
     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],
@@ -61369,6 +62179,13 @@ Error in definition of "${name}"`,
   function gpuVec2(target) {
     return target?.language === "wgsl" ? "vec2f" : "vec2";
   }
+  function gpuVec3(target) {
+    return target?.language === "wgsl" ? "vec3f" : "vec3";
+  }
+  function readStringLiteral(expr2) {
+    if (!isString(expr2)) return null;
+    return expr2.string?.toLowerCase() ?? null;
+  }
   function compileIntArg(expr2, compile3, target) {
     const c = tryGetConstant(expr2);
     if (c !== void 0 && Number.isInteger(c)) return c.toString();
@@ -61427,17 +62244,10 @@ Error in definition of "${name}"`,
       `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, compile3, target) => {
@@ -61488,8 +62298,7 @@ Error in definition of "${name}"`,
         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) => compile3(f));
         if (iScale !== 1) factors.unshift(formatFloat(iScale));
         const imCode = foldTerms(factors, "1.0", "*");
@@ -61542,8 +62351,7 @@ Error in definition of "${name}"`,
       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 `(-${compile3(x)})`;
     },
     // Standard math functions with complex dispatch
@@ -61916,49 +62724,139 @@ Error in definition of "${name}"`,
       }
       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], compile3) => {
       if (color === null || space === null)
         throw new Error("ColorToColorspace: need color and space");
-      return `_gpu_srgb_to_oklab(${compile3(color)})`;
+      const spaceName = readStringLiteral(space);
+      if (spaceName === null)
+        throw new Error("ColorToColorspace: space must be a string literal");
+      const c = compile3(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], compile3) => {
       if (components === null || space === null)
         throw new Error("ColorFromColorspace: need components and space");
-      return `_gpu_oklab_to_srgb(${compile3(components)})`;
+      const spaceName = readStringLiteral(space);
+      if (spaceName === null)
+        throw new Error("ColorFromColorspace: space must be a string literal");
+      const c = compile3(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], _compile2, 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, compile3, target) => {
+      if (args.length < 3) throw new Error("Rgb: need 3 components");
+      const v3 = gpuVec3(target);
+      return `_gpu_srgb_to_oklch(${v3}(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(args[2])}))`;
+    },
+    Hsv: (args, compile3, 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}(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(args[2])})))`;
+    },
+    Hsl: (args, compile3, 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}(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(args[2])})))`;
+    },
+    Oklab: (args, compile3, target) => {
+      if (args.length < 3) throw new Error("Oklab: need 3 components");
+      const v3 = gpuVec3(target);
+      return `_gpu_oklab_to_oklch(${v3}(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(args[2])}))`;
+    },
+    Oklch: (args, compile3, target) => {
+      if (args.length < 3) throw new Error("Oklch: need 3 components");
+      const v3 = gpuVec3(target);
+      return `${v3}(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(args[2])})`;
+    },
+    // ---------------------------------------------------------------------------
+    // As* operators. AsOklch is identity (canonical). The other As* return
+    // components in the named space, equivalent to ColorToColorspace(c, 'x').
+    // ---------------------------------------------------------------------------
+    AsOklch: ([c], compile3) => {
+      if (c === null) throw new Error("AsOklch: no argument");
+      return compile3(c);
+    },
+    AsOklab: ([c], compile3) => {
+      if (c === null) throw new Error("AsOklab: no argument");
+      return `_gpu_oklch_to_oklab(${compile3(c)})`;
+    },
+    AsRgb: ([c], compile3) => {
+      if (c === null) throw new Error("AsRgb: no argument");
+      return `_gpu_oklch_to_srgb(${compile3(c)})`;
+    },
+    AsHsv: ([c], compile3) => {
+      if (c === null) throw new Error("AsHsv: no argument");
+      return `_gpu_rgb_to_hsv(_gpu_oklch_to_srgb(${compile3(c)}))`;
+    },
+    AsHsl: ([c], compile3) => {
+      if (c === null) throw new Error("AsHsl: no argument");
+      return `_gpu_rgb_to_hsl(_gpu_oklch_to_srgb(${compile3(c)}))`;
     },
     // Fractal functions
     Mandelbrot: ([c, maxIter], compile3, target) => {
       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 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(${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 dpCoord = target?.language === "wgsl" ? "_dp_coord(v_uv)" : "_dp_coord()";
-        const cCode = compile3(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 = compile3(c);
-        return `_fractal_julia_pt(${ptDelta}, ${cCode}, ${iterCode})`;
-      }
       return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
     },
     // Vector/Matrix operations
@@ -62555,232 +63453,6 @@ fn _gpu_besselJ(n_in: i32, x_in: f32) -> f32 {
   for (var k2: i32 = 2; k2 <= M; k2 += 2) { norm += 2.0 * vals[k2]; }
   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) {
@@ -62824,208 +63496,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) {
@@ -63067,28 +63537,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_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));
 }
 
-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));
+// 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);
@@ -63099,9 +63665,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;
 }
 `;
@@ -63145,28 +63709,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_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_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(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);
@@ -63454,7 +64123,7 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
           if (stmts.length === 0) return "";
           const last = stmts.length - 1;
           stmts[last] = `return ${stmts[last]}`;
-          return stmts.join(";\n");
+          return stmts.join(";\n") + ";";
         },
         ...options
       };
@@ -63465,7 +64134,6 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       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];
@@ -63504,89 +64172,12 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       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(expr2, _options = {}) {
@@ -63631,7 +64222,7 @@ fn _gpu_apca(bg: vec3f, fg: vec3f) -> f32 {
       if (body.includes("\n")) {
         const indented = body.split("\n").map((l) => `  ${l}`).join("\n");
         return `${returnType} ${functionName}(${params}) {
-${indented};
+${indented}
 }`;
       }
       return `${returnType} ${functionName}(${params}) {
@@ -63742,7 +64333,7 @@ ${indented};
         return `fn ${functionName}(${params}) -> ${toWGSLType(
           returnType
         )} {
-${indented};
+${indented}
 }`;
       }
       return `fn ${functionName}(${params}) -> ${toWGSLType(returnType)} {
@@ -67727,6 +68318,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       this.pushScope(void 0, "global");
       this._compilationTargets.registerDefaults();
       if (options?.latexSyntax) this._latexSyntax = options.latexSyntax;
+      if (options?.latexOptions) this._latexOptions = { ...options.latexOptions };
       hidePrivateProperties(this);
     }
     toJSON() {
@@ -68387,6 +68979,29 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
         );
       return this._latexSyntax;
     }
+    /** @internal Engine-wide LaTeX parse/serialize options (e.g. decimalSeparator).
+     *  Merged into every `parse()` and `toLatex()` call between the LatexSyntax
+     *  instance defaults and any per-call overrides. */
+    _latexOptions = {};
+    /** Engine-wide LaTeX parse/serialize options.
+     *
+     * These options are merged into every `parse()` and `toLatex()` call.
+     * Precedence (most-specific wins):
+     *   1. LatexSyntax instance defaults (set at its construction)
+     *   2. `ce.latexOptions` (this property)
+     *   3. Per-call options passed to `ce.parse()` / `expr.toLatex()`
+     *
+     * Assigning replaces the whole bag. Use spread to merge:
+     * ```ts
+     * ce.latexOptions = { ...ce.latexOptions, decimalSeparator: '{,}' };
+     * ```
+     */
+    get latexOptions() {
+      return this._latexOptions;
+    }
+    set latexOptions(options) {
+      this._latexOptions = { ...options };
+    }
     parse(latex, options) {
       if (latex === null || latex === void 0) return null;
       if (typeof latex !== "string")
@@ -68394,7 +69009,6 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       const syntax = this._requireLatexSyntax();
       const { form, ...parseOpts } = options ?? {};
       const result = syntax.parse(latex, {
-        decimalSeparator: ".",
         getSymbolType: (id) => {
           const def = this.lookupDefinition(id);
           if (!def) return BoxedType.unknown;
@@ -68406,6 +69020,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
           const def = this.lookupDefinition(id);
           return !!(isValueDef(def) && def.value.subscriptEvaluate);
         },
+        ...this._latexOptions,
         ...parseOpts
       });
       if (result === null) return null;
@@ -68569,7 +69184,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/core.ts
-  var version = "0.55.5";
+  var version = "0.56.0";
   return __toCommonJS(core_exports);
 })();
 /*! Bundled license information: