@cortex-js/compute-engine 0.56.0 → 0.57.0

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.56.0 */
+/** Compute Engine 0.57.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -7914,8 +7914,15 @@ var ComputeEngine = (() => {
      *
      * Numeric values are rounded to `ce.precision` significant digits
      * (via `fractionalDigits: 'auto'`).
+     *
+     * If `options.verbatim` is `true` and `verbatimLatex` is set on this
+     * expression (i.e. it was parsed with `preserveLatex: true`), return
+     * the verbatim source instead of re-serializing. Falls through to
+     * re-serialization if no verbatim is available.
      */
     toLatex(options) {
+      if (options?.verbatim === true && this.verbatimLatex !== void 0)
+        return this.verbatimLatex;
       if (this.isLazyCollection) {
         const materialized = this.evaluate({
           materialization: options?.materialization ?? true
@@ -10058,6 +10065,64 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
+  var COMPONENT_ACCESS_HEADS = {
+    x: "First",
+    y: "Second",
+    z: "Third",
+    real: "Real",
+    re: "Real",
+    imag: "Imaginary",
+    im: "Imaginary",
+    count: "Length",
+    total: "Sum",
+    max: "Max",
+    min: "Min"
+  };
+  function memberHead(name) {
+    return COMPONENT_ACCESS_HEADS[name] ?? null;
+  }
+  function parseComponentAccess(parser, lhs) {
+    parser.skipVisualSpace();
+    if (parser.match("\\operatorname")) {
+      const name = parser.parseStringGroup();
+      if (name === null) return null;
+      const head = memberHead(name.trim());
+      if (head === null) return null;
+      return [head, lhs];
+    }
+    const tok = parser.peek;
+    if (typeof tok === "string" && tok.startsWith("\\")) {
+      const bare = tok.slice(1);
+      const head = memberHead(bare);
+      if (head !== null) {
+        parser.nextToken();
+        return [head, lhs];
+      }
+      return null;
+    }
+    if (typeof tok === "string" && /^[a-zA-Z]$/.test(tok)) {
+      const head = memberHead(tok);
+      if (head === null) return null;
+      parser.nextToken();
+      return [head, lhs];
+    }
+    return null;
+  }
+  function parseWhenRestriction(parser, lhs, close) {
+    parser.addBoundary(close);
+    parser.skipVisualSpace();
+    const cond = parser.parseExpression({ minPrec: 0 });
+    if (cond === null) {
+      parser.removeBoundary();
+      return null;
+    }
+    parser.skipVisualSpace();
+    if (!parser.matchBoundary()) {
+      parser.removeBoundary();
+      return null;
+    }
+    return ["When", lhs, cond];
+  }
   function parseSequence(parser, terminator, lhs, prec, sep) {
     if (terminator && terminator.minPrec >= prec) return null;
     const result = lhs ? [lhs] : ["Nothing"];
@@ -10529,6 +10594,15 @@ var ComputeEngine = (() => {
       }
     },
     { name: "LatexTokens", serialize: serializeLatexTokens },
+    // Component-access postfix: expr.member  (C3)
+    // The '.' trigger is consumed before the parse function is called.
+    // Precedence 850 > 810 (At/indexing) so .x chains tightly.
+    {
+      kind: "postfix",
+      precedence: 850,
+      latexTrigger: ["."],
+      parse: parseComponentAccess
+    },
     {
       name: "At",
       kind: "postfix",
@@ -10549,6 +10623,29 @@ var ComputeEngine = (() => {
       latexTrigger: ["\\left", "\\lbrack"],
       parse: parseAt("\\right", "\\rbrack")
     },
+    // When-restriction: `expr\left\{cond\right\}` → `When(expr, cond)` (D3)
+    {
+      name: "When",
+      kind: "postfix",
+      precedence: 800,
+      latexTrigger: ["\\left", "\\{"],
+      parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\right", "\\}"]),
+      serialize: (serializer, expr2) => {
+        const e = operand(expr2, 1);
+        const cond = operand(expr2, 2);
+        if (!e || !cond) return "";
+        const clauses = operator(cond) === "And" ? operands(cond) ?? [] : [cond];
+        const inner = clauses.map((c) => `\\left\\{${serializer.serialize(c)}\\right\\}`).join("");
+        return `${serializer.serialize(e)}${inner}`;
+      }
+    },
+    // When-restriction: bare `expr\{cond\}` → `When(expr, cond)`
+    {
+      kind: "postfix",
+      precedence: 800,
+      latexTrigger: ["\\{"],
+      parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\}"])
+    },
     {
       kind: "postfix",
       latexTrigger: ["_"],
@@ -10631,6 +10728,29 @@ var ComputeEngine = (() => {
         return "";
       }
     },
+    // Additional triggers for Range: `...`, `\ldots`, and `\dots` are
+    // equivalent to `..` when used as infix operators (e.g. `[1...9]`).
+    // No `name` field here — names must be unique per the dictionary rules;
+    // the first Range entry owns the name. When there is no LHS the symbol
+    // entries near the top of the file still fire (ContinuationPlaceholder).
+    {
+      latexTrigger: [".", ".", "."],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
+    {
+      latexTrigger: ["\\ldots"],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
+    {
+      latexTrigger: ["\\dots"],
+      kind: "infix",
+      precedence: 800,
+      parse: parseRange
+    },
     {
       latexTrigger: [";"],
       kind: "infix",
@@ -10815,13 +10935,24 @@ var ComputeEngine = (() => {
         const args = operands(expr2);
         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);
+        const elements = args.slice(1);
+        const allElements = elements.every((e) => operator(e) === "Element");
+        if (!allElements) {
+          return joinLatex([
+            "\\operatorname{Loop}(",
+            serializer.serialize(body),
+            ", ",
+            serializer.serialize(elements[0]),
+            ")"
+          ]);
+        }
+        if (elements.length === 1) {
+          const elem = elements[0];
+          const index = operand(elem, 1);
+          const coll = operand(elem, 2);
+          if (operator(coll) === "Range") {
+            const lo = operand(coll, 1);
+            const hi = operand(coll, 2);
             return joinLatex([
               "\\text{for }",
               serializer.serialize(index),
@@ -10833,13 +10964,27 @@ var ComputeEngine = (() => {
               serializer.serialize(body)
             ]);
           }
+          return joinLatex([
+            serializer.serialize(body),
+            " \\operatorname{for} ",
+            serializer.serialize(index),
+            " = ",
+            serializer.serialize(coll)
+          ]);
         }
+        const bindings = elements.map((elem) => {
+          const name = operand(elem, 1);
+          const coll = operand(elem, 2);
+          return joinLatex([
+            serializer.serialize(name),
+            " = ",
+            serializer.serialize(coll)
+          ]);
+        }).join(", ");
         return joinLatex([
-          "\\operatorname{Loop}(",
           serializer.serialize(body),
-          ", ",
-          serializer.serialize(indexing),
-          ")"
+          " \\operatorname{for} ",
+          bindings
         ]);
       }
     },
@@ -10872,6 +11017,18 @@ var ComputeEngine = (() => {
       precedence: 245,
       parse: (parser, until) => parseForExpression(parser, until)
     },
+    // \operatorname{for} as postfix infix (list comprehension):
+    //   `body \operatorname{for} x = L_1, y = L_2`
+    // Precedence 19 — just below comma (20) so the body is allowed to use
+    // any operator (including comma sequencing) up to the keyword, and the
+    // bindings can be comma-separated below us.
+    {
+      symbolTrigger: "for",
+      kind: "infix",
+      associativity: "none",
+      precedence: 19,
+      parse: (parser, lhs, until) => parseForComprehension(parser, lhs, until)
+    },
     // \operatorname{break}
     {
       symbolTrigger: "break",
@@ -11076,7 +11233,10 @@ var ComputeEngine = (() => {
         if (!sym2 || !parser.getSymbolType(sym2).matches("function")) return null;
         parser.addBoundary([")"]);
         const expr2 = parser.parseExpression(until);
-        if (!parser.matchBoundary()) return null;
+        if (!parser.matchBoundary()) {
+          parser.removeBoundary();
+          return null;
+        }
         if (!parser.match("<}>")) return null;
         return ["Derivative", lhs, expr2];
       }
@@ -11517,7 +11677,12 @@ var ComputeEngine = (() => {
     if (isEmptySequence(body)) return ["List"];
     const h = operator(body);
     if (h === "Range" || h === "Linspace") return body;
-    if (h === "Sequence") return ["List", ...operands(body)];
+    if (h === "Sequence") {
+      const elems = operands(body);
+      const inferred = tryInferRangeFromElements(elems, parser);
+      if (inferred) return inferred;
+      return ["List", ...elems];
+    }
     if (h === "Delimiter") {
       const delim = stringValue(operand(body, 2)) ?? "...";
       if (delim === ";" || delim === ".;.") {
@@ -11530,12 +11695,37 @@ var ComputeEngine = (() => {
       }
       if (delim === "," || delim === ".,.") {
         body = operand(body, 1);
-        if (operator(body) === "Sequence") return ["List", ...operands(body)];
+        if (operator(body) === "Sequence") {
+          const elems = operands(body);
+          const inferred = tryInferRangeFromElements(elems, parser);
+          if (inferred) return inferred;
+          return ["List", ...elems];
+        }
         return ["List", body ?? "Nothing"];
       }
     }
     return ["List", body];
   }
+  function tryInferRangeFromElements(elems, parser) {
+    if (elems.length < 4) return null;
+    const penultimate = elems[elems.length - 2];
+    if (symbol(penultimate) !== "ContinuationPlaceholder") return null;
+    const samples = elems.slice(0, -2);
+    const endExpr = elems[elems.length - 1];
+    if (samples.length < 2) return null;
+    const sampleNums = samples.map(machineValue);
+    if (sampleNums.some((n) => n === null)) return null;
+    const nums = sampleNums;
+    const step = nums[nums.length - 1] - nums[nums.length - 2];
+    const tol = parser.options.tolerance;
+    if (Math.abs(step) < tol)
+      return parser.error("degenerate-range-step", parser.index);
+    for (let i = 1; i < nums.length; i++) {
+      if (Math.abs(nums[i] - nums[i - 1] - step) > tol)
+        return parser.error("inconsistent-range-samples", parser.index);
+    }
+    return ["Range", nums[0], endExpr, step];
+  }
   function serializeList(serializer, expr2) {
     if (nops(expr2) > 1 && operands(expr2).every((x) => {
       const op = operator(x);
@@ -11787,6 +11977,35 @@ var ComputeEngine = (() => {
       ["Element", index, ["Range", lower, upper]]
     ];
   }
+  function parseForComprehension(parser, lhs, until) {
+    const bindingTerminator = {
+      minPrec: 21,
+      // Above comma (20) and ; (19), so `x = L_1` is captured whole
+      condition: (p) => {
+        if (until?.condition?.(p)) return true;
+        const saved = p.index;
+        p.skipVisualSpace();
+        const isComma = p.peek === ",";
+        p.index = saved;
+        return isComma;
+      }
+    };
+    const elements = [];
+    do {
+      parser.skipVisualSpace();
+      const binding = parser.parseExpression(bindingTerminator);
+      if (binding === null) break;
+      const op = operator(binding);
+      if (op !== "Equal" && op !== "Assign") return null;
+      const name = operand(binding, 1);
+      const list = operand(binding, 2);
+      if (!name || !list) return null;
+      elements.push(["Element", name, list]);
+      parser.skipVisualSpace();
+    } while (parser.match(","));
+    if (elements.length === 0) return null;
+    return ["Loop", lhs, ...elements];
+  }
   function parseWhereExpression(parser, lhs, until) {
     const bindingTerminator = {
       minPrec: 21,
@@ -19558,6 +19777,19 @@ var ComputeEngine = (() => {
         } while (postfix !== null);
       }
       if (result !== null) result = this.parseSupsub(result);
+      if (result !== null) {
+        let postfix = null;
+        let index = this.index;
+        do {
+          postfix = this.parsePostfixOperator(result, until);
+          result = postfix ?? result;
+          if (this.index === index && postfix !== null) {
+            console.assert(this.index !== index, "No token consumed");
+            break;
+          }
+          index = this.index;
+        } while (postfix !== null);
+      }
       if (result === null) {
         result = this.options.parseUnexpectedToken?.(null, this) ?? null;
         if (result === null && this.peek.startsWith("\\")) {
@@ -20066,6 +20298,28 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/latex-syntax/serializer.ts
+  var DOT_NOTATION_MAP = {
+    First: ".x",
+    Second: ".y",
+    Third: ".z",
+    Real: ".\\operatorname{real}",
+    Imaginary: ".\\operatorname{imag}",
+    Length: ".\\operatorname{count}",
+    Sum: ".\\operatorname{total}",
+    Max: ".\\max",
+    Min: ".\\min"
+  };
+  function trySerializeDotNotation(serializer, expr2) {
+    if (!serializer.options.dotNotation) return null;
+    const ops = operands(expr2);
+    if (!ops || ops.length !== 1) return null;
+    const head = operator(expr2);
+    if (!head) return null;
+    const suffix = DOT_NOTATION_MAP[head];
+    if (suffix === void 0) return null;
+    const lhs = serializer.wrap(ops[0], 810);
+    return `${lhs}${suffix}`;
+  }
   var ACCENT_MODIFIERS = {
     deg: (s) => `${s}\\degree`,
     prime: (s) => `${s}^{\\prime}`,
@@ -20109,6 +20363,7 @@ var ComputeEngine = (() => {
     constructor(dictionary, options) {
       this.dictionary = dictionary;
       this.options = {
+        dotNotation: false,
         dmsFormat: false,
         angleNormalization: "none",
         ...options
@@ -20207,6 +20462,8 @@ var ComputeEngine = (() => {
       return def?.serialize?.(this, expr2) ?? serializeSymbol2(symbol(expr2)) ?? "";
     }
     serializeFunction(expr2, def) {
+      const dotResult = trySerializeDotNotation(this, expr2);
+      if (dotResult !== null) return dotResult;
       if (def?.serialize) return def.serialize(this, expr2);
       const h = operator(expr2);
       return serializeSymbol2(h, "auto") + this.wrapArguments(expr2);
@@ -20449,6 +20706,8 @@ var ComputeEngine = (() => {
       preserveLatex: opts.preserveLatex ?? false,
       quantifierScope: opts.quantifierScope ?? "tight",
       timeDerivativeVariable: opts.timeDerivativeVariable ?? "t",
+      // Standalone mode has no engine; use the same default as ComputeEngine
+      tolerance: 1e-7,
       // Callbacks -- standalone mode has no engine, so these are stubs
       getSymbolType: (_id) => BoxedType.unknown,
       hasSubscriptEvaluate: (_id) => false,
@@ -20481,6 +20740,7 @@ var ComputeEngine = (() => {
       invisiblePlus: "",
       multiply: "\\times",
       missingSymbol: "\\blacksquare",
+      dotNotation: false,
       dmsFormat: false,
       angleNormalization: "none",
       // Style callbacks -- use same defaults as the engine
@@ -27451,7 +27711,11 @@ ${lines.join("\n")}`;
     //
     Range: {
       complexity: 8200,
-      signature: "(number, number?, step: number?) -> indexed_collection<integer>",
+      signature: "(number, number?, step: number?) -> indexed_collection<number>",
+      type: (ops) => {
+        const allInt = ops.every((op) => op.isInteger);
+        return allInt ? parseType("indexed_collection<integer>") : parseType("indexed_collection<number>");
+      },
       canonical: (ops, { engine: ce }) => {
         if (ops.length === 0) return null;
         if (ops.length === 1) return ce._fn("Range", [ce.One, ops[0].canonical]);
@@ -27475,19 +27739,26 @@ ${lines.join("\n")}`;
           const [lower, upper, step] = range(expr2);
           if (step === 0) return 0;
           if (!isFinite(lower) || !isFinite(upper)) return Infinity;
-          return 1 + Math.max(0, Math.floor((upper - lower) / step));
+          return Math.max(0, Math.floor((upper - lower) / step) + 1);
         },
         contains: (expr2, target) => {
-          if (!target.type.matches("integer")) return false;
           const t = target.re;
+          if (!isFinite(t)) return false;
           const [lower, upper, step] = range(expr2);
           if (step === 0) return false;
-          if (step > 0) return t >= lower && t <= upper;
-          return t <= lower && t >= upper;
+          if (step > 0) {
+            if (t < lower || t > upper) return false;
+          } else {
+            if (t > lower || t < upper) return false;
+          }
+          const k = (t - lower) / step;
+          const tol = expr2.engine.tolerance;
+          const kRounded = Math.round(k);
+          return kRounded >= 0 && Math.abs(k - kRounded) < tol;
         },
         iterator: (expr2) => {
           const [lower, upper, step] = range(expr2);
-          const maxCount = step === 0 ? 0 : Math.floor((upper - lower) / step) + 1;
+          const maxCount = step === 0 ? 0 : Math.max(0, Math.floor((upper - lower) / step) + 1);
           let index = 1;
           return {
             next: () => {
@@ -27505,7 +27776,9 @@ ${lines.join("\n")}`;
         at: (expr2, index) => {
           if (typeof index !== "number") return void 0;
           const [lower, upper, step] = range(expr2);
-          if (index < 1 || index > 1 + (upper - lower) / step) return void 0;
+          if (step === 0) return void 0;
+          const maxCount = Math.max(0, Math.floor((upper - lower) / step) + 1);
+          if (index < 1 || index > maxCount) return void 0;
           return expr2.engine.number(lower + step * (index - 1));
         },
         indexWhere: void 0,
@@ -27530,7 +27803,13 @@ ${lines.join("\n")}`;
           if (step > 0) return lower <= upper ? "positive" : "negative";
           return lower >= upper ? "positive" : "negative";
         },
-        elttype: (_expr) => "finite_integer"
+        elttype: (expr2) => {
+          if (!isFunction2(expr2)) return "finite_integer";
+          for (let i = 1; i <= expr2.nops; i++) {
+            if (!expr2[`op${i}`].isInteger) return "finite_real";
+          }
+          return "finite_integer";
+        }
       }
     },
     Interval: {
@@ -28128,15 +28407,45 @@ ${lines.join("\n")}`;
     },
     First: {
       complexity: 8200,
-      signature: "(collection) -> any",
+      signature: "(any) -> any",
       type: ([xs]) => xs.operatorDefinition?.collection?.elttype?.(xs) ?? "any",
-      evaluate: ([xs], { engine: ce }) => xs.at(1) ?? ce.Nothing
+      evaluate: ([xs], { engine: ce }) => {
+        if (!xs.isCollection)
+          return ce.error([
+            "incompatible-type",
+            `'collection'`,
+            xs.type.toString()
+          ]);
+        return xs.at(1) ?? ce.Nothing;
+      }
     },
     Second: {
       complexity: 8200,
-      signature: "(collection) -> any",
+      signature: "(any) -> any",
+      type: ([xs]) => xs.operatorDefinition?.collection?.elttype?.(xs) ?? "any",
+      evaluate: ([xs], { engine: ce }) => {
+        if (!xs.isCollection)
+          return ce.error([
+            "incompatible-type",
+            `'collection'`,
+            xs.type.toString()
+          ]);
+        return xs.at(2) ?? ce.Nothing;
+      }
+    },
+    Third: {
+      complexity: 8200,
+      signature: "(any) -> any",
       type: ([xs]) => xs.operatorDefinition?.collection?.elttype?.(xs) ?? "any",
-      evaluate: ([xs], { engine: ce }) => xs.at(2) ?? ce.Nothing
+      evaluate: ([xs], { engine: ce }) => {
+        if (!xs.isCollection)
+          return ce.error([
+            "incompatible-type",
+            `'collection'`,
+            xs.type.toString()
+          ]);
+        return xs.at(3) ?? ce.Nothing;
+      }
     },
     Last: {
       complexity: 8200,
@@ -29115,17 +29424,14 @@ ${lines.join("\n")}`;
     if (!isFunction2(expr2)) return [1, 0, 0];
     if (expr2.nops === 0) return [1, 0, 0];
     let op1 = expr2.op1.re;
-    if (!isFinite(op1)) op1 = 1;
-    else op1 = Math.round(op1);
+    if (!isFinite(op1) && !op1) op1 = 1;
     if (expr2.nops === 1) return [1, op1, 1];
     let op2 = expr2.op2.re;
     if (!isFinite(op2) && !op2) op2 = 1;
-    else if (isFinite(op2)) op2 = Math.round(op2);
-    if (expr2.nops === 2) return [op1, op2, op2 > op1 ? 1 : -1];
+    if (expr2.nops === 2) return [op1, op2, op2 >= op1 ? 1 : -1];
     let op3 = expr2.op3.re;
-    if (!isFinite(op3)) op3 = 1;
-    else op3 = Math.abs(Math.round(op3));
-    return [op1, op2, op1 < op2 ? op3 : -op3];
+    if (!isFinite(op3) && !op3) op3 = 1;
+    return [op1, op2, op3];
   }
   function rangeLast(r) {
     const [lower, upper, step] = r;
@@ -42855,12 +43161,42 @@ ${e.message}
         }
       },
       Loop: {
-        description: "Evaluate a body expression over elements of a collection.",
+        description: "Evaluate a body expression in nested iteration over Element clauses. Later clauses see earlier bindings; independent clauses produce a Cartesian product.",
+        lazy: true,
+        signature: "(body:expression, iterators:expression*) -> any",
+        type: ([body]) => {
+          if (!body) return "nothing";
+          return parseType(`indexed_collection<${String(body.type)}>`);
+        },
+        canonical: canonicalLoop,
+        evaluate: (ops, { engine: ce }) => run(runLoop(ops[0], ops.slice(1), ce), ce._timeRemaining),
+        evaluateAsync: async (ops, { engine: ce, signal }) => runAsync(runLoop(ops[0], ops.slice(1), ce), ce._timeRemaining, signal)
+      },
+      When: {
+        description: "Conditional value: returns expr when cond holds, undefined otherwise.",
         lazy: true,
-        signature: "(body:expression, collection:expression) -> any",
-        type: ([body]) => body.type,
-        evaluate: ([body, collection], { engine: ce }) => run(runLoop(body, collection, ce), ce._timeRemaining),
-        evaluateAsync: async ([body, collection], { engine: ce, signal }) => runAsync(runLoop(body, collection, ce), ce._timeRemaining, signal)
+        signature: "(expression, boolean) -> any",
+        type: ([expr2]) => expr2.type,
+        canonical: (args, { engine: ce }) => {
+          if (args.length !== 2) return null;
+          const [expr2, cond] = args;
+          if (isFunction2(expr2, "When")) {
+            const inner = expr2.op1.canonical;
+            const innerCond = expr2.op2.canonical;
+            return ce._fn("When", [
+              inner,
+              ce._fn("And", [innerCond, cond.canonical])
+            ]);
+          }
+          return ce._fn("When", [expr2.canonical, cond.canonical]);
+        },
+        evaluate: ([expr2, cond], { engine: ce }) => {
+          const c = cond.evaluate();
+          const cs = sym(c);
+          if (cs === "True") return expr2.evaluate();
+          if (cs === "False") return ce.symbol("Undefined");
+          return ce._fn("When", [expr2, c]);
+        }
       },
       Which: {
         description: "Return the value for the first condition that is true.",
@@ -42920,9 +43256,141 @@ ${e.message}
     );
     return result;
   }
-  function* runLoop(body, collection, ce) {
+  function canonicalLoop(ops, options) {
+    const { engine: ce, scope } = options;
+    if (ops.length === 0) return null;
+    if (ops.length === 1) {
+      return ce._fn("Loop", [ops[0].canonical]);
+    }
+    const body = ops[0];
+    const iterators = ops.slice(1);
+    const allElement = iterators.every((it) => it.operator === "Element");
+    if (!allElement) {
+      return ce._fn(
+        "Loop",
+        ops.map((op) => op.canonical)
+      );
+    }
+    const loopScope = scope ?? {
+      parent: ce.context.lexicalScope,
+      bindings: /* @__PURE__ */ new Map()
+    };
+    loopScope.noAutoDeclare = true;
+    ce.pushScope(loopScope);
+    let canonicalIterators;
+    let canonicalBody;
+    try {
+      canonicalIterators = iterators.map((it) => {
+        if (!isFunction2(it, "Element")) {
+          return ce._fn("Element", [
+            ce.error("missing").canonical,
+            ce.error("missing").canonical
+          ]);
+        }
+        const indexExpr = it.ops[0];
+        const collExpr = it.ops[1];
+        if (!indexExpr || !collExpr) {
+          return ce._fn("Element", [
+            (indexExpr ?? ce.error("missing")).canonical,
+            (collExpr ?? ce.error("missing")).canonical
+          ]);
+        }
+        if (isSymbol2(indexExpr) && indexExpr.symbol !== "Nothing") {
+          if (!ce.context.lexicalScope.bindings.has(indexExpr.symbol))
+            ce.declare(indexExpr.symbol, "unknown");
+        }
+        return ce._fn("Element", [indexExpr.canonical, collExpr.canonical]);
+      });
+      canonicalBody = body.canonical;
+    } finally {
+      ce.popScope();
+      loopScope.noAutoDeclare = false;
+    }
+    return ce._fn("Loop", [canonicalBody, ...canonicalIterators], {
+      scope: loopScope
+    });
+  }
+  function* runLoop(body, elements, ce) {
     body ??= ce.Nothing;
     if (sym(body) === "Nothing") return body;
+    if (elements.length === 0) {
+      const result = body.evaluate();
+      yield result;
+      return result;
+    }
+    if (elements.length === 1 && elements[0].operator !== "Element") {
+      return yield* runLoopLegacy(body, elements[0], ce);
+    }
+    const results = [];
+    const state = { stopped: false, broke: false, count: 0 };
+    const freshScope = {
+      parent: ce.context.lexicalScope,
+      bindings: /* @__PURE__ */ new Map()
+    };
+    ce._pushEvalContext(freshScope);
+    try {
+      for (const elem of elements) {
+        if (!isFunction2(elem, "Element")) continue;
+        const idx = elem.ops[0];
+        if (idx && isSymbol2(idx) && idx.symbol !== "Nothing") {
+          if (!freshScope.bindings.has(idx.symbol))
+            ce.declare(idx.symbol, "unknown");
+        }
+      }
+      yield* runLoopNested(body, elements, 0, ce, results, state);
+    } finally {
+      ce._popEvalContext();
+    }
+    if (state.stopped && state.value !== void 0) {
+      if (!state.broke) return state.value;
+      return state.value;
+    }
+    return ce.function("List", results);
+  }
+  function* runLoopNested(body, elements, index, ce, results, state) {
+    if (state.stopped) return;
+    if (index === elements.length) {
+      const result = body.evaluate();
+      state.count += 1;
+      if (state.count > ce.iterationLimit)
+        throw new CancellationError({ cause: "iteration-limit-exceeded" });
+      if (isFunction2(result, "Break")) {
+        state.stopped = true;
+        state.broke = true;
+        state.value = result.op1;
+        return;
+      }
+      if (result.operator === "Return") {
+        state.stopped = true;
+        state.value = result;
+        return;
+      }
+      results.push(result);
+      yield result;
+      return;
+    }
+    const elem = elements[index];
+    if (!isFunction2(elem, "Element")) {
+      return;
+    }
+    const indexExpr = elem.ops[0];
+    const collExpr = elem.ops[1];
+    if (!indexExpr || !isSymbol2(indexExpr) || !collExpr) {
+      return;
+    }
+    const name = indexExpr.symbol;
+    const collection = collExpr.evaluate();
+    if (!collection?.isCollection) {
+      return;
+    }
+    const skipAssign = name === "Nothing";
+    for (const value of collection.each()) {
+      if (!skipAssign) ce.assign(name, value);
+      yield* runLoopNested(body, elements, index + 1, ce, results, state);
+      if (state.stopped) return;
+    }
+  }
+  function* runLoopLegacy(body, collection, ce) {
     if (collection?.isCollection) {
       let result = void 0;
       const fn = applicable(body);
@@ -55005,6 +55473,23 @@ Error in definition of "${name}"`,
         };
         return compilePair(0);
       }
+      if (h === "When") {
+        if (args.length !== 2)
+          throw new Error("When: expected exactly 2 arguments (expr, cond)");
+        const fn2 = target.functions?.(h);
+        if (fn2) {
+          if (typeof fn2 === "function") {
+            return fn2(args, (expr2) => _BaseCompiler.compile(expr2, target), target);
+          }
+          return `${fn2}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
+        }
+        if (isSymbol2(args[1], "True"))
+          return `(${_BaseCompiler.compile(args[0], target)})`;
+        if (isSymbol2(args[1], "False")) return "NaN";
+        const val = _BaseCompiler.compile(args[0], target);
+        const cond = _BaseCompiler.compile(args[1], target);
+        return `((${cond}) ? (${val}) : NaN)`;
+      }
       if (h === "Block") {
         return _BaseCompiler.compileBlock(args, target);
       }
@@ -55079,17 +55564,91 @@ Error in definition of "${name}"`,
       )}${target.ws("\n")}})()`;
     }
     /**
-     * Compile a Loop expression with Element(index, Range(lo, hi)) indexing.
-     * Generates: (() => { for (let i = lo; i <= hi; i++) { body } })()
+     * Compile a Loop expression.
+     *
+     * Two forms are supported:
+     *
+     * 1. **Imperative / single-Element form** (existing behaviour):
+     *    `Loop(body, Element(i, Range(lo, hi)))`
+     *    Generates a raw `for (let i = lo; i <= hi; i++) { body }` loop wrapped
+     *    in an IIFE.  The loop counter is always a plain number.  For targets
+     *    that wrap numeric values (e.g. interval-js uses `_IA.point()`),
+     *    references to the loop index inside the body are re-wrapped via
+     *    `target.number`.  `break` / `continue` / `return` are preserved.
+     *
+     * 2. **Comprehension / variadic-Element form** (new):
+     *    `Loop(body, Element(x, coll1), Element(y, coll2), …)`
+     *    When two or more `Element` clauses are present — or when the single
+     *    Element's collection is not a `Range` — the loop is compiled as a
+     *    comprehension that collects results into an array.  Each clause
+     *    produces a `for (const name of collection)` loop, nested
+     *    outermost-to-innermost, and the innermost body pushes into `result`.
+     *
+     *    Example output (JS):
+     *    ```js
+     *    (() => { const result = [];
+     *      for (const x of [1,2]) { for (const y of [3,4]) { result.push(body); } }
+     *      return result; })()
+     *    ```
      *
-     * 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`.
+     *    GLSL: multi-Element comprehension is not trivially representable in
+     *    GLSL (no dynamic arrays, no push).  A compile-time error is thrown.
+     *    TODO(E3-GLSL): support GLSL multi-Element via a pre-declared fixed-size
+     *    array or by unrolling when bounds are known at compile time.
      */
     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];
+      const body = args[0];
+      const elements = args.slice(1);
+      const useComprehension = elements.length > 1 || elements.length === 1 && isFunction2(elements[0], "Element") && !_BaseCompiler.isLegacyCompatibleRange(elements[0].ops[1]);
+      if (useComprehension) {
+        const lang = target.language ?? "";
+        if (lang === "glsl" || lang === "wgsl") {
+          throw new Error(
+            `${lang.toUpperCase()}: multi-Element Loop comprehension is not yet supported. TODO(E3-GLSL): unroll or use a fixed-size array.`
+          );
+        }
+        const narrowedElements = [];
+        for (let i = 0; i < elements.length; i++) {
+          const elem = elements[i];
+          if (!isFunction2(elem, "Element"))
+            throw new Error(
+              `Loop: argument ${i + 1} must be an Element clause, got ${elem.operator ?? "?"}`
+            );
+          if (!isSymbol2(elem.ops[0]))
+            throw new Error(
+              `Loop: Element index (argument ${i + 1}) must be a symbol`
+            );
+          narrowedElements.push(elem);
+        }
+        const loopVarSet = new Set(
+          narrowedElements.map(
+            (e) => e.ops[0].symbol
+          )
+        );
+        const needsWrap2 = target.number(0) !== "0";
+        const bodyTarget2 = needsWrap2 ? {
+          ...target,
+          var: (id) => loopVarSet.has(id) ? target.number(0).replace("0", id) : target.var(id)
+        } : target;
+        const bodyCode = _BaseCompiler.compile(body, bodyTarget2);
+        let inner = `result.push(${bodyCode});`;
+        for (let i = narrowedElements.length - 1; i >= 0; i--) {
+          const elem = narrowedElements[i];
+          const name = elem.ops[0].symbol;
+          const collExpr = elem.ops[1];
+          let collection;
+          if (isFunction2(collExpr, "Range")) {
+            collection = _BaseCompiler.compileRangeIterable(collExpr, bodyTarget2);
+          } else {
+            collection = _BaseCompiler.compile(collExpr, bodyTarget2);
+          }
+          inner = `for (const ${name} of ${collection}) { ${inner} }`;
+        }
+        return `(() => { const result = []; ${inner} return result; })()`;
+      }
+      const indexing = elements[0];
       if (!isFunction2(indexing, "Element"))
         throw new Error("Loop: expected Element(index, Range(lo, hi))");
       const indexExpr = indexing.ops[0];
@@ -55107,13 +55666,72 @@ Error in definition of "${name}"`,
         ...target,
         var: (id) => id === index ? needsWrap ? target.number(0).replace("0", index) : index : target.var(id)
       };
-      const bodyStmts = _BaseCompiler.compileLoopBody(args[0], bodyTarget);
+      const bodyStmts = _BaseCompiler.compileLoopBody(body, bodyTarget);
       return `(() => {${target.ws(
         "\n"
       )}for (let ${index} = ${lower}; ${index} <= ${upper}; ${index}++) {${target.ws(
         "\n"
       )}${bodyStmts}${target.ws("\n")}}${target.ws("\n")}})()`;
     }
+    /**
+     * Returns `true` when the given collection expression is a `Range` whose
+     * runtime semantics match the legacy imperative for-loop shape
+     * `for (let i = lo; i <= hi; i++)`.
+     *
+     * Concretely: integer-ascending bounds and step omitted-or-1. When bounds
+     * are not statically numeric we accept the Range (the historical
+     * behaviour) — runtime mismatch in the descending-unknown-bounds case is
+     * left as a known limitation; callers can force the iterable path by
+     * supplying an explicit step.
+     */
+    static isLegacyCompatibleRange(coll) {
+      if (!isFunction2(coll, "Range")) return false;
+      if (coll.ops.length >= 3) {
+        const stepExpr = coll.ops[2];
+        if (!isNumber(stepExpr) || stepExpr.re !== 1) return false;
+      }
+      const lo = coll.ops[0];
+      const hi = coll.ops[1];
+      if (isNumber(lo) && !Number.isInteger(lo.re)) return false;
+      if (isNumber(hi) && !Number.isInteger(hi.re)) return false;
+      if (isNumber(lo) && isNumber(hi) && lo.re > hi.re) return false;
+      return true;
+    }
+    /**
+     * Compile a `Range(lo, hi)` or `Range(lo, hi, step)` expression into a JS
+     * iterable expression. Mirrors the runtime semantics in
+     * `library/collections.ts` Range:
+     *     count    = step === 0 ? 0 : max(0, floor((hi - lo) / step) + 1)
+     *     element  = lo + step * k          (0-indexed)
+     * Default step is 1 when omitted. Bounds and step may be fractional.
+     *
+     * Only used from the comprehension path in `compileForLoop`.
+     * Caller must have already verified `isFunction(rangeExpr, 'Range')`.
+     */
+    static compileRangeIterable(rangeExpr, target) {
+      const loExpr = rangeExpr.ops[0];
+      const hiExpr = rangeExpr.ops[1];
+      const stepExpr = rangeExpr.ops[2];
+      if (isNumber(loExpr) && isNumber(hiExpr) && (stepExpr === void 0 || isNumber(stepExpr))) {
+        const lo2 = loExpr.re;
+        const hi2 = hiExpr.re;
+        const step2 = stepExpr === void 0 ? hi2 >= lo2 ? 1 : -1 : stepExpr.re;
+        if (step2 === 0) return "[]";
+        const len = Math.max(0, Math.floor((hi2 - lo2) / step2) + 1);
+        if (step2 === 1) {
+          if (lo2 === 0) return `Array.from({length:${len}},(_,k)=>k)`;
+          return `Array.from({length:${len}},(_,k)=>${lo2}+k)`;
+        }
+        return `Array.from({length:${len}},(_,k)=>${lo2}+(${step2})*k)`;
+      }
+      const lo = _BaseCompiler.compile(loExpr, target);
+      const hi = _BaseCompiler.compile(hiExpr, target);
+      if (stepExpr === void 0) {
+        return `((_lo,_hi)=>{const _st=_hi>=_lo?1:-1;return Array.from({length:Math.max(0,Math.floor((_hi-_lo)/_st)+1)},(_,k)=>_lo+_st*k);})(${lo},${hi})`;
+      }
+      const step = _BaseCompiler.compile(stepExpr, target);
+      return `((_lo,_hi,_st)=>_st===0?[]:Array.from({length:Math.max(0,Math.floor((_hi-_lo)/_st)+1)},(_,k)=>_lo+_st*k))(${lo},${hi},${step})`;
+    }
     /**
      * Compile a loop body expression as statements (not wrapped in IIFE).
      * Handles Break, Continue, Return as statements, and If as if-else when
@@ -69184,6 +69802,15 @@ ${code}`;
     lookupDefinition(id) {
       return lookupDefinition(this, id);
     }
+    operatorInfo(head) {
+      const def = this.lookupDefinition(head);
+      if (!def || !isOperatorDef(def)) return void 0;
+      const op = def.operator;
+      return {
+        kind: op.evaluate || op.collection ? "function" : "opaque",
+        signature: op.signature
+      };
+    }
     /**
      * Associate a new definition to a symbol in the current context.
      *
@@ -69471,6 +70098,7 @@ ${code}`;
           const def = this.lookupDefinition(id);
           return !!(isValueDef(def) && def.value.subscriptEvaluate);
         },
+        tolerance: this.tolerance,
         ...this._latexOptions,
         ...parseOpts
       });
@@ -69635,14 +70263,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.56.0";
+  var version = "0.57.0";
   ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
   _setDefaultEngineFactory(
     () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
   );
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.56.0"
+    version: "0.57.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();