@cortex-js/compute-engine 0.60.0 → 0.61.0

package/dist/types/compute-engine/compilation/interval-glsl-target.d.ts

@@ -0,0 +1,49 @@
+/* 0.61.0 */
+import type { CompiledFunctions, CompiledOperators, CompileTarget, CompilationOptions, CompilationResult } from './types';
+import { GLSLTarget } from './glsl-target';
+/**
+ * GLSL preamble: the `_iv_*` interval-arithmetic library. Injected whole when
+ * the compiled code references any `_iv_` helper. (A later phase can split this
+ * per-marker like the `_gpu_*` blocks to keep shaders lean.)
+ */
+export declare const INTERVAL_GLSL_PREAMBLE = "\nconst float IV_INF = 1e18;\nconst vec2 IV_ENTIRE = vec2(-IV_INF, IV_INF);\nconst vec2 IV_EMPTY = vec2(IV_INF, -IV_INF);\n\nbool _iv_is_empty(vec2 a) { return a.x > a.y; }\n\n// Clamp bounds to the finite sentinel range. Preserves IV_EMPTY (its components\n// already sit at the sentinels) and folds any overflowed intermediate back to\n// the sentinel (min(inf, IV_INF) = IV_INF), so a real `inf` never escapes an op.\nvec2 _iv_clamp(vec2 a) { return clamp(a, -IV_INF, IV_INF); }\n\n// Exact empty propagation: force empty if any operand is empty.\nvec2 _iv_guard1(vec2 r, vec2 a) { return _iv_is_empty(a) ? IV_EMPTY : r; }\nvec2 _iv_guard2(vec2 r, vec2 a, vec2 b) {\n  return (_iv_is_empty(a) || _iv_is_empty(b)) ? IV_EMPTY : r;\n}\n\nvec2 _iv_negate(vec2 a) { return _iv_guard1(_iv_clamp(vec2(-a.y, -a.x)), a); }\n\nvec2 _iv_add(vec2 a, vec2 b) {\n  return _iv_guard2(_iv_clamp(vec2(a.x + b.x, a.y + b.y)), a, b);\n}\n\nvec2 _iv_sub(vec2 a, vec2 b) {\n  return _iv_guard2(_iv_clamp(vec2(a.x - b.y, a.y - b.x)), a, b);\n}\n\nvec2 _iv_mul(vec2 a, vec2 b) {\n  float p1 = a.x * b.x, p2 = a.x * b.y, p3 = a.y * b.x, p4 = a.y * b.y;\n  vec2 r = vec2(min(min(p1, p2), min(p3, p4)), max(max(p1, p2), max(p3, p4)));\n  return _iv_guard2(_iv_clamp(r), a, b);\n}\n\nvec2 _iv_div(vec2 a, vec2 b) {\n  // Denominator spanning 0 \u2192 entire (wide, never narrow): the CPU pass turns\n  // the pole into a proper asymptote break.\n  bool spansZero = (b.x <= 0.0 && b.y >= 0.0);\n  float q1 = a.x / b.x, q2 = a.x / b.y, q3 = a.y / b.x, q4 = a.y / b.y;\n  vec2 r = vec2(min(min(q1, q2), min(q3, q4)), max(max(q1, q2), max(q3, q4)));\n  r = spansZero ? IV_ENTIRE : r;\n  return _iv_guard2(_iv_clamp(r), a, b);\n}\n\nvec2 _iv_square(vec2 a) {\n  float lo2 = a.x * a.x, hi2 = a.y * a.y;\n  // Straddles 0 \u21D2 min is 0; otherwise the smaller endpoint\u00B2 is the min.\n  float lo = (a.x <= 0.0 && a.y >= 0.0) ? 0.0 : min(lo2, hi2);\n  return _iv_guard1(_iv_clamp(vec2(lo, max(lo2, hi2))), a);\n}\n\n// Scalar integer power that is correct for negative bases (GLSL `pow` requires\n// a non-negative base): keep the sign for odd exponents, drop it for even.\nfloat _iv_powi_scalar(float x, float n) {\n  float a = pow(abs(x), n);\n  return (mod(n, 2.0) == 1.0 && x < 0.0) ? -a : a;\n}\n\nvec2 _iv_powi(vec2 a, float n) {\n  float pl = _iv_powi_scalar(a.x, n);\n  float ph = _iv_powi_scalar(a.y, n);\n  bool even = (mod(n, 2.0) == 0.0);\n  bool straddle = (a.x <= 0.0 && a.y >= 0.0);\n  float lo = even ? (straddle ? 0.0 : min(pl, ph)) : pl;\n  float hi = even ? max(pl, ph) : ph;\n  return _iv_guard1(_iv_clamp(vec2(lo, hi)), a);\n}\n\n// \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\n\nvec2 _iv_abs(vec2 a) {\n  float al = abs(a.x), ah = abs(a.y);\n  bool straddle = (a.x <= 0.0 && a.y >= 0.0);\n  return _iv_guard1(_iv_clamp(vec2(straddle ? 0.0 : min(al, ah), max(al, ah))), a);\n}\n\n// Domain x \u2265 0: fully-negative box \u2192 empty; a box straddling 0 clamps lo to 0.\nvec2 _iv_sqrt(vec2 a) {\n  vec2 r = vec2(sqrt(max(a.x, 0.0)), sqrt(max(a.y, 0.0)));\n  r = (a.y < 0.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_exp(vec2 a) {\n  return _iv_guard1(_iv_clamp(vec2(exp(a.x), exp(a.y))), a);\n}\n\n// Domain x > 0: fully-\u22640 box \u2192 empty; straddling box \u2192 lo clamped to \u2212IV_INF\n// (ln \u2192 \u2212\u221E as x \u2192 0\u207A, never a real \u2212inf).\nvec2 _iv_ln(vec2 a) {\n  vec2 r = vec2(a.x > 0.0 ? log(a.x) : -IV_INF, log(a.y));\n  r = (a.y <= 0.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nconst float _IV_INV_LN10 = 0.43429448190325176;\nconst float _IV_INV_LN2 = 1.4426950408889634;\n\nvec2 _iv_log10(vec2 a) {\n  vec2 r = vec2(a.x > 0.0 ? log(a.x) * _IV_INV_LN10 : -IV_INF, log(a.y) * _IV_INV_LN10);\n  r = (a.y <= 0.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_log2(vec2 a) {\n  vec2 r = vec2(a.x > 0.0 ? log(a.x) * _IV_INV_LN2 : -IV_INF, log(a.y) * _IV_INV_LN2);\n  r = (a.y <= 0.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\n// Non-integer power. Real only for base \u2265 0: fully-negative box \u2192 empty; a box\n// straddling 0 clamps the base low end to 0. `p` is a compile-time constant, so\n// the `p >= 0` test is a constant branch.\nvec2 _iv_powf(vec2 a, float p) {\n  float lob = max(a.x, 0.0);\n  float e0 = pow(lob, p), e1 = pow(a.y, p);\n  vec2 r = (p >= 0.0) ? vec2(e0, e1) : vec2(e1, e0);\n  r = (a.y < 0.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\n// \u2500\u2500 Phase 3: trigonometric & inverse-trigonometric functions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Mirrors interval-js (interval/trigonometric.ts): exact endpoints with\n// extremum snapping (no outward epsilon). Per the Option-A contract, a tan pole\n// yields `entire` (interval-js returns `singular`; entire \u2287 singular and the\n// CPU classifies the asymptote).\n\nconst float _IV_PI = 3.141592653589793;\nconst float _IV_TWO_PI = 6.283185307179586;\nconst float _IV_HALF_PI = 1.5707963267948966;\nconst float _IV_THREE_HALF_PI = 4.71238898038469;\n\n// True if [a] contains an extremum of the family { ext + n\u00B7period }.\nbool _iv_has_ext(vec2 a, float ext, float period) {\n  float n = ceil((a.x - ext) / period);\n  float cand = ext + n * period;\n  return cand >= a.x - 1e-15 && cand <= a.y + 1e-15;\n}\n\nvec2 _iv_sin(vec2 a) {\n  vec2 r;\n  if (a.y - a.x >= _IV_TWO_PI) r = vec2(-1.0, 1.0);\n  else {\n    float sl = sin(a.x), sh = sin(a.y);\n    float lo = min(sl, sh), hi = max(sl, sh);\n    if (_iv_has_ext(a, _IV_HALF_PI, _IV_TWO_PI)) hi = 1.0;\n    if (_iv_has_ext(a, _IV_THREE_HALF_PI, _IV_TWO_PI)) lo = -1.0;\n    r = vec2(lo, hi);\n  }\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_cos(vec2 a) {\n  vec2 r;\n  if (a.y - a.x >= _IV_TWO_PI) r = vec2(-1.0, 1.0);\n  else {\n    float cl = cos(a.x), ch = cos(a.y);\n    float lo = min(cl, ch), hi = max(cl, ch);\n    if (_iv_has_ext(a, 0.0, _IV_TWO_PI)) hi = 1.0;\n    if (_iv_has_ext(a, _IV_PI, _IV_TWO_PI)) lo = -1.0;\n    r = vec2(lo, hi);\n  }\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_tan(vec2 a) {\n  // A pole in the interval \u2192 entire (cannot exclude).\n  bool pole =\n    (a.y - a.x >= _IV_PI) || _iv_has_ext(a, _IV_HALF_PI, _IV_PI);\n  float tl = tan(a.x), th = tan(a.y);\n  // Floating-point branch-cross sanity (large opposite-sign endpoints).\n  bool crossed = (tl > 1e10 && th < -1e10) || (tl < -1e10 && th > 1e10);\n  vec2 r = (pole || crossed) ? IV_ENTIRE : vec2(tl, th);\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\n// asin: domain [\u22121, 1]. Fully outside \u2192 empty; straddling clamps to the valid\n// sub-range. Monotonic increasing.\nvec2 _iv_asin(vec2 a) {\n  vec2 r = vec2(asin(max(a.x, -1.0)), asin(min(a.y, 1.0)));\n  r = (a.x > 1.0 || a.y < -1.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\n// acos: domain [\u22121, 1], monotonic decreasing (bounds swap).\nvec2 _iv_acos(vec2 a) {\n  vec2 r = vec2(acos(min(a.y, 1.0)), acos(max(a.x, -1.0)));\n  r = (a.x > 1.0 || a.y < -1.0) ? IV_EMPTY : r;\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_atan(vec2 a) {\n  return _iv_guard1(_iv_clamp(vec2(atan(a.x), atan(a.y))), a);\n}\n\n// \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\n// Bounded jump-discontinuity functions return the TIGHT value-range enclosure\n// (sound, and excludable when the range misses 0) rather than `entire` \u2014 only\n// genuine poles are entire. Per the Option-A division of labor, the CPU still\n// classifies the discontinuity on the (kept) live cells; the GPU only needs a\n// sound bound for the exclusion test. These functions are monotone, so the\n// enclosure is just [f(lo), f(hi)] unless noted.\n\nvec2 _iv_floor(vec2 a) { return _iv_guard1(_iv_clamp(vec2(floor(a.x), floor(a.y))), a); }\nvec2 _iv_ceil(vec2 a) { return _iv_guard1(_iv_clamp(vec2(ceil(a.x), ceil(a.y))), a); }\nvec2 _iv_round(vec2 a) { return _iv_guard1(_iv_clamp(vec2(floor(a.x + 0.5), floor(a.y + 0.5))), a); }\nvec2 _iv_trunc(vec2 a) { return _iv_guard1(_iv_clamp(vec2(trunc(a.x), trunc(a.y))), a); }\nvec2 _iv_sign(vec2 a) { return _iv_guard1(vec2(sign(a.x), sign(a.y)), a); }\n\nvec2 _iv_heaviside(vec2 a) {\n  float hl = a.x < 0.0 ? 0.0 : (a.x > 0.0 ? 1.0 : 0.5);\n  float hh = a.y < 0.0 ? 0.0 : (a.y > 0.0 ? 1.0 : 0.5);\n  return _iv_guard1(vec2(hl, hh), a);\n}\n\n// fract(x) = x \u2212 floor(x): continuous within an integer cell, sawtooth across\n// one (\u2192 full [0, 1] range).\nvec2 _iv_fract(vec2 a) {\n  float fl = floor(a.x);\n  vec2 r = (fl == floor(a.y)) ? vec2(a.x - fl, a.y - fl) : vec2(0.0, 1.0);\n  return _iv_guard1(_iv_clamp(r), a);\n}\n\nvec2 _iv_min(vec2 a, vec2 b) {\n  return _iv_guard2(_iv_clamp(vec2(min(a.x, b.x), min(a.y, b.y))), a, b);\n}\nvec2 _iv_max(vec2 a, vec2 b) {\n  return _iv_guard2(_iv_clamp(vec2(max(a.x, b.x), max(a.y, b.y))), a, b);\n}\n\n// mod(x, y) = x \u2212 y\u00B7floor(x/y). A modulus straddling 0 is a pole \u2192 entire. For\n// a constant (point) modulus the fast path is exact; otherwise compose (the\n// tight floor keeps it sound).\nvec2 _iv_mod(vec2 a, vec2 b) {\n  if (b.x <= 0.0 && b.y >= 0.0) return _iv_guard2(IV_ENTIRE, a, b);\n  if (b.x == b.y) {\n    float p = abs(b.x);\n    float flo = floor(a.x / p);\n    vec2 r = (flo == floor(a.y / p)) ? vec2(a.x - p * flo, a.y - p * flo)\n                                     : vec2(0.0, p);\n    return _iv_guard2(_iv_clamp(r), a, b);\n  }\n  return _iv_sub(a, _iv_mul(b, _iv_floor(_iv_div(a, b))));\n}\n";
+/**
+ * GLSL interval-arithmetic compilation target. Reuses `GLSLTarget`'s shader
+ * assembly; swaps in the interval function table, the `vec2` point-interval
+ * number/var hooks, and the `_iv_*` preamble.
+ */
+export declare class IntervalGLSLTarget extends GLSLTarget {
+    protected readonly languageId = "interval-glsl";
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions<Expression>;
+    getConstants(): Record<string, string>;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    /**
+     * 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: Expression, options?: {
+        version?: string;
+        precision?: string;
+    }): string;
+}

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,6 +1,6 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
-import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
+import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc, sinIntegral, cosIntegral, expIntegralEi, logIntegral, erfi, agm, ellipticK, ellipticE, ellipticEIncomplete, ellipticF, ellipticPiComplete, ellipticPiIncomplete, hypergeometric2F1, hypergeometric1F1 } from '../numerics/special-functions';
 import { choose } from '../boxed-expression/expand';
 import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult, ComplexResult } from './types';
@@ -68,6 +68,20 @@ export declare class ComputeEngineFunction extends Function {
         sinc: typeof sinc;
         fresnelS: typeof fresnelS;
         fresnelC: typeof fresnelC;
+        sinIntegral: typeof sinIntegral;
+        cosIntegral: typeof cosIntegral;
+        expIntegralEi: typeof expIntegralEi;
+        logIntegral: typeof logIntegral;
+        erfi: typeof erfi;
+        agm: typeof agm;
+        ellipticK: typeof ellipticK;
+        ellipticE: typeof ellipticE;
+        ellipticEIncomplete: typeof ellipticEIncomplete;
+        ellipticF: typeof ellipticF;
+        ellipticPiComplete: typeof ellipticPiComplete;
+        ellipticPiIncomplete: typeof ellipticPiIncomplete;
+        hypergeometric2F1: typeof hypergeometric2F1;
+        hypergeometric1F1: typeof hypergeometric1F1;
         mandelbrot: (c: number | {
             re: number;
             im: number;
@@ -258,6 +272,20 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         sinc: typeof sinc;
         fresnelS: typeof fresnelS;
         fresnelC: typeof fresnelC;
+        sinIntegral: typeof sinIntegral;
+        cosIntegral: typeof cosIntegral;
+        expIntegralEi: typeof expIntegralEi;
+        logIntegral: typeof logIntegral;
+        erfi: typeof erfi;
+        agm: typeof agm;
+        ellipticK: typeof ellipticK;
+        ellipticE: typeof ellipticE;
+        ellipticEIncomplete: typeof ellipticEIncomplete;
+        ellipticF: typeof ellipticF;
+        ellipticPiComplete: typeof ellipticPiComplete;
+        ellipticPiIncomplete: typeof ellipticPiIncomplete;
+        hypergeometric2F1: typeof hypergeometric2F1;
+        hypergeometric1F1: typeof hypergeometric1F1;
         mandelbrot: (c: number | {
             re: number;
             im: number;

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation

package/dist/types/compute-engine/compilation/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Source code in the target language
  */
@@ -132,7 +132,21 @@ export interface CompilationOptions<Expr = unknown> {
     operators?: Partial<CompiledOperators> | ((op: MathJsonSymbol) => [op: string, prec: number] | undefined);
     /** Custom function implementations */
     functions?: Record<MathJsonSymbol, TargetSource | Function>;
-    /** Variable bindings */
+    /**
+     * Map a symbol to the target-language source emitted for it (e.g. a GLSL
+     * uniform name `{ a: 'u_var_a' }`, or a JS literal `{ a: 5 }`).
+     *
+     * A `vars`-mapped symbol is **never constant-folded**, even when the symbol
+     * has an assigned value in the engine (`ce.assign('a', …)`). The mapping
+     * always wins, so the generated code keeps referencing the mapped
+     * identifier — a per-frame uniform / argument write updates the result
+     * without recompiling. This is a guaranteed contract.
+     *
+     * A symbol that is *not* mapped here but *is* known to the engine (an
+     * assigned value or a declared constant) is folded into the generated code,
+     * matching `evaluate()` and `expr.unknowns`. A genuinely free symbol (no
+     * mapping, no value) is emitted through the target's free-symbol plumbing.
+     */
     vars?: Record<MathJsonSymbol, TargetSource>;
     /** Additional imports/libraries to include */
     imports?: unknown[];
@@ -232,6 +246,44 @@ export type CompilationResult<T extends string = string, R = number | ComplexRes
     success: boolean;
     /** Generated source code */
     code: string;
+    /**
+     * Identifiers the generated `code` references that the caller must supply at
+     * run time (JS vars-object keys / GLSL uniforms) for the result to be
+     * self-contained.
+     *
+     * These are the expression's free symbols *as the generated code sees them*:
+     * symbols with no value in the engine, after assigned values and declared
+     * constants are folded in (so an assigned symbol is **not** listed — its
+     * value is inlined, matching `evaluate()`), and after bound variables (lambda
+     * parameters, `Sum`/`Product`/`Integrate`/`Loop` indices, `Block` locals) are
+     * excluded. A symbol supplied through the `vars` option is always listed —
+     * the mapping makes it an external input.
+     *
+     * Populated by the built-in targets on a successful compile. Use it instead
+     * of `expr.unknowns` when building a uniforms / vars mapping: unlike
+     * `unknowns`, it is guaranteed consistent with what the code actually
+     * references (including symbols reachable only through a folded value).
+     */
+    freeSymbols?: string[];
+    /**
+     * Operator heads in the expression that this target cannot lower — they have
+     * no operator or function mapping and are not one of the structural forms the
+     * compiler handles directly. An empty array means every operator was
+     * lowerable.
+     *
+     * On the built-in `LanguageTarget.compile` paths a genuinely unsupported
+     * operator throws (so the engine-level `compile()` can fall back to
+     * interpretation); this field lets a caller detect the condition
+     * **declaratively** — it is populated on the engine-level `compile()` result
+     * (including its `success: false` fallback) and on successful direct-target
+     * compiles (where it is `[]`).
+     */
+    unsupported?: string[];
+    /**
+     * When `success` is `false`, a human-readable reason the expression could not
+     * be compiled to the target (e.g. `Unknown operator \`SinIntegral\``).
+     */
+    error?: string;
     /**
      * Library/helper code that must be included before the compiled `code`.
      *

package/dist/types/compute-engine/compilation/wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/engine-assumptions.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

package/dist/types/compute-engine/engine-cache.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

package/dist/types/compute-engine/engine-common-symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

package/dist/types/compute-engine/engine-compilation-targets.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

package/dist/types/compute-engine/engine-configuration-lifecycle.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

package/dist/types/compute-engine/engine-declarations.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

package/dist/types/compute-engine/engine-expression-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BigDecimal } from '../big-decimal';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

package/dist/types/compute-engine/engine-extension-contracts.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

package/dist/types/compute-engine/engine-library-bootstrap.d.ts

@@ -1,3 +1,3 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

package/dist/types/compute-engine/engine-numeric-configuration.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _precision;

package/dist/types/compute-engine/engine-runtime-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

package/dist/types/compute-engine/engine-scope.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;
 export declare function pushEvalContext(ce: IComputeEngine, scope: Scope, name?: string): void;

package/dist/types/compute-engine/engine-sequences.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

package/dist/types/compute-engine/engine-simplification-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * Internal holder for a rule array and its cache-staleness marker.
  *

package/dist/types/compute-engine/engine-startup-coordinator.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

package/dist/types/compute-engine/engine-type-resolver.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

package/dist/types/compute-engine/engine-validation-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

package/dist/types/compute-engine/free-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';

package/dist/types/compute-engine/function-properties/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { Expression, ExpressionInput } from '../types-expression';
 /** A single analytic-property record for an operator. The MathJSON fields are
  * raw (as translated from Fungrim); box them with `ce.expr` to query. */

package/dist/types/compute-engine/function-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/fungrim/loader.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { FungrimLoadOptions, FungrimLoadReport, FungrimRuleData } from './types';
 /** The compiled artifact (the whole slice, bundled as JSON). */
 export declare const FUNGRIM_CORE: FungrimRuleData;

package/dist/types/compute-engine/fungrim/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { BoxedSubstitution } from '../types-serialization';
 /** Raw MathJSON — the artifact is plain JSON. */
 export type FungrimMathJson = unknown;

package/dist/types/compute-engine/global-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

package/dist/types/compute-engine/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -550,6 +550,15 @@ export declare class ComputeEngine implements IComputeEngine {
         details?: boolean;
         maxDepth?: number;
     }): void;
+    /** Stack of parameter-name sets active while canonicalizing function bodies.
+     * @internal */
+    private _shadowedParameterStack;
+    /** @internal */
+    _pushShadowedParameters(names: ReadonlyArray<string>): void;
+    /** @internal */
+    _popShadowedParameters(): void;
+    /** @internal */
+    _isShadowedParameter(name: string): boolean;
     /**
      * Use `ce.expr(name)` instead
      * @internal */

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

package/dist/types/compute-engine/interval/elementary.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary

package/dist/types/compute-engine/interval/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations

package/dist/types/compute-engine/interval/trigonometric.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

package/dist/types/compute-engine/interval/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

package/dist/types/compute-engine/interval/util.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

package/dist/types/compute-engine/latex-syntax/dictionary/default-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Default LaTeX dictionary assembly.
  *
  * This file imports all individual domain dictionaries and assembles them

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-colors.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 /**
  * LaTeX dictionary for color constructors and conversions.
  *

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;
 export declare const DELIMITERS_SHORTHAND: {
     '(': string;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import type { MathJsonExpression } from '../../../math-json';
 export declare const DEFINITIONS_LOGIC: LatexDictionary;
 export declare function parseQuantifier(kind: 'NotForAll' | 'NotExists' | 'ForAll' | 'Exists' | 'ExistsUnique'): (parser: Parser, terminator?: Readonly<Terminator>) => MathJsonExpression | null;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-relational-operators.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-statistics.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,3 +1,3 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.60.0 */
+/* 0.61.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-units.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * LaTeX dictionary entries for parsing and serializing physical quantities
  * with units.
  *

package/dist/types/compute-engine/latex-syntax/dictionary/definitions.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { LatexDictionaryEntry } from '../types';
 export type { CommonEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPrefixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary, } from './indexed-types';
 import type { IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary } from './indexed-types';

package/dist/types/compute-engine/latex-syntax/dictionary/indexed-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Type definitions for the indexed LaTeX dictionary.
  *
  * These are separated from definitions.ts to break a circular dependency:

package/dist/types/compute-engine/latex-syntax/latex-syntax.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Standalone LaTeX <-> MathJSON parsing and serialization.
  *
  * This module provides a `LatexSyntax` class and free-standing `parse()` /

package/dist/types/compute-engine/latex-syntax/parse-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * Number parsing extracted from the _Parser class for modularity.
  *
  * All functions take a `Parser` interface and a `NumberFormatTokens` config

package/dist/types/compute-engine/latex-syntax/parse-symbol.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { Parser } from './types';
 /** For error handling, if we have a symbol prefix, assume
  * the symbol is invalid (it would have been captured by

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { BoxedType } from '../../common/type/boxed-type';

package/dist/types/compute-engine/latex-syntax/serialize-dms.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
  * DMS (Degrees-Minutes-Seconds) serialization utilities.
  */
 export interface DMSComponents {

package/dist/types/compute-engine/latex-syntax/serialize-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.60.0 */
+/* 0.61.0 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string