@cortex-js/compute-engine 0.35.2 → 0.35.4

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.2 */
+/** Compute Engine 0.35.4 */
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -51485,6 +51485,13 @@ var JAVASCRIPT_FUNCTIONS = {
   },
   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),
@@ -51918,6 +51925,87 @@ var GLSL_FUNCTIONS = {
   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",
@@ -52464,19 +52552,39 @@ function floor2(x) {
   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, continuity: "right" };
 }
 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, continuity: "left" };
 }
 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, continuity: "right" };
+}
+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, continuity: "right" };
 }
 function min2(a, b) {
   const unwrapped = unwrapOrPropagate(a, b);
@@ -52503,18 +52611,15 @@ function mod2(a, b) {
   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, continuity: "right" };
   }
+  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);
@@ -52523,9 +52628,7 @@ function sign2(x) {
   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
@@ -52785,6 +52888,81 @@ function atanh2(x) {
   }
   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) {
@@ -52932,6 +53110,7 @@ var IntervalArithmetic = {
   floor: floor2,
   ceil: ceil2,
   round: round2,
+  fract,
   min: min2,
   max: max2,
   mod: mod2,
@@ -52953,6 +53132,15 @@ var IntervalArithmetic = {
   asinh: asinh2,
   acosh: acosh2,
   atanh: atanh2,
+  acot,
+  acsc,
+  asec,
+  coth,
+  csch,
+  sech,
+  acoth,
+  acsch,
+  asech,
   // Comparison
   less,
   lessEqual,
@@ -53097,17 +53285,28 @@ var INTERVAL_JAVASCRIPT_FUNCTIONS = {
   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
@@ -53269,6 +53468,8 @@ const float IA_SINGULAR = 3.0;
 const float IA_PARTIAL_LO = 4.0;
 const float IA_PARTIAL_HI = 5.0;
 const float IA_PARTIAL_BOTH = 6.0;
+const float IA_SINGULAR_RIGHT = 7.0;
+const float IA_SINGULAR_LEFT = 8.0;
 
 // Interval result struct
 struct IntervalResult {
@@ -53302,12 +53503,20 @@ IntervalResult ia_singular(float at) {
   return IntervalResult(vec2(at, at), IA_SINGULAR);
 }
 
+IntervalResult ia_singular_right(float at) {
+  return IntervalResult(vec2(at, at), IA_SINGULAR_RIGHT);
+}
+
+IntervalResult ia_singular_left(float at) {
+  return IntervalResult(vec2(at, at), IA_SINGULAR_LEFT);
+}
+
 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;
+  return status == IA_EMPTY || status == IA_ENTIRE || status == IA_SINGULAR || status == IA_SINGULAR_RIGHT || status == IA_SINGULAR_LEFT;
 }
 
 // Addition
@@ -53430,24 +53639,99 @@ 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
+  // floor is right-continuous
+  return ia_singular_right(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)
+  // ceil is left-continuous
+  return ia_singular_left(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
+  // round is right-continuous (with round-half-up convention)
+  return ia_singular_right(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
+  // fract is right-continuous (inherits from floor)
+  return ia_singular_right(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
+    // mod has sawtooth discontinuities, right-continuous
+    return ia_singular_right((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
@@ -53736,6 +54020,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;
@@ -53817,6 +54127,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],
@@ -53868,7 +54435,9 @@ var INTERVAL_GLSL_FUNCTIONS = {
   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]);
@@ -53901,6 +54470,7 @@ var INTERVAL_GLSL_FUNCTIONS = {
     }
     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])})`,
@@ -53911,10 +54481,40 @@ var INTERVAL_GLSL_FUNCTIONS = {
   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() {
@@ -55812,10 +56412,10 @@ function defToString(name, def, v) {
 // src/compute-engine.ts
 init_types6();
 init_base_compiler();
-var version = "0.35.2";
+var version = "0.35.4";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.35.2"
+  version: "0.35.4"
 };
 export {
   BaseCompiler,