@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/compile.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.60.0 */
+/** Compute Engine 0.61.0 */
 
 // src/common/interruptible.ts
 var CancellationError = class extends Error {
@@ -4524,10 +4524,18 @@ function canonicalFunctionLiteral(expr) {
 }
 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)) {
@@ -16721,6 +16729,13 @@ function normalizeIndexingSet(indexingSet) {
 
 // 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
    */
@@ -16737,7 +16752,9 @@ var BaseCompiler = class _BaseCompiler {
       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) {
@@ -17063,10 +17080,10 @@ var BaseCompiler = class _BaseCompiler {
         )
       );
       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--) {
@@ -17364,6 +17381,167 @@ var BaseCompiler = class _BaseCompiler {
     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
    */
@@ -17511,11 +17689,16 @@ function compile(expr, options) {
   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);
@@ -17534,11 +17717,26 @@ function compile(expr, options) {
     });
   } 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 {
@@ -17546,7 +17744,9 @@ function compile(expr, options) {
           success: false,
           code: "",
           calling: "lambda",
-          run: lambdaRun
+          run: lambdaRun,
+          error,
+          ...refs
         };
       }
       const fallbackRun = ((vars) => {
@@ -17565,7 +17765,9 @@ function compile(expr, options) {
         success: false,
         code: "",
         calling: "expression",
-        run: fallbackRun
+        run: fallbackRun,
+        error,
+        ...refs
       };
     }
     throw e;
@@ -17574,6 +17776,10 @@ function compile(expr, options) {
 
 // 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`;
@@ -21863,6 +22069,442 @@ function fresnelC(x) {
 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 = [
@@ -22582,6 +23224,7 @@ var JAVASCRIPT_FUNCTIONS = {
   Erf: "_SYS.erf",
   Erfc: "_SYS.erfc",
   ErfInv: "_SYS.erfInv",
+  Erfi: "_SYS.erfi",
   // Special functions
   Beta: "_SYS.beta",
   Digamma: "_SYS.digamma",
@@ -22597,6 +23240,30 @@ var JAVASCRIPT_FUNCTIONS = {
   // 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)
@@ -22609,6 +23276,8 @@ var JAVASCRIPT_FUNCTIONS = {
     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) => {
@@ -23114,6 +23783,20 @@ var SYS_HELPERS = {
   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;
@@ -23300,7 +23983,7 @@ var JavaScriptTarget = class {
       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",
@@ -23311,13 +23994,20 @@ var JavaScriptTarget = class {
           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) {
@@ -25888,6 +26578,10 @@ var GPU_CONSTANTS = {
   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`;
@@ -25915,7 +26609,7 @@ var GPUShaderTarget = class {
       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,
@@ -25954,7 +26648,7 @@ var GPUShaderTarget = class {
         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);
@@ -25994,7 +26688,12 @@ var GPUShaderTarget = class {
       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();
@@ -26027,6 +26726,8 @@ var GLSL_FUNCTIONS = {
   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;
@@ -26547,7 +27248,17 @@ var PythonTarget = class {
    */
   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
@@ -28404,11 +29115,18 @@ var IntervalJavaScriptTarget = class {
         };
         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) {
@@ -28432,12 +29150,539 @@ function compileToIntervalTarget(expr, target) {
   };
 }
 
+// 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";
 export {
   BaseCompiler,
   GLSLTarget,
   GPUShaderTarget,
+  IntervalGLSLTarget,
   IntervalJavaScriptTarget,
   JavaScriptTarget,
   PythonTarget,