@cortex-js/compute-engine 0.51.0 → 0.51.1

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.51.0 */
+/** Compute Engine 0.51.1 */
     (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.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -9860,13 +9860,175 @@ var ComputeEngine = (() => {
       parse: (parser, lhs, terminator) => {
         const seq = parseSequence(parser, terminator, lhs, 19, ";");
         if (seq === null) return null;
+        if (seq.some((e) => operator(e) === "Assign"))
+          return buildBlockFromSequence(seq);
         return ["Delimiter", ["Sequence", ...seq], "';'"];
       }
     },
+    // \text{where} — variable binding infix
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "none",
+      precedence: 21,
+      // Above ; (19) and , (20), very low binding
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "where")) {
+          parser.index = start;
+          return null;
+        }
+        return parseWhereExpression(parser, lhs, until);
+      }
+    },
+    // \operatorname{where}
+    {
+      symbolTrigger: "where",
+      kind: "infix",
+      associativity: "none",
+      precedence: 21,
+      parse: (parser, lhs, until) => parseWhereExpression(parser, lhs, until)
+    },
+    // Block serializer — used by both `where` and semicolon blocks
+    {
+      name: "Block",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length === 0) return "";
+        const parts = args.filter((a) => operator(a) !== "Declare").map((a) => serializer.serialize(a));
+        return parts.join(";\\; ");
+      }
+    },
+    // Serializer for If expressions (separate from the parser entry
+    // because name-based entries affect kind-based indexing)
+    {
+      name: "If",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length < 3) return "";
+        return joinLatex([
+          "\\text{if }",
+          serializer.serialize(args[0]),
+          "\\text{ then }",
+          serializer.serialize(args[1]),
+          "\\text{ else }",
+          serializer.serialize(args[2])
+        ]);
+      }
+    },
+    // Serializer for Loop expressions
+    {
+      name: "Loop",
+      serialize: (serializer, expr) => {
+        const args = operands(expr);
+        if (!args || args.length < 2) return "";
+        const body = args[0];
+        const indexing = args[1];
+        if (operator(indexing) === "Element") {
+          const index = operand(indexing, 1);
+          const range2 = operand(indexing, 2);
+          if (operator(range2) === "Range") {
+            const lo = operand(range2, 1);
+            const hi = operand(range2, 2);
+            return joinLatex([
+              "\\text{for }",
+              serializer.serialize(index),
+              "\\text{ from }",
+              serializer.serialize(lo),
+              "\\text{ to }",
+              serializer.serialize(hi),
+              "\\text{ do }",
+              serializer.serialize(body)
+            ]);
+          }
+        }
+        return joinLatex([
+          "\\operatorname{Loop}(",
+          serializer.serialize(body),
+          ", ",
+          serializer.serialize(indexing),
+          ")"
+        ]);
+      }
+    },
+    // Serializer for Break
+    { name: "Break", serialize: () => "\\text{break}" },
+    // Serializer for Continue
+    { name: "Continue", serialize: () => "\\text{continue}" },
+    // Serializer for Return
+    {
+      name: "Return",
+      serialize: (serializer, expr) => {
+        const arg = operand(expr, 1);
+        if (!arg || symbol(arg) === "Nothing") return "\\text{return}";
+        return joinLatex(["\\text{return }", serializer.serialize(arg)]);
+      }
+    },
+    // Also match `\operatorname{if}` / `\mathrm{if}`
+    {
+      symbolTrigger: "if",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => {
+        return parseIfExpression(parser, until);
+      }
+    },
+    // \operatorname{for}
+    {
+      symbolTrigger: "for",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => parseForExpression(parser, until)
+    },
+    // \operatorname{break}
+    {
+      symbolTrigger: "break",
+      kind: "prefix",
+      precedence: 245,
+      parse: () => ["Break"]
+    },
+    // \operatorname{continue}
+    {
+      symbolTrigger: "continue",
+      kind: "prefix",
+      precedence: 245,
+      parse: () => ["Continue"]
+    },
+    // \operatorname{return}
+    {
+      symbolTrigger: "return",
+      kind: "prefix",
+      precedence: 245,
+      parse: (parser, until) => [
+        "Return",
+        parser.parseExpression(until) ?? "Nothing"
+      ]
+    },
     {
       name: "String",
       latexTrigger: ["\\text"],
-      parse: (scanner) => parseTextRun(scanner),
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (matchTextKeyword(parser, "if"))
+          return parseIfExpression(parser, until);
+        parser.index = start;
+        if (matchTextKeyword(parser, "for"))
+          return parseForExpression(parser, until);
+        parser.index = start;
+        if (matchTextKeyword(parser, "break"))
+          return ["Break"];
+        parser.index = start;
+        if (matchTextKeyword(parser, "continue"))
+          return ["Continue"];
+        parser.index = start;
+        if (matchTextKeyword(parser, "return"))
+          return [
+            "Return",
+            parser.parseExpression(until) ?? "Nothing"
+          ];
+        parser.index = start;
+        return parseTextRun(parser);
+      },
       serialize: (serializer, expr) => {
         const args = operands(expr);
         if (args.length === 0) return "\\text{}";
@@ -10520,7 +10682,7 @@ var ComputeEngine = (() => {
     // '⎾': '', // U+23BE RIGHT PARENTHESIS UPPER HOOK
     // '⎿': '', // U+23BF RIGHT PARENTHESIS LOWER HOOK
   };
-  function parseAssign(parser, lhs) {
+  function parseAssign(parser, lhs, until) {
     const lhsSymbol = symbol(lhs);
     if (lhsSymbol && lhsSymbol.includes("_")) {
       const underscoreIndex = lhsSymbol.indexOf("_");
@@ -10533,7 +10695,7 @@ var ComputeEngine = (() => {
     if (operator(lhs) === "InvisibleOperator" && nops(lhs) === 2 && operator(operand(lhs, 2)) === "Delimiter") {
       const fn2 = symbol(operand(lhs, 1));
       if (!fn2) return null;
-      const rhs2 = parser.parseExpression({ minPrec: 0 });
+      const rhs2 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
       if (rhs2 === null) return null;
       const delimBody = operand(operand(lhs, 2), 1);
       let args = [];
@@ -10544,7 +10706,7 @@ var ComputeEngine = (() => {
     if (operator(lhs) === "Subscript" && symbol(operand(lhs, 1))) {
       const fn2 = symbol(operand(lhs, 1));
       if (!fn2) return null;
-      const rhs2 = parser.parseExpression({ minPrec: 0 });
+      const rhs2 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
       if (rhs2 === null) return null;
       const sub3 = operand(lhs, 2);
       if (stringValue(sub3) !== null) {
@@ -10560,12 +10722,12 @@ var ComputeEngine = (() => {
       if (fn === "Subscript" || fn === "Superscript") {
       }
       const args = operands(lhs);
-      const rhs2 = parser.parseExpression({ minPrec: 0 });
+      const rhs2 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
       if (rhs2 === null) return null;
       return ["Assign", fn, ["Function", rhs2, ...args]];
     }
     if (!symbol(lhs)) return null;
-    const rhs = parser.parseExpression({ minPrec: 0 });
+    const rhs = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
     if (rhs === null) return null;
     return ["Assign", lhs, rhs];
   }
@@ -10592,6 +10754,141 @@ var ComputeEngine = (() => {
     }
     return ["Which", ...result];
   }
+  function matchTextKeyword(parser, keyword) {
+    const start = parser.index;
+    if (!parser.match("<{>")) {
+      parser.index = start;
+      return false;
+    }
+    while (parser.match("<space>")) {
+    }
+    let text = "";
+    while (!parser.atEnd && parser.peek !== "<}>" && parser.peek !== "<space>") {
+      const tok = parser.peek;
+      if (/^[a-zA-Z]$/.test(tok)) {
+        text += tok;
+        parser.nextToken();
+      } else {
+        break;
+      }
+    }
+    while (parser.match("<space>")) {
+    }
+    if (!parser.match("<}>")) {
+      parser.index = start;
+      return false;
+    }
+    if (text !== keyword) {
+      parser.index = start;
+      return false;
+    }
+    return true;
+  }
+  function matchKeyword(parser, keyword) {
+    const start = parser.index;
+    if (parser.match("\\text")) {
+      if (matchTextKeyword(parser, keyword)) return true;
+      parser.index = start;
+    }
+    const saved = parser.index;
+    const sym2 = parser.parseSymbol();
+    if (sym2 !== null && symbol(sym2) === keyword) return true;
+    parser.index = saved;
+    return false;
+  }
+  function peekKeyword(parser, keyword) {
+    const start = parser.index;
+    const result = matchKeyword(parser, keyword);
+    parser.index = start;
+    return result;
+  }
+  function parseIfExpression(parser, until) {
+    const condition = parser.parseExpression({
+      minPrec: 0,
+      condition: (p) => peekKeyword(p, "then")
+    });
+    if (condition === null) return null;
+    if (!matchKeyword(parser, "then")) return null;
+    const trueBranch = parser.parseExpression({
+      minPrec: 0,
+      condition: (p) => peekKeyword(p, "else")
+    });
+    if (trueBranch === null) return null;
+    if (!matchKeyword(parser, "else")) return null;
+    const falseBranch = parser.parseExpression(until) ?? "Nothing";
+    return ["If", condition, trueBranch, falseBranch];
+  }
+  function parseForExpression(parser, until) {
+    const indexExpr = parser.parseExpression({
+      minPrec: 0,
+      condition: (p) => peekKeyword(p, "from")
+    });
+    const index = indexExpr ? symbol(indexExpr) : null;
+    if (!index) return null;
+    if (!matchKeyword(parser, "from")) return null;
+    const lower = parser.parseExpression({
+      minPrec: 0,
+      condition: (p) => peekKeyword(p, "to")
+    });
+    if (lower === null) return null;
+    if (!matchKeyword(parser, "to")) return null;
+    const upper = parser.parseExpression({
+      minPrec: 0,
+      condition: (p) => peekKeyword(p, "do")
+    });
+    if (upper === null) return null;
+    if (!matchKeyword(parser, "do")) return null;
+    const body = parser.parseExpression(until) ?? "Nothing";
+    return [
+      "Loop",
+      body,
+      ["Element", index, ["Range", lower, upper]]
+    ];
+  }
+  function parseWhereExpression(parser, lhs, until) {
+    const bindingTerminator = {
+      minPrec: 21,
+      // Above comma (20) and ; (19)
+      condition: (p) => {
+        if (until?.condition?.(p)) return true;
+        const saved = p.index;
+        p.skipSpace();
+        const isComma = p.peek === ",";
+        p.index = saved;
+        return isComma;
+      }
+    };
+    const bindings = [];
+    do {
+      parser.skipSpace();
+      const binding = parser.parseExpression(bindingTerminator);
+      if (!binding) break;
+      bindings.push(binding);
+      parser.skipSpace();
+    } while (parser.match(","));
+    if (bindings.length === 0) return null;
+    const block = [];
+    for (const b of bindings) {
+      if (operator(b) === "Assign") {
+        block.push(["Declare", operand(b, 1)]);
+        block.push(b);
+      } else {
+        block.push(b);
+      }
+    }
+    block.push(lhs);
+    return ["Block", ...block];
+  }
+  function buildBlockFromSequence(seq) {
+    const block = [];
+    for (const s of seq) {
+      if (operator(s) === "Assign") {
+        block.push(["Declare", operand(s, 1)]);
+      }
+      block.push(s);
+    }
+    return ["Block", ...block];
+  }
   function parseAt(...close) {
     return (parser, lhs) => {
       if (!symbol(lhs) && operator(lhs) !== "List") return null;
@@ -10726,7 +11023,11 @@ var ComputeEngine = (() => {
     level = -1;
     constructor(dictionary, options) {
       this.dictionary = dictionary;
-      this.options = options;
+      this.options = {
+        dmsFormat: false,
+        angleNormalization: "none",
+        ...options
+      };
     }
     /**
      * Serialize the expression, and if the expression is an operator
@@ -11848,6 +12149,8 @@ var ComputeEngine = (() => {
         // invisibleApply: '',
         multiply: "\\times",
         missingSymbol: "\\blacksquare",
+        dmsFormat: false,
+        angleNormalization: "none",
         // openGroup: '(',
         // closeGroup: ')',
         // divide: '\\frac{#1}{#2}',
@@ -16903,6 +17206,150 @@ ${lines.join("\n")}`;
     const x14 = Math.pow(absX, 0.25);
     return Math.cos(xi + Math.PI / 4) / (Math.sqrt(Math.PI) * x14);
   }
+  var SN = [
+    -2991.8191940101983,
+    708840.0452577386,
+    -6297414862058625e-8,
+    25489088057337637e-7,
+    -4429795180596978e-5,
+    3180162978765678e-4
+  ];
+  var SD = [
+    1,
+    281.3762688899943,
+    45584.78108065326,
+    5173438887700964e-9,
+    4193202458981112e-7,
+    22441179564534092e-6,
+    607366389490085e-3
+  ];
+  var CN = [
+    -49884311457357354e-24,
+    9504280628298596e-21,
+    -6451914356839651e-19,
+    0.018884331939670384,
+    -0.20552590095501388,
+    1
+  ];
+  var CD = [
+    399982968972496e-26,
+    9154392157746574e-25,
+    12500186247959882e-23,
+    12226278902417902e-21,
+    8680295429417843e-19,
+    0.04121420907221998,
+    1
+  ];
+  var FN = [
+    0.4215435550436775,
+    0.1434079197807589,
+    0.011522095507358577,
+    345017939782574e-18,
+    46361374928786735e-22,
+    3055689837902576e-23,
+    10230451416490724e-26,
+    17201074326816183e-29,
+    13428327623306275e-32,
+    3763297112699879e-35
+  ];
+  var FD = [
+    1,
+    0.7515863983533789,
+    0.11688892585919138,
+    0.0064405152650885865,
+    15593440916415301e-20,
+    18462756734893055e-22,
+    11269922476399903e-24,
+    36014002958937136e-27,
+    5887545336215784e-29,
+    45200143407412973e-33,
+    12544323709001127e-36
+  ];
+  var GN = [
+    0.5044420736433832,
+    0.1971028335255234,
+    0.018764858409257526,
+    6840793809153931e-19,
+    11513882611188428e-21,
+    9828524436884223e-23,
+    44534441586175015e-26,
+    10826804113902088e-28,
+    1375554606332618e-30,
+    8363544356306774e-34,
+    18695871016278324e-38
+  ];
+  var GD = [
+    1,
+    1.4749575992512833,
+    0.33774898912002,
+    0.02536037414203388,
+    8146791071843061e-19,
+    12754507566772912e-21,
+    10431458965757199e-23,
+    46068072851523205e-26,
+    11027321506624028e-28,
+    13879653125957886e-31,
+    8391588162831187e-34,
+    18695871016278324e-38
+  ];
+  function polevl(x, coef) {
+    let ans = coef[0];
+    for (let i = 1; i < coef.length; i++) ans = ans * x + coef[i];
+    return ans;
+  }
+  function fresnelS(x) {
+    if (!isFinite(x)) {
+      if (x !== x) return NaN;
+      return x > 0 ? 0.5 : -0.5;
+    }
+    const sign3 = x < 0 ? -1 : 1;
+    x = Math.abs(x);
+    if (x < 1.6) {
+      const x2 = x * x;
+      const t = x2 * x2;
+      return sign3 * x * x2 * polevl(t, SN) / polevl(t, SD);
+    }
+    if (x < 36) {
+      const x2 = x * x;
+      const t = Math.PI * x2;
+      const u = 1 / (t * t);
+      const f = 1 - u * polevl(u, FN) / polevl(u, FD);
+      const g = 1 / t * polevl(u, GN) / polevl(u, GD);
+      const z = Math.PI / 2 * x2;
+      const c = Math.cos(z);
+      const s = Math.sin(z);
+      return sign3 * (0.5 - (f * c + g * s) / (Math.PI * x));
+    }
+    return sign3 * 0.5;
+  }
+  function fresnelC(x) {
+    if (!isFinite(x)) {
+      if (x !== x) return NaN;
+      return x > 0 ? 0.5 : -0.5;
+    }
+    const sign3 = x < 0 ? -1 : 1;
+    x = Math.abs(x);
+    if (x < 1.6) {
+      const x2 = x * x;
+      const t = x2 * x2;
+      return sign3 * x * polevl(t, CN) / polevl(t, CD);
+    }
+    if (x < 36) {
+      const x2 = x * x;
+      const t = Math.PI * x2;
+      const u = 1 / (t * t);
+      const f = 1 - u * polevl(u, FN) / polevl(u, FD);
+      const g = 1 / t * polevl(u, GN) / polevl(u, GD);
+      const z = Math.PI / 2 * x2;
+      const c = Math.cos(z);
+      const s = Math.sin(z);
+      return sign3 * (0.5 + (f * s - g * c) / (Math.PI * x));
+    }
+    return sign3 * 0.5;
+  }
+  function sinc(x) {
+    return x === 0 ? 1 : Math.sin(x) / x;
+  }
 
   // src/compute-engine/boxed-expression/predicates.ts
   function isPrime2(expr) {
@@ -23554,7 +24001,7 @@ ${lines.join("\n")}`;
         wikidata: "Q715358",
         complexity: 2e3,
         broadcastable: true,
-        signature: "(number) -> number",
+        signature: "(value) -> value",
         type: ([x]) => x.type,
         sgn: ([x]) => oppositeSgn(x.sgn),
         canonical: (args, { engine }) => {
@@ -23767,6 +24214,20 @@ ${lines.join("\n")}`;
           (x2) => x2.round(0)
         )
       },
+      /** Heaviside step function: H(x) = 0 for x < 0, 1/2 for x = 0, 1 for x > 0 */
+      Heaviside: {
+        complexity: 1200,
+        broadcastable: true,
+        signature: "(number) -> real",
+        type: () => "finite_real",
+        sgn: () => "non-negative",
+        evaluate: ([x], { engine }) => {
+          if (x.is(0)) return engine.Half;
+          if (x.isPositive) return engine.One;
+          if (x.isNegative) return engine.Zero;
+          return void 0;
+        }
+      },
       Sign: {
         complexity: 1200,
         broadcastable: true,
@@ -28837,7 +29298,7 @@ ${e.message}
   ];
 
   // src/color/palette.ts
-  var FOREGROUND_COLORS = {
+  var NAMED_COLORS = {
     "red": "#d7170b",
     //<- 700, 500 ->'#f21c0d'
     "orange": "#fe8a2b",
@@ -28851,11 +29312,31 @@ ${e.message}
     "indigo": "#63c",
     "purple": "#a219e6",
     "magenta": "#eb4799",
+    "brown": "#8c564b",
+    "olive": "#8a8f2a",
+    "midnight": "#2c4670",
+    "sky": "#d2dce9",
     "black": "#000",
+    "white": "#ffffff",
+    "carbon": "#111111",
+    // near-black, high-contrast text
+    "charcoal": "#333333",
+    // primary axis / label color
+    "slate": "#555555",
+    // secondary text, major gridlines
     "dark-grey": "#666",
+    "graphite": "#777777",
+    // minor gridlines
+    "stone": "#999999",
+    // de-emphasized strokes
     "grey": "#A6A6A6",
     "light-grey": "#d4d5d2",
-    "white": "#ffffff"
+    "ash": "#E6E6E6",
+    // subtle fills, light strokes
+    "mist": "#F3F3F3",
+    // light background tint
+    "snow": "#FFFFFF"
+    // pure white
   };
 
   // src/color/manipulation.ts
@@ -29065,9 +29546,9 @@ ${e.message}
       }
       const lms = lmsFromLab(l, labA, labB);
       const lin = linSRGBFromLMS(lms);
-      let r = Math.max(0, Math.min(1, gammaCorrect(lin.r)));
-      let g = Math.max(0, Math.min(1, gammaCorrect(lin.g)));
-      let b = Math.max(0, Math.min(1, gammaCorrect(lin.b)));
+      const r = Math.max(0, Math.min(1, gammaCorrect(lin.r)));
+      const g = Math.max(0, Math.min(1, gammaCorrect(lin.g)));
+      const b = Math.max(0, Math.min(1, gammaCorrect(lin.b)));
       const rByte = Math.round(r * 255);
       const gByte = Math.round(g * 255);
       const bByte = Math.round(b * 255);
@@ -29103,8 +29584,8 @@ ${e.message}
       return (r << 24 | g << 16 | b << 8 | a) >>> 0;
     }
     if (str === "transparent") return 0;
-    if (str in FOREGROUND_COLORS)
-      return parseColor(FOREGROUND_COLORS[str]);
+    if (str in NAMED_COLORS)
+      return parseColor(NAMED_COLORS[str]);
     console.warn(`parseColor: unrecognized color "${s}"`);
     return 0;
   }
@@ -31424,50 +31905,188 @@ ${e.message}
 
   // src/color/categorical.ts
   var TYCHO_11 = [
-    "#0d80f2",
-    // blue
-    "#d7170b",
-    // red
-    "#21ba3a",
-    // green
-    "#eb4799",
-    // magenta
-    "#13a7ec",
-    // cyan
-    "#fe8a2b",
-    // orange
-    "#17cfcf",
-    // teal
-    "#a219e6",
-    // purple
-    "#ffc02b",
-    // yellow
-    "#63b215",
-    // lime
-    "#663399"
-    // indigo
-  ];
-  var TABLEAU_10 = [
     "#4e79a7",
     // Blue
     "#f28e2b",
     // Orange
+    "#59a14f",
+    // Green
     "#e15759",
     // Red
+    "#b07aa1",
+    // Purple
+    "#9c755f",
+    // Brown
+    "#ff9da7",
+    // Pink
+    "#edc948",
+    // Yellow
     "#76b7b2",
     // Teal
-    "#59a14f",
+    "#6b8fd6",
+    // Steel Blue
+    "#c07bc4"
+    // Magenta
+  ];
+  var TYCHO_DARK_11 = [
+    "#78a6d9",
+    // Blue
+    "#ffae54",
+    // Orange
+    "#7ddc7a",
     // Green
-    "#edc948",
+    "#ff7a7a",
+    // Red
+    "#d29be0",
+    // Purple
+    "#c49a84",
+    // Brown
+    "#ffb3bf",
+    // Pink
+    "#ffe066",
     // Yellow
+    "#7fd6d0",
+    // Teal
+    "#8fb4ff",
+    // Steel Blue
+    "#e199eb"
+    // Magenta
+  ];
+  var TYCHO_ROBUST_11 = [
+    "#4e79a7",
+    // Blue
+    "#f28e2b",
+    // Orange
+    "#2ca58d",
+    // Teal-shifted green (more CB-safe)
+    "#d13a3c",
+    // Stronger red
     "#b07aa1",
     // Purple
+    "#9c755f",
+    // Brown
     "#ff9da7",
     // Pink
-    "#9c755f",
+    "#e3c13b",
+    // Darker yellow for contrast
+    "#5fb8b2",
+    // Teal
+    "#6b8fd6",
+    // Steel Blue
+    "#c07bc4"
+    // Magenta
+  ];
+  var TYCHO_SOFT_11 = [
+    "#8fb1d4",
+    "#f6b878",
+    "#8ecf86",
+    "#f08a8b",
+    "#d3a9cc",
+    "#c3a492",
+    "#ffc6cc",
+    "#f3e08a",
+    "#a8d8d4",
+    "#a9c0ea",
+    "#e0b4e4"
+  ];
+  var TYCHO_SOFT_DARK_11 = [
+    "#78a6d9",
+    "#ffae54",
+    "#7ddc7a",
+    "#ff7a7a",
+    "#d29be0",
+    "#c49a84",
+    "#ffb3bf",
+    "#ffe066",
+    "#7fd6d0",
+    "#8fb4ff",
+    "#e199eb"
+  ];
+  var TYCHO_BOLD_11 = [
+    "#2f6fb0",
+    "#ff7a00",
+    "#2fa23a",
+    "#e02f2f",
+    "#9b4db5",
+    "#7f4f38",
+    "#ff6f86",
+    "#f2c200",
+    "#2daaa3",
+    "#4c79e0",
+    "#b84ac6"
+  ];
+  var TYCHO_BOLD_DARK_11 = [
+    "#4f93ff",
+    "#ff8c1a",
+    "#33c94a",
+    "#ff4f4f",
+    "#b86bff",
+    "#a86a4a",
+    "#ff7f9e",
+    "#ffd400",
+    "#2ec9c1",
+    "#6f9bff",
+    "#cc5bd9"
+  ];
+  var MATHEMATICA_10 = [
+    "#5E81B5",
+    "#E19C24",
+    "#8FB131",
+    "#EB6235",
+    "#8778B3",
+    "#C56E1A",
+    "#5E9EC9",
+    "#B23A3A",
+    "#4C9F70",
+    "#C979B7"
+  ];
+  var TABLEAU_10 = [
+    "#1f77b4",
+    // Blue
+    "#ff7f0e",
+    // Orange
+    "#2ca02c",
+    // Green
+    "#d62728",
+    // Red
+    "#9467bd",
+    // Purple
+    "#8c564b",
     // Brown
-    "#bab0ac"
+    "#e377c2",
+    // Pink
+    "#7f7f7f",
     // Gray
+    "#bcbd22",
+    // Olive
+    "#17becf"
+    // Cyan
+  ];
+  var CUPERTINO_10 = [
+    "#007AFF",
+    "#FF9500",
+    "#34C759",
+    "#FF3B30",
+    "#AF52DE",
+    "#FF2D55",
+    "#30B0C7",
+    "#5856D6",
+    "#A2845E",
+    "#32ADE6",
+    "#00C7BE"
+  ];
+  var CUPERTINO_DARK_10 = [
+    "#0A84FF",
+    "#FF9F0A",
+    "#30D158",
+    "#FF453A",
+    "#BF5AF2",
+    "#FF375F",
+    "#40C8E0",
+    "#5E5CE6",
+    "#AC8E68",
+    "#64D2FF",
+    "#00D1C1"
   ];
   var KELLY_22 = [
     "#fdfdfd",
@@ -31515,28 +32134,6 @@ ${e.message}
     "#2b3514"
     // Olive green
   ];
-  var GRAPH_6 = [
-    "#2d6fb4",
-    // Blue
-    "#c84442",
-    // Red
-    "#398c46",
-    // Green
-    "#fa7d19",
-    // Orange
-    "#00beff",
-    // Light Blue
-    "#6042a6"
-    // Purple
-  ];
-  var SPECTRUM_6 = [
-    "#4148cc",
-    "#db3c80",
-    "#12b5b0",
-    "#ff8c14",
-    "#848aff",
-    "#78e16e"
-  ];
   var SPECTRUM_12 = [
     "#4148cc",
     "#db3c80",
@@ -31552,12 +32149,19 @@ ${e.message}
     "#00915f"
   ];
   var CATEGORICAL_PALETTES = {
-    tycho11: TYCHO_11,
-    tableau10: TABLEAU_10,
-    kelly22: KELLY_22,
-    graph6: GRAPH_6,
-    spectrum6: SPECTRUM_6,
-    spectrum12: SPECTRUM_12
+    "tycho11": TYCHO_11,
+    "tycho-dark11": TYCHO_DARK_11,
+    "tycho-robust11": TYCHO_ROBUST_11,
+    "tycho-soft11": TYCHO_SOFT_11,
+    "tycho-soft-dark11": TYCHO_SOFT_DARK_11,
+    "tycho-bold11": TYCHO_BOLD_11,
+    "tycho-bold-dark11": TYCHO_BOLD_DARK_11,
+    "tableau10": TABLEAU_10,
+    "kelly22": KELLY_22,
+    "mathematica10": MATHEMATICA_10,
+    "cupertino10": CUPERTINO_10,
+    "cupertino-dark10": CUPERTINO_DARK_10,
+    "spectrum12": SPECTRUM_12
   };
 
   // src/color/diverging-palettes.ts
@@ -39854,6 +40458,29 @@ ${e.message}
           return ops[0].mul(options.engine.Pi.div(180)).evaluate(options);
         }
       },
+      // DMS(degrees, minutes?, seconds?) — programmatic angle construction
+      DMS: {
+        signature: "(real, real?, real?) -> real",
+        type: () => "finite_real",
+        canonical: (ops, { engine: ce }) => {
+          const deg = ops[0]?.re ?? NaN;
+          const min3 = ops[1]?.re ?? 0;
+          const sec2 = ops[2]?.re ?? 0;
+          if (Number.isNaN(deg)) return ce._fn("DMS", ops);
+          const total = deg + min3 / 60 + sec2 / 3600;
+          return ce.function("Degrees", [ce.number(total)]);
+        },
+        evaluate: (ops, options) => {
+          const ce = options.engine;
+          const deg = ops[0]?.re ?? NaN;
+          const min3 = ops[1]?.re ?? 0;
+          const sec2 = ops[2]?.re ?? 0;
+          if (Number.isNaN(deg)) return ce._fn("DMS", ops);
+          const total = deg + min3 / 60 + sec2 / 3600;
+          if (ce.angularUnit === "deg") return ce.number(total);
+          return ce.number(total).div(180).mul(ce.Pi).evaluate(options);
+        }
+      },
       // Hypot: sqrt(x*x + y*y)
       Hypot: {
         broadcastable: true,
@@ -39955,6 +40582,39 @@ ${e.message}
       Arsech: trigFunction("Arsech", 6250),
       Arccsc: trigFunction("Arccsc", 5650),
       Coth: trigFunction("Coth", 6300),
+      /** sinc(x) = sin(x)/x with sinc(0) = 1 (unnormalized cardinal sine) */
+      Sinc: {
+        complexity: 5100,
+        broadcastable: true,
+        signature: "(number) -> real",
+        type: () => "finite_real",
+        evaluate: ([x], { engine: ce }) => {
+          if (!x || !isNumber(x)) return void 0;
+          return ce.number(sinc(x.re));
+        }
+      },
+      /** FresnelS(x) = ∫₀ˣ sin(πt²/2) dt — odd function, S(∞) = 1/2 */
+      FresnelS: {
+        complexity: 5200,
+        broadcastable: true,
+        signature: "(number) -> real",
+        type: () => "finite_real",
+        evaluate: ([x], { engine: ce }) => {
+          if (!x || !isNumber(x)) return void 0;
+          return ce.number(fresnelS(x.re));
+        }
+      },
+      /** FresnelC(x) = ∫₀ˣ cos(πt²/2) dt — odd function, C(∞) = 1/2 */
+      FresnelC: {
+        complexity: 5200,
+        broadcastable: true,
+        signature: "(number) -> real",
+        type: () => "finite_real",
+        evaluate: ([x], { engine: ce }) => {
+          if (!x || !isNumber(x)) return void 0;
+          return ce.number(fresnelC(x.re));
+        }
+      },
       /* converts (radius, angle) -> (x, y) */
       // FromPolarCoordinates: {
       //   domain: 'Function',
@@ -40038,6 +40698,61 @@ ${e.message}
     }
   ];
 
+  // src/compute-engine/latex-syntax/serialize-dms.ts
+  function normalizeAngle(degrees, mode2) {
+    if (mode2 === "none") return degrees;
+    if (mode2 === "0...360") {
+      const normalized = degrees % 360;
+      return (normalized < 0 ? normalized + 360 : normalized) || 0;
+    }
+    if (mode2 === "-180...180") {
+      let normalized = degrees % 360;
+      if (normalized > 180) normalized -= 360;
+      if (normalized < -180) normalized += 360;
+      return normalized || 0;
+    }
+    return degrees;
+  }
+  function degreesToDMS(totalDegrees) {
+    const sign3 = totalDegrees < 0 ? -1 : 1;
+    const absDegrees = Math.abs(totalDegrees);
+    const deg = Math.floor(absDegrees);
+    const minDecimal = (absDegrees - deg) * 60;
+    const min3 = Math.floor(minDecimal);
+    const secDecimal = (minDecimal - min3) * 60;
+    let sec2 = Math.round(secDecimal * 1e3) / 1e3;
+    let finalMin = min3;
+    let finalDeg = deg;
+    if (sec2 >= 60) {
+      sec2 = 0;
+      finalMin++;
+    }
+    if (finalMin >= 60) {
+      finalMin = 0;
+      finalDeg++;
+    }
+    return {
+      deg: sign3 * finalDeg || 0,
+      // Avoid -0
+      min: sign3 * finalMin || 0,
+      // Avoid -0
+      sec: sec2 === 0 ? 0 : sign3 * sec2
+    };
+  }
+  function formatDMS(degrees) {
+    const { deg, min: min3, sec: sec2 } = degreesToDMS(degrees);
+    let result = `${deg}\xB0`;
+    if (Math.abs(sec2) > 1e-3) {
+      const secStr = sec2 % 1 === 0 ? sec2.toString() : sec2.toFixed(2);
+      result += `${Math.abs(min3)}'${Math.abs(Number(secStr))}"`;
+    } else if (Math.abs(min3) > 0) {
+      result += `${Math.abs(min3)}'`;
+    } else {
+      result += `0'0"`;
+    }
+    return result;
+  }
+
   // src/compute-engine/latex-syntax/dictionary/definitions-units.ts
   function readBracedText(parser) {
     if (!parser.match("<{>")) return null;
@@ -40205,6 +40920,29 @@ ${e.message}
         const magnitude = operand(expr, 1);
         const unit = operand(expr, 2);
         if (magnitude === null || unit === null) return "";
+        const unitSymbol2 = symbol(unit);
+        const isAngleUnit = unitSymbol2 === "deg" || unitSymbol2 === "rad" || unitSymbol2 === "arcmin" || unitSymbol2 === "arcsec";
+        const options = serializer.options;
+        if (isAngleUnit && (options.dmsFormat || options.angleNormalization && options.angleNormalization !== "none")) {
+          const magnitudeValue = machineValue(magnitude);
+          if (magnitudeValue === null) {
+            const magLatex2 = serializer.serialize(magnitude);
+            const unitStr2 = unitToMathrm(unit);
+            return joinLatex([magLatex2, "\\,", `\\mathrm{${unitStr2}}`]);
+          }
+          let degrees = magnitudeValue;
+          if (unitSymbol2 === "rad") {
+            degrees = degrees * 180 / Math.PI;
+          } else if (unitSymbol2 === "arcmin") {
+            degrees = degrees / 60;
+          } else if (unitSymbol2 === "arcsec") {
+            degrees = degrees / 3600;
+          }
+          if (options.angleNormalization && options.angleNormalization !== "none")
+            degrees = normalizeAngle(degrees, options.angleNormalization);
+          if (options.dmsFormat) return formatDMS(degrees);
+          return `${degrees}\xB0`;
+        }
         const magLatex = serializer.serialize(magnitude);
         const unitStr = unitToMathrm(unit);
         return joinLatex([magLatex, "\\,", `\\mathrm{${unitStr}}`]);
@@ -40610,6 +41348,37 @@ ${e.message}
       serializer.serialize(exp3)
     );
   }
+  function parseDMS(parser, lhs) {
+    parser.skipSpace();
+    const savepoint = parser.index;
+    const minExpr = parser.parseNumber();
+    let minNum = null;
+    let secNum = null;
+    if (minExpr !== null && (parser.match("'") || parser.match("\\prime"))) {
+      minNum = machineValue(minExpr);
+      parser.skipSpace();
+      const secSavepoint = parser.index;
+      const secExpr = parser.parseNumber();
+      if (secExpr !== null && (parser.match('"') || parser.match("\\doubleprime"))) {
+        secNum = machineValue(secExpr);
+      } else {
+        parser.index = secSavepoint;
+      }
+    } else {
+      parser.index = savepoint;
+      return ["Degrees", lhs];
+    }
+    const degNum = machineValue(lhs);
+    if (degNum !== null && minNum !== null) {
+      let total = degNum + minNum / 60;
+      if (secNum !== null) total += secNum / 3600;
+      return ["Degrees", total];
+    }
+    const parts = [["Quantity", lhs, "deg"]];
+    parts.push(["Quantity", minExpr, "arcmin"]);
+    if (secNum !== null) parts.push(["Quantity", secNum, "arcsec"]);
+    return ["Add", ...parts];
+  }
   var DEFINITIONS_ARITHMETIC = [
     // Constants
     { name: "CatalanConstant", symbolTrigger: "G" },
@@ -40620,32 +41389,48 @@ ${e.message}
       latexTrigger: ["\\degree"],
       kind: "postfix",
       precedence: 880,
-      parse: (_parser, lhs) => ["Degrees", lhs],
+      parse: (parser, lhs) => parseDMS(parser, lhs),
       serialize: (serializer, expr) => {
-        return joinLatex([serializer.serialize(operand(expr, 1)), "\\degree"]);
+        const options = serializer.options;
+        const arg = operand(expr, 1);
+        if (options.dmsFormat || options.angleNormalization && options.angleNormalization !== "none") {
+          const argValue = machineValue(arg);
+          if (argValue !== null) {
+            let degrees = argValue;
+            if (options.angleNormalization && options.angleNormalization !== "none")
+              degrees = normalizeAngle(degrees, options.angleNormalization);
+            if (options.dmsFormat) return formatDMS(degrees);
+            return `${degrees}\xB0`;
+          }
+        }
+        return joinLatex([serializer.serialize(arg), "\\degree"]);
       }
     },
     {
       latexTrigger: ["\\degree"],
       kind: "postfix",
       precedence: 880,
-      parse: (_parser, lhs) => ["Degrees", lhs]
+      parse: (parser, lhs) => parseDMS(parser, lhs)
     },
+    // No `precedence` on these entries: the dictionary validator
+    // (definitions.ts:947-968) rejects `precedence` on entries whose
+    // `latexTrigger` starts with `^` or `_`, since their binding is
+    // governed by LaTeX grouping rules, not operator precedence.
     {
       latexTrigger: ["^", "<{>", "\\circ", "<}>"],
       kind: "postfix",
-      parse: (_parser, lhs) => ["Degrees", lhs]
+      parse: (parser, lhs) => parseDMS(parser, lhs)
     },
     {
       latexTrigger: ["^", "\\circ"],
       kind: "postfix",
-      parse: (_parser, lhs) => ["Degrees", lhs]
+      parse: (parser, lhs) => parseDMS(parser, lhs)
     },
     {
       latexTrigger: ["\xB0"],
       kind: "postfix",
       precedence: 880,
-      parse: (_parser, lhs) => ["Degrees", lhs]
+      parse: (parser, lhs) => parseDMS(parser, lhs)
     },
     {
       latexTrigger: ["\\ang"],
@@ -40654,6 +41439,28 @@ ${e.message}
         return arg === null ? ["Degrees"] : ["Degrees", arg];
       }
     },
+    {
+      name: "DMS",
+      serialize: (serializer, expr) => {
+        const deg = machineValue(operand(expr, 1));
+        const min3 = machineValue(operand(expr, 2));
+        const sec2 = machineValue(operand(expr, 3));
+        if (deg !== null) {
+          const m = min3 ?? 0;
+          const s = sec2 ?? 0;
+          let result = `${deg}\xB0`;
+          if (m !== 0 || s !== 0) result += `${m}'`;
+          if (s !== 0) result += `${s}"`;
+          return result;
+        }
+        const args = [];
+        for (const i of [1, 2, 3]) {
+          const op = operand(expr, i);
+          if (op !== void 0) args.push(serializer.serialize(op));
+        }
+        return `\\operatorname{DMS}(${args.join(", ")})`;
+      }
+    },
     {
       latexTrigger: ["\\infty"],
       parse: "PositiveInfinity"
@@ -41389,6 +42196,11 @@ ${e.message}
       parse: parseBigOp("Sum", "Add", MULTIPLICATION_PRECEDENCE),
       serialize: serializeBigOp("\\sum")
     },
+    {
+      name: "Heaviside",
+      symbolTrigger: "Heaviside",
+      kind: "function"
+    },
     {
       name: "Sign",
       // As per ISO 80000-2, "signum" is 'sgn'
@@ -44274,6 +45086,21 @@ ${e.message}
       name: "Sin",
       latexTrigger: ["\\sin"],
       parse: parseTrig("Sin")
+    },
+    {
+      name: "Sinc",
+      symbolTrigger: "sinc",
+      kind: "function"
+    },
+    {
+      name: "FresnelS",
+      symbolTrigger: "FresnelS",
+      kind: "function"
+    },
+    {
+      name: "FresnelC",
+      symbolTrigger: "FresnelC",
+      kind: "function"
     }
   ];
 
@@ -54158,6 +54985,17 @@ Error in definition of "${name}"`,
         return `(${args.map((arg) => _BaseCompiler.compile(arg, target, prec)).join(", ")})`;
       }
       if (h === "Sum" || h === "Product") {
+        const sumProdFn = target.functions?.(h);
+        if (typeof sumProdFn === "function") {
+          return sumProdFn(
+            args,
+            (expr) => _BaseCompiler.compile(expr, target),
+            target
+          );
+        }
+        if (typeof sumProdFn === "string") {
+          return `${sumProdFn}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
+        }
         return _BaseCompiler.compileLoop(h, args, target);
       }
       const op = target.operators?.(h);
@@ -54166,7 +55004,6 @@ Error in definition of "${name}"`,
         if (!hasComplex) {
           const isFunction4 = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(op[0]);
           if (isFunction4) {
-            if (args === null) return `${op[0]}()`;
             return `${op[0]}(${args.map((arg) => _BaseCompiler.compile(arg, target)).join(", ")})`;
           } else {
             if (args.every((x) => !x.isCollection)) {
@@ -54185,7 +55022,6 @@ Error in definition of "${name}"`,
                 }
                 return `(${result.join(") && (")})`;
               }
-              if (args === null) return "";
               let resultStr;
               if (args.length === 1) {
                 resultStr = `${op[0]}${_BaseCompiler.compile(args[0], target, op[1])}`;
@@ -54213,6 +55049,9 @@ Error in definition of "${name}"`,
         return `${isSymbol2(args[0]) ? args[0].symbol : "_"} = ${_BaseCompiler.compile(args[1], target)}`;
       if (h === "Return")
         return `return ${_BaseCompiler.compile(args[0], target)}`;
+      if (h === "Break") return "break";
+      if (h === "Continue") return "continue";
+      if (h === "Loop") return _BaseCompiler.compileForLoop(args, target);
       if (h === "If") {
         if (args.length !== 3) throw new Error("If: wrong number of arguments");
         const fn2 = target.functions?.(h);
@@ -54220,7 +55059,6 @@ Error in definition of "${name}"`,
           if (typeof fn2 === "function") {
             return fn2(args, (expr) => _BaseCompiler.compile(expr, target), target);
           }
-          if (args === null) return `${fn2}()`;
           return `${fn2}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
         }
         return `((${_BaseCompiler.compile(args[0], target)}) ? (${_BaseCompiler.compile(
@@ -54228,6 +55066,29 @@ Error in definition of "${name}"`,
           target
         )}) : (${_BaseCompiler.compile(args[2], target)}))`;
       }
+      if (h === "Which") {
+        if (args.length < 2 || args.length % 2 !== 0)
+          throw new Error(
+            "Which: expected even number of arguments (condition/value pairs)"
+          );
+        const fn2 = target.functions?.(h);
+        if (fn2) {
+          if (typeof fn2 === "function") {
+            return fn2(args, (expr) => _BaseCompiler.compile(expr, target), target);
+          }
+          return `${fn2}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
+        }
+        const compilePair = (i) => {
+          if (i >= args.length) return "NaN";
+          const cond = args[i];
+          const val = args[i + 1];
+          if (isSymbol2(cond) && cond.symbol === "True") {
+            return `(${_BaseCompiler.compile(val, target)})`;
+          }
+          return `((${_BaseCompiler.compile(cond, target)}) ? (${_BaseCompiler.compile(val, target)}) : ${compilePair(i + 2)})`;
+        };
+        return compilePair(0);
+      }
       if (h === "Block") {
         return _BaseCompiler.compileBlock(args, target);
       }
@@ -54245,7 +55106,6 @@ Error in definition of "${name}"`,
         }
         return fn(args, (expr) => _BaseCompiler.compile(expr, target), target);
       }
-      if (args === null) return `${fn}()`;
       return `${fn}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
     }
     /**
@@ -54276,11 +55136,109 @@ Error in definition of "${name}"`,
         `;${target.ws("\n")}`
       )}${target.ws("\n")}})()`;
     }
+    /**
+     * Compile a Loop expression with Element(index, Range(lo, hi)) indexing.
+     * Generates: (() => { for (let i = lo; i <= hi; i++) { body } })()
+     *
+     * The loop counter is always a raw number. For targets that wrap numeric
+     * values (e.g. interval-js wraps with `_IA.point()`), references to the
+     * loop index inside the body are wrapped via `target.number`.
+     */
+    static compileForLoop(args, target) {
+      if (!args[0]) throw new Error("Loop: no body");
+      if (!args[1]) throw new Error("Loop: no indexing set");
+      const indexing = args[1];
+      if (indexing.operator !== "Element" || !isFunction2(indexing))
+        throw new Error("Loop: expected Element(index, Range(lo, hi))");
+      const indexExpr = indexing.ops[0];
+      const rangeExpr = indexing.ops[1];
+      if (!isSymbol2(indexExpr)) throw new Error("Loop: index must be a symbol");
+      if (rangeExpr.operator !== "Range" || !isFunction2(rangeExpr))
+        throw new Error("Loop: expected Range(lo, hi)");
+      const index = indexExpr.symbol;
+      const lower = Math.floor(rangeExpr.ops[0].re);
+      const upper = Math.floor(rangeExpr.ops[1].re);
+      if (!Number.isFinite(lower) || !Number.isFinite(upper))
+        throw new Error("Loop: bounds must be finite numbers");
+      const needsWrap = target.number(0) !== "0";
+      const bodyTarget = {
+        ...target,
+        var: (id) => id === index ? needsWrap ? target.number(0).replace("0", index) : index : target.var(id)
+      };
+      const bodyStmts = _BaseCompiler.compileLoopBody(args[0], bodyTarget);
+      return `(() => {${target.ws("\n")}for (let ${index} = ${lower}; ${index} <= ${upper}; ${index}++) {${target.ws("\n")}${bodyStmts}${target.ws("\n")}}${target.ws("\n")}})()`;
+    }
+    /**
+     * Compile a loop body expression as statements (not wrapped in IIFE).
+     * Handles Break, Continue, Return as statements, and If as if-else when
+     * branches contain control flow.
+     */
+    static compileLoopBody(expr, target) {
+      if (isSymbol2(expr) && expr.symbol === "Nothing") return "";
+      if (!isFunction2(expr)) return _BaseCompiler.compile(expr, target);
+      const h = expr.operator;
+      if (h === "Break") return "break";
+      if (h === "Continue") return "continue";
+      if (h === "Return")
+        return `return ${_BaseCompiler.compile(expr.ops[0], target)}`;
+      if (h === "If") {
+        const condTarget = _BaseCompiler.scalarConditionTarget(target);
+        const cond = _BaseCompiler.compile(expr.ops[0], condTarget);
+        const thenBranch = _BaseCompiler.compileLoopBody(expr.ops[1], target);
+        if (expr.ops.length > 2) {
+          const elseBranch = _BaseCompiler.compileLoopBody(expr.ops[2], target);
+          if (elseBranch)
+            return `if (${cond}) { ${thenBranch} } else { ${elseBranch} }`;
+        }
+        return `if (${cond}) { ${thenBranch} }`;
+      }
+      if (h === "Block") {
+        return expr.ops.map((s) => _BaseCompiler.compileLoopBody(s, target)).join("; ");
+      }
+      return _BaseCompiler.compile(expr, target);
+    }
+    /**
+     * Create a target that compiles conditions as plain JS booleans.
+     * Used inside `compileLoopBody` so that `if (cond)` gets a real boolean,
+     * not an interval result object (which would always be truthy).
+     *
+     * Overrides comparison and logical operators to use plain JS, and
+     * numeric values/variables to use raw numbers (the loop counter is
+     * already a plain number).
+     */
+    static scalarConditionTarget(target) {
+      const SCALAR_OPS = {
+        Less: ["<", 20],
+        Greater: [">", 20],
+        LessEqual: ["<=", 20],
+        GreaterEqual: [">=", 20],
+        Equal: ["===", 20],
+        NotEqual: ["!==", 20],
+        And: ["&&", 6],
+        Or: ["||", 5],
+        Not: ["!", 16]
+      };
+      if (target.number(0) === "0") return target;
+      return {
+        ...target,
+        number: (n) => String(n),
+        var: (id) => {
+          const resolved = target.var(id);
+          if (!resolved) return void 0;
+          const match2 = resolved.match(/^_IA\.point\((.+)\)$/);
+          return match2 ? match2[1] : resolved;
+        },
+        operators: (op) => SCALAR_OPS[op] ?? target.operators?.(op),
+        functions: (id) => {
+          if (id in SCALAR_OPS) return void 0;
+          return target.functions?.(id);
+        }
+      };
+    }
     /**
      * Compile loop constructs (Sum/Product)
      */
     static compileLoop(h, args, target) {
-      if (args === null) throw new Error("Sum/Product: no arguments");
       if (!args[0]) throw new Error("Sum/Product: no body");
       const {
         index,
@@ -54532,6 +55490,8 @@ Error in definition of "${name}"`,
     GCD: "_SYS.gcd",
     Integrate: (args, compile3, target) => compileIntegrate(args, compile3, target),
     LCM: "_SYS.lcm",
+    Product: (args, compile3, target) => compileSumProduct("Product", args, compile3, target),
+    Sum: (args, compile3, target) => compileSumProduct("Sum", args, compile3, target),
     Limit: (args, compile3) => `_SYS.limit(${compile3(args[0])}, ${compile3(args[1])})`,
     Ln: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -54683,7 +55643,11 @@ Error in definition of "${name}"`,
       if (BaseCompiler.isComplexValued(arg)) return `_SYS.csech(${compile3(arg)})`;
       return `1 / Math.cosh(${compile3(arg)})`;
     },
+    Heaviside: "_SYS.heaviside",
     Sign: "Math.sign",
+    Sinc: "_SYS.sinc",
+    FresnelS: "_SYS.fresnelS",
+    FresnelC: "_SYS.fresnelC",
     Sin: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.csin(${compile3(args[0])})`;
@@ -55085,9 +56049,18 @@ Error in definition of "${name}"`,
       const pos = t * (colors.length - 1);
       const i = Math.floor(pos);
       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 };
+      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;
@@ -55136,82 +56109,87 @@ Error in definition of "${name}"`,
       return result;
     }
   };
+  var SYS_HELPERS = {
+    chop,
+    factorial: factorial2,
+    factorial2: factorial22,
+    gamma: gamma2,
+    gcd,
+    heaviside: (x) => x < 0 ? 0 : x === 0 ? 0.5 : 1,
+    integrate: (f, a, b) => monteCarloEstimate(f, a, b, 1e7).estimate,
+    lcm,
+    lngamma: gammaln2,
+    limit,
+    mean,
+    median,
+    variance,
+    populationVariance,
+    standardDeviation,
+    populationStandardDeviation,
+    kurtosis,
+    skewness,
+    mode,
+    quartiles,
+    interquartileRange,
+    erf,
+    erfc,
+    erfInv,
+    beta,
+    digamma,
+    trigamma,
+    polygamma,
+    zeta,
+    lambertW,
+    besselJ,
+    besselY,
+    besselI,
+    besselK,
+    airyAi,
+    airyBi,
+    sinc,
+    fresnelS,
+    fresnelC,
+    binomial: choose,
+    fibonacci,
+    // Complex helpers
+    csin: (z) => toRI(new Complex(z.re, z.im).sin()),
+    ccos: (z) => toRI(new Complex(z.re, z.im).cos()),
+    ctan: (z) => toRI(new Complex(z.re, z.im).tan()),
+    casin: (z) => toRI(new Complex(z.re, z.im).asin()),
+    cacos: (z) => toRI(new Complex(z.re, z.im).acos()),
+    catan: (z) => toRI(new Complex(z.re, z.im).atan()),
+    csinh: (z) => toRI(new Complex(z.re, z.im).sinh()),
+    ccosh: (z) => toRI(new Complex(z.re, z.im).cosh()),
+    ctanh: (z) => toRI(new Complex(z.re, z.im).tanh()),
+    csqrt: (z) => toRI(new Complex(z.re, z.im).sqrt()),
+    cexp: (z) => toRI(new Complex(z.re, z.im).exp()),
+    cln: (z) => toRI(new Complex(z.re, z.im).log()),
+    cpow: (z, w) => {
+      const zz = typeof z === "number" ? new Complex(z, 0) : new Complex(z.re, z.im);
+      const ww = typeof w === "number" ? new Complex(w, 0) : new Complex(w.re, w.im);
+      return toRI(zz.pow(ww));
+    },
+    ccot: (z) => toRI(new Complex(z.re, z.im).cot()),
+    csec: (z) => toRI(new Complex(z.re, z.im).sec()),
+    ccsc: (z) => toRI(new Complex(z.re, z.im).csc()),
+    ccoth: (z) => toRI(new Complex(z.re, z.im).coth()),
+    csech: (z) => toRI(new Complex(z.re, z.im).sech()),
+    ccsch: (z) => toRI(new Complex(z.re, z.im).csch()),
+    cacot: (z) => toRI(new Complex(z.re, z.im).acot()),
+    casec: (z) => toRI(new Complex(z.re, z.im).asec()),
+    cacsc: (z) => toRI(new Complex(z.re, z.im).acsc()),
+    cacoth: (z) => toRI(new Complex(z.re, z.im).acoth()),
+    casech: (z) => toRI(new Complex(z.re, z.im).asech()),
+    cacsch: (z) => toRI(new Complex(z.re, z.im).acsch()),
+    cabs: (z) => new Complex(z.re, z.im).abs(),
+    carg: (z) => new Complex(z.re, z.im).arg(),
+    cconj: (z) => toRI(new Complex(z.re, z.im).conjugate()),
+    cneg: (z) => ({ re: -z.re, im: -z.im }),
+    // Color helpers
+    ...colorHelpers
+  };
   var ComputeEngineFunction = class extends Function {
-    SYS = {
-      chop,
-      factorial: factorial2,
-      factorial2: factorial22,
-      gamma: gamma2,
-      gcd,
-      integrate: (f, a, b) => monteCarloEstimate(f, a, b, 1e7).estimate,
-      lcm,
-      lngamma: gammaln2,
-      limit,
-      mean,
-      median,
-      variance,
-      populationVariance,
-      standardDeviation,
-      populationStandardDeviation,
-      kurtosis,
-      skewness,
-      mode,
-      quartiles,
-      interquartileRange,
-      erf,
-      erfc,
-      erfInv,
-      beta,
-      digamma,
-      trigamma,
-      polygamma,
-      zeta,
-      lambertW,
-      besselJ,
-      besselY,
-      besselI,
-      besselK,
-      airyAi,
-      airyBi,
-      binomial: choose,
-      fibonacci,
-      // Complex helpers
-      csin: (z) => toRI(new Complex(z.re, z.im).sin()),
-      ccos: (z) => toRI(new Complex(z.re, z.im).cos()),
-      ctan: (z) => toRI(new Complex(z.re, z.im).tan()),
-      casin: (z) => toRI(new Complex(z.re, z.im).asin()),
-      cacos: (z) => toRI(new Complex(z.re, z.im).acos()),
-      catan: (z) => toRI(new Complex(z.re, z.im).atan()),
-      csinh: (z) => toRI(new Complex(z.re, z.im).sinh()),
-      ccosh: (z) => toRI(new Complex(z.re, z.im).cosh()),
-      ctanh: (z) => toRI(new Complex(z.re, z.im).tanh()),
-      csqrt: (z) => toRI(new Complex(z.re, z.im).sqrt()),
-      cexp: (z) => toRI(new Complex(z.re, z.im).exp()),
-      cln: (z) => toRI(new Complex(z.re, z.im).log()),
-      cpow: (z, w) => {
-        const zz = typeof z === "number" ? new Complex(z, 0) : new Complex(z.re, z.im);
-        const ww = typeof w === "number" ? new Complex(w, 0) : new Complex(w.re, w.im);
-        return toRI(zz.pow(ww));
-      },
-      ccot: (z) => toRI(new Complex(z.re, z.im).cot()),
-      csec: (z) => toRI(new Complex(z.re, z.im).sec()),
-      ccsc: (z) => toRI(new Complex(z.re, z.im).csc()),
-      ccoth: (z) => toRI(new Complex(z.re, z.im).coth()),
-      csech: (z) => toRI(new Complex(z.re, z.im).sech()),
-      ccsch: (z) => toRI(new Complex(z.re, z.im).csch()),
-      cacot: (z) => toRI(new Complex(z.re, z.im).acot()),
-      casec: (z) => toRI(new Complex(z.re, z.im).asec()),
-      cacsc: (z) => toRI(new Complex(z.re, z.im).acsc()),
-      cacoth: (z) => toRI(new Complex(z.re, z.im).acoth()),
-      casech: (z) => toRI(new Complex(z.re, z.im).asech()),
-      cacsch: (z) => toRI(new Complex(z.re, z.im).acsch()),
-      cabs: (z) => new Complex(z.re, z.im).abs(),
-      carg: (z) => new Complex(z.re, z.im).arg(),
-      cconj: (z) => toRI(new Complex(z.re, z.im).conjugate()),
-      cneg: (z) => ({ re: -z.re, im: -z.im }),
-      // Color helpers
-      ...colorHelpers
-    };
+    SYS = SYS_HELPERS;
     constructor(body, preamble = "") {
       super(
         "_SYS",
@@ -55229,81 +56207,7 @@ Error in definition of "${name}"`,
     }
   };
   var ComputeEngineFunctionLiteral = class extends Function {
-    SYS = {
-      chop,
-      factorial: factorial2,
-      factorial2: factorial22,
-      gamma: gamma2,
-      gcd,
-      integrate: (f, a, b) => monteCarloEstimate(f, a, b, 1e7).estimate,
-      lcm,
-      lngamma: gammaln2,
-      limit,
-      mean,
-      median,
-      variance,
-      populationVariance,
-      standardDeviation,
-      populationStandardDeviation,
-      kurtosis,
-      skewness,
-      mode,
-      quartiles,
-      interquartileRange,
-      erf,
-      erfc,
-      erfInv,
-      beta,
-      digamma,
-      trigamma,
-      polygamma,
-      zeta,
-      lambertW,
-      besselJ,
-      besselY,
-      besselI,
-      besselK,
-      airyAi,
-      airyBi,
-      binomial: choose,
-      fibonacci,
-      // Complex helpers
-      csin: (z) => toRI(new Complex(z.re, z.im).sin()),
-      ccos: (z) => toRI(new Complex(z.re, z.im).cos()),
-      ctan: (z) => toRI(new Complex(z.re, z.im).tan()),
-      casin: (z) => toRI(new Complex(z.re, z.im).asin()),
-      cacos: (z) => toRI(new Complex(z.re, z.im).acos()),
-      catan: (z) => toRI(new Complex(z.re, z.im).atan()),
-      csinh: (z) => toRI(new Complex(z.re, z.im).sinh()),
-      ccosh: (z) => toRI(new Complex(z.re, z.im).cosh()),
-      ctanh: (z) => toRI(new Complex(z.re, z.im).tanh()),
-      csqrt: (z) => toRI(new Complex(z.re, z.im).sqrt()),
-      cexp: (z) => toRI(new Complex(z.re, z.im).exp()),
-      cln: (z) => toRI(new Complex(z.re, z.im).log()),
-      cpow: (z, w) => {
-        const zz = typeof z === "number" ? new Complex(z, 0) : new Complex(z.re, z.im);
-        const ww = typeof w === "number" ? new Complex(w, 0) : new Complex(w.re, w.im);
-        return toRI(zz.pow(ww));
-      },
-      ccot: (z) => toRI(new Complex(z.re, z.im).cot()),
-      csec: (z) => toRI(new Complex(z.re, z.im).sec()),
-      ccsc: (z) => toRI(new Complex(z.re, z.im).csc()),
-      ccoth: (z) => toRI(new Complex(z.re, z.im).coth()),
-      csech: (z) => toRI(new Complex(z.re, z.im).sech()),
-      ccsch: (z) => toRI(new Complex(z.re, z.im).csch()),
-      cacot: (z) => toRI(new Complex(z.re, z.im).acot()),
-      casec: (z) => toRI(new Complex(z.re, z.im).asec()),
-      cacsc: (z) => toRI(new Complex(z.re, z.im).acsc()),
-      cacoth: (z) => toRI(new Complex(z.re, z.im).acoth()),
-      casech: (z) => toRI(new Complex(z.re, z.im).asech()),
-      cacsch: (z) => toRI(new Complex(z.re, z.im).acsch()),
-      cabs: (z) => new Complex(z.re, z.im).abs(),
-      carg: (z) => new Complex(z.re, z.im).arg(),
-      cconj: (z) => toRI(new Complex(z.re, z.im).conjugate()),
-      cneg: (z) => ({ re: -z.re, im: -z.im }),
-      // Color helpers
-      ...colorHelpers
-    };
+    SYS = SYS_HELPERS;
     constructor(body, args) {
       super("_SYS", ...args, `return ${body}`);
       return new Proxy(this, {
@@ -55353,7 +56257,14 @@ Error in definition of "${name}"`,
       };
     }
     compile(expr, options = {}) {
-      const { operators, functions, vars, imports = [], preamble } = options;
+      const {
+        operators,
+        functions,
+        vars,
+        imports = [],
+        preamble,
+        realOnly
+      } = options;
       const unknowns = expr.unknowns;
       let preambleImports = imports.map((x) => {
         if (typeof x === "function") return x.toString();
@@ -55406,10 +56317,21 @@ Error in definition of "${name}"`,
         },
         preamble: (preamble ?? "") + preambleImports
       });
-      return compileToTarget(expr, target);
+      return compileToTarget(expr, target, realOnly);
     }
   };
-  function compileToTarget(expr, target) {
+  function wrapRealOnly(result) {
+    if (!result.run) return result;
+    const origRun = result.run;
+    result.run = ((...args) => {
+      const r = origRun(...args);
+      if (typeof r === "object" && r !== null && "im" in r)
+        return r.im === 0 ? r.re : NaN;
+      return r;
+    });
+    return result;
+  }
+  function compileToTarget(expr, target, realOnly) {
     if (expr.operator === "Function" && isFunction2(expr)) {
       const args = expr.ops;
       const params = args.slice(1).map((x) => isSymbol2(x) ? x.symbol : "_");
@@ -55439,12 +56361,68 @@ Error in definition of "${name}"`,
     }
     const js = BaseCompiler.compile(expr, target);
     const fn = new ComputeEngineFunction(js, target.preamble);
-    return {
+    const result = {
       target: "javascript",
       success: true,
       code: js,
       run: fn
     };
+    return realOnly ? wrapRealOnly(result) : result;
+  }
+  var UNROLL_LIMIT = 100;
+  function compileSumProduct(kind, args, _compile, target) {
+    if (!args[0]) throw new Error(`${kind}: no body`);
+    if (!args[1]) throw new Error(`${kind}: no indexing set`);
+    const { index, lower, upper } = normalizeIndexingSet(args[1]);
+    const isSum = kind === "Sum";
+    const op = isSum ? "+" : "*";
+    const identity = isSum ? "0" : "1";
+    if (lower > upper) return identity;
+    const termCount = upper - lower + 1;
+    const bodyIsComplex = BaseCompiler.isComplexValued(args[0]);
+    if (termCount <= UNROLL_LIMIT) {
+      const terms = [];
+      for (let k = lower; k <= upper; k++) {
+        const innerTarget = {
+          ...target,
+          var: (id) => id === index ? String(k) : target.var(id)
+        };
+        terms.push(`(${BaseCompiler.compile(args[0], innerTarget)})`);
+      }
+      if (!bodyIsComplex) {
+        return `(${terms.join(` ${op} `)})`;
+      }
+      const temps = terms.map((_, i) => `_t${i}`);
+      const assignments = terms.map((t, i) => `const ${temps[i]} = ${t}`).join("; ");
+      if (isSum) {
+        const reSum = temps.map((t) => `${t}.re`).join(" + ");
+        const imSum = temps.map((t) => `${t}.im`).join(" + ");
+        return `(() => { ${assignments}; return { re: ${reSum}, im: ${imSum} }; })()`;
+      }
+      let acc2 = temps[0];
+      const parts = [assignments];
+      for (let i = 1; i < temps.length; i++) {
+        const prev = acc2;
+        acc2 = `_p${i}`;
+        parts.push(
+          `const ${acc2} = { re: ${prev}.re * ${temps[i]}.re - ${prev}.im * ${temps[i]}.im, im: ${prev}.re * ${temps[i]}.im + ${prev}.im * ${temps[i]}.re }`
+        );
+      }
+      return `(() => { ${parts.join("; ")}; return ${acc2}; })()`;
+    }
+    const bodyCode = BaseCompiler.compile(args[0], {
+      ...target,
+      var: (id) => id === index ? index : target.var(id)
+    });
+    const acc = BaseCompiler.tempVar();
+    if (bodyIsComplex) {
+      const val = BaseCompiler.tempVar();
+      if (isSum) {
+        return `(() => { let ${acc} = { re: 0, im: 0 }; let ${index} = ${lower}; while (${index} <= ${upper}) { const ${val} = ${bodyCode}; ${acc} = { re: ${acc}.re + ${val}.re, im: ${acc}.im + ${val}.im }; ${index}++; } return ${acc}; })()`;
+      }
+      return `(() => { let ${acc} = { re: 1, im: 0 }; let ${index} = ${lower}; while (${index} <= ${upper}) { const ${val} = ${bodyCode}; ${acc} = { re: ${acc}.re * ${val}.re - ${acc}.im * ${val}.im, im: ${acc}.re * ${val}.im + ${acc}.im * ${val}.re }; ${index}++; } return ${acc}; })()`;
+    }
+    return `(() => { let ${acc} = ${identity}; let ${index} = ${lower}; while (${index} <= ${upper}) { ${acc} ${op}= ${bodyCode}; ${index}++; } return ${acc}; })()`;
   }
   function compileIntegrate(args, _, target) {
     const { index, lower, upper } = normalizeIndexingSet(args[1]);
@@ -55660,13 +56638,11 @@ Error in definition of "${name}"`,
     Truncate: "trunc",
     // Complex-specific functions
     Re: (args, compile3) => {
-      if (BaseCompiler.isComplexValued(args[0]))
-        return `(${compile3(args[0])}).x`;
+      if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).x`;
       return compile3(args[0]);
     },
     Im: (args, compile3) => {
-      if (BaseCompiler.isComplexValued(args[0]))
-        return `(${compile3(args[0])}).y`;
+      if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).y`;
       return "0.0";
     },
     Arg: (args, compile3) => {
@@ -57119,6 +58095,15 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
   function remainder(a, b) {
     return sub2(a, mul4(b, round2(div3(a, b))));
   }
+  function heaviside(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo > 0) return ok({ lo: 1, hi: 1 });
+    if (xVal.hi < 0) return ok({ lo: 0, hi: 0 });
+    if (xVal.lo === 0 && xVal.hi === 0) return ok({ lo: 0.5, hi: 0.5 });
+    return { kind: "singular", at: 0 };
+  }
   function sign2(x) {
     const unwrapped = unwrapOrPropagate(x);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -57128,6 +58113,61 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     if (xVal.lo === 0 && xVal.hi === 0) return ok({ lo: 0, hi: 0 });
     return { kind: "singular", at: 0 };
   }
+  var GAMMA_MIN_X = 1.4616321449683622;
+  var GAMMA_MIN_Y = 0.8856031944108887;
+  function gamma3(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return _gamma(xVal);
+  }
+  function _gamma(x) {
+    if (x.hi >= 0 && x.lo <= 0) {
+      return { kind: "singular", at: 0 };
+    }
+    if (x.lo < 0) {
+      const ceilLo = Math.ceil(x.lo);
+      const floorHi = Math.floor(x.hi);
+      if (ceilLo <= floorHi) {
+        return { kind: "singular", at: ceilLo };
+      }
+      const gLo = gamma2(x.lo);
+      const gHi = gamma2(x.hi);
+      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+    }
+    if (x.lo >= GAMMA_MIN_X) {
+      return ok({ lo: gamma2(x.lo), hi: gamma2(x.hi) });
+    }
+    if (x.hi <= GAMMA_MIN_X) {
+      return ok({ lo: gamma2(x.hi), hi: gamma2(x.lo) });
+    }
+    return ok({
+      lo: GAMMA_MIN_Y,
+      hi: Math.max(gamma2(x.lo), gamma2(x.hi))
+    });
+  }
+  function gammaln3(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return _gammaln(xVal);
+  }
+  function _gammaln(x) {
+    if (x.hi >= 0 && x.lo <= 0) {
+      return { kind: "singular", at: 0 };
+    }
+    if (x.lo < 0) {
+      const ceilLo = Math.ceil(x.lo);
+      const floorHi = Math.floor(x.hi);
+      if (ceilLo <= floorHi) {
+        return { kind: "singular", at: ceilLo };
+      }
+      const gLo = gammaln2(x.lo);
+      const gHi = gammaln2(x.hi);
+      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+    }
+    return ok({ lo: gammaln2(x.lo), hi: gammaln2(x.hi) });
+  }
 
   // src/compute-engine/interval/trigonometric.ts
   var TWO_PI = 2 * Math.PI;
@@ -57461,6 +58501,86 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     }
     return acosh2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
   }
+  var SINC_EXTREMA = [
+    4.49341,
+    7.72525,
+    10.90412,
+    14.06619,
+    17.22076,
+    20.3713,
+    23.51945,
+    26.66605,
+    29.8116,
+    32.95639
+  ];
+  var SINC_GLOBAL_LO = -0.21724;
+  function sinc2(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    const sincVal = (t) => t === 0 ? 1 : Math.sin(t) / t;
+    let lo = sincVal(xVal.lo);
+    let hi = lo;
+    const update = (v) => {
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    };
+    update(sincVal(xVal.hi));
+    if (xVal.lo <= 0 && xVal.hi >= 0) {
+      update(1);
+    }
+    const lastExtremum = SINC_EXTREMA[SINC_EXTREMA.length - 1];
+    for (const e of SINC_EXTREMA) {
+      if (e >= xVal.lo && e <= xVal.hi) update(sincVal(e));
+      if (-e >= xVal.lo && -e <= xVal.hi) update(sincVal(-e));
+    }
+    if (Math.abs(xVal.lo) > lastExtremum || Math.abs(xVal.hi) > lastExtremum) {
+      update(SINC_GLOBAL_LO);
+    }
+    return ok({ lo, hi });
+  }
+  var FRESNEL_S_EXTREMA = [];
+  var FRESNEL_C_EXTREMA = [];
+  for (let n = 1; n <= 20; n++) {
+    FRESNEL_S_EXTREMA.push(Math.sqrt(2 * n));
+    FRESNEL_C_EXTREMA.push(Math.sqrt(2 * n - 1));
+  }
+  function fresnelS2(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    let lo = fresnelS(xVal.lo);
+    let hi = lo;
+    const update = (v) => {
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    };
+    update(fresnelS(xVal.hi));
+    if (xVal.lo <= 0 && xVal.hi >= 0) update(0);
+    for (const e of FRESNEL_S_EXTREMA) {
+      if (e >= xVal.lo && e <= xVal.hi) update(fresnelS(e));
+      if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelS(-e));
+    }
+    return ok({ lo, hi });
+  }
+  function fresnelC2(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    let lo = fresnelC(xVal.lo);
+    let hi = lo;
+    const update = (v) => {
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    };
+    update(fresnelC(xVal.hi));
+    if (xVal.lo <= 0 && xVal.hi >= 0) update(0);
+    for (const e of FRESNEL_C_EXTREMA) {
+      if (e >= xVal.lo && e <= xVal.hi) update(fresnelC(e));
+      if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelC(-e));
+    }
+    return ok({ lo, hi });
+  }
 
   // src/compute-engine/interval/comparison.ts
   function less(a, b) {
@@ -57614,7 +58734,10 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     max: max2,
     mod: mod2,
     remainder,
+    heaviside,
     sign: sign2,
+    gamma: gamma3,
+    gammaln: gammaln3,
     // Trigonometric
     sin: sin2,
     cos: cos2,
@@ -57641,6 +58764,9 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     acoth,
     acsch,
     asech,
+    sinc: sinc2,
+    fresnelS: fresnelS2,
+    fresnelC: fresnelC2,
     // Comparison
     less,
     lessEqual,
@@ -57772,6 +58898,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       return `_IA.powInterval(${compile3(arg)}, _IA.div(_IA.point(1), ${compile3(exp3)}))`;
     },
     Round: (args, compile3) => `_IA.round(${compile3(args[0])})`,
+    Heaviside: (args, compile3) => `_IA.heaviside(${compile3(args[0])})`,
     Sign: (args, compile3) => `_IA.sign(${compile3(args[0])})`,
     Sqrt: (args, compile3) => `_IA.sqrt(${compile3(args[0])})`,
     Square: (args, compile3) => `_IA.square(${compile3(args[0])})`,
@@ -57801,6 +58928,11 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     Arcoth: (args, compile3) => `_IA.acoth(${compile3(args[0])})`,
     Arcsch: (args, compile3) => `_IA.acsch(${compile3(args[0])})`,
     Arsech: (args, compile3) => `_IA.asech(${compile3(args[0])})`,
+    // Cardinal sine
+    Sinc: (args, compile3) => `_IA.sinc(${compile3(args[0])})`,
+    // Fresnel integrals
+    FresnelS: (args, compile3) => `_IA.fresnelS(${compile3(args[0])})`,
+    FresnelC: (args, compile3) => `_IA.fresnelC(${compile3(args[0])})`,
     // Special functions
     Gamma: (args, compile3) => `_IA.gamma(${compile3(args[0])})`,
     GammaLn: (args, compile3) => `_IA.gammaln(${compile3(args[0])})`,
@@ -57810,6 +58942,9 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     // Mod / Remainder
     Mod: (args, compile3) => `_IA.mod(${compile3(args[0])}, ${compile3(args[1])})`,
     Remainder: (args, compile3) => `_IA.remainder(${compile3(args[0])}, ${compile3(args[1])})`,
+    // Sum / Product
+    Sum: (args, compile3, target) => compileIntervalSumProduct("Sum", args, compile3, target),
+    Product: (args, compile3, target) => compileIntervalSumProduct("Product", args, compile3, target),
     // Conditionals
     If: (args, compile3) => {
       if (args.length !== 3) throw new Error("If: wrong number of arguments");
@@ -57819,6 +58954,26 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       () => ${compile3(args[2])}
     )`;
     },
+    Which: (args, compile3) => {
+      if (args.length < 2 || args.length % 2 !== 0)
+        throw new Error(
+          "Which: expected even number of arguments (condition/value pairs)"
+        );
+      const buildPiecewise = (i) => {
+        if (i >= args.length) return `{ kind: 'empty' }`;
+        const cond = args[i];
+        const val = args[i + 1];
+        if (isSymbol2(cond) && cond.symbol === "True") {
+          return compile3(val);
+        }
+        return `_IA.piecewise(
+      ${compile3(cond)},
+      () => ${compile3(val)},
+      () => ${buildPiecewise(i + 2)}
+    )`;
+      };
+      return buildPiecewise(0);
+    },
     // Comparisons
     Equal: (args, compile3) => `_IA.equal(${compile3(args[0])}, ${compile3(args[1])})`,
     NotEqual: (args, compile3) => `_IA.notEqual(${compile3(args[0])}, ${compile3(args[1])})`,
@@ -57830,6 +58985,38 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     Or: (args, compile3) => `_IA.or(${compile3(args[0])}, ${compile3(args[1])})`,
     Not: (args, compile3) => `_IA.not(${compile3(args[0])})`
   };
+  var INTERVAL_UNROLL_LIMIT = 100;
+  function compileIntervalSumProduct(kind, args, _compile, target) {
+    if (!args[0]) throw new Error(`${kind}: no body`);
+    if (!args[1]) throw new Error(`${kind}: no indexing set`);
+    const { index, lower, upper } = normalizeIndexingSet(args[1]);
+    const isSum = kind === "Sum";
+    const iaOp = isSum ? "_IA.add" : "_IA.mul";
+    const identity = isSum ? "_IA.point(0)" : "_IA.point(1)";
+    if (lower > upper) return identity;
+    const termCount = upper - lower + 1;
+    if (termCount <= INTERVAL_UNROLL_LIMIT) {
+      const terms = [];
+      for (let k = lower; k <= upper; k++) {
+        const innerTarget = {
+          ...target,
+          var: (id) => id === index ? `_IA.point(${k})` : target.var(id)
+        };
+        terms.push(BaseCompiler.compile(args[0], innerTarget));
+      }
+      let result = terms[terms.length - 1];
+      for (let i = terms.length - 2; i >= 0; i--) {
+        result = `${iaOp}(${terms[i]}, ${result})`;
+      }
+      return result;
+    }
+    const acc = BaseCompiler.tempVar();
+    const bodyCode = BaseCompiler.compile(args[0], {
+      ...target,
+      var: (id) => id === index ? `_IA.point(${index})` : target.var(id)
+    });
+    return `(() => { let ${acc} = ${identity}; for (let ${index} = ${lower}; ${index} <= ${upper}; ${index}++) { ${acc} = ${iaOp}(${acc}, ${bodyCode}); } return ${acc}; })()`;
+  }
   var ComputeEngineIntervalFunction = class extends Function {
     IA = IntervalArithmetic;
     constructor(body, preamble = "") {
@@ -57840,8 +59027,12 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       );
       return new Proxy(this, {
         apply: (target, thisArg, argumentsList) => {
-          const processedArgs = argumentsList.map(processInput);
-          return super.apply(thisArg, [this.IA, ...processedArgs]);
+          try {
+            const processedArgs = argumentsList.map(processInput);
+            return super.apply(thisArg, [this.IA, ...processedArgs]);
+          } catch {
+            return { kind: "entire" };
+          }
         },
         get: (target, prop) => {
           if (prop === "toString") return () => body;
@@ -57953,7 +59144,12 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     }
   };
   function compileToIntervalTarget(expr, target) {
-    const js = BaseCompiler.compile(expr, target);
+    let js;
+    try {
+      js = BaseCompiler.compile(expr, target);
+    } catch {
+      return { target: "interval-js", success: false, code: "" };
+    }
     const fn = new ComputeEngineIntervalFunction(js, target.preamble);
     return {
       target: "interval-js",
@@ -64080,7 +65276,8 @@ fn ${functionName}(${params}) -> IntervalResult {
           this.skipSpace();
           let result = this.parseInfixOperator(lhs, until);
           if (result === null && until.minPrec <= INVISIBLE_OP_PRECEDENCE) {
-            if (this.peekDefinitions("operator").length === 0) {
+            const opDefs = this.peekDefinitions("operator");
+            if (opDefs.length === 0 || opDefs.every(([def]) => def.latexTrigger === "\\text")) {
               const rhs = this.parseExpression({
                 ...until,
                 minPrec: INVISIBLE_OP_PRECEDENCE + 1
@@ -67615,10 +68812,10 @@ ${code}`;
   _setComputeEngineClass(ComputeEngine);
 
   // src/compute-engine.ts
-  var version = "0.51.0";
+  var version = "0.51.1";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.51.0"
+    version: "0.51.1"
   };
   return __toCommonJS(compute_engine_exports);
 })();