@cortex-js/compute-engine 0.35.1 → 0.35.3

package/dist/compute-engine.umd.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.1 */
+/** Compute Engine 0.35.3 */
     (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);
@@ -23797,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;
@@ -23846,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);
@@ -23930,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;
       }
@@ -23969,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;
@@ -24007,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;
         }
@@ -24041,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;
       }
@@ -35478,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) {
@@ -35559,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;
@@ -45696,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;
@@ -45863,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 });
@@ -45935,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;
@@ -45973,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();
@@ -45998,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();
@@ -46006,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();
@@ -46022,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;
@@ -46088,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;
@@ -46121,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() {
@@ -51451,6 +51499,13 @@ Error in definition of "${name}"`,
     },
     Exp: "Math.exp",
     Floor: "Math.floor",
+    Fract: ([x], compile) => {
+      if (x === null) throw new Error("Fract: no argument");
+      return BaseCompiler.inlineExpression(
+        "${x} - Math.floor(${x})",
+        compile(x)
+      );
+    },
     Gamma: "_SYS.gamma",
     GCD: "_SYS.gcd",
     Integrate: (args, compile, target) => compileIntegrate(args, compile, target),
@@ -51884,6 +51939,87 @@ Error in definition of "${name}"`,
     Sqrt: "sqrt",
     Step: "step",
     Tan: "tan",
+    // Reciprocal trigonometric functions (no GLSL built-ins)
+    Cot: ([x], compile) => {
+      if (x === null) throw new Error("Cot: no argument");
+      const arg = compile(x);
+      return `(cos(${arg}) / sin(${arg}))`;
+    },
+    Csc: ([x], compile) => {
+      if (x === null) throw new Error("Csc: no argument");
+      return `(1.0 / sin(${compile(x)}))`;
+    },
+    Sec: ([x], compile) => {
+      if (x === null) throw new Error("Sec: no argument");
+      return `(1.0 / cos(${compile(x)}))`;
+    },
+    // Inverse trigonometric (reciprocal)
+    Arccot: ([x], compile) => {
+      if (x === null) throw new Error("Arccot: no argument");
+      return `atan(1.0 / (${compile(x)}))`;
+    },
+    Arccsc: ([x], compile) => {
+      if (x === null) throw new Error("Arccsc: no argument");
+      return `asin(1.0 / (${compile(x)}))`;
+    },
+    Arcsec: ([x], compile) => {
+      if (x === null) throw new Error("Arcsec: no argument");
+      return `acos(1.0 / (${compile(x)}))`;
+    },
+    // Hyperbolic functions (GLSL ES 3.0+ built-ins)
+    Sinh: "sinh",
+    Cosh: "cosh",
+    Tanh: "tanh",
+    // Reciprocal hyperbolic functions
+    Coth: ([x], compile) => {
+      if (x === null) throw new Error("Coth: no argument");
+      const arg = compile(x);
+      return `(cosh(${arg}) / sinh(${arg}))`;
+    },
+    Csch: ([x], compile) => {
+      if (x === null) throw new Error("Csch: no argument");
+      return `(1.0 / sinh(${compile(x)}))`;
+    },
+    Sech: ([x], compile) => {
+      if (x === null) throw new Error("Sech: no argument");
+      return `(1.0 / cosh(${compile(x)}))`;
+    },
+    // Inverse hyperbolic functions (GLSL ES 3.0+ built-ins)
+    Arcosh: "acosh",
+    Arsinh: "asinh",
+    Artanh: "atanh",
+    // Inverse hyperbolic (reciprocal)
+    Arcoth: ([x], compile) => {
+      if (x === null) throw new Error("Arcoth: no argument");
+      return `atanh(1.0 / (${compile(x)}))`;
+    },
+    Arcsch: ([x], compile) => {
+      if (x === null) throw new Error("Arcsch: no argument");
+      return `asinh(1.0 / (${compile(x)}))`;
+    },
+    Arsech: ([x], compile) => {
+      if (x === null) throw new Error("Arsech: no argument");
+      return `acosh(1.0 / (${compile(x)}))`;
+    },
+    // Additional math functions
+    Sgn: "sign",
+    Lb: "log2",
+    Log: (args, compile) => {
+      if (args.length === 0) throw new Error("Log: no argument");
+      if (args.length === 1) return `(log(${compile(args[0])}) / log(10.0))`;
+      return `(log(${compile(args[0])}) / log(${compile(args[1])}))`;
+    },
+    Square: ([x], compile) => {
+      if (x === null) throw new Error("Square: no argument");
+      const arg = compile(x);
+      return `(${arg} * ${arg})`;
+    },
+    Root: ([x, n], compile) => {
+      if (x === null) throw new Error("Root: no argument");
+      if (n === null || n === void 0) return `sqrt(${compile(x)})`;
+      if (n?.re === 2) return `sqrt(${compile(x)})`;
+      return `pow(${compile(x)}, 1.0 / ${compile(n)})`;
+    },
     // Vector/Matrix operations
     Cross: "cross",
     Distance: "distance",
@@ -52430,19 +52566,39 @@ Error in definition of "${name}"`,
     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) });
+    const flo = Math.floor(xVal.lo);
+    const fhi = Math.floor(xVal.hi);
+    if (flo === fhi) return ok({ lo: flo, hi: fhi });
+    return { kind: "singular", at: flo + 1 };
   }
   function ceil2(x) {
     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) });
+    const clo = Math.ceil(xVal.lo);
+    const chi = Math.ceil(xVal.hi);
+    if (clo === chi) return ok({ lo: clo, hi: chi });
+    return { kind: "singular", at: clo };
   }
   function round2(x) {
     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) });
+    const rlo = Math.round(xVal.lo);
+    const rhi = Math.round(xVal.hi);
+    if (rlo === rhi) return ok({ lo: rlo, hi: rhi });
+    return { kind: "singular", at: rlo + 0.5 };
+  }
+  function fract(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    const flo = Math.floor(xVal.lo);
+    const fhi = Math.floor(xVal.hi);
+    if (flo === fhi) {
+      return ok({ lo: xVal.lo - flo, hi: xVal.hi - flo });
+    }
+    return { kind: "singular", at: flo + 1 };
   }
   function min2(a, b) {
     const unwrapped = unwrapOrPropagate(a, b);
@@ -52469,18 +52625,15 @@ Error in definition of "${name}"`,
     if (containsZero(bVal)) {
       return { kind: "singular" };
     }
-    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 = (aVal.lo % bAbs + bAbs) % bAbs;
-    const modHi = (aVal.hi % bAbs + bAbs) % bAbs;
-    if (modLo <= modHi) {
-      return ok({ lo: modLo, hi: modHi });
-    } else {
-      return ok({ lo: 0, hi: bAbs });
+    const period = Math.abs(bVal.lo === bVal.hi ? bVal.lo : Math.max(Math.abs(bVal.lo), Math.abs(bVal.hi)));
+    const flo = Math.floor(aVal.lo / period);
+    const fhi = Math.floor(aVal.hi / period);
+    if (flo !== fhi) {
+      return { kind: "singular", at: (flo + 1) * period };
     }
+    const modLo = aVal.lo - period * flo;
+    const modHi = aVal.hi - period * flo;
+    return ok({ lo: Math.min(modLo, modHi), hi: Math.max(modLo, modHi) });
   }
   function sign2(x) {
     const unwrapped = unwrapOrPropagate(x);
@@ -52489,9 +52642,7 @@ Error in definition of "${name}"`,
     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 });
+    return { kind: "singular", at: 0 };
   }
 
   // src/compute-engine/interval/trigonometric.ts
@@ -52751,6 +52902,81 @@ Error in definition of "${name}"`,
     }
     return ok({ lo: Math.atanh(xVal.lo), hi: Math.atanh(xVal.hi) });
   }
+  function acot(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return atan3(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
+  function acsc(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return asin2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
+  function asec(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return acos2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
+  function coth(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return div3(cosh3(xVal), sinh3(xVal));
+  }
+  function csch(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return div3(ok({ lo: 1, hi: 1 }), sinh3(xVal));
+  }
+  function sech(x) {
+    return div3(ok({ lo: 1, hi: 1 }), cosh3(x));
+  }
+  function acoth(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return atanh2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
+  function acsch(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return asinh2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
+  function asech(x) {
+    const unwrapped = unwrapOrPropagate(x);
+    if (!Array.isArray(unwrapped)) return unwrapped;
+    const [xVal] = unwrapped;
+    if (containsZero(xVal)) {
+      return { kind: "singular", at: 0 };
+    }
+    return acosh2(div3(ok({ lo: 1, hi: 1 }), ok(xVal)));
+  }
 
   // src/compute-engine/interval/comparison.ts
   function less(a, b) {
@@ -52898,6 +53124,7 @@ Error in definition of "${name}"`,
     floor: floor2,
     ceil: ceil2,
     round: round2,
+    fract,
     min: min2,
     max: max2,
     mod: mod2,
@@ -52919,6 +53146,15 @@ Error in definition of "${name}"`,
     asinh: asinh2,
     acosh: acosh2,
     atanh: atanh2,
+    acot,
+    acsc,
+    asec,
+    coth,
+    csch,
+    sech,
+    acoth,
+    acsch,
+    asech,
     // Comparison
     less,
     lessEqual,
@@ -53063,17 +53299,28 @@ Error in definition of "${name}"`,
     Arcsin: (args, compile) => `_IA.asin(${compile(args[0])})`,
     Arccos: (args, compile) => `_IA.acos(${compile(args[0])})`,
     Arctan: (args, compile) => `_IA.atan(${compile(args[0])})`,
+    Arccot: (args, compile) => `_IA.acot(${compile(args[0])})`,
+    Arccsc: (args, compile) => `_IA.acsc(${compile(args[0])})`,
+    Arcsec: (args, compile) => `_IA.asec(${compile(args[0])})`,
     // Hyperbolic functions
     Sinh: (args, compile) => `_IA.sinh(${compile(args[0])})`,
     Cosh: (args, compile) => `_IA.cosh(${compile(args[0])})`,
     Tanh: (args, compile) => `_IA.tanh(${compile(args[0])})`,
+    Coth: (args, compile) => `_IA.coth(${compile(args[0])})`,
+    Csch: (args, compile) => `_IA.csch(${compile(args[0])})`,
+    Sech: (args, compile) => `_IA.sech(${compile(args[0])})`,
     Arsinh: (args, compile) => `_IA.asinh(${compile(args[0])})`,
     Arcosh: (args, compile) => `_IA.acosh(${compile(args[0])})`,
     Artanh: (args, compile) => `_IA.atanh(${compile(args[0])})`,
+    Arcoth: (args, compile) => `_IA.acoth(${compile(args[0])})`,
+    Arcsch: (args, compile) => `_IA.acsch(${compile(args[0])})`,
+    Arsech: (args, compile) => `_IA.asech(${compile(args[0])})`,
     // Inverse trig (alternative names)
     Asin: (args, compile) => `_IA.asin(${compile(args[0])})`,
     Acos: (args, compile) => `_IA.acos(${compile(args[0])})`,
     Atan: (args, compile) => `_IA.atan(${compile(args[0])})`,
+    // Elementary
+    Fract: (args, compile) => `_IA.fract(${compile(args[0])})`,
     // Mod
     Mod: (args, compile) => `_IA.mod(${compile(args[0])}, ${compile(args[1])})`,
     // Conditionals
@@ -53396,24 +53643,94 @@ IntervalResult ia_abs(vec2 x) {
   return ia_ok(vec2(0.0, max(-x.x, x.y)));
 }
 
-// Sign function
+// Sign function - has jump discontinuity at 0
 IntervalResult ia_sign(vec2 x) {
   if (x.x > 0.0) return ia_ok(vec2(1.0, 1.0));
   if (x.y < 0.0) return ia_ok(vec2(-1.0, -1.0));
   if (x.x == 0.0 && x.y == 0.0) return ia_ok(vec2(0.0, 0.0));
-  if (x.x < 0.0 && x.y > 0.0) return ia_ok(vec2(-1.0, 1.0));
-  if (x.x == 0.0) return ia_ok(vec2(0.0, 1.0));
-  return ia_ok(vec2(-1.0, 0.0));
+  // Interval spans 0 - discontinuity
+  return ia_singular(0.0);
 }
 
-// Floor
+// Floor - has jump discontinuities at every integer
 IntervalResult ia_floor(vec2 x) {
-  return ia_ok(vec2(floor(x.x), floor(x.y)));
+  float flo = floor(x.x);
+  float fhi = floor(x.y);
+  if (flo == fhi) {
+    return ia_ok(vec2(flo, fhi));
+  }
+  // Interval spans an integer boundary - discontinuity at first integer > x.x
+  return ia_singular(flo + 1.0);
 }
 
-// Ceiling
+// Ceiling - has jump discontinuities at every integer
 IntervalResult ia_ceil(vec2 x) {
-  return ia_ok(vec2(ceil(x.x), ceil(x.y)));
+  float clo = ceil(x.x);
+  float chi = ceil(x.y);
+  if (clo == chi) {
+    return ia_ok(vec2(clo, chi));
+  }
+  // Interval spans an integer boundary - discontinuity at ceil(x.x)
+  return ia_singular(clo);
+}
+
+// Round - has jump discontinuities at every half-integer
+// Note: GLSL round() uses IEEE 754 round-half-to-even, while JS Math.round
+// uses round-half-up. They differ only AT half-integers; discontinuity
+// detection is safe because intervals spanning half-integers return singular.
+IntervalResult ia_round(vec2 x) {
+  float rlo = round(x.x);
+  float rhi = round(x.y);
+  if (rlo == rhi) {
+    return ia_ok(vec2(rlo, rhi));
+  }
+  // Interval spans a half-integer boundary - discontinuity
+  return ia_singular(rlo + 0.5);
+}
+
+// Fract - sawtooth discontinuities at every integer
+// fract(x) = x - floor(x), jumps from ~1 back to 0 at each integer
+IntervalResult ia_fract(vec2 x) {
+  float flo = floor(x.x);
+  float fhi = floor(x.y);
+  if (flo == fhi) {
+    // No integer crossing - fract is continuous (linear) on this interval
+    return ia_ok(vec2(fract(x.x) - IA_EPS, fract(x.y) + IA_EPS));
+  }
+  // Interval spans an integer - sawtooth discontinuity
+  return ia_singular(flo + 1.0);
+}
+
+// Mod - periodic discontinuities at multiples of the modulus
+// mod(x, y) = x - y * floor(x / y)
+IntervalResult ia_mod(vec2 x, vec2 y) {
+  // y contains zero - undefined
+  if (y.x <= 0.0 && y.y >= 0.0) {
+    return ia_singular(0.0);
+  }
+
+  // Constant modulus (point interval) - common case
+  if (y.x == y.y) {
+    float period = abs(y.x);
+    float flo = floor(x.x / period);
+    float fhi = floor(x.y / period);
+    if (flo == fhi) {
+      // No discontinuity - mod is continuous (linear) on this interval
+      float mlo = x.x - period * flo;
+      float mhi = x.y - period * flo;
+      return ia_ok(vec2(min(mlo, mhi) - IA_EPS, max(mlo, mhi) + IA_EPS));
+    }
+    // Discontinuity at first multiple of period in the interval
+    return ia_singular((flo + 1.0) * period);
+  }
+
+  // General case: compose from existing operations
+  // Discontinuity detection comes from ia_floor
+  IntervalResult q = ia_div(x, y);
+  if (ia_is_error(q.status)) return q;
+  IntervalResult fq = ia_floor(q.value);
+  if (ia_is_error(fq.status)) return fq;
+  return ia_sub(x, ia_mul_raw(y, fq.value));
 }
 
 // Min of two intervals
@@ -53702,6 +54019,32 @@ IntervalResult ia_ceil(IntervalResult x) {
   return ia_ceil(x.value);
 }
 
+IntervalResult ia_round(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_round(x.value);
+}
+
+IntervalResult ia_fract(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_fract(x.value);
+}
+
+IntervalResult ia_mod(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status)) return a;
+  if (ia_is_error(b.status)) return b;
+  return ia_mod(a.value, b.value);
+}
+
+IntervalResult ia_mod(IntervalResult a, vec2 b) {
+  if (ia_is_error(a.status)) return a;
+  return ia_mod(a.value, b);
+}
+
+IntervalResult ia_mod(vec2 a, IntervalResult b) {
+  if (ia_is_error(b.status)) return b;
+  return ia_mod(a, b.value);
+}
+
 IntervalResult ia_min(IntervalResult a, IntervalResult b) {
   if (ia_is_error(a.status)) return a;
   if (ia_is_error(b.status)) return b;
@@ -53783,6 +54126,263 @@ IntervalResult ia_tanh(IntervalResult x) {
   if (ia_is_error(x.status)) return x;
   return ia_tanh(x.value);
 }
+
+// Cotangent (derived from cos/sin)
+IntervalResult ia_cot(vec2 x) {
+  return ia_div(ia_cos(x), ia_sin(x));
+}
+
+IntervalResult ia_cot(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_cot(x.value);
+}
+
+// Cosecant (derived from 1/sin)
+IntervalResult ia_csc(vec2 x) {
+  return ia_div(ia_ok(vec2(1.0, 1.0)), ia_sin(x));
+}
+
+IntervalResult ia_csc(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_csc(x.value);
+}
+
+// Secant (derived from 1/cos)
+IntervalResult ia_sec(vec2 x) {
+  return ia_div(ia_ok(vec2(1.0, 1.0)), ia_cos(x));
+}
+
+IntervalResult ia_sec(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sec(x.value);
+}
+
+// Inverse cotangent
+IntervalResult ia_acot(vec2 x) {
+  return ia_atan(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_acot(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acot(x.value);
+}
+
+// Inverse cosecant
+IntervalResult ia_acsc(vec2 x) {
+  return ia_asin(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_acsc(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acsc(x.value);
+}
+
+// Inverse secant
+IntervalResult ia_asec(vec2 x) {
+  return ia_acos(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_asec(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_asec(x.value);
+}
+
+// Hyperbolic cotangent
+IntervalResult ia_coth(vec2 x) {
+  return ia_div(ia_cosh(x), ia_sinh(x));
+}
+
+IntervalResult ia_coth(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_coth(x.value);
+}
+
+// Hyperbolic cosecant
+IntervalResult ia_csch(vec2 x) {
+  return ia_div(ia_ok(vec2(1.0, 1.0)), ia_sinh(x));
+}
+
+IntervalResult ia_csch(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_csch(x.value);
+}
+
+// Hyperbolic secant
+IntervalResult ia_sech(vec2 x) {
+  return ia_div(ia_ok(vec2(1.0, 1.0)), ia_cosh(x));
+}
+
+IntervalResult ia_sech(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_sech(x.value);
+}
+
+// Inverse hyperbolic sine
+IntervalResult ia_asinh(vec2 x) {
+  return ia_ok(vec2(asinh(x.x) - IA_EPS, asinh(x.y) + IA_EPS));
+}
+
+IntervalResult ia_asinh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_asinh(x.value);
+}
+
+// Inverse hyperbolic cosine
+IntervalResult ia_acosh(vec2 x) {
+  if (x.y < 1.0) {
+    return ia_empty();
+  }
+  if (x.x >= 1.0) {
+    return ia_ok(vec2(acosh(x.x) - IA_EPS, acosh(x.y) + IA_EPS));
+  }
+  return ia_partial(vec2(0.0, acosh(x.y) + IA_EPS), IA_PARTIAL_LO);
+}
+
+IntervalResult ia_acosh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acosh(x.value);
+}
+
+// Inverse hyperbolic tangent
+IntervalResult ia_atanh(vec2 x) {
+  if (x.x >= 1.0 || x.y <= -1.0) {
+    return ia_empty();
+  }
+  vec2 clipped = vec2(max(x.x, -1.0 + IA_EPS), min(x.y, 1.0 - IA_EPS));
+  if (x.x < -1.0 || x.y > 1.0) {
+    float clip = (x.x < -1.0 && x.y > 1.0) ? IA_PARTIAL_BOTH :
+                 (x.x < -1.0) ? IA_PARTIAL_LO : IA_PARTIAL_HI;
+    return ia_partial(vec2(atanh(clipped.x) - IA_EPS, atanh(clipped.y) + IA_EPS), clip);
+  }
+  return ia_ok(vec2(atanh(x.x) - IA_EPS, atanh(x.y) + IA_EPS));
+}
+
+IntervalResult ia_atanh(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_atanh(x.value);
+}
+
+// Inverse hyperbolic cotangent
+IntervalResult ia_acoth(vec2 x) {
+  return ia_atanh(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_acoth(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acoth(x.value);
+}
+
+// Inverse hyperbolic cosecant
+IntervalResult ia_acsch(vec2 x) {
+  return ia_asinh(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_acsch(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_acsch(x.value);
+}
+
+// Inverse hyperbolic secant
+IntervalResult ia_asech(vec2 x) {
+  return ia_acosh(ia_div(ia_ok(vec2(1.0, 1.0)), ia_ok(x)));
+}
+
+IntervalResult ia_asech(IntervalResult x) {
+  if (ia_is_error(x.status)) return x;
+  return ia_asech(x.value);
+}
+
+// Boolean interval comparisons
+// Returns 1.0 = true, 0.0 = false, 0.5 = maybe
+const float IA_TRUE = 1.0;
+const float IA_FALSE = 0.0;
+const float IA_MAYBE = 0.5;
+
+float ia_less(vec2 a, vec2 b) {
+  if (a.y < b.x) return IA_TRUE;
+  if (a.x >= b.y) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_lessEqual(vec2 a, vec2 b) {
+  if (a.y <= b.x) return IA_TRUE;
+  if (a.x > b.y) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_greater(vec2 a, vec2 b) {
+  if (a.x > b.y) return IA_TRUE;
+  if (a.y <= b.x) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_greaterEqual(vec2 a, vec2 b) {
+  if (a.x >= b.y) return IA_TRUE;
+  if (a.y < b.x) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_equal(vec2 a, vec2 b) {
+  if (a.x == a.y && b.x == b.y && a.x == b.x) return IA_TRUE;
+  if (a.y < b.x || b.y < a.x) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_notEqual(vec2 a, vec2 b) {
+  float eq = ia_equal(a, b);
+  if (eq == IA_TRUE) return IA_FALSE;
+  if (eq == IA_FALSE) return IA_TRUE;
+  return IA_MAYBE;
+}
+
+float ia_and(float a, float b) {
+  if (a == IA_FALSE || b == IA_FALSE) return IA_FALSE;
+  if (a == IA_TRUE && b == IA_TRUE) return IA_TRUE;
+  return IA_MAYBE;
+}
+
+float ia_or(float a, float b) {
+  if (a == IA_TRUE || b == IA_TRUE) return IA_TRUE;
+  if (a == IA_FALSE && b == IA_FALSE) return IA_FALSE;
+  return IA_MAYBE;
+}
+
+float ia_not(float a) {
+  if (a == IA_TRUE) return IA_FALSE;
+  if (a == IA_FALSE) return IA_TRUE;
+  return IA_MAYBE;
+}
+
+// IntervalResult overloads for comparisons
+float ia_less(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_less(a.value, b.value);
+}
+
+float ia_lessEqual(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_lessEqual(a.value, b.value);
+}
+
+float ia_greater(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_greater(a.value, b.value);
+}
+
+float ia_greaterEqual(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_greaterEqual(a.value, b.value);
+}
+
+float ia_equal(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_equal(a.value, b.value);
+}
+
+float ia_notEqual(IntervalResult a, IntervalResult b) {
+  if (ia_is_error(a.status) || ia_is_error(b.status)) return IA_MAYBE;
+  return ia_notEqual(a.value, b.value);
+}
 `;
   var INTERVAL_GLSL_OPERATORS = {
     Add: ["ia_add", 20],
@@ -53834,7 +54434,9 @@ IntervalResult ia_tanh(IntervalResult x) {
     Ceiling: (args, compile) => `ia_ceil(${compile(args[0])})`,
     Exp: (args, compile) => `ia_exp(${compile(args[0])})`,
     Floor: (args, compile) => `ia_floor(${compile(args[0])})`,
+    Fract: (args, compile) => `ia_fract(${compile(args[0])})`,
     Ln: (args, compile) => `ia_ln(${compile(args[0])})`,
+    Mod: (args, compile) => `ia_mod(${compile(args[0])}, ${compile(args[1])})`,
     Max: (args, compile) => {
       if (args.length === 0) return "ia_point(-1e38)";
       if (args.length === 1) return compile(args[0]);
@@ -53867,6 +54469,7 @@ IntervalResult ia_tanh(IntervalResult x) {
       }
       throw new Error("Interval GLSL does not support variable exponents");
     },
+    Round: (args, compile) => `ia_round(${compile(args[0])})`,
     Sgn: (args, compile) => `ia_sign(${compile(args[0])})`,
     Sqrt: (args, compile) => `ia_sqrt(${compile(args[0])})`,
     Square: (args, compile) => `ia_square(${compile(args[0])})`,
@@ -53877,10 +54480,40 @@ IntervalResult ia_tanh(IntervalResult x) {
     Arcsin: (args, compile) => `ia_asin(${compile(args[0])})`,
     Arccos: (args, compile) => `ia_acos(${compile(args[0])})`,
     Arctan: (args, compile) => `ia_atan(${compile(args[0])})`,
+    // Reciprocal trigonometric functions
+    Cot: (args, compile) => `ia_cot(${compile(args[0])})`,
+    Csc: (args, compile) => `ia_csc(${compile(args[0])})`,
+    Sec: (args, compile) => `ia_sec(${compile(args[0])})`,
+    // Inverse trigonometric (reciprocal)
+    Arccot: (args, compile) => `ia_acot(${compile(args[0])})`,
+    Arccsc: (args, compile) => `ia_acsc(${compile(args[0])})`,
+    Arcsec: (args, compile) => `ia_asec(${compile(args[0])})`,
     // Hyperbolic functions
     Sinh: (args, compile) => `ia_sinh(${compile(args[0])})`,
     Cosh: (args, compile) => `ia_cosh(${compile(args[0])})`,
-    Tanh: (args, compile) => `ia_tanh(${compile(args[0])})`
+    Tanh: (args, compile) => `ia_tanh(${compile(args[0])})`,
+    // Reciprocal hyperbolic functions
+    Coth: (args, compile) => `ia_coth(${compile(args[0])})`,
+    Csch: (args, compile) => `ia_csch(${compile(args[0])})`,
+    Sech: (args, compile) => `ia_sech(${compile(args[0])})`,
+    // Inverse hyperbolic functions
+    Arsinh: (args, compile) => `ia_asinh(${compile(args[0])})`,
+    Arcosh: (args, compile) => `ia_acosh(${compile(args[0])})`,
+    Artanh: (args, compile) => `ia_atanh(${compile(args[0])})`,
+    // Inverse hyperbolic (reciprocal)
+    Arcoth: (args, compile) => `ia_acoth(${compile(args[0])})`,
+    Arcsch: (args, compile) => `ia_acsch(${compile(args[0])})`,
+    Arsech: (args, compile) => `ia_asech(${compile(args[0])})`,
+    // Comparison and logic (return float: 1.0=true, 0.0=false, 0.5=maybe)
+    Equal: (args, compile) => `ia_equal(${compile(args[0])}, ${compile(args[1])})`,
+    NotEqual: (args, compile) => `ia_notEqual(${compile(args[0])}, ${compile(args[1])})`,
+    Less: (args, compile) => `ia_less(${compile(args[0])}, ${compile(args[1])})`,
+    LessEqual: (args, compile) => `ia_lessEqual(${compile(args[0])}, ${compile(args[1])})`,
+    Greater: (args, compile) => `ia_greater(${compile(args[0])}, ${compile(args[1])})`,
+    GreaterEqual: (args, compile) => `ia_greaterEqual(${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 IntervalGLSLTarget = class {
     getOperators() {
@@ -54708,12 +55341,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) {
@@ -55779,10 +56411,10 @@ IntervalResult ${functionName}(${params}) {
   // src/compute-engine.ts
   init_types6();
   init_base_compiler();
-  var version = "0.35.1";
+  var version = "0.35.3";
   globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.35.1"
+    version: "0.35.3"
   };
   return __toCommonJS(compute_engine_exports);
 })();