@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.57.0 */
+/** Compile 0.59.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.Compile = {}));})(this, (function (exports) { 'use strict';
 var Compile = (() => {
   var __defProp = Object.defineProperty;
@@ -192,6 +192,7 @@ var Compile = (() => {
     return sum;
   }
   function fpln(x, scale) {
+    if (x <= 0n) throw new RangeError("fpln: input must be positive");
     if (x === scale) return 0n;
     const xNum = Number(x);
     const scaleNum = Number(scale);
@@ -841,9 +842,11 @@ var Compile = (() => {
       if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
         if (other.significand === 0n) return _BigDecimal.NAN;
         if (this.significand === 0n) return fromRaw(0n, 0);
-        return this.sub(this.div(other).trunc().mul(other)).toPrecision(
-          _BigDecimal.precision
-        );
+        const ediff = thisExp - otherExp;
+        const num = ediff >= 0 ? this.significand * pow10(ediff) : this.significand;
+        const den = ediff >= 0 ? other.significand : other.significand * pow10(-ediff);
+        const q = num / den;
+        return this.sub(fromRaw(q, 0).mul(other));
       }
       if (thisExp !== thisExp || otherExp !== otherExp) return _BigDecimal.NAN;
       if (!Number.isFinite(thisExp)) return _BigDecimal.NAN;
@@ -888,7 +891,10 @@ var Compile = (() => {
           return this.pow(n.neg()).inv();
         }
         const absSig = this.significand < 0n ? -this.significand : this.significand;
-        const thisLog10 = bigintDigits(absSig) + this.exponent;
+        const sigDigits = bigintDigits(absSig);
+        const dropped = sigDigits > 15 ? sigDigits - 15 : 0;
+        const lead = dropped > 0 ? Number(absSig / 10n ** BigInt(dropped)) : Number(absSig);
+        const thisLog10 = Math.log10(lead) + dropped + this.exponent;
         const resultLog10 = Number(expValue) * thisLog10;
         if (resultLog10 > 9e15) {
           return this.significand < 0n && expValue % 2n !== 0n ? _BigDecimal.NEGATIVE_INFINITY : _BigDecimal.POSITIVE_INFINITY;
@@ -921,7 +927,19 @@ var Compile = (() => {
         return _BigDecimal.POSITIVE_INFINITY;
       }
       if (this.significand < 0n) return _BigDecimal.NAN;
-      return n.mul(this.ln()).exp();
+      const baseSig = this.significand;
+      const decExpBase = this.exponent + bigintDigits(baseSig) - 1;
+      const nSig = n.significand < 0n ? -n.significand : n.significand;
+      const decExpN = n.exponent + bigintDigits(nSig) - 1;
+      const argMag = decExpN + Math.log10(Math.abs(decExpBase) * 2.303 + 3) + 1;
+      const extra = Math.min(20, Math.max(2, Math.ceil(argMag) + 2));
+      const savedPrec = _BigDecimal.precision;
+      _BigDecimal.precision = savedPrec + extra;
+      try {
+        return n.mul(this.ln()).exp().toPrecision(savedPrec);
+      } finally {
+        _BigDecimal.precision = savedPrec;
+      }
     }
     // ---------- Conversion methods ----------
     /** Convert to a JavaScript number. May lose precision for large values. */
@@ -1162,6 +1180,20 @@ var Compile = (() => {
     const sig = negative ? -absFp : absFp;
     return fromRaw(sig, resultExp);
   }
+  function decimalExponent(x) {
+    const sig = x.significand < 0n ? -x.significand : x.significand;
+    return x.exponent + bigintDigits(sig) - 1;
+  }
+  var MAX_SAFE_EXPONENT = BigInt(Number.MAX_SAFE_INTEGER);
+  var _ln10Fp = null;
+  var _ln10Scale = null;
+  function ln10Fixed(scale) {
+    if (_ln10Scale !== scale) {
+      _ln10Fp = fpln(10n * scale, scale);
+      _ln10Scale = scale;
+    }
+    return _ln10Fp;
+  }
   BigDecimal.prototype.sqrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
@@ -1172,9 +1204,13 @@ var Compile = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 2);
+    const m = fromRaw(this.significand, this.exponent - 2 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const sqrtFp = fpsqrt(fp, scale);
-    return fromFixedPoint(sqrtFp, scale, targetPrec);
+    const root = fromFixedPoint(sqrtFp, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.prototype.cbrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1188,10 +1224,13 @@ var Compile = (() => {
     }
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 3);
+    const m = fromRaw(this.significand, this.exponent - 3 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const C = fp * scale * scale;
     let x;
-    const numVal = this.toNumber();
+    const numVal = m.toNumber();
     const scaleNum = Number(scale);
     if (Number.isFinite(numVal) && numVal > 0 && Number.isFinite(scaleNum)) {
       const approx = Math.cbrt(numVal);
@@ -1220,7 +1259,8 @@ var Compile = (() => {
       const diffNext = bigintAbs(next * next * next - C);
       if (diffNext < diffX) x = next;
     }
-    return fromFixedPoint(x, scale, targetPrec);
+    const root = fromFixedPoint(x, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.sqrt = function(x) {
     return x.sqrt();
@@ -1235,11 +1275,27 @@ var Compile = (() => {
       return BigDecimal.ZERO;
     }
     if (this.isZero()) return BigDecimal.ONE;
+    if (decimalExponent(this) >= 17)
+      return this.significand > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const expFp = fpexp(fp, scale);
-    return fromFixedPoint(expFp, scale, targetPrec);
+    const absSig = this.significand < 0n ? -this.significand : this.significand;
+    const magnitude = Math.max(0, this.exponent + bigintDigits(absSig));
+    const workingPrec = targetPrec + 20 + magnitude;
+    const [xFp, scale] = toFixedPoint(this, workingPrec);
+    const l10 = ln10Fixed(scale);
+    let k = xFp / l10;
+    let rFp = xFp - k * l10;
+    if (rFp < 0n) {
+      k -= 1n;
+      rFp += l10;
+    }
+    if (k > MAX_SAFE_EXPONENT || k < -MAX_SAFE_EXPONENT)
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    const expR = fromFixedPoint(fpexp(rFp, scale), scale, targetPrec);
+    const newExp = expR.exponent + Number(k);
+    if (!Number.isSafeInteger(newExp))
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    return fromRaw(expR.significand, newExp);
   };
   BigDecimal.prototype.ln = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -1251,10 +1307,16 @@ var Compile = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     if (this.eq(1)) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const lnFp = fpln(fp, scale);
-    return fromFixedPoint(lnFp, scale, targetPrec);
+    const sig = this.significand;
+    const digits = bigintDigits(sig);
+    const e = this.exponent + digits - 1;
+    const m = fromRaw(sig, -(digits - 1));
+    const eDigits = Math.abs(e).toString().length;
+    const workingPrec = targetPrec + 20 + eDigits;
+    const [mFp, scale] = toFixedPoint(m, workingPrec);
+    const l10 = ln10Fixed(scale);
+    const resultFp = fpln(mFp, scale) + BigInt(e) * l10;
+    return fromFixedPoint(resultFp, scale, targetPrec);
   };
   BigDecimal.prototype.log = function(base) {
     const b = base instanceof BigDecimal ? base : new BigDecimal(base);
@@ -1274,7 +1336,10 @@ var Compile = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp] = fpsincos(fp, scale);
     return fromFixedPoint(sinFp, scale, targetPrec);
@@ -1285,6 +1350,8 @@ var Compile = (() => {
     if (this.isZero()) return BigDecimal.ONE;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [, cosFp] = fpsincos(fp, scale);
     return fromFixedPoint(cosFp, scale, targetPrec);
@@ -1294,7 +1361,10 @@ var Compile = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp, cosFp] = fpsincos(fp, scale);
     if (cosFp === 0n) {
@@ -1312,7 +1382,9 @@ var Compile = (() => {
       return piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const atanFp = fpatan(fp, scale);
     return fromFixedPoint(atanFp, scale, targetPrec);
@@ -1329,7 +1401,9 @@ var Compile = (() => {
       return this.significand > 0n ? piHalf : piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 20;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 20 + (e < 0 ? -e : 0);
     const [xFp, scale] = toFixedPoint(this, workingPrec);
     const x2 = fpmul(xFp, xFp, scale);
     const oneMinusX2 = scale - x2;
@@ -1392,6 +1466,23 @@ var Compile = (() => {
       if (this.significand > 0n) return BigDecimal.POSITIVE_INFINITY;
       return BigDecimal.NEGATIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const expX2 = this.exp();
+        return expX2.sub(expX2.inv()).div(BigDecimal.TWO).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3)) {
+      const h = this.abs().exp().div(BigDecimal.TWO);
+      return this.significand > 0n ? h : h.neg();
+    }
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.sub(expNegX).div(BigDecimal.TWO);
@@ -1402,6 +1493,9 @@ var Compile = (() => {
     if (!this.isFinite()) {
       return BigDecimal.POSITIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.abs().exp().div(BigDecimal.TWO);
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.add(expNegX).div(BigDecimal.TWO);
@@ -1413,6 +1507,21 @@ var Compile = (() => {
       if (this.significand > 0n) return BigDecimal.ONE;
       return BigDecimal.NEGATIVE_ONE;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const exp2x2 = this.mul(BigDecimal.TWO).exp();
+        return exp2x2.sub(BigDecimal.ONE).div(exp2x2.add(BigDecimal.ONE)).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.significand > 0n ? BigDecimal.ONE : BigDecimal.NEGATIVE_ONE;
     const exp2x = this.mul(BigDecimal.TWO).exp();
     return exp2x.sub(BigDecimal.ONE).div(exp2x.add(BigDecimal.ONE));
   };
@@ -1461,6 +1570,7 @@ var Compile = (() => {
     Math.log10(Math.pow(2, MACHINE_PRECISION_BITS))
   );
   var DEFAULT_TOLERANCE = 1e-10;
+  var SMALL_INTEGER = 1e6;
   var MAX_ITERATION = 1e4;
   function gcd(a, b) {
     if (a === 0) return b;
@@ -1472,7 +1582,8 @@ var Compile = (() => {
   }
   function lcm(a, b) {
     if (a === 0 || b === 0) return 0;
-    const res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    let res = BigInt(a) * BigInt(b) / BigInt(gcd(a, b));
+    if (res < 0n) res = -res;
     return Number(res);
   }
   function factorial(n) {
@@ -1562,216 +1673,27 @@ var Compile = (() => {
     "error",
     ...EXPRESSION_TYPES
   ];
+  var NUMERIC_TYPES_SET = new Set(
+    NUMERIC_TYPES
+  );
+  var COLLECTION_TYPES_SET = new Set(
+    COLLECTION_TYPES
+  );
+  var SCALAR_TYPES_SET = new Set(
+    SCALAR_TYPES
+  );
+  var PRIMITIVE_TYPES_SET = new Set(
+    PRIMITIVE_TYPES
+  );
+  function isValidPrimitiveType(s) {
+    if (typeof s !== "string") return false;
+    return PRIMITIVE_TYPES_SET.has(s);
+  }
   function isValidType(t) {
-    if (typeof t === "string")
-      return PRIMITIVE_TYPES.includes(t);
+    if (typeof t === "string") return PRIMITIVE_TYPES_SET.has(t);
     if (typeof t !== "object") return false;
     if (!("kind" in t)) return false;
-    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "function" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
-  }
-
-  // src/common/type/serialize.ts
-  var NEGATION_PRECEDENCE = 3;
-  var UNION_PRECEDENCE = 1;
-  var INTERSECTION_PRECEDENCE = 2;
-  var LIST_PRECEDENCE = 4;
-  var RECORD_PRECEDENCE = 5;
-  var DICTIONARY_PRECEDENCE = 6;
-  var SET_PRECEDENCE = 7;
-  var COLLECTION_PRECEDENCE = 8;
-  var TUPLE_PRECEDENCE = 9;
-  var SIGNATURE_PRECEDENCE = 10;
-  var VALUE_PRECEDENCE = 11;
-  function typeToString(type, precedence = 0) {
-    if (typeof type === "string") return type;
-    let result = "";
-    switch (type.kind) {
-      case "value":
-        if (typeof type.value === "string") result = `"${type.value}"`;
-        else if (typeof type.value === "boolean")
-          result = type.value ? "true" : "false";
-        else result = type.value.toString();
-        break;
-      case "reference":
-        result = type.name;
-        break;
-      case "negation":
-        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
-        break;
-      case "union":
-        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
-        break;
-      case "intersection":
-        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
-        break;
-      case "expression":
-        result = `expression<${symbolName(type.operator)}>`;
-        break;
-      case "symbol":
-        result = `symbol<${symbolName(type.name)}>`;
-        break;
-      case "numeric":
-        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
-          result = `${type.type}<${type.lower}..${type.upper}>`;
-        } else if (Number.isFinite(type.lower)) {
-          result = `${type.type}<${type.lower}..>`;
-        } else if (Number.isFinite(type.upper)) {
-          result = `${type.type}<..${type.upper}>`;
-        } else {
-          result = `${type.type}`;
-        }
-        break;
-      case "list":
-        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES.includes(type.elements)) {
-          if (type.dimensions === void 0) {
-            if (type.elements === "number") result = "tensor";
-          } else if (type.dimensions.length === 1) {
-            if (type.elements === "number") {
-              if (type.dimensions[0] < 0) result = "vector";
-              else result = `vector<${type.dimensions[0]}>`;
-            } else {
-              if (type.dimensions[0] < 0)
-                result = `vector<${typeToString(type.elements)}>`;
-              else
-                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
-            }
-          } else if (type.dimensions.length === 2) {
-            const dims = type.dimensions;
-            if (type.elements === "number") {
-              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
-              else result = `matrix<${dims[0]}x${dims[1]}>`;
-            } else {
-              if (dims[0] < 0 && dims[1] < 0)
-                result = `matrix<${typeToString(type.elements)}>`;
-              else
-                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
-            }
-          }
-        }
-        if (!result) {
-          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
-          result = `list<${typeToString(type.elements)}${dimensions}>`;
-        }
-        break;
-      case "record":
-        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
-        result = `record<${elements}>`;
-        break;
-      case "dictionary":
-        result = `dictionary<${typeToString(type.values)}>`;
-        break;
-      case "set":
-        result = `set<${typeToString(type.elements)}>`;
-        break;
-      case "collection":
-        result = `collection<${typeToString(type.elements)}>`;
-        break;
-      case "indexed_collection":
-        result = `indexed_collection<${typeToString(type.elements)}>`;
-        break;
-      case "tuple":
-        if (type.elements.length === 0) result = "tuple";
-        else if (type.elements.length === 1) {
-          const [el] = type.elements;
-          result = `tuple<${namedElement(el)}>`;
-        } else {
-          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
-        }
-        break;
-      case "signature":
-        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
-        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
-        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
-        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
-        result = `(${argsList}) -> ${typeToString(type.result)}`;
-        break;
-      default:
-        result = "error";
-    }
-    if (precedence > 0 && precedence > getPrecedence(type.kind))
-      return `(${result})`;
-    return result;
-  }
-  function namedElement(el) {
-    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
-    return typeToString(el.type);
-  }
-  function symbolName(name) {
-    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
-    return `\`${name}\``;
-  }
-  function getPrecedence(kind) {
-    switch (kind) {
-      case "negation":
-        return NEGATION_PRECEDENCE;
-      case "union":
-        return UNION_PRECEDENCE;
-      case "intersection":
-        return INTERSECTION_PRECEDENCE;
-      case "list":
-        return LIST_PRECEDENCE;
-      case "record":
-        return RECORD_PRECEDENCE;
-      case "dictionary":
-        return DICTIONARY_PRECEDENCE;
-      case "set":
-        return SET_PRECEDENCE;
-      case "collection":
-      case "indexed_collection":
-        return COLLECTION_PRECEDENCE;
-      case "tuple":
-        return TUPLE_PRECEDENCE;
-      case "signature":
-        return SIGNATURE_PRECEDENCE;
-      case "value":
-        return VALUE_PRECEDENCE;
-      default:
-        return 0;
-    }
-  }
-
-  // src/common/fuzzy-string-match.ts
-  function levenshtein(source, target) {
-    if (source === target) return 0;
-    if (source.length === 0) return target.length;
-    if (target.length === 0) return source.length;
-    let prevRow = Array.from(
-      { length: source.length + 1 },
-      (_, j) => j
-    );
-    let currRow = new Array(source.length + 1);
-    for (let i = 1; i <= target.length; i++) {
-      currRow[0] = i;
-      for (let j = 1; j <= source.length; j++) {
-        const cost = source[j - 1] === target[i - 1] ? 0 : 1;
-        currRow[j] = Math.min(
-          prevRow[j] + 1,
-          // deletion
-          currRow[j - 1] + 1,
-          // insertion
-          prevRow[j - 1] + cost
-          // substitution
-        );
-      }
-      [prevRow, currRow] = [currRow, prevRow];
-    }
-    return prevRow[source.length];
-  }
-  function fuzzyStringMatch(invalidWord, validWords) {
-    const threshold = 7;
-    let bestMatch = null;
-    let minDistance = Infinity;
-    const invalidLength = invalidWord.length;
-    for (const word of validWords) {
-      if (Math.abs(invalidLength - word.length) > threshold) continue;
-      const distance = levenshtein(invalidWord, word);
-      if (distance === 0) return word;
-      if (distance <= threshold && distance < minDistance) {
-        minDistance = distance;
-        bestMatch = word;
-      }
-    }
-    return bestMatch;
+    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "value" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "symbol" || t.kind === "expression" || t.kind === "numeric" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
   }
 
   // src/common/type/lexer.ts
@@ -2481,19 +2403,13 @@ var Compile = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -2534,19 +2450,13 @@ var Compile = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -2577,16 +2487,30 @@ var Compile = (() => {
       return this.createNode("tensor", { elementType });
     }
     parseDimensions() {
-      const dimensions = [];
       const firstDim = this.parseDimension();
       if (!firstDim) return void 0;
-      dimensions.push(firstDim);
-      while (this.match("x")) {
-        const dim = this.parseDimension();
-        if (!dim) {
-          this.error("Expected dimension after x");
+      const dimensions = [firstDim];
+      for (; ; ) {
+        const tok = this.current;
+        if (tok.type === "IDENTIFIER" && /^(x\d+)+$/.test(tok.value)) {
+          this.advance();
+          for (const m of tok.value.match(/x(\d+)/g))
+            dimensions.push(
+              this.createNode("dimension", {
+                size: parseInt(m.slice(1))
+              })
+            );
+        } else if (tok.type === "IDENTIFIER" && tok.value === "x") {
+          const next = this.lexer.peekToken();
+          if (next.type !== "NUMBER_LITERAL" && next.type !== "?")
+            this.error(
+              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
+            );
+          this.advance();
+          dimensions.push(this.parseDimension());
+        } else {
+          break;
         }
-        dimensions.push(dim);
       }
       return dimensions;
     }
@@ -2600,35 +2524,11 @@ var Compile = (() => {
       }
       return void 0;
     }
-    parseDimensionWithX() {
-      if (this.current.type === "NUMBER_LITERAL") {
-        const dimensions = [];
-        const firstDim = parseInt(this.advance().value);
-        dimensions.push(
-          this.createNode("dimension", { size: firstDim })
-        );
-        if (this.current.type === "IDENTIFIER" && this.current.value.startsWith("x")) {
-          const dimString = this.current.value;
-          const matches = dimString.match(/x(\d+)/g);
-          if (matches && matches.join("") === dimString) {
-            this.advance();
-            for (const match of matches) {
-              const dimValue = parseInt(match.substring(1));
-              dimensions.push(
-                this.createNode("dimension", { size: dimValue })
-              );
-            }
-          } else if (dimString === "x" || dimString.startsWith("x")) {
-            this.error(
-              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
-            );
-          }
-        }
-        if (dimensions.length > 1) {
-          return dimensions;
-        }
-      }
-      return void 0;
+    parseCaretDimensions() {
+      const paren = this.match("(");
+      const dimensions = this.parseDimensions();
+      if (paren) this.expect(")");
+      return dimensions;
     }
     parseTupleType() {
       if (this.current.type === "IDENTIFIER" && this.current.value === "tuple") {
@@ -2813,6 +2713,18 @@ var Compile = (() => {
             this.expect("..");
             const upperBound = this.parseValue();
             this.expect(">");
+            const lower = lowerBound?.value ?? -Infinity;
+            const upper = upperBound?.value ?? Infinity;
+            if (Number.isNaN(lower) || Number.isNaN(upper))
+              this.error(
+                "Invalid numeric type",
+                "Lower and upper bounds must be valid numbers"
+              );
+            if (lower > upper)
+              this.error(
+                `Invalid range: ${lower}..${upper}`,
+                "The lower bound must be less than the upper bound"
+              );
             return this.createNode("numeric", {
               baseType,
               lowerBound,
@@ -2827,7 +2739,7 @@ var Compile = (() => {
     parsePrimitiveType() {
       if (this.current.type === "IDENTIFIER") {
         const name = this.current.value;
-        if (PRIMITIVE_TYPES.includes(name)) {
+        if (PRIMITIVE_TYPES_SET.has(name)) {
           this.advance();
           return this.createNode("primitive", { name });
         }
@@ -3161,14 +3073,32 @@ var Compile = (() => {
   }
 
   // src/common/type/parse.ts
+  var TYPE_CACHE = /* @__PURE__ */ new Map();
+  var TYPE_CACHE_MAX_SIZE = 2048;
+  function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (Object.isFrozen(obj)) return obj;
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) deepFreeze(value);
+    return obj;
+  }
   function parseType(s, typeResolver) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
     if (typeof s !== "string") return void 0;
+    const cacheable = typeResolver === void 0;
+    if (cacheable) {
+      const cached = TYPE_CACHE.get(s);
+      if (cached !== void 0) return cached;
+    }
     try {
       const parser = new Parser(s, { typeResolver });
       const ast = parser.parseType();
       const type = buildTypeFromAST(ast, typeResolver);
+      if (cacheable) {
+        if (TYPE_CACHE.size >= TYPE_CACHE_MAX_SIZE) TYPE_CACHE.clear();
+        TYPE_CACHE.set(s, deepFreeze(type));
+      }
       return type;
     } catch (error) {
       throw new Error(
@@ -3243,19 +3173,54 @@ var Compile = (() => {
     color: [],
     expression: EXPRESSION_TYPES
   };
+  var PRIMITIVE_SUBTYPES_CLOSURE = (() => {
+    const closure = {};
+    const closeOver = (t) => {
+      if (closure[t]) return closure[t];
+      const result = /* @__PURE__ */ new Set([t]);
+      closure[t] = result;
+      for (const sub2 of PRIMITIVE_SUBTYPES[t]) {
+        if (sub2 === t) continue;
+        for (const s of closeOver(sub2)) result.add(s);
+      }
+      return result;
+    };
+    for (const t of Object.keys(PRIMITIVE_SUBTYPES))
+      closeOver(t);
+    return closure;
+  })();
   function isPrimitiveSubtype(lhs, rhs) {
     if (rhs === "any") return true;
     if (lhs === "never") return true;
     if (lhs === "unknown" || rhs === "unknown") return false;
     if (lhs === rhs) return true;
-    return PRIMITIVE_SUBTYPES[rhs].includes(lhs);
+    return PRIMITIVE_SUBTYPES_CLOSURE[rhs].has(lhs);
+  }
+  function meetPrimitiveTypes(a, b) {
+    if (a === b) return [a];
+    const sa = PRIMITIVE_SUBTYPES_CLOSURE[a];
+    const sb = PRIMITIVE_SUBTYPES_CLOSURE[b];
+    if (sa.has(b)) return [b];
+    if (sb.has(a)) return [a];
+    const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+    const cached = MEET_CACHE.get(key);
+    if (cached) return cached;
+    const common = [];
+    for (const t of sa) if (sb.has(t)) common.push(t);
+    const maximals = common.filter(
+      (t) => !common.some((u) => u !== t && PRIMITIVE_SUBTYPES_CLOSURE[u].has(t))
+    );
+    MEET_CACHE.set(key, maximals);
+    return maximals;
   }
+  var MEET_CACHE = /* @__PURE__ */ new Map();
   function isSubtype(lhs, rhs) {
-    if (typeof lhs === "string" && !PRIMITIVE_TYPES.includes(lhs))
+    if (typeof lhs === "string" && !PRIMITIVE_TYPES_SET.has(lhs))
       lhs = parseType(lhs);
-    if (typeof rhs === "string" && !PRIMITIVE_TYPES.includes(rhs))
+    if (typeof rhs === "string" && !PRIMITIVE_TYPES_SET.has(rhs))
       rhs = parseType(rhs);
     if (rhs === "any") return true;
+    if (lhs === "never") return true;
     if (rhs === "never") return false;
     if (rhs === "error") return lhs === "error";
     if (rhs === "nothing") return lhs === "nothing";
@@ -3270,7 +3235,7 @@ var Compile = (() => {
         if (typeof lhs.value === "number") {
           if (Number.isInteger(lhs.value))
             return isPrimitiveSubtype("integer", rhs);
-          return isPrimitiveSubtype("number", rhs);
+          return isPrimitiveSubtype("real", rhs);
         }
         if (typeof lhs.value === "boolean")
           return isPrimitiveSubtype("boolean", rhs);
@@ -3500,7 +3465,7 @@ var Compile = (() => {
   }
   function isNumeric(type) {
     if (typeof type === "string")
-      return NUMERIC_TYPES.includes(type);
+      return NUMERIC_TYPES_SET.has(type);
     if (type.kind === "value") return typeof type.value === "number";
     if (type.kind === "numeric") return true;
     return false;
@@ -3508,7 +3473,7 @@ var Compile = (() => {
   function isScalar(type) {
     if (isNumeric(type)) return true;
     if (typeof type === "string")
-      return SCALAR_TYPES.includes(type);
+      return SCALAR_TYPES_SET.has(type);
     if (type.kind === "value")
       return ["string", "boolean", "number"].includes(typeof type.value);
     return false;
@@ -3516,7 +3481,7 @@ var Compile = (() => {
   function isCollection(type) {
     if (isIndexedCollection(type)) return true;
     if (typeof type === "string")
-      return COLLECTION_TYPES.includes(type);
+      return COLLECTION_TYPES_SET.has(type);
     return ["collection", "set", "record", "dictionary"].includes(type.kind);
   }
   function isIndexedCollection(type) {
@@ -3555,7 +3520,7 @@ var Compile = (() => {
     if (b === "unknown") return a;
     if (isSubtype(a, b)) return a;
     if (isSubtype(b, a)) return b;
-    return superType(a, b);
+    return "never";
   }
   function widen2(a, b) {
     if (a === b) return a;
@@ -3568,7 +3533,43 @@ var Compile = (() => {
     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 keys = /* @__PURE__ */ new Set();
+    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 (!keys.has(key)) {
+        keys.add(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";
@@ -3580,6 +3581,32 @@ var Compile = (() => {
     if (types.length === 1) return types[0];
     return types.reduce((a, b) => widen2(a, b));
   }
+  var SUPERTYPE_PROBE_ORDER = [
+    "non_finite_number",
+    "finite_integer",
+    "integer",
+    "finite_rational",
+    "rational",
+    "finite_real",
+    "real",
+    "imaginary",
+    "finite_complex",
+    "complex",
+    "finite_number",
+    "number",
+    "list",
+    "record",
+    "dictionary",
+    "set",
+    "tuple",
+    "indexed_collection",
+    "collection",
+    "scalar",
+    "value",
+    "function",
+    "expression"
+  ];
+  var PRIMITIVE_SUPERTYPE_CACHE = /* @__PURE__ */ new Map();
   function superType(a, b) {
     if (a === b) return a;
     if (a === "any" || b === "any") return "any";
@@ -3589,34 +3616,185 @@ var Compile = (() => {
     if (b === "unknown") return a;
     if (a === "nothing") return b;
     if (b === "nothing") return a;
-    if (commonSupertype(a, b, "non_finite_number")) return "non_finite_number";
-    if (commonSupertype(a, b, "finite_integer")) return "finite_integer";
-    if (commonSupertype(a, b, "integer")) return "integer";
-    if (commonSupertype(a, b, "finite_rational")) return "finite_rational";
-    if (commonSupertype(a, b, "rational")) return "rational";
-    if (commonSupertype(a, b, "finite_real")) return "finite_real";
-    if (commonSupertype(a, b, "real")) return "real";
-    if (commonSupertype(a, b, "imaginary")) return "imaginary";
-    if (commonSupertype(a, b, "finite_complex")) return "finite_complex";
-    if (commonSupertype(a, b, "complex")) return "complex";
-    if (commonSupertype(a, b, "finite_number")) return "finite_number";
-    if (commonSupertype(a, b, "number")) return "number";
-    if (commonSupertype(a, b, "list")) return "list";
-    if (commonSupertype(a, b, "record")) return "record";
-    if (commonSupertype(a, b, "dictionary")) return "dictionary";
-    if (commonSupertype(a, b, "set")) return "set";
-    if (commonSupertype(a, b, "tuple")) return "tuple";
-    if (commonSupertype(a, b, "indexed_collection")) return "indexed_collection";
-    if (commonSupertype(a, b, "collection")) return "collection";
-    if (commonSupertype(a, b, "scalar")) return "scalar";
-    if (commonSupertype(a, b, "value")) return "value";
-    if (commonSupertype(a, b, "function")) return "function";
-    if (commonSupertype(a, b, "expression")) return "expression";
+    if (typeof a === "string" && typeof b === "string") {
+      const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+      let result = PRIMITIVE_SUPERTYPE_CACHE.get(key);
+      if (result === void 0) {
+        result = "any";
+        for (const ancestor of SUPERTYPE_PROBE_ORDER) {
+          const subtypes = PRIMITIVE_SUBTYPES_CLOSURE[ancestor];
+          if (subtypes.has(a) && subtypes.has(b)) {
+            result = ancestor;
+            break;
+          }
+        }
+        PRIMITIVE_SUPERTYPE_CACHE.set(key, result);
+      }
+      return result;
+    }
+    for (const ancestor of SUPERTYPE_PROBE_ORDER)
+      if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return ancestor;
     return "any";
   }
-  function commonSupertype(a, b, ancestor) {
-    if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return true;
-    return false;
+
+  // src/common/type/serialize.ts
+  var NEGATION_PRECEDENCE = 3;
+  var UNION_PRECEDENCE = 1;
+  var INTERSECTION_PRECEDENCE = 2;
+  var LIST_PRECEDENCE = 4;
+  var RECORD_PRECEDENCE = 5;
+  var DICTIONARY_PRECEDENCE = 6;
+  var SET_PRECEDENCE = 7;
+  var COLLECTION_PRECEDENCE = 8;
+  var TUPLE_PRECEDENCE = 9;
+  var SIGNATURE_PRECEDENCE = 10;
+  var VALUE_PRECEDENCE = 11;
+  function typeToString(type, precedence = 0) {
+    if (typeof type === "string") return type;
+    let result = "";
+    switch (type.kind) {
+      case "value":
+        if (typeof type.value === "string") result = `"${type.value}"`;
+        else if (typeof type.value === "boolean")
+          result = type.value ? "true" : "false";
+        else result = type.value.toString();
+        break;
+      case "reference":
+        result = type.name;
+        break;
+      case "negation":
+        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
+        break;
+      case "union":
+        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
+        break;
+      case "intersection":
+        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
+        break;
+      case "expression":
+        result = `expression<${symbolName(type.operator)}>`;
+        break;
+      case "symbol":
+        result = `symbol<${symbolName(type.name)}>`;
+        break;
+      case "numeric":
+        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
+          result = `${type.type}<${type.lower}..${type.upper}>`;
+        } else if (Number.isFinite(type.lower)) {
+          result = `${type.type}<${type.lower}..>`;
+        } else if (Number.isFinite(type.upper)) {
+          result = `${type.type}<..${type.upper}>`;
+        } else {
+          result = `${type.type}`;
+        }
+        break;
+      case "list":
+        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES_SET.has(type.elements)) {
+          if (type.dimensions === void 0) {
+            if (type.elements === "number") result = "tensor";
+          } else if (type.dimensions.length === 1) {
+            if (type.elements === "number") {
+              if (type.dimensions[0] < 0) result = "vector";
+              else result = `vector<${type.dimensions[0]}>`;
+            } else {
+              if (type.dimensions[0] < 0)
+                result = `vector<${typeToString(type.elements)}>`;
+              else
+                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
+            }
+          } else if (type.dimensions.length === 2) {
+            const dims = type.dimensions;
+            if (type.elements === "number") {
+              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
+              else result = `matrix<${dims[0]}x${dims[1]}>`;
+            } else {
+              if (dims[0] < 0 && dims[1] < 0)
+                result = `matrix<${typeToString(type.elements)}>`;
+              else
+                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
+            }
+          }
+        }
+        if (!result) {
+          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
+          result = `list<${typeToString(type.elements)}${dimensions}>`;
+        }
+        break;
+      case "record":
+        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
+        result = `record<${elements}>`;
+        break;
+      case "dictionary":
+        result = `dictionary<${typeToString(type.values)}>`;
+        break;
+      case "set":
+        result = `set<${typeToString(type.elements)}>`;
+        break;
+      case "collection":
+        result = `collection<${typeToString(type.elements)}>`;
+        break;
+      case "indexed_collection":
+        result = `indexed_collection<${typeToString(type.elements)}>`;
+        break;
+      case "tuple":
+        if (type.elements.length === 0) result = "tuple";
+        else if (type.elements.length === 1) {
+          const [el] = type.elements;
+          result = `tuple<${namedElement(el)}>`;
+        } else {
+          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
+        }
+        break;
+      case "signature":
+        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
+        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
+        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
+        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
+        result = `(${argsList}) -> ${typeToString(type.result)}`;
+        break;
+      default:
+        result = "error";
+    }
+    if (precedence > 0 && precedence > getPrecedence(type.kind))
+      return `(${result})`;
+    return result;
+  }
+  function namedElement(el) {
+    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
+    return typeToString(el.type);
+  }
+  function symbolName(name) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
+    return `\`${name}\``;
+  }
+  function getPrecedence(kind) {
+    switch (kind) {
+      case "negation":
+        return NEGATION_PRECEDENCE;
+      case "union":
+        return UNION_PRECEDENCE;
+      case "intersection":
+        return INTERSECTION_PRECEDENCE;
+      case "list":
+        return LIST_PRECEDENCE;
+      case "record":
+        return RECORD_PRECEDENCE;
+      case "dictionary":
+        return DICTIONARY_PRECEDENCE;
+      case "set":
+        return SET_PRECEDENCE;
+      case "collection":
+      case "indexed_collection":
+        return COLLECTION_PRECEDENCE;
+      case "tuple":
+        return TUPLE_PRECEDENCE;
+      case "signature":
+        return SIGNATURE_PRECEDENCE;
+      case "value":
+        return VALUE_PRECEDENCE;
+      default:
+        return 0;
+    }
   }
 
   // src/common/type/utils.ts
@@ -3642,7 +3820,7 @@ var Compile = (() => {
     if (type.kind === "set") return type.elements;
     if (type.kind === "tuple") return widen(...type.elements.map((x) => x.type));
     if (type.kind === "dictionary")
-      return parseType(`tuple<string, ${type.values}>`);
+      return parseType(`tuple<string, ${typeToString(type.values)}>`);
     if (type.kind === "record") {
       return parseType(
         `tuple<string, ${typeToString(widen(...Object.values(type.elements)))}>`
@@ -3725,6 +3903,12 @@ var Compile = (() => {
     return expr?._kind === "symbol" ? expr.symbol : void 0;
   }
 
+  // src/compute-engine/boxed-expression/constraint-subject.ts
+  var EMPTY_FACT_INDEX = Object.freeze({
+    bySubject: /* @__PURE__ */ new Map(),
+    membership: /* @__PURE__ */ new Map()
+  });
+
   // src/compute-engine/boxed-expression/stochastic-equal.ts
   var WELL_KNOWN_POINTS = [
     0,
@@ -3973,6 +4157,7 @@ var Compile = (() => {
   }
 
   // src/compute-engine/collection-utils.ts
+  var MAX_SIZE_EAGER_COLLECTION = 100;
   function isFiniteIndexedCollection(col) {
     return (col.isFiniteCollection ?? false) && col.isIndexedCollection;
   }
@@ -4601,12 +4786,14 @@ var Compile = (() => {
     if (expr === null) return null;
     if (isDictionaryObject(expr)) return expr;
     const kv = keyValuePair(expr);
-    if (kv) return { [kv[0]]: kv[1] };
+    if (kv)
+      return {
+        dict: { [kv[0]]: expressionToDictionaryValue(kv[1]) ?? "Nothing" }
+      };
     if (operator(expr) === "Dictionary") {
       const dict = {};
-      const ops = operands(expr);
-      for (let i = 1; i < nops(expr); i++) {
-        const kv2 = keyValuePair(ops[i]);
+      for (const op of operands(expr)) {
+        const kv2 = keyValuePair(op);
         if (kv2) {
           dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
         }
@@ -5544,15 +5731,16 @@ var Compile = (() => {
       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, expr) => joinLatex([
         serializer.serialize(operand(expr, 1)),
         "\\colon",
@@ -5563,7 +5751,7 @@ var Compile = (() => {
       latexTrigger: "\\colon",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       parse: "Colon"
     },
     {
@@ -6539,6 +6727,7 @@ var Compile = (() => {
           }
         }
         if (!variable) return null;
+        if (symbol(variable) === null) return null;
         parser.skipSpace();
         const fn = parser.parseExpression({ minPrec: 740 });
         if (!fn) return null;
@@ -6725,7 +6914,7 @@ var Compile = (() => {
     if (runs.length === 1) body = runs[0];
     else {
       if (runs.every((x) => stringValue(x) !== null))
-        body = "'" + runs.map((x) => stringValue(x)).join() + "'";
+        body = "'" + runs.map((x) => stringValue(x)).join("") + "'";
       else body = ["Text", ...runs];
     }
     return style ? ["Annotated", body, dictionaryFromEntries(style)] : body;
@@ -7133,7 +7322,10 @@ var Compile = (() => {
         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 = [];
@@ -7174,6 +7366,25 @@ var Compile = (() => {
       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);
@@ -7387,6 +7598,17 @@ var Compile = (() => {
     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
@@ -7645,18 +7867,58 @@ var Compile = (() => {
       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 expr = operand(body, 1);
           const condition = operand(body, 2);
           if (expr !== null && condition !== null)
             return ["Set", expr, ["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, expr) => {
         if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
@@ -8185,6 +8447,8 @@ var Compile = (() => {
         const h = operator(arg);
         if (prevWasNumber && (h === "Divide" || h === "Rational")) {
           result = latexTemplate(serializer.options.multiply, result, term);
+        } else if (/^\d/.test(term)) {
+          result = latexTemplate(serializer.options.multiply, result, term);
         } else if (!serializer.options.invisibleMultiply) {
           result = joinLatex([result, term]);
         } else {
@@ -9630,7 +9894,9 @@ var Compile = (() => {
         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 isTwoArgArctan = args?.length === 2 && (fn === "Arctan" || Array.isArray(fn) && fn[0] === "InverseFunction" && fn[1] === "Tan");
+      const head = isTwoArgArctan ? "Arctan2" : fn;
+      const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
       return sup === null ? appliedFn : ["Power", appliedFn, sup];
     };
   }
@@ -11753,10 +12019,17 @@ var Compile = (() => {
     // 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
@@ -11909,6 +12182,30 @@ var Compile = (() => {
   var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
   var EMOJIS = new RegExp(`^(?:${POSSIBLE_EMOJI})+$`, "u");
 
+  // src/compute-engine/latex-syntax/parse.ts
+  var PARSE_TOKEN_EXCLUDED = /* @__PURE__ */ new Set([
+    ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
+    "\\left",
+    "\\bigl",
+    "\\mleft"
+  ]);
+  var TEX_UNIT_TOKENS = [
+    "pt",
+    "em",
+    "mu",
+    "ex",
+    "mm",
+    "cm",
+    "in",
+    "bp",
+    "sp",
+    "dd",
+    "cc",
+    "pc",
+    "nc",
+    "nd"
+  ].map((unit) => [...unit]);
+
   // src/compute-engine/boxed-expression/utils.ts
   function isValueDef(def) {
     return def !== void 0 && "value" in def;
@@ -11944,6 +12241,50 @@ var Compile = (() => {
     return ys;
   }
 
+  // src/common/fuzzy-string-match.ts
+  function levenshtein(source, target) {
+    if (source === target) return 0;
+    if (source.length === 0) return target.length;
+    if (target.length === 0) return source.length;
+    let prevRow = Array.from(
+      { length: source.length + 1 },
+      (_, j) => j
+    );
+    let currRow = new Array(source.length + 1);
+    for (let i = 1; i <= target.length; i++) {
+      currRow[0] = i;
+      for (let j = 1; j <= source.length; j++) {
+        const cost = source[j - 1] === target[i - 1] ? 0 : 1;
+        currRow[j] = Math.min(
+          prevRow[j] + 1,
+          // deletion
+          currRow[j - 1] + 1,
+          // insertion
+          prevRow[j - 1] + cost
+          // substitution
+        );
+      }
+      [prevRow, currRow] = [currRow, prevRow];
+    }
+    return prevRow[source.length];
+  }
+  function fuzzyStringMatch(invalidWord, validWords) {
+    const threshold = 7;
+    let bestMatch = null;
+    let minDistance = Infinity;
+    const invalidLength = invalidWord.length;
+    for (const word of validWords) {
+      if (Math.abs(invalidLength - word.length) > threshold) continue;
+      const distance = levenshtein(invalidWord, word);
+      if (distance === 0) return word;
+      if (distance <= threshold && distance < minDistance) {
+        minDistance = distance;
+        bestMatch = word;
+      }
+    }
+    return bestMatch;
+  }
+
   // src/compute-engine/boxed-expression/validate.ts
   function checkArity(ce, ops, count) {
     ops = flatten(ops);
@@ -12886,12 +13227,240 @@ ${lines.join("\n")}`;
   Complex["EPSILON"] = 1e-15;
 
   // src/compute-engine/boxed-expression/numerics.ts
+  function asSmallInteger(expr) {
+    if (expr === void 0 || expr === null) return null;
+    if (typeof expr === "number") {
+      if (Number.isInteger(expr) && expr >= -SMALL_INTEGER && expr <= SMALL_INTEGER)
+        return expr;
+      return null;
+    }
+    if (!isNumber(expr)) return null;
+    const num = expr.numericValue;
+    if (typeof num === "number") {
+      if (Number.isInteger(num) && num >= -SMALL_INTEGER && num <= SMALL_INTEGER)
+        return num;
+      return null;
+    }
+    if (num.im !== 0) return null;
+    const n = num.re;
+    if (Number.isInteger(n) && n >= -SMALL_INTEGER && n <= SMALL_INTEGER)
+      return Number(n);
+    return null;
+  }
   function toInteger(expr) {
     if (!isNumber(expr)) return null;
     const num = expr.numericValue;
     return Math.round(typeof num === "number" ? num : num.re);
   }
 
+  // src/compute-engine/library/logic-analysis.ts
+  function filterValuesWithCondition(values, variable, conditionExpr, _ce) {
+    return values.filter((value) => {
+      const substituted = conditionExpr.subs({ [variable]: value });
+      const result = substituted.evaluate();
+      return sym(result) === "True";
+    });
+  }
+  function extractFiniteDomainWithReason(condition, ce) {
+    if (condition.operator !== "Element") {
+      return { status: "error", reason: "expected-element-expression" };
+    }
+    if (!isFunction2(condition)) {
+      return { status: "error", reason: "expected-element-expression" };
+    }
+    const variable = isSymbol2(condition.op1) ? condition.op1.symbol : void 0;
+    if (!variable) {
+      return { status: "error", reason: "expected-index-variable" };
+    }
+    const domain = condition.op2;
+    if (!domain) {
+      return { status: "error", reason: "expected-domain" };
+    }
+    const maybeCondition = condition.op3;
+    const filterCondition = condition.nops >= 3 && maybeCondition && sym(maybeCondition) !== "Nothing" ? maybeCondition : null;
+    const successResult = (values) => {
+      if (filterCondition) {
+        const filteredValues = filterValuesWithCondition(
+          values,
+          variable,
+          filterCondition,
+          ce
+        );
+        return { status: "success", variable, values: filteredValues };
+      }
+      return { status: "success", variable, values };
+    };
+    if (domain.operator === "Set" || domain.operator === "List") {
+      const values = isFunction2(domain) ? domain.ops : void 0;
+      if (values && values.length <= 1e3) {
+        if (domain.operator === "List" && values.length === 2) {
+          const start = asSmallInteger(values[0]);
+          const end = asSmallInteger(values[1]);
+          if (start !== null && end !== null) {
+            const count = end - start + 1;
+            if (count > 0 && count <= 1e3) {
+              const rangeValues = [];
+              for (let i = start; i <= end; i++) {
+                rangeValues.push(ce.number(i));
+              }
+              return successResult(rangeValues);
+            }
+            if (count > 1e3) {
+              return {
+                status: "non-enumerable",
+                variable,
+                domain,
+                reason: "domain-too-large"
+              };
+            }
+          }
+        }
+        return successResult([...values]);
+      }
+      if (values && values.length > 1e3) {
+        return {
+          status: "non-enumerable",
+          variable,
+          domain,
+          reason: "domain-too-large"
+        };
+      }
+      return { status: "error", reason: "empty-domain" };
+    }
+    if (isFunction2(domain, "Range")) {
+      const start = asSmallInteger(domain.op1);
+      const end = asSmallInteger(domain.op2);
+      const step = domain.ops.length >= 3 ? asSmallInteger(domain.op3) : 1;
+      if (start !== null && end !== null && step !== null && step !== 0) {
+        const count = Math.floor((end - start) / step) + 1;
+        if (count > 0 && count <= 1e3) {
+          const values = [];
+          for (let i = start; step > 0 ? i <= end : i >= end; i += step) {
+            values.push(ce.number(i));
+          }
+          return successResult(values);
+        }
+        if (count > 1e3) {
+          return {
+            status: "non-enumerable",
+            variable,
+            domain,
+            reason: "domain-too-large"
+          };
+        }
+      }
+      return {
+        status: "non-enumerable",
+        variable,
+        domain,
+        reason: "non-integer-bounds"
+      };
+    }
+    if (isFunction2(domain, "Interval")) {
+      let op1 = domain.op1;
+      let op2 = domain.op2;
+      let openStart = false;
+      let openEnd = false;
+      if (isFunction2(op1, "Open")) {
+        openStart = true;
+        op1 = op1.op1;
+      } else if (isFunction2(op1, "Closed")) {
+        op1 = op1.op1;
+      }
+      if (isFunction2(op2, "Open")) {
+        openEnd = true;
+        op2 = op2.op1;
+      } else if (isFunction2(op2, "Closed")) {
+        op2 = op2.op1;
+      }
+      let start = asSmallInteger(op1);
+      let end = asSmallInteger(op2);
+      if (start !== null && end !== null) {
+        if (openStart) start += 1;
+        if (openEnd) end -= 1;
+        const count = end - start + 1;
+        if (count > 0 && count <= 1e3) {
+          const values = [];
+          for (let i = start; i <= end; i++) {
+            values.push(ce.number(i));
+          }
+          return successResult(values);
+        }
+        if (count > 1e3) {
+          return {
+            status: "non-enumerable",
+            variable,
+            domain,
+            reason: "domain-too-large"
+          };
+        }
+      }
+      return {
+        status: "non-enumerable",
+        variable,
+        domain,
+        reason: "non-integer-bounds"
+      };
+    }
+    const domainSymbol = sym(domain);
+    if (domainSymbol) {
+      const knownInfiniteSets = [
+        "Integers",
+        "NonNegativeIntegers",
+        "PositiveIntegers",
+        "NegativeIntegers",
+        "Rationals",
+        "Reals",
+        "PositiveReals",
+        "NonNegativeReals",
+        "NegativeReals",
+        "NonPositiveReals",
+        "ExtendedReals",
+        "Complexes",
+        "ImaginaryNumbers",
+        "Numbers",
+        "ExtendedComplexes",
+        "AlgebraicNumbers",
+        "TranscendentalNumbers"
+      ];
+      if (knownInfiniteSets.includes(domainSymbol)) {
+        return {
+          status: "non-enumerable",
+          variable,
+          domain,
+          reason: "infinite-domain"
+        };
+      }
+      const domainValue = domain.value;
+      if (domainValue && domainValue.operator === "Set" && isFunction2(domainValue)) {
+        const values = domainValue.ops;
+        if (values && values.length <= 1e3) {
+          return successResult([...values]);
+        }
+        if (values && values.length > 1e3) {
+          return {
+            status: "non-enumerable",
+            variable,
+            domain,
+            reason: "domain-too-large"
+          };
+        }
+      }
+      return {
+        status: "non-enumerable",
+        variable,
+        domain,
+        reason: "unknown-domain"
+      };
+    }
+    return {
+      status: "non-enumerable",
+      variable,
+      domain,
+      reason: "unrecognized-domain-type"
+    };
+  }
+
   // src/compute-engine/numerics/interval.ts
   function isNumber2(expr) {
     return expr?._kind === "number";
@@ -12946,6 +13515,20 @@ ${lines.join("\n")}`;
     }
     return void 0;
   }
+  function intervalContains(int, val) {
+    if (int.openStart ? val <= int.start : val < int.start) return false;
+    if (int.openEnd ? val >= int.end : val > int.end) return false;
+    return true;
+  }
+
+  // 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) {
@@ -12953,8 +13536,236 @@ ${lines.join("\n")}`;
     return xs.map((x) => ce.expr(x, { scope }));
   }
 
+  // src/common/type/reduce.ts
+  function reduceType(type) {
+    if (typeof type === "string") {
+      if (!isValidPrimitiveType(type)) return "error";
+      return type;
+    }
+    switch (type.kind) {
+      case "union":
+        return reduceUnionType(type);
+      case "intersection":
+        return reduceIntersectionType(type);
+      case "negation":
+        return reduceNegationType(type);
+      case "collection":
+      case "indexed_collection":
+        return reduceCollectionType(type.kind, type);
+      case "list":
+        return reduceListType(type);
+      case "set":
+        return reduceSetType(type);
+      case "tuple":
+        return reduceTupleType(type);
+      case "record":
+        return reduceRecordType(type);
+      case "dictionary":
+        return reduceDictionaryType(type);
+      case "signature":
+        return reduceSignatureType(type);
+      case "value":
+        return type;
+      case "reference":
+        return type;
+      default:
+        throw new Error(`Unknown type kind: ${type}`);
+    }
+  }
+  function decorate(t) {
+    if (typeof t !== "object") return t;
+    if (Object.isFrozen(t) || Object.prototype.hasOwnProperty.call(t, "toString"))
+      return t;
+    Object.defineProperty(t, "toString", { value: () => typeToString(t) });
+    return t;
+  }
+  function reduceMembers(types) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of types) {
+      const reduced = reduceType(t);
+      const key = typeof reduced === "string" ? reduced : typeToString(reduced);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(reduced);
+      }
+    }
+    return result;
+  }
+  function reduceNegationType(type) {
+    const reducedType = reduceType(type.type);
+    if (reducedType === "nothing") return "any";
+    if (reducedType === "any") return "nothing";
+    return decorate({ kind: "negation", type: reducedType });
+  }
+  function reduceUnionType(type) {
+    const reducedTypes = reduceMembers(type.types);
+    if (reducedTypes.length === 0) return "never";
+    if (reducedTypes.some((type2) => type2 === "error")) return "error";
+    if (reducedTypes.length === 1) return decorate(reducedTypes[0]);
+    const acc = [];
+    for (const current of reducedTypes) {
+      if (acc.some((t) => isSubtype(current, t))) continue;
+      for (let i = acc.length - 1; i >= 0; i--)
+        if (isSubtype(acc[i], current)) acc.splice(i, 1);
+      acc.push(current);
+    }
+    if (acc.length === 1) return decorate(acc[0]);
+    return decorate({ kind: "union", types: acc });
+  }
+  function meet2(a, b) {
+    if (isSubtype(a, b)) return a;
+    if (isSubtype(b, a)) return b;
+    if (typeof a === "object" && a.kind === "union") return meetUnion(a.types, b);
+    if (typeof b === "object" && b.kind === "union") return meetUnion(b.types, a);
+    if (typeof a === "string" && typeof b === "string") {
+      const maximals = meetPrimitiveTypes(a, b);
+      if (maximals.length === 0) return "nothing";
+      if (maximals.length === 1) return maximals[0];
+      return { kind: "union", types: maximals };
+    }
+    return "nothing";
+  }
+  function meetUnion(types, b) {
+    const members = types.map((t) => meet2(t, b)).filter((t) => t !== "nothing");
+    if (members.length === 0) return "nothing";
+    if (members.length === 1) return members[0];
+    return reduceUnionType({ kind: "union", types: members });
+  }
+  function reduceIntersectionType(type) {
+    const reducedTypes = reduceMembers(type.types);
+    if (reducedTypes.length === 0) return "nothing";
+    if (reducedTypes.some((type2) => type2 === "error")) return "error";
+    let result = reducedTypes[0];
+    for (let i = 1; i < reducedTypes.length; i++) {
+      result = meet2(result, reducedTypes[i]);
+      if (result === "nothing") return "nothing";
+    }
+    return decorate(result);
+  }
+  function reduceCollectionType(kind, type) {
+    const reducedType = reduceType(type.elements);
+    if (reducedType === "error") return "error";
+    if (reducedType === "nothing") return decorate({ kind, elements: "nothing" });
+    if (reducedType === "any") return kind;
+    return decorate({
+      ...type,
+      elements: reducedType
+    });
+  }
+  function reduceListType(type) {
+    const reducedType = reduceType(type.elements);
+    if (reducedType === "error") return "error";
+    if (reducedType === "nothing")
+      return decorate({ kind: "list", elements: "nothing" });
+    if (reducedType === "any") return "list";
+    let dimensions = type.dimensions;
+    if (dimensions) {
+      dimensions = dimensions.filter((dim) => dim >= 1 || dim === -1);
+      if (dimensions.length === 0) return "nothing";
+    }
+    return decorate({
+      ...type,
+      dimensions,
+      elements: reducedType
+    });
+  }
+  function reduceSetType(type) {
+    const reducedType = reduceType(type.elements);
+    if (reducedType === "error") return "error";
+    if (reducedType === "nothing")
+      return decorate({ kind: "set", elements: "nothing" });
+    if (reducedType === "any") return "set";
+    return decorate({
+      ...type,
+      elements: reducedType
+    });
+  }
+  function reduceTupleType(type) {
+    let reducedElements = type.elements.map((element) => ({
+      ...element,
+      type: reduceType(element.type)
+    }));
+    if (reducedElements.length === 0) return "nothing";
+    if (reducedElements.some((element) => element.type === "error"))
+      return "error";
+    reducedElements = reducedElements.filter(
+      (element) => element.type !== "nothing"
+    );
+    return decorate({
+      ...type,
+      elements: reducedElements
+    });
+  }
+  function reduceRecordType(type) {
+    let reducedElements = {};
+    for (const [key, value] of Object.entries(type.elements))
+      reducedElements[key] = reduceType(value);
+    if (Object.values(reducedElements).some((type2) => type2 === "error"))
+      return "error";
+    reducedElements = Object.fromEntries(
+      Object.entries(reducedElements).filter(([_, value]) => value !== "nothing")
+    );
+    if (Object.keys(reducedElements).length === 0) return "record";
+    return decorate({
+      ...type,
+      elements: reducedElements
+    });
+  }
+  function reduceDictionaryType(type) {
+    const reducedValues = reduceType(type.values);
+    if (reducedValues === "error") return "error";
+    if (reducedValues === "nothing") return "error";
+    if (reducedValues === "any" || reducedValues === "unknown") return "any";
+    return decorate({ kind: "dictionary", values: reducedValues });
+  }
+  function reduceSignatureType(type) {
+    const reducedArgs = type.args?.map((arg) => ({
+      ...arg,
+      type: reduceType(arg.type)
+    }));
+    let reducedOptArgs = type.optArgs?.map((arg) => ({
+      ...arg,
+      type: reduceType(arg.type)
+    }));
+    let reducedVarArg = type.variadicArg ? {
+      ...type.variadicArg,
+      type: reduceType(type.variadicArg.type)
+    } : void 0;
+    const reducedResult = reduceType(type.result);
+    if (reducedArgs?.some((arg) => arg.type === "error")) return "error";
+    if (reducedOptArgs?.some((arg) => arg.type === "error")) return "error";
+    if (reducedVarArg?.type === "error") return "error";
+    if (reducedResult === "error") return "error";
+    reducedOptArgs = reducedOptArgs?.filter((arg) => arg.type !== "nothing");
+    if (reducedArgs?.length === 0) reducedOptArgs = void 0;
+    if (reducedOptArgs?.length === 0) reducedOptArgs = void 0;
+    if (reducedVarArg?.type === "nothing") reducedVarArg = void 0;
+    return decorate({
+      ...type,
+      args: reducedArgs,
+      optArgs: reducedOptArgs,
+      variadicArg: reducedVarArg,
+      variadicMin: reducedVarArg ? type.variadicMin : void 0,
+      result: reducedResult
+    });
+  }
+
+  // src/compute-engine/library/sets.ts
+  function typeIntersection(a, b) {
+    return reduceType({ kind: "intersection", types: [a, b] });
+  }
+  function typeMembership(x, t) {
+    const vt = x.type;
+    if (vt.matches(t)) return true;
+    if (typeIntersection(vt.type, t) === "nothing") return false;
+    if (isNumber(x)) return false;
+    return void 0;
+  }
+
   // src/compute-engine/library/collections.ts
   var DEFAULT_LINSPACE_COUNT = 50;
+  var SET_BASE_HANDLERS = basicIndexedCollectionHandlers();
   var COLLECTIONS_LIBRARY = {
     //
     // Data Structures
@@ -12977,11 +13788,38 @@ ${lines.join("\n")}`;
     },
     // Extensional set. Elements do not repeat. The order of the elements is not significant.
     // For intensional set, use `Filter` with a condition, e.g. `Filter(RealNumbers, _ > 0)`
+    //
+    // A `Set` expression can also be a set-builder (comprehension), e.g.
+    // `["Set", body, ["Element", k, domain, cond?]]` or
+    // `["Set", body, ["Condition", ...]]` (see `parseSetComprehension()`).
+    // Comprehensions are not literal 2-element sets: their elements are the
+    // substituted bodies over the (filtered) domain.
     Set: {
       complexity: 8200,
       signature: "(any*) -> set",
-      type: (ops, { engine: _ce }) => parseType(`set<${BoxedType.widen(...ops.map((op) => op.type))}>`),
+      type: (ops, { engine: _ce }) => {
+        if (parseSetComprehension(ops) !== null) return parseType("set");
+        return parseType(`set<${BoxedType.widen(...ops.map((op) => op.type))}>`);
+      },
       canonical: canonicalSet,
+      // The `lazy` flag suppresses the default operand evaluation: evaluating
+      // the operands of a comprehension would mangle its indexing set (e.g.
+      // the condition `gcd(n,k) = 1` with a free `k` evaluates to `False`).
+      // Literal elements are evaluated explicitly in the `evaluate` handler.
+      lazy: true,
+      evaluate: (ops, { engine: ce, numericApproximation, materialization }) => {
+        const comp = parseSetComprehension(ops);
+        if (comp !== null) {
+          const elements = enumerateSetComprehension(comp);
+          if (elements === void 0 || elements.length > MAX_SIZE_EAGER_COLLECTION)
+            return void 0;
+          return ce.function("Set", elements);
+        }
+        return ce.function(
+          "Set",
+          ops.map((op) => op.evaluate({ numericApproximation, materialization }))
+        );
+      },
       eq: (a, b) => {
         if (a.operator !== b.operator) return false;
         if (!isFunction2(a) || !isFunction2(b)) return false;
@@ -12990,10 +13828,75 @@ ${lines.join("\n")}`;
         return a.ops.every(has);
       },
       collection: {
-        ...basicIndexedCollectionHandlers(),
+        ...SET_BASE_HANDLERS,
         // A set is not indexable
         at: void 0,
-        indexWhere: void 0
+        indexWhere: void 0,
+        // A comprehension computes its elements on demand
+        isLazy: (expr) => isFunction2(expr) && parseSetComprehension(expr.ops) !== null,
+        count: (expr) => {
+          if (!isFunction2(expr)) return 0;
+          const comp = parseSetComprehension(expr.ops);
+          if (comp === null) return expr.nops;
+          return enumerateSetComprehension(comp)?.length;
+        },
+        isEmpty: (expr) => {
+          if (!isFunction2(expr)) return true;
+          const comp = parseSetComprehension(expr.ops);
+          if (comp === null) return expr.nops === 0;
+          const elements = enumerateSetComprehension(comp);
+          return elements === void 0 ? void 0 : elements.length === 0;
+        },
+        isFinite: (expr) => {
+          if (!isFunction2(expr)) return true;
+          const comp = parseSetComprehension(expr.ops);
+          if (comp === null) return true;
+          if (enumerateSetComprehension(comp) !== void 0) return true;
+          if (comp.domain?.isFiniteCollection === true) return true;
+          return void 0;
+        },
+        iterator: (expr) => {
+          if (!isFunction2(expr)) return SET_BASE_HANDLERS.iterator(expr);
+          const comp = parseSetComprehension(expr.ops);
+          if (comp === null) return SET_BASE_HANDLERS.iterator(expr);
+          const elements = enumerateSetComprehension(comp);
+          if (elements === void 0) return void 0;
+          let i = 0;
+          return {
+            next: () => i >= elements.length ? { value: void 0, done: true } : { value: elements[i++], done: false }
+          };
+        },
+        // Three-valued membership: `true` when an element matches, `false`
+        // only when every element is definitively different from `target`
+        // (concrete values), `undefined` otherwise — e.g. a symbolic target
+        // (`Element(ω, {-1, 1})`) is indeterminate, not refuted.
+        contains: (expr, target) => {
+          if (!isFunction2(expr)) return void 0;
+          const comp = parseSetComprehension(expr.ops);
+          if (comp !== null) return setComprehensionContains(comp, target);
+          return literalSetContains(expr.ops, target);
+        },
+        elttype: (expr) => {
+          if (!isFunction2(expr)) return SET_BASE_HANDLERS.elttype(expr);
+          const comp = parseSetComprehension(expr.ops);
+          if (comp === null) return SET_BASE_HANDLERS.elttype(expr);
+          const elements = enumerateSetComprehension(comp);
+          if (elements === void 0 || elements.length === 0) return "unknown";
+          return widen(...elements.map((op) => op.type.type));
+        }
+      }
+    },
+    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: {
@@ -13080,7 +13983,12 @@ ${lines.join("\n")}`;
         },
         contains: (expr, target) => {
           const t = target.re;
+          if (Number.isNaN(t))
+            return typeMembership(target, "number") === false ? false : void 0;
+          if (target.im !== 0) return false;
           if (!isFinite(t)) return false;
+          if (isFunction2(expr) && expr.ops.some((op) => Number.isNaN(op.re)))
+            return void 0;
           const [lower, upper, step] = range(expr);
           if (step === 0) return false;
           if (step > 0) {
@@ -13156,13 +14064,23 @@ ${lines.join("\n")}`;
       signature: "(number, number) -> set<real>",
       canonical: ([lo, hi], { engine }) => {
         if (!lo || !hi) return null;
+        const unwrap2 = (op) => {
+          if (isFunction2(op, "Open")) return [op.op1, true];
+          if (isFunction2(op, "Closed")) return [op.op1, false];
+          return [op, false];
+        };
+        const [loVal, loOpen] = unwrap2(lo);
+        const [hiVal, hiOpen] = unwrap2(hi);
         const [lower, upper] = checkTypes(
           engine,
-          [lo.canonical, hi.canonical],
+          [loVal.canonical, hiVal.canonical],
           ["number", "number"]
         );
         if (!lower.isValid || !upper.isValid) return null;
-        return engine._fn("Interval", [lower, upper]);
+        return engine._fn("Interval", [
+          loOpen ? engine._fn("Open", [lower]) : lower,
+          hiOpen ? engine._fn("Open", [upper]) : upper
+        ]);
       },
       eq: (a, b) => {
         const intervalA = interval(a);
@@ -13197,19 +14115,32 @@ ${lines.join("\n")}`;
         },
         isEmpty: (_expr) => {
           const int = interval(_expr);
-          if (!int) return false;
+          if (!int) return void 0;
           if (int.openStart && int.start === int.end) return true;
           if (int.openEnd && int.start === int.end) return true;
           if (int.openStart && int.openEnd) return false;
           return int.start >= int.end;
         },
         isFinite: (_expr) => false,
+        // Three-valued membership: `true` only when both bound checks are
+        // entailed, `false` when a bound check (or the type of the target)
+        // refutes membership, `undefined` otherwise (e.g. symbolic target
+        // with unknown bounds). Endpoints may be ±Infinity.
         contains: (expr, target) => {
           const int = interval(expr);
-          if (!int) return false;
-          if (int.openStart && target.isLessEqual(int.start)) return false;
-          if (int.openEnd && target.isGreaterEqual(int.end)) return false;
-          return target.isGreaterEqual(int.start) && target.isLessEqual(int.end);
+          if (!int) return void 0;
+          if (typeMembership(target, "number") === false) return false;
+          const t = target.re;
+          if (!Number.isNaN(t)) {
+            if (target.im !== 0) return false;
+            return intervalContains(int, t);
+          }
+          const aboveLower = int.openStart ? target.isGreater(int.start) : target.isGreaterEqual(int.start);
+          if (aboveLower === false) return false;
+          const belowUpper = int.openEnd ? target.isLess(int.end) : target.isLessEqual(int.end);
+          if (belowUpper === false) return false;
+          if (aboveLower === true && belowUpper === true) return true;
+          return void 0;
         },
         eltsgn: (expr) => {
           const i = interval(expr);
@@ -13249,10 +14180,12 @@ ${lines.join("\n")}`;
           const upper = expr.op2.re;
           let count = expr.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 expr.engine.number(lower);
           return expr.engine.number(
-            lower + (upper - lower) * (index - 1) / count
+            lower + (upper - lower) * (index - 1) / (count - 1)
           );
         },
         iterator: (expr) => {
@@ -13271,6 +14204,8 @@ ${lines.join("\n")}`;
               !isFinite(expr.op3.re) ? DEFAULT_LINSPACE_COUNT : expr.op3.re
             );
           }
+          totalCount = Math.floor(totalCount);
+          const denom = totalCount > 1 ? totalCount - 1 : 1;
           let index = 1;
           return {
             next: () => {
@@ -13279,7 +14214,7 @@ ${lines.join("\n")}`;
               index += 1;
               return {
                 value: expr.engine.number(
-                  lower + (upper - lower) * (index - 1 - 1) / totalCount
+                  lower + (upper - lower) * (index - 1 - 1) / denom
                 ),
                 done: false
               };
@@ -13287,17 +14222,26 @@ ${lines.join("\n")}`;
           };
         },
         contains: (expr, target) => {
-          if (!target.type.matches("finite_real")) return false;
-          if (!isFunction2(expr)) return false;
           const t = target.re;
+          if (Number.isNaN(t))
+            return typeMembership(target, "number") === false ? false : void 0;
+          if (target.im !== 0) return false;
+          if (!isFinite(t)) return false;
+          if (!isFunction2(expr)) return void 0;
           const lower = expr.op1.re;
           const upper = expr.op2.re;
+          if (Number.isNaN(lower) || Number.isNaN(upper)) return void 0;
           if (t < lower || t > upper) return false;
           let count = expr.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 = expr.engine.tolerance;
+          const kRounded = Math.round(k);
+          return kRounded >= 0 && kRounded <= count - 1 && Math.abs(k - kRounded) < tol;
         }
       }
     },
@@ -13316,8 +14260,18 @@ ${lines.join("\n")}`;
       description: ["Return the number of elements in the collection."],
       complexity: 8200,
       signature: "(collection) -> integer",
-      evaluate: ([xs], { engine }) => xs.isEmptyCollection ? engine.Zero : engine.number(xs.count),
-      sgn: ([xs]) => xs.isEmptyCollection ? "zero" : "positive"
+      evaluate: ([xs], { engine }) => {
+        if (xs.isEmptyCollection) return engine.Zero;
+        const n = xs.count;
+        if (n === void 0) return void 0;
+        return engine.number(n);
+      },
+      sgn: ([xs]) => {
+        const empty = xs.isEmptyCollection;
+        if (empty === true) return "zero";
+        if (empty === false) return "positive";
+        return void 0;
+      }
     },
     IsEmpty: {
       description: ["Return True if the collection is empty, False otherwise."],
@@ -13433,7 +14387,13 @@ ${lines.join("\n")}`;
       },
       collection: {
         isLazy: (_expr) => true,
-        count: (_expr) => Infinity,
+        count: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          if (!expr.op1.isFiniteCollection) return Infinity;
+          let n = 0;
+          for (const _ of expr.each()) n++;
+          return n;
+        },
         contains: (expr, target) => {
           if (!isFunction2(expr)) return false;
           if (!expr.contains(target)) return false;
@@ -13542,24 +14502,26 @@ ${lines.join("\n")}`;
       type: (ops) => parseType(functionResult(ops[1].type.type) ?? "unknown"),
       evaluate: ([collection, fn, initial], { engine: ce }) => {
         if (!collection.isFiniteCollection) return void 0;
+        const hasInitial = initial !== void 0;
         initial ??= ce.Nothing;
         if (initial.type.matches("real") && collection.type.matches(ce.type("collection<real>"))) {
           const compiled = ce._compile(fn);
-          if (compiled.calling !== "lambda" || !compiled.run) return void 0;
-          return run(
-            (function* () {
-              let accumulator = initial.re;
-              let first = true;
-              for (const item of collection.each()) {
-                if (first) accumulator = item.re;
-                else accumulator = compiled.run(accumulator, item.re);
-                first = false;
-                yield;
-              }
-              return ce.expr(accumulator);
-            })(),
-            ce._timeRemaining
-          );
+          if (compiled.calling === "lambda" && compiled.run) {
+            return run(
+              (function* () {
+                let accumulator = hasInitial ? initial.re : NaN;
+                let first = true;
+                for (const item of collection.each()) {
+                  if (first && !hasInitial) accumulator = item.re;
+                  else accumulator = compiled.run(accumulator, item.re);
+                  first = false;
+                  yield;
+                }
+                return ce.expr(accumulator);
+              })(),
+              ce._timeRemaining
+            );
+          }
         }
         const f = applicable(fn);
         return run(
@@ -13622,10 +14584,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 expr = ops[0];
@@ -13636,12 +14600,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) expr = at(expr, s) ?? ce.Nothing;
-          else {
-            const i = ops[index].re;
-            if (!Number.isInteger(i)) return void 0;
-            expr = at(expr, i) ?? ce.Nothing;
+          if (s !== void 0) {
+            expr = at(expr, 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(expr, 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(expr, k);
+                if (v !== void 0) picked.push(v);
+              }
+            }
+            expr = ce._fn("List", picked);
+            index += 1;
+            continue;
           }
+          const i = opAtIndex.re;
+          if (!Number.isInteger(i)) return void 0;
+          expr = at(expr, i) ?? ce.Nothing;
           index += 1;
         }
         return expr;
@@ -13652,7 +14643,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);
@@ -13699,7 +14690,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: (expr) => {
@@ -13723,10 +14714,13 @@ ${lines.join("\n")}`;
           const [xs, nExpr] = expr.ops;
           const n = toInteger(nExpr) ?? 0;
           if (n <= 0) return xs.each();
+          const count = xs.count;
           let index = n + 1;
           return {
             next: () => {
-              const value = expr.op1.at(index++);
+              if (count !== void 0 && index > count)
+                return { value: void 0, done: true };
+              const value = xs.at(index++);
               if (value === void 0) return { value: void 0, done: true };
               return { value, done: false };
             }
@@ -13737,7 +14731,13 @@ ${lines.join("\n")}`;
           if (!isFunction2(expr)) return void 0;
           const [xs, nExpr] = expr.ops;
           const n = toInteger(nExpr) ?? 0;
-          if (n <= 0) return void 0;
+          if (n <= 0) return xs.at(index);
+          if (index < 0) {
+            const count = xs.count;
+            if (count !== void 0 && -index > count - n) return void 0;
+            return xs.at(index);
+          }
+          if (index < 1) return void 0;
           return xs.at(index + n);
         }
       }
@@ -13819,11 +14819,15 @@ ${lines.join("\n")}`;
         iterator: (expr) => {
           if (!isFunction2(expr))
             return { next: () => ({ value: void 0, done: true }) };
+          const op1 = expr.op1;
+          const count = op1.count;
+          let index = 2;
           return {
             next: () => {
-              let index = 1;
-              const value = expr.op1.at(index > 0 ? index + 1 : index);
-              if (!value) return { value: void 0, done: true };
+              if (count !== void 0 && index > count)
+                return { value: void 0, done: true };
+              const value = op1.at(index);
+              if (value === void 0) return { value: void 0, done: true };
               index += 1;
               return { value, done: false };
             }
@@ -13895,17 +14899,24 @@ ${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: (expr) => {
           if (!isFunction2(expr)) return void 0;
-          const start = toInteger(expr.op2) ?? 1;
           const count = expr.op1.count;
           if (count === void 0) return void 0;
-          const end = toInteger(expr.op3) ?? count;
-          if (start < 1) return Math.max(0, end + start - 1);
-          return Math.max(0, Math.min(end, count) - start + 1);
+          let start = toInteger(expr.op2) ?? 1;
+          if (start < 1) start = count + 1 + start;
+          if (start < 1) start = 1;
+          if (start > count) return 0;
+          let end = toInteger(expr.op3) ?? count;
+          if (end < 1) end = count + 1 + end;
+          if (end < 1) end = 1;
+          if (end > count) end = count;
+          return Math.max(0, end - start + 1);
         },
         isFinite: (_expr) => true,
         at: (expr, index) => {
@@ -13921,6 +14932,11 @@ ${lines.join("\n")}`;
           if (end < 1) end = count + 1 + end;
           if (end < 1) end = 1;
           if (end > count) end = count;
+          const length = end - start + 1;
+          if (length <= 0) return void 0;
+          if (index < 0) index = length + 1 + index;
+          if (index < 1 || index > length) return void 0;
+          return expr.op1.at(start + index - 1);
         },
         iterator: (expr) => {
           if (!isFunction2(expr))
@@ -14184,7 +15200,7 @@ ${lines.join("\n")}`;
         for (const item of xs.each()) {
           const pred = sym(f([item]));
           if (pred === "True") indices.push(ce.number(index));
-          if (pred !== "False")
+          else if (pred !== "False")
             throw new Error(
               `Filter predicate must return "True" or "False". ${spellCheckMessage(
                 fn
@@ -14227,16 +15243,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);
       }
@@ -14303,7 +15329,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 }) => {
@@ -14319,7 +15347,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]);
@@ -14331,7 +15359,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);
@@ -14421,11 +15449,25 @@ ${lines.join("\n")}`;
         count: zipCount,
         isFinite: (expr) => {
           if (!isFunction2(expr)) return void 0;
-          return expr.ops.every((x) => x.isFiniteCollection);
+          if (expr.nops === 0) return true;
+          let anyUnknown = false;
+          for (const x of expr.ops) {
+            const f = x.isFiniteCollection;
+            if (f === true) return true;
+            if (f === void 0) anyUnknown = true;
+          }
+          return anyUnknown ? void 0 : false;
         },
         isEmpty: (expr) => {
           if (!isFunction2(expr)) return void 0;
-          return expr.nops === 0 || expr.ops.every((x) => x.isEmptyCollection);
+          if (expr.nops === 0) return true;
+          let anyUnknown = false;
+          for (const x of expr.ops) {
+            const e = x.isEmptyCollection;
+            if (e === true) return true;
+            if (e === void 0) anyUnknown = true;
+          }
+          return anyUnknown ? void 0 : false;
         },
         iterator: (expr) => {
           if (!isFunction2(expr))
@@ -14505,32 +15547,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: (expr) => isFunction2(expr) && expr.ops?.length === 1,
+        count: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          if (expr.ops?.length === 2) {
+            const n = toInteger(expr.op2);
+            return n !== null ? Math.max(0, n) : void 0;
+          }
+          return Infinity;
+        },
+        isEmpty: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          if (expr.ops?.length === 2) {
+            const n = toInteger(expr.op2);
+            return n !== null ? n <= 0 : void 0;
+          }
+          return false;
+        },
+        isFinite: (expr) => isFunction2(expr) && expr.ops?.length === 2,
         contains: (expr, target) => {
           if (!isFunction2(expr)) return false;
+          if (expr.ops?.length === 2) {
+            const n = toInteger(expr.op2);
+            if (n !== null && n <= 0) return false;
+          }
           return expr.op1.isSame(target);
         },
         iterator: (expr) => {
           if (!isFunction2(expr))
             return { next: () => ({ value: void 0, done: true }) };
+          if (expr.ops?.length === 2) {
+            const n = toInteger(expr.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: expr.op1, done: false } : { value: void 0, done: true }
+            };
+          }
           return { next: () => ({ value: expr.op1, done: false }) };
         },
-        at: (expr, _index) => {
+        // at is 1-based (consistent with Range, Take, and other collection handlers)
+        at: (expr, index) => {
           if (!isFunction2(expr)) return void 0;
+          if (typeof index !== "number") return void 0;
+          if (expr.ops?.length === 2) {
+            const n = toInteger(expr.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 expr.op1;
         }
       }
@@ -14543,9 +15627,22 @@ ${lines.join("\n")}`;
       signature: "(list) -> list",
       collection: {
         isLazy: (_expr) => true,
-        count: () => Infinity,
-        isEmpty: (expr) => expr.isEmptyCollection,
-        isFinite: (expr) => !expr.isEmptyCollection,
+        // Cycling a non-empty collection is infinite; cycling an empty one is
+        // empty. Inspect the *underlying* collection (`op1`) — reading
+        // `expr.isEmptyCollection`/`expr.isFiniteCollection` here would re-enter
+        // these same handlers and recurse infinitely.
+        count: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          return expr.op1.isEmptyCollection ? 0 : Infinity;
+        },
+        isEmpty: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          return expr.op1.isEmptyCollection;
+        },
+        isFinite: (expr) => {
+          if (!isFunction2(expr)) return void 0;
+          return expr.op1.isEmptyCollection;
+        },
         contains: (expr, target) => {
           if (!isFunction2(expr)) return false;
           return expr.op1.contains(target) ?? false;
@@ -14559,7 +15656,7 @@ ${lines.join("\n")}`;
             return { next: () => ({ value: void 0, done: true }) };
           return {
             next: () => {
-              const i = (index - 1 - 1) % l + 1;
+              const i = (index - 1) % l + 1;
               const value = expr.op1.at(i);
               if (value === void 0) return { value: void 0, done: true };
               index += 1;
@@ -14681,7 +15778,7 @@ ${lines.join("\n")}`;
       evaluate: (ops, { engine: ce }) => {
         const elements = [];
         for (const xs of ops) {
-          if (xs.isCollection) elements.push(xs);
+          if (!xs.isCollection) elements.push(xs);
           else {
             if (!xs.isFiniteCollection) return void 0;
             elements.push(...Array.from(xs.each()));
@@ -14697,7 +15794,7 @@ ${lines.join("\n")}`;
       evaluate: (ops, { engine: ce }) => {
         const elements = [];
         for (const xs of ops) {
-          if (xs.isCollection) elements.push(xs);
+          if (!xs.isCollection) elements.push(xs);
           else {
             if (!xs.isFiniteCollection) return void 0;
             elements.push(...Array.from(xs.each()));
@@ -14790,11 +15887,129 @@ ${lines.join("\n")}`;
     return ce._fn("List", ops);
   }
   function canonicalSet(ops, { engine }) {
+    ops = ops.map((op) => op.canonical);
+    if (parseSetComprehension(ops) !== null) return engine._fn("Set", [...ops]);
     const set = [];
     const has = (x) => set.some((y) => y.isSame(x));
     for (const op of ops) if (!has(op)) set.push(op);
     return engine._fn("Set", set);
   }
+  function parseSetComprehension(ops) {
+    if (ops.length !== 2) return null;
+    const [body, spec] = ops;
+    const canon = (x) => x.isCanonical ? x : x.canonical;
+    if (isFunction2(spec, "Element") && spec.nops >= 2) {
+      if (!isSymbol2(spec.op1)) return null;
+      const v = spec.op1.symbol;
+      if (!body.has(v)) return null;
+      const cond = spec.nops >= 3 && sym(spec.op3) !== "Nothing" ? spec.op3 : void 0;
+      return { body, variable: v, domain: spec.op2, condition: cond };
+    }
+    if (isFunction2(spec, "Condition") && spec.nops >= 1) {
+      const pred = spec.op1;
+      if (isFunction2(body, "Element") && body.nops === 2 && isSymbol2(body.op1)) {
+        return {
+          body: body.op1,
+          variable: body.op1.symbol,
+          domain: canon(body.op2),
+          condition: canon(pred)
+        };
+      }
+      if (isFunction2(pred, "Element") && pred.nops === 2 && isSymbol2(pred.op1)) {
+        const v = pred.op1.symbol;
+        if (body.has(v))
+          return {
+            body,
+            variable: v,
+            domain: canon(pred.op2),
+            condition: void 0
+          };
+      }
+      if (isFunction2(pred, "And")) {
+        const memberships = pred.ops.filter(
+          (x) => isFunction2(x, "Element") && x.nops === 2 && isSymbol2(x.op1) && body.has(x.op1.symbol)
+        );
+        const membership = memberships.length === 1 ? memberships[0] : void 0;
+        if (membership && isFunction2(membership, "Element") && isSymbol2(membership.op1)) {
+          const rest = pred.ops.filter((x) => x !== membership).map(canon);
+          const ce = body.engine;
+          const cond = rest.length === 0 ? void 0 : rest.length === 1 ? rest[0] : ce._fn("And", rest);
+          return {
+            body,
+            variable: membership.op1.symbol,
+            domain: canon(membership.op2),
+            condition: cond
+          };
+        }
+      }
+      return {
+        body,
+        variable: isSymbol2(body) ? body.symbol : void 0,
+        domain: void 0,
+        condition: pred
+      };
+    }
+    return null;
+  }
+  function enumerateSetComprehension(comp) {
+    const { body, variable, domain, condition } = comp;
+    if (variable === void 0 || domain === void 0) return void 0;
+    const ce = body.engine;
+    const extract = (dom) => extractFiniteDomainWithReason(
+      ce._fn("Element", [
+        ce.symbol(variable),
+        dom,
+        ...condition ? [condition] : []
+      ]),
+      ce
+    );
+    let result = extract(domain);
+    if (result.status !== "success") {
+      const evaluatedDomain = domain.evaluate();
+      if (!evaluatedDomain.isSame(domain)) result = extract(evaluatedDomain);
+    }
+    if (result.status !== "success") return void 0;
+    const isIdentity = isSymbol2(body) && body.symbol === variable;
+    const elements = [];
+    for (const value of result.values) {
+      const x = isIdentity ? value : body.subs({ [variable]: value }).evaluate();
+      if (!elements.some((y) => y.isSame(x))) elements.push(x);
+    }
+    return elements;
+  }
+  function literalSetContains(ops, target) {
+    let indeterminate = false;
+    for (const op of ops) {
+      if (target.isSame(op)) return true;
+      if (isNumber(target) && isNumber(op)) {
+        const eq2 = target.isEqual(op);
+        if (eq2 === true) return true;
+        if (eq2 !== false) indeterminate = true;
+      } else if (isString(target) && isString(op)) {
+      } else {
+        indeterminate = true;
+      }
+    }
+    return indeterminate ? void 0 : false;
+  }
+  function setComprehensionContains(comp, target) {
+    const elements = enumerateSetComprehension(comp);
+    if (elements !== void 0) return literalSetContains(elements, target);
+    if (comp.domain !== void 0 && comp.variable !== void 0 && isSymbol2(comp.body) && comp.body.symbol === comp.variable) {
+      const inDomain = comp.domain.contains(target);
+      if (inDomain === false) return false;
+      let condition = true;
+      if (comp.condition !== void 0) {
+        if (isNumber(target) || isString(target)) {
+          const result = comp.condition.subs({ [comp.variable]: target }).evaluate();
+          condition = sym(result) === "True" ? true : sym(result) === "False" ? false : void 0;
+        } else condition = void 0;
+      }
+      if (condition === false) return false;
+      if (inDomain === true && condition === true) return true;
+    }
+    return void 0;
+  }
   function tally(collection) {
     const values = [];
     const counts = [];
@@ -15034,7 +16249,11 @@ ${lines.join("\n")}`;
                   op[1]
                 )}`;
               } else {
-                resultStr = args.map((arg) => _BaseCompiler.compile(arg, target, op[1])).join(` ${op[0]} `);
+                const rightAssoc = h === "Power";
+                resultStr = args.map((arg, i) => {
+                  const operandPrec = rightAssoc && i < args.length - 1 ? op[1] + 1 : op[1];
+                  return _BaseCompiler.compile(arg, target, operandPrec);
+                }).join(` ${op[0]} `);
               }
               return op[1] < prec ? `(${resultStr})` : resultStr;
             }
@@ -15239,6 +16458,13 @@ ${lines.join("\n")}`;
      *    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");
@@ -15720,6 +16946,17 @@ ${lines.join("\n")}`;
           `Compilation fallback for "${expr.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
         );
         const ce = expr.engine;
+        const target = options?.to ?? "javascript";
+        if (isFunction2(expr, "Function")) {
+          const lambdaRun = ((...args) => ce.function("Apply", [expr, ...args.map((a) => ce.box(a))]).evaluate().re);
+          return {
+            target,
+            success: false,
+            code: "",
+            calling: "lambda",
+            run: lambdaRun
+          };
+        }
         const fallbackRun = ((vars) => {
           ce.pushScope();
           try {
@@ -15732,7 +16969,7 @@ ${lines.join("\n")}`;
           }
         });
         return {
-          target: options?.to ?? "javascript",
+          target,
           success: false,
           code: "",
           calling: "expression",
@@ -15786,6 +17023,11 @@ ${lines.join("\n")}`;
     if (symbolic.length === 1) return symbolic[0];
     return symbolic.join(op === "+" ? " + " : " * ");
   }
+  function parenthesizeFactor(expr, code) {
+    if (isFunction2(expr, "Add") || isFunction2(expr, "Subtract"))
+      return `(${code})`;
+    return code;
+  }
   function tryGetComplexParts(expr, compile2) {
     if (isSymbol2(expr, "ImaginaryUnit")) {
       return { re: null, im: "1.0" };
@@ -15810,7 +17052,9 @@ ${lines.join("\n")}`;
         if (remaining.length === 0) {
           return { re: null, im: formatFloat(iScale) };
         }
-        const compiledFactors = remaining.map((r) => compile2(r));
+        const compiledFactors = remaining.map(
+          (r) => parenthesizeFactor(r, compile2(r))
+        );
         if (iScale !== 1) compiledFactors.unshift(formatFloat(iScale));
         const imCode = foldTerms(compiledFactors, "1.0", "*");
         return { re: null, im: imCode };
@@ -19327,9 +20571,14 @@ ${lines.join("\n")}`;
   ];
   function gammaln(z) {
     if (z < 0) return NaN;
+    let shift = 0;
+    while (z < 10) {
+      shift += Math.log(z);
+      z += 1;
+    }
     const pi = Math.PI;
     const z3 = z * z * z;
-    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z);
+    return z * Math.log(z) - z - 0.5 * Math.log(z) + 0.5 * Math.log(2 * pi) + 1 / (12 * z) - 1 / (360 * z3) + 1 / (1260 * z3 * z * z) - shift;
   }
   function gamma(z) {
     if (z < 0.5) return Math.PI / (Math.sin(Math.PI * z) * gamma(1 - z));
@@ -19340,31 +20589,62 @@ ${lines.join("\n")}`;
     const t = z + gammaG + 0.5;
     return Math.sqrt(2 * Math.PI) * Math.pow(t, z + 0.5) * Math.exp(-t) * x;
   }
+  function erfInvApprox(x) {
+    const a = 0.147;
+    const ln1mx2 = Math.log(1 - x * x);
+    const b = 2 / (Math.PI * a) + ln1mx2 / 2;
+    return Math.sign(x) * Math.sqrt(Math.sqrt(b * b - ln1mx2 / a) - b);
+  }
   function erfInv(x) {
-    const pi = Math.PI;
-    const pi2 = pi * pi;
-    const pi3 = pi2 * pi;
-    const x2 = x * x;
-    const x3 = x * x2;
-    const x5 = x3 * x2;
-    const x7 = x5 * x2;
-    return Math.sqrt(pi) / 2 * (x + pi / 12 * x3 + 7 * pi2 / 480 * x5 + 127 * pi3 / 40320 * x7 + 4369 * pi2 * pi2 / 5806080 * x7 * x2 + 34807 * pi3 * pi2 / 182476800 * x7 * x2 * x2);
+    if (Number.isNaN(x) || x < -1 || x > 1) return NaN;
+    if (x === 0) return 0;
+    if (x === 1) return Infinity;
+    if (x === -1) return -Infinity;
+    const sign2 = x < 0 ? -1 : 1;
+    const ax = Math.abs(x);
+    let y = erfInvApprox(ax);
+    const c = Math.sqrt(Math.PI) / 2;
+    for (let i = 0; i < 4; i++) y -= (erf(y) - ax) * c * Math.exp(y * y);
+    return sign2 * y;
   }
   function erfc(x) {
-    return 1 - erf(x);
+    if (Number.isNaN(x)) return NaN;
+    if (!Number.isFinite(x)) return x > 0 ? 0 : 2;
+    if (x < 0) return 2 - erfc(-x);
+    if (x < 2) return 1 - erf(x);
+    const tiny = 1e-300;
+    let f = x === 0 ? tiny : x;
+    let c = f;
+    let d = 0;
+    for (let k = 1; k <= 500; k++) {
+      const a = k / 2;
+      d = x + a * d;
+      if (d === 0) d = tiny;
+      d = 1 / d;
+      c = x + a / c;
+      if (c === 0) c = tiny;
+      const delta = c * d;
+      f *= delta;
+      if (Math.abs(delta - 1) < 1e-17) break;
+    }
+    return Math.exp(-x * x) / (Math.sqrt(Math.PI) * f);
   }
   function erf(x) {
-    const a1 = 0.254829592;
-    const a2 = -0.284496736;
-    const a3 = 1.421413741;
-    const a4 = -1.453152027;
-    const a5 = 1.061405429;
-    const p = 0.3275911;
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return 0;
+    if (!Number.isFinite(x)) return x > 0 ? 1 : -1;
     const sign2 = x < 0 ? -1 : 1;
-    x = Math.abs(x);
-    const t = 1 / (1 + p * x);
-    const y = ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t;
-    return sign2 * (1 - y * Math.exp(-x * x));
+    const ax = Math.abs(x);
+    if (ax >= 6) return sign2;
+    const x2 = ax * ax;
+    let term = ax;
+    let sum = ax;
+    for (let n = 1; n < 200; n++) {
+      term *= 2 * x2 / (2 * n + 1);
+      sum += term;
+      if (term < sum * 1e-18) break;
+    }
+    return sign2 * (2 / Math.sqrt(Math.PI)) * Math.exp(-x2) * sum;
   }
   var EULER_MASCHERONI = 0.5772156649015329;
   var BERNOULLI_2K = [
@@ -19950,7 +21230,7 @@ ${lines.join("\n")}`;
       const t = x2 * x2;
       return sign2 * x * x2 * polevl(t, SN) / polevl(t, SD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -19975,7 +21255,7 @@ ${lines.join("\n")}`;
       const t = x2 * x2;
       return sign2 * x * polevl(t, CN) / polevl(t, CD);
     }
-    if (x < 36) {
+    if (x < 36974) {
       const x2 = x * x;
       const t = Math.PI * x2;
       const u = 1 / (t * t);
@@ -20066,6 +21346,7 @@ ${lines.join("\n")}`;
   function kurtosis(values) {
     let sum = 0;
     let sum2 = 0;
+    let sum3 = 0;
     let sum4 = 0;
     let count = 0;
     for (const op of values) {
@@ -20073,12 +21354,16 @@ ${lines.join("\n")}`;
       if (!Number.isFinite(v)) return NaN;
       sum += v;
       sum2 += v * v;
+      sum3 += v * v * v;
       sum4 += v * v * v * v;
       count++;
     }
     if (count === 0) return NaN;
-    const s2 = (sum2 - sum * sum / count) / (count - 1);
-    return (sum4 - 4 * sum * sum2 / count + 6 * sum * sum * sum / count / count - 3 * sum * sum * sum * sum / count / count / count) / (s2 * s2);
+    const n = count;
+    const m = sum / n;
+    const m2 = (sum2 - sum * sum / n) / n;
+    const m4 = (sum4 - 4 * m * sum3 + 6 * m * m * sum2 - 4 * m * m * m * sum + n * m * m * m * m) / n;
+    return m4 / (m2 * m2);
   }
   function skewness(values) {
     let sum = 0;
@@ -20094,9 +21379,11 @@ ${lines.join("\n")}`;
       count++;
     }
     if (count === 0) return NaN;
-    const s2 = (sum2 - sum * sum / count) / (count - 1);
-    const s3 = (sum3 - sum2 * sum / count) / (count - 1);
-    return s3 / Math.pow(s2, 3 / 2) * Math.sqrt(count * 1);
+    const n = count;
+    const m = sum / n;
+    const m2 = (sum2 - sum * sum / n) / n;
+    const m3 = (sum3 - 3 * m * sum2 + 3 * m * m * sum - n * m * m * m) / n;
+    return m3 / Math.pow(m2, 3 / 2);
   }
   function mode(values) {
     const counts = {};
@@ -20123,11 +21410,8 @@ ${lines.join("\n")}`;
     return [q1, q2, q3];
   }
   function interquartileRange(values) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    const lower = sorted.slice(0, mid);
-    const upper = sorted.slice(mid + 1);
-    return median(upper) - median(lower);
+    const [q1, , q3] = quartiles(values);
+    return q3 - q1;
   }
 
   // src/compute-engine/numerics/monte-carlo.ts
@@ -20326,6 +21610,7 @@ ${lines.join("\n")}`;
         return `_SYS.cexp(${compile2(args[0])})`;
       return `Math.exp(${compile2(args[0])})`;
     },
+    First: (args, compile2) => `${compile2(args[0])}[0]`,
     Floor: (args, compile2) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
       return `Math.floor(${compile2(args[0])})`;
@@ -20457,7 +21742,7 @@ ${lines.join("\n")}`;
       if (parseFloat(step) === 1) {
         const fStop = parseFloat(stop);
         const fStart = parseFloat(start);
-        if (fStop !== null && fStart !== null) {
+        if (!isNaN(fStop) && !isNaN(fStart)) {
           if (fStop - fStart < 50) {
             return `[${Array.from(
               { length: fStop - fStart + 1 },
@@ -20468,9 +21753,9 @@ ${lines.join("\n")}`;
         }, (_, i) => ${start} + i)`;
         }
         return `Array.from({length: ${stop} - ${start} + 1
-      }, (_, i) => ${start} + i)`;
+      }, (_e, i) => ${start} + i)`;
       }
-      return `Array.from({length: Math.floor((${stop} - ${start}) / ${step}) + 1}, (_, i) => ${start} + i * ${step})`;
+      return `Array.from({length: Math.floor((${stop} - ${start}) / ${step}) + 1}, (_e, i) => ${start} + i * ${step})`;
     },
     Root: ([arg, exp3], compile2) => {
       if (arg === null) throw new Error("Root: no argument");
@@ -20484,7 +21769,20 @@ ${lines.join("\n")}`;
       if (nConst !== void 0) return `Math.pow(${compile2(arg)}, ${1 / nConst})`;
       return `Math.pow(${compile2(arg)}, 1 / (${compile2(exp3)}))`;
     },
-    Random: "Math.random",
+    Random: (args, compile2) => {
+      if (args.length === 0) return "Math.random()";
+      if (args.length === 2) {
+        const m = compile2(args[0]);
+        const n = compile2(args[1]);
+        return `((${m}) + Math.floor(Math.random() * ((${n}) - (${m}))))`;
+      }
+      const arg = args[0];
+      if (BaseCompiler.isIntegerValued(arg)) {
+        return `Math.floor(Math.random() * (${compile2(arg)}))`;
+      }
+      const a = compile2(arg);
+      return `(() => { const _s = (${a}) * 12.9898; const _v = Math.sin(_s) * 43758.5453; return _v - Math.floor(_v); })()`;
+    },
     Round: (args, compile2) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
       return `Math.round(${compile2(args[0])})`;
@@ -20512,6 +21810,7 @@ ${lines.join("\n")}`;
       if (BaseCompiler.isComplexValued(arg)) return `_SYS.csech(${compile2(arg)})`;
       return `1 / Math.cosh(${compile2(arg)})`;
     },
+    Second: (args, compile2) => `${compile2(args[0])}[1]`,
     Heaviside: "_SYS.heaviside",
     Sign: "Math.sign",
     Sinc: "_SYS.sinc",
@@ -20544,6 +21843,7 @@ ${lines.join("\n")}`;
         return `_SYS.ctanh(${compile2(args[0])})`;
       return `Math.tanh(${compile2(args[0])})`;
     },
+    Third: (args, compile2) => `${compile2(args[0])}[2]`,
     Mod: ([a, b], compile2) => {
       if (a === null || b === null) throw new Error("Mod: missing argument");
       const ca = compile2(a);
@@ -21612,6 +22912,14 @@ ${lines.join("\n")}`;
   function gpuVec3(target) {
     return target?.language === "wgsl" ? "vec3f" : "vec3";
   }
+  function gpuNaN(target) {
+    return target?.language === "wgsl" ? "bitcast<f32>(0x7fc00000u)" : "(0.0 / 0.0)";
+  }
+  function gpuConditional(cond, whenTrue, whenFalse, target) {
+    if (target?.language === "wgsl")
+      return `select(${whenFalse}, ${whenTrue}, ${cond})`;
+    return `((${cond}) ? (${whenTrue}) : (${whenFalse}))`;
+  }
   function readStringLiteral(expr) {
     if (!isString(expr)) return null;
     return expr.string?.toLowerCase() ?? null;
@@ -21729,7 +23037,7 @@ ${lines.join("\n")}`;
         const realFactors = args.filter((_, i) => i !== iIndex);
         const v2 = gpuVec2(target);
         if (realFactors.length === 0) return `${v2}(0.0, ${formatFloat(iScale)})`;
-        const factors = realFactors.map((f) => compile2(f));
+        const factors = realFactors.map((f) => parenthesizeFactor(f, compile2(f)));
         if (iScale !== 1) factors.unshift(formatFloat(iScale));
         const imCode = foldTerms(factors, "1.0", "*");
         return `${v2}(0.0, ${imCode})`;
@@ -21738,7 +23046,7 @@ ${lines.join("\n")}`;
       const complexCodes = [];
       for (const a of args) {
         if (BaseCompiler.isComplexValued(a)) complexCodes.push(compile2(a));
-        else realCodes.push(compile2(a));
+        else realCodes.push(parenthesizeFactor(a, compile2(a)));
       }
       const scalarCode = foldTerms(realCodes, "1.0", "*");
       let result = complexCodes[0];
@@ -21816,13 +23124,23 @@ ${lines.join("\n")}`;
         return `_gpu_ccos(${compile2(args[0])})`;
       return `cos(${compile2(args[0])})`;
     },
-    Degrees: "degrees",
+    // CE's `Degrees` converts degrees→radians (Degrees(180) = π), which is
+    // GLSL's `radians()`. GLSL's `degrees()` is the inverse (rad→deg).
+    Degrees: "radians",
     Exp: (args, compile2) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_gpu_cexp(${compile2(args[0])})`;
       return `exp(${compile2(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, compile2) => `${compile2(args[0])}.x`,
+    Second: (args, compile2) => `${compile2(args[0])}.y`,
+    Third: (args, compile2) => `${compile2(args[0])}.z`,
     Floor: (args, compile2) => {
       if (BaseCompiler.isIntegerValued(args[0])) return compile2(args[0]);
       return `floor(${compile2(args[0])})`;
@@ -21837,6 +23155,43 @@ ${lines.join("\n")}`;
     Max: "max",
     Min: "min",
     Mix: "mix",
+    // Control-flow forms — the base compiler's default emits a JS ternary and a
+    // bare `NaN`, neither of which is valid GPU code (WGSL has no `?:`, and no
+    // shader language has a `NaN` identifier). Emit `select(...)` for WGSL and a
+    // language-appropriate NaN.
+    If: (args, compile2, target) => {
+      if (args.length !== 3) throw new Error("If: wrong number of arguments");
+      return gpuConditional(
+        compile2(args[0]),
+        compile2(args[1]),
+        compile2(args[2]),
+        target
+      );
+    },
+    When: (args, compile2, target) => {
+      if (args.length !== 2)
+        throw new Error("When: expected exactly 2 arguments (expr, cond)");
+      if (isSymbol2(args[1], "True")) return `(${compile2(args[0])})`;
+      if (isSymbol2(args[1], "False")) return gpuNaN(target);
+      return gpuConditional(
+        compile2(args[1]),
+        compile2(args[0]),
+        gpuNaN(target),
+        target
+      );
+    },
+    Which: (args, compile2, target) => {
+      if (args.length < 2 || args.length % 2 !== 0)
+        throw new Error("Which: expected condition/value pairs");
+      const build = (i) => {
+        if (i >= args.length) return gpuNaN(target);
+        const cond = args[i];
+        const val = args[i + 1];
+        if (isSymbol2(cond, "True")) return `(${compile2(val)})`;
+        return gpuConditional(compile2(cond), compile2(val), build(i + 2), target);
+      };
+      return build(0);
+    },
     Power: (args, compile2, target) => {
       const base = args[0];
       const exp3 = args[1];
@@ -22300,6 +23655,39 @@ ${lines.join("\n")}`;
     // Sum/Product — unrolled or for-loop
     Sum: (args, compile2, target) => compileGPUSumProduct("Sum", args, compile2, target),
     Product: (args, compile2, target) => compileGPUSumProduct("Product", args, compile2, target),
+    // Range — inline constant array literal (bounds must be compile-time constants)
+    Range: (args, _compile, 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, _compile, target) => {
       if (!args[0]) throw new Error("Loop: no body");
@@ -22328,6 +23716,134 @@ ${lines.join("\n")}`;
   ${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, compile2) => {
+      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(${compile2(a)}, ${compile2(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, compile2) => {
+      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) => compile2(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, compile2) => {
+      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) => compile2(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, compile2, 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 = compile2(arg);
+          return `floor(_gpu_random(float(${compiled})) * float(${compiled}))`;
+        }
+        return `_gpu_random(${compile2(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 = compile2(args[0]);
+        const n = compile2(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(
@@ -22363,7 +23879,7 @@ ${lines.join("\n")}`;
     }
     return compile2(body);
   }
-  var GPU_GAMMA_PREAMBLE = `
+  var GPU_GAMMA_PREAMBLE_GLSL = `
 float _gpu_gamma(float z) {
   const float PI = 3.14159265358979;
   // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)
@@ -22395,7 +23911,37 @@ float _gpu_gammaln(float z) {
     + 1.0 / (1260.0 * z3 * z * z);
 }
 `;
-  var GPU_ERF_PREAMBLE = `
+  var GPU_GAMMA_PREAMBLE_WGSL = `
+fn _gpu_gamma(z: f32) -> f32 {
+  let PI = 3.14159265358979;
+  var w = z;
+  if (z < 0.5) { w = 1.0 - z; }
+  w = w - 1.0;
+  var x = 0.99999999999980993;
+  x = x + 676.5203681218851 / (w + 1.0);
+  x = x + -1259.1392167224028 / (w + 2.0);
+  x = x + 771.32342877765313 / (w + 3.0);
+  x = x + -176.61502916214059 / (w + 4.0);
+  x = x + 12.507343278686905 / (w + 5.0);
+  x = x + -0.13857109526572012 / (w + 6.0);
+  x = x + 9.9843695780195716e-6 / (w + 7.0);
+  x = x + 1.5056327351493116e-7 / (w + 8.0);
+  let t = w + 7.5;
+  let g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;
+  if (z < 0.5) { return PI / (sin(PI * z) * g); }
+  return g;
+}
+
+fn _gpu_gammaln(z: f32) -> f32 {
+  let z3 = z * z * z;
+  return z * log(z) - z - 0.5 * log(z)
+    + 0.5 * log(2.0 * 3.14159265358979)
+    + 1.0 / (12.0 * z)
+    - 1.0 / (360.0 * z3)
+    + 1.0 / (1260.0 * z3 * z * z);
+}
+`;
+  var GPU_ERF_PREAMBLE_GLSL = `
 float _gpu_erf(float x) {
   float ax = abs(x);
   float t = 1.0 / (1.0 + 0.3275911 * ax);
@@ -22413,6 +23959,26 @@ float _gpu_erfinv(float x) {
   float x9 = x7 * x2;
   return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);
 }
+`;
+  var GPU_ERF_PREAMBLE_WGSL = `
+fn _gpu_erf(x: f32) -> f32 {
+  let ax = abs(x);
+  let t = 1.0 / (1.0 + 0.3275911 * ax);
+  let y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;
+  let result = 1.0 - y * exp(-ax * ax);
+  if (x < 0.0) { return -result; }
+  return result;
+}
+
+fn _gpu_erfinv(x: f32) -> f32 {
+  let pi = 3.14159265358979;
+  let x2 = x * x;
+  let x3 = x * x2;
+  let x5 = x3 * x2;
+  let x7 = x5 * x2;
+  let x9 = x7 * x2;
+  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);
+}
 `;
   var GPU_HEAVISIDE_PREAMBLE_GLSL = `
 float _gpu_heaviside(float x) {
@@ -22926,6 +24492,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) {
@@ -23587,8 +25359,10 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
       };
       let preamble = "";
       preamble += buildComplexPreamble(code, this.languageId);
-      if (code.includes("_gpu_gamma")) preamble += GPU_GAMMA_PREAMBLE;
-      if (code.includes("_gpu_erf")) preamble += GPU_ERF_PREAMBLE;
+      if (code.includes("_gpu_gamma"))
+        preamble += this.languageId === "wgsl" ? GPU_GAMMA_PREAMBLE_WGSL : GPU_GAMMA_PREAMBLE_GLSL;
+      if (code.includes("_gpu_erf"))
+        preamble += this.languageId === "wgsl" ? GPU_ERF_PREAMBLE_WGSL : GPU_ERF_PREAMBLE_GLSL;
       if (code.includes("_gpu_heaviside"))
         preamble += this.languageId === "wgsl" ? GPU_HEAVISIDE_PREAMBLE_WGSL : GPU_HEAVISIDE_PREAMBLE_GLSL;
       if (code.includes("_gpu_sinc"))
@@ -23604,6 +25378,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;
       }
@@ -24368,9 +26148,18 @@ ${code}`;
     return ok({ lo: -xVal.hi, hi: -xVal.lo });
   }
   function _mul(a, b) {
-    const products = [a.lo * b.lo, a.lo * b.hi, a.hi * b.lo, a.hi * b.hi];
+    const products = [
+      _prod(a.lo, b.lo),
+      _prod(a.lo, b.hi),
+      _prod(a.hi, b.lo),
+      _prod(a.hi, b.hi)
+    ];
     return { lo: Math.min(...products), hi: Math.max(...products) };
   }
+  function _prod(x, y) {
+    if (x === 0 || y === 0) return 0;
+    return x * y;
+  }
   function mul3(a, b) {
     const unwrapped = unwrapOrPropagate(a, b);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -24704,6 +26493,7 @@ ${code}`;
     const period = Math.abs(
       bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi))
     );
+    const divisorNegative = bVal.hi < 0;
     const flo = Math.floor(aVal.lo / period);
     const fhi = Math.floor(aVal.hi / period);
     if (flo !== fhi) {
@@ -24711,6 +26501,11 @@ ${code}`;
     }
     const modLo = aVal.lo - period * flo;
     const modHi = aVal.hi - period * flo;
+    if (divisorNegative) {
+      if (modLo === 0)
+        return { kind: "singular", at: aVal.lo, continuity: "right" };
+      return ok({ lo: modLo - period, hi: modHi - period });
+    }
     return ok({ lo: Math.min(modLo, modHi), hi: Math.max(modLo, modHi) });
   }
   function remainder(a, b) {
@@ -24742,6 +26537,23 @@ ${code}`;
     const [xVal] = unwrapped;
     return _gamma(xVal);
   }
+  var GAMMA_NEG_EXTREMA_X = [
+    -0.504083008264455,
+    -1.573498473162391,
+    -2.610720868444145,
+    -3.635293366436901,
+    -4.653163765628266,
+    -5.667162441556885,
+    -6.678418213073426,
+    -7.687788325031709,
+    -8.695764163640956,
+    -9.702672540001863
+  ];
+  function gammaNegStripExtremum(lo) {
+    const n = Math.floor(lo);
+    const idx = -n - 1;
+    return idx >= 0 && idx < GAMMA_NEG_EXTREMA_X.length ? GAMMA_NEG_EXTREMA_X[idx] : null;
+  }
   function _gamma(x) {
     if (x.hi >= 0 && x.lo <= 0) {
       return { kind: "singular", at: 0 };
@@ -24754,7 +26566,21 @@ ${code}`;
       }
       const gLo = gamma(x.lo);
       const gHi = gamma(x.hi);
-      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+      let lo = Math.min(gLo, gHi);
+      let hi = Math.max(gLo, gHi);
+      const xStar = gammaNegStripExtremum(x.lo);
+      if (xStar !== null) {
+        if (xStar >= x.lo && xStar <= x.hi) {
+          const g = gamma(xStar);
+          lo = Math.min(lo, g);
+          hi = Math.max(hi, g);
+        }
+      } else {
+        const stripEven = Math.floor(x.lo) % 2 === 0;
+        if (stripEven) lo = Math.min(lo, 0);
+        else hi = Math.max(hi, 0);
+      }
+      return ok({ lo, hi });
     }
     if (x.lo >= GAMMA_MIN_X) {
       return ok({ lo: gamma(x.lo), hi: gamma(x.hi) });
@@ -24785,7 +26611,15 @@ ${code}`;
       }
       const gLo = gammaln(x.lo);
       const gHi = gammaln(x.hi);
-      return ok({ lo: Math.min(gLo, gHi), hi: Math.max(gLo, gHi) });
+      let lo = Math.min(gLo, gHi);
+      const hi = Math.max(gLo, gHi);
+      const xStar = gammaNegStripExtremum(x.lo);
+      if (xStar !== null) {
+        if (xStar >= x.lo && xStar <= x.hi) lo = Math.min(lo, gammaln(xStar));
+      } else {
+        lo = -Infinity;
+      }
+      return ok({ lo, hi });
     }
     return ok({ lo: gammaln(x.lo), hi: gammaln(x.hi) });
   }
@@ -24811,6 +26645,33 @@ ${code}`;
       return ok({ lo: Math.min(fLo, fHi), hi: Math.max(fLo, fHi) });
     return ok({ lo: fLo, hi: fHi });
   }
+  var MAX_INT_ENUM_POINTS = 4096;
+  function integerPoints(lo, hi, cap) {
+    const a = Math.round(lo);
+    const b = Math.round(hi);
+    if (!Number.isFinite(a) || !Number.isFinite(b)) return null;
+    if (b - a + 1 > cap) return null;
+    const out = [];
+    for (let i = a; i <= b; i++) out.push(i);
+    return out;
+  }
+  function enumerateInteger2(a, b, f) {
+    const xs = integerPoints(a.lo, a.hi, MAX_INT_ENUM_POINTS);
+    const ys = integerPoints(b.lo, b.hi, MAX_INT_ENUM_POINTS);
+    if (!xs || !ys || xs.length * ys.length > MAX_INT_ENUM_POINTS) return null;
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (const x of xs)
+      for (const y of ys) {
+        const v = f(x, y);
+        if (Number.isFinite(v)) {
+          if (v < lo) lo = v;
+          if (v > hi) hi = v;
+        }
+      }
+    if (lo === Infinity) return null;
+    return ok({ lo, hi });
+  }
   function binomial(n, k) {
     const uN = unwrapOrPropagate(n);
     if (!Array.isArray(uN)) return uN;
@@ -24818,13 +26679,10 @@ ${code}`;
     if (!Array.isArray(uK)) return uK;
     const [nVal] = uN;
     const [kVal] = uK;
-    const vals = [
-      choose(Math.round(nVal.lo), Math.round(kVal.lo)),
-      choose(Math.round(nVal.lo), Math.round(kVal.hi)),
-      choose(Math.round(nVal.hi), Math.round(kVal.lo)),
-      choose(Math.round(nVal.hi), Math.round(kVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(nVal, kVal, choose);
+    if (enumerated) return enumerated;
+    const nMax = Math.round(nVal.hi);
+    return ok({ lo: 0, hi: choose(nMax, Math.floor(nMax / 2)) });
   }
   function gcd3(a, b) {
     const uA = unwrapOrPropagate(a);
@@ -24833,13 +26691,15 @@ ${code}`;
     if (!Array.isArray(uB)) return uB;
     const [aVal] = uA;
     const [bVal] = uB;
-    const vals = [
-      gcd(Math.round(aVal.lo), Math.round(bVal.lo)),
-      gcd(Math.round(aVal.lo), Math.round(bVal.hi)),
-      gcd(Math.round(aVal.hi), Math.round(bVal.lo)),
-      gcd(Math.round(aVal.hi), Math.round(bVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(aVal, bVal, gcd);
+    if (enumerated) return enumerated;
+    const m = Math.max(
+      Math.abs(Math.round(aVal.lo)),
+      Math.abs(Math.round(aVal.hi)),
+      Math.abs(Math.round(bVal.lo)),
+      Math.abs(Math.round(bVal.hi))
+    );
+    return ok({ lo: 0, hi: m });
   }
   function lcm3(a, b) {
     const uA = unwrapOrPropagate(a);
@@ -24848,13 +26708,11 @@ ${code}`;
     if (!Array.isArray(uB)) return uB;
     const [aVal] = uA;
     const [bVal] = uB;
-    const vals = [
-      lcm(Math.round(aVal.lo), Math.round(bVal.lo)),
-      lcm(Math.round(aVal.lo), Math.round(bVal.hi)),
-      lcm(Math.round(aVal.hi), Math.round(bVal.lo)),
-      lcm(Math.round(aVal.hi), Math.round(bVal.hi))
-    ];
-    return ok({ lo: Math.min(...vals), hi: Math.max(...vals) });
+    const enumerated = enumerateInteger2(aVal, bVal, lcm);
+    if (enumerated) return enumerated;
+    const ma = Math.max(Math.abs(Math.round(aVal.lo)), Math.abs(Math.round(aVal.hi)));
+    const mb = Math.max(Math.abs(Math.round(bVal.lo)), Math.abs(Math.round(bVal.hi)));
+    return ok({ lo: 0, hi: ma * mb });
   }
   function chop2(x) {
     const unwrapped = unwrapOrPropagate(x);
@@ -25246,7 +27104,6 @@ ${code}`;
     29.8116,
     32.95639
   ];
-  var SINC_GLOBAL_LO = -0.21724;
   function sinc2(x) {
     const unwrapped = unwrapOrPropagate(x);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -25267,8 +27124,14 @@ ${code}`;
       if (e >= xVal.lo && e <= xVal.hi) update(sincVal(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(sincVal(-e));
     }
-    if (Math.abs(xVal.lo) > lastExtremum || Math.abs(xVal.hi) > lastExtremum) {
-      update(SINC_GLOBAL_LO);
+    let minBeyondAbs = Infinity;
+    if (xVal.hi > lastExtremum)
+      minBeyondAbs = Math.min(minBeyondAbs, Math.max(xVal.lo, lastExtremum));
+    if (xVal.lo < -lastExtremum)
+      minBeyondAbs = Math.min(minBeyondAbs, -Math.min(xVal.hi, -lastExtremum));
+    if (Number.isFinite(minBeyondAbs) && minBeyondAbs > 0) {
+      update(1 / minBeyondAbs);
+      update(-1 / minBeyondAbs);
     }
     return ok({ lo, hi });
   }
@@ -25294,8 +27157,21 @@ ${code}`;
       if (e >= xVal.lo && e <= xVal.hi) update(fresnelS(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelS(-e));
     }
+    fresnelConvergenceBound(xVal, FRESNEL_S_EXTREMA, fresnelS, update);
     return ok({ lo, hi });
   }
+  function fresnelConvergenceBound(xVal, extrema, scalar, update) {
+    const lastE = extrema[extrema.length - 1];
+    const amp = Math.abs(scalar(lastE) - 0.5);
+    if (xVal.hi > lastE) {
+      update(0.5 + amp);
+      update(0.5 - amp);
+    }
+    if (xVal.lo < -lastE) {
+      update(-0.5 - amp);
+      update(-0.5 + amp);
+    }
+  }
   function fresnelC2(x) {
     const unwrapped = unwrapOrPropagate(x);
     if (!Array.isArray(unwrapped)) return unwrapped;
@@ -25312,6 +27188,7 @@ ${code}`;
       if (e >= xVal.lo && e <= xVal.hi) update(fresnelC(e));
       if (-e >= xVal.lo && -e <= xVal.hi) update(fresnelC(-e));
     }
+    fresnelConvergenceBound(xVal, FRESNEL_C_EXTREMA, fresnelC, update);
     return ok({ lo, hi });
   }
 
@@ -25419,11 +27296,9 @@ ${code}`;
     const unwrapped = unwrapOrPropagate(x, lo, hi);
     if (!Array.isArray(unwrapped)) return unwrapped;
     const [xVal, loVal, hiVal] = unwrapped;
-    const resultLo = Math.max(xVal.lo, loVal.lo);
-    const resultHi = Math.min(xVal.hi, hiVal.hi);
-    if (resultLo > resultHi) {
-      return { kind: "empty" };
-    }
+    const lowered = { lo: Math.max(xVal.lo, loVal.lo), hi: Math.max(xVal.hi, loVal.hi) };
+    const resultLo = Math.min(lowered.lo, hiVal.lo);
+    const resultHi = Math.min(lowered.hi, hiVal.hi);
     return { kind: "interval", value: { lo: resultLo, hi: resultHi } };
   }
 
@@ -25756,7 +27631,7 @@ ${code}`;
   function compileIntervalBound(expr, numVal, target) {
     if (numVal !== void 0) return String(numVal);
     const compiled = BaseCompiler.compile(expr, target);
-    return `Math.floor((${compiled}).hi)`;
+    return `Math.floor(((_b) => (_b && _b.value ? _b.value.hi : _b.hi))(${compiled}))`;
   }
   function compileIntervalSumProduct(kind, args, _compile, target) {
     if (!args[0]) throw new Error(`${kind}: no body`);
@@ -25942,7 +27817,7 @@ ${code}`;
   }
 
   // src/compile.ts
-  var version = "0.57.0";
+  var version = "0.59.0";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information: