@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/compile.umd.cjs

@@ -1,4 +1,4 @@
-/** Compile 0.60.0 */
+/** Compile 0.61.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Compile = {}));})(this, (function (exports) { 'use strict';
 "use strict";
 var Compile = (() => {
@@ -26,6 +26,7 @@ var Compile = (() => {
     BaseCompiler: () => BaseCompiler,
     GLSLTarget: () => GLSLTarget,
     GPUShaderTarget: () => GPUShaderTarget,
+    IntervalGLSLTarget: () => IntervalGLSLTarget,
     IntervalJavaScriptTarget: () => IntervalJavaScriptTarget,
     JavaScriptTarget: () => JavaScriptTarget,
     PythonTarget: () => PythonTarget,
@@ -4558,10 +4559,18 @@ var Compile = (() => {
   }
   function canonicalFunctionLiteralArguments(ce, ops) {
     if (ops.length === 0) return void 0;
-    const block = ops[0].operator === "Block" ? ops[0].canonical : ce.function("Block", [ops[0]]);
     const params = ops.slice(1).map(
       (x) => isSymbol2(x) ? x : ce.error("expected-a-symbol", x.toString())
     );
+    ce._pushShadowedParameters(
+      params.filter((p) => isSymbol2(p)).map((p) => p.symbol)
+    );
+    let block;
+    try {
+      block = ops[0].operator === "Block" ? ops[0].canonical : ce.function("Block", [ops[0]]);
+    } finally {
+      ce._popShadowedParameters();
+    }
     console.assert(block.isScoped);
     for (const param of params) {
       if (isSymbol2(param) && !block.localScope.bindings.has(param.symbol)) {
@@ -16755,6 +16764,13 @@ ${lines.join("\n")}`;
 
   // src/compute-engine/compilation/base-compiler.ts
   var BaseCompiler = class _BaseCompiler {
+    /**
+     * Precedence used when compiling a folded symbol value. Higher than any
+     * target's infix operator precedence, so a compound value parenthesizes
+     * itself when spliced into a surrounding expression. See
+     * `tryFoldKnownSymbol`.
+     */
+    static FOLD_OPERAND_PREC = 1e3;
     /**
      * Compile an expression to target language source code
      */
@@ -16771,7 +16787,9 @@ ${lines.join("\n")}`;
         if (op !== void 0) {
           return `(a,b) => a ${op[0]} b`;
         }
-        return target.var?.(s) ?? s;
+        const resolved = target.var?.(s);
+        if (resolved !== void 0) return resolved;
+        return _BaseCompiler.tryFoldKnownSymbol(expr.engine, s, target) ?? s;
       }
       if (isNumber(expr)) {
         if (expr.im !== 0) {
@@ -17097,10 +17115,10 @@ ${lines.join("\n")}`;
           )
         );
         const needsWrap2 = target.number(0) !== "0";
-        const bodyTarget2 = needsWrap2 ? {
+        const bodyTarget2 = {
           ...target,
-          var: (id) => loopVarSet.has(id) ? target.number(0).replace("0", id) : target.var(id)
-        } : target;
+          var: (id) => loopVarSet.has(id) ? needsWrap2 ? target.number(0).replace("0", id) : id : target.var(id)
+        };
         const bodyCode = _BaseCompiler.compile(body, bodyTarget2);
         let inner = `result.push(${bodyCode});`;
         for (let i = narrowedElements.length - 1; i >= 0; i--) {
@@ -17398,6 +17416,167 @@ ${lines.join("\n")}`;
       if (isNumber(expr)) return expr.im === 0 && expr.re >= 0;
       return expr.isNonNegative === true;
     }
+    /**
+     * If `id` names a symbol that is *known* to the engine — it has an assigned
+     * value (`ce.assign("a", 1.5)`) or is a declared constant — return the
+     * compiled target code for that value, i.e. **fold** the value into the
+     * generated code the way `evaluate()` does. Returns `undefined` for a
+     * genuinely free symbol (no value), so the caller falls back to its
+     * free-symbol plumbing (a `vars` mapping, a `_.id` argument lookup, or a
+     * declarable identifier).
+     *
+     * This keeps the compiled output consistent with `expr.unknowns` and
+     * `evaluate()`: a symbol they treat as known (folded / dropped) is also
+     * folded by `compile()`, instead of being emitted as a bare, dangling
+     * reference (an undeclared GLSL identifier, or a bare JS global that throws
+     * `ReferenceError` at run time).
+     *
+     * Callers MUST resolve any `vars` mapping for `id` **before** calling this,
+     * so an explicitly `vars`-mapped symbol is never folded — the GPU/JS live
+     * path relies on a mapped symbol staying a per-frame uniform / argument.
+     *
+     * `target` is the in-flight target: nested symbols inside the value resolve
+     * through the same `vars`/constant/fold rules as the top-level expression.
+     *
+     * The value is compiled at a high precedence so a compound (operator) value
+     * self-parenthesizes: folding `b = c + 1` into `b * x` must yield
+     * `(c + 1) * x`, not `c + 1 * x`, and must stay safe when a handler splices
+     * the folded string into its own expression (e.g. `Power`'s `(code * code)`).
+     * An atomic value (number, symbol, function call) ignores the precedence, so
+     * no redundant parentheses are added in the common assigned-number case.
+     */
+    static tryFoldKnownSymbol(engine, id, target) {
+      const value = engine._getSymbolValue(id);
+      if (value === void 0) return void 0;
+      return _BaseCompiler.compile(value, target, _BaseCompiler.FOLD_OPERAND_PREC);
+    }
+    /**
+     * Operator heads the compiler lowers directly in `compileExpr`, independent
+     * of any target operator/function mapping (control-flow, binding, and
+     * indexing-set forms). `analyzeReferences` never reports these as
+     * "unsupported".
+     */
+    static STRUCTURAL_HEADS = /* @__PURE__ */ new Set([
+      "Sequence",
+      "Sum",
+      "Product",
+      "Function",
+      "Declare",
+      "Assign",
+      "Return",
+      "Break",
+      "Continue",
+      "Loop",
+      "If",
+      "Which",
+      "When",
+      "Block",
+      // Indexing-set wrappers consumed by Sum/Product/Loop — never compiled
+      // standalone.
+      "Limits",
+      "Element"
+    ]);
+    /**
+     * Analyze — without compiling, and never throwing — which external references
+     * the generated code for `expr` would have on `target`:
+     *
+     * - `freeSymbols`: identifiers the caller must supply at run time. These are
+     *   the free symbols *as codegen sees them*: symbols with no value in the
+     *   engine, after descending into the values of folded (assigned / constant)
+     *   symbols — so `a = b + 1` surfaces `b`, which `expr.unknowns` misses — and
+     *   after excluding bound variables (lambda parameters, indices of
+     *   `Sum`/`Product`/`Integrate`/`Loop`, `Block` locals). A `vars`-mapped
+     *   symbol is always included: the mapping makes it an external input even
+     *   when it also has an assigned value.
+     *
+     * - `unsupported`: operator heads with no operator/function mapping in the
+     *   target and not one of the structural forms above.
+     *
+     * Lets a caller validate that a compiled result is self-contained
+     * (`freeSymbols` covered by its inputs, `unsupported` empty) declaratively,
+     * instead of executing or GPU-compiling the code to discover a dangling
+     * reference or an unlowerable operator.
+     */
+    static analyzeReferences(expr, target, varsKeys) {
+      const engine = expr.engine;
+      const free = /* @__PURE__ */ new Set();
+      const unsupported = /* @__PURE__ */ new Set();
+      const foldedSeen = /* @__PURE__ */ new Set();
+      const union = (a, more) => {
+        const s = new Set(a);
+        for (const m of more) s.add(m);
+        return s;
+      };
+      const visit = (e, bound) => {
+        if (isSymbol2(e)) {
+          const s = e.symbol;
+          if (bound.has(s)) return;
+          if (target.operators?.(s) !== void 0) return;
+          if (varsKeys?.has(s)) {
+            free.add(s);
+            return;
+          }
+          const value = engine._getSymbolValue(s);
+          if (value !== void 0) {
+            if (!foldedSeen.has(s)) {
+              foldedSeen.add(s);
+              visit(value, bound);
+            }
+            return;
+          }
+          free.add(s);
+          return;
+        }
+        if (!isFunction2(e)) return;
+        const h = e.operator;
+        const ops = e.ops;
+        if (h !== "Error" && !_BaseCompiler.STRUCTURAL_HEADS.has(h) && target.functions?.(h) === void 0 && target.operators?.(h) === void 0)
+          unsupported.add(h);
+        if (h === "Function") {
+          const params = ops.slice(1).filter((p) => isSymbol2(p)).map((p) => p.symbol);
+          visit(ops[0], params.length ? union(bound, params) : bound);
+          return;
+        }
+        if (h === "Sum" || h === "Product" || h === "Integrate" || h === "Loop") {
+          const indices = [];
+          const limitExprs = [];
+          for (const clause of ops.slice(1)) {
+            if (isFunction2(clause)) {
+              if (isSymbol2(clause.ops[0])) indices.push(clause.ops[0].symbol);
+              for (const sub2 of clause.ops.slice(1)) limitExprs.push(sub2);
+            } else {
+              limitExprs.push(clause);
+            }
+          }
+          visit(ops[0], indices.length ? union(bound, indices) : bound);
+          for (const le of limitExprs) visit(le, bound);
+          return;
+        }
+        if (h === "Block") {
+          const locals = [];
+          for (const stmt of ops)
+            if (isFunction2(stmt, "Declare") && isSymbol2(stmt.ops[0]))
+              locals.push(stmt.ops[0].symbol);
+          const inner = locals.length ? union(bound, locals) : bound;
+          for (const op of ops) visit(op, inner);
+          return;
+        }
+        for (const op of ops) visit(op, bound);
+      };
+      visit(expr, /* @__PURE__ */ new Set());
+      return { freeSymbols: [...free], unsupported: [...unsupported] };
+    }
+    /**
+     * Attach `freeSymbols` / `unsupported` (from `analyzeReferences`) to a
+     * compilation result, returning the same object. Used by the built-in
+     * targets to make every result carry its declarative reference analysis.
+     */
+    static withReferences(result, expr, target, varsKeys) {
+      return Object.assign(
+        result,
+        _BaseCompiler.analyzeReferences(expr, target, varsKeys)
+      );
+    }
     /**
      * Generate a temporary variable name
      */
@@ -17545,11 +17724,16 @@ ${lines.join("\n")}`;
     try {
       if (options?.target) {
         const code = BaseCompiler.compile(expr, options.target);
-        return {
-          target: options.target.language ?? "custom",
-          success: true,
-          code
-        };
+        return BaseCompiler.withReferences(
+          {
+            target: options.target.language ?? "custom",
+            success: true,
+            code
+          },
+          expr,
+          options.target,
+          options.vars ? new Set(Object.keys(options.vars)) : void 0
+        );
       }
       const targetName = options?.to ?? "javascript";
       const languageTarget = expr.engine.getCompilationTarget(targetName);
@@ -17568,11 +17752,26 @@ ${lines.join("\n")}`;
       });
     } catch (e) {
       if (options?.fallback ?? true) {
+        const error = e.message;
         console.warn(
-          `Compilation fallback for "${expr.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
+          `Compilation fallback for "${expr.operator}" (target: ${options?.to ?? "javascript"}): ${error}`
         );
         const ce = expr.engine;
         const target = options?.to ?? "javascript";
+        let refs = {
+          freeSymbols: [],
+          unsupported: []
+        };
+        try {
+          const compileTarget = options?.target ?? expr.engine.getCompilationTarget(target)?.createTarget();
+          if (compileTarget)
+            refs = BaseCompiler.analyzeReferences(
+              expr,
+              compileTarget,
+              options?.vars ? new Set(Object.keys(options.vars)) : void 0
+            );
+        } catch {
+        }
         if (isFunction2(expr, "Function")) {
           const lambdaRun = ((...args) => ce.function("Apply", [expr, ...args.map((a) => ce.expr(a))]).evaluate().re);
           return {
@@ -17580,7 +17779,9 @@ ${lines.join("\n")}`;
             success: false,
             code: "",
             calling: "lambda",
-            run: lambdaRun
+            run: lambdaRun,
+            error,
+            ...refs
           };
         }
         const fallbackRun = ((vars) => {
@@ -17599,7 +17800,9 @@ ${lines.join("\n")}`;
           success: false,
           code: "",
           calling: "expression",
-          run: fallbackRun
+          run: fallbackRun,
+          error,
+          ...refs
         };
       }
       throw e;
@@ -17608,6 +17811,10 @@ ${lines.join("\n")}`;
 
   // src/compute-engine/compilation/constant-folding.ts
   function formatFloat(n) {
+    if (!Number.isFinite(n))
+      throw new Error(
+        `Cannot compile the non-finite value \`${n}\` to a GPU shader: GLSL/WGSL have no infinity or NaN literals.`
+      );
     const str = n.toString();
     if (!str.includes(".") && !str.includes("e") && !str.includes("E")) {
       return `${str}.0`;
@@ -21897,6 +22104,442 @@ ${lines.join("\n")}`;
   function sinc(x) {
     return x === 0 ? 1 : Math.sin(x) / x;
   }
+  function erfi(x) {
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return 0;
+    if (!Number.isFinite(x)) return x > 0 ? Infinity : -Infinity;
+    const sign2 = x < 0 ? -1 : 1;
+    const ax = Math.abs(x);
+    const x2 = ax * ax;
+    let term = ax;
+    let sum = ax;
+    for (let n = 1; n < 1e3; n++) {
+      term *= x2 * (2 * n - 1) / (n * (2 * n + 1));
+      sum += term;
+      if (term < sum * 1e-18) break;
+    }
+    return sign2 * (2 / Math.sqrt(Math.PI)) * sum;
+  }
+  var EULER_GAMMA = 0.5772156649015329;
+  function cisi(x) {
+    const EPS = 1e-16;
+    const TMIN = 2;
+    const BIG = 1e30;
+    const t = Math.abs(x);
+    if (t === 0) return { si: 0, ci: -Infinity };
+    if (!Number.isFinite(t))
+      return { si: x > 0 ? Math.PI / 2 : -Math.PI / 2, ci: 0 };
+    let si;
+    let ci;
+    if (t > TMIN) {
+      let br = 1;
+      const bi = t;
+      let cr = BIG;
+      let cim = 0;
+      let denom = br * br + bi * bi;
+      let dr = br / denom;
+      let di = -bi / denom;
+      let hr = dr;
+      let hi = di;
+      for (let i = 1; i < 100; i++) {
+        const a = -i * i;
+        br += 2;
+        let tr = a * dr + br;
+        let ti = a * di + bi;
+        denom = tr * tr + ti * ti;
+        dr = tr / denom;
+        di = -ti / denom;
+        denom = cr * cr + cim * cim;
+        cr = br + a * cr / denom;
+        cim = bi - a * cim / denom;
+        const delr = cr * dr - cim * di;
+        const deli = cr * di + cim * dr;
+        tr = hr * delr - hi * deli;
+        ti = hr * deli + hi * delr;
+        hr = tr;
+        hi = ti;
+        if (Math.abs(delr - 1) + Math.abs(deli) <= EPS) break;
+      }
+      const ct = Math.cos(t);
+      const st = Math.sin(t);
+      const reH = ct * hr + st * hi;
+      const imH = ct * hi - st * hr;
+      ci = -reH;
+      si = Math.PI / 2 + imH;
+    } else {
+      let sum = 0;
+      let sums = 0;
+      let sumc = 0;
+      let sign2 = 1;
+      let fact = 1;
+      let odd = true;
+      for (let k = 1; k <= 100; k++) {
+        fact *= t / k;
+        const term = fact / k;
+        sum += sign2 * term;
+        const err = term / Math.abs(sum);
+        if (odd) {
+          sign2 = -sign2;
+          sums = sum;
+          sum = sumc;
+        } else {
+          sumc = sum;
+          sum = sums;
+        }
+        if (err < EPS) break;
+        odd = !odd;
+      }
+      si = sums;
+      ci = sumc + Math.log(t) + EULER_GAMMA;
+    }
+    if (x < 0) si = -si;
+    return { si, ci };
+  }
+  function sinIntegral(x) {
+    if (Number.isNaN(x)) return NaN;
+    return cisi(x).si;
+  }
+  function cosIntegral(x) {
+    if (Number.isNaN(x)) return NaN;
+    return cisi(x).ci;
+  }
+  function expInt1(x) {
+    const EPS = 1e-16;
+    const MAXIT = 200;
+    if (x <= 0) return NaN;
+    if (x <= 1) {
+      let sum = -Math.log(x) - EULER_GAMMA;
+      let fact = 1;
+      for (let n = 1; n <= MAXIT; n++) {
+        fact *= -x / n;
+        const del = -fact / n;
+        sum += del;
+        if (Math.abs(del) < Math.abs(sum) * EPS) break;
+      }
+      return sum;
+    }
+    const BIG = 1e30;
+    let b = x + 1;
+    let c = BIG;
+    let d = 1 / b;
+    let h = d;
+    for (let i = 1; i <= MAXIT; i++) {
+      const a = -i * i;
+      b += 2;
+      d = 1 / (a * d + b);
+      c = b + a / c;
+      const del = c * d;
+      h *= del;
+      if (Math.abs(del - 1) <= EPS) break;
+    }
+    return h * Math.exp(-x);
+  }
+  function expIntegralEi(x) {
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return -Infinity;
+    if (!Number.isFinite(x)) return x > 0 ? Infinity : 0;
+    if (x < 0) return -expInt1(-x);
+    const EPS = 1e-16;
+    const MAXIT = 200;
+    const SWITCH = -Math.log(EPS);
+    if (x <= SWITCH) {
+      let sum2 = 0;
+      let fact = 1;
+      for (let k = 1; k <= MAXIT; k++) {
+        fact *= x / k;
+        const term2 = fact / k;
+        sum2 += term2;
+        if (term2 < EPS * sum2) break;
+      }
+      return sum2 + Math.log(x) + EULER_GAMMA;
+    }
+    let sum = 0;
+    let term = 1;
+    for (let k = 1; k <= MAXIT; k++) {
+      const prev = term;
+      term *= k / x;
+      if (term < EPS) break;
+      if (term < prev) sum += term;
+      else {
+        sum -= prev;
+        break;
+      }
+    }
+    return Math.exp(x) * (1 + sum) / x;
+  }
+  function logIntegral(x) {
+    if (Number.isNaN(x)) return NaN;
+    if (x === 0) return 0;
+    if (x === 1) return -Infinity;
+    if (x < 0) return NaN;
+    return expIntegralEi(Math.log(x));
+  }
+  function agm(a, b) {
+    if (Number.isNaN(a) || Number.isNaN(b)) return NaN;
+    if (a < 0 || b < 0) return NaN;
+    if (a === 0 || b === 0) return 0;
+    if (!isFinite(a) || !isFinite(b)) return Infinity;
+    for (let i = 0; i < 64 && Math.abs(a - b) > 1e-17 * Math.abs(a); i++) {
+      const an = 0.5 * (a + b);
+      b = Math.sqrt(a * b);
+      a = an;
+    }
+    return 0.5 * (a + b);
+  }
+  function ellipticK(m) {
+    if (Number.isNaN(m)) return NaN;
+    if (m === 1) return Infinity;
+    if (m > 1) return NaN;
+    return Math.PI / (2 * agm(1, Math.sqrt(1 - m)));
+  }
+  function ellipticE(m) {
+    if (Number.isNaN(m)) return NaN;
+    if (m === 1) return 1;
+    if (m > 1) return NaN;
+    let a = 1;
+    let b = Math.sqrt(1 - m);
+    let sum = 0.5 * m;
+    let pow2 = 0.5;
+    for (let i = 0; i < 64 && Math.abs(a - b) > 1e-17 * a; i++) {
+      const c = 0.5 * (a - b);
+      const an = 0.5 * (a + b);
+      b = Math.sqrt(a * b);
+      a = an;
+      pow2 *= 2;
+      sum += pow2 * c * c;
+    }
+    const K = Math.PI / (2 * a);
+    return K * (1 - sum);
+  }
+  var CARLSON_TOL = 1e-24;
+  function carlsonRC(x, y) {
+    if (Number.isNaN(x) || Number.isNaN(y) || x < 0) return NaN;
+    if (y === 0) return Infinity;
+    if (x === 0) return Math.PI / (2 * Math.sqrt(y));
+    if (y < 0) return Math.sqrt(x / (x - y)) * carlsonRC(x - y, -y);
+    if (x === y) return 1 / Math.sqrt(x);
+    const e = (y - x) / x;
+    if (Math.abs(e) < 0.01) {
+      let sum = 0;
+      let term = 1;
+      for (let k = 0; k < 10; k++) {
+        sum += term / (2 * k + 1);
+        term *= -e;
+      }
+      return sum / Math.sqrt(x);
+    }
+    const a = Math.sqrt(x / y);
+    return x < y ? Math.acos(a) / Math.sqrt(y - x) : Math.acosh(a) / Math.sqrt(x - y);
+  }
+  function carlsonRF(x, y, z) {
+    if (Number.isNaN(x) || Number.isNaN(y) || Number.isNaN(z)) return NaN;
+    if (x < 0 || y < 0 || z < 0) return NaN;
+    if ((x === 0 ? 1 : 0) + (y === 0 ? 1 : 0) + (z === 0 ? 1 : 0) > 1)
+      return Infinity;
+    if (y === z) return carlsonRC(x, y);
+    if (x === z) return carlsonRC(y, x);
+    if (x === y) return carlsonRC(z, x);
+    const A0 = (x + y + z) / 3;
+    const Q = Math.pow(3 * CARLSON_TOL, -1 / 6) * Math.max(Math.abs(A0 - x), Math.abs(A0 - y), Math.abs(A0 - z));
+    let [xm, ym, zm] = [x, y, z];
+    let A = A0;
+    let pow4 = 1;
+    for (let i = 0; i < 64 && pow4 * Q >= Math.abs(A); i++) {
+      const sx = Math.sqrt(xm);
+      const sy = Math.sqrt(ym);
+      const sz = Math.sqrt(zm);
+      const lm = sx * sy + sx * sz + sy * sz;
+      A = (A + lm) / 4;
+      xm = (xm + lm) / 4;
+      ym = (ym + lm) / 4;
+      zm = (zm + lm) / 4;
+      pow4 /= 4;
+    }
+    const t = pow4 / A;
+    const Xc = (A0 - x) * t;
+    const Yc = (A0 - y) * t;
+    const Zc = -Xc - Yc;
+    const E2 = Xc * Yc - Zc * Zc;
+    const E3 = Xc * Yc * Zc;
+    return Math.pow(A, -0.5) * (9240 - 924 * E2 + 385 * E2 * E2 + 660 * E3 - 630 * E2 * E3) / 9240;
+  }
+  function carlsonRJ(x, y, z, p) {
+    if (Number.isNaN(x) || Number.isNaN(y) || Number.isNaN(z) || Number.isNaN(p))
+      return NaN;
+    if (x < 0 || y < 0 || z < 0) return NaN;
+    if (p === 0) return Infinity;
+    if ((x === 0 ? 1 : 0) + (y === 0 ? 1 : 0) + (z === 0 ? 1 : 0) > 1)
+      return Infinity;
+    if (p < 0) {
+      const [a, b, c] = [x, y, z].sort((u, v2) => u - v2);
+      const q = -p;
+      const pn = (c * (a + b + q) - a * b) / (c + q);
+      let v = (pn - c) * carlsonRJ(a, b, c, pn);
+      v -= 3 * carlsonRF(a, b, c);
+      v += 3 * Math.sqrt(a * b * c / (a * b + pn * q)) * carlsonRC(a * b + pn * q, pn * q);
+      return v / (c + q);
+    }
+    const A0 = (x + y + z + 2 * p) / 5;
+    const delta = (p - x) * (p - y) * (p - z);
+    const Q = Math.pow(0.25 * CARLSON_TOL, -1 / 6) * Math.max(
+      Math.abs(A0 - x),
+      Math.abs(A0 - y),
+      Math.abs(A0 - z),
+      Math.abs(A0 - p)
+    );
+    let [xm, ym, zm, pm] = [x, y, z, p];
+    let A = A0;
+    let pow4 = 1;
+    let S = 0;
+    for (let i = 0; i < 64; i++) {
+      const sx = Math.sqrt(xm);
+      const sy = Math.sqrt(ym);
+      const sz = Math.sqrt(zm);
+      const sp = Math.sqrt(pm);
+      const lm = sx * sy + sx * sz + sy * sz;
+      const A1 = (A + lm) / 4;
+      xm = (xm + lm) / 4;
+      ym = (ym + lm) / 4;
+      zm = (zm + lm) / 4;
+      pm = (pm + lm) / 4;
+      const dm = (sp + sx) * (sp + sy) * (sp + sz);
+      const em = delta * pow4 * pow4 * pow4 / (dm * dm);
+      if (pow4 * Q < Math.abs(A)) break;
+      S += carlsonRC(1, 1 + em) * pow4 / dm;
+      pow4 /= 4;
+      A = A1;
+    }
+    const t = pow4 / A;
+    const X = (A0 - x) * t;
+    const Y = (A0 - y) * t;
+    const Z = (A0 - z) * t;
+    const P = (-X - Y - Z) / 2;
+    const E2 = X * Y + X * Z + Y * Z - 3 * P * P;
+    const E3 = X * Y * Z + 2 * E2 * P + 4 * P * P * P;
+    const E4 = (2 * X * Y * Z + E2 * P + 3 * P * P * P) * P;
+    const E5 = X * Y * Z * P * P;
+    const series = (24024 - 5148 * E2 + 2457 * E2 * E2 + 4004 * E3 - 4158 * E2 * E3 - 3276 * E4 + 2772 * E5) / 24024;
+    return pow4 * Math.pow(A, -1.5) * series + 6 * S;
+  }
+  function carlsonRD(x, y, z) {
+    return carlsonRJ(x, y, z, z);
+  }
+  function ellipticF(phi, m) {
+    if (Number.isNaN(phi) || Number.isNaN(m)) return NaN;
+    if (Math.abs(phi) > Math.PI / 2) {
+      const k = Math.round(phi / Math.PI);
+      const K = ellipticK(m);
+      if (!Number.isFinite(K)) return NaN;
+      return 2 * k * K + ellipticF(phi - k * Math.PI, m);
+    }
+    const s = Math.sin(phi);
+    const y = 1 - m * s * s;
+    if (y < 0) return NaN;
+    const c = Math.cos(phi);
+    return s * carlsonRF(c * c, y, 1);
+  }
+  function ellipticEIncomplete(phi, m) {
+    if (Number.isNaN(phi) || Number.isNaN(m)) return NaN;
+    if (Math.abs(phi) > Math.PI / 2) {
+      const k = Math.round(phi / Math.PI);
+      const E = ellipticE(m);
+      if (!Number.isFinite(E)) return NaN;
+      return 2 * k * E + ellipticEIncomplete(phi - k * Math.PI, m);
+    }
+    const s = Math.sin(phi);
+    const y = 1 - m * s * s;
+    if (y < 0) return NaN;
+    const c = Math.cos(phi);
+    const s3 = s * s * s;
+    return s * carlsonRF(c * c, y, 1) - m / 3 * s3 * carlsonRD(c * c, y, 1);
+  }
+  function ellipticPiComplete(n, m) {
+    if (Number.isNaN(n) || Number.isNaN(m)) return NaN;
+    if (n === 1 || m === 1) return Infinity;
+    if (m > 1) return NaN;
+    return carlsonRF(0, 1 - m, 1) + n / 3 * carlsonRJ(0, 1 - m, 1, 1 - n);
+  }
+  function ellipticPiIncomplete(n, phi, m) {
+    if (Number.isNaN(n) || Number.isNaN(phi) || Number.isNaN(m)) return NaN;
+    if (Math.abs(phi) > Math.PI / 2) {
+      const k = Math.round(phi / Math.PI);
+      const P = ellipticPiComplete(n, m);
+      if (!Number.isFinite(P)) return NaN;
+      return 2 * k * P + ellipticPiIncomplete(n, phi - k * Math.PI, m);
+    }
+    const s = Math.sin(phi);
+    const y = 1 - m * s * s;
+    if (y < 0) return NaN;
+    const c = Math.cos(phi);
+    const s3 = s * s * s;
+    const p = 1 - n * s * s;
+    if (p === 0) return Infinity;
+    return s * carlsonRF(c * c, y, 1) + n / 3 * s3 * carlsonRJ(c * c, y, 1, p);
+  }
+  function isNonPositiveInteger(x) {
+    return Number.isInteger(x) && x <= 0;
+  }
+  function gauss2F1Series(a, b, c, z, maxTerms = 1e4) {
+    let term = 1;
+    let sum = 1;
+    for (let n = 0; n < maxTerms; n++) {
+      term *= (a + n) * (b + n) * z / ((c + n) * (n + 1));
+      if (term === 0) return sum;
+      sum += term;
+      if (n > 2 && Math.abs(term) <= Number.EPSILON * Math.abs(sum)) return sum;
+    }
+    return sum;
+  }
+  function hypergeometric2F1(a, b, c, z) {
+    if ([a, b, c, z].some(Number.isNaN)) return NaN;
+    const aTerm = isNonPositiveInteger(a) ? -a : Infinity;
+    const bTerm = isNonPositiveInteger(b) ? -b : Infinity;
+    const nTerms = Math.min(aTerm, bTerm);
+    if (isNonPositiveInteger(c)) {
+      if (nTerms === Infinity || nTerms > -c) return NaN;
+    }
+    if (nTerms !== Infinity) return gauss2F1Series(a, b, c, z, nTerms + 1);
+    if (z === 0) return 1;
+    if (z === 1) {
+      const s2 = c - a - b;
+      if (s2 <= 0) return s2 === 0 ? Infinity : NaN;
+      return gamma(c) * gamma(s2) / (gamma(c - a) * gamma(c - b));
+    }
+    if (z > 1) return NaN;
+    if (z < 0) {
+      return Math.pow(1 - z, -a) * hypergeometric2F1(a, c - b, c, z / (z - 1));
+    }
+    if (z <= 0.5) return gauss2F1Series(a, b, c, z);
+    const s = c - a - b;
+    if (Number.isInteger(s)) {
+      if (z <= 0.95) return gauss2F1Series(a, b, c, z, 1e6);
+      return NaN;
+    }
+    const t1 = gamma(c) * gamma(s) / (gamma(c - a) * gamma(c - b)) * gauss2F1Series(a, b, 1 - s, 1 - z);
+    const t2 = gamma(c) * gamma(-s) / (gamma(a) * gamma(b)) * Math.pow(1 - z, s) * gauss2F1Series(c - a, c - b, 1 + s, 1 - z);
+    return t1 + t2;
+  }
+  function kummer1F1Series(a, b, z, maxTerms = 2e4) {
+    let term = 1;
+    let sum = 1;
+    for (let n = 0; n < maxTerms; n++) {
+      term *= (a + n) * z / ((b + n) * (n + 1));
+      if (term === 0) return sum;
+      sum += term;
+      if (n > 2 && Math.abs(term) <= Number.EPSILON * Math.abs(sum)) return sum;
+    }
+    return sum;
+  }
+  function hypergeometric1F1(a, b, z) {
+    if ([a, b, z].some(Number.isNaN)) return NaN;
+    const aTerm = isNonPositiveInteger(a) ? -a : Infinity;
+    if (isNonPositiveInteger(b)) {
+      if (aTerm === Infinity || aTerm > -b) return NaN;
+    }
+    if (aTerm !== Infinity) return kummer1F1Series(a, b, z, aTerm + 1);
+    if (z < 0) return Math.exp(z) * hypergeometric1F1(b - a, b, -z);
+    return kummer1F1Series(a, b, z);
+  }
 
   // src/compute-engine/boxed-expression/expand.ts
   var binomials = [
@@ -22616,6 +23259,7 @@ ${lines.join("\n")}`;
     Erf: "_SYS.erf",
     Erfc: "_SYS.erfc",
     ErfInv: "_SYS.erfInv",
+    Erfi: "_SYS.erfi",
     // Special functions
     Beta: "_SYS.beta",
     Digamma: "_SYS.digamma",
@@ -22631,6 +23275,30 @@ ${lines.join("\n")}`;
     // Airy functions
     AiryAi: "_SYS.airyAi",
     AiryBi: "_SYS.airyBi",
+    // Exponential / trigonometric / logarithmic integrals. These are the closed
+    // forms the antiderivative engine emits (e.g. ∫sin x/x dx = SinIntegral(x)),
+    // so an "evaluate then compile" pipeline must be able to lower them.
+    SinIntegral: "_SYS.sinIntegral",
+    CosIntegral: "_SYS.cosIntegral",
+    ExpIntegralEi: "_SYS.expIntegralEi",
+    LogIntegral: "_SYS.logIntegral",
+    // Arithmetic-geometric mean and elliptic integrals (parameter convention
+    // m = k², as in the library). `AGM`, `EllipticE`, and `EllipticPi` are
+    // arity-overloaded — the handlers mirror the library's evaluate dispatch.
+    AGM: (args, compile2) => args.length === 1 ? `_SYS.agm(1, ${compile2(args[0])})` : `_SYS.agm(${compile2(args[0])}, ${compile2(args[1])})`,
+    EllipticK: "_SYS.ellipticK",
+    EllipticE: (args, compile2) => args.length === 2 ? `_SYS.ellipticEIncomplete(${compile2(args[0])}, ${compile2(args[1])})` : `_SYS.ellipticE(${compile2(args[0])})`,
+    EllipticF: (args, compile2) => `_SYS.ellipticF(${compile2(args[0])}, ${compile2(args[1])})`,
+    EllipticPi: (args, compile2) => args.length === 3 ? `_SYS.ellipticPiIncomplete(${compile2(args[0])}, ${compile2(
+      args[1]
+    )}, ${compile2(args[2])})` : `_SYS.ellipticPiComplete(${compile2(args[0])}, ${compile2(args[1])})`,
+    // Hypergeometric functions.
+    Hypergeometric2F1: (args, compile2) => `_SYS.hypergeometric2F1(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(
+      args[2]
+    )}, ${compile2(args[3])})`,
+    Hypergeometric1F1: (args, compile2) => `_SYS.hypergeometric1F1(${compile2(args[0])}, ${compile2(args[1])}, ${compile2(
+      args[2]
+    )})`,
     // Combinatorics
     Mandelbrot: ([c, maxIter], compile2) => {
       if (c === null || maxIter === null)
@@ -22643,6 +23311,8 @@ ${lines.join("\n")}`;
       return `_SYS.julia(${compile2(z)}, ${compile2(c)}, ${compile2(maxIter)})`;
     },
     Binomial: (args, compile2) => `_SYS.binomial(${compile2(args[0])}, ${compile2(args[1])})`,
