@cortex-js/compute-engine 0.55.0 → 0.55.3

package/dist/core.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.0 */
+/** Compute Engine 0.55.3 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -9526,6 +9526,452 @@ function expressionToDictionaryValue(expr2) {
   return expr2;
 }
 
+// src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
+var DEFINITIONS_LOGIC = [
+  // Constants
+  {
+    name: "True",
+    kind: "symbol",
+    latexTrigger: ["\\top"]
+    // ⊤ U+22A4
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathrm{True}",
+    parse: "True"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\operatorname{True}",
+    parse: "True"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathsf{T}",
+    parse: "True"
+  },
+  {
+    name: "False",
+    kind: "symbol",
+    latexTrigger: ["\\bot"]
+    // ⊥ U+22A5
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\operatorname{False}",
+    parse: "False"
+  },
+  {
+    kind: "symbol",
+    latexTrigger: "\\mathsf{F}",
+    parse: "False"
+  },
+  // Operators
+  // Logic operators have lower precedence than comparisons (245)
+  // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
+  // See https://github.com/cortex-js/compute-engine/issues/243
+  {
+    name: "And",
+    kind: "infix",
+    latexTrigger: ["\\land"],
+    precedence: 235
+    // serialize: '\\land',
+  },
+  { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
+  { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
+  {
+    kind: "infix",
+    latexTrigger: "\\operatorname{and}",
+    parse: "And",
+    precedence: 235
+  },
+  {
+    name: "Or",
+    kind: "infix",
+    latexTrigger: ["\\lor"],
+    precedence: 230
+  },
+  { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
+  { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
+  {
+    kind: "infix",
+    latexTrigger: "\\operatorname{or}",
+    parse: "Or",
+    precedence: 230
+  },
+  {
+    name: "Xor",
+    kind: "infix",
+    latexTrigger: ["\\veebar"],
+    precedence: 232
+  },
+  // Possible alt: \oplus ⊕ U+2295
+  {
+    name: "Not",
+    kind: "prefix",
+    latexTrigger: ["\\lnot"],
+    precedence: 880
+  },
+  {
+    kind: "prefix",
+    latexTrigger: ["\\neg"],
+    parse: "Not",
+    precedence: 880
+  },
+  {
+    name: "Nand",
+    kind: "infix",
+    latexTrigger: ["\\barwedge"],
+    precedence: 232
+    // serialize: '\\mid',
+  },
+  {
+    name: "Nor",
+    kind: "infix",
+    latexTrigger: ["\u22BD"],
+    // bar vee
+    precedence: 232
+    // serialize: '\\downarrow',
+  },
+  // Functions
+  {
+    kind: "function",
+    symbolTrigger: "and",
+    parse: "And"
+  },
+  {
+    kind: "function",
+    symbolTrigger: "or",
+    parse: "Or"
+  },
+  {
+    kind: "function",
+    symbolTrigger: "not",
+    parse: "Not"
+  },
+  // Relations
+  {
+    name: "Implies",
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    latexTrigger: ["\\implies"],
+    serialize: "\\implies"
+  },
+  {
+    latexTrigger: ["\\Rightarrow"],
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    parse: "Implies"
+  },
+  {
+    latexTrigger: ["\\rightarrow"],
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    parse: "Implies"
+  },
+  {
+    latexTrigger: ["\\Longrightarrow"],
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    parse: "Implies"
+  },
+  {
+    latexTrigger: ["\\longrightarrow"],
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    parse: "Implies"
+  },
+  {
+    // Non-strict mode: => for implies
+    latexTrigger: ["=", ">"],
+    kind: "infix",
+    precedence: 220,
+    associativity: "right",
+    parse: (parser, lhs, until) => {
+      if (parser.options.strict !== false) return null;
+      const rhs = parser.parseExpression({ ...until, minPrec: 220 });
+      if (rhs === null) return null;
+      return ["Implies", lhs, rhs];
+    }
+  },
+  {
+    name: "Equivalent",
+    // MathML: identical to, Mathematica: Congruent
+    latexTrigger: ["\\iff"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219
+  },
+  {
+    latexTrigger: ["\\Leftrightarrow"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: "Equivalent"
+  },
+  {
+    latexTrigger: ["\\leftrightarrow"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: "Equivalent"
+  },
+  {
+    latexTrigger: ["\\Longleftrightarrow"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: "Equivalent"
+  },
+  {
+    latexTrigger: ["\\longleftrightarrow"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: "Equivalent"
+  },
+  {
+    // Non-strict mode: <=> for equivalence
+    latexTrigger: ["<", "=", ">"],
+    kind: "infix",
+    precedence: 219,
+    associativity: "right",
+    parse: (parser, lhs, until) => {
+      if (parser.options.strict !== false) return null;
+      const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+      if (rhs === null) return null;
+      return ["Equivalent", lhs, rhs];
+    }
+  },
+  {
+    latexTrigger: ["\\equiv"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: (parser, lhs, terminator) => {
+      const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
+      const index = parser.index;
+      const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
+      if (modulus !== null && operator(modulus) === "Mod")
+        return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
+      parser.index = index;
+      return ["Equivalent", lhs, missingIfEmpty(rhs)];
+    }
+  },
+  {
+    name: "Proves",
+    kind: "infix",
+    latexTrigger: ["\\vdash"],
+    precedence: 220,
+    associativity: "right",
+    serialize: "\\vdash"
+  },
+  {
+    name: "Entails",
+    kind: "infix",
+    latexTrigger: ["\\vDash"],
+    precedence: 220,
+    associativity: "right",
+    serialize: "\\vDash"
+  },
+  {
+    name: "Satisfies",
+    kind: "infix",
+    latexTrigger: ["\\models"],
+    precedence: 220,
+    associativity: "right",
+    serialize: "\\models"
+  },
+  // Quantifiers: for all, exists
+  {
+    name: "ForAll",
+    kind: "prefix",
+    latexTrigger: ["\\forall"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE
+    serialize: serializeQuantifier("\\forall"),
+    parse: parseQuantifier("ForAll")
+  },
+  {
+    name: "Exists",
+    kind: "prefix",
+    latexTrigger: ["\\exists"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE,
+    serialize: serializeQuantifier("\\exists"),
+    parse: parseQuantifier("Exists")
+  },
+  {
+    name: "ExistsUnique",
+    kind: "prefix",
+    latexTrigger: ["\\exists", "!"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE,
+    serialize: serializeQuantifier("\\exists!"),
+    parse: parseQuantifier("ExistsUnique")
+  },
+  {
+    name: "NotForAll",
+    kind: "prefix",
+    latexTrigger: ["\\lnot", "\\forall"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE
+    serialize: serializeQuantifier("\\lnot\\forall"),
+    parse: parseQuantifier("NotForAll")
+  },
+  {
+    name: "NotExists",
+    kind: "prefix",
+    latexTrigger: ["\\lnot", "\\exists"],
+    precedence: 200,
+    // Has to be lower than COMPARISON_PRECEDENCE,
+    serialize: serializeQuantifier("\\lnot\\exists"),
+    parse: parseQuantifier("NotExists")
+  },
+  {
+    name: "KroneckerDelta",
+    kind: "prefix",
+    latexTrigger: ["\\delta", "_"],
+    precedence: 200,
+    serialize: (serializer, expr2) => {
+      const args = operands(expr2);
+      if (args.length === 0) return "\\delta";
+      if (args.every((x) => symbol(x)))
+        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
+      return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
+    },
+    parse: (parser) => {
+      const group = parser.parseGroup();
+      if (group === null) {
+        const token = parser.parseToken();
+        if (!token) return null;
+        return ["KroneckerDelta", token];
+      }
+      const seq = getSequence(group);
+      if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
+      if (operator(group) === "InvisibleOperator")
+        return ["KroneckerDelta", ...operands(group)];
+      if (group !== null) return ["KroneckerDelta", group];
+      return null;
+    }
+  },
+  // Iverson brackets. Also called the "indicator function"
+  // Must have a single argument, a relational expression, i.e.
+  // `[ a = b ]` or `[ x \leq 0 ]`
+  // Otherwise, it gets rejected, it could be something else, like a list or
+  // tuple.
+  {
+    name: "Boole",
+    kind: "matchfix",
+    openTrigger: "[",
+    closeTrigger: "]",
+    // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
+    //   const args = ops(expr);
+    //   return `[${serializer.serialize(arg)}]`;
+    // },
+    parse: (_parser, body) => {
+      const h = operator(body);
+      if (!h) return null;
+      if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+      return ["Boole", body];
+    }
+  },
+  {
+    kind: "matchfix",
+    openTrigger: "\\llbracket",
+    closeTrigger: "\\rrbracket",
+    parse: (_parser, body) => {
+      const h = operator(body);
+      if (!h) return null;
+      if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+      return ["Boole", body];
+    }
+  },
+  // Predicate application in First-Order Logic.
+  // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
+  {
+    name: "Predicate",
+    serialize: (serializer, expr2) => {
+      const args = operands(expr2);
+      if (args.length === 0) return "";
+      const pred = args[0];
+      const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
+      if (args.length === 1) return predStr;
+      const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
+      return `${predStr}(${argStrs.join(", ")})`;
+    }
+  }
+];
+function serializeQuantifier(quantifierSymbol) {
+  return (serializer, expr2) => {
+    const args = operands(expr2);
+    if (args.length === 0) return quantifierSymbol;
+    if (args.length === 1)
+      return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
+    const boundVar = serializer.serialize(args[0]);
+    const body = serializer.serialize(args[1]);
+    return `${quantifierSymbol} ${boundVar}, ${body}`;
+  };
+}
+function tightBindingCondition(p, terminator) {
+  return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
+}
+function parseQuantifier(kind) {
+  return (parser, terminator) => {
+    const index = parser.index;
+    const useTightBinding = parser.options.quantifierScope !== "loose";
+    const symbol2 = parser.parseSymbol(terminator);
+    if (symbol2) {
+      parser.skipSpace();
+      if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
+        const bodyTerminator = useTightBinding ? {
+          ...terminator,
+          condition: (p) => tightBindingCondition(p, terminator)
+        } : terminator;
+        parser.enterQuantifierScope();
+        const body2 = parser.parseExpression(bodyTerminator);
+        parser.exitQuantifierScope();
+        return [kind, symbol2, missingIfEmpty(body2)];
+      }
+      parser.enterQuantifierScope();
+      const body = parser.parseEnclosure();
+      parser.exitQuantifierScope();
+      if (body) return [kind, symbol2, missingIfEmpty(body)];
+    }
+    parser.index = index;
+    const condTerminator = {
+      ...terminator,
+      condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
+    };
+    const condition = parser.parseExpression(condTerminator);
+    if (condition === null) return null;
+    parser.skipSpace();
+    if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
+      const bodyTerminator = useTightBinding ? {
+        ...terminator,
+        condition: (p) => tightBindingCondition(p, terminator)
+      } : terminator;
+      parser.enterQuantifierScope();
+      const body = parser.parseExpression(bodyTerminator);
+      parser.exitQuantifierScope();
+      return [kind, condition, missingIfEmpty(body)];
+    }
+    if (parser.match("(")) {
+      parser.enterQuantifierScope();
+      const body = parser.parseExpression(terminator);
+      parser.exitQuantifierScope();
+      if (!parser.match(")")) return null;
+      return [kind, condition, missingIfEmpty(body)];
+    }
+    return null;
+  };
+}
+
 // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
 function parseSequence(parser, terminator, lhs, prec, sep) {
   if (terminator && terminator.minPrec >= prec) return null;
@@ -10136,6 +10582,120 @@ var DEFINITIONS_CORE = [
     precedence: 21,
     parse: (parser, lhs, until) => parseWhereExpression(parser, lhs, until)
   },
+  // \text{and} — logical conjunction infix
+  {
+    latexTrigger: ["\\text"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 235,
+    // Same as \land
+    parse: (parser, lhs, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "and")) {
+        parser.index = start;
+        return null;
+      }
+      const rhs = parser.parseExpression({ ...until, minPrec: 235 });
+      return ["And", lhs, rhs ?? "Nothing"];
+    }
+  },
+  // \text{or} — logical disjunction infix
+  {
+    latexTrigger: ["\\text"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 230,
+    // Same as \lor
+    parse: (parser, lhs, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "or")) {
+        parser.index = start;
+        return null;
+      }
+      const rhs = parser.parseExpression({ ...until, minPrec: 230 });
+      return ["Or", lhs, rhs ?? "Nothing"];
+    }
+  },
+  // \text{iff} — biconditional (if and only if)
+  {
+    latexTrigger: ["\\text"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    // Same as \iff
+    parse: (parser, lhs, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "iff")) {
+        parser.index = start;
+        return null;
+      }
+      const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+      return ["Equivalent", lhs, rhs ?? "Nothing"];
+    }
+  },
+  // \text{if and only if} — verbose biconditional
+  {
+    latexTrigger: ["\\text"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 219,
+    parse: (parser, lhs, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "if and only if")) {
+        parser.index = start;
+        return null;
+      }
+      const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+      return ["Equivalent", lhs, rhs ?? "Nothing"];
+    }
+  },
+  // \text{such that} — constraint separator (like : in set-builder notation)
+  {
+    latexTrigger: ["\\text"],
+    kind: "infix",
+    associativity: "right",
+    precedence: 21,
+    // Low precedence to capture full condition (same as 'where')
+    parse: (parser, lhs, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "such that")) {
+        parser.index = start;
+        return null;
+      }
+      const rhs = parser.parseExpression({ ...until, minPrec: 21 });
+      return ["Colon", lhs, rhs ?? "Nothing"];
+    }
+  },
+  // \text{for all} — universal quantifier
+  {
+    latexTrigger: ["\\text"],
+    kind: "prefix",
+    precedence: 200,
+    // Same as \forall
+    parse: (parser, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "for all")) {
+        parser.index = start;
+        return null;
+      }
+      return parseQuantifier("ForAll")(parser, until);
+    }
+  },
+  // \text{there exists} — existential quantifier
+  {
+    latexTrigger: ["\\text"],
+    kind: "prefix",
+    precedence: 200,
+    // Same as \exists
+    parse: (parser, until) => {
+      const start = parser.index;
+      if (!matchTextKeyword(parser, "there exists")) {
+        parser.index = start;
+        return null;
+      }
+      return parseQuantifier("Exists")(parser, until);
+    }
+  },
   // Block serializer — used by both `where` and semicolon blocks
   {
     name: "Block",
@@ -10251,6 +10811,39 @@ var DEFINITIONS_CORE = [
       parser.parseExpression(until) ?? "Nothing"
     ]
   },
+  // Text serializer — reconstructs \text{...} with inline $...$ for math
+  {
+    name: "Text",
+    serialize: (serializer, expr2) => {
+      const args = operands(expr2);
+      if (args.length === 0) return "";
+      let firstStr = -1;
+      let lastStr = -1;
+      for (let i = 0; i < args.length; i++) {
+        if (stringValue(args[i]) !== null) {
+          if (firstStr < 0) firstStr = i;
+          lastStr = i;
+        }
+      }
+      if (firstStr < 0)
+        return joinLatex(args.map((a) => serializer.serialize(a)));
+      const parts = [];
+      for (let i = 0; i < firstStr; i++)
+        parts.push(serializer.serialize(args[i]));
+      let textContent = "";
+      for (let i = firstStr; i <= lastStr; i++) {
+        const s = stringValue(args[i]);
+        if (s !== null) textContent += sanitizeLatex(s);
+        else if (operator(args[i]) === "Annotated" || operator(args[i]) === "Text")
+          textContent += serializer.serialize(args[i]);
+        else textContent += "$" + serializer.serialize(args[i]) + "$";
+      }
+      parts.push("\\text{" + textContent + "}");
+      for (let i = lastStr + 1; i < args.length; i++)
+        parts.push(serializer.serialize(args[i]));
+      return joinLatex(parts);
+    }
+  },
   {
     name: "String",
     latexTrigger: ["\\text"],
@@ -10641,9 +11234,10 @@ function parseTextRun(parser, style) {
     } else if (parser.match("\\textcolor")) {
       const pos = parser.index;
       const color = parser.parseStringGroup();
-      const body2 = parser.parseExpression();
-      if (color !== null && body2 !== null) {
-        runs.push(["Annotated", body2, { dict: { color } }]);
+      if (color !== null) {
+        flush();
+        const body2 = parseTextRun(parser);
+        runs.push(["Annotated", body2, dictionaryFromEntries({ color })]);
       } else {
         parser.index = pos;
         text += "\\textcolor";
@@ -10661,6 +11255,7 @@ function parseTextRun(parser, style) {
       const expr2 = parser.parseExpression() ?? "Nothing";
       parser.skipSpace();
       if (parser.match("<$>")) {
+        flush();
         runs.push(expr2);
       } else {
         text += "$";
@@ -10671,6 +11266,7 @@ function parseTextRun(parser, style) {
       const expr2 = parser.parseExpression() ?? "Nothing";
       parser.skipSpace();
       if (parser.match("<$$>")) {
+        flush();
         runs.push(expr2);
       } else {
         text += "$$";
@@ -11021,14 +11617,20 @@ function matchTextKeyword(parser, keyword) {
   }
   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();
+  for (let i = 0; i < keyword.length; i++) {
+    if (keyword[i] === " ") {
+      if (!parser.match("<space>")) {
+        parser.index = start;
+        return false;
+      }
+      while (parser.match("<space>")) {
+      }
     } else {
-      break;
+      if (parser.peek !== keyword[i]) {
+        parser.index = start;
+        return false;
+      }
+      parser.nextToken();
     }
   }
   while (parser.match("<space>")) {
@@ -11037,10 +11639,6 @@ function matchTextKeyword(parser, keyword) {
     parser.index = start;
     return false;
   }
-  if (text !== keyword) {
-    parser.index = start;
-    return false;
-  }
   return true;
 }
 function matchKeyword(parser, keyword) {
@@ -11208,561 +11806,115 @@ var SYMBOLS2 = [
   ["piSymbol", "\\varpi", 982],
   // GREEK PI SYMBOL
   ["rho", "\\rho", 961],
-  ["rhoSymbol", "\\varrho", 1009],
-  // GREEK RHO SYMBOL
-  ["sigma", "\\sigma", 963],
-  ["finalSigma", "\\varsigma", 962],
-  //GREEK SMALL LETTER FINAL SIGMA
-  ["tau", "\\tau", 964],
-  ["phi", "\\phi", 981],
-  // Note GREEK PHI SYMBOL, but common usage in math
-  ["phiLetter", "\\varphi", 966],
-  ["upsilon", "\\upsilon", 965],
-  ["chi", "\\chi", 967],
-  ["psi", "\\psi", 968],
-  ["omega", "\\omega", 969],
-  ["Alpha", "\\Alpha", 913],
-  ["Beta", "\\Beta", 914],
-  ["Gamma", "\\Gamma", 915],
-  ["Delta", "\\Delta", 916],
-  ["Epsilon", "\\Epsilon", 917],
-  ["Zeta", "\\Zeta", 918],
-  ["Eta", "\\Eta", 919],
-  ["Theta", "\\Theta", 920],
-  ["Iota", "\\Iota", 921],
-  ["Kappa", "\\Kappa", 922],
-  ["Lambda", "\\Lambda", 923],
-  ["Mu", "\\Mu", 924],
-  ["Nu", "\\Nu", 925],
-  ["Xi", "\\Xi", 926],
-  ["Omicron", "\\Omicron", 927],
-  // ['Pi', '\\Pi', 0x03a0],
-  ["Rho", "\\Rho", 929],
-  ["Sigma", "\\Sigma", 931],
-  ["Tau", "\\Tau", 932],
-  ["Phi", "\\Phi", 934],
-  ["Upsilon", "\\Upsilon", 933],
-  ["Chi", "\\Chi", 935],
-  ["Psi", "\\Psi", 936],
-  ["Omega", "\\Omega", 937],
-  ["digamma", "\\digamma", 989],
-  // Hebrew
-  ["aleph", "\\aleph", 8501],
-  // Unicode ALEF SYMBOL
-  ["bet", "\\beth", 8502],
-  ["gimel", "\\gimel", 8503],
-  ["dalet", "\\daleth", 8504],
-  // Letter-like
-  ["ell", "\\ell", 8499],
-  // Unicode SCRIPT SMALL L
-  ["turnedCapitalF", "\\Finv", 8498],
-  // Unicode TURNED CAPITAL F'
-  ["turnedCapitalG", "\\Game", 8513],
-  // TURNED SANS-SERIF CAPITAL G
-  ["weierstrass", "\\wp", 8472],
-  // Unicode SCRIPT CAPITAL P
-  ["eth", "\\eth", 240],
-  ["invertedOhm", "\\mho", 8487],
-  // Unicode INVERTED OHM SIGN
-  ["hBar", "\\hbar", 295],
-  // Unicode LATIN SMALL LETTER H WITH STROKE
-  ["hSlash", "\\hslash", 8463],
-  // Unicode PLANCK CONSTANT OVER TWO PI
-  // Symbols
-  ["blackClubSuit", "\\clubsuit", 9827],
-  ["whiteHeartSuit", "\\heartsuit", 9825],
-  ["blackSpadeSuit", "\\spadesuit", 9824],
-  ["whiteDiamondSuit", "\\diamondsuit", 9826],
-  ["sharp", "\\sharp", 9839],
-  ["flat", "\\flat", 9837],
-  ["natural", "\\natural", 9838]
-];
-var DEFINITIONS_SYMBOLS = [
-  ...SYMBOLS2.map(([symbol2, latex, _codepoint]) => {
-    return {
-      kind: "symbol",
-      name: symbol2,
-      latexTrigger: [latex],
-      parse: symbol2
-    };
-  }),
-  ...SYMBOLS2.map(([symbol2, _latex, codepoint]) => {
-    return {
-      kind: "symbol",
-      latexTrigger: [String.fromCodePoint(codepoint)],
-      parse: symbol2
-    };
-  })
-];
-
-// src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
-var DEFINITIONS_ALGEBRA = [
-  {
-    name: "To",
-    latexTrigger: ["\\to"],
-    kind: "infix",
-    precedence: 270
-    // MathML rightwards arrow
-  },
-  {
-    // Non-strict mode: -> for maps-to arrow
-    latexTrigger: ["-", ">"],
-    kind: "infix",
-    precedence: 270,
-    parse: (parser, lhs, until) => {
-      if (parser.options.strict !== false) return null;
-      const rhs = parser.parseExpression({ ...until, minPrec: 270 });
-      if (rhs === null) return null;
-      return ["To", lhs, rhs];
-    }
-  }
-];
-
-// src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
-var DEFINITIONS_LOGIC = [
-  // Constants
-  {
-    name: "True",
-    kind: "symbol",
-    latexTrigger: ["\\top"]
-    // ⊤ U+22A4
-  },
-  {
-    kind: "symbol",
-    latexTrigger: "\\mathrm{True}",
-    parse: "True"
-  },
-  {
-    kind: "symbol",
-    latexTrigger: "\\operatorname{True}",
-    parse: "True"
-  },
-  {
-    kind: "symbol",
-    latexTrigger: "\\mathsf{T}",
-    parse: "True"
-  },
-  {
-    name: "False",
-    kind: "symbol",
-    latexTrigger: ["\\bot"]
-    // ⊥ U+22A5
-  },
-  {
-    kind: "symbol",
-    latexTrigger: "\\operatorname{False}",
-    parse: "False"
-  },
-  {
-    kind: "symbol",
-    latexTrigger: "\\mathsf{F}",
-    parse: "False"
-  },
-  // Operators
-  // Logic operators have lower precedence than comparisons (245)
-  // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
-  // See https://github.com/cortex-js/compute-engine/issues/243
-  {
-    name: "And",
-    kind: "infix",
-    latexTrigger: ["\\land"],
-    precedence: 235
-    // serialize: '\\land',
-  },
-  { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
-  { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
-  {
-    kind: "infix",
-    latexTrigger: "\\operatorname{and}",
-    parse: "And",
-    precedence: 235
-  },
-  {
-    name: "Or",
-    kind: "infix",
-    latexTrigger: ["\\lor"],
-    precedence: 230
-  },
-  { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
-  { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
-  {
-    kind: "infix",
-    latexTrigger: "\\operatorname{or}",
-    parse: "Or",
-    precedence: 230
-  },
-  {
-    name: "Xor",
-    kind: "infix",
-    latexTrigger: ["\\veebar"],
-    precedence: 232
-  },
-  // Possible alt: \oplus ⊕ U+2295
-  {
-    name: "Not",
-    kind: "prefix",
-    latexTrigger: ["\\lnot"],
-    precedence: 880
-  },
-  {
-    kind: "prefix",
-    latexTrigger: ["\\neg"],
-    parse: "Not",
-    precedence: 880
-  },
-  {
-    name: "Nand",
-    kind: "infix",
-    latexTrigger: ["\\barwedge"],
-    precedence: 232
-    // serialize: '\\mid',
-  },
-  {
-    name: "Nor",
-    kind: "infix",
-    latexTrigger: ["\u22BD"],
-    // bar vee
-    precedence: 232
-    // serialize: '\\downarrow',
-  },
-  // Functions
-  {
-    kind: "function",
-    symbolTrigger: "and",
-    parse: "And"
-  },
-  {
-    kind: "function",
-    symbolTrigger: "or",
-    parse: "Or"
-  },
-  {
-    kind: "function",
-    symbolTrigger: "not",
-    parse: "Not"
-  },
-  // Relations
-  {
-    name: "Implies",
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    latexTrigger: ["\\implies"],
-    serialize: "\\implies"
-  },
-  {
-    latexTrigger: ["\\Rightarrow"],
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    parse: "Implies"
-  },
-  {
-    latexTrigger: ["\\rightarrow"],
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    parse: "Implies"
-  },
-  {
-    latexTrigger: ["\\Longrightarrow"],
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    parse: "Implies"
-  },
-  {
-    latexTrigger: ["\\longrightarrow"],
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    parse: "Implies"
-  },
-  {
-    // Non-strict mode: => for implies
-    latexTrigger: ["=", ">"],
-    kind: "infix",
-    precedence: 220,
-    associativity: "right",
-    parse: (parser, lhs, until) => {
-      if (parser.options.strict !== false) return null;
-      const rhs = parser.parseExpression({ ...until, minPrec: 220 });
-      if (rhs === null) return null;
-      return ["Implies", lhs, rhs];
-    }
-  },
-  {
-    name: "Equivalent",
-    // MathML: identical to, Mathematica: Congruent
-    latexTrigger: ["\\iff"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 219
-  },
-  {
-    latexTrigger: ["\\Leftrightarrow"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 219,
-    parse: "Equivalent"
-  },
-  {
-    latexTrigger: ["\\leftrightarrow"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 219,
-    parse: "Equivalent"
-  },
-  {
-    latexTrigger: ["\\Longleftrightarrow"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 219,
-    parse: "Equivalent"
-  },
+  ["rhoSymbol", "\\varrho", 1009],
+  // GREEK RHO SYMBOL
+  ["sigma", "\\sigma", 963],
+  ["finalSigma", "\\varsigma", 962],
+  //GREEK SMALL LETTER FINAL SIGMA
+  ["tau", "\\tau", 964],
+  ["phi", "\\phi", 981],
+  // Note GREEK PHI SYMBOL, but common usage in math
+  ["phiLetter", "\\varphi", 966],
+  ["upsilon", "\\upsilon", 965],
+  ["chi", "\\chi", 967],
+  ["psi", "\\psi", 968],
+  ["omega", "\\omega", 969],
+  ["Alpha", "\\Alpha", 913],
+  ["Beta", "\\Beta", 914],
+  ["Gamma", "\\Gamma", 915],
+  ["Delta", "\\Delta", 916],
+  ["Epsilon", "\\Epsilon", 917],
+  ["Zeta", "\\Zeta", 918],
+  ["Eta", "\\Eta", 919],
+  ["Theta", "\\Theta", 920],
+  ["Iota", "\\Iota", 921],
+  ["Kappa", "\\Kappa", 922],
+  ["Lambda", "\\Lambda", 923],
+  ["Mu", "\\Mu", 924],
+  ["Nu", "\\Nu", 925],
+  ["Xi", "\\Xi", 926],
+  ["Omicron", "\\Omicron", 927],
+  // ['Pi', '\\Pi', 0x03a0],
+  ["Rho", "\\Rho", 929],
+  ["Sigma", "\\Sigma", 931],
+  ["Tau", "\\Tau", 932],
+  ["Phi", "\\Phi", 934],
+  ["Upsilon", "\\Upsilon", 933],
+  ["Chi", "\\Chi", 935],
+  ["Psi", "\\Psi", 936],
+  ["Omega", "\\Omega", 937],
+  ["digamma", "\\digamma", 989],
+  // Hebrew
+  ["aleph", "\\aleph", 8501],
+  // Unicode ALEF SYMBOL
+  ["bet", "\\beth", 8502],
+  ["gimel", "\\gimel", 8503],
+  ["dalet", "\\daleth", 8504],
+  // Letter-like
+  ["ell", "\\ell", 8499],
+  // Unicode SCRIPT SMALL L
+  ["turnedCapitalF", "\\Finv", 8498],
+  // Unicode TURNED CAPITAL F'
+  ["turnedCapitalG", "\\Game", 8513],
+  // TURNED SANS-SERIF CAPITAL G
+  ["weierstrass", "\\wp", 8472],
+  // Unicode SCRIPT CAPITAL P
+  ["eth", "\\eth", 240],
+  ["invertedOhm", "\\mho", 8487],
+  // Unicode INVERTED OHM SIGN
+  ["hBar", "\\hbar", 295],
+  // Unicode LATIN SMALL LETTER H WITH STROKE
+  ["hSlash", "\\hslash", 8463],
+  // Unicode PLANCK CONSTANT OVER TWO PI
+  // Symbols
+  ["blackClubSuit", "\\clubsuit", 9827],
+  ["whiteHeartSuit", "\\heartsuit", 9825],
+  ["blackSpadeSuit", "\\spadesuit", 9824],
+  ["whiteDiamondSuit", "\\diamondsuit", 9826],
+  ["sharp", "\\sharp", 9839],
+  ["flat", "\\flat", 9837],
+  ["natural", "\\natural", 9838]
+];
+var DEFINITIONS_SYMBOLS = [
+  ...SYMBOLS2.map(([symbol2, latex, _codepoint]) => {
+    return {
+      kind: "symbol",
+      name: symbol2,
+      latexTrigger: [latex],
+      parse: symbol2
+    };
+  }),
+  ...SYMBOLS2.map(([symbol2, _latex, codepoint]) => {
+    return {
+      kind: "symbol",
+      latexTrigger: [String.fromCodePoint(codepoint)],
+      parse: symbol2
+    };
+  })
+];
+
+// src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
+var DEFINITIONS_ALGEBRA = [
   {
-    latexTrigger: ["\\longleftrightarrow"],
+    name: "To",
+    latexTrigger: ["\\to"],
     kind: "infix",
-    associativity: "right",
-    precedence: 219,
-    parse: "Equivalent"
+    precedence: 270
+    // MathML rightwards arrow
   },
   {
-    // Non-strict mode: <=> for equivalence
-    latexTrigger: ["<", "=", ">"],
+    // Non-strict mode: -> for maps-to arrow
+    latexTrigger: ["-", ">"],
     kind: "infix",
-    precedence: 219,
-    associativity: "right",
+    precedence: 270,
     parse: (parser, lhs, until) => {
       if (parser.options.strict !== false) return null;
-      const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+      const rhs = parser.parseExpression({ ...until, minPrec: 270 });
       if (rhs === null) return null;
-      return ["Equivalent", lhs, rhs];
-    }
-  },
-  {
-    latexTrigger: ["\\equiv"],
-    kind: "infix",
-    associativity: "right",
-    precedence: 219,
-    parse: (parser, lhs, terminator) => {
-      const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
-      const index = parser.index;
-      const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
-      if (modulus !== null && operator(modulus) === "Mod")
-        return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
-      parser.index = index;
-      return ["Equivalent", lhs, missingIfEmpty(rhs)];
-    }
-  },
-  {
-    name: "Proves",
-    kind: "infix",
-    latexTrigger: ["\\vdash"],
-    precedence: 220,
-    associativity: "right",
-    serialize: "\\vdash"
-  },
-  {
-    name: "Entails",
-    kind: "infix",
-    latexTrigger: ["\\vDash"],
-    precedence: 220,
-    associativity: "right",
-    serialize: "\\vDash"
-  },
-  {
-    name: "Satisfies",
-    kind: "infix",
-    latexTrigger: ["\\models"],
-    precedence: 220,
-    associativity: "right",
-    serialize: "\\models"
-  },
-  // Quantifiers: for all, exists
-  {
-    name: "ForAll",
-    kind: "prefix",
-    latexTrigger: ["\\forall"],
-    precedence: 200,
-    // Has to be lower than COMPARISON_PRECEDENCE
-    serialize: serializeQuantifier("\\forall"),
-    parse: parseQuantifier("ForAll")
-  },
-  {
-    name: "Exists",
-    kind: "prefix",
-    latexTrigger: ["\\exists"],
-    precedence: 200,
-    // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: serializeQuantifier("\\exists"),
-    parse: parseQuantifier("Exists")
-  },
-  {
-    name: "ExistsUnique",
-    kind: "prefix",
-    latexTrigger: ["\\exists", "!"],
-    precedence: 200,
-    // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: serializeQuantifier("\\exists!"),
-    parse: parseQuantifier("ExistsUnique")
-  },
-  {
-    name: "NotForAll",
-    kind: "prefix",
-    latexTrigger: ["\\lnot", "\\forall"],
-    precedence: 200,
-    // Has to be lower than COMPARISON_PRECEDENCE
-    serialize: serializeQuantifier("\\lnot\\forall"),
-    parse: parseQuantifier("NotForAll")
-  },
-  {
-    name: "NotExists",
-    kind: "prefix",
-    latexTrigger: ["\\lnot", "\\exists"],
-    precedence: 200,
-    // Has to be lower than COMPARISON_PRECEDENCE,
-    serialize: serializeQuantifier("\\lnot\\exists"),
-    parse: parseQuantifier("NotExists")
-  },
-  {
-    name: "KroneckerDelta",
-    kind: "prefix",
-    latexTrigger: ["\\delta", "_"],
-    precedence: 200,
-    serialize: (serializer, expr2) => {
-      const args = operands(expr2);
-      if (args.length === 0) return "\\delta";
-      if (args.every((x) => symbol(x)))
-        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
-      return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
-    },
-    parse: (parser) => {
-      const group = parser.parseGroup();
-      if (group === null) {
-        const token = parser.parseToken();
-        if (!token) return null;
-        return ["KroneckerDelta", token];
-      }
-      const seq = getSequence(group);
-      if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
-      if (operator(group) === "InvisibleOperator")
-        return ["KroneckerDelta", ...operands(group)];
-      if (group !== null) return ["KroneckerDelta", group];
-      return null;
-    }
-  },
-  // Iverson brackets. Also called the "indicator function"
-  // Must have a single argument, a relational expression, i.e.
-  // `[ a = b ]` or `[ x \leq 0 ]`
-  // Otherwise, it gets rejected, it could be something else, like a list or
-  // tuple.
-  {
-    name: "Boole",
-    kind: "matchfix",
-    openTrigger: "[",
-    closeTrigger: "]",
-    // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
-    //   const args = ops(expr);
-    //   return `[${serializer.serialize(arg)}]`;
-    // },
-    parse: (_parser, body) => {
-      const h = operator(body);
-      if (!h) return null;
-      if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-      return ["Boole", body];
-    }
-  },
-  {
-    kind: "matchfix",
-    openTrigger: "\\llbracket",
-    closeTrigger: "\\rrbracket",
-    parse: (_parser, body) => {
-      const h = operator(body);
-      if (!h) return null;
-      if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-      return ["Boole", body];
-    }
-  },
-  // Predicate application in First-Order Logic.
-  // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
-  {
-    name: "Predicate",
-    serialize: (serializer, expr2) => {
-      const args = operands(expr2);
-      if (args.length === 0) return "";
-      const pred = args[0];
-      const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
-      if (args.length === 1) return predStr;
-      const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
-      return `${predStr}(${argStrs.join(", ")})`;
+      return ["To", lhs, rhs];
     }
   }
 ];
-function serializeQuantifier(quantifierSymbol) {
-  return (serializer, expr2) => {
-    const args = operands(expr2);
-    if (args.length === 0) return quantifierSymbol;
-    if (args.length === 1)
-      return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
-    const boundVar = serializer.serialize(args[0]);
-    const body = serializer.serialize(args[1]);
-    return `${quantifierSymbol} ${boundVar}, ${body}`;
-  };
-}
-function tightBindingCondition(p, terminator) {
-  return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
-}
-function parseQuantifier(kind) {
-  return (parser, terminator) => {
-    const index = parser.index;
-    const useTightBinding = parser.options.quantifierScope !== "loose";
-    const symbol2 = parser.parseSymbol(terminator);
-    if (symbol2) {
-      parser.skipSpace();
-      if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-        const bodyTerminator = useTightBinding ? {
-          ...terminator,
-          condition: (p) => tightBindingCondition(p, terminator)
-        } : terminator;
-        parser.enterQuantifierScope();
-        const body2 = parser.parseExpression(bodyTerminator);
-        parser.exitQuantifierScope();
-        return [kind, symbol2, missingIfEmpty(body2)];
-      }
-      parser.enterQuantifierScope();
-      const body = parser.parseEnclosure();
-      parser.exitQuantifierScope();
-      if (body) return [kind, symbol2, missingIfEmpty(body)];
-    }
-    parser.index = index;
-    const condTerminator = {
-      ...terminator,
-      condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
-    };
-    const condition = parser.parseExpression(condTerminator);
-    if (condition === null) return null;
-    parser.skipSpace();
-    if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
-      const bodyTerminator = useTightBinding ? {
-        ...terminator,
-        condition: (p) => tightBindingCondition(p, terminator)
-      } : terminator;
-      parser.enterQuantifierScope();
-      const body = parser.parseExpression(bodyTerminator);
-      parser.exitQuantifierScope();
-      return [kind, condition, missingIfEmpty(body)];
-    }
-    if (parser.match("(")) {
-      parser.enterQuantifierScope();
-      const body = parser.parseExpression(terminator);
-      parser.exitQuantifierScope();
-      if (!parser.match(")")) return null;
-      return [kind, condition, missingIfEmpty(body)];
-    }
-    return null;
-  };
-}
 
 // src/compute-engine/latex-syntax/dictionary/definitions-sets.ts
 function parseIntervalBody(body, openLeft, openRight) {
@@ -16268,7 +16420,7 @@ var ZWJ2 = "\\u{200D}";
 var FLAG_SEQUENCE = "\\p{RI}\\p{RI}";
 var TAG_MOD = `(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})`;
 var EMOJI_MOD = `(?:\\p{EMod}|${VS16}${KEYCAP}?|${TAG_MOD})`;
-var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})\\p{Emoji})`;
+var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})(?=[^\\x23\\x2a\\x30-\\x39])\\p{Emoji})`;
 var ZWJ_ELEMENT = `(?:${EMOJI_NOT_SYMBOL}${EMOJI_MOD}*|\\p{Emoji}${EMOJI_MOD}+|${FLAG_SEQUENCE})`;
 var POSSIBLE_EMOJI = `(?:${ZWJ_ELEMENT})(${ZWJ2}${ZWJ_ELEMENT})*`;
 var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
@@ -16977,7 +17129,9 @@ function parseSymbolToken(parser, options) {
     }
     return c;
   }
-  return parser.nextToken();
+  const raw = parser.peek;
+  if (raw && /^[\p{XIDC}\p{M}]/u.test(raw)) return parser.nextToken();
+  return null;
 }
 function parseSymbolBody(parser) {
   let id = matchPrefixedSymbol(parser);
@@ -18267,6 +18421,29 @@ var _Parser = class __Parser {
     this.index = start;
     return null;
   }
+  /**
+   * Speculatively check if any \text infix entry (e.g. "and", "or", "where")
+   * would match the upcoming tokens. This is used to prevent InvisibleOperator
+   * from consuming \text{keyword} as a text run when the keyword is actually
+   * an infix operator that was skipped due to precedence constraints.
+   *
+   * Returns true if any entry's parse function would succeed (non-null result).
+   * The parser index is always restored to its original position.
+   */
+  wouldMatchTextInfix(opDefs) {
+    const start = this.index;
+    for (const [def, n] of opDefs) {
+      if (def.kind !== "infix") continue;
+      this.index = start + n;
+      const result = def.parse(this, "Nothing", { minPrec: 0 });
+      if (result !== null) {
+        this.index = start;
+        return true;
+      }
+    }
+    this.index = start;
+    return false;
+  }
   /**
    * This returns an array of arguments (as in a function application),
    * or null if there is no match.
@@ -18892,6 +19069,7 @@ var _Parser = class __Parser {
     if (isDelimiterCommand(this))
       return this.error("unexpected-delimiter", start);
     if (command[0] !== "\\") {
+      this.nextToken();
       return this.error(
         ["unexpected-token", { str: tokensToString(command) }],
         start
@@ -19020,25 +19198,28 @@ var _Parser = class __Parser {
         if (result === null && until.minPrec <= INVISIBLE_OP_PRECEDENCE) {
           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
-            });
-            if (rhs !== null) {
-              if (operator(lhs) === "InvisibleOperator") {
-                if (operator(rhs) === "InvisibleOperator")
-                  result = [
-                    "InvisibleOperator",
-                    ...operands(lhs),
-                    ...operands(rhs)
-                  ];
-                else result = ["InvisibleOperator", ...operands(lhs), rhs];
-              } else if (operator(rhs) === "InvisibleOperator") {
-                result = ["InvisibleOperator", lhs, ...operands(rhs)];
-              } else result = ["InvisibleOperator", lhs, rhs];
+            if (opDefs.length > 0 && this.wouldMatchTextInfix(opDefs)) {
             } else {
-              if (result === null) {
-                result = this.options.parseUnexpectedToken?.(lhs, this) ?? null;
+              const rhs = this.parseExpression({
+                ...until,
+                minPrec: INVISIBLE_OP_PRECEDENCE + 1
+              });
+              if (rhs !== null) {
+                if (operator(lhs) === "InvisibleOperator") {
+                  if (operator(rhs) === "InvisibleOperator")
+                    result = [
+                      "InvisibleOperator",
+                      ...operands(lhs),
+                      ...operands(rhs)
+                    ];
+                  else result = ["InvisibleOperator", ...operands(lhs), rhs];
+                } else if (operator(rhs) === "InvisibleOperator") {
+                  result = ["InvisibleOperator", lhs, ...operands(rhs)];
+                } else result = ["InvisibleOperator", lhs, rhs];
+              } else {
+                if (result === null) {
+                  result = this.options.parseUnexpectedToken?.(lhs, this) ?? null;
+                }
               }
             }
           }
@@ -30503,8 +30684,7 @@ var ARITHMETIC_LIBRARY = [
       broadcastable: true,
       idempotent: true,
       complexity: 1200,
-      signature: "(number) -> number",
-      type: ([x]) => x.type,
+      signature: "(number) -> real",
       sgn: ([x]) => {
         if (x.isSame(0)) return "zero";
         if (isNumber(x)) return "positive";
@@ -37863,6 +38043,10 @@ var CALCULUS_LIBRARY = [
       scoped: true,
       lazy: true,
       signature: "(expression, variable:symbol, variables:symbol+) -> expression",
+      type: ([body]) => {
+        if (body && body.type.matches("number")) return body.type;
+        return void 0;
+      },
       canonical: (ops, { engine: ce, scope }) => {
         if (isSymbol2(ops[0]) && ops[0].canonical.operatorDefinition) {
           const vars = ops.slice(1);
@@ -42434,6 +42618,18 @@ function canonicalInvisibleOperator(ops, { engine: ce }) {
     }
   }
   ops = flattenInvisibleOperator(ops);
+  if (ops.some((op) => isFunction2(op, "Text") || isString(op))) {
+    const runs = [];
+    for (const op of ops) {
+      if (isFunction2(op, "Text")) {
+        runs.push(...op.ops);
+      } else if (op.operator !== "HorizontalSpacing") {
+        runs.push(op.canonical);
+      }
+    }
+    return ce._fn("Text", runs);
+  }
+  ops = combineFunctionApplications(ce, ops);
   {
     const significant = ops.filter((x) => x.operator !== "HorizontalSpacing");
     if (significant.length === 2) {
@@ -42448,7 +42644,7 @@ function canonicalInvisibleOperator(ops, { engine: ce }) {
   }
   ops = flatten(ops);
   if (ops.every(
-    (x) => x.isValid && (x.type.isUnknown || x.type.matches("number") || x.isIndexedCollection && !isString(x))
+    (x) => x.isValid && (x.type.isUnknown || x.type.type === "any" || x.type.type === "expression" || x.type.matches("number") || x.isIndexedCollection && !isString(x))
   )) {
     return ce._fn("Multiply", ops);
   }
@@ -42463,6 +42659,40 @@ function flattenInvisibleOperator(ops) {
   }
   return ys;
 }
+function combineFunctionApplications(ce, ops) {
+  const result = [];
+  let i = 0;
+  while (i < ops.length) {
+    const op = ops[i];
+    if (i < ops.length - 1 && isSymbol2(op) && isFunction2(ops[i + 1], "Delimiter")) {
+      const symName = op.symbol;
+      const def = ce.lookupDefinition(symName);
+      const delim = ops[i + 1];
+      if (def && (isOperatorDef(def) || def.value?.type?.matches("function"))) {
+        let args = delim.op1 ? isFunction2(delim.op1, "Sequence") ? delim.op1.ops : [delim.op1] : [];
+        args = flatten(args);
+        result.push(ce.function(symName, args));
+        i += 2;
+        continue;
+      }
+      if (delim.op1 && isFunction2(delim.op1, "Sequence")) {
+        let args = delim.op1.ops;
+        args = flatten(args);
+        if (args.length > 1) {
+          if (!def) ce.declare(symName, "function");
+          else if (!isOperatorDef(def) && def.value?.type?.isUnknown)
+            op.canonical.infer("function");
+          result.push(ce.function(symName, args));
+          i += 2;
+          continue;
+        }
+      }
+    }
+    result.push(ops[i]);
+    i++;
+  }
+  return result;
+}
 function asInteger(expr2) {
   if (isNumber(expr2)) {
     const n = expr2.re;
@@ -43466,7 +43696,21 @@ var CORE_LIBRARY = [
     },
     Text: {
       description: "A sequence of strings, annotated expressions and other Text expressions",
-      signature: "(any*) -> expression"
+      signature: "(any*) -> string",
+      evaluate: (ops, { engine: ce }) => {
+        if (ops.length === 0) return ce.string("");
+        const parts = [];
+        for (const op of ops) {
+          const unwrapped = op.operator === "Annotated" ? op.op1 : op;
+          if (isString(unwrapped)) parts.push(unwrapped.string);
+          else {
+            const evaluated = unwrapped.evaluate();
+            if (isString(evaluated)) parts.push(evaluated.string);
+            else parts.push(evaluated.toString());
+          }
+        }
+        return ce.string(parts.join(""));
+      }
     }
   },
   {
@@ -43561,7 +43805,16 @@ var CORE_LIBRARY = [
         if (!isSymbol2(symbol2)) {
           symbol2 = checkType(ce, lhs, "symbol");
         }
-        return ce._fn("Assign", [symbol2, args[1].canonical]);
+        const canonRhs = args[1].canonical;
+        const result = ce._fn("Assign", [symbol2, canonRhs]);
+        const symbolName2 = sym(symbol2);
+        if (symbolName2 && isFunction2(canonRhs, "Function")) {
+          if (!ce.lookupDefinition(symbolName2)) ce.symbol(symbolName2);
+          const def = ce.lookupDefinition(symbolName2);
+          if (def && isValueDef(def) && def.value.inferredType)
+            def.value.type = ce.type("function");
+        }
+        return result;
       },
       evaluate: ([op1, op2], { engine: ce }) => {
         if (isFunction2(op1, "Subscript") && sym(op1.op1)) {
@@ -43758,6 +44011,7 @@ var CORE_LIBRARY = [
       description: "Simplify an expression.",
       lazy: true,
       signature: "(any) -> expression",
+      type: ([x]) => x?.type ?? void 0,
       canonical: (ops, { engine: ce }) => ce._fn("Simplify", checkArity(ce, ops, 1)),
       evaluate: ([x]) => x.simplify() ?? void 0
     },
@@ -53981,8 +54235,11 @@ var BaseCompiler = class _BaseCompiler {
       for (const local of locals) {
         for (const arg of args) {
           if (isFunction2(arg, "Assign") && isSymbol2(arg.ops[0], local)) {
-            if (_BaseCompiler.isComplexValued(arg.ops[1])) {
+            const rhs = arg.ops[1];
+            if (_BaseCompiler.isComplexValued(rhs)) {
               typeHints[local] = isWGSL ? "vec2f" : "vec2";
+            } else if (_BaseCompiler.isIntegerValued(rhs)) {
+              typeHints[local] = isWGSL ? "i32" : "int";
             }
             break;
           }
@@ -54187,12 +54444,9 @@ var BaseCompiler = class _BaseCompiler {
   /**
    * Determine at compile time whether an expression produces a complex value.
    *
-   * Rules:
-   * - Numbers: complex if im !== 0
-   * - Symbols: ImaginaryUnit is complex; others use expr.isReal
-   *   (undefined is treated as real -- assume-real policy)
-   * - Functions: Abs, Arg, Re, Im always return real.
-   *   All others: complex if any operand is complex.
+   * Uses the expression's declared type (from operator signatures) when
+   * available. Falls back to operand inspection for functions whose
+   * return type is unknown.
    */
   static isComplexValued(expr2) {
     if (isNumber(expr2)) return expr2.im !== 0;
@@ -54203,13 +54457,24 @@ var BaseCompiler = class _BaseCompiler {
       return t.matches("complex") && !t.matches("real");
     }
     if (isFunction2(expr2)) {
-      const op = expr2.operator;
-      if (op === "Abs" || op === "Arg" || op === "Re" || op === "Im")
-        return false;
+      const t = expr2.type;
+      if (t.matches("complex") && !t.matches("real")) return true;
+      if (t.matches("real")) return false;
       return expr2.ops.some((arg) => _BaseCompiler.isComplexValued(arg));
     }
     return false;
   }
+  /** True if the expression is provably integer-typed. */
+  static isIntegerValued(expr2) {
+    if (isNumber(expr2)) return expr2.im === 0 && Number.isInteger(expr2.re);
+    const t = expr2.type;
+    return t ? t.matches("integer") : false;
+  }
+  /** True if the expression is provably non-negative (sign ≥ 0). */
+  static isNonNegative(expr2) {
+    if (isNumber(expr2)) return expr2.im === 0 && expr2.re >= 0;
+    return expr2.isNonNegative === true;
+  }
   /**
    * Generate a temporary variable name
    */
@@ -54463,14 +54728,27 @@ function compile(expr2, options) {
   } catch (e) {
     if (options?.fallback ?? true) {
       console.warn(
-        `Compilation fallback for "${expr2.operator}": ${e.message}`
+        `Compilation fallback for "${expr2.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
       );
+      const ce = expr2.engine;
+      const fallbackRun = ((vars) => {
+        ce.pushScope();
+        try {
+          if (vars && typeof vars === "object") {
+            for (const [k, v] of Object.entries(vars))
+              ce.assign(k, v);
+          }
+          return expr2.evaluate().re;
+        } finally {
+          ce.popScope();
+        }
+      });
       return {
         target: options?.to ?? "javascript",
         success: false,
         code: "",
         calling: "expression",
-        run: applicableN1(expr2)
+        run: fallbackRun
       };
     }
     throw e;
@@ -59620,6 +59898,86 @@ function resetCommonSymbols(commonSymbols) {
   for (const symbol2 of Object.values(commonSymbols)) symbol2?.reset();
 }
 
+// src/compute-engine/compilation/constant-folding.ts
+function formatFloat(n) {
+  const str = n.toString();
+  if (!str.includes(".") && !str.includes("e") && !str.includes("E")) {
+    return `${str}.0`;
+  }
+  return str;
+}
+function tryGetConstant(expr2) {
+  if (!isNumber(expr2)) return void 0;
+  if (expr2.im !== 0) return void 0;
+  const re = expr2.re;
+  if (!isFinite(re)) return void 0;
+  return re;
+}
+var NUMERIC_LITERAL_RE = /^-?\d+(\.\d+)?$/;
+function foldTerms(terms, identity, op) {
+  const identityValue = op === "+" ? 0 : 1;
+  let numericAcc = null;
+  const symbolic = [];
+  for (const term of terms) {
+    if (NUMERIC_LITERAL_RE.test(term)) {
+      const val = parseFloat(term);
+      if (op === "*" && val === 0) return "0.0";
+      if (numericAcc === null) {
+        numericAcc = val;
+      } else {
+        numericAcc = op === "+" ? numericAcc + val : numericAcc * val;
+      }
+    } else {
+      symbolic.push(term);
+    }
+  }
+  if (numericAcc !== null && numericAcc !== identityValue) {
+    symbolic.unshift(formatFloat(numericAcc));
+  }
+  if (symbolic.length === 0) {
+    if (numericAcc !== null) return formatFloat(numericAcc);
+    return identity;
+  }
+  if (symbolic.length === 1) return symbolic[0];
+  return symbolic.join(op === "+" ? " + " : " * ");
+}
+function tryGetComplexParts(expr2, compile3) {
+  if (isSymbol2(expr2, "ImaginaryUnit")) {
+    return { re: null, im: "1.0" };
+  }
+  if (isNumber(expr2) && expr2.im !== 0) {
+    const re = expr2.re;
+    const im = expr2.im;
+    return {
+      re: re !== 0 ? formatFloat(re) : null,
+      im: formatFloat(im)
+    };
+  }
+  if (isFunction2(expr2, "Multiply")) {
+    const ops = expr2.ops;
+    const iIndex = ops.findIndex(
+      (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+    );
+    if (iIndex >= 0) {
+      const iFactor = ops[iIndex];
+      const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+      const remaining = ops.filter((_, idx) => idx !== iIndex);
+      if (remaining.length === 0) {
+        return { re: null, im: formatFloat(iScale) };
+      }
+      const compiledFactors = remaining.map((r) => compile3(r));
+      if (iScale !== 1)
+        compiledFactors.unshift(formatFloat(iScale));
+      const imCode = foldTerms(compiledFactors, "1.0", "*");
+      return { re: null, im: imCode };
+    }
+  }
+  if (BaseCompiler.isComplexValued(expr2)) {
+    return null;
+  }
+  return { re: compile3(expr2), im: null };
+}
+
 // src/compute-engine/compilation/javascript-target.ts
 var JAVASCRIPT_OPERATORS = {
   Add: ["+", 11],
@@ -59643,12 +60001,21 @@ var JAVASCRIPT_FUNCTIONS = {
   Abs: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.cabs(${compile3(args[0])})`;
+    if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
     return `Math.abs(${compile3(args[0])})`;
   },
   Add: (args, compile3) => {
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return `(${args.map((x) => compile3(x)).join(" + ")})`;
+    if (!anyComplex) {
+      const constants = args.map(tryGetConstant);
+      if (constants.every((c) => c !== void 0))
+        return String(constants.reduce((a, b) => a + b, 0));
+      const nonZero = args.filter((a) => tryGetConstant(a) !== 0);
+      if (nonZero.length === 0) return "0";
+      if (nonZero.length === 1) return compile3(nonZero[0]);
+      return `(${nonZero.map((x) => compile3(x)).join(" + ")})`;
+    }
     const parts = args.map((a) => {
       const code = compile3(a);
       return { code, isComplex: BaseCompiler.isComplexValued(a) };
@@ -59705,7 +60072,10 @@ var JAVASCRIPT_FUNCTIONS = {
     return `Math.atan(${compile3(args[0])})`;
   },
   Artanh: "Math.atanh",
-  Ceil: "Math.ceil",
+  Ceil: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.ceil(${compile3(args[0])})`;
+  },
   Chop: "_SYS.chop",
   Cos: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -59748,7 +60118,10 @@ var JAVASCRIPT_FUNCTIONS = {
       return `_SYS.cexp(${compile3(args[0])})`;
     return `Math.exp(${compile3(args[0])})`;
   },
-  Floor: "Math.floor",
+  Floor: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.floor(${compile3(args[0])})`;
+  },
   Fract: ([x], compile3) => {
     if (x === null) throw new Error("Fract: no argument");
     return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile3(x));
@@ -59844,12 +60217,20 @@ var JAVASCRIPT_FUNCTIONS = {
     if (BaseCompiler.isComplexValued(base) || BaseCompiler.isComplexValued(exp3)) {
       return `_SYS.cpow(${compile3(base)}, ${compile3(exp3)})`;
     }
-    const expVal = exp3.re;
-    if (expVal === 0.5) return `Math.sqrt(${compile3(base)})`;
-    if (expVal === 1 / 3) return `Math.cbrt(${compile3(base)})`;
-    if (expVal === 1) return compile3(base);
-    if (expVal === -1) return `(1 / (${compile3(base)}))`;
-    if (expVal === -0.5) return `(1 / Math.sqrt(${compile3(base)}))`;
+    const bConst = tryGetConstant(base);
+    const eConst = tryGetConstant(exp3);
+    if (bConst !== void 0 && eConst !== void 0)
+      return String(Math.pow(bConst, eConst));
+    if (eConst === 0) return "1";
+    if (eConst === 1) return compile3(base);
+    if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+      const code = compile3(base);
+      return `(${code} * ${code})`;
+    }
+    if (eConst === -1) return `(1 / (${compile3(base)}))`;
+    if (eConst === 0.5) return `Math.sqrt(${compile3(base)})`;
+    if (eConst === 1 / 3) return `Math.cbrt(${compile3(base)})`;
+    if (eConst === -0.5) return `(1 / Math.sqrt(${compile3(base)}))`;
     return `Math.pow(${compile3(base)}, ${compile3(exp3)})`;
   },
   Range: (args, compile3) => {
@@ -59886,16 +60267,29 @@ var JAVASCRIPT_FUNCTIONS = {
   Root: ([arg, exp3], compile3) => {
     if (arg === null) throw new Error("Root: no argument");
     if (exp3 === null) return `Math.sqrt(${compile3(arg)})`;
-    if (exp3?.re === 2) return `Math.sqrt(${compile3(arg)})`;
-    if (exp3?.re === 3) return `Math.cbrt(${compile3(arg)})`;
-    if (!isNaN(exp3?.re)) return `Math.pow(${compile3(arg)},  ${1 / exp3.re})`;
+    const aConst = tryGetConstant(arg);
+    const nConst = tryGetConstant(exp3);
+    if (aConst !== void 0 && nConst !== void 0 && nConst !== 0)
+      return String(Math.pow(aConst, 1 / nConst));
+    if (nConst === 2) return `Math.sqrt(${compile3(arg)})`;
+    if (nConst === 3) return `Math.cbrt(${compile3(arg)})`;
+    if (nConst !== void 0) return `Math.pow(${compile3(arg)}, ${1 / nConst})`;
     return `Math.pow(${compile3(arg)}, 1 / (${compile3(exp3)}))`;
   },
   Random: "Math.random",
-  Round: "Math.round",
+  Round: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.round(${compile3(args[0])})`;
+  },
   Square: (args, compile3) => {
     const arg = args[0];
     if (arg === null) throw new Error("Square: no argument");
+    const c = tryGetConstant(arg);
+    if (c !== void 0) return String(c * c);
+    if (isSymbol2(arg)) {
+      const code = compile3(arg);
+      return `(${code} * ${code})`;
+    }
     return `Math.pow(${compile3(arg)}, 2)`;
   },
   Sec: (args, compile3) => {
@@ -59928,6 +60322,8 @@ var JAVASCRIPT_FUNCTIONS = {
   Sqrt: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.csqrt(${compile3(args[0])})`;
+    const c = tryGetConstant(args[0]);
+    if (c !== void 0) return String(Math.sqrt(c));
     return `Math.sqrt(${compile3(args[0])})`;
   },
   Tan: (args, compile3) => {
@@ -59944,9 +60340,14 @@ var JAVASCRIPT_FUNCTIONS = {
     if (a === null || b === null) throw new Error("Mod: missing argument");
     const ca = compile3(a);
     const cb = compile3(b);
+    if (BaseCompiler.isIntegerValued(a) && BaseCompiler.isIntegerValued(b) && BaseCompiler.isNonNegative(a))
+      return `(${ca} % ${cb})`;
     return `((${ca} % ${cb}) + ${cb}) % ${cb}`;
   },
-  Truncate: "Math.trunc",
+  Truncate: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `Math.trunc(${compile3(args[0])})`;
+  },
   Remainder: ([a, b], compile3) => {
     if (a === null || b === null)
       throw new Error("Remainder: missing argument");
@@ -59954,25 +60355,20 @@ var JAVASCRIPT_FUNCTIONS = {
       a
     )} / ${compile3(b)}))`;
   },
-  // Arithmetic operators handled as functions for completeness
-  Subtract: ([a, b], compile3) => {
-    if (a === null || b === null) throw new Error("Subtract: missing argument");
-    const ac = BaseCompiler.isComplexValued(a);
-    const bc = BaseCompiler.isComplexValued(b);
-    if (!ac && !bc) return `(${compile3(a)} - ${compile3(b)})`;
-    const ca = compile3(a);
-    const cb = compile3(b);
-    const reA = ac ? `(${ca}).re` : ca;
-    const imA = ac ? `(${ca}).im` : "0";
-    const reB = bc ? `(${cb}).re` : cb;
-    const imB = bc ? `(${cb}).im` : "0";
-    return `({ re: ${reA} - ${reB}, im: ${imA} - ${imB} })`;
-  },
+  // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+  // The operator entry in JAVASCRIPT_OPERATORS handles any edge cases.
   Divide: ([a, b], compile3) => {
     if (a === null || b === null) throw new Error("Divide: missing argument");
     const ac = BaseCompiler.isComplexValued(a);
     const bc = BaseCompiler.isComplexValued(b);
-    if (!ac && !bc) return `(${compile3(a)} / ${compile3(b)})`;
+    if (!ac && !bc) {
+      const ca = tryGetConstant(a);
+      const cb = tryGetConstant(b);
+      if (ca !== void 0 && cb !== void 0 && cb !== 0)
+        return String(ca / cb);
+      if (cb === 1) return compile3(a);
+      return `(${compile3(a)} / ${compile3(b)})`;
+    }
     if (ac && bc) {
       return `(() => { const _a = ${compile3(a)}, _b = ${compile3(
         b
@@ -59989,13 +60385,26 @@ var JAVASCRIPT_FUNCTIONS = {
   },
   Negate: ([x], compile3) => {
     if (x === null) throw new Error("Negate: no argument");
-    if (!BaseCompiler.isComplexValued(x)) return `(-${compile3(x)})`;
+    if (!BaseCompiler.isComplexValued(x)) {
+      const c = tryGetConstant(x);
+      if (c !== void 0) return String(-c);
+      return `(-${compile3(x)})`;
+    }
     return `_SYS.cneg(${compile3(x)})`;
   },
   Multiply: (args, compile3) => {
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return `(${args.map((x) => compile3(x)).join(" * ")})`;
+    if (!anyComplex) {
+      if (args.some((a) => tryGetConstant(a) === 0)) return "0";
+      const constants = args.map(tryGetConstant);
+      if (constants.every((c) => c !== void 0))
+        return String(constants.reduce((a, b) => a * b, 1));
+      const nonOne = args.filter((a) => tryGetConstant(a) !== 1);
+      if (nonOne.length === 0) return "1";
+      if (nonOne.length === 1) return compile3(nonOne[0]);
+      return `(${nonOne.map((x) => compile3(x)).join(" * ")})`;
+    }
     if (args.length === 2) {
       const ac = BaseCompiler.isComplexValued(args[0]);
       const bc = BaseCompiler.isComplexValued(args[1]);
@@ -60080,20 +60489,30 @@ var JAVASCRIPT_FUNCTIONS = {
   AiryAi: "_SYS.airyAi",
   AiryBi: "_SYS.airyBi",
   // Combinatorics
+  Mandelbrot: ([c, maxIter], compile3) => {
+    if (c === null || maxIter === null)
+      throw new Error("Mandelbrot: missing arguments");
+    return `_SYS.mandelbrot(${compile3(c)}, ${compile3(maxIter)})`;
+  },
+  Julia: ([z, c, maxIter], compile3) => {
+    if (z === null || c === null || maxIter === null)
+      throw new Error("Julia: missing arguments");
+    return `_SYS.julia(${compile3(z)}, ${compile3(c)}, ${compile3(maxIter)})`;
+  },
   Binomial: (args, compile3) => `_SYS.binomial(${compile3(args[0])}, ${compile3(args[1])})`,
   Fibonacci: "_SYS.fibonacci",
   // Complex-specific functions
-  Re: (args, compile3) => {
+  Real: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `(${compile3(args[0])}).re`;
     return compile3(args[0]);
   },
-  Im: (args, compile3) => {
+  Imaginary: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `(${compile3(args[0])}).im`;
     return "0";
   },
-  Arg: (args, compile3) => {
+  Argument: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_SYS.carg(${compile3(args[0])})`;
     return `(${compile3(args[0])} >= 0 ? 0 : Math.PI)`;
@@ -60429,6 +60848,41 @@ var SYS_HELPERS = {
   sinc,
   fresnelS,
   fresnelC,
+  mandelbrot: (c, maxIter) => {
+    let zx = 0, zy = 0;
+    const cx = typeof c === "number" ? c : c.re;
+    const cy = typeof c === "number" ? 0 : c.im;
+    const n = Math.round(maxIter);
+    for (let i = 0; i < n; i++) {
+      const newZx = zx * zx - zy * zy + cx;
+      zy = 2 * zx * zy + cy;
+      zx = newZx;
+      const mag2 = zx * zx + zy * zy;
+      if (mag2 > 4) {
+        const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+        return Math.max(0, Math.min(1, smooth));
+      }
+    }
+    return 1;
+  },
+  julia: (z, c, maxIter) => {
+    let zx = typeof z === "number" ? z : z.re;
+    let zy = typeof z === "number" ? 0 : z.im;
+    const cx = typeof c === "number" ? c : c.re;
+    const cy = typeof c === "number" ? 0 : c.im;
+    const n = Math.round(maxIter);
+    for (let i = 0; i < n; i++) {
+      const newZx = zx * zx - zy * zy + cx;
+      zy = 2 * zx * zy + cy;
+      zx = newZx;
+      const mag2 = zx * zx + zy * zy;
+      if (mag2 > 4) {
+        const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+        return Math.max(0, Math.min(1, smooth));
+      }
+    }
+    return 1;
+  },
   binomial: choose,
   fibonacci,
   // Complex helpers
@@ -60774,6 +61228,7 @@ var GPU_OPERATORS = {
   Add: ["+", 11],
   Negate: ["-", 14],
   Subtract: ["-", 11],
+  // Subtract canonicalizes to Add+Negate; kept as fallback
   Multiply: ["*", 12],
   Divide: ["/", 13],
   Equal: ["==", 8],
@@ -60789,6 +61244,12 @@ var GPU_OPERATORS = {
 function gpuVec2(target) {
   return target?.language === "wgsl" ? "vec2f" : "vec2";
 }
+function compileIntArg(expr2, compile3, target) {
+  const c = tryGetConstant(expr2);
+  if (c !== void 0 && Number.isInteger(c)) return c.toString();
+  const intCast = target?.language === "wgsl" ? "i32" : "int";
+  return `${intCast}(${compile3(expr2)})`;
+}
 var GPU_UNROLL_LIMIT = 100;
 function compileGPUSumProduct(kind, args, _compile2, target) {
   if (!args[0]) throw new Error(`${kind}: no body`);
@@ -60851,88 +61312,113 @@ var GPU_FUNCTIONS = {
     if (args.length === 0) return "0.0";
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return args.map((x) => compile3(x)).join(" + ");
-    const v2 = gpuVec2(target);
-    return args.map((a) => {
-      const code = compile3(a);
-      return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-    }).join(" + ");
-  },
-  Multiply: (args, compile3, _target) => {
-    if (args.length === 0) return "1.0";
-    if (args.length === 1) return compile3(args[0]);
-    const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-    if (!anyComplex) return args.map((x) => compile3(x)).join(" * ");
-    let result = compile3(args[0]);
-    let resultIsComplex = BaseCompiler.isComplexValued(args[0]);
-    for (let i = 1; i < args.length; i++) {
-      const code = compile3(args[i]);
-      const argIsComplex = BaseCompiler.isComplexValued(args[i]);
-      if (!resultIsComplex && !argIsComplex) {
-        result = `(${result} * ${code})`;
-      } else if (resultIsComplex && !argIsComplex) {
-        result = `(${code} * ${result})`;
-      } else if (!resultIsComplex && argIsComplex) {
-        result = `(${result} * ${code})`;
-        resultIsComplex = true;
-      } else {
-        result = `_gpu_cmul(${result}, ${code})`;
-      }
+    if (!anyComplex) {
+      return foldTerms(
+        args.map((x) => compile3(x)),
+        "0.0",
+        "+"
+      );
     }
-    return result;
-  },
-  Subtract: (args, compile3, target) => {
-    if (args.length === 0) return "0.0";
+    const parts = args.map((a) => tryGetComplexParts(a, compile3));
+    if (parts.some((p) => p === null)) {
+      const v2 = gpuVec2(target);
+      return args.map((a) => {
+        const code = compile3(a);
+        return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
+      }).join(" + ");
+    }
+    const reParts = [];
+    const imParts = [];
+    for (const p of parts) {
+      if (p.re !== null) reParts.push(p.re);
+      if (p.im !== null) imParts.push(p.im);
+    }
+    const reSum = foldTerms(reParts, "0.0", "+");
+    const imSum = foldTerms(imParts, "0.0", "+");
+    return `${gpuVec2(target)}(${reSum}, ${imSum})`;
+  },
+  Multiply: (args, compile3, target) => {
+    if (args.length === 0) return "1.0";
     if (args.length === 1) return compile3(args[0]);
     const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
     if (!anyComplex) {
-      if (args.length === 2) return `${compile3(args[0])} - ${compile3(args[1])}`;
-      let result2 = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result2 = `${result2} - ${compile3(args[i])}`;
-      }
-      return result2;
-    }
-    const v2 = gpuVec2(target);
-    const promote = (a) => {
-      const code = compile3(a);
-      return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-    };
-    if (args.length === 2) return `${promote(args[0])} - ${promote(args[1])}`;
-    let result = promote(args[0]);
-    for (let i = 1; i < args.length; i++) {
-      result = `${result} - ${promote(args[i])}`;
+      return foldTerms(
+        args.map((x) => compile3(x)),
+        "1.0",
+        "*"
+      );
     }
+    const iIndex = args.findIndex(
+      (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+    );
+    if (iIndex >= 0) {
+      const iFactor = args[iIndex];
+      const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+      const realFactors = args.filter((_, i) => i !== iIndex);
+      const v2 = gpuVec2(target);
+      if (realFactors.length === 0)
+        return `${v2}(0.0, ${formatFloat(iScale)})`;
+      const factors = realFactors.map((f) => compile3(f));
+      if (iScale !== 1) factors.unshift(formatFloat(iScale));
+      const imCode = foldTerms(factors, "1.0", "*");
+      return `${v2}(0.0, ${imCode})`;
+    }
+    const realCodes = [];
+    const complexCodes = [];
+    for (const a of args) {
+      if (BaseCompiler.isComplexValued(a)) complexCodes.push(compile3(a));
+      else realCodes.push(compile3(a));
+    }
+    const scalarCode = foldTerms(realCodes, "1.0", "*");
+    let result = complexCodes[0];
+    for (let i = 1; i < complexCodes.length; i++) {
+      result = `_gpu_cmul(${result}, ${complexCodes[i]})`;
+    }
+    if (scalarCode !== "1.0") result = `(${scalarCode} * ${result})`;
     return result;
   },
+  // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+  // The operator entry in GPU_OPERATORS handles any edge cases.
   Divide: (args, compile3, target) => {
     if (args.length === 0) return "1.0";
     if (args.length === 1) return compile3(args[0]);
     const ac = BaseCompiler.isComplexValued(args[0]);
     const bc = args.length >= 2 && BaseCompiler.isComplexValued(args[1]);
     if (!ac && !bc) {
-      if (args.length === 2) return `${compile3(args[0])} / ${compile3(args[1])}`;
+      if (args.length === 2) {
+        const a = tryGetConstant(args[0]);
+        const b = tryGetConstant(args[1]);
+        if (a !== void 0 && b !== void 0 && b !== 0)
+          return formatFloat(a / b);
+        if (b === 1) return compile3(args[0]);
+        return `${compile3(args[0])} / ${compile3(args[1])}`;
+      }
       let result = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
+      for (let i = 1; i < args.length; i++)
         result = `${result} / ${compile3(args[i])}`;
-      }
       return result;
     }
     if (ac && bc) return `_gpu_cdiv(${compile3(args[0])}, ${compile3(args[1])})`;
-    if (ac && !bc) {
-      return `(${compile3(args[0])} / ${compile3(args[1])})`;
-    }
+    if (ac && !bc) return `(${compile3(args[0])} / ${compile3(args[1])})`;
     const v2 = gpuVec2(target);
     return `_gpu_cdiv(${v2}(${compile3(args[0])}, 0.0), ${compile3(args[1])})`;
   },
-  Negate: ([x], compile3) => {
+  Negate: ([x], compile3, target) => {
     if (x === null) throw new Error("Negate: no argument");
+    const c = tryGetConstant(x);
+    if (c !== void 0) return formatFloat(-c);
+    if (isNumber(x) && x.im !== 0) {
+      return `${gpuVec2(target)}(${formatFloat(-x.re)}, ${formatFloat(-x.im)})`;
+    }
+    if (isSymbol2(x, "ImaginaryUnit"))
+      return `${gpuVec2(target)}(0.0, -1.0)`;
     return `(-${compile3(x)})`;
   },
   // Standard math functions with complex dispatch
   Abs: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `length(${compile3(args[0])})`;
+    if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
     return `abs(${compile3(args[0])})`;
   },
   Arccos: (args, compile3) => {
@@ -60950,7 +61436,10 @@ var GPU_FUNCTIONS = {
       return `_gpu_catan(${compile3(args[0])})`;
     return `atan(${compile3(args[0])})`;
   },
-  Ceil: "ceil",
+  Ceil: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `ceil(${compile3(args[0])})`;
+  },
   Clamp: "clamp",
   Cos: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -60964,7 +61453,10 @@ var GPU_FUNCTIONS = {
     return `exp(${compile3(args[0])})`;
   },
   Exp2: "exp2",
-  Floor: "floor",
+  Floor: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `floor(${compile3(args[0])})`;
+  },
   Fract: "fract",
   Ln: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -60986,10 +61478,25 @@ var GPU_FUNCTIONS = {
       const eCode = BaseCompiler.isComplexValued(exp3) ? compile3(exp3) : `${v2}(${compile3(exp3)}, 0.0)`;
       return `_gpu_cpow(${bCode}, ${eCode})`;
     }
+    const bConst = tryGetConstant(base);
+    const eConst = tryGetConstant(exp3);
+    if (bConst !== void 0 && eConst !== void 0)
+      return formatFloat(Math.pow(bConst, eConst));
+    if (eConst === 0) return "1.0";
+    if (eConst === 1) return compile3(base);
+    if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+      const code = compile3(base);
+      return `(${code} * ${code})`;
+    }
+    if (eConst === -1) return `(1.0 / ${compile3(base)})`;
+    if (eConst === 0.5) return `sqrt(${compile3(base)})`;
     return `pow(${compile3(base)}, ${compile3(exp3)})`;
   },
   Radians: "radians",
-  Round: "round",
+  Round: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `round(${compile3(args[0])})`;
+  },
   Sign: "sign",
   Sin: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
@@ -61000,6 +61507,8 @@ var GPU_FUNCTIONS = {
   Sqrt: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0]))
       return `_gpu_csqrt(${compile3(args[0])})`;
+    const c = tryGetConstant(args[0]);
+    if (c !== void 0) return formatFloat(Math.sqrt(c));
     return `sqrt(${compile3(args[0])})`;
   },
   Step: "step",
@@ -61008,17 +61517,20 @@ var GPU_FUNCTIONS = {
       return `_gpu_ctan(${compile3(args[0])})`;
     return `tan(${compile3(args[0])})`;
   },
-  Truncate: "trunc",
+  Truncate: (args, compile3) => {
+    if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+    return `trunc(${compile3(args[0])})`;
+  },
   // Complex-specific functions
-  Re: (args, compile3) => {
+  Real: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).x`;
     return compile3(args[0]);
   },
-  Im: (args, compile3) => {
+  Imaginary: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).y`;
     return "0.0";
   },
-  Arg: (args, compile3) => {
+  Argument: (args, compile3) => {
     if (BaseCompiler.isComplexValued(args[0])) {
       const code = compile3(args[0]);
       return `atan(${code}.y, ${code}.x)`;
@@ -61233,13 +61745,20 @@ var GPU_FUNCTIONS = {
   },
   Square: ([x], compile3) => {
     if (x === null) throw new Error("Square: no argument");
-    const arg = compile3(x);
-    return `(${arg} * ${arg})`;
+    if (isSymbol2(x) || isNumber(x)) {
+      const arg = compile3(x);
+      return `(${arg} * ${arg})`;
+    }
+    return `pow(${compile3(x)}, 2.0)`;
   },
   Root: ([x, n], compile3) => {
     if (x === null) throw new Error("Root: no argument");
     if (n === null || n === void 0) return `sqrt(${compile3(x)})`;
-    if (n?.re === 2) return `sqrt(${compile3(x)})`;
+    const nConst = tryGetConstant(n);
+    if (nConst === 2) return `sqrt(${compile3(x)})`;
+    const xConst = tryGetConstant(x);
+    if (xConst !== void 0 && nConst !== void 0)
+      return formatFloat(Math.pow(xConst, 1 / nConst));
     return `pow(${compile3(x)}, 1.0 / ${compile3(n)})`;
   },
   // Color functions (pure-math, GPU-compilable)
@@ -61281,18 +61800,14 @@ var GPU_FUNCTIONS = {
   Mandelbrot: ([c, maxIter], compile3, target) => {
     if (c === null || maxIter === null)
       throw new Error("Mandelbrot: missing arguments");
-    const intCast = target?.language === "wgsl" ? "i32" : "int";
-    return `_fractal_mandelbrot(${compile3(c)}, ${intCast}(${compile3(
-      maxIter
-    )}))`;
+    const iterCode = compileIntArg(maxIter, compile3, target);
+    return `_fractal_mandelbrot(${compile3(c)}, ${iterCode})`;
   },
   Julia: ([z, c, maxIter], compile3, target) => {
     if (z === null || c === null || maxIter === null)
       throw new Error("Julia: missing arguments");
-    const intCast = target?.language === "wgsl" ? "i32" : "int";
-    return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${intCast}(${compile3(
-      maxIter
-    )}))`;
+    const iterCode = compileIntArg(maxIter, compile3, target);
+    return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
   },
   // Vector/Matrix operations
   Cross: "cross",
@@ -63924,6 +64439,7 @@ var INTERVAL_JAVASCRIPT_OPERATORS = {
   Add: ["_IA.add", 20],
   Negate: ["_IA.negate", 20],
   Subtract: ["_IA.sub", 20],
+  // Subtract canonicalizes to Add+Negate; kept as fallback
   Multiply: ["_IA.mul", 20],
   Divide: ["_IA.div", 20],
   // Comparisons return BoolInterval
@@ -63948,17 +64464,7 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
     }
     return result;
   },
-  Subtract: (args, compile3) => {
-    if (args.length === 0) return "_IA.point(0)";
-    if (args.length === 1) return `_IA.negate(${compile3(args[0])})`;
-    if (args.length === 2)
-      return `_IA.sub(${compile3(args[0])}, ${compile3(args[1])})`;
-    let result = compile3(args[0]);
-    for (let i = 1; i < args.length; i++) {
-      result = `_IA.sub(${result}, ${compile3(args[i])})`;
-    }
-    return result;
-  },
+  // No Subtract handler — canonicalizes to Add+Negate before compilation.
   Multiply: (args, compile3) => {
     if (args.length === 0) return "_IA.point(1)";
     if (args.length === 1) return compile3(args[0]);
@@ -66932,7 +67438,9 @@ var ComputeEngine = class _ComputeEngine {
       }
       return new ExactNumericValue(value, makeNumericValue);
     }
-    throw Error("Unexpected value");
+    throw Error(
+      `Unexpected value: ${typeof value === "object" ? JSON.stringify(value) : String(value)}`
+    );
   }
   /**
    * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
@@ -67403,7 +67911,7 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/core.ts
-var version = "0.55.0";
+var version = "0.55.3";
 export {
   ComputeEngine,
   N,