@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.60.0 */
+/** Compute Engine 0.61.0 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -7421,10 +7421,18 @@ function canonicalFunctionLiteral(expr2) {
 }
 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)) {
@@ -66913,6 +66921,13 @@ function serializeJson(ce, expr2, options) {
 
 // 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
    */
@@ -66929,7 +66944,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(expr2.engine, s, target) ?? s;
     }
     if (isNumber(expr2)) {
       if (expr2.im !== 0) {
@@ -67255,10 +67272,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--) {
@@ -67556,6 +67573,167 @@ var BaseCompiler = class _BaseCompiler {
     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
    */
@@ -67785,11 +67963,16 @@ function compile(expr2, options) {
   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);
@@ -67808,11 +67991,26 @@ function compile(expr2, options) {
     });
   } 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 {
@@ -67820,7 +68018,9 @@ function compile(expr2, options) {
           success: false,
           code: "",
           calling: "lambda",
-          run: lambdaRun
+          run: lambdaRun,
+          error,
+          ...refs
         };
       }
       const fallbackRun = ((vars) => {
@@ -67839,7 +68039,9 @@ function compile(expr2, options) {
         success: false,
         code: "",
         calling: "expression",
-        run: fallbackRun
+        run: fallbackRun,
+        error,
+        ...refs
       };
     }
     throw e;
@@ -73365,6 +73567,10 @@ function resetCommonSymbols(commonSymbols) {
 
 // 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`;
@@ -73960,6 +74166,7 @@ var JAVASCRIPT_FUNCTIONS = {
   Erf: "_SYS.erf",
   Erfc: "_SYS.erfc",
   ErfInv: "_SYS.erfInv",
+  Erfi: "_SYS.erfi",
   // Special functions
   Beta: "_SYS.beta",
   Digamma: "_SYS.digamma",
@@ -73975,6 +74182,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, 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)
@@ -73987,6 +74218,8 @@ var JAVASCRIPT_FUNCTIONS = {
     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) => {
@@ -74492,6 +74725,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;
@@ -74678,7 +74925,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",
@@ -74689,13 +74936,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 (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) {
@@ -77266,6 +77520,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`;
@@ -77293,7 +77551,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,
@@ -77332,7 +77590,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(expr2, target);
@@ -77372,7 +77630,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,
+      expr2,
+      target,
+      vars ? new Set(Object.keys(vars)) : void 0
+    );
   }
   compileToSource(expr2, _options = {}) {
     const target = this.createTarget();
@@ -77405,6 +77668,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;
@@ -79366,11 +79631,18 @@ var IntervalJavaScriptTarget = class {
         };
         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) {
@@ -79394,6 +79666,532 @@ function compileToIntervalTarget(expr2, 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, 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();
@@ -79416,6 +80214,7 @@ var CompilationTargetRegistry = class {
     this.register("glsl", new GLSLTarget());
     this.register("wgsl", new WGSLTarget());
     this.register("interval-js", new IntervalJavaScriptTarget());
+    this.register("interval-glsl", new IntervalGLSLTarget());
   }
 };
 
@@ -79533,6 +80332,20 @@ function createSymbolExpression(engine, commonSymbols, symbolName2, options) {
   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);
@@ -80284,7 +81097,17 @@ var PythonTarget = class {
    */
   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
@@ -82640,6 +83463,24 @@ var ComputeEngine = class _ComputeEngine {
   _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 */
@@ -83059,14 +83900,14 @@ var ComputeEngine = class _ComputeEngine {
 _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"
 };
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,