@cortex-js/compute-engine 0.57.0 → 0.58.0

package/dist/core.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.57.0 */
+/** Compute Engine 0.58.0 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -4268,7 +4268,42 @@ function widen2(a, b) {
   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";
@@ -4346,7 +4381,7 @@ function collectionElementType(type2) {
   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)))}>`
@@ -5892,6 +5927,84 @@ function sym(expr2) {
 }
 
 // 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;
@@ -5908,8 +6021,8 @@ function getInequalityBoundsFromAssumptions(ce, symbol2) {
     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;
       }
     }
@@ -5928,16 +6041,16 @@ function getInequalityBoundsFromAssumptions(ce, symbol2) {
       }
       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;
       }
     }
@@ -5956,8 +6069,8 @@ function getInequalityBoundsFromAssumptions(ce, symbol2) {
       }
       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;
         }
       }
@@ -6177,8 +6290,8 @@ function cmp(a, b) {
         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 "<";
@@ -6186,8 +6299,8 @@ function cmp(a, b) {
               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 ">";
@@ -6217,8 +6330,8 @@ function cmp(a, b) {
   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 ">";
@@ -6226,8 +6339,8 @@ function cmp(a, b) {
           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 "<";
@@ -6283,8 +6396,8 @@ function cmp(a, b) {
       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 ">";
@@ -6292,8 +6405,8 @@ function cmp(a, b) {
             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 "<";
@@ -6831,6 +6944,12 @@ var _BoxedOperatorDefinition = class {
   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;
@@ -6988,6 +7107,8 @@ var _BoxedOperatorDefinition = class {
           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", {
@@ -8304,6 +8425,29 @@ var _BoxedExpression = class __BoxedExpression {
   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;
   }
@@ -10322,15 +10466,16 @@ var DEFINITIONS_CORE = [
     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",
@@ -10341,7 +10486,7 @@ var DEFINITIONS_CORE = [
     latexTrigger: "\\colon",
     kind: "infix",
     associativity: "right",
-    precedence: 250,
+    precedence: 240,
     parse: "Colon"
   },
   {
@@ -11911,7 +12056,10 @@ function parseForComprehension(parser, lhs, until) {
       p.skipVisualSpace();
       const isComma = p.peek === ",";
       p.index = saved;
-      return isComma;
+      if (isComma) return true;
+      if (peekKeyword(p, "where")) return true;
+      if (peekKeyword(p, "with")) return true;
+      return false;
     }
   };
   const elements = [];
@@ -11952,6 +12100,25 @@ function parseWhereExpression(parser, lhs, until) {
     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);
@@ -12165,6 +12332,17 @@ function parseIntervalBody(body, openLeft, openRight) {
   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
@@ -12423,18 +12601,58 @@ var DEFINITIONS_SETS = [
     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 (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];
       }
-      if (operator(body) !== "Sequence") return ["Set", body];
-      return ["Set", ...operands(body)];
+      return ["Set", body];
     },
     serialize: (serializer, expr2) => {
       if (nops(expr2) === 2 && operator(operand(expr2, 2)) === "Condition") {
@@ -14438,7 +14656,8 @@ function parseTrig(op) {
       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];
   };
 }
@@ -16654,10 +16873,17 @@ var DEFINITIONS_OTHERS = [
   // 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
@@ -22499,6 +22725,15 @@ function expressionTensorInfo(operator2, rows) {
       }
     } 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));
       }
     }
@@ -27534,6 +27769,15 @@ function interval(expr2) {
   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;
@@ -27583,6 +27827,19 @@ var COLLECTIONS_LIBRARY = {
       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,
@@ -27836,10 +28093,12 @@ var COLLECTIONS_LIBRARY = {
         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) => {
@@ -27858,6 +28117,8 @@ var COLLECTIONS_LIBRARY = {
             !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: () => {
@@ -27866,7 +28127,7 @@ var COLLECTIONS_LIBRARY = {
             index += 1;
             return {
               value: expr2.engine.number(
-                lower + (upper - lower) * (index - 1 - 1) / totalCount
+                lower + (upper - lower) * (index - 1 - 1) / denom
               ),
               done: false
             };
@@ -27882,9 +28143,14 @@ var COLLECTIONS_LIBRARY = {
         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;
       }
     }
   },
@@ -28209,10 +28475,12 @@ var COLLECTIONS_LIBRARY = {
     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];
@@ -28223,12 +28491,39 @@ var COLLECTIONS_LIBRARY = {
         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;
@@ -28239,7 +28534,7 @@ var COLLECTIONS_LIBRARY = {
     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);
@@ -28286,7 +28581,7 @@ var COLLECTIONS_LIBRARY = {
     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) => {
@@ -28482,7 +28777,9 @@ var COLLECTIONS_LIBRARY = {
     ],
     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) => {
@@ -28814,16 +29111,26 @@ var COLLECTIONS_LIBRARY = {
   },
   // 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);
     }
@@ -28890,7 +29197,9 @@ var COLLECTIONS_LIBRARY = {
       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 }) => {
@@ -28906,7 +29215,7 @@ var COLLECTIONS_LIBRARY = {
     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]);
@@ -28918,7 +29227,7 @@ var COLLECTIONS_LIBRARY = {
     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);
@@ -29092,32 +29401,74 @@ var COLLECTIONS_LIBRARY = {
       }
     }
   },
-  // 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;
       }
     }
@@ -31403,11 +31754,12 @@ var ARITHMETIC_LIBRARY = [
         );
       }
     },
-    // 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",
@@ -32757,48 +33109,83 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     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)) {
@@ -43035,7 +43422,7 @@ var COLORS_LIBRARY = {
 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",
@@ -43097,7 +43484,7 @@ var CONTROL_STRUCTURES_LIBRARY = [
       evaluateAsync: async (ops, { engine: ce, signal }) => runAsync(runLoop(ops[0], ops.slice(1), ce), ce._timeRemaining, signal)
     },
     When: {
-      description: "Conditional value: returns expr when cond holds, undefined otherwise.",
+      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,
@@ -44956,7 +45343,7 @@ var CORE_LIBRARY = [
       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",
@@ -45087,7 +45474,12 @@ var CORE_LIBRARY = [
       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;
         }
@@ -45096,6 +45488,11 @@ var CORE_LIBRARY = [
           (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;
       }
@@ -45213,33 +45610,41 @@ var CORE_LIBRARY = [
     },
     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)));
         }
-        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));
+        }
+        const seed = firstOp.re;
+        if (isNaN(seed)) return ce.number(0);
+        return ce.number(deterministicRandom(seed));
       }
     },
     // @todo: need review
@@ -45695,6 +46100,14 @@ var CORE_LIBRARY = [
     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"
     }
   }
 ];
@@ -50735,18 +51148,28 @@ var STATISTICS_LIBRARY = [
   },
   {
     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);
@@ -53567,6 +53990,20 @@ var BoxedFunction = class extends _BoxedExpression {
         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));
@@ -53613,6 +54050,22 @@ var BoxedFunction = class extends _BoxedExpression {
           (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)
@@ -53827,8 +54280,47 @@ function applyFunctionLiteral(expr2, def, options) {
   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;
@@ -53836,6 +54328,11 @@ function materialize(expr2, def, options) {
     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) {
@@ -54063,7 +54560,7 @@ var BoxedDictionary = class _BoxedDictionary extends _BoxedExpression {
     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() {
@@ -54341,6 +54838,7 @@ function box(ce, expr2, options) {
   }
   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);
@@ -55519,6 +56017,13 @@ var BaseCompiler = class _BaseCompiler {
    *    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");
@@ -60155,8 +60660,8 @@ function assumeInequality(proposition) {
         }
         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";
@@ -60168,8 +60673,8 @@ function assumeInequality(proposition) {
               }
             }
           }
-          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";
@@ -60184,8 +60689,8 @@ function assumeInequality(proposition) {
           }
         } 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";
@@ -60196,8 +60701,8 @@ function assumeInequality(proposition) {
               }
             }
           }
-          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";
@@ -60425,7 +60930,7 @@ function ask(ce, pattern) {
       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 });
@@ -60435,7 +60940,7 @@ function ask(ce, pattern) {
         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;
@@ -61467,6 +61972,7 @@ var JAVASCRIPT_FUNCTIONS = {
       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])})`;
@@ -61625,7 +62131,20 @@ var JAVASCRIPT_FUNCTIONS = {
     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])})`;
@@ -61653,6 +62172,7 @@ var JAVASCRIPT_FUNCTIONS = {
     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",
@@ -61685,6 +62205,7 @@ var JAVASCRIPT_FUNCTIONS = {
       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);
@@ -62964,6 +63485,14 @@ var GPU_FUNCTIONS = {
     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])})`;
@@ -63441,6 +63970,39 @@ var GPU_FUNCTIONS = {
   // 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");
@@ -63469,6 +64031,134 @@ var GPU_FUNCTIONS = {
   ${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(
@@ -64068,6 +64758,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) {
   if (c <= 0.04045) return c / 12.92;
@@ -64745,6 +65641,12 @@ var GPUShaderTarget = class {
     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;
     }
@@ -66970,6 +67872,7 @@ var EngineRuntimeState = class {
   _timeLimit = 2e3;
   _iterationLimit = 1024;
   _recursionLimit = 1024;
+  _maxCollectionSize = 1e4;
   _deadline = void 0;
   _isVerifying = false;
   get timeLimit() {
@@ -66990,6 +67893,12 @@ var EngineRuntimeState = class {
   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;
   }
@@ -69028,6 +69937,23 @@ var ComputeEngine = class _ComputeEngine {
   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.
    *
@@ -69304,6 +70230,18 @@ var ComputeEngine = class _ComputeEngine {
   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;
@@ -69313,6 +70251,15 @@ var ComputeEngine = class _ComputeEngine {
       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.
    *
@@ -69765,7 +70712,7 @@ var ComputeEngine = class _ComputeEngine {
 _setDefaultEngineFactory(() => new ComputeEngine());
 
 // src/core.ts
-var version = "0.57.0";
+var version = "0.58.0";
 export {
   ComputeEngine,
   N,