@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.60.0 */
+/** Compute Engine 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.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 "use strict";
 var ComputeEngine = (() => {
@@ -7499,10 +7499,18 @@ var ComputeEngine = (() => {
   }
   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)) {
@@ -66991,6 +66999,13 @@ Error in definition of "${name}"`,
 
   // 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
      */
@@ -67007,7 +67022,9 @@ Error in definition of "${name}"`,
         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(expr2.engine, s, target) ?? s;
       }
       if (isNumber(expr2)) {
         if (expr2.im !== 0) {
@@ -67333,10 +67350,10 @@ Error in definition of "${name}"`,
           )
         );
         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--) {
@@ -67634,6 +67651,167 @@ Error in definition of "${name}"`,
       if (isNumber(expr2)) return expr2.im === 0 && expr2.re >= 0;
       return expr2.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(expr2, target, varsKeys) {
+      const engine = expr2.engine;
+      const free = /* @__PURE__ */ new Set();
+      const unsupported = /* @__PURE__ */ new Set();
+      const foldedSeen = /* @__PURE__ */ new Set();
+      const union2 = (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 ? union2(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 ? union2(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 ? union2(bound, locals) : bound;
+          for (const op of ops) visit(op, inner);
+          return;
+        }
+        for (const op of ops) visit(op, bound);
+      };
+      visit(expr2, /* @__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, expr2, target, varsKeys) {
+      return Object.assign(
+        result,
+        _BaseCompiler.analyzeReferences(expr2, target, varsKeys)
+      );
+    }
     /**
      * Generate a temporary variable name
      */
@@ -67863,11 +68041,16 @@ Error in definition of "${name}"`,
     try {
       if (options?.target) {
         const code = BaseCompiler.compile(expr2, options.target);
-        return {
-          target: options.target.language ?? "custom",
-          success: true,
-          code
-        };
+        return BaseCompiler.withReferences(
+          {
+            target: options.target.language ?? "custom",
+            success: true,
+            code
+          },
+          expr2,
+          options.target,
+          options.vars ? new Set(Object.keys(options.vars)) : void 0
+        );
       }
       const targetName = options?.to ?? "javascript";
       const languageTarget = expr2.engine.getCompilationTarget(targetName);
@@ -67886,11 +68069,26 @@ Error in definition of "${name}"`,
       });
     } catch (e) {
       if (options?.fallback ?? true) {
+        const error = e.message;
         console.warn(
-          `Compilation fallback for "${expr2.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
+          `Compilation fallback for "${expr2.operator}" (target: ${options?.to ?? "javascript"}): ${error}`
         );
         const ce = expr2.engine;
         const target = options?.to ?? "javascript";
+        let refs = {
+          freeSymbols: [],
+          unsupported: []
+        };
+        try {
+          const compileTarget = options?.target ?? expr2.engine.getCompilationTarget(target)?.createTarget();
+          if (compileTarget)
+            refs = BaseCompiler.analyzeReferences(
+              expr2,
+              compileTarget,
+              options?.vars ? new Set(Object.keys(options.vars)) : void 0
+            );
+        } catch {
+        }
         if (isFunction2(expr2, "Function")) {
           const lambdaRun = ((...args) => ce.function("Apply", [expr2, ...args.map((a) => ce.expr(a))]).evaluate().re);
           return {
@@ -67898,7 +68096,9 @@ Error in definition of "${name}"`,
             success: false,
             code: "",
             calling: "lambda",
-            run: lambdaRun
+            run: lambdaRun,
+            error,
+            ...refs
           };
         }
         const fallbackRun = ((vars) => {
@@ -67917,7 +68117,9 @@ Error in definition of "${name}"`,
           success: false,
           code: "",
           calling: "expression",
-          run: fallbackRun
+          run: fallbackRun,
+          error,
+          ...refs
         };
       }
       throw e;
@@ -73443,6 +73645,10 @@ Error in definition of "${name}"`,
 
   // 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`;
@@ -74038,6 +74244,7 @@ Error in definition of "${name}"`,
     Erf: "_SYS.erf",
     Erfc: "_SYS.erfc",
     ErfInv: "_SYS.erfInv",
+    Erfi: "_SYS.erfi",
     // Special functions
     Beta: "_SYS.beta",
     Digamma: "_SYS.digamma",
@@ -74053,6 +74260,30 @@ Error in definition of "${name}"`,
     // 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, compile3) => args.length === 1 ? `_SYS.agm(1, ${compile3(args[0])})` : `_SYS.agm(${compile3(args[0])}, ${compile3(args[1])})`,
+    EllipticK: "_SYS.ellipticK",
+    EllipticE: (args, compile3) => args.length === 2 ? `_SYS.ellipticEIncomplete(${compile3(args[0])}, ${compile3(args[1])})` : `_SYS.ellipticE(${compile3(args[0])})`,
+    EllipticF: (args, compile3) => `_SYS.ellipticF(${compile3(args[0])}, ${compile3(args[1])})`,
+    EllipticPi: (args, compile3) => args.length === 3 ? `_SYS.ellipticPiIncomplete(${compile3(args[0])}, ${compile3(
+      args[1]
+    )}, ${compile3(args[2])})` : `_SYS.ellipticPiComplete(${compile3(args[0])}, ${compile3(args[1])})`,
+    // Hypergeometric functions.
+    Hypergeometric2F1: (args, compile3) => `_SYS.hypergeometric2F1(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(
+      args[2]
+    )}, ${compile3(args[3])})`,
+    Hypergeometric1F1: (args, compile3) => `_SYS.hypergeometric1F1(${compile3(args[0])}, ${compile3(args[1])}, ${compile3(
+      args[2]
+    )})`,
     // Combinatorics
     Mandelbrot: ([c, maxIter], compile3) => {
       if (c === null || maxIter === null)
@@ -74065,6 +74296,8 @@ Error in definition of "${name}"`,
       return `_SYS.julia(${compile3(z)}, ${compile3(c)}, ${compile3(maxIter)})`;
     },
     Binomial: (args, compile3) => `_SYS.binomial(${compile3(args[0])}, ${compile3(args[1])})`,
+    // Choose(n, k) is the binomial coefficient — same runtime helper.
+    Choose: (args, compile3) => `_SYS.binomial(${compile3(args[0])}, ${compile3(args[1])})`,
     Fibonacci: "_SYS.fibonacci",
     // Complex-specific functions
     Real: (args, compile3) => {
@@ -74570,6 +74803,20 @@ Error in definition of "${name}"`,
     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;
@@ -74756,7 +75003,7 @@ Error in definition of "${name}"`,
         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",
@@ -74767,13 +75014,20 @@ Error in definition of "${name}"`,
             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 (expr2.engine._getSymbolValue(id) !== void 0) return void 0;
+          return `_.${id}`;
         },
         preamble: (preamble ?? "") + preambleImports
       });
-      return compileToTarget(expr2, target, realOnly);
+      const result = compileToTarget(expr2, target, realOnly);
+      return BaseCompiler.withReferences(
+        result,
+        expr2,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
   };
   function wrapRealOnly(result) {
@@ -77344,6 +77598,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`;
@@ -77371,7 +77629,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,
@@ -77410,7 +77668,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(expr2, target);
@@ -77450,7 +77708,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,
+        expr2,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
     compileToSource(expr2, _options = {}) {
       const target = this.createTarget();
@@ -77483,6 +77746,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;
@@ -79444,11 +79709,18 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
           };
           if (id in constants) return constants[id];
           if (unknowns.includes(id)) return `_.${id}`;
-          return void 0;
+          if (expr2.engine._getSymbolValue(id) !== void 0) return void 0;
+          return `_.${id}`;
         },
         preamble: (preamble ?? "") + preambleImports
       });
-      return compileToIntervalTarget(expr2, target);
+      const result = compileToIntervalTarget(expr2, target);
+      return BaseCompiler.withReferences(
+        result,
+        expr2,
+        target,
+        vars ? new Set(Object.keys(vars)) : void 0
+      );
     }
   };
   function compileToIntervalTarget(expr2, target) {
@@ -79472,6 +79744,532 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     };
   }
 
+  // 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, compile3) => {
+      if (args.length === 0) return "vec2(0.0, 0.0)";
+      let r = compile3(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_add(${r}, ${compile3(args[i])})`;
+      return r;
+    },
+    Subtract: ([a, b], compile3) => {
+      if (a === null || b === null) throw new Error("Subtract: missing argument");
+      return `_iv_sub(${compile3(a)}, ${compile3(b)})`;
+    },
+    Multiply: (args, compile3) => {
+      if (args.length === 0) return "vec2(1.0, 1.0)";
+      let r = compile3(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_mul(${r}, ${compile3(args[i])})`;
+      return r;
+    },
+    Divide: ([a, b], compile3) => {
+      if (a === null || b === null) throw new Error("Divide: missing argument");
+      return `_iv_div(${compile3(a)}, ${compile3(b)})`;
+    },
+    Negate: ([a], compile3) => {
+      if (a === null) throw new Error("Negate: no argument");
+      return `_iv_negate(${compile3(a)})`;
+    },
+    Square: ([a], compile3) => {
+      if (a === null) throw new Error("Square: no argument");
+      return `_iv_square(${compile3(a)})`;
+    },
+    Sqrt: ([a], compile3) => {
+      if (a === null) throw new Error("Sqrt: no argument");
+      return `_iv_sqrt(${compile3(a)})`;
+    },
+    Abs: ([a], compile3) => {
+      if (a === null) throw new Error("Abs: no argument");
+      return `_iv_abs(${compile3(a)})`;
+    },
+    Exp: ([a], compile3) => {
+      if (a === null) throw new Error("Exp: no argument");
+      return `_iv_exp(${compile3(a)})`;
+    },
+    Ln: ([a], compile3) => {
+      if (a === null) throw new Error("Ln: no argument");
+      return `_iv_ln(${compile3(a)})`;
+    },
+    Log: (args, compile3) => {
+      if (args.length === 1) return `_iv_log10(${compile3(args[0])})`;
+      return `_iv_div(_iv_ln(${compile3(args[0])}), _iv_ln(${compile3(args[1])}))`;
+    },
+    Lb: ([a], compile3) => {
+      if (a === null) throw new Error("Lb: no argument");
+      return `_iv_log2(${compile3(a)})`;
+    },
+    Sin: ([a], compile3) => {
+      if (a === null) throw new Error("Sin: no argument");
+      return `_iv_sin(${compile3(a)})`;
+    },
+    Cos: ([a], compile3) => {
+      if (a === null) throw new Error("Cos: no argument");
+      return `_iv_cos(${compile3(a)})`;
+    },
+    Tan: ([a], compile3) => {
+      if (a === null) throw new Error("Tan: no argument");
+      return `_iv_tan(${compile3(a)})`;
+    },
+    Arcsin: ([a], compile3) => {
+      if (a === null) throw new Error("Arcsin: no argument");
+      return `_iv_asin(${compile3(a)})`;
+    },
+    Arccos: ([a], compile3) => {
+      if (a === null) throw new Error("Arccos: no argument");
+      return `_iv_acos(${compile3(a)})`;
+    },
+    Arctan: ([a], compile3) => {
+      if (a === null) throw new Error("Arctan: no argument");
+      return `_iv_atan(${compile3(a)})`;
+    },
+    Floor: ([a], compile3) => {
+      if (a === null) throw new Error("Floor: no argument");
+      return `_iv_floor(${compile3(a)})`;
+    },
+    Ceil: ([a], compile3) => {
+      if (a === null) throw new Error("Ceil: no argument");
+      return `_iv_ceil(${compile3(a)})`;
+    },
+    Round: ([a], compile3) => {
+      if (a === null) throw new Error("Round: no argument");
+      return `_iv_round(${compile3(a)})`;
+    },
+    Truncate: ([a], compile3) => {
+      if (a === null) throw new Error("Truncate: no argument");
+      return `_iv_trunc(${compile3(a)})`;
+    },
+    Fract: ([a], compile3) => {
+      if (a === null) throw new Error("Fract: no argument");
+      return `_iv_fract(${compile3(a)})`;
+    },
+    Sign: ([a], compile3) => {
+      if (a === null) throw new Error("Sign: no argument");
+      return `_iv_sign(${compile3(a)})`;
+    },
+    Heaviside: ([a], compile3) => {
+      if (a === null) throw new Error("Heaviside: no argument");
+      return `_iv_heaviside(${compile3(a)})`;
+    },
+    Mod: ([a, b], compile3) => {
+      if (a === null || b === null) throw new Error("Mod: missing argument");
+      return `_iv_mod(${compile3(a)}, ${compile3(b)})`;
+    },
+    Min: (args, compile3) => {
+      if (args.length === 0) throw new Error("Min: no argument");
+      let r = compile3(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_min(${r}, ${compile3(args[i])})`;
+      return r;
+    },
+    Max: (args, compile3) => {
+      if (args.length === 0) throw new Error("Max: no argument");
+      let r = compile3(args[0]);
+      for (let i = 1; i < args.length; i++)
+        r = `_iv_max(${r}, ${compile3(args[i])})`;
+      return r;
+    },
+    Power: ([base, exp3], compile3) => {
+      if (base === null || exp3 === null)
+        throw new Error("Power: missing argument");
+      if (isSymbol2(base, "ExponentialE")) return `_iv_exp(${compile3(exp3)})`;
+      if (isNumber(exp3) && exp3.im === 0) {
+        const v = exp3.re;
+        if (v === 0.5) return `_iv_sqrt(${compile3(base)})`;
+        if (v === 2) return `_iv_square(${compile3(base)})`;
+        if (Number.isInteger(v) && v >= 0)
+          return `_iv_powi(${compile3(base)}, ${formatGPUNumber(v)})`;
+        if (!Number.isInteger(v) && v > 0)
+          return `_iv_powf(${compile3(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(expr2, 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(expr2, target);
+      const result = {
+        target: "interval-glsl",
+        success: true,
+        code
+      };
+      if (code.includes("_iv_")) result.preamble = INTERVAL_GLSL_PREAMBLE;
+      return BaseCompiler.withReferences(
+        result,
+        expr2,
+        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(expr2, options = {}) {
+      const { version: version2 = "300 es", precision = "highp" } = options;
+      const compiled = this.compile(expr2);
+      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/compute-engine/engine-compilation-targets.ts
   var CompilationTargetRegistry = class {
     _targets = /* @__PURE__ */ new Map();
@@ -79494,6 +80292,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       this.register("glsl", new GLSLTarget());
       this.register("wgsl", new WGSLTarget());
       this.register("interval-js", new IntervalJavaScriptTarget());
+      this.register("interval-glsl", new IntervalGLSLTarget());
     }
   };
 
@@ -79611,6 +80410,20 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     if (engine.strict && !isValidSymbol(name))
       return engine.error(["invalid-symbol", validateSymbol(name)], name);
     if (!canonical2) return new BoxedSymbol(engine, name, { metadata });
+    if (engine._isShadowedParameter(name)) {
+      let pdef = engine.lookupDefinition(name);
+      if (!pdef || isValueDef(pdef) && pdef.value.isConstant) {
+        let autoScope2 = engine.context.lexicalScope;
+        while (autoScope2.noAutoDeclare && autoScope2.parent)
+          autoScope2 = autoScope2.parent;
+        pdef = engine._declareSymbolValue(
+          name,
+          { type: "unknown", inferred: true },
+          autoScope2
+        );
+      }
+      return new BoxedSymbol(engine, name, { metadata, def: pdef });
+    }
     const result = commonSymbols[name];
     if (result) return result;
     let def = engine.lookupDefinition(name);
@@ -80362,7 +81175,17 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
      */
     compile(expr2, options = {}) {
       const code = this.compileToSource(expr2, options);
-      return { target: "python", success: true, code };
+      const result = {
+        target: "python",
+        success: true,
+        code
+      };
+      return BaseCompiler.withReferences(
+        result,
+        expr2,
+        this.createTarget(),
+        options.vars ? new Set(Object.keys(options.vars)) : void 0
+      );
     }
     /**
      * Compile an expression to Python source code
@@ -82718,6 +83541,24 @@ ${code}`;
     _printStack(options) {
       printStack(this, options);
     }
+    /** Stack of parameter-name sets active while canonicalizing function bodies.
+     * @internal */
+    _shadowedParameterStack = [];
+    /** @internal */
+    _pushShadowedParameters(names) {
+      this._shadowedParameterStack.push(new Set(names));
+    }
+    /** @internal */
+    _popShadowedParameters() {
+      this._shadowedParameterStack.pop();
+    }
+    /** @internal */
+    _isShadowedParameter(name) {
+      const stack = this._shadowedParameterStack;
+      for (let i = stack.length - 1; i >= 0; i--)
+        if (stack[i].has(name)) return true;
+      return false;
+    }
     /**
      * Use `ce.expr(name)` instead
      * @internal */
@@ -83137,14 +83978,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.60.0";
+  var version = "0.61.0";
   ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
   _setDefaultEngineFactory(
     () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
   );
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.60.0"
+    version: "0.61.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();