+    // Choose(n, k) is the binomial coefficient — same runtime helper.
+    Choose: (args, compile2) => `_SYS.binomial(${compile2(args[0])}, ${compile2(args[1])})`,
     Fibonacci: "_SYS.fibonacci",
     // Complex-specific functions
     Real: (args, compile2) => {
@@ -23148,6 +23818,20 @@ ${lines.join("\n")}`;
     sinc,
     fresnelS,
     fresnelC,
+    sinIntegral,
+    cosIntegral,
+    expIntegralEi,
+    logIntegral,
+    erfi,
+    agm,
+    ellipticK,
+    ellipticE,
+    ellipticEIncomplete,
+    ellipticF,
+    ellipticPiComplete,
+    ellipticPiIncomplete,
+    hypergeometric2F1,
+    hypergeometric1F1,
     mandelbrot: (c, maxIter) => {
       let zx = 0, zy = 0;
       const cx = typeof c === "number" ? c : c.re;
@@ -23334,7 +24018,7 @@ ${lines.join("\n")}`;
         functions: (id) => namedFunctions?.[id] ? namedFunctions[id] : JAVASCRIPT_FUNCTIONS[id],
         var: (id) => {
           if (vars && id in vars) return JSON.stringify(vars[id]);
-          const result = {
+          const result2 = {
             Pi: "Math.PI",
             ExponentialE: "Math.E",
             NaN: "Number.NaN",
@@ -23345,13 +24029,20 @@ ${lines.join("\n")}`;
             CatalanConstant: "0.91596559417721901",
             EulerGamma: "0.57721566490153286"
           }[id];
-          if (result !== void 0) return result;
+          if (result2 !== void 0) return result2;
           if (unknowns.includes(id)) return `_.${id}`;
-          return void 0;
+          if (expr.engine._getSymbolValue(id) !== void 0) return void 0;
+          return `_.${id}`;
         },
         preamble: (preamble ?? "") + preambleImports
       });
-      return compileToTarget(expr, target, realOnly);
+      const result = compileToTarget(expr, target, realOnly);
+      return BaseCompiler.withReferences(
+        result,
+        expr,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
   };
   function wrapRealOnly(result) {
@@ -25922,6 +26613,10 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
     EulerGamma: "0.57721566490"
   };
   function formatGPUNumber(n) {
+    if (!Number.isFinite(n))
+      throw new Error(
+        `Cannot compile the non-finite value \`${n}\` to a GPU shader: GLSL/WGSL have no infinity or NaN literals.`
+      );
     const str = n.toString();
     if (!str.includes(".") && !str.includes("e") && !str.includes("E")) {
       return `${str}.0`;
@@ -25949,7 +26644,7 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
         var: (id) => {
           if (id === "ImaginaryUnit") return `${v2}(0.0, 1.0)`;
           if (id in constants) return constants[id];
-          return id;
+          return void 0;
         },
         string: (str) => JSON.stringify(str),
         number: formatGPUNumber,
@@ -25988,7 +26683,7 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
           if (vars && id in vars) return vars[id];
           if (id === "ImaginaryUnit") return `${v2}(0.0, 1.0)`;
           if (id in constants) return constants[id];
-          return id;
+          return void 0;
         }
       });
       const code = BaseCompiler.compile(expr, target);
@@ -26028,7 +26723,12 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
         preamble += this.languageId === "wgsl" ? GPU_COLOR_PREAMBLE_WGSL : GPU_COLOR_PREAMBLE_GLSL;
       }
       if (preamble) result.preamble = preamble;
-      return result;
+      return BaseCompiler.withReferences(
+        result,
+        expr,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
     compileToSource(expr, _options = {}) {
       const target = this.createTarget();
@@ -26061,6 +26761,8 @@ fn _gpu_apca(lch_bg: vec3f, lch_fg: vec3f) -> f32 {
     Tuple: compileGLSLList
   };
   var GLSLTarget = class extends GPUShaderTarget {
+    // Annotated `string` (not the literal `'glsl'`) so subclasses such as
+    // `IntervalGLSLTarget` can override it while reusing the GLSL shader assembly.
     languageId = "glsl";
     getLanguageSpecificFunctions() {
       return GLSL_FUNCTIONS;
@@ -26581,7 +27283,17 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
      */
     compile(expr, options = {}) {
       const code = this.compileToSource(expr, options);
-      return { target: "python", success: true, code };
+      const result = {
+        target: "python",
+        success: true,
+        code
+      };
+      return BaseCompiler.withReferences(
+        result,
+        expr,
+        this.createTarget(),
+        options.vars ? new Set(Object.keys(options.vars)) : void 0
+      );
     }
     /**
      * Compile an expression to Python source code
@@ -28438,11 +29150,18 @@ ${code}`;
           };
           if (id in constants) return constants[id];
           if (unknowns.includes(id)) return `_.${id}`;
-          return void 0;
+          if (expr.engine._getSymbolValue(id) !== void 0) return void 0;
+          return `_.${id}`;
         },
         preamble: (preamble ?? "") + preambleImports
       });
-      return compileToIntervalTarget(expr, target);
+      const result = compileToIntervalTarget(expr, target);
+      return BaseCompiler.withReferences(
+        result,
+        expr,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
   };
   function compileToIntervalTarget(expr, target) {
@@ -28466,8 +29185,534 @@ ${code}`;
     };
   }
 
+  // src/compute-engine/compilation/interval-glsl-target.ts
+  var IV_INF = "1e18";
+  var INTERVAL_GLSL_PREAMBLE = `
+const float IV_INF = ${IV_INF};
+const vec2 IV_ENTIRE = vec2(-IV_INF, IV_INF);
+const vec2 IV_EMPTY = vec2(IV_INF, -IV_INF);
+
+bool _iv_is_empty(vec2 a) { return a.x > a.y; }
+
+// Clamp bounds to the finite sentinel range. Preserves IV_EMPTY (its components
+// already sit at the sentinels) and folds any overflowed intermediate back to
+// the sentinel (min(inf, IV_INF) = IV_INF), so a real \`inf\` never escapes an op.
+vec2 _iv_clamp(vec2 a) { return clamp(a, -IV_INF, IV_INF); }
+
+// Exact empty propagation: force empty if any operand is empty.
+vec2 _iv_guard1(vec2 r, vec2 a) { return _iv_is_empty(a) ? IV_EMPTY : r; }
+vec2 _iv_guard2(vec2 r, vec2 a, vec2 b) {
+  return (_iv_is_empty(a) || _iv_is_empty(b)) ? IV_EMPTY : r;
+}
+
+vec2 _iv_negate(vec2 a) { return _iv_guard1(_iv_clamp(vec2(-a.y, -a.x)), a); }
+
+vec2 _iv_add(vec2 a, vec2 b) {
+  return _iv_guard2(_iv_clamp(vec2(a.x + b.x, a.y + b.y)), a, b);
+}
+
+vec2 _iv_sub(vec2 a, vec2 b) {
+  return _iv_guard2(_iv_clamp(vec2(a.x - b.y, a.y - b.x)), a, b);
+}
+
+vec2 _iv_mul(vec2 a, vec2 b) {
+  float p1 = a.x * b.x, p2 = a.x * b.y, p3 = a.y * b.x, p4 = a.y * b.y;
+  vec2 r = vec2(min(min(p1, p2), min(p3, p4)), max(max(p1, p2), max(p3, p4)));
+  return _iv_guard2(_iv_clamp(r), a, b);
+}
+
+vec2 _iv_div(vec2 a, vec2 b) {
+  // Denominator spanning 0 \u2192 entire (wide, never narrow): the CPU pass turns
+  // the pole into a proper asymptote break.
+  bool spansZero = (b.x <= 0.0 && b.y >= 0.0);
+  float q1 = a.x / b.x, q2 = a.x / b.y, q3 = a.y / b.x, q4 = a.y / b.y;
+  vec2 r = vec2(min(min(q1, q2), min(q3, q4)), max(max(q1, q2), max(q3, q4)));
+  r = spansZero ? IV_ENTIRE : r;
+  return _iv_guard2(_iv_clamp(r), a, b);
+}
+
+vec2 _iv_square(vec2 a) {
+  float lo2 = a.x * a.x, hi2 = a.y * a.y;
+  // Straddles 0 \u21D2 min is 0; otherwise the smaller endpoint\xB2 is the min.
+  float lo = (a.x <= 0.0 && a.y >= 0.0) ? 0.0 : min(lo2, hi2);
+  return _iv_guard1(_iv_clamp(vec2(lo, max(lo2, hi2))), a);
+}
+
+// Scalar integer power that is correct for negative bases (GLSL \`pow\` requires
+// a non-negative base): keep the sign for odd exponents, drop it for even.
+float _iv_powi_scalar(float x, float n) {
+  float a = pow(abs(x), n);
+  return (mod(n, 2.0) == 1.0 && x < 0.0) ? -a : a;
+}
+
+vec2 _iv_powi(vec2 a, float n) {
+  float pl = _iv_powi_scalar(a.x, n);
+  float ph = _iv_powi_scalar(a.y, n);
+  bool even = (mod(n, 2.0) == 0.0);
+  bool straddle = (a.x <= 0.0 && a.y >= 0.0);
+  float lo = even ? (straddle ? 0.0 : min(pl, ph)) : pl;
+  float hi = even ? max(pl, ph) : ph;
+  return _iv_guard1(_iv_clamp(vec2(lo, hi)), a);
+}
+
+// \u2500\u2500 Phase 2: elementary functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+vec2 _iv_abs(vec2 a) {
+  float al = abs(a.x), ah = abs(a.y);
+  bool straddle = (a.x <= 0.0 && a.y >= 0.0);
+  return _iv_guard1(_iv_clamp(vec2(straddle ? 0.0 : min(al, ah), max(al, ah))), a);
+}
+
+// Domain x \u2265 0: fully-negative box \u2192 empty; a box straddling 0 clamps lo to 0.
+vec2 _iv_sqrt(vec2 a) {
+  vec2 r = vec2(sqrt(max(a.x, 0.0)), sqrt(max(a.y, 0.0)));
+  r = (a.y < 0.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_exp(vec2 a) {
+  return _iv_guard1(_iv_clamp(vec2(exp(a.x), exp(a.y))), a);
+}
+
+// Domain x > 0: fully-\u22640 box \u2192 empty; straddling box \u2192 lo clamped to \u2212IV_INF
+// (ln \u2192 \u2212\u221E as x \u2192 0\u207A, never a real \u2212inf).
+vec2 _iv_ln(vec2 a) {
+  vec2 r = vec2(a.x > 0.0 ? log(a.x) : -IV_INF, log(a.y));
+  r = (a.y <= 0.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+const float _IV_INV_LN10 = 0.43429448190325176;
+const float _IV_INV_LN2 = 1.4426950408889634;
+
+vec2 _iv_log10(vec2 a) {
+  vec2 r = vec2(a.x > 0.0 ? log(a.x) * _IV_INV_LN10 : -IV_INF, log(a.y) * _IV_INV_LN10);
+  r = (a.y <= 0.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_log2(vec2 a) {
+  vec2 r = vec2(a.x > 0.0 ? log(a.x) * _IV_INV_LN2 : -IV_INF, log(a.y) * _IV_INV_LN2);
+  r = (a.y <= 0.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+// Non-integer power. Real only for base \u2265 0: fully-negative box \u2192 empty; a box
+// straddling 0 clamps the base low end to 0. \`p\` is a compile-time constant, so
+// the \`p >= 0\` test is a constant branch.
+vec2 _iv_powf(vec2 a, float p) {
+  float lob = max(a.x, 0.0);
+  float e0 = pow(lob, p), e1 = pow(a.y, p);
+  vec2 r = (p >= 0.0) ? vec2(e0, e1) : vec2(e1, e0);
+  r = (a.y < 0.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+// \u2500\u2500 Phase 3: trigonometric & inverse-trigonometric functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// Mirrors interval-js (interval/trigonometric.ts): exact endpoints with
+// extremum snapping (no outward epsilon). Per the Option-A contract, a tan pole
+// yields \`entire\` (interval-js returns \`singular\`; entire \u2287 singular and the
+// CPU classifies the asymptote).
+
+const float _IV_PI = 3.141592653589793;
+const float _IV_TWO_PI = 6.283185307179586;
+const float _IV_HALF_PI = 1.5707963267948966;
+const float _IV_THREE_HALF_PI = 4.71238898038469;
+
+// True if [a] contains an extremum of the family { ext + n\xB7period }.
+bool _iv_has_ext(vec2 a, float ext, float period) {
+  float n = ceil((a.x - ext) / period);
+  float cand = ext + n * period;
+  return cand >= a.x - 1e-15 && cand <= a.y + 1e-15;
+}
+
+vec2 _iv_sin(vec2 a) {
+  vec2 r;
+  if (a.y - a.x >= _IV_TWO_PI) r = vec2(-1.0, 1.0);
+  else {
+    float sl = sin(a.x), sh = sin(a.y);
+    float lo = min(sl, sh), hi = max(sl, sh);
+    if (_iv_has_ext(a, _IV_HALF_PI, _IV_TWO_PI)) hi = 1.0;
+    if (_iv_has_ext(a, _IV_THREE_HALF_PI, _IV_TWO_PI)) lo = -1.0;
+    r = vec2(lo, hi);
+  }
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_cos(vec2 a) {
+  vec2 r;
+  if (a.y - a.x >= _IV_TWO_PI) r = vec2(-1.0, 1.0);
+  else {
+    float cl = cos(a.x), ch = cos(a.y);
+    float lo = min(cl, ch), hi = max(cl, ch);
+    if (_iv_has_ext(a, 0.0, _IV_TWO_PI)) hi = 1.0;
+    if (_iv_has_ext(a, _IV_PI, _IV_TWO_PI)) lo = -1.0;
+    r = vec2(lo, hi);
+  }
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_tan(vec2 a) {
+  // A pole in the interval \u2192 entire (cannot exclude).
+  bool pole =
+    (a.y - a.x >= _IV_PI) || _iv_has_ext(a, _IV_HALF_PI, _IV_PI);
+  float tl = tan(a.x), th = tan(a.y);
+  // Floating-point branch-cross sanity (large opposite-sign endpoints).
+  bool crossed = (tl > 1e10 && th < -1e10) || (tl < -1e10 && th > 1e10);
+  vec2 r = (pole || crossed) ? IV_ENTIRE : vec2(tl, th);
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+// asin: domain [\u22121, 1]. Fully outside \u2192 empty; straddling clamps to the valid
+// sub-range. Monotonic increasing.
+vec2 _iv_asin(vec2 a) {
+  vec2 r = vec2(asin(max(a.x, -1.0)), asin(min(a.y, 1.0)));
+  r = (a.x > 1.0 || a.y < -1.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+// acos: domain [\u22121, 1], monotonic decreasing (bounds swap).
+vec2 _iv_acos(vec2 a) {
+  vec2 r = vec2(acos(min(a.y, 1.0)), acos(max(a.x, -1.0)));
+  r = (a.x > 1.0 || a.y < -1.0) ? IV_EMPTY : r;
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_atan(vec2 a) {
+  return _iv_guard1(_iv_clamp(vec2(atan(a.x), atan(a.y))), a);
+}
+
+// \u2500\u2500 Discontinuous / step functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+// Bounded jump-discontinuity functions return the TIGHT value-range enclosure
+// (sound, and excludable when the range misses 0) rather than \`entire\` \u2014 only
+// genuine poles are entire. Per the Option-A division of labor, the CPU still
+// classifies the discontinuity on the (kept) live cells; the GPU only needs a
+// sound bound for the exclusion test. These functions are monotone, so the
+// enclosure is just [f(lo), f(hi)] unless noted.
+
+vec2 _iv_floor(vec2 a) { return _iv_guard1(_iv_clamp(vec2(floor(a.x), floor(a.y))), a); }
+vec2 _iv_ceil(vec2 a) { return _iv_guard1(_iv_clamp(vec2(ceil(a.x), ceil(a.y))), a); }
+vec2 _iv_round(vec2 a) { return _iv_guard1(_iv_clamp(vec2(floor(a.x + 0.5), floor(a.y + 0.5))), a); }
+vec2 _iv_trunc(vec2 a) { return _iv_guard1(_iv_clamp(vec2(trunc(a.x), trunc(a.y))), a); }
+vec2 _iv_sign(vec2 a) { return _iv_guard1(vec2(sign(a.x), sign(a.y)), a); }
+
+vec2 _iv_heaviside(vec2 a) {
+  float hl = a.x < 0.0 ? 0.0 : (a.x > 0.0 ? 1.0 : 0.5);
+  float hh = a.y < 0.0 ? 0.0 : (a.y > 0.0 ? 1.0 : 0.5);
+  return _iv_guard1(vec2(hl, hh), a);
+}
+
+// fract(x) = x \u2212 floor(x): continuous within an integer cell, sawtooth across
+// one (\u2192 full [0, 1] range).
+vec2 _iv_fract(vec2 a) {
+  float fl = floor(a.x);
+  vec2 r = (fl == floor(a.y)) ? vec2(a.x - fl, a.y - fl) : vec2(0.0, 1.0);
+  return _iv_guard1(_iv_clamp(r), a);
+}
+
+vec2 _iv_min(vec2 a, vec2 b) {
+  return _iv_guard2(_iv_clamp(vec2(min(a.x, b.x), min(a.y, b.y))), a, b);
+}
+vec2 _iv_max(vec2 a, vec2 b) {
+  return _iv_guard2(_iv_clamp(vec2(max(a.x, b.x), max(a.y, b.y))), a, b);
+}
+
+// mod(x, y) = x \u2212 y\xB7floor(x/y). A modulus straddling 0 is a pole \u2192 entire. For
+// a constant (point) modulus the fast path is exact; otherwise compose (the
+// tight floor keeps it sound).
+vec2 _iv_mod(vec2 a, vec2 b) {
+  if (b.x <= 0.0 && b.y >= 0.0) return _iv_guard2(IV_ENTIRE, a, b);
+  if (b.x == b.y) {
+    float p = abs(b.x);
+    float flo = floor(a.x / p);
+    vec2 r = (flo == floor(a.y / p)) ? vec2(a.x - p * flo, a.y - p * flo)
+                                     : vec2(0.0, p);
+    return _iv_guard2(_iv_clamp(r), a, b);
+  }
+  return _iv_sub(a, _iv_mul(b, _iv_floor(_iv_div(a, b))));
+}
+`;
+  var INTERVAL_GLSL_FUNCTIONS = {
+    Add: (args, compile2) => {
+      if (args.length === 0) return "vec2(0.0, 0.0)";
+      let r = compile2(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_add(${r}, ${compile2(args[i])})`;
+      return r;
+    },
+    Subtract: ([a, b], compile2) => {
+      if (a === null || b === null) throw new Error("Subtract: missing argument");
+      return `_iv_sub(${compile2(a)}, ${compile2(b)})`;
+    },
+    Multiply: (args, compile2) => {
+      if (args.length === 0) return "vec2(1.0, 1.0)";
+      let r = compile2(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_mul(${r}, ${compile2(args[i])})`;
+      return r;
+    },
+    Divide: ([a, b], compile2) => {
+      if (a === null || b === null) throw new Error("Divide: missing argument");
+      return `_iv_div(${compile2(a)}, ${compile2(b)})`;
+    },
+    Negate: ([a], compile2) => {
+      if (a === null) throw new Error("Negate: no argument");
+      return `_iv_negate(${compile2(a)})`;
+    },
+    Square: ([a], compile2) => {
+      if (a === null) throw new Error("Square: no argument");
+      return `_iv_square(${compile2(a)})`;
+    },
+    Sqrt: ([a], compile2) => {
+      if (a === null) throw new Error("Sqrt: no argument");
+      return `_iv_sqrt(${compile2(a)})`;
+    },
+    Abs: ([a], compile2) => {
+      if (a === null) throw new Error("Abs: no argument");
+      return `_iv_abs(${compile2(a)})`;
+    },
+    Exp: ([a], compile2) => {
+      if (a === null) throw new Error("Exp: no argument");
+      return `_iv_exp(${compile2(a)})`;
+    },
+    Ln: ([a], compile2) => {
+      if (a === null) throw new Error("Ln: no argument");
+      return `_iv_ln(${compile2(a)})`;
+    },
+    Log: (args, compile2) => {
+      if (args.length === 1) return `_iv_log10(${compile2(args[0])})`;
+      return `_iv_div(_iv_ln(${compile2(args[0])}), _iv_ln(${compile2(args[1])}))`;
+    },
+    Lb: ([a], compile2) => {
+      if (a === null) throw new Error("Lb: no argument");
+      return `_iv_log2(${compile2(a)})`;
+    },
+    Sin: ([a], compile2) => {
+      if (a === null) throw new Error("Sin: no argument");
+      return `_iv_sin(${compile2(a)})`;
+    },
+    Cos: ([a], compile2) => {
+      if (a === null) throw new Error("Cos: no argument");
+      return `_iv_cos(${compile2(a)})`;
+    },
+    Tan: ([a], compile2) => {
+      if (a === null) throw new Error("Tan: no argument");
+      return `_iv_tan(${compile2(a)})`;
+    },
+    Arcsin: ([a], compile2) => {
+      if (a === null) throw new Error("Arcsin: no argument");
+      return `_iv_asin(${compile2(a)})`;
+    },
+    Arccos: ([a], compile2) => {
+      if (a === null) throw new Error("Arccos: no argument");
+      return `_iv_acos(${compile2(a)})`;
+    },
+    Arctan: ([a], compile2) => {
+      if (a === null) throw new Error("Arctan: no argument");
+      return `_iv_atan(${compile2(a)})`;
+    },
+    Floor: ([a], compile2) => {
+      if (a === null) throw new Error("Floor: no argument");
+      return `_iv_floor(${compile2(a)})`;
+    },
+    Ceil: ([a], compile2) => {
+      if (a === null) throw new Error("Ceil: no argument");
+      return `_iv_ceil(${compile2(a)})`;
+    },
+    Round: ([a], compile2) => {
+      if (a === null) throw new Error("Round: no argument");
+      return `_iv_round(${compile2(a)})`;
+    },
+    Truncate: ([a], compile2) => {
+      if (a === null) throw new Error("Truncate: no argument");
+      return `_iv_trunc(${compile2(a)})`;
+    },
+    Fract: ([a], compile2) => {
+      if (a === null) throw new Error("Fract: no argument");
+      return `_iv_fract(${compile2(a)})`;
+    },
+    Sign: ([a], compile2) => {
+      if (a === null) throw new Error("Sign: no argument");
+      return `_iv_sign(${compile2(a)})`;
+    },
+    Heaviside: ([a], compile2) => {
+      if (a === null) throw new Error("Heaviside: no argument");
+      return `_iv_heaviside(${compile2(a)})`;
+    },
+    Mod: ([a, b], compile2) => {
+      if (a === null || b === null) throw new Error("Mod: missing argument");
+      return `_iv_mod(${compile2(a)}, ${compile2(b)})`;
+    },
+    Min: (args, compile2) => {
+      if (args.length === 0) throw new Error("Min: no argument");
+      let r = compile2(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_min(${r}, ${compile2(args[i])})`;
+      return r;
+    },
+    Max: (args, compile2) => {
+      if (args.length === 0) throw new Error("Max: no argument");
+      let r = compile2(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_max(${r}, ${compile2(args[i])})`;
+      return r;
+    },
+    Power: ([base, exp3], compile2) => {
+      if (base === null || exp3 === null)
+        throw new Error("Power: missing argument");
+      if (isSymbol2(base, "ExponentialE")) return `_iv_exp(${compile2(exp3)})`;
+      if (isNumber(exp3) && exp3.im === 0) {
+        const v = exp3.re;
+        if (v === 0.5) return `_iv_sqrt(${compile2(base)})`;
+        if (v === 2) return `_iv_square(${compile2(base)})`;
+        if (Number.isInteger(v) && v >= 0)
+          return `_iv_powi(${compile2(base)}, ${formatGPUNumber(v)})`;
+        if (!Number.isInteger(v) && v > 0)
+          return `_iv_powf(${compile2(base)}, ${formatGPUNumber(v)})`;
+        throw new Error(
+          `interval-glsl: Power with exponent \`${exp3.toString()}\` is not yet supported`
+        );
+      }
+      throw new Error(
+        "interval-glsl: Power with a variable exponent is not yet supported"
+      );
+    }
+  };
+  var INTERVAL_GLSL_CONSTANTS = {
+    Pi: "vec2(3.14159265359, 3.14159265359)",
+    ExponentialE: "vec2(2.71828182846, 2.71828182846)",
+    GoldenRatio: "vec2(1.61803398875, 1.61803398875)",
+    CatalanConstant: "vec2(0.91596559417, 0.91596559417)",
+    EulerGamma: "vec2(0.57721566490, 0.57721566490)"
+  };
+  var IntervalGLSLTarget = class extends GLSLTarget {
+    languageId = "interval-glsl";
+    getOperators() {
+      return {};
+    }
+    getFunctions() {
+      return INTERVAL_GLSL_FUNCTIONS;
+    }
+    getConstants() {
+      return INTERVAL_GLSL_CONSTANTS;
+    }
+    createTarget(options = {}) {
+      return super.createTarget({
+        operators: () => void 0,
+        functions: (id) => INTERVAL_GLSL_FUNCTIONS[id],
+        number: (n) => `vec2(${formatGPUNumber(n)}, ${formatGPUNumber(n)})`,
+        complex: () => {
+          throw new Error("interval-glsl: complex values are not supported");
+        },
+        var: (id) => INTERVAL_GLSL_CONSTANTS[id],
+        ...options
+      });
+    }
+    compile(expr, options = {}) {
+      const { vars } = options;
+      const target = this.createTarget({
+        var: (id) => {
+          if (vars && id in vars) return vars[id];
+          if (id in INTERVAL_GLSL_CONSTANTS) return INTERVAL_GLSL_CONSTANTS[id];
+          return void 0;
+        }
+      });
+      const code = BaseCompiler.compile(expr, target);
+      const result = {
+        target: "interval-glsl",
+        success: true,
+        code
+      };
+      if (code.includes("_iv_")) result.preamble = INTERVAL_GLSL_PREAMBLE;
+      return BaseCompiler.withReferences(
+        result,
+        expr,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
+    }
+    /**
+     * Emit a complete, self-contained GLSL fragment shader implementing the
+     * **interval exclusion oracle** for the implicit curve `f = 0` (Phase 4).
+     *
+     * The shader is structured so the core contract — the interval evaluator —
+     * is cleanly separable from the render harness:
+     *
+     * - `vec2 _implicit(<vec2 per free variable>)` evaluates the interval of `f`
+     *   over a cell box (this is the part that matters; it is identical to
+     *   `compile(expr).code` wrapped in a function).
+     * - `main()` is a **reference harness**: it derives each fragment's cell box
+     *   from `gl_FragCoord` and the viewport uniforms, evaluates `_implicit`, and
+     *   writes the exclusion result. The renderer is free to replace `main()` /
+     *   the uniforms with its own conventions and keep `_implicit`.
+     *
+     * The first free variable maps to `u_domainX`, the second to `u_domainY`
+     * (≤ 2 free variables; a 2D implicit curve). The exclusion predicate is
+     * `f.lo > 0 || f.hi < 0` — which also excludes the `empty` (domain-undefined)
+     * interval, since its `lo` is the `+IV_INF` sentinel.
+     *
+     * @throws if the expression has more than two free variables, or cannot be
+     * lowered (an unsupported head propagates from `BaseCompiler.compile`).
+     */
+    compileExclusionShader(expr, options = {}) {
+      const { version: version2 = "300 es", precision = "highp" } = options;
+      const compiled = this.compile(expr);
+      const vars = compiled.freeSymbols ?? [];
+      if (vars.length > 2)
+        throw new Error(
+          `interval-glsl exclusion shader supports at most 2 free variables (got ${vars.length}: ${vars.join(", ")})`
+        );
+      const params = vars.map((v) => `vec2 ${v}`).join(", ");
+      const [axisX, axisY] = vars;
+      const main = ["void main() {"];
+      main.push("  vec2 _cell = gl_FragCoord.xy / u_resolution;");
+      main.push("  vec2 _step = 1.0 / u_resolution;");
+      const callArgs = [];
+      if (axisX !== void 0) {
+        main.push("  float _xlo = mix(u_domainX.x, u_domainX.y, _cell.x);");
+        main.push(
+          "  float _xhi = mix(u_domainX.x, u_domainX.y, _cell.x + _step.x);"
+        );
+        callArgs.push("vec2(_xlo, _xhi)");
+      }
+      if (axisY !== void 0) {
+        main.push("  float _ylo = mix(u_domainY.x, u_domainY.y, _cell.y);");
+        main.push(
+          "  float _yhi = mix(u_domainY.x, u_domainY.y, _cell.y + _step.y);"
+        );
+        callArgs.push("vec2(_ylo, _yhi)");
+      }
+      main.push(`  vec2 _f = _implicit(${callArgs.join(", ")});`);
+      main.push("  bool _excluded = (_f.x > 0.0 || _f.y < 0.0);");
+      main.push(
+        "  fragColor = _excluded ? vec4(0.0, 0.0, 0.0, 1.0) : vec4(1.0);"
+      );
+      main.push("}");
+      return [
+        `#version ${version2}`,
+        `precision ${precision} float;`,
+        "",
+        INTERVAL_GLSL_PREAMBLE.trim(),
+        "",
+        "uniform vec2 u_domainX;    // [min, max] for the 1st free variable",
+        "uniform vec2 u_domainY;    // [min, max] for the 2nd free variable",
+        "uniform vec2 u_resolution; // render target size, in pixels",
+        "",
+        "out vec4 fragColor;",
+        "",
+        "// Interval evaluation of the implicit field f over a cell box.",
+        `vec2 _implicit(${params}) {`,
+        `  return ${compiled.code};`,
+        "}",
+        "",
+        main.join("\n"),
+        ""
+      ].join("\n");
+    }
+  };
+
   // src/compile.ts
-  var version = "0.60.0";
+  var version = "0.61.0";
   return __toCommonJS(compile_exports);
 })();
 /*! Bundled license information: