@cortex-js/compute-engine 0.35.0 → 0.35.2

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.0 */
+/** Compute Engine 0.35.2 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -5443,15 +5443,14 @@ var ComputeEngine = (() => {
     }
     if (a instanceof Decimal) {
       if (!a.isInteger()) return null;
-      return bigint(a.toString());
+      return BigInt(a.toFixed(0));
     }
     let s = a.toLowerCase();
-    const m = s.match(/([+-]?[0-9]*)(?:\.([0-9]+))?e([+-]?[0-9]+)$/);
+    const m = s.match(/^([+-]?[0-9]+)e([+-]?[0-9]+)$/);
     if (m) {
-      const exp3 = parseInt(m[3]);
-      const pad = exp3 - (m[2] ? m[2].length : 0);
-      if (pad < 0) return null;
-      s = (m[1] ?? "") + (m[2] ?? "") + "0".repeat(pad);
+      const exp3 = parseInt(m[2]);
+      if (exp3 < 0) return null;
+      s = m[1] + "0".repeat(exp3);
     }
     const i = s.indexOf(".");
     if (i >= 0) return null;
@@ -9762,6 +9761,23 @@ var ComputeEngine = (() => {
     if (!m) return serializeAutoNotationNumber(valString, options);
     let exponent = parseInt(m[2]);
     let mantissa = m[1];
+    {
+      const signMatch = mantissa.match(/^(-?)/);
+      const sign3 = signMatch ? signMatch[1] : "";
+      const unsigned = sign3 ? mantissa.substring(1) : mantissa;
+      const parts = unsigned.match(/^(\d+)(?:\.(\d*))?$/);
+      if (parts) {
+        let whole = parts[1];
+        let fraction = parts[2] ?? "";
+        if (whole.length > 1) {
+          fraction = whole.slice(1) + fraction;
+          exponent += whole.length - 1;
+          whole = whole[0];
+        }
+        mantissa = sign3 + whole;
+        if (fraction) mantissa += "." + fraction;
+      }
+    }
     if (Math.abs(exponent) % expMultiple !== 0) {
       const adjust = exponent > 0 ? exponent % expMultiple : -((expMultiple + exponent) % expMultiple);
       exponent = exponent >= 0 ? exponent - adjust : exponent + adjust;
@@ -11720,7 +11736,8 @@ var ComputeEngine = (() => {
               }
             } else {
               console.assert(isSubtype(value.type, "integer"));
-              rationalSum = add2(rationalSum, [value.re, 1]);
+              const intValue = BigInt(value.bignumRe.toFixed(0));
+              rationalSum = add2(rationalSum, [intValue, BigInt(1)]);
             }
           }
           if (isZero(rationalSum) && radicals.length === 0) {
@@ -12086,11 +12103,14 @@ var ComputeEngine = (() => {
     const ce = op1.engine;
     if (!op1.isValid || !op2.isValid) return ce._fn("Divide", [op1, op2]);
     if (op1.isNaN || op2.isNaN) return ce.NaN;
-    const op2IsConstantExpression = op2.symbols.length === 0 && !op2.isNumberLiteral;
+    const op2IsConstantExpression = op2.unknowns.length === 0 && !op2.isNumberLiteral;
     if (op2.is(0)) return op1.is(0) ? ce.NaN : ce.ComplexInfinity;
     if (op1.is(0) && op2.isFinite !== false) {
       if (op2IsConstantExpression)
-        return ce._fn("Divide", [op1, op2], { canonical: false });
+        return ce.function("Divide", [op1, op2], {
+          canonical: false,
+          structural: true
+        });
       return ce.Zero;
     }
     if (op2.isInfinity) return op1.isInfinity ? ce.NaN : ce.Zero;
@@ -12099,7 +12119,10 @@ var ComputeEngine = (() => {
         return ce.One;
       if (op1.isSame(op2)) {
         if (op2IsConstantExpression)
-          return ce._fn("Divide", [op1, op2], { canonical: false });
+          return ce.function("Divide", [op1, op2], {
+            canonical: false,
+            structural: true
+          });
         return ce.One;
       }
     }
@@ -15250,7 +15273,7 @@ var ComputeEngine = (() => {
   }
   function canonicalPower(a, b) {
     const ce = a.engine;
-    const fullyCanonical = a.isCanonical && b.isCanonical;
+    const fullyCanonical = (a.isCanonical || a.isStructural) && (b.isCanonical || b.isStructural);
     const unchanged = () => ce._fn("Power", [a, b], { canonical: fullyCanonical });
     if (a.operator === "Power") {
       const [base, aPow] = a.ops;
@@ -15296,7 +15319,7 @@ var ComputeEngine = (() => {
         if (a.is(-1)) return ce.NegativeOne;
         if (a.is(1)) return ce.One;
       }
-      if (!a.isCanonical)
+      if (!(a.isCanonical || a.isStructural))
         return ce._fn("Power", [a, ce.number(-1)], { canonical: false });
       return a.inv();
     }
@@ -15352,10 +15375,10 @@ var ComputeEngine = (() => {
       }
     }
     if (b.is(0.5))
-      return a.isCanonical ? canonicalRoot(a, 2) : ce._fn("Sqrt", [a], { canonical: false });
+      return a.isCanonical || a.isStructural ? canonicalRoot(a, 2) : ce._fn("Sqrt", [a], { canonical: false });
     const r = asRational(b);
     if (r !== void 0 && r[0] === 1 && r[1] !== 1)
-      return a.isCanonical ? canonicalRoot(a, ce.number(r[1])) : ce._fn("Root", [a, ce.number(r[1])], { canonical: false });
+      return a.isCanonical || a.isStructural ? canonicalRoot(a, ce.number(r[1])) : ce._fn("Root", [a, ce.number(r[1])], { canonical: false });
     return unchanged();
   }
   function canonicalRoot(a, b) {
@@ -15374,14 +15397,14 @@ var ComputeEngine = (() => {
           if (v.numericValue.isExact) return v;
         }
       }
-      return ce._fn("Sqrt", [a], { canonical: a.isCanonical });
+      return ce._fn("Sqrt", [a], { canonical: a.isCanonical || a.isStructural });
     }
     return ce._fn("Root", [a, typeof b === "number" ? ce.number(b) : b], {
-      canonical: a.isCanonical && (typeof b === "number" || b.isCanonical)
+      canonical: (a.isCanonical || a.isStructural) && (typeof b === "number" || b.isCanonical || b.isStructural)
     });
   }
   function pow2(x, exp3, { numericApproximation }) {
-    if (!x.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
+    if (!(x.isCanonical || x.isStructural) || typeof exp3 !== "number" && !(exp3.isCanonical || exp3.isStructural))
       return x.engine._fn("Power", [x, x.engine.box(exp3)], { canonical: false });
     if (numericApproximation) {
       if (x.isNumberLiteral) {
@@ -15477,7 +15500,7 @@ var ComputeEngine = (() => {
     return ce._fn("Power", [x, ce.box(exp3)]);
   }
   function root(a, b, { numericApproximation }) {
-    if (!a.isCanonical || !b.isCanonical)
+    if (!(a.isCanonical || a.isStructural) || !(b.isCanonical || b.isStructural))
       return a.engine._fn("Root", [a, b], { canonical: false });
     if (numericApproximation) {
       if (a.isNumberLiteral && b.isNumberLiteral) {
@@ -15683,7 +15706,7 @@ var ComputeEngine = (() => {
     return (a.complexity ?? DEFAULT_COMPLEXITY) - (b.complexity ?? DEFAULT_COMPLEXITY);
   }
   function canonicalOrder(expr, { recursive = false }) {
-    if (expr.isCanonical || !expr.ops) return expr;
+    if (expr.isCanonical || expr.isStructural || !expr.ops) return expr;
     let ops = expr.ops;
     if (recursive) ops = ops.map((x) => canonicalOrder(x, { recursive }));
     ops = sortOperands(expr.operator, ops);
@@ -20107,6 +20130,14 @@ var ComputeEngine = (() => {
             return `return ${_BaseCompiler.compile(args[0], target)}`;
           if (h === "If") {
             if (args.length !== 3) throw new Error("If: wrong number of arguments");
+            const fn2 = target.functions?.(h);
+            if (fn2) {
+              if (typeof fn2 === "function") {
+                return fn2(args, (expr) => _BaseCompiler.compile(expr, target), target);
+              }
+              if (args === null) return `${fn2}()`;
+              return `${fn2}(${args.map((x) => _BaseCompiler.compile(x, target)).join(", ")})`;
+            }
             return `((${_BaseCompiler.compile(args[0], target)}) ? (${_BaseCompiler.compile(
               args[1],
               target
@@ -23789,6 +23820,24 @@ ${e.message}`);
   });
 
   // src/compute-engine/boxed-expression/validate.ts
+  function typeCouldBeCollection(type2) {
+    if (typeof type2 === "string") {
+      return type2 === "collection" || type2 === "indexed_collection" || type2 === "list" || type2 === "set" || type2 === "tuple" || type2 === "any";
+    }
+    if (type2.kind === "list" || type2.kind === "set" || type2.kind === "tuple")
+      return true;
+    if (type2.kind === "union") return type2.types.some((t) => typeCouldBeCollection(t));
+    return false;
+  }
+  function typeCouldBeNumericCollection(type2) {
+    if (typeof type2 === "string") {
+      return type2 === "list" || type2 === "set" || type2 === "collection" || type2 === "indexed_collection";
+    }
+    if (type2.kind === "list" || type2.kind === "set") return true;
+    if (type2.kind === "union")
+      return type2.types.some((t) => typeCouldBeNumericCollection(t));
+    return false;
+  }
   function checkArity(ce, ops, count) {
     ops = flatten(ops);
     if (!ce.strict) return ops;
@@ -23838,7 +23887,9 @@ ${e.message}`);
         xs.push(op);
       } else if (op.symbol && !ce.lookupDefinition(op.symbol)) {
         xs.push(op);
-      } else if (op.type.isUnknown) {
+      } else if (op.type.isUnknown || op.type.type === "any") {
+        xs.push(op);
+      } else if (typeCouldBeNumericCollection(op.type.type)) {
         xs.push(op);
       } else if (isBoxedTensor(op)) {
         xs.push(op);
@@ -23922,11 +23973,11 @@ ${e.message}`);
         isValid = false;
         continue;
       }
-      if (op.type.isUnknown) {
+      if (op.type.isUnknown || op.type.type === "any") {
         result.push(op);
         continue;
       }
-      if (threadable && isFiniteIndexedCollection(op)) {
+      if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
         result.push(op);
         continue;
       }
@@ -23961,12 +24012,12 @@ ${e.message}`);
         i += 1;
         continue;
       }
-      if (op.type.isUnknown) {
+      if (op.type.isUnknown || op.type.type === "any") {
         result.push(op);
         i += 1;
         continue;
       }
-      if (threadable && isFiniteIndexedCollection(op)) {
+      if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
         result.push(op);
         i += 1;
         continue;
@@ -23999,11 +24050,11 @@ ${e.message}`);
           isValid = false;
           continue;
         }
-        if (op.type.isUnknown) {
+        if (op.type.isUnknown || op.type.type === "any") {
           result.push(op);
           continue;
         }
-        if (threadable && isFiniteIndexedCollection(op)) {
+        if (threadable && (isFiniteIndexedCollection(op) || typeCouldBeCollection(op.type.type))) {
           result.push(op);
           continue;
         }
@@ -24033,20 +24084,22 @@ ${e.message}`);
     i = 0;
     for (const param of params) {
       if (!lazy) {
-        if (!threadable || !isFiniteIndexedCollection(ops[i]))
+        if (!threadable || !isFiniteIndexedCollection(ops[i]) && !typeCouldBeCollection(ops[i].type.type))
           ops[i].infer(param);
       }
       i += 1;
     }
     for (const param of optParams) {
       if (!ops[i]) break;
-      if (!threadable || !isFiniteIndexedCollection(ops[i])) ops[i]?.infer(param);
+      if (!threadable || !isFiniteIndexedCollection(ops[i]) && !typeCouldBeCollection(ops[i].type.type))
+        ops[i]?.infer(param);
       i += 1;
     }
     if (varParam) {
       for (const op of ops.slice(i)) {
         if (!lazy) {
-          if (!threadable || !isFiniteIndexedCollection(op)) op.infer(varParam);
+          if (!threadable || !isFiniteIndexedCollection(op) && !typeCouldBeCollection(op.type.type))
+            op.infer(varParam);
         }
         i += 1;
       }
@@ -35470,6 +35523,12 @@ ${lines.join("\n")}`;
           throw Error("Invalid canonical form");
       }
     }
+    if (expr.isFunctionExpression && expr.isCanonical) {
+      expr = expr.engine.function(expr.operator, [...expr.ops], {
+        canonical: false,
+        structural: true
+      });
+    }
     return expr;
   }
   function flattenForm(expr) {
@@ -35551,10 +35610,7 @@ ${lines.join("\n")}`;
     if (!expr.ops) return expr;
     const ops = expr.ops.map(multiplyForm);
     if (expr.operator === "Multiply")
-      return canonicalMultiply(
-        expr.engine,
-        ops.map((x) => x.canonical)
-      );
+      return canonicalMultiply(expr.engine, ops);
     if (expr.operator === "Negate")
       return canonicalMultiply(expr.engine, [ops[0], expr.engine.NegativeOne]);
     return expr;
@@ -45688,7 +45744,7 @@ Error in definition of "${name}"`,
       return void 0;
     }
     get isCanonical() {
-      return this._def !== void 0 && this._def !== null;
+      return this._def !== void 0 && this._def !== null && !this._isStructural;
     }
     get isPure() {
       if (this._isPure !== void 0) return this._isPure;
@@ -45855,7 +45911,7 @@ Error in definition of "${name}"`,
     subs(sub3, options) {
       options ??= { canonical: void 0 };
       if (options.canonical === void 0)
-        options = { canonical: this.isCanonical };
+        options = { canonical: this.isCanonical || this.isStructural };
       const ops = this._ops.map((x) => x.subs(sub3, options));
       if (!ops.every((x) => x.isValid))
         return this.engine.function(this._operator, ops, { canonical: false });
@@ -45927,7 +45983,7 @@ Error in definition of "${name}"`,
       return this.numeratorDenominator[1];
     }
     get numeratorDenominator() {
-      if (!this.isCanonical) return [this, this.engine.One];
+      if (!(this.isCanonical || this.isStructural)) return [this, this.engine.One];
       if (this.isNumber !== true)
         return [this.engine.Nothing, this.engine.Nothing];
       const operator2 = this.operator;
@@ -45965,11 +46021,11 @@ Error in definition of "${name}"`,
     // ALGEBRAIC OPERATIONS
     //
     neg() {
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       return negate(this);
     }
     inv() {
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       if (this.isOne) return this;
       if (this.isNegativeOne) return this;
       if (this.operator === "Sqrt") return this.op1.inv().sqrt();
@@ -45990,7 +46046,7 @@ Error in definition of "${name}"`,
       return this.engine._fn("Divide", [this.engine.One, this]);
     }
     abs() {
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       if (this.operator === "Abs" || this.operator === "Negate") return this;
       if (this.isNonNegative) return this;
       if (this.isNonPositive) return this.neg();
@@ -45998,11 +46054,11 @@ Error in definition of "${name}"`,
     }
     add(rhs) {
       if (rhs === 0) return this;
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       return add3(this, this.engine.box(rhs));
     }
     mul(rhs) {
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       if (rhs === 0) return this.engine.Zero;
       if (rhs === 1) return this;
       if (rhs === -1) return this.neg();
@@ -46014,14 +46070,14 @@ Error in definition of "${name}"`,
       return mul3(this, this.engine.box(rhs));
     }
     div(rhs) {
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       return div2(this, rhs);
     }
     pow(exp3) {
       return pow2(this, exp3, { numericApproximation: false });
     }
     root(exp3) {
-      if (!this.isCanonical || typeof exp3 !== "number" && !exp3.isCanonical)
+      if (!(this.isCanonical || this.isStructural) || typeof exp3 !== "number" && !(exp3.isCanonical || exp3.isStructural))
         throw new Error("Not canonical");
       const e = typeof exp3 === "number" ? exp3 : exp3.im === 0 ? exp3.re : void 0;
       if (e === 0) return this.engine.NaN;
@@ -46080,7 +46136,7 @@ Error in definition of "${name}"`,
     }
     ln(semiBase) {
       const base = semiBase ? this.engine.box(semiBase) : void 0;
-      if (!this.isCanonical) throw new Error("Not canonical");
+      if (!(this.isCanonical || this.isStructural)) throw new Error("Not canonical");
       if (this.is(0)) return this.engine.NegativeInfinity;
       if (this.operator === "Exp") {
         if (!base) return this.op1;
@@ -46113,7 +46169,7 @@ Error in definition of "${name}"`,
       return this.engine._fn("Ln", [this]);
     }
     get complexity() {
-      if (!this.isCanonical) return void 0;
+      if (!(this.isCanonical || this.isStructural)) return void 0;
       return this.operatorDefinition?.complexity ?? DEFAULT_COMPLEXITY;
     }
     get baseDefinition() {
@@ -52279,49 +52335,64 @@ Error in definition of "${name}"`,
     return { lo: Math.pow(base.lo, n), hi: Math.pow(base.hi, n) };
   }
   function pow3(base, exp3) {
+    const unwrapped = unwrapOrPropagate(base);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [baseVal] = unwrapped;
     if (Number.isInteger(exp3)) {
       if (exp3 >= 0) {
-        return ok(intPow2(base, exp3));
+        return ok(intPow2(baseVal, exp3));
       } else {
-        if (containsZero(base)) {
+        if (containsZero(baseVal)) {
           return { kind: "singular" };
         }
-        const denom = intPow2(base, -exp3);
+        const denom = intPow2(baseVal, -exp3);
         return ok({ lo: 1 / denom.hi, hi: 1 / denom.lo });
       }
     } else {
-      if (isNegative(base)) {
+      if (isNegative(baseVal)) {
         return { kind: "empty" };
       }
-      if (base.lo < 0) {
-        const value = exp3 > 0 ? { lo: 0, hi: Math.pow(base.hi, exp3) } : { lo: Math.pow(base.hi, exp3), hi: Infinity };
+      if (baseVal.lo < 0) {
+        const value = exp3 > 0 ? { lo: 0, hi: Math.pow(baseVal.hi, exp3) } : { lo: Math.pow(baseVal.hi, exp3), hi: Infinity };
         return { kind: "partial", value, domainClipped: "lo" };
       }
       if (exp3 > 0) {
-        return ok({ lo: Math.pow(base.lo, exp3), hi: Math.pow(base.hi, exp3) });
+        return ok({
+          lo: Math.pow(baseVal.lo, exp3),
+          hi: Math.pow(baseVal.hi, exp3)
+        });
       } else {
-        if (base.lo === 0) {
+        if (baseVal.lo === 0) {
           return {
             kind: "partial",
-            value: { lo: Math.pow(base.hi, exp3), hi: Infinity },
+            value: { lo: Math.pow(baseVal.hi, exp3), hi: Infinity },
             domainClipped: "hi"
           };
         }
-        return ok({ lo: Math.pow(base.hi, exp3), hi: Math.pow(base.lo, exp3) });
+        return ok({
+          lo: Math.pow(baseVal.hi, exp3),
+          hi: Math.pow(baseVal.lo, exp3)
+        });
       }
     }
   }
   function powInterval(base, exp3) {
-    if (base.hi <= 0) {
+    const unwrapped = unwrapOrPropagate(base, exp3);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [baseVal, expVal] = unwrapped;
+    if (baseVal.hi <= 0) {
       return { kind: "empty" };
     }
-    if (base.lo <= 0) {
-      const posBase = { lo: Math.max(base.lo, Number.EPSILON), hi: base.hi };
+    if (baseVal.lo <= 0) {
+      const posBase = {
+        lo: Math.max(baseVal.lo, Number.EPSILON),
+        hi: baseVal.hi
+      };
       const corners2 = [
-        Math.pow(posBase.lo, exp3.lo),
-        Math.pow(posBase.lo, exp3.hi),
-        Math.pow(posBase.hi, exp3.lo),
-        Math.pow(posBase.hi, exp3.hi)
+        Math.pow(posBase.lo, expVal.lo),
+        Math.pow(posBase.lo, expVal.hi),
+        Math.pow(posBase.hi, expVal.lo),
+        Math.pow(posBase.hi, expVal.hi)
       ];
       return {
         kind: "partial",
@@ -52330,10 +52401,10 @@ Error in definition of "${name}"`,
       };
     }
     const corners = [
-      Math.pow(base.lo, exp3.lo),
-      Math.pow(base.lo, exp3.hi),
-      Math.pow(base.hi, exp3.lo),
-      Math.pow(base.hi, exp3.hi)
+      Math.pow(baseVal.lo, expVal.lo),
+      Math.pow(baseVal.lo, expVal.hi),
+      Math.pow(baseVal.hi, expVal.lo),
+      Math.pow(baseVal.hi, expVal.hi)
     ];
     return ok({ lo: Math.min(...corners), hi: Math.max(...corners) });
   }
@@ -52344,79 +52415,115 @@ Error in definition of "${name}"`,
     return ok({ lo: Math.exp(xVal.lo), hi: Math.exp(xVal.hi) });
   }
   function ln2(x) {
-    if (x.hi <= 0) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi <= 0) {
       return { kind: "empty" };
     }
-    if (x.lo > 0) {
-      return ok({ lo: Math.log(x.lo), hi: Math.log(x.hi) });
+    if (xVal.lo > 0) {
+      return ok({ lo: Math.log(xVal.lo), hi: Math.log(xVal.hi) });
     }
     return {
       kind: "partial",
-      value: { lo: -Infinity, hi: Math.log(x.hi) },
+      value: { lo: -Infinity, hi: Math.log(xVal.hi) },
       domainClipped: "lo"
     };
   }
   function log102(x) {
-    if (x.hi <= 0) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi <= 0) {
       return { kind: "empty" };
     }
-    if (x.lo > 0) {
-      return ok({ lo: Math.log10(x.lo), hi: Math.log10(x.hi) });
+    if (xVal.lo > 0) {
+      return ok({ lo: Math.log10(xVal.lo), hi: Math.log10(xVal.hi) });
     }
     return {
       kind: "partial",
-      value: { lo: -Infinity, hi: Math.log10(x.hi) },
+      value: { lo: -Infinity, hi: Math.log10(xVal.hi) },
       domainClipped: "lo"
     };
   }
   function log22(x) {
-    if (x.hi <= 0) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi <= 0) {
       return { kind: "empty" };
     }
-    if (x.lo > 0) {
-      return ok({ lo: Math.log2(x.lo), hi: Math.log2(x.hi) });
+    if (xVal.lo > 0) {
+      return ok({ lo: Math.log2(xVal.lo), hi: Math.log2(xVal.hi) });
     }
     return {
       kind: "partial",
-      value: { lo: -Infinity, hi: Math.log2(x.hi) },
+      value: { lo: -Infinity, hi: Math.log2(xVal.hi) },
       domainClipped: "lo"
     };
   }
   function abs2(x) {
-    if (x.lo >= 0) {
-      return ok(x);
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo >= 0) {
+      return ok(xVal);
     }
-    if (x.hi <= 0) {
-      return ok({ lo: -x.hi, hi: -x.lo });
+    if (xVal.hi <= 0) {
+      return ok({ lo: -xVal.hi, hi: -xVal.lo });
     }
-    return ok({ lo: 0, hi: Math.max(-x.lo, x.hi) });
+    return ok({ lo: 0, hi: Math.max(-xVal.lo, xVal.hi) });
   }
   function floor2(x) {
-    return ok({ lo: Math.floor(x.lo), hi: Math.floor(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.floor(xVal.lo), hi: Math.floor(xVal.hi) });
   }
   function ceil2(x) {
-    return ok({ lo: Math.ceil(x.lo), hi: Math.ceil(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.ceil(xVal.lo), hi: Math.ceil(xVal.hi) });
   }
   function round2(x) {
-    return ok({ lo: Math.round(x.lo), hi: Math.round(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.round(xVal.lo), hi: Math.round(xVal.hi) });
   }
   function min2(a, b) {
-    return ok({ lo: Math.min(a.lo, b.lo), hi: Math.min(a.hi, b.hi) });
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [aVal, bVal] = unwrapped;
+    return ok({
+      lo: Math.min(aVal.lo, bVal.lo),
+      hi: Math.min(aVal.hi, bVal.hi)
+    });
   }
   function max2(a, b) {
-    return ok({ lo: Math.max(a.lo, b.lo), hi: Math.max(a.hi, b.hi) });
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [aVal, bVal] = unwrapped;
+    return ok({
+      lo: Math.max(aVal.lo, bVal.lo),
+      hi: Math.max(aVal.hi, bVal.hi)
+    });
   }
   function mod2(a, b) {
-    if (containsZero(b)) {
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [aVal, bVal] = unwrapped;
+    if (containsZero(bVal)) {
       return { kind: "singular" };
     }
-    const bAbs = Math.max(Math.abs(b.lo), Math.abs(b.hi));
-    const aWidth = a.hi - a.lo;
+    const bAbs = Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi));
+    const aWidth = aVal.hi - aVal.lo;
     if (aWidth >= bAbs) {
       return ok({ lo: 0, hi: bAbs });
     }
-    const modLo = (a.lo % bAbs + bAbs) % bAbs;
-    const modHi = (a.hi % bAbs + bAbs) % bAbs;
+    const modLo = (aVal.lo % bAbs + bAbs) % bAbs;
+    const modHi = (aVal.hi % bAbs + bAbs) % bAbs;
     if (modLo <= modHi) {
       return ok({ lo: modLo, hi: modHi });
     } else {
@@ -52424,11 +52531,14 @@ Error in definition of "${name}"`,
     }
   }
   function sign2(x) {
-    if (x.lo > 0) return ok({ lo: 1, hi: 1 });
-    if (x.hi < 0) return ok({ lo: -1, hi: -1 });
-    if (x.lo === 0 && x.hi === 0) return ok({ lo: 0, hi: 0 });
-    if (x.lo < 0 && x.hi > 0) return ok({ lo: -1, hi: 1 });
-    if (x.lo === 0) return ok({ lo: 0, hi: 1 });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo > 0) return ok({ lo: 1, hi: 1 });
+    if (xVal.hi < 0) return ok({ lo: -1, hi: -1 });
+    if (xVal.lo === 0 && xVal.hi === 0) return ok({ lo: 0, hi: 0 });
+    if (xVal.lo < 0 && xVal.hi > 0) return ok({ lo: -1, hi: 1 });
+    if (xVal.lo === 0) return ok({ lo: 0, hi: 1 });
     return ok({ lo: -1, hi: 0 });
   }
 
@@ -52438,231 +52548,298 @@ Error in definition of "${name}"`,
   var HALF_PI = Math.PI / 2;
   var THREE_HALF_PI = 3 * Math.PI / 2;
   function sin2(x) {
-    if (x.hi - x.lo >= TWO_PI) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= TWO_PI) {
       return ok({ lo: -1, hi: 1 });
     }
-    const sinLo = Math.sin(x.lo);
-    const sinHi = Math.sin(x.hi);
+    const sinLo = Math.sin(xVal.lo);
+    const sinHi = Math.sin(xVal.hi);
     let lo = Math.min(sinLo, sinHi);
     let hi = Math.max(sinLo, sinHi);
-    if (containsExtremum(x, HALF_PI, TWO_PI)) {
+    if (containsExtremum(xVal, HALF_PI, TWO_PI)) {
       hi = 1;
     }
-    if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+    if (containsExtremum(xVal, THREE_HALF_PI, TWO_PI)) {
       lo = -1;
     }
     return ok({ lo, hi });
   }
   function cos2(x) {
-    if (x.hi - x.lo >= TWO_PI) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= TWO_PI) {
       return ok({ lo: -1, hi: 1 });
     }
-    const cosLo = Math.cos(x.lo);
-    const cosHi = Math.cos(x.hi);
+    const cosLo = Math.cos(xVal.lo);
+    const cosHi = Math.cos(xVal.hi);
     let lo = Math.min(cosLo, cosHi);
     let hi = Math.max(cosLo, cosHi);
-    if (containsExtremum(x, 0, TWO_PI)) {
+    if (containsExtremum(xVal, 0, TWO_PI)) {
       hi = 1;
     }
-    if (containsExtremum(x, PI2, TWO_PI)) {
+    if (containsExtremum(xVal, PI2, TWO_PI)) {
       lo = -1;
     }
     return ok({ lo, hi });
   }
   function tan2(x) {
-    if (x.hi - x.lo >= PI2) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= PI2) {
       return { kind: "singular" };
     }
-    if (containsExtremum(x, HALF_PI, PI2)) {
-      const n = Math.ceil((x.lo - HALF_PI) / PI2);
+    if (containsExtremum(xVal, HALF_PI, PI2)) {
+      const n = Math.ceil((xVal.lo - HALF_PI) / PI2);
       const poleAt = HALF_PI + n * PI2;
       return { kind: "singular", at: poleAt };
     }
-    const tanLo = Math.tan(x.lo);
-    const tanHi = Math.tan(x.hi);
+    const tanLo = Math.tan(xVal.lo);
+    const tanHi = Math.tan(xVal.hi);
     if (tanLo > 1e10 && tanHi < -1e10 || tanLo < -1e10 && tanHi > 1e10) {
       return { kind: "singular" };
     }
     return ok({ lo: tanLo, hi: tanHi });
   }
   function cot(x) {
-    if (x.hi - x.lo >= PI2) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= PI2) {
       return { kind: "singular" };
     }
-    if (containsExtremum(x, 0, PI2)) {
-      const n = Math.ceil(x.lo / PI2);
+    if (containsExtremum(xVal, 0, PI2)) {
+      const n = Math.ceil(xVal.lo / PI2);
       const poleAt = n * PI2;
       return { kind: "singular", at: poleAt };
     }
-    const cotLo = 1 / Math.tan(x.lo);
-    const cotHi = 1 / Math.tan(x.hi);
+    const cotLo = 1 / Math.tan(xVal.lo);
+    const cotHi = 1 / Math.tan(xVal.hi);
     return ok({ lo: Math.min(cotLo, cotHi), hi: Math.max(cotLo, cotHi) });
   }
   function sec(x) {
-    if (x.hi - x.lo >= PI2) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= PI2) {
       return { kind: "singular" };
     }
-    if (containsExtremum(x, HALF_PI, PI2)) {
-      const n = Math.ceil((x.lo - HALF_PI) / PI2);
+    if (containsExtremum(xVal, HALF_PI, PI2)) {
+      const n = Math.ceil((xVal.lo - HALF_PI) / PI2);
       const poleAt = HALF_PI + n * PI2;
       return { kind: "singular", at: poleAt };
     }
-    const secLo = 1 / Math.cos(x.lo);
-    const secHi = 1 / Math.cos(x.hi);
+    const secLo = 1 / Math.cos(xVal.lo);
+    const secHi = 1 / Math.cos(xVal.hi);
     let lo = Math.min(secLo, secHi);
     let hi = Math.max(secLo, secHi);
-    if (containsExtremum(x, 0, TWO_PI)) {
+    if (containsExtremum(xVal, 0, TWO_PI)) {
       lo = Math.min(lo, 1);
       hi = Math.max(hi, 1);
     }
-    if (containsExtremum(x, PI2, TWO_PI)) {
+    if (containsExtremum(xVal, PI2, TWO_PI)) {
       lo = Math.min(lo, -1);
       hi = Math.max(hi, -1);
     }
     return ok({ lo, hi });
   }
   function csc(x) {
-    if (x.hi - x.lo >= PI2) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi - xVal.lo >= PI2) {
       return { kind: "singular" };
     }
-    if (containsExtremum(x, 0, PI2)) {
-      const n = Math.ceil(x.lo / PI2);
+    if (containsExtremum(xVal, 0, PI2)) {
+      const n = Math.ceil(xVal.lo / PI2);
       const poleAt = n * PI2;
       return { kind: "singular", at: poleAt };
     }
-    const cscLo = 1 / Math.sin(x.lo);
-    const cscHi = 1 / Math.sin(x.hi);
+    const cscLo = 1 / Math.sin(xVal.lo);
+    const cscHi = 1 / Math.sin(xVal.hi);
     let lo = Math.min(cscLo, cscHi);
     let hi = Math.max(cscLo, cscHi);
-    if (containsExtremum(x, HALF_PI, TWO_PI)) {
+    if (containsExtremum(xVal, HALF_PI, TWO_PI)) {
       lo = Math.min(lo, 1);
       hi = Math.max(hi, 1);
     }
-    if (containsExtremum(x, THREE_HALF_PI, TWO_PI)) {
+    if (containsExtremum(xVal, THREE_HALF_PI, TWO_PI)) {
       lo = Math.min(lo, -1);
       hi = Math.max(hi, -1);
     }
     return ok({ lo, hi });
   }
   function asin2(x) {
-    if (x.lo > 1 || x.hi < -1) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo > 1 || xVal.hi < -1) {
       return { kind: "empty" };
     }
-    if (x.lo < -1 || x.hi > 1) {
-      const clippedLo = Math.max(x.lo, -1);
-      const clippedHi = Math.min(x.hi, 1);
+    if (xVal.lo < -1 || xVal.hi > 1) {
+      const clippedLo = Math.max(xVal.lo, -1);
+      const clippedHi = Math.min(xVal.hi, 1);
       return {
         kind: "partial",
         value: { lo: Math.asin(clippedLo), hi: Math.asin(clippedHi) },
-        domainClipped: x.lo < -1 && x.hi > 1 ? "both" : x.lo < -1 ? "lo" : "hi"
+        domainClipped: xVal.lo < -1 && xVal.hi > 1 ? "both" : xVal.lo < -1 ? "lo" : "hi"
       };
     }
-    return ok({ lo: Math.asin(x.lo), hi: Math.asin(x.hi) });
+    return ok({ lo: Math.asin(xVal.lo), hi: Math.asin(xVal.hi) });
   }
   function acos2(x) {
-    if (x.lo > 1 || x.hi < -1) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo > 1 || xVal.hi < -1) {
       return { kind: "empty" };
     }
-    if (x.lo < -1 || x.hi > 1) {
-      const clippedLo = Math.max(x.lo, -1);
-      const clippedHi = Math.min(x.hi, 1);
+    if (xVal.lo < -1 || xVal.hi > 1) {
+      const clippedLo = Math.max(xVal.lo, -1);
+      const clippedHi = Math.min(xVal.hi, 1);
       return {
         kind: "partial",
         value: { lo: Math.acos(clippedHi), hi: Math.acos(clippedLo) },
-        domainClipped: x.lo < -1 && x.hi > 1 ? "both" : x.lo < -1 ? "lo" : "hi"
+        domainClipped: xVal.lo < -1 && xVal.hi > 1 ? "both" : xVal.lo < -1 ? "lo" : "hi"
       };
     }
-    return ok({ lo: Math.acos(x.hi), hi: Math.acos(x.lo) });
+    return ok({ lo: Math.acos(xVal.hi), hi: Math.acos(xVal.lo) });
   }
   function atan3(x) {
-    return ok({ lo: Math.atan(x.lo), hi: Math.atan(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.atan(xVal.lo), hi: Math.atan(xVal.hi) });
   }
   function atan22(y, x) {
-    if (y.lo === y.hi && x.lo === x.hi) {
-      const result = Math.atan2(y.lo, x.lo);
+    const unwrapped = unwrapOrPropagate(y, x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [yVal, xVal] = unwrapped;
+    if (yVal.lo === yVal.hi && xVal.lo === xVal.hi) {
+      const result = Math.atan2(yVal.lo, xVal.lo);
       return ok({ lo: result, hi: result });
     }
     const angles = [];
-    angles.push(Math.atan2(y.lo, x.lo));
-    angles.push(Math.atan2(y.lo, x.hi));
-    angles.push(Math.atan2(y.hi, x.lo));
-    angles.push(Math.atan2(y.hi, x.hi));
-    if (x.lo < 0 && y.lo < 0 && y.hi > 0) {
+    angles.push(Math.atan2(yVal.lo, xVal.lo));
+    angles.push(Math.atan2(yVal.lo, xVal.hi));
+    angles.push(Math.atan2(yVal.hi, xVal.lo));
+    angles.push(Math.atan2(yVal.hi, xVal.hi));
+    if (xVal.lo < 0 && yVal.lo < 0 && yVal.hi > 0) {
       return ok({ lo: -PI2, hi: PI2 });
     }
     return ok({ lo: Math.min(...angles), hi: Math.max(...angles) });
   }
   function sinh3(x) {
-    return ok({ lo: Math.sinh(x.lo), hi: Math.sinh(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.sinh(xVal.lo), hi: Math.sinh(xVal.hi) });
   }
   function cosh3(x) {
-    if (x.lo >= 0) {
-      return ok({ lo: Math.cosh(x.lo), hi: Math.cosh(x.hi) });
-    } else if (x.hi <= 0) {
-      return ok({ lo: Math.cosh(x.hi), hi: Math.cosh(x.lo) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo >= 0) {
+      return ok({ lo: Math.cosh(xVal.lo), hi: Math.cosh(xVal.hi) });
+    } else if (xVal.hi <= 0) {
+      return ok({ lo: Math.cosh(xVal.hi), hi: Math.cosh(xVal.lo) });
     } else {
-      return ok({ lo: 1, hi: Math.max(Math.cosh(x.lo), Math.cosh(x.hi)) });
+      return ok({
+        lo: 1,
+        hi: Math.max(Math.cosh(xVal.lo), Math.cosh(xVal.hi))
+      });
     }
   }
   function tanh2(x) {
-    return ok({ lo: Math.tanh(x.lo), hi: Math.tanh(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.tanh(xVal.lo), hi: Math.tanh(xVal.hi) });
   }
   function asinh2(x) {
-    return ok({ lo: Math.asinh(x.lo), hi: Math.asinh(x.hi) });
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    return ok({ lo: Math.asinh(xVal.lo), hi: Math.asinh(xVal.hi) });
   }
   function acosh2(x) {
-    if (x.hi < 1) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.hi < 1) {
       return { kind: "empty" };
     }
-    if (x.lo < 1) {
+    if (xVal.lo < 1) {
       return {
         kind: "partial",
-        value: { lo: 0, hi: Math.acosh(x.hi) },
+        value: { lo: 0, hi: Math.acosh(xVal.hi) },
         domainClipped: "lo"
       };
     }
-    return ok({ lo: Math.acosh(x.lo), hi: Math.acosh(x.hi) });
+    return ok({ lo: Math.acosh(xVal.lo), hi: Math.acosh(xVal.hi) });
   }
   function atanh2(x) {
-    if (x.lo >= 1 || x.hi <= -1) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (xVal.lo >= 1 || xVal.hi <= -1) {
       return { kind: "empty" };
     }
-    if (x.lo <= -1 || x.hi >= 1) {
-      const clippedLo = Math.max(x.lo, -1 + Number.EPSILON);
-      const clippedHi = Math.min(x.hi, 1 - Number.EPSILON);
+    if (xVal.lo <= -1 || xVal.hi >= 1) {
+      const clippedLo = Math.max(xVal.lo, -1 + Number.EPSILON);
+      const clippedHi = Math.min(xVal.hi, 1 - Number.EPSILON);
       return {
         kind: "partial",
         value: { lo: Math.atanh(clippedLo), hi: Math.atanh(clippedHi) },
-        domainClipped: x.lo <= -1 && x.hi >= 1 ? "both" : x.lo <= -1 ? "lo" : "hi"
+        domainClipped: xVal.lo <= -1 && xVal.hi >= 1 ? "both" : xVal.lo <= -1 ? "lo" : "hi"
       };
     }
-    return ok({ lo: Math.atanh(x.lo), hi: Math.atanh(x.hi) });
+    return ok({ lo: Math.atanh(xVal.lo), hi: Math.atanh(xVal.hi) });
   }
 
   // src/compute-engine/interval/comparison.ts
   function less(a, b) {
-    if (a.hi < b.lo) return "true";
-    if (a.lo >= b.hi) return "false";
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return "maybe";
+    const [aVal, bVal] = unwrapped;
+    if (aVal.hi < bVal.lo) return "true";
+    if (aVal.lo >= bVal.hi) return "false";
     return "maybe";
   }
   function lessEqual(a, b) {
-    if (a.hi <= b.lo) return "true";
-    if (a.lo > b.hi) return "false";
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return "maybe";
+    const [aVal, bVal] = unwrapped;
+    if (aVal.hi <= bVal.lo) return "true";
+    if (aVal.lo > bVal.hi) return "false";
     return "maybe";
   }
   function greater(a, b) {
-    if (a.lo > b.hi) return "true";
-    if (a.hi <= b.lo) return "false";
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return "maybe";
+    const [aVal, bVal] = unwrapped;
+    if (aVal.lo > bVal.hi) return "true";
+    if (aVal.hi <= bVal.lo) return "false";
     return "maybe";
   }
   function greaterEqual(a, b) {
-    if (a.lo >= b.hi) return "true";
-    if (a.hi < b.lo) return "false";
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return "maybe";
+    const [aVal, bVal] = unwrapped;
+    if (aVal.lo >= bVal.hi) return "true";
+    if (aVal.hi < bVal.lo) return "false";
     return "maybe";
   }
   function equal(a, b) {
-    if (a.lo === a.hi && b.lo === b.hi && a.lo === b.lo) return "true";
-    if (a.hi < b.lo || b.hi < a.lo) return "false";
+    const unwrapped = unwrapOrPropagate(a, b);
+    if (!Array.isArray(unwrapped)) return "maybe";
+    const [aVal, bVal] = unwrapped;
+    if (aVal.lo === aVal.hi && bVal.lo === bVal.hi && aVal.lo === bVal.lo)
+      return "true";
+    if (aVal.hi < bVal.lo || bVal.hi < aVal.lo) return "false";
     return "maybe";
   }
   function notEqual(a, b) {
@@ -52686,22 +52863,45 @@ Error in definition of "${name}"`,
     if (a === "false") return "true";
     return "maybe";
   }
-  function piecewise(x, condition, trueBranch, falseBranch) {
-    const cond = condition(x);
+  function piecewise(xOrCond, conditionOrTrue, trueOrFalse, falseBranch) {
+    if (xOrCond === "true" || xOrCond === "false" || xOrCond === "maybe") {
+      const cond2 = xOrCond;
+      const trueBranch2 = conditionOrTrue;
+      const falseBranchFn2 = trueOrFalse;
+      switch (cond2) {
+        case "true":
+          return trueBranch2();
+        case "false":
+          return falseBranchFn2();
+        case "maybe":
+          return unionResults(trueBranch2(), falseBranchFn2());
+      }
+    }
+    const x = xOrCond;
+    const condition = conditionOrTrue;
+    const trueBranch = trueOrFalse;
+    const falseBranchFn = falseBranch;
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    const cond = condition(xVal);
     switch (cond) {
       case "true":
-        return trueBranch(x);
+        return trueBranch(xVal);
       case "false":
-        return falseBranch(x);
+        return falseBranchFn(xVal);
       case "maybe":
-        const t = trueBranch(x);
-        const f = falseBranch(x);
+        const t = trueBranch(xVal);
+        const f = falseBranchFn(xVal);
         return unionResults(t, f);
     }
   }
   function clamp2(x, lo, hi) {
-    const resultLo = Math.max(x.lo, lo.lo);
-    const resultHi = Math.min(x.hi, hi.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" };
     }
@@ -52929,11 +53129,20 @@ Error in definition of "${name}"`,
       if (args.length !== 3) throw new Error("If: wrong number of arguments");
       return `_IA.piecewise(
       ${compile(args[0])},
-      (_x) => ${compile(args[0])},
-      (_x) => ${compile(args[1])},
-      (_x) => ${compile(args[2])}
+      () => ${compile(args[1])},
+      () => ${compile(args[2])}
     )`;
-    }
+    },
+    // Comparisons
+    Equal: (args, compile) => `_IA.equal(${compile(args[0])}, ${compile(args[1])})`,
+    NotEqual: (args, compile) => `_IA.notEqual(${compile(args[0])}, ${compile(args[1])})`,
+    LessEqual: (args, compile) => `_IA.lessEqual(${compile(args[0])}, ${compile(args[1])})`,
+    GreaterEqual: (args, compile) => `_IA.greaterEqual(${compile(args[0])}, ${compile(args[1])})`,
+    Less: (args, compile) => `_IA.less(${compile(args[0])}, ${compile(args[1])})`,
+    Greater: (args, compile) => `_IA.greater(${compile(args[0])}, ${compile(args[1])})`,
+    And: (args, compile) => `_IA.and(${compile(args[0])}, ${compile(args[1])})`,
+    Or: (args, compile) => `_IA.or(${compile(args[0])}, ${compile(args[1])})`,
+    Not: (args, compile) => `_IA.not(${compile(args[0])})`
   };
   var ComputeEngineIntervalFunction = class extends Function {
     IA = IntervalArithmetic;
@@ -53111,6 +53320,10 @@ IntervalResult ia_partial(vec2 v, float clip) {
   return IntervalResult(v, clip);
 }
 
+bool ia_is_error(float status) {
+  return status == IA_EMPTY || status == IA_ENTIRE || status == IA_SINGULAR;
+}
+
 // Addition
 IntervalResult ia_add(vec2 a, vec2 b) {
   return ia_ok(vec2(a.x + b.x - IA_EPS, a.y + b.y + IA_EPS));
@@ -53426,6 +53639,198 @@ IntervalResult ia_cosh(vec2 x) {
 IntervalResult ia_tanh(vec2 x) {
   return ia_ok(vec2(tanh(x.x) - IA_EPS, tanh(x.y) + IA_EPS));
 }
+
+// IntervalResult overloads for propagation
+IntervalResult ia_add(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_add(a.value, b.value);
+}
+
+IntervalResult ia_add(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_add(a.value, b);
+}
+
+IntervalResult ia_add(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_add(a, b.value);
+}
+
+IntervalResult ia_sub(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_sub(a.value, b.value);
+}
+
+IntervalResult ia_sub(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_sub(a.value, b);
+}
+
+IntervalResult ia_sub(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_sub(a, b.value);
+}
+
+IntervalResult ia_mul(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_mul(a.value, b.value);
+}
+
+IntervalResult ia_mul(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_mul(a.value, b);
+}
+
+IntervalResult ia_mul(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_mul(a, b.value);
+}
+
+IntervalResult ia_div(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_div(a.value, b.value);
+}
+
+IntervalResult ia_div(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_div(a.value, b);
+}
+
+IntervalResult ia_div(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_div(a, b.value);
+}
+
+IntervalResult ia_negate(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_negate(x.value);
+}
+
+IntervalResult ia_sqrt(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sqrt(x.value);
+}
+
+IntervalResult ia_square(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_square(x.value);
+}
+
+IntervalResult ia_exp(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_exp(x.value);
+}
+
+IntervalResult ia_ln(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_ln(x.value);
+}
+
+IntervalResult ia_abs(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_abs(x.value);
+}
+
+IntervalResult ia_sign(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sign(x.value);
+}
+
+IntervalResult ia_floor(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_floor(x.value);
+}
+
+IntervalResult ia_ceil(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_ceil(x.value);
+}
+
+IntervalResult ia_min(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_min(a.value, b.value);
+}
+
+IntervalResult ia_min(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_min(a.value, b);
+}
+
+IntervalResult ia_min(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_min(a, b.value);
+}
+
+IntervalResult ia_max(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_max(a.value, b.value);
+}
+
+IntervalResult ia_max(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_max(a.value, b);
+}
+
+IntervalResult ia_max(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_max(a, b.value);
+}
+
+IntervalResult ia_pow(IntervalResult base, float exp) {
+  if (ia_is_error(base.status)) return base;
+  return ia_pow(base.value, exp);
+}
+
+IntervalResult ia_sin(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sin(x.value);
+}
+
+IntervalResult ia_cos(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_cos(x.value);
+}
+
+IntervalResult ia_tan(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_tan(x.value);
+}
+
+IntervalResult ia_asin(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_asin(x.value);
+}
+
+IntervalResult ia_acos(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acos(x.value);
+}
+
+IntervalResult ia_atan(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_atan(x.value);
+}
+
+IntervalResult ia_sinh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sinh(x.value);
+}
+
+IntervalResult ia_cosh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_cosh(x.value);
+}
+
+IntervalResult ia_tanh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_tanh(x.value);
+}
 `;
   var INTERVAL_GLSL_OPERATORS = {
     Add: ["ia_add", 20],
@@ -54351,12 +54756,11 @@ IntervalResult ${functionName}(${params}) {
           bignum
         );
       if (value instanceof Decimal) {
-        if (value.isInteger() && value.e <= MAX_BIGINT_DIGITS)
-          return new ExactNumericValue(
-            bigint(value.toString()),
-            makeNumericValue,
-            bignum
-          );
+        if (value.isInteger() && value.e <= MAX_BIGINT_DIGITS) {
+          const n = bigint(value.toString());
+          if (n !== null)
+            return new ExactNumericValue(n, makeNumericValue, bignum);
+        }
         return makeNumericValue(value);
       }
       if (value instanceof Complex) {
@@ -55422,10 +55826,10 @@ IntervalResult ${functionName}(${params}) {
   // src/compute-engine.ts
   init_types6();
   init_base_compiler();
-  var version = "0.35.0";
+  var version = "0.35.2";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.35.0"
+    version: "0.35.2"
   };
   return __toCommonJS(compute_engine_exports);
 })();