@cortex-js/compute-engine 0.51.0 → 0.51.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.51.0 */
+/** Compute Engine 0.51.1 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -9798,13 +9798,175 @@ var DEFINITIONS_CORE = [
     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{}";
@@ -10458,7 +10620,7 @@ var DELIMITERS_SHORTHAND = {
   // '⎾': '', // 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("_");
@@ -10471,7 +10633,7 @@ function parseAssign(parser, lhs) {
   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 = [];
@@ -10482,7 +10644,7 @@ function parseAssign(parser, lhs) {
   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) {
@@ -10498,12 +10660,12 @@ function parseAssign(parser, lhs) {
     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];
 }
@@ -10530,6 +10692,141 @@ function parseCasesEnvironment(parser) {
   }
   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;
@@ -10664,7 +10961,11 @@ var Serializer2 = class {
   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
@@ -11786,6 +12087,8 @@ var _BoxedExpression = class {
       // invisibleApply: '',
       multiply: "\\times",
       missingSymbol: "\\blacksquare",
+      dmsFormat: false,
+      angleNormalization: "none",
       // openGroup: '(',
       // closeGroup: ')',
       // divide: '\\frac{#1}{#2}',
@@ -16841,6 +17144,150 @@ function airyBiNegAsymptotic(absX, xi) {
   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) {
@@ -23492,7 +23939,7 @@ var ARITHMETIC_LIBRARY = [
       wikidata: "Q715358",
       complexity: 2e3,
       broadcastable: true,
-      signature: "(number) -> number",
+      signature: "(value) -> value",
       type: ([x]) => x.type,
       sgn: ([x]) => oppositeSgn(x.sgn),
       canonical: (args, { engine }) => {
@@ -23705,6 +24152,20 @@ var ARITHMETIC_LIBRARY = [
         (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,
@@ -28775,7 +29236,7 @@ var CALCULUS_LIBRARY = [
 ];
 
 // src/color/palette.ts
-var FOREGROUND_COLORS = {
+var NAMED_COLORS = {
   "red": "#d7170b",
   //<- 700, 500 ->'#f21c0d'
   "orange": "#fe8a2b",
@@ -28789,11 +29250,31 @@ var FOREGROUND_COLORS = {
   "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
@@ -29003,9 +29484,9 @@ function parseColor(s) {
     }
     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);
@@ -29041,8 +29522,8 @@ function parseColor(s) {
     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;
 }
@@ -31362,50 +31843,188 @@ var SEQUENTIAL_PALETTES = {
 
 // 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",
@@ -31453,28 +32072,6 @@ var KELLY_22 = [
   "#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",
@@ -31490,12 +32087,19 @@ var SPECTRUM_12 = [
   "#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
@@ -39792,6 +40396,29 @@ var TRIGONOMETRY_LIBRARY = [
         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,
@@ -39893,6 +40520,39 @@ var TRIGONOMETRY_LIBRARY = [
     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',
@@ -39976,6 +40636,61 @@ var DEFINITIONS_ALGEBRA = [
   }
 ];
 
+// 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;
@@ -40143,6 +40858,29 @@ var DEFINITIONS_UNITS = [
       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}}`]);
@@ -40548,6 +41286,37 @@ function serializePower(serializer, expr) {
     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" },
@@ -40558,32 +41327,48 @@ var DEFINITIONS_ARITHMETIC = [
     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"],
@@ -40592,6 +41377,28 @@ var DEFINITIONS_ARITHMETIC = [
       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"
@@ -41327,6 +42134,11 @@ var DEFINITIONS_ARITHMETIC = [
     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'
@@ -44212,6 +45024,21 @@ var DEFINITIONS_TRIGONOMETRY = [
     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"
   }
 ];
 
@@ -54096,6 +54923,17 @@ var BaseCompiler = class _BaseCompiler {
       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);
@@ -54104,7 +54942,6 @@ var BaseCompiler = class _BaseCompiler {
       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)) {
@@ -54123,7 +54960,6 @@ var BaseCompiler = class _BaseCompiler {
               }
               return `(${result.join(") && (")})`;
             }
-            if (args === null) return "";
             let resultStr;
             if (args.length === 1) {
               resultStr = `${op[0]}${_BaseCompiler.compile(args[0], target, op[1])}`;
@@ -54151,6 +54987,9 @@ var BaseCompiler = class _BaseCompiler {
       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);
@@ -54158,7 +54997,6 @@ var BaseCompiler = class _BaseCompiler {
         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(
@@ -54166,6 +55004,29 @@ var BaseCompiler = class _BaseCompiler {
         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);
     }
@@ -54183,7 +55044,6 @@ var BaseCompiler = class _BaseCompiler {
       }
       return fn(args, (expr) => _BaseCompiler.compile(expr, target), target);
     }
-    if (args === null) return `${fn}()`;
     return `${fn}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
   }
   /**
@@ -54214,11 +55074,109 @@ var BaseCompiler = class _BaseCompiler {
       `;${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,
@@ -54470,6 +55428,8 @@ var JAVASCRIPT_FUNCTIONS = {
   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]))
@@ -54621,7 +55581,11 @@ var JAVASCRIPT_FUNCTIONS = {
     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])})`;
@@ -55023,9 +55987,18 @@ var colorHelpers = {
     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;
@@ -55074,82 +56047,87 @@ var colorHelpers = {
     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",
@@ -55167,81 +56145,7 @@ var ComputeEngineFunction = class extends Function {
   }
 };
 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, {
@@ -55291,7 +56195,14 @@ var JavaScriptTarget = class {
     };
   }
   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();
@@ -55344,10 +56255,21 @@ var JavaScriptTarget = class {
       },
       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 : "_");
@@ -55377,12 +56299,68 @@ function compileToTarget(expr, target) {
   }
   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]);
@@ -55598,13 +56576,11 @@ var GPU_FUNCTIONS = {
   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) => {
@@ -57057,6 +58033,15 @@ function mod2(a, b) {
 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;
@@ -57066,6 +58051,61 @@ function sign2(x) {
   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;
@@ -57399,6 +58439,86 @@ function asech(x) {
   }
   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) {
@@ -57552,7 +58672,10 @@ var IntervalArithmetic = {
   max: max2,
   mod: mod2,
   remainder,
+  heaviside,
   sign: sign2,
+  gamma: gamma3,
+  gammaln: gammaln3,
   // Trigonometric
   sin: sin2,
   cos: cos2,
@@ -57579,6 +58702,9 @@ var IntervalArithmetic = {
   acoth,
   acsch,
   asech,
+  sinc: sinc2,
+  fresnelS: fresnelS2,
+  fresnelC: fresnelC2,
   // Comparison
   less,
   lessEqual,
@@ -57710,6 +58836,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     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])})`,
@@ -57739,6 +58866,11 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   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])})`,
@@ -57748,6 +58880,9 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   // 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");
@@ -57757,6 +58892,26 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
       () => ${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])})`,
@@ -57768,6 +58923,38 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   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 = "") {
@@ -57778,8 +58965,12 @@ var ComputeEngineIntervalFunction = class extends Function {
     );
     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;
@@ -57891,7 +59082,12 @@ var IntervalJavaScriptTarget = class {
   }
 };
 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",
@@ -64018,7 +65214,8 @@ var _Parser = class __Parser {
         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
@@ -67553,10 +68750,10 @@ var ComputeEngine = class _ComputeEngine {
 _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"
 };
 export {
   BaseCompiler,