@cortex-js/compute-engine 0.58.0 → 0.59.0

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.58.0 */
+/** Compute Engine 0.59.0 */
 
 // src/compute-engine/numerics/richardson.ts
 function extrapolate(f, x0, options = {}) {
@@ -159,6 +159,7 @@ function fpexp(x, scale) {
   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);
@@ -808,9 +809,11 @@ var BigDecimal = class _BigDecimal {
     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;
@@ -855,7 +858,10 @@ var BigDecimal = class _BigDecimal {
         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;
@@ -888,7 +894,19 @@ var BigDecimal = class _BigDecimal {
       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. */
@@ -1129,6 +1147,20 @@ function fromFixedPoint(fp, scale, targetPrecision) {
   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;
@@ -1139,9 +1171,13 @@ BigDecimal.prototype.sqrt = function() {
   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;
@@ -1155,10 +1191,13 @@ BigDecimal.prototype.cbrt = function() {
   }
   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);
@@ -1187,7 +1226,8 @@ BigDecimal.prototype.cbrt = function() {
     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();
@@ -1202,11 +1242,27 @@ BigDecimal.prototype.exp = function() {
     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;
@@ -1218,10 +1274,16 @@ BigDecimal.prototype.ln = function() {
   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);
@@ -1241,7 +1303,10 @@ BigDecimal.prototype.sin = function() {
   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);
@@ -1252,6 +1317,8 @@ BigDecimal.prototype.cos = function() {
   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);
@@ -1261,7 +1328,10 @@ BigDecimal.prototype.tan = function() {
   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) {
@@ -1279,7 +1349,9 @@ BigDecimal.prototype.atan = function() {
     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);
@@ -1296,7 +1368,9 @@ BigDecimal.prototype.asin = function() {
     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;
@@ -1359,6 +1433,23 @@ BigDecimal.prototype.sinh = function() {
     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);
@@ -1369,6 +1460,9 @@ BigDecimal.prototype.cosh = function() {
   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);
@@ -1380,6 +1474,21 @@ BigDecimal.prototype.tanh = function() {
     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));
 };
@@ -1428,6 +1537,7 @@ var MACHINE_PRECISION = Math.floor(
   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;
@@ -1439,7 +1549,8 @@ function gcd(a, b) {
 }
 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) {
@@ -1529,216 +1640,27 @@ var PRIMITIVE_TYPES = [
   "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
@@ -2448,19 +2370,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -2501,19 +2417,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -2544,16 +2454,30 @@ var Parser = class {
     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;
   }
@@ -2567,35 +2491,11 @@ var Parser = class {
     }
     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") {
@@ -2780,6 +2680,18 @@ var Parser = class {
           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,
@@ -2794,7 +2706,7 @@ var Parser = class {
   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 });
       }
@@ -3128,14 +3040,32 @@ function buildTypeFromAST(node, typeResolver) {
 }
 
 // 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(
@@ -3210,19 +3140,54 @@ var PRIMITIVE_SUBTYPES = {
   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";
@@ -3237,7 +3202,7 @@ function isSubtype(lhs, rhs) {
       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);
@@ -3467,7 +3432,7 @@ function isSubtype(lhs, rhs) {
 }
 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;
@@ -3475,7 +3440,7 @@ function isNumeric(type) {
 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;
@@ -3483,7 +3448,7 @@ function isScalar(type) {
 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) {
@@ -3522,7 +3487,7 @@ function narrow2(a, b) {
   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;
@@ -3556,16 +3521,17 @@ var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
 ]);
 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 (!members.some(
-      (m) => (typeof m === "string" ? m : JSON.stringify(m)) === key
-    ))
+    if (!keys.has(key)) {
+      keys.add(key);
       members.push(t);
+    }
   };
   push(a);
   push(b);
@@ -3577,48 +3543,225 @@ function narrow(...types) {
   if (types.length === 1) return types[0];
   return types.reduce((a, b) => narrow2(a, b));
 }
-function widen(...types) {
-  if (types.length === 0) return "nothing";
-  if (types.length === 1) return types[0];
-  return types.reduce((a, b) => widen2(a, b));
+function widen(...types) {
+  if (types.length === 0) return "nothing";
+  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";
+  if (a === "never") return b;
+  if (b === "never") return a;
+  if (a === "unknown") return b;
+  if (b === "unknown") return a;
+  if (a === "nothing") return b;
+  if (b === "nothing") return a;
+  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";
+}
+
+// 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 superType(a, b) {
-  if (a === b) return a;
-  if (a === "any" || b === "any") return "any";
-  if (a === "never") return b;
-  if (b === "never") return a;
-  if (a === "unknown") return b;
-  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";
-  return "any";
+function symbolName(name) {
+  if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
+  return `\`${name}\``;
 }
-function commonSupertype(a, b, ancestor) {
-  if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return true;
-  return false;
+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
@@ -3727,6 +3870,12 @@ function sym(expr) {
   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,
@@ -3975,6 +4124,7 @@ function applicable(fn) {
 }
 
 // src/compute-engine/collection-utils.ts
+var MAX_SIZE_EAGER_COLLECTION = 100;
 function isFiniteIndexedCollection(col) {
   return (col.isFiniteCollection ?? false) && col.isIndexedCollection;
 }
@@ -4603,12 +4753,14 @@ function dictionaryFromExpression(expr) {
   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";
       }
@@ -6542,6 +6694,7 @@ var DEFINITIONS_CORE = [
         }
       }
       if (!variable) return null;
+      if (symbol(variable) === null) return null;
       parser.skipSpace();
       const fn = parser.parseExpression({ minPrec: 740 });
       if (!fn) return null;
@@ -6728,7 +6881,7 @@ function parseTextRun(parser, style) {
   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;
@@ -8261,6 +8414,8 @@ function serializeMultiply(serializer, expr) {
       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 {
@@ -9706,7 +9861,8 @@ function parseTrig(op) {
       minPrec: MULTIPLICATION_PRECEDENCE,
       condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
     });
-    const head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+    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];
   };
@@ -11993,6 +12149,30 @@ var POSSIBLE_EMOJI = `(?:${ZWJ_ELEMENT})(${ZWJ}${ZWJ_ELEMENT})*`;
 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;
@@ -12028,6 +12208,50 @@ function flatten(ops, operator2, canonicalize = true) {
   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);
@@ -12959,21 +13183,249 @@ var Complex = class _Complex {
   isInfinite() {
     return !(this["isNaN"]() || this["isFinite"]());
   }
-};
-Complex["ZERO"] = new Complex(0, 0);
-Complex["ONE"] = new Complex(1, 0);
-Complex["I"] = new Complex(0, 1);
-Complex["PI"] = new Complex(Math.PI, 0);
-Complex["E"] = new Complex(Math.E, 0);
-Complex["INFINITY"] = new Complex(Infinity, Infinity);
-Complex["NAN"] = new Complex(NaN, NaN);
-Complex["EPSILON"] = 1e-15;
-
-// src/compute-engine/boxed-expression/numerics.ts
-function toInteger(expr) {
-  if (!isNumber(expr)) return null;
-  const num = expr.numericValue;
-  return Math.round(typeof num === "number" ? num : num.re);
+};
+Complex["ZERO"] = new Complex(0, 0);
+Complex["ONE"] = new Complex(1, 0);
+Complex["I"] = new Complex(0, 1);
+Complex["PI"] = new Complex(Math.PI, 0);
+Complex["E"] = new Complex(Math.E, 0);
+Complex["INFINITY"] = new Complex(Infinity, Infinity);
+Complex["NAN"] = new Complex(NaN, NaN);
+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
@@ -13030,6 +13482,11 @@ function interval(expr) {
   }
   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) {
@@ -13046,8 +13503,236 @@ function canonical(ce, xs, scope) {
   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
@@ -13070,11 +13755,38 @@ var COLLECTIONS_LIBRARY = {
   },
   // 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;
@@ -13083,10 +13795,62 @@ var COLLECTIONS_LIBRARY = {
       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: {
@@ -13186,7 +13950,12 @@ var COLLECTIONS_LIBRARY = {
       },
       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) {
@@ -13262,13 +14031,23 @@ var COLLECTIONS_LIBRARY = {
     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);
@@ -13303,19 +14082,32 @@ var COLLECTIONS_LIBRARY = {
       },
       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);
@@ -13397,11 +14189,15 @@ var COLLECTIONS_LIBRARY = {
         };
       },
       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;
@@ -13431,8 +14227,18 @@ var COLLECTIONS_LIBRARY = {
     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."],
@@ -13548,7 +14354,13 @@ var COLLECTIONS_LIBRARY = {
     },
     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;
@@ -13657,24 +14469,26 @@ var COLLECTIONS_LIBRARY = {
     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(
@@ -13867,10 +14681,13 @@ var COLLECTIONS_LIBRARY = {
         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 };
           }
@@ -13881,7 +14698,13 @@ var COLLECTIONS_LIBRARY = {
         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);
       }
     }
@@ -13963,11 +14786,15 @@ var COLLECTIONS_LIBRARY = {
       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 };
           }
@@ -14046,12 +14873,17 @@ var COLLECTIONS_LIBRARY = {
       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) => {
@@ -14067,6 +14899,11 @@ var COLLECTIONS_LIBRARY = {
         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))
@@ -14330,7 +15167,7 @@ var COLLECTIONS_LIBRARY = {
       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
@@ -14579,11 +15416,25 @@ var COLLECTIONS_LIBRARY = {
       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))
@@ -14743,9 +15594,22 @@ var COLLECTIONS_LIBRARY = {
     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;
@@ -14759,7 +15623,7 @@ var COLLECTIONS_LIBRARY = {
           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;
@@ -14881,7 +15745,7 @@ var COLLECTIONS_LIBRARY = {
     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()));
@@ -14897,7 +15761,7 @@ var COLLECTIONS_LIBRARY = {
     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()));
@@ -14990,11 +15854,129 @@ function canonicalList(ops, { engine: ce }) {
   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 = [];
@@ -15234,7 +16216,11 @@ var BaseCompiler = class _BaseCompiler {
                 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;
           }
@@ -15927,6 +16913,17 @@ function compile(expr, options) {
         `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 {
@@ -15939,7 +16936,7 @@ function compile(expr, options) {
         }
       });
       return {
-        target: options?.to ?? "javascript",
+        target,
         success: false,
         code: "",
         calling: "expression",
@@ -15993,6 +16990,11 @@ function foldTerms(terms, identity, op) {
   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" };
@@ -16017,7 +17019,9 @@ function tryGetComplexParts(expr, compile2) {
       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 };
@@ -19534,9 +20538,14 @@ var lanczos_7_c = [
 ];
 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));
@@ -19547,31 +20556,62 @@ function gamma(z) {
   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 = [
@@ -20157,7 +21197,7 @@ function fresnelS(x) {
     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);
@@ -20182,7 +21222,7 @@ function fresnelC(x) {
     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);
@@ -20273,6 +21313,7 @@ function populationStandardDeviation(values) {
 function kurtosis(values) {
   let sum = 0;
   let sum2 = 0;
+  let sum3 = 0;
   let sum4 = 0;
   let count = 0;
   for (const op of values) {
@@ -20280,12 +21321,16 @@ function kurtosis(values) {
     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;
@@ -20301,9 +21346,11 @@ function skewness(values) {
     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 = {};
@@ -20330,11 +21377,8 @@ function quartiles(values) {
   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
@@ -20665,7 +21709,7 @@ var JAVASCRIPT_FUNCTIONS = {
     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 },
@@ -20676,9 +21720,9 @@ var JAVASCRIPT_FUNCTIONS = {
         }, (_, 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");
@@ -21835,6 +22879,14 @@ function gpuVec2(target) {
 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;
@@ -21952,7 +23004,7 @@ var GPU_FUNCTIONS = {
       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})`;
@@ -21961,7 +23013,7 @@ var GPU_FUNCTIONS = {
     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];
@@ -22039,7 +23091,9 @@ var GPU_FUNCTIONS = {
       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])})`;
@@ -22068,6 +23122,43 @@ var GPU_FUNCTIONS = {
   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];
@@ -22755,7 +23846,7 @@ function compileGPUMatrix(args, compile2, vecFn, matFn, arrayFn) {
   }
   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)
@@ -22787,7 +23878,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);
@@ -22806,6 +23927,26 @@ float _gpu_erfinv(float x) {
   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) {
   if (x < 0.0) return 0.0;
@@ -24185,8 +25326,10 @@ var GPUShaderTarget = class {
     };
     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"))
@@ -24972,9 +26115,18 @@ function negate(x) {
   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;
@@ -25308,6 +26460,7 @@ function mod(a, b) {
   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) {
@@ -25315,6 +26468,11 @@ function mod(a, b) {
   }
   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) {
@@ -25346,6 +26504,23 @@ function gamma2(x) {
   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 };
@@ -25358,7 +26533,21 @@ function _gamma(x) {
     }
     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) });
@@ -25389,7 +26578,15 @@ function _gammaln(x) {
     }
     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) });
 }
@@ -25415,6 +26612,33 @@ function factorial22(x) {
     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;
@@ -25422,13 +26646,10 @@ function binomial(n, k) {
   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);
@@ -25437,13 +26658,15 @@ function gcd3(a, b) {
   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);
@@ -25452,13 +26675,11 @@ function lcm3(a, b) {
   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);
@@ -25850,7 +27071,6 @@ var SINC_EXTREMA = [
   29.8116,
   32.95639
 ];
-var SINC_GLOBAL_LO = -0.21724;
 function sinc2(x) {
   const unwrapped = unwrapOrPropagate(x);
   if (!Array.isArray(unwrapped)) return unwrapped;
@@ -25871,8 +27091,14 @@ function sinc2(x) {
     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 });
 }
@@ -25898,8 +27124,21 @@ function fresnelS2(x) {
     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;
@@ -25916,6 +27155,7 @@ function fresnelC2(x) {
     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 });
 }
 
@@ -26023,11 +27263,9 @@ function clamp(x, lo, hi) {
   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 } };
 }
 
@@ -26360,7 +27598,7 @@ function extractIntervalLimits(limitsExpr) {
 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`);
@@ -26546,7 +27784,7 @@ function compileToIntervalTarget(expr, target) {
 }
 
 // src/compile.ts
-var version = "0.58.0";
+var version = "0.59.0";
 export {
   BaseCompiler,
   GLSLTarget,