@cortex-js/compute-engine 0.56.0 → 0.58.0

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.56.0 */
+/** Compute Engine 0.58.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;
@@ -4344,7 +4344,42 @@ var ComputeEngine = (() => {
     if (b === "nothing") return a;
     if (isSubtype(a, b)) return b;
     if (isSubtype(b, a)) return a;
-    return superType(a, b);
+    const sup = superType(a, b);
+    if (LOSSY_SUPERTYPE.has(sup)) return unionTypes(a, b);
+    return sup;
+  }
+  var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
+    "scalar",
+    "value",
+    "function",
+    "expression",
+    "collection",
+    "indexed_collection",
+    "list",
+    "set",
+    "tuple",
+    "record",
+    "dictionary",
+    "map",
+    "any"
+  ]);
+  function unionTypes(a, b) {
+    const members = [];
+    const push = (t) => {
+      if (typeof t === "object" && t.kind === "union") {
+        for (const m of t.types) push(m);
+        return;
+      }
+      const key = typeof t === "string" ? t : JSON.stringify(t);
+      if (!members.some(
+        (m) => (typeof m === "string" ? m : JSON.stringify(m)) === key
+      ))
+        members.push(t);
+    };
+    push(a);
+    push(b);
+    if (members.length === 1) return members[0];
+    return { kind: "union", types: members };
   }
   function narrow(...types) {
     if (types.length === 0) return "nothing";
@@ -4422,7 +4457,7 @@ var ComputeEngine = (() => {
     if (type2.kind === "set") return type2.elements;
     if (type2.kind === "tuple") return widen(...type2.elements.map((x) => x.type));
     if (type2.kind === "dictionary")
-      return parseType(`tuple<string, ${type2.values}>`);
+      return parseType(`tuple<string, ${typeToString(type2.values)}>`);
     if (type2.kind === "record") {
       return parseType(
         `tuple<string, ${typeToString(widen(...Object.values(type2.elements)))}>`
@@ -5968,6 +6003,84 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/boxed-expression/inequality-bounds.ts
+  function extractIntervalBounds(expr2, symbol2) {
+    if (isFunction2(expr2, "When")) {
+      const cond = expr2.op2;
+      if (!cond) return void 0;
+      return extractIntervalBounds(cond, symbol2);
+    }
+    if (isFunction2(expr2, "Multiply")) {
+      const ops = expr2.ops;
+      if (!ops) return void 0;
+      const merged = {};
+      for (const sub2 of ops) {
+        if (isFunction2(sub2, "When")) {
+          const sub_ = extractIntervalBounds(sub2, symbol2);
+          if (sub_ !== void 0) _mergeBounds(merged, sub_);
+        }
+      }
+      return _hasAnyBound(merged) ? merged : void 0;
+    }
+    const result = {};
+    if (isFunction2(expr2, "And")) {
+      const ops = expr2.ops;
+      if (!ops) return void 0;
+      for (const sub2 of ops) {
+        const subBounds = extractIntervalBounds(sub2, symbol2);
+        if (subBounds === void 0) continue;
+        _mergeBounds(result, subBounds);
+      }
+      return _hasAnyBound(result) ? result : void 0;
+    }
+    const op = expr2.operator;
+    if ((op === "Less" || op === "LessEqual" || op === "Greater" || op === "GreaterEqual") && isFunction2(expr2)) {
+      const isStrict = op === "Less" || op === "Greater";
+      const ops = expr2.ops;
+      if (!ops || ops.length < 2) return void 0;
+      const flipped = op === "Greater" || op === "GreaterEqual" ? [...ops].reverse() : ops;
+      for (let i = 0; i < flipped.length; i++) {
+        if (isSymbol2(flipped[i], symbol2)) {
+          if (i > 0) {
+            const candidate = flipped[i - 1];
+            if (result.lower === void 0 || candidate.isGreater(result.lower) === true) {
+              result.lower = candidate;
+              result.lowerStrict = isStrict;
+            }
+          }
+          if (i < flipped.length - 1) {
+            const candidate = flipped[i + 1];
+            if (result.upper === void 0 || candidate.isLess(result.upper) === true) {
+              result.upper = candidate;
+              result.upperStrict = isStrict;
+            }
+          }
+        }
+      }
+      return _hasAnyBound(result) ? result : void 0;
+    }
+    return void 0;
+  }
+  function _mergeBounds(into, from) {
+    if (from.lower !== void 0) {
+      if (into.lower === void 0 || from.lower.isGreater(into.lower) === true) {
+        into.lower = from.lower;
+        into.lowerStrict = from.lowerStrict;
+      } else if (from.lower.isSame(into.lower)) {
+        into.lowerStrict = into.lowerStrict || from.lowerStrict;
+      }
+    }
+    if (from.upper !== void 0) {
+      if (into.upper === void 0 || from.upper.isLess(into.upper) === true) {
+        into.upper = from.upper;
+        into.upperStrict = from.upperStrict;
+      } else if (from.upper.isSame(into.upper)) {
+        into.upperStrict = into.upperStrict || from.upperStrict;
+      }
+    }
+  }
+  function _hasAnyBound(b) {
+    return b.lower !== void 0 || b.upper !== void 0;
+  }
   function getInequalityBoundsFromAssumptions(ce, symbol2) {
     const result = {};
     const assumptions = ce.context?.assumptions;
@@ -5984,8 +6097,8 @@ var ComputeEngine = (() => {
       const isStrict = op === "Less";
       if (isFunction2(lhs, "Negate") && isSymbol2(lhs.op1, symbol2)) {
         const bound = ce.Zero;
-        if (result.lowerBound === void 0 || bound.isGreater(result.lowerBound) === true) {
-          result.lowerBound = bound;
+        if (result.lower === void 0 || bound.isGreater(result.lower) === true) {
+          result.lower = bound;
           result.lowerStrict = isStrict;
         }
       }
@@ -6004,16 +6117,16 @@ var ComputeEngine = (() => {
         }
         if (hasNegatedSymbol && constantSum !== 0) {
           const bound = ce.expr(constantSum);
-          if (result.lowerBound === void 0 || bound.isGreater(result.lowerBound) === true) {
-            result.lowerBound = bound;
+          if (result.lower === void 0 || bound.isGreater(result.lower) === true) {
+            result.lower = bound;
             result.lowerStrict = isStrict;
           }
         }
       }
       if (isSymbol2(lhs, symbol2)) {
         const bound = ce.Zero;
-        if (result.upperBound === void 0 || bound.isLess(result.upperBound) === true) {
-          result.upperBound = bound;
+        if (result.upper === void 0 || bound.isLess(result.upper) === true) {
+          result.upper = bound;
           result.upperStrict = isStrict;
         }
       }
@@ -6032,8 +6145,8 @@ var ComputeEngine = (() => {
         }
         if (hasSymbol && constantSum !== 0) {
           const bound = ce.expr(-constantSum);
-          if (result.upperBound === void 0 || bound.isLess(result.upperBound) === true) {
-            result.upperBound = bound;
+          if (result.upper === void 0 || bound.isLess(result.upper) === true) {
+            result.upper = bound;
             result.upperStrict = isStrict;
           }
         }
@@ -6253,8 +6366,8 @@ var ComputeEngine = (() => {
           const bounds = getInequalityBoundsFromAssumptions(a.engine, b.symbol);
           const aNum = typeof a.numericValue === "number" ? a.numericValue : a.numericValue.re;
           if (aNum !== void 0 && Number.isFinite(aNum)) {
-            if (bounds.lowerBound !== void 0) {
-              const lb = bounds.lowerBound;
+            if (bounds.lower !== void 0) {
+              const lb = bounds.lower;
               const lowerNum = isNumber(lb) ? typeof lb.numericValue === "number" ? lb.numericValue : lb.numericValue.re : void 0;
               if (lowerNum !== void 0 && Number.isFinite(lowerNum)) {
                 if (lowerNum > aNum) return "<";
@@ -6262,8 +6375,8 @@ var ComputeEngine = (() => {
                 if (lowerNum === aNum && !bounds.lowerStrict) return "<=";
               }
             }
-            if (bounds.upperBound !== void 0) {
-              const ub = bounds.upperBound;
+            if (bounds.upper !== void 0) {
+              const ub = bounds.upper;
               const upperNum = isNumber(ub) ? typeof ub.numericValue === "number" ? ub.numericValue : ub.numericValue.re : void 0;
               if (upperNum !== void 0 && Number.isFinite(upperNum)) {
                 if (upperNum < aNum) return ">";
@@ -6293,8 +6406,8 @@ var ComputeEngine = (() => {
     if (typeof b === "number") {
       if (isSymbol2(a)) {
         const bounds = getInequalityBoundsFromAssumptions(a.engine, a.symbol);
-        if (bounds.lowerBound !== void 0) {
-          const lb = bounds.lowerBound;
+        if (bounds.lower !== void 0) {
+          const lb = bounds.lower;
           const lowerNum = isNumber(lb) ? typeof lb.numericValue === "number" ? lb.numericValue : lb.numericValue.re : void 0;
           if (lowerNum !== void 0 && Number.isFinite(lowerNum)) {
             if (lowerNum > b) return ">";
@@ -6302,8 +6415,8 @@ var ComputeEngine = (() => {
             if (lowerNum === b && !bounds.lowerStrict) return ">=";
           }
         }
-        if (bounds.upperBound !== void 0) {
-          const ub = bounds.upperBound;
+        if (bounds.upper !== void 0) {
+          const ub = bounds.upper;
           const upperNum = isNumber(ub) ? typeof ub.numericValue === "number" ? ub.numericValue : ub.numericValue.re : void 0;
           if (upperNum !== void 0 && Number.isFinite(upperNum)) {
             if (upperNum < b) return "<";
@@ -6359,8 +6472,8 @@ var ComputeEngine = (() => {
         const bounds = getInequalityBoundsFromAssumptions(a.engine, a.symbol);
         const bNum = typeof b.numericValue === "number" ? b.numericValue : b.numericValue.re;
         if (bNum !== void 0 && Number.isFinite(bNum)) {
-          if (bounds.lowerBound !== void 0) {
-            const lb = bounds.lowerBound;
+          if (bounds.lower !== void 0) {
+            const lb = bounds.lower;
             const lowerNum = isNumber(lb) ? typeof lb.numericValue === "number" ? lb.numericValue : lb.numericValue.re : void 0;
             if (lowerNum !== void 0 && Number.isFinite(lowerNum)) {
               if (lowerNum > bNum) return ">";
@@ -6368,8 +6481,8 @@ var ComputeEngine = (() => {
               if (lowerNum === bNum && !bounds.lowerStrict) return ">=";
             }
           }
-          if (bounds.upperBound !== void 0) {
-            const ub = bounds.upperBound;
+          if (bounds.upper !== void 0) {
+            const ub = bounds.upper;
             const upperNum = isNumber(ub) ? typeof ub.numericValue === "number" ? ub.numericValue : ub.numericValue.re : void 0;
             if (upperNum !== void 0 && Number.isFinite(upperNum)) {
               if (upperNum < bNum) return "<";
@@ -6907,6 +7020,12 @@ var ComputeEngine = (() => {
     scoped = false;
     signature;
     inferredSignature = true;
+    /** True if this operator definition was created from a user-defined
+     * function literal (e.g. via `ce.assign('f', ce.parse('x \\mapsto x^2'))`).
+     * Used to enable auto-broadcasting when applied to indexed collections.
+     * @internal
+     */
+    _isLambda = false;
     type;
     sgn;
     eq;
@@ -7064,6 +7183,8 @@ var ComputeEngine = (() => {
             this.engine._typeResolver
           );
         }
+        if (isFunction2(boxedFn) && boxedFn.operator === "Function")
+          this._isLambda = true;
         const fn = applicable(boxedFn);
         evaluate2 = (xs, _options) => fn(xs);
         Object.defineProperty(evaluate2, "toString", {
@@ -7914,8 +8035,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
@@ -8373,6 +8501,29 @@ var ComputeEngine = (() => {
     get isReal() {
       return void 0;
     }
+    toSignedFunction() {
+      const op = this.operator;
+      if (op === void 0 || this.ops === void 0 || this.ops.length < 2) {
+        return void 0;
+      }
+      const [lhs, rhs] = this.ops;
+      const engine = this.engine;
+      switch (op) {
+        case "Equal":
+        case "NotEqual":
+        case "Less":
+        case "LessEqual":
+          return engine.function("Subtract", [lhs, rhs]);
+        case "Greater":
+        case "GreaterEqual":
+          return engine.function("Subtract", [rhs, lhs]);
+        default:
+          return void 0;
+      }
+    }
+    getInterval(symbol2) {
+      return extractIntervalBounds(this, symbol2);
+    }
     simplify(_options) {
       return this;
     }
@@ -10058,6 +10209,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"];
@@ -10333,15 +10542,16 @@ var ComputeEngine = (() => {
       precedence: ASSIGNMENT_PRECEDENCE,
       parse: parseAssign
     },
-    // General colon operator (type annotation, mapping notation)
-    // Precedence below assignment (260) so `:=` takes priority,
-    // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
+    // General colon operator (type annotation, mapping notation, Desmos piecewise)
+    // Precedence below comparisons (245) so `cond : val` (Desmos compact piecewise)
+    // parses as `Colon(cond, val)`, and below arrows (270) so
+    // `f: A \to B` parses as `Colon(f, To(A, B))`.
     {
       name: "Colon",
       latexTrigger: ":",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       serialize: (serializer, expr2) => joinLatex([
         serializer.serialize(operand(expr2, 1)),
         "\\colon",
@@ -10352,7 +10562,7 @@ var ComputeEngine = (() => {
       latexTrigger: "\\colon",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       parse: "Colon"
     },
     {
@@ -10529,6 +10739,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 +10768,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 +10873,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 +11080,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 +11109,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 +11162,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 +11378,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 +11822,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 +11840,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 +12122,38 @@ 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;
+        if (isComma) return true;
+        if (peekKeyword(p, "where")) return true;
+        if (peekKeyword(p, "with")) return true;
+        return false;
+      }
+    };
+    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,
@@ -11809,6 +12176,25 @@ var ComputeEngine = (() => {
       parser.skipVisualSpace();
     } while (parser.match(","));
     if (bindings.length === 0) return null;
+    const forStart = parser.index;
+    if (matchKeyword(parser, "for")) {
+      const loop = parseForComprehension(parser, lhs, until);
+      if (loop) {
+        const block2 = [];
+        for (const b of bindings) {
+          const normalized = normalizeLocalAssign(b);
+          if (operator(normalized) === "Assign") {
+            block2.push(["Declare", operand(normalized, 1)]);
+            block2.push(normalized);
+          } else {
+            block2.push(normalized);
+          }
+        }
+        block2.push(loop);
+        return ["Block", ...block2];
+      }
+      parser.index = forStart;
+    }
     const block = [];
     for (const b of bindings) {
       const normalized = normalizeLocalAssign(b);
@@ -12022,6 +12408,17 @@ var ComputeEngine = (() => {
     const upperExpr = openRight ? ["Open", upper] : upper;
     return ["Interval", lowerExpr, upperExpr];
   }
+  var COMPARISON_HEADS = /* @__PURE__ */ new Set([
+    "Less",
+    "LessEqual",
+    "Greater",
+    "GreaterEqual",
+    "Equal",
+    "NotEqual",
+    "And",
+    "Or",
+    "Not"
+  ]);
   var DEFINITIONS_SETS = [
     //
     // Constants
@@ -12280,18 +12677,58 @@ var ComputeEngine = (() => {
       closeTrigger: "}",
       parse: (_parser, body) => {
         if (isEmptySequence(body)) return "EmptySet";
+        if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
+          body = operand(body, 1);
+        }
         const h = operator(body);
-        if (h === "Divides" || h === "Colon") {
+        if (h === "Divides") {
           const expr2 = operand(body, 1);
           const condition = operand(body, 2);
           if (expr2 !== null && condition !== null)
             return ["Set", expr2, ["Condition", condition]];
         }
-        if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
-          body = operand(body, 1);
+        if (h === "Colon") {
+          const lhs = operand(body, 1);
+          const rhs = operand(body, 2);
+          if (lhs !== null && rhs !== null) {
+            const lhsOp = operator(lhs);
+            if (lhsOp !== null && COMPARISON_HEADS.has(lhsOp)) {
+              return ["Which", lhs, rhs];
+            }
+            return ["Set", lhs, ["Condition", rhs]];
+          }
         }
-        if (operator(body) !== "Sequence") return ["Set", body];
-        return ["Set", ...operands(body)];
+        if (h === "Sequence") {
+          const elements = operands(body);
+          const colonElements = elements.filter((el) => operator(el) === "Colon");
+          const allPiecewise = colonElements.length > 0 && colonElements.every((el) => {
+            const lhs = operand(el, 1);
+            const lhsOp = lhs !== null ? operator(lhs) : null;
+            return lhsOp !== null && COMPARISON_HEADS.has(lhsOp);
+          });
+          if (allPiecewise) {
+            const whichOps = [];
+            for (let i = 0; i < elements.length; i++) {
+              const el = elements[i];
+              if (operator(el) === "Colon") {
+                const cond = operand(el, 1);
+                const val = operand(el, 2);
+                if (cond === null || val === null) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push(cond, val);
+              } else {
+                if (i !== elements.length - 1) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push("True", el);
+              }
+            }
+            return ["Which", ...whichOps];
+          }
+          return ["Set", ...elements];
+        }
+        return ["Set", body];
       },
       serialize: (serializer, expr2) => {
         if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
@@ -14295,7 +14732,8 @@ var ComputeEngine = (() => {
         minPrec: MULTIPLICATION_PRECEDENCE,
         condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
       });
-      const appliedFn = args === null ? fn : typeof fn === "string" ? [fn, ...args] : ["Apply", fn, ...args];
+      const head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+      const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
       return sup === null ? appliedFn : ["Power", appliedFn, sup];
     };
   }
@@ -16511,10 +16949,17 @@ var ComputeEngine = (() => {
     // The capitalized library entries already exist; these are pure parse
     // aliases so the lowercase names don't land in `unsupported-operator`.
     // ---------------------------------------------------------------------------
+    { latexTrigger: "\\operatorname{count}", parse: "Length" },
     { latexTrigger: "\\operatorname{random}", parse: "Random" },
     { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
     { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
     { latexTrigger: "\\operatorname{join}", parse: "Join" },
+    { latexTrigger: "\\operatorname{range}", parse: "Range" },
+    // Note: `\operatorname{with}` (Desmos's local-binding clause) is intentionally
+    // NOT registered here. Use the math-notation equivalent `\operatorname{where}`
+    // (with `\coloneq` for bindings), or register `with` as a custom dictionary
+    // entry at the integration layer — see the "Desmos-Specific Syntax — Prefer
+    // Custom LaTeX Dictionary" section in COMPUTE_ENGINE.md for a worked example.
     // ---------------------------------------------------------------------------
     // Geometric primitive heads. Registered as known typed heads so consumers
     // can branch on the operator name; CE itself doesn't render them. The
@@ -19558,6 +20003,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 +20524,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 +20589,7 @@ var ComputeEngine = (() => {
     constructor(dictionary, options) {
       this.dictionary = dictionary;
       this.options = {
+        dotNotation: false,
         dmsFormat: false,
         angleNormalization: "none",
         ...options
@@ -20207,6 +20688,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 +20932,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 +20966,7 @@ var ComputeEngine = (() => {
       invisiblePlus: "",
       multiply: "\\times",
       missingSymbol: "\\blacksquare",
+      dotNotation: false,
       dmsFormat: false,
       angleNormalization: "none",
       // Style callbacks -- use same defaults as the engine
@@ -22315,6 +22801,15 @@ var ComputeEngine = (() => {
         }
       } else {
         for (const item of t) {
+          const op = item.operator;
+          if (op === "Tuple" || op === "Pair" || op === "Single" || op === "Triple" || op === "Quadruple" || op === "KeyValuePair" || op === "Dictionary" || op === "Set" || op === "Record") {
+            valid = false;
+            return;
+          }
+          if (item.type.type === "string") {
+            valid = false;
+            return;
+          }
           dtype = getSupertype(dtype, getExpressionDatatype(item));
         }
       }
@@ -27350,6 +27845,15 @@ ${lines.join("\n")}`;
     return void 0;
   }
 
+  // src/compute-engine/numerics/random.ts
+  function deterministicRandom(seed) {
+    const v = Math.sin(seed * 12.9898) * 43758.5453;
+    return v - Math.floor(v);
+  }
+  function nextSeed(seed) {
+    return seed + 0.6180339887498949;
+  }
+
   // src/compute-engine/boxed-expression/canonical-utils.ts
   function canonical(ce, xs, scope) {
     if (xs.every((x) => x.isCanonical)) return xs;
@@ -27399,6 +27903,19 @@ ${lines.join("\n")}`;
         indexWhere: void 0
       }
     },
+    Length: {
+      description: "Number of elements in a collection. Returns undefined for non-collections and for infinite collections.",
+      complexity: 4e3,
+      signature: "(any) -> integer",
+      type: () => "integer",
+      evaluate: ([xs], { engine }) => {
+        if (!xs.isCollection) return void 0;
+        if (xs.isEmptyCollection) return engine.Zero;
+        const n = xs.count;
+        if (n === void 0 || !isFinite(n)) return void 0;
+        return engine.number(n);
+      }
+    },
     Tuple: {
       description: "A fixed number of heterogeneous elements",
       complexity: 8200,
@@ -27451,7 +27968,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 +27996,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 +28033,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 +28060,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: {
@@ -27633,10 +28169,12 @@ ${lines.join("\n")}`;
           const upper = expr2.op2.re;
           let count = expr2.op3.re;
           if (!isFinite(count)) count = DEFAULT_LINSPACE_COUNT;
+          count = Math.floor(count);
           if (!isFinite(lower) || !isFinite(upper)) return void 0;
           if (index < 1 || index > count) return void 0;
+          if (count === 1) return expr2.engine.number(lower);
           return expr2.engine.number(
-            lower + (upper - lower) * (index - 1) / count
+            lower + (upper - lower) * (index - 1) / (count - 1)
           );
         },
         iterator: (expr2) => {
@@ -27655,6 +28193,8 @@ ${lines.join("\n")}`;
               !isFinite(expr2.op3.re) ? DEFAULT_LINSPACE_COUNT : expr2.op3.re
             );
           }
+          totalCount = Math.floor(totalCount);
+          const denom = totalCount > 1 ? totalCount - 1 : 1;
           let index = 1;
           return {
             next: () => {
@@ -27663,7 +28203,7 @@ ${lines.join("\n")}`;
               index += 1;
               return {
                 value: expr2.engine.number(
-                  lower + (upper - lower) * (index - 1 - 1) / totalCount
+                  lower + (upper - lower) * (index - 1 - 1) / denom
                 ),
                 done: false
               };
@@ -27679,9 +28219,14 @@ ${lines.join("\n")}`;
           if (t < lower || t > upper) return false;
           let count = expr2.op3.re;
           if (!isFinite(count)) count = DEFAULT_LINSPACE_COUNT;
+          count = Math.floor(count);
           if (count === 0) return false;
-          const step = (upper - lower) / count;
-          return (t - lower) % step === 0;
+          if (count === 1) return t === lower;
+          const step = (upper - lower) / (count - 1);
+          const k = (t - lower) / step;
+          const tol = expr2.engine.tolerance;
+          const kRounded = Math.round(k);
+          return kRounded >= 0 && kRounded <= count - 1 && Math.abs(k - kRounded) < tol;
         }
       }
     },
@@ -28006,10 +28551,12 @@ ${lines.join("\n")}`;
       description: [
         "Access an element of an indexed collection.",
         "If the index is negative, it is counted from the end.",
-        "Multiple indices can be provided to access nested collections (e.g., matrices)."
+        "Multiple indices can be provided to access nested collections (e.g., matrices).",
+        "If the index is a finite collection of booleans, returns the elements where the mask is True.",
+        "If the index is a finite collection of integers, returns the elements at those indices."
       ],
       complexity: 8200,
-      signature: "(value: indexed_collection, index: (number|string)+) -> unknown",
+      signature: "(value: indexed_collection, index: (number|string|indexed_collection)+) -> unknown",
       type: ([xs]) => xs.operatorDefinition?.collection?.elttype?.(xs) ?? collectionElementType(xs.type.type) ?? "any",
       evaluate: (ops, { engine: ce }) => {
         let expr2 = ops[0];
@@ -28020,12 +28567,39 @@ ${lines.join("\n")}`;
           if (!at) return void 0;
           const opAtIndex = ops[index];
           const s = isString(opAtIndex) ? opAtIndex.string : void 0;
-          if (s !== void 0) expr2 = at(expr2, s) ?? ce.Nothing;
-          else {
-            const i = ops[index].re;
-            if (!Number.isInteger(i)) return void 0;
-            expr2 = at(expr2, i) ?? ce.Nothing;
+          if (s !== void 0) {
+            expr2 = at(expr2, s) ?? ce.Nothing;
+            index += 1;
+            continue;
           }
+          if (opAtIndex.isCollection && opAtIndex.isFiniteCollection) {
+            const indices = Array.from(opAtIndex.each());
+            const isMask = indices.every((m) => {
+              const name = sym(m);
+              return name === "True" || name === "False";
+            });
+            const picked = [];
+            if (isMask) {
+              indices.forEach((m, i2) => {
+                if (sym(m) !== "True") return;
+                const v = at(expr2, i2 + 1);
+                if (v !== void 0) picked.push(v);
+              });
+            } else {
+              for (const m of indices) {
+                const k = m.re;
+                if (!Number.isInteger(k)) return void 0;
+                const v = at(expr2, k);
+                if (v !== void 0) picked.push(v);
+              }
+            }
+            expr2 = ce._fn("List", picked);
+            index += 1;
+            continue;
+          }
+          const i = opAtIndex.re;
+          if (!Number.isInteger(i)) return void 0;
+          expr2 = at(expr2, i) ?? ce.Nothing;
           index += 1;
         }
         return expr2;
@@ -28036,7 +28610,7 @@ ${lines.join("\n")}`;
       description: ["Return `n` elements from a collection."],
       complexity: 8200,
       signature: "(xs: indexed_collection, count: number) -> indexed_collection",
-      type: ([xs]) => `list<${collectionElementType(xs.type.type)}>`,
+      type: ([xs]) => `list<${typeToString(collectionElementType(xs.type.type) ?? "any")}>`,
       evaluate: (ops, { engine, materialization: eager }) => {
         if (!eager) return void 0;
         const takeExpr = engine._fn("Take", ops);
@@ -28083,7 +28657,7 @@ ${lines.join("\n")}`;
       description: ["Return the collection without the first n elements."],
       complexity: 8200,
       signature: "(xs: indexed_collection, count: number) -> indexed_collection",
-      type: ([xs]) => `list<${collectionElementType(xs.type.type)}>`,
+      type: ([xs]) => `list<${typeToString(collectionElementType(xs.type.type) ?? "any")}>`,
       collection: {
         isLazy: (_expr) => true,
         count: (expr2) => {
@@ -28128,15 +28702,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 }) => xs.at(2) ?? ce.Nothing
+      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 }) => {
+        if (!xs.isCollection)
+          return ce.error([
+            "incompatible-type",
+            `'collection'`,
+            xs.type.toString()
+          ]);
+        return xs.at(3) ?? ce.Nothing;
+      }
     },
     Last: {
       complexity: 8200,
@@ -28249,7 +28853,9 @@ ${lines.join("\n")}`;
       ],
       complexity: 8200,
       signature: "(value: indexed_collection, start: number, end: number) -> list",
-      type: ([xs]) => parseType(`list<${collectionElementType(xs.type.type)}>`),
+      type: ([xs]) => parseType(
+        `list<${typeToString(collectionElementType(xs.type.type) ?? "any")}>`
+      ),
       collection: {
         isLazy: (_expr) => true,
         count: (expr2) => {
@@ -28581,16 +29187,26 @@ ${lines.join("\n")}`;
     },
     // Randomize the order of the elements in the collection.
     Shuffle: {
-      description: "Randomize the order of the elements in the collection.",
+      description: "Randomize the order of the elements in the collection. With an optional `seed` argument, the shuffle is deterministic.",
       complexity: 8200,
-      signature: "(indexed_collection) -> indexed_collection",
+      signature: "(indexed_collection, real?) -> indexed_collection",
       type: (ops) => ops[0].type,
-      evaluate: ([xs], { engine: ce }) => {
+      evaluate: ([xs, seedOp], { engine: ce }) => {
         if (!xs.isFiniteCollection) return void 0;
         const data = Array.from(xs.each());
-        for (let i = data.length - 1; i > 0; i--) {
-          const j = Math.floor(Math.random() * (i + 1));
-          [data[i], data[j]] = [data[j], data[i]];
+        const seed = seedOp?.re;
+        if (seed !== void 0 && !Number.isNaN(seed)) {
+          let s = seed;
+          for (let i = data.length - 1; i > 0; i--) {
+            const j = Math.floor(deterministicRandom(s) * (i + 1));
+            [data[i], data[j]] = [data[j], data[i]];
+            s = nextSeed(s);
+          }
+        } else {
+          for (let i = data.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [data[i], data[j]] = [data[j], data[i]];
+          }
         }
         return ce.function(xs.operator, data);
       }
@@ -28657,7 +29273,9 @@ ${lines.join("\n")}`;
         if (t === "string")
           return parseType(`tuple<list<string>, list<integer>>`);
         return parseType(
-          `tuple<list<${collectionElementType(t)}>, list<integer>>`
+          `tuple<list<${typeToString(
+            collectionElementType(t) ?? "any"
+          )}>, list<integer>>`
         );
       },
       evaluate: (ops, { engine: ce }) => {
@@ -28673,7 +29291,7 @@ ${lines.join("\n")}`;
       description: "Return a list of the unique elements of the collection.",
       complexity: 8200,
       signature: "(collection) -> list",
-      type: ([xs]) => `list<${collectionElementType(xs.type.type)}>`,
+      type: ([xs]) => `list<${typeToString(collectionElementType(xs.type.type) ?? "any")}>`,
       evaluate: (ops, { engine: ce }) => {
         if (!ops[0].isFiniteCollection) return void 0;
         const [values, _counts] = tally(ops[0]);
@@ -28685,7 +29303,7 @@ ${lines.join("\n")}`;
       wikidata: "Q381060",
       complexity: 8200,
       signature: "(collection, integer | function) -> list",
-      type: ([xs]) => `list<${collectionElementType(xs.type.type)}>`,
+      type: ([xs]) => `list<${typeToString(collectionElementType(xs.type.type) ?? "any")}>`,
       evaluate: ([xs, arg], { engine: ce }) => {
         if (!xs.isFiniteCollection) return void 0;
         const k = toInteger(arg);
@@ -28859,32 +29477,74 @@ ${lines.join("\n")}`;
         }
       }
     },
-    // Repeat(x) -> [x, x, ...]
-    // This is an infinite series. Can use Take(Repeat(x), n) to get a finite series
-    // x is evaluated once. Although could use Hold()?
-    // So that First(Repeat(Hold(Random(5))), 10) would return 10 random numbers...
+    // Repeat(x) -> [x, x, ...]        — infinite sequence
+    // Repeat(x, n) -> [x, x, ..., x]  — finite list of n copies
     Repeat: {
-      description: "Produce an infinite sequence by repeating a single value.",
+      description: "Produce a sequence by repeating a single value. With 1 argument, returns an infinite sequence; with 2 arguments (value, count), returns a finite list of `count` copies.",
       complexity: 8200,
-      signature: "(value: any) -> list",
+      signature: "(value: any, count: integer?) -> list",
+      evaluate: (ops, { engine }) => {
+        if (ops.length !== 2) return void 0;
+        const raw = toInteger(ops[1]);
+        if (raw === null) return void 0;
+        const n = Math.max(0, raw);
+        if (n > engine.maxCollectionSize) return void 0;
+        return engine._fn("List", Array(n).fill(ops[0]));
+      },
       collection: {
-        isLazy: (_expr) => true,
-        count: () => Infinity,
-        isEmpty: (_expr) => false,
-        // Never empty
-        isFinite: () => false,
-        // Infinite collection
+        isLazy: (expr2) => isFunction2(expr2) && expr2.ops?.length === 1,
+        count: (expr2) => {
+          if (!isFunction2(expr2)) return void 0;
+          if (expr2.ops?.length === 2) {
+            const n = toInteger(expr2.op2);
+            return n !== null ? Math.max(0, n) : void 0;
+          }
+          return Infinity;
+        },
+        isEmpty: (expr2) => {
+          if (!isFunction2(expr2)) return void 0;
+          if (expr2.ops?.length === 2) {
+            const n = toInteger(expr2.op2);
+            return n !== null ? n <= 0 : void 0;
+          }
+          return false;
+        },
+        isFinite: (expr2) => isFunction2(expr2) && expr2.ops?.length === 2,
         contains: (expr2, target) => {
           if (!isFunction2(expr2)) return false;
+          if (expr2.ops?.length === 2) {
+            const n = toInteger(expr2.op2);
+            if (n !== null && n <= 0) return false;
+          }
           return expr2.op1.isSame(target);
         },
         iterator: (expr2) => {
           if (!isFunction2(expr2))
             return { next: () => ({ value: void 0, done: true }) };
+          if (expr2.ops?.length === 2) {
+            const n = toInteger(expr2.op2);
+            if (n === null) {
+              return { next: () => ({ value: void 0, done: true }) };
+            }
+            const count = Math.max(0, n);
+            let i = 0;
+            return {
+              next: () => i++ < count ? { value: expr2.op1, done: false } : { value: void 0, done: true }
+            };
+          }
           return { next: () => ({ value: expr2.op1, done: false }) };
         },
-        at: (expr2, _index) => {
+        // at is 1-based (consistent with Range, Take, and other collection handlers)
+        at: (expr2, index) => {
           if (!isFunction2(expr2)) return void 0;
+          if (typeof index !== "number") return void 0;
+          if (expr2.ops?.length === 2) {
+            const n = toInteger(expr2.op2);
+            const count = n !== null ? Math.max(0, n) : 0;
+            if (index < 1 || index > count) return void 0;
+          } else {
+            if (index < 1) return void 0;
+          }
           return expr2.op1;
         }
       }
@@ -29115,17 +29775,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;
@@ -31173,11 +31830,12 @@ ${lines.join("\n")}`;
           );
         }
       },
-      // Complex: {
-      //   // This function is converted during boxing, so unlikely to encounter
-      //   wikidata: 'Q11567',
-      //   complexity: 500,
-      // },
+      Complex: {
+        description: 'Construct a complex number from real and imaginary parts. Converted directly to a BoxedNumber during boxing; this entry exists so `operatorInfo("Complex")` returns a signature.',
+        wikidata: "Q11567",
+        complexity: 500,
+        signature: "(real: number, imaginary: number) -> complex"
+      },
       Divide: {
         description: "Quotient of a numerator and one or more denominators.",
         wikidata: "Q1226939",
@@ -32527,48 +33185,83 @@ ${lines.join("\n")}`;
         }
       },
       Sum: {
-        description: "`Sum(f, [a, b])` computes the sum of `f` from `a` to `b`",
+        description: "`Sum(f, [a, b])` computes the sum of `f` from `a` to `b`; `Sum(L)` sums the elements of a collection `L`",
         wikidata: "Q218005",
         complexity: 1e3,
         broadcastable: false,
         scoped: true,
         lazy: true,
-        signature: "((number) -> number, bounds:tuple+) -> number",
-        canonical: ([body, ...bounds], { scope }) => canonicalBigop("Sum", body, bounds, scope),
-        evaluate: ([body, ...indexes], { engine, numericApproximation: numericApproximation2 }) => {
+        signature: "(any, tuple*) -> number",
+        canonical: ([body, ...bounds], { scope, engine: ce }) => {
+          if (bounds.length === 0) {
+            const canon = body?.canonical;
+            if (canon?.isCollection) return ce._fn("Sum", [canon]);
+          }
+          return canonicalBigop("Sum", body, bounds, scope);
+        },
+        evaluate: ([first, ...rest], { engine, numericApproximation: numericApproximation2 }) => {
+          if (rest.length === 0 && first?.isCollection) {
+            if (first.isFiniteCollection !== true) return void 0;
+            const result2 = run(
+              reduceCollection2(
+                first,
+                engine.Zero,
+                (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 }))
+              ),
+              engine._timeRemaining
+            );
+            return result2?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
+          }
           const result = run(
             reduceBigOp(
-              body,
-              indexes,
+              first,
+              rest,
               (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 })),
               engine.Zero
             ),
             engine._timeRemaining
           );
-          if (result === NON_ENUMERABLE_DOMAIN) {
-            return void 0;
-          }
+          if (result === NON_ENUMERABLE_DOMAIN) return void 0;
           return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
         },
-        evaluateAsync: async (xs, { engine, signal, numericApproximation: numericApproximation2 }) => {
+        evaluateAsync: async ([first, ...rest], { engine, signal, numericApproximation: numericApproximation2 }) => {
+          if (rest.length === 0 && first?.isCollection) {
+            if (first.isFiniteCollection !== true) return void 0;
+            const result2 = await runAsync(
+              reduceCollection2(
+                first,
+                engine.Zero,
+                (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 }))
+              ),
+              engine._timeRemaining,
+              signal
+            );
+            return result2?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
+          }
           const result = await runAsync(
             reduceBigOp(
-              xs[0],
-              xs.slice(1),
+              first,
+              rest,
               (acc, x) => acc.add(x.evaluate({ numericApproximation: numericApproximation2 })),
               engine.Zero
             ),
             engine._timeRemaining,
             signal
           );
-          if (result === NON_ENUMERABLE_DOMAIN) {
-            return void 0;
-          }
+          if (result === NON_ENUMERABLE_DOMAIN) return void 0;
           return result?.evaluate({ numericApproximation: numericApproximation2 }) ?? engine.NaN;
         }
       }
     }
   ];
+  function* reduceCollection2(collection, init, combine) {
+    let acc = init;
+    for (const x of collection.each()) {
+      acc = combine(acc, x);
+      yield acc;
+    }
+    return acc;
+  }
   function evaluateAbs(arg) {
     const ce = arg.engine;
     if (isNumber(arg)) {
@@ -42805,7 +43498,7 @@ ${e.message}
   var CONTROL_STRUCTURES_LIBRARY = [
     {
       Block: {
-        description: "Evaluate a sequence of expressions in a local scope.",
+        description: "Evaluate a sequence of expressions in a local scope, **sequentially**. Each operand is evaluated in order; later operands observe side effects (`Assign`, `Declare`) of earlier operands. The block's value is the value of the last expression. Short-circuiting heads (`Return`, `Break`, `Continue`) terminate the sequence early.\n\nIMPORTANT \u2014 consumers translating *simultaneous* action tuples (e.g. Desmos `(a \u2192 1, b \u2192 a + 1)` where `b` reads the *pre-action* `a`) must rewrite to a snapshot-then-commit Block: bind each RHS to a fresh temp first, then assign the temps to the LHS symbols. See `docs/architecture/actions-and-randomness.md` for the canonical recipe.",
         lazy: true,
         scoped: true,
         signature: "(unknown*) -> unknown",
@@ -42855,12 +43548,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, 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: "(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/restriction value. `When(e, cond)` evaluates to:\n  - `e` when `cond` evaluates to `True`\n  - `Undefined` when `cond` evaluates to `False` (the "masking rule"; consumers like 2D plotters skip masked points)\n  - `When(e, cond_simplified)` when `cond` is indeterminate (holds)\nStacked restrictions canonicalize: `When(When(e, c1), c2)` \u2192 `When(e, And(c1, c2))`.\nCompiles to ternary `(cond) ? (e) : NaN` in JS and GLSL.',
+        lazy: true,
+        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 +43643,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);
@@ -44564,7 +45419,7 @@ ${e.message}
         evaluate: (ops) => apply(ops[0], ops.slice(1))
       },
       Assign: {
-        description: "Assign a value to a symbol or define a sequence",
+        description: "Assign a value to a symbol or define a sequence. The RHS is evaluated immediately and `ce.assign(name, val)` mutates the binding in the current scope chain. When used inside a `Block`, the assignment is visible to subsequent statements in the block (sequential semantics).",
         lazy: true,
         pure: false,
         signature: "(symbol | expression, any) -> any",
@@ -44695,7 +45550,12 @@ ${e.message}
         evaluate: (ops, { engine: ce }) => {
           const symbolName2 = sym(ops[0].evaluate());
           if (!symbolName2) return void 0;
+          const currentScope = ce.context.lexicalScope;
+          const existing = currentScope.bindings.get(symbolName2);
+          const existingValueDef = existing && isValueDef(existing) ? existing : void 0;
+          const isAutoDeclareHere = !!existingValueDef && existingValueDef.value.inferredType && existingValueDef.value.value === void 0;
           if (!ops[1]) {
+            if (isAutoDeclareHere) return ce.Nothing;
             ce.declare(symbolName2, { inferred: true, type: "unknown" });
             return ce.Nothing;
           }
@@ -44704,6 +45564,11 @@ ${e.message}
             (isString(t) ? t.string : void 0) ?? sym(t) ?? void 0
           );
           if (!isValidType(type2)) return void 0;
+          if (isAutoDeclareHere && existingValueDef) {
+            existingValueDef.value.type = ce.type(type2);
+            existingValueDef.value.inferredType = false;
+            return ce.Nothing;
+          }
           ce.declare(symbolName2, type2);
           return ce.Nothing;
         }
@@ -44821,33 +45686,41 @@ ${e.message}
       },
       Random: {
         description: [
-          "Random(): Return a random number between 0 and 1",
-          "Random(n): Return a random integer between 0 and n-1",
-          "Random(m, n): Return a random integer between m and n-1"
+          "Random(): non-deterministic float in [0, 1)",
+          "Random(seed: real): deterministic float in [0, 1) from a real seed",
+          "Random(n: integer): non-deterministic integer in [0, n)",
+          "Random(m: integer, n: integer): non-deterministic integer in [m, n)"
         ],
         pure: false,
-        signature: "(lower:integer?, upper:integer?) -> finite_number",
-        type: ([lower, upper]) => {
-          if (lower === void 0 && upper === void 0) return "finite_number";
-          return "finite_integer";
+        // Signature accepts: nothing, one number, or two integers.
+        // Use `number` (not `integer`) for the single-arg case so float seeds
+        // type-check; runtime dispatch differentiates integer vs real.
+        signature: "(number?, integer?) -> finite_number",
+        type: ([first, second]) => {
+          if (first === void 0) return "finite_number";
+          if (second !== void 0) return "finite_integer";
+          if (first.type.matches("integer")) return "finite_integer";
+          return "finite_number";
         },
         sgn: () => "non-negative",
         evaluate: (ops, { engine: ce }) => {
           if (ops.length === 0) return ce.number(Math.random());
-          const [lowerOp, upperOp] = ops;
-          let lower;
-          let upper;
-          if (upperOp === void 0) {
-            lower = 0;
-            upper = Math.floor(lowerOp.re - 1);
-            if (isNaN(upper)) upper = 0;
-          } else {
-            lower = Math.floor(lowerOp.re);
-            upper = Math.floor(upperOp.re);
+          const [firstOp, secondOp] = ops;
+          if (secondOp !== void 0) {
+            let lower = Math.floor(firstOp.re);
+            let upper = Math.floor(secondOp.re);
             if (isNaN(lower)) lower = 0;
             if (isNaN(upper)) upper = 0;
+            return ce.number(lower + Math.floor(Math.random() * (upper - lower)));
+          }
+          if (firstOp.type.matches("integer")) {
+            let n = Math.floor(firstOp.re);
+            if (isNaN(n)) n = 0;
+            return ce.number(Math.floor(Math.random() * n));
           }
-          return ce.number(lower + Math.floor(Math.random() * (upper - lower)));
+          const seed = firstOp.re;
+          if (isNaN(seed)) return ce.number(0);
+          return ce.number(deterministicRandom(seed));
         }
       },
       // @todo: need review
@@ -45303,6 +46176,14 @@ ${e.message}
       To: {
         description: "Action arrow / mapping (`a \\to b`) \u2014 opaque typed head.",
         signature: "(any, any) -> nothing"
+      },
+      Colon: {
+        description: "Type annotation (`a : b`) \u2014 opaque typed head.",
+        signature: "(any, any) -> expression"
+      },
+      Prime: {
+        description: "Derivative or prime notation (`f'`, `f^{(n)}`) \u2014 opaque typed head until a derivative library handler runs.",
+        signature: "(any, integer?) -> expression"
       }
     }
   ];
@@ -50343,18 +51224,28 @@ ${e.message}
     },
     {
       Sample: {
-        description: "Return a random sample of k elements from the collection, without replacement.",
+        description: "Return a random sample of k elements from the collection, without replacement. With an optional `seed` argument, the sample is deterministic.",
         complexity: 8200,
-        signature: "(collection, integer) -> list",
-        evaluate: ([xs, nArg], { engine: ce }) => {
+        signature: "(collection, integer, real?) -> list",
+        evaluate: ([xs, nArg, seedArg], { engine: ce }) => {
           if (!xs.isFiniteCollection) return void 0;
           const k = toInteger(nArg);
           if (k === null || k < 0) return void 0;
           const data = Array.from(xs.each());
           if (k > data.length) return void 0;
-          for (let i = data.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [data[i], data[j]] = [data[j], data[i]];
+          const seed = seedArg?.re;
+          if (seed !== void 0 && !Number.isNaN(seed)) {
+            let s = seed;
+            for (let i = data.length - 1; i > 0; i--) {
+              const j = Math.floor(deterministicRandom(s) * (i + 1));
+              [data[i], data[j]] = [data[j], data[i]];
+              s = nextSeed(s);
+            }
+          } else {
+            for (let i = data.length - 1; i > 0; i--) {
+              const j = Math.floor(Math.random() * (i + 1));
+              [data[i], data[j]] = [data[j], data[i]];
+            }
           }
           const sample = data.slice(0, k);
           return ce.function("List", sample);
@@ -53175,6 +54066,20 @@ Error in definition of "${name}"`,
           if (results.length === 1) return results[0];
           return this.engine._fn("List", results);
         }
+        if (def instanceof _BoxedOperatorDefinition && def._isLambda && this.ops.some((x) => isFiniteIndexedCollection(x)) && paramsAreScalar(def)) {
+          const items = zip(this._ops);
+          if (items) {
+            const results = [];
+            while (true) {
+              const { done, value } = items.next();
+              if (done) break;
+              results.push(
+                this.engine._fn(this.operator, value).evaluate(options)
+              );
+            }
+            return this.engine._fn("List", results);
+          }
+        }
         if (materialization !== false && !def.evaluate && this.isLazyCollection)
           return materialize(this, def, options);
         const tail = holdMap(this, (x) => x.evaluate(options));
@@ -53221,6 +54126,22 @@ Error in definition of "${name}"`,
             (resolved) => this.engine._fn("List", resolved)
           );
         }
+        if (def instanceof _BoxedOperatorDefinition && def._isLambda && this.ops.some((x) => isFiniteIndexedCollection(x)) && paramsAreScalar(def)) {
+          const items = zip(this._ops);
+          if (items) {
+            const results = [];
+            while (true) {
+              const { done, value } = items.next();
+              if (done) break;
+              results.push(
+                this.engine._fn(this.operator, value).evaluateAsync(options)
+              );
+            }
+            return Promise.all(results).then(
+              (resolved) => this.engine._fn("List", resolved)
+            );
+          }
+        }
         const tail = await holdMapAsync(
           this,
           async (x) => await x.evaluateAsync(options)
@@ -53435,8 +54356,47 @@ Error in definition of "${name}"`,
     const ops = expr2.ops.map((x) => x.evaluate(options));
     if (!value || value.type.isUnknown)
       return expr2.engine.function(expr2.operator, ops);
+    if (ops.some((x) => isFiniteIndexedCollection(x)) && paramsAreScalar(value.type.type)) {
+      const items = zip(ops);
+      if (items) {
+        const results = [];
+        while (true) {
+          const { done, value: zipped } = items.next();
+          if (done) break;
+          results.push(apply(value, zipped).evaluate(options));
+        }
+        return expr2.engine._fn("List", results);
+      }
+    }
     return apply(value, ops);
   }
+  function paramsAreScalar(source) {
+    const sigType = isOperatorDefinition(source) ? source.signature?.type : source;
+    if (!sigType || typeof sigType === "string") return true;
+    if (sigType.kind !== "signature") return true;
+    const args = [
+      ...sigType.args ?? [],
+      ...sigType.optArgs ?? [],
+      ...sigType.variadicArg ? [sigType.variadicArg] : []
+    ];
+    return args.every((arg) => isScalarType(arg.type));
+  }
+  function isOperatorDefinition(source) {
+    return typeof source === "object" && source !== null && "signature" in source;
+  }
+  function isScalarType(t) {
+    if (typeof t === "string") {
+      if (t === "collection" || t === "indexed_collection" || t === "list" || t === "tuple" || t === "set" || t === "dictionary" || t === "record" || t === "function")
+        return false;
+      return true;
+    }
+    if (t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "list" || t.kind === "tuple" || t.kind === "set" || t.kind === "dictionary" || t.kind === "record" || t.kind === "signature")
+      return false;
+    if (t.kind === "union" || t.kind === "intersection")
+      return t.types.every((x) => isScalarType(x));
+    if (t.kind === "negation") return isScalarType(t.type);
+    return true;
+  }
   function materialize(expr2, def, options) {
     if (!expr2.isValid || options?.materialization === false) return expr2;
     let materialization = options?.materialization ?? false;
@@ -53444,6 +54404,11 @@ Error in definition of "${name}"`,
       materialization = DEFAULT_MATERIALIZATION;
     const isIndexed = expr2.isIndexedCollection;
     const isFinite2 = expr2.isFiniteCollection;
+    if (isIndexed && isFinite2) {
+      const count = expr2.count;
+      if (count !== void 0 && count > expr2.engine.maxCollectionSize)
+        return expr2;
+    }
     const xs = [];
     if (!expr2.isEmptyCollection) {
       if (!isIndexed || !isFinite2) {
@@ -53671,7 +54636,7 @@ Error in definition of "${name}"`,
       const eltType = widen(
         ...Object.values(this._keyValues).map((op) => op.type.type)
       );
-      this._type = this.engine.type(`dictionary<${eltType}>`);
+      this._type = new BoxedType({ kind: "dictionary", values: eltType });
       return this._type;
     }
     get isPure() {
@@ -53949,6 +54914,7 @@ Error in definition of "${name}"`,
     }
     if (typeof expr2 === "number" || expr2 instanceof BigDecimal || expr2 instanceof Complex)
       return ce.number(expr2);
+    if (typeof expr2 === "boolean") return ce.symbol(expr2 ? "True" : "False");
     if (typeof expr2 === "string") {
       if (matchesSymbol(expr2)) {
         const sym2 = symbol(expr2);
@@ -55005,6 +55971,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 +56062,98 @@ 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.
      *
-     * 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`.
+     * 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; })()
+     *    ```
+     *
+     *    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.
+     *
+     * Known issue (imperative form): the IIFE generated by form (1) has no
+     * `return` statement, so `Loop(body, Element(i, Range(lo, hi)))` compiled
+     * to JS evaluates to `undefined` at runtime, while CE evaluation returns a
+     * `List` of body values. See `test/compute-engine/a1-c1-compile-parity.test.ts`
+     * ("Loop compiles in JS") for the verify-only test that locks in the
+     * current behavior.
      */
     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 +56171,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
@@ -59613,8 +60736,8 @@ Error in definition of "${name}"`,
           }
           if (effectiveOp === "greater" || effectiveOp === "greaterEqual") {
             const isStrict = effectiveOp === "greater";
-            if (bounds.lowerBound !== void 0) {
-              const lowerVal = isNumber(bounds.lowerBound) ? bounds.lowerBound.numericValue : void 0;
+            if (bounds.lower !== void 0) {
+              const lowerVal = isNumber(bounds.lower) ? bounds.lower.numericValue : void 0;
               if (typeof lowerVal === "number" && isFinite(lowerVal)) {
                 if (isStrict) {
                   if (lowerVal > k) return "tautology";
@@ -59626,8 +60749,8 @@ Error in definition of "${name}"`,
                 }
               }
             }
-            if (bounds.upperBound !== void 0) {
-              const upperVal = isNumber(bounds.upperBound) ? bounds.upperBound.numericValue : void 0;
+            if (bounds.upper !== void 0) {
+              const upperVal = isNumber(bounds.upper) ? bounds.upper.numericValue : void 0;
               if (typeof upperVal === "number" && isFinite(upperVal)) {
                 if (isStrict) {
                   if (upperVal < k) return "contradiction";
@@ -59642,8 +60765,8 @@ Error in definition of "${name}"`,
             }
           } else {
             const isStrict = effectiveOp === "less";
-            if (bounds.upperBound !== void 0) {
-              const upperVal = isNumber(bounds.upperBound) ? bounds.upperBound.numericValue : void 0;
+            if (bounds.upper !== void 0) {
+              const upperVal = isNumber(bounds.upper) ? bounds.upper.numericValue : void 0;
               if (typeof upperVal === "number" && isFinite(upperVal)) {
                 if (isStrict) {
                   if (upperVal < k) return "tautology";
@@ -59654,8 +60777,8 @@ Error in definition of "${name}"`,
                 }
               }
             }
-            if (bounds.lowerBound !== void 0) {
-              const lowerVal = isNumber(bounds.lowerBound) ? bounds.lowerBound.numericValue : void 0;
+            if (bounds.lower !== void 0) {
+              const lowerVal = isNumber(bounds.lower) ? bounds.lower.numericValue : void 0;
               if (typeof lowerVal === "number" && isFinite(lowerVal)) {
                 if (isStrict) {
                   if (lowerVal > k) return "contradiction";
@@ -59883,7 +61006,7 @@ Error in definition of "${name}"`,
         const patOp1B2 = pat.op1;
         if (isSymbol2(patOp1B2)) {
           const bounds = getInequalityBoundsFromAssumptions(ce, patOp1B2.symbol);
-          const bound = isLower ? bounds.lowerBound : bounds.upperBound;
+          const bound = isLower ? bounds.lower : bounds.upper;
           const strictOk = isLower ? bounds.lowerStrict : bounds.upperStrict;
           if (bound !== void 0 && (!isStrict || strictOk === true))
             pushResult({ [boundWildcard]: bound });
@@ -59893,7 +61016,7 @@ Error in definition of "${name}"`,
           if (symbolWildcard && !symbolWildcard.startsWith("__")) {
             for (const s of candidatesFromAssumptions()) {
               const bounds = getInequalityBoundsFromAssumptions(ce, s);
-              const bound = isLower ? bounds.lowerBound : bounds.upperBound;
+              const bound = isLower ? bounds.lower : bounds.upper;
               const strictOk = isLower ? bounds.lowerStrict : bounds.upperStrict;
               if (bound === void 0 || isStrict && strictOk !== true)
                 continue;
@@ -60925,6 +62048,7 @@ Error in definition of "${name}"`,
         return `_SYS.cexp(${compile3(args[0])})`;
       return `Math.exp(${compile3(args[0])})`;
     },
+    First: (args, compile3) => `${compile3(args[0])}[0]`,
     Floor: (args, compile3) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
       return `Math.floor(${compile3(args[0])})`;
@@ -61083,7 +62207,20 @@ Error in definition of "${name}"`,
       if (nConst !== void 0) return `Math.pow(${compile3(arg)}, ${1 / nConst})`;
       return `Math.pow(${compile3(arg)}, 1 / (${compile3(exp3)}))`;
     },
-    Random: "Math.random",
+    Random: (args, compile3) => {
+      if (args.length === 0) return "Math.random()";
+      if (args.length === 2) {
+        const m = compile3(args[0]);
+        const n = compile3(args[1]);
+        return `((${m}) + Math.floor(Math.random() * ((${n}) - (${m}))))`;
+      }
+      const arg = args[0];
+      if (BaseCompiler.isIntegerValued(arg)) {
+        return `Math.floor(Math.random() * (${compile3(arg)}))`;
+      }
+      const a = compile3(arg);
+      return `(() => { const _s = (${a}) * 12.9898; const _v = Math.sin(_s) * 43758.5453; return _v - Math.floor(_v); })()`;
+    },
     Round: (args, compile3) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
       return `Math.round(${compile3(args[0])})`;
@@ -61111,6 +62248,7 @@ Error in definition of "${name}"`,
       if (BaseCompiler.isComplexValued(arg)) return `_SYS.csech(${compile3(arg)})`;
       return `1 / Math.cosh(${compile3(arg)})`;
     },
+    Second: (args, compile3) => `${compile3(args[0])}[1]`,
     Heaviside: "_SYS.heaviside",
     Sign: "Math.sign",
     Sinc: "_SYS.sinc",
@@ -61143,6 +62281,7 @@ Error in definition of "${name}"`,
         return `_SYS.ctanh(${compile3(args[0])})`;
       return `Math.tanh(${compile3(args[0])})`;
     },
+    Third: (args, compile3) => `${compile3(args[0])}[2]`,
     Mod: ([a, b], compile3) => {
       if (a === null || b === null) throw new Error("Mod: missing argument");
       const ca = compile3(a);
@@ -62422,6 +63561,14 @@ Error in definition of "${name}"`,
       return `exp(${compile3(args[0])})`;
     },
     Exp2: "exp2",
+    // Component access — assumes the argument compiles to a vec2/vec3/vec4
+    // (the common case for 2D/3D points). For 5+-element tuples that compile
+    // to `float[N]` arrays, swizzle access is invalid GLSL and the shader
+    // will fail to compile; that's an edge case `First`/`Second`/`Third`
+    // aren't designed for. Vec swizzles are identical between GLSL and WGSL.
+    First: (args, compile3) => `${compile3(args[0])}.x`,
+    Second: (args, compile3) => `${compile3(args[0])}.y`,
+    Third: (args, compile3) => `${compile3(args[0])}.z`,
     Floor: (args, compile3) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
       return `floor(${compile3(args[0])})`;
@@ -62899,6 +64046,39 @@ Error in definition of "${name}"`,
     // Sum/Product — unrolled or for-loop
     Sum: (args, compile3, target) => compileGPUSumProduct("Sum", args, compile3, target),
     Product: (args, compile3, target) => compileGPUSumProduct("Product", args, compile3, target),
+    // Range — inline constant array literal (bounds must be compile-time constants)
+    Range: (args, _compile2, target) => {
+      if (args.length < 2 || args.length > 3) {
+        throw new Error(
+          "Range: GPU compile expects 2 or 3 arguments (lo, hi, step?)"
+        );
+      }
+      const lo = args[0].re;
+      const hi = args[1].re;
+      const step = args.length === 3 ? args[2].re : 1;
+      if (!Number.isFinite(lo) || !Number.isFinite(hi) || !Number.isFinite(step)) {
+        throw new Error(
+          "Range: GPU compile requires constant numeric bounds (non-constant ranges must be materialized at JS host then uploaded as a uniform)"
+        );
+      }
+      if (step === 0) throw new Error("Range: step cannot be zero");
+      const count = Math.max(0, Math.floor((hi - lo) / step) + 1);
+      if (count === 0) {
+        throw new Error(
+          "Range: empty range (lo > hi for positive step, or lo < hi for negative step)"
+        );
+      }
+      if (count > 256) {
+        throw new Error(
+          `Range: GPU compile inlines ranges up to 256 elements (got ${count})`
+        );
+      }
+      const values = [];
+      for (let i = 0; i < count; i++) values.push(lo + i * step);
+      const isWGSL = target.language === "wgsl";
+      const arrayType = isWGSL ? `array<f32, ${count}>` : `float[${count}]`;
+      return `${arrayType}(${values.map(formatGPUNumber).join(", ")})`;
+    },
     // Loop — GPU for-loop (no IIFE, no let)
     Loop: (args, _compile2, target) => {
       if (!args[0]) throw new Error("Loop: no body");
@@ -62927,6 +64107,134 @@ Error in definition of "${name}"`,
   ${bodyCode};
 }`;
     },
+    // Statistical functions
+    /**
+     * GCD of two scalar arguments.
+     *
+     * Uses a preamble helper `_gpu_gcd` (Euclidean algorithm via `mod`).
+     * Only two-argument form is supported in GPU targets.
+     */
+    GCD: (args, compile3) => {
+      if (args.length < 2) throw new Error("GCD: need at least two arguments");
+      if (args.length > 2)
+        throw new Error("GCD: GPU target supports only two-argument GCD");
+      const a = args[0];
+      const b = args[1];
+      if (a === null || b === null) throw new Error("GCD: missing argument");
+      return `_gpu_gcd(${compile3(a)}, ${compile3(b)})`;
+    },
+    /**
+     * Variance of a compile-time-known list.
+     *
+     * Accepts either a single `List(...)` argument or N scalar arguments.
+     * Generates fully inline code: computes mean then sum of squared deviations,
+     * divided by (N-1) for sample variance (matches JS `_SYS.variance`).
+     */
+    Variance: (args, compile3) => {
+      let elems;
+      if (args.length === 1 && isFunction2(args[0], "List")) {
+        elems = args[0].ops;
+      } else if (args.length >= 2) {
+        elems = args;
+      } else {
+        throw new Error(
+          "Variance: GPU target requires a List argument or at least 2 scalar arguments"
+        );
+      }
+      const n = elems.length;
+      if (n < 2) throw new Error("Variance: need at least 2 elements");
+      const compiled = elems.map((e) => compile3(e));
+      const sum = compiled.join(" + ");
+      const mean2 = `((${sum}) / ${formatGPUNumber(n)})`;
+      const sqDiffs = compiled.map((c) => `(${c} - ${mean2}) * (${c} - ${mean2})`).join(" + ");
+      return `((${sqDiffs}) / ${formatGPUNumber(n - 1)})`;
+    },
+    /**
+     * Median of a compile-time-known list.
+     *
+     * Accepts either a single `List(...)` argument or N scalar arguments.
+     * For N ≤ 8: generates a fully unrolled inline sorting network followed by
+     * a middle-element pick. For larger N, throws (too large to inline cleanly).
+     *
+     * The sorting network uses the "odd-even merge sort" comparator pattern
+     * inlined as `min`/`max` calls — no GPU statements required.
+     */
+    Median: (args, compile3) => {
+      let elems;
+      if (args.length === 1 && isFunction2(args[0], "List")) {
+        elems = args[0].ops;
+      } else if (args.length >= 1) {
+        elems = args;
+      } else {
+        throw new Error(
+          "Median: GPU target requires a List argument or at least 1 scalar argument"
+        );
+      }
+      const n = elems.length;
+      if (n === 0) throw new Error("Median: empty list");
+      if (n > 8) {
+        throw new Error(
+          `Median: GPU target supports up to 8 elements via inline sorting network (got ${n}). For larger lists, compute on the CPU and pass the result as a uniform.`
+        );
+      }
+      const compiled = elems.map((e) => compile3(e));
+      if (n === 1) return compiled[0];
+      return `_gpu_median_${n}(${compiled.join(", ")})`;
+    },
+    /**
+     * Deterministic pseudorandom for GPU.
+     *
+     * All emitted forms return a GLSL `float` (or WGSL `f32`) so the result
+     * composes with surrounding float arithmetic without explicit casts. The
+     * "integer-bound" forms return an integer-valued float (the result of
+     * `floor`), matching the convention used by `Floor` and other ostensibly
+     * integer-returning operators in this target.
+     *
+     * - 0 args (GLSL only): fall back to a fragment-coord-derived seed.
+     *   Only meaningful in fragment shaders (gl_FragCoord is FS-only).
+     * - 0 args (WGSL): throws — WGSL has no built-in fragment coordinate;
+     *   caller must provide an explicit seed.
+     * - 1 arg, real-typed: `_gpu_random(seed)` — deterministic float in [0, 1)
+     * - 1 arg, integer-typed: `floor(_gpu_random(float(n)) * float(n))` —
+     *   integer-valued float in {0, 1, ..., n-1}. The seed is derived from
+     *   `n` itself, so the result is per-pixel-and-n deterministic in GLSL.
+     * - 2 args (integer m, n): float in [m, n), seeded from gl_FragCoord.
+     *
+     * JS-side `Random` has matching semantics (see `library/core.ts`'s
+     * polymorphic dispatch). JS↔GLSL parity is approximate — same seed yields
+     * a similar value, not bit-identical, due to fp64 vs fp32 and platform
+     * `sin` differences.
+     */
+    Random: (args, compile3, target) => {
+      if (args.length === 0) {
+        if (target.language === "wgsl") {
+          throw new Error(
+            "Random(): WGSL compile requires an explicit seed argument. WGSL has no gl_FragCoord built-in outside fragment entry points, so the no-arg fallback used in GLSL is unavailable. Use Random(seed) where seed is a deterministic per-invocation value."
+          );
+        }
+        return "_gpu_random(gl_FragCoord.x + gl_FragCoord.y * 1024.0)";
+      }
+      if (args.length === 1) {
+        const arg = args[0];
+        if (BaseCompiler.isIntegerValued(arg)) {
+          const compiled = compile3(arg);
+          return `floor(_gpu_random(float(${compiled})) * float(${compiled}))`;
+        }
+        return `_gpu_random(${compile3(arg)})`;
+      }
+      if (args.length === 2) {
+        if (target.language === "wgsl") {
+          throw new Error(
+            "Random(m, n): WGSL compile requires explicit seeding. Use a seeded variant or compute the integer range manually."
+          );
+        }
+        const m = compile3(args[0]);
+        const n = compile3(args[1]);
+        const seed = "_gpu_random(gl_FragCoord.x + gl_FragCoord.y * 1024.0)";
+        return `(float(${m}) + floor(${seed} * float((${n}) - (${m}))))`;
+      }
+      throw new Error("Random: GPU compile expects 0, 1, or 2 arguments");
+    },
     // Function (lambda) — not supported in GPU
     Function: () => {
       throw new Error(
@@ -63525,6 +64833,212 @@ fn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {
   }
   return 1.0;
 }
+`;
+  var GPU_GCD_PREAMBLE_GLSL = `
+float _gpu_gcd(float a, float b) {
+  a = abs(a); b = abs(b);
+  for (int i = 0; i < 32; i++) {
+    if (b < 0.5) break;
+    float t = mod(a, b);
+    a = b;
+    b = t;
+  }
+  return a;
+}
+`;
+  var GPU_GCD_PREAMBLE_WGSL = `
+fn _gpu_gcd(a_in: f32, b_in: f32) -> f32 {
+  var a = abs(a_in); var b = abs(b_in);
+  for (var i: i32 = 0; i < 32; i++) {
+    if (b < 0.5) { break; }
+    let t = a % b;
+    a = b;
+    b = t;
+  }
+  return a;
+}
+`;
+  var GPU_RANDOM_PREAMBLE_GLSL = `
+// Deterministic pseudorandom in [0, 1) from a float seed.
+// Standard fract-sin hash; reproducible across runs for the same seed.
+// Note: this hash exhibits visible banding near seed \u2248 k\u03C0 for integer k.
+// For high-quality shader random, callers should use a more robust hash
+// (e.g. PCG or xxHash) and pre-seed it appropriately.
+float _gpu_random(float seed) {
+  return fract(sin(seed * 12.9898) * 43758.5453);
+}
+`;
+  var GPU_RANDOM_PREAMBLE_WGSL = `
+// Deterministic pseudorandom in [0, 1) from a float seed.
+// Standard fract-sin hash; reproducible across runs for the same seed.
+// Note: this hash exhibits visible banding near seed \u2248 k\u03C0 for integer k.
+// For high-quality shader random, callers should use a more robust hash
+// (e.g. PCG or xxHash) and pre-seed it appropriately.
+fn _gpu_random(seed: f32) -> f32 {
+  return fract(sin(seed * 12.9898) * 43758.5453);
+}
+`;
+  var GPU_MEDIAN_PREAMBLE_GLSL = `
+float _gpu_median_2(float a, float b) {
+  return (a + b) * 0.5;
+}
+float _gpu_median_3(float a, float b, float c) {
+  return max(min(a, b), min(max(a, b), c));
+}
+float _gpu_median_4(float a, float b, float c, float d) {
+  float lo = max(min(a, b), min(c, d));
+  float hi = min(max(a, b), max(c, d));
+  return (lo + hi) * 0.5;
+}
+float _gpu_median_5(float a, float b, float c, float d, float e) {
+  // 9-comparator Bose-Nelson sort; v2 holds the median.
+  float t; float v0=a,v1=b,v2=c,v3=d,v4=e;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v0,v3); v3=max(v0,v3); v0=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v4); v4=max(v1,v4); v1=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  return v2;
+}
+float _gpu_median_6(float a, float b, float c, float d, float e, float f) {
+  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return (v2 + v3) * 0.5;
+}
+float _gpu_median_7(float a, float b, float c, float d, float e, float f, float g) {
+  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f,v6=g;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v4,v6); v6=max(v4,v6); v4=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v6); v6=max(v2,v6); v2=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return v3;
+}
+float _gpu_median_8(float a, float b, float c, float d, float e, float f, float g, float h) {
+  float t; float v0=a,v1=b,v2=c,v3=d,v4=e,v5=f,v6=g,v7=h;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v6,v7); v7=max(v6,v7); v6=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v4,v6); v6=max(v4,v6); v4=t;
+  t=min(v5,v7); v7=max(v5,v7); v5=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v6); v6=max(v2,v6); v2=t;
+  t=min(v3,v7); v7=max(v3,v7); v3=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  t=min(v5,v6); v6=max(v5,v6); v5=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return (v3 + v4) * 0.5;
+}
+`;
+  var GPU_MEDIAN_PREAMBLE_WGSL = `
+fn _gpu_median_2(a: f32, b: f32) -> f32 {
+  return (a + b) * 0.5;
+}
+fn _gpu_median_3(a: f32, b: f32, c: f32) -> f32 {
+  return max(min(a, b), min(max(a, b), c));
+}
+fn _gpu_median_4(a: f32, b: f32, c: f32, d: f32) -> f32 {
+  let lo = max(min(a, b), min(c, d));
+  let hi = min(max(a, b), max(c, d));
+  return (lo + hi) * 0.5;
+}
+fn _gpu_median_5(a: f32, b: f32, c: f32, d: f32, e: f32) -> f32 {
+  // 9-comparator Bose-Nelson sort; v2 holds the median.
+  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var t: f32;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v0,v3); v3=max(v0,v3); v0=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v4); v4=max(v1,v4); v1=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  return v2;
+}
+fn _gpu_median_6(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32) -> f32 {
+  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var t: f32;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return (v2 + v3) * 0.5;
+}
+fn _gpu_median_7(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32, g: f32) -> f32 {
+  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var v6=g; var t: f32;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v4,v6); v6=max(v4,v6); v4=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v6); v6=max(v2,v6); v2=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return v3;
+}
+fn _gpu_median_8(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32, g: f32, h: f32) -> f32 {
+  var v0=a; var v1=b; var v2=c; var v3=d; var v4=e; var v5=f; var v6=g; var v7=h; var t: f32;
+  t=min(v0,v1); v1=max(v0,v1); v0=t;
+  t=min(v2,v3); v3=max(v2,v3); v2=t;
+  t=min(v4,v5); v5=max(v4,v5); v4=t;
+  t=min(v6,v7); v7=max(v6,v7); v6=t;
+  t=min(v0,v2); v2=max(v0,v2); v0=t;
+  t=min(v1,v3); v3=max(v1,v3); v1=t;
+  t=min(v4,v6); v6=max(v4,v6); v4=t;
+  t=min(v5,v7); v7=max(v5,v7); v5=t;
+  t=min(v0,v4); v4=max(v0,v4); v0=t;
+  t=min(v1,v5); v5=max(v1,v5); v1=t;
+  t=min(v2,v6); v6=max(v2,v6); v2=t;
+  t=min(v3,v7); v7=max(v3,v7); v3=t;
+  t=min(v1,v2); v2=max(v1,v2); v1=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  t=min(v5,v6); v6=max(v5,v6); v5=t;
+  t=min(v3,v5); v5=max(v3,v5); v3=t;
+  t=min(v2,v4); v4=max(v2,v4); v2=t;
+  t=min(v3,v4); v4=max(v3,v4); v3=t;
+  return (v3 + v4) * 0.5;
+}
 `;
   var GPU_COLOR_PREAMBLE_GLSL = `
 float _gpu_srgb_to_linear(float c) {
@@ -64203,6 +65717,12 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
       if (code.includes("_fractal_")) {
         preamble += this.languageId === "wgsl" ? GPU_FRACTAL_PREAMBLE_WGSL : GPU_FRACTAL_PREAMBLE_GLSL;
       }
+      if (code.includes("_gpu_random"))
+        preamble += this.languageId === "wgsl" ? GPU_RANDOM_PREAMBLE_WGSL : GPU_RANDOM_PREAMBLE_GLSL;
+      if (code.includes("_gpu_gcd"))
+        preamble += this.languageId === "wgsl" ? GPU_GCD_PREAMBLE_WGSL : GPU_GCD_PREAMBLE_GLSL;
+      if (code.includes("_gpu_median_"))
+        preamble += this.languageId === "wgsl" ? GPU_MEDIAN_PREAMBLE_WGSL : GPU_MEDIAN_PREAMBLE_GLSL;
       if (code.includes("_gpu_srgb_to") || code.includes("_gpu_oklab") || code.includes("_gpu_oklch") || code.includes("_gpu_color_mix") || code.includes("_gpu_apca")) {
         preamble += this.languageId === "wgsl" ? GPU_COLOR_PREAMBLE_WGSL : GPU_COLOR_PREAMBLE_GLSL;
       }
@@ -66428,6 +67948,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     _timeLimit = 2e3;
     _iterationLimit = 1024;
     _recursionLimit = 1024;
+    _maxCollectionSize = 1e4;
     _deadline = void 0;
     _isVerifying = false;
     get timeLimit() {
@@ -66448,6 +67969,12 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     set recursionLimit(value) {
       this._recursionLimit = value <= 0 ? Number.POSITIVE_INFINITY : value;
     }
+    get maxCollectionSize() {
+      return this._maxCollectionSize;
+    }
+    set maxCollectionSize(value) {
+      this._maxCollectionSize = value <= 0 ? Number.POSITIVE_INFINITY : value;
+    }
     get deadline() {
       return this._deadline;
     }
@@ -68908,6 +70435,23 @@ ${code}`;
     set recursionLimit(t) {
       this._runtimeState.recursionLimit = t;
     }
+    /** Maximum number of elements a collection may have when materialized
+     * (converted from a lazy form to a `List`). Default: 10,000.
+     *
+     * When a materialization would exceed this size, the operation leaves
+     * the expression in its lazy form. Consumers can detect oversize
+     * collections via the symbolic form's `count`.
+     *
+     * Set to `Infinity` (or `0` / a negative number) to disable the cap.
+     *
+     * @experimental
+     */
+    get maxCollectionSize() {
+      return this._runtimeState.maxCollectionSize;
+    }
+    set maxCollectionSize(t) {
+      this._runtimeState.maxCollectionSize = t;
+    }
     /**
      * Flag to prevent infinite recursion in the verify/ask/equality checking cycle.
      *
@@ -69184,6 +70728,36 @@ ${code}`;
     lookupDefinition(id) {
       return lookupDefinition(this, id);
     }
+    normalizeIdentifier(latex) {
+      if (!latex) return "";
+      if (isValidSymbol(latex)) return latex;
+      this.pushScope();
+      try {
+        const expr2 = this.parse(latex);
+        if (isSymbol2(expr2)) return expr2.symbol;
+      } finally {
+        this.popScope();
+      }
+      return "";
+    }
+    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
+      };
+    }
+    symbolInfo(name) {
+      const def = this.lookupDefinition(name);
+      if (!def || !isValueDef(def)) return void 0;
+      const v = def.value;
+      return {
+        kind: v.isConstant ? "constant" : "variable",
+        type: v.type
+      };
+    }
     /**
      * Associate a new definition to a symbol in the current context.
      *
@@ -69471,6 +71045,7 @@ ${code}`;
           const def = this.lookupDefinition(id);
           return !!(isValueDef(def) && def.value.subscriptEvaluate);
         },
+        tolerance: this.tolerance,
         ...this._latexOptions,
         ...parseOpts
       });
@@ -69635,14 +71210,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.56.0";
+  var version = "0.58.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.58.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();