@cortex-js/compute-engine 0.52.0 → 0.53.0

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { IComputeEngine as ComputeEngine, Expression, JsonSerializationOptions } from '../global-types';
 interface ProductLike {
     asRationalExpression(): Expression;

package/dist/types/compute-engine/boxed-expression/sgn.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare function sgn(expr: Expression): Sign | undefined;
 /**
  * Sign `s` is > 0.

package/dist/types/compute-engine/boxed-expression/simplify.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 /**
  * Solve a system of linear equations.
  *

package/dist/types/compute-engine/boxed-expression/solve.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * MathJsonExpression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/boxed-expression/stochastic-equal.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 type ComplexResult = {
     re: number;
     im: number;

package/dist/types/compute-engine/boxed-expression/trigonometry.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: Expression | undefined): Expression | undefined;
 export declare function evalTrig(name: string, op: Expression | undefined): Expression | undefined;

package/dist/types/compute-engine/boxed-expression/type-guards.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { NumericValue } from '../numeric-value/types';
 /** Preferred guard for runtime expressions. */
 export declare function isExpression(x: unknown): x is Expression;

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { Expression, JSSource } from '../global-types';
 import type { CompileTarget, CompilationResult } from './types';
 type CompileExpressionOptions<T extends string = string> = {

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

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

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -35,12 +35,24 @@ export declare function compileGPUMatrix(args: ReadonlyArray<Expression>, compil
  * Uses reflection formula for z < 0.5 and Lanczos for z >= 0.5.
  * Valid for both GLSL and WGSL (uses standard math builtins).
  */
-export declare const GPU_GAMMA_PREAMBLE = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  if (z < 0.5) {\n    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));\n  }\n  z -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (z + 1.0);\n  x += -1259.1392167224028 / (z + 2.0);\n  x += 771.32342877765313 / (z + 3.0);\n  x += -176.61502916214059 / (z + 4.0);\n  x += 12.507343278686905 / (z + 5.0);\n  x += -0.13857109526572012 / (z + 6.0);\n  x += 9.9843695780195716e-6 / (z + 7.0);\n  x += 1.5056327351493116e-7 / (z + 8.0);\n  float t = z + 7.5;\n  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+export declare const GPU_GAMMA_PREAMBLE = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)\n  float w = z;\n  if (z < 0.5) w = 1.0 - z;\n  w -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (w + 1.0);\n  x += -1259.1392167224028 / (w + 2.0);\n  x += 771.32342877765313 / (w + 3.0);\n  x += -176.61502916214059 / (w + 4.0);\n  x += 12.507343278686905 / (w + 5.0);\n  x += -0.13857109526572012 / (w + 6.0);\n  x += 9.9843695780195716e-6 / (w + 7.0);\n  x += 1.5056327351493116e-7 / (w + 8.0);\n  float t = w + 7.5;\n  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) return PI / (sin(PI * z) * g);\n  return g;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
 /**
  * GPU error function using Abramowitz & Stegun approximation.
  * Maximum error: |epsilon(x)| <= 1.5e-7.
  */
 export declare const GPU_ERF_PREAMBLE = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+/**
+ * Fractal preamble (GLSL syntax).
+ *
+ * Smooth escape-time iteration for Mandelbrot and Julia sets.
+ * Both functions return a normalized float in [0, 1] with smooth coloring
+ * (log2(log2(|z|²)) formula) to avoid banding.
+ */
+export declare const GPU_FRACTAL_PREAMBLE_GLSL = "\nfloat _fractal_mandelbrot(vec2 c, int maxIter) {\n  vec2 z = vec2(0.0, 0.0);\n  for (int i = 0; i < maxIter; i++) {\n    z = vec2(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0)\n      return clamp((float(i) - log2(log2(dot(z, z))) + 4.0) / float(maxIter), 0.0, 1.0);\n  }\n  return 1.0;\n}\n\nfloat _fractal_julia(vec2 z, vec2 c, int maxIter) {\n  for (int i = 0; i < maxIter; i++) {\n    z = vec2(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0)\n      return clamp((float(i) - log2(log2(dot(z, z))) + 4.0) / float(maxIter), 0.0, 1.0);\n  }\n  return 1.0;\n}\n";
+/**
+ * Fractal preamble (WGSL syntax).
+ */
+export declare const GPU_FRACTAL_PREAMBLE_WGSL = "\nfn _fractal_mandelbrot(c: vec2f, maxIter: i32) -> f32 {\n  var z = vec2f(0.0, 0.0);\n  for (var i: i32 = 0; i < maxIter; i++) {\n    z = vec2f(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0) {\n      return clamp((f32(i) - log2(log2(dot(z, z))) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n  }\n  return 1.0;\n}\n\nfn _fractal_julia(z_in: vec2f, c: vec2f, maxIter: i32) -> f32 {\n  var z = z_in;\n  for (var i: i32 = 0; i < maxIter; i++) {\n    z = vec2f(z.x*z.x - z.y*z.y + c.x, 2.0*z.x*z.y + c.y);\n    if (dot(z, z) > 4.0) {\n      return clamp((f32(i) - log2(log2(dot(z, z))) + 4.0) / f32(maxIter), 0.0, 1.0);\n    }\n  }\n  return 1.0;\n}\n";
 /**
  * GPU color space conversion preamble (GLSL syntax).
  *

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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 { choose } from '../boxed-expression/expand';

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 /**
  * Source code in the target language
  */
@@ -71,8 +71,6 @@ export interface CompilationOptions<Expr = unknown> {
      * - `'glsl'` - Compile to GLSL (OpenGL Shading Language)
      * - `'wgsl'` - Compile to WGSL (WebGPU Shading Language)
      * - `'interval-js'` - Compile to JavaScript with interval arithmetic
-     * - `'interval-glsl'` - Compile to GLSL with interval arithmetic
-     * - `'interval-wgsl'` - Compile to WGSL with interval arithmetic
      *
      * Custom targets can be registered using `ce.registerCompilationTarget()`.
      *
@@ -229,12 +227,8 @@ export type CompilationResult<T extends string = string, R = number | ComplexRes
     /**
      * Library/helper code that must be included before the compiled `code`.
      *
-     * For shader targets (e.g. `interval-wgsl`, `interval-glsl`), this contains
-     * the interval arithmetic library (struct definitions, helper functions, etc.)
-     * that the compiled expression references.
-     *
-     * To produce a complete shader, concatenate `preamble + code` or use the
-     * target's `compileShaderFunction()` method directly.
+     * For targets like `interval-js`, this contains the interval arithmetic
+     * library (helper functions, etc.) that the compiled expression references.
      */
     preamble?: string;
     /**

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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';
@@ -7,7 +7,6 @@ export declare function declareSymbolValue(ce: IComputeEngine, name: MathJsonSym
 export declare function declareSymbolOperator(ce: IComputeEngine, name: string, def: OperatorDefinition, scope?: Scope): BoxedDefinition;
 export declare function getSymbolValue(ce: IComputeEngine, id: MathJsonSymbol): Expression | undefined;
 export declare function setSymbolValue(ce: IComputeEngine, id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
-export declare function setCurrentContextValue(ce: IComputeEngine, id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
 export declare function declareType(ce: IComputeEngine, name: string, type: BoxedType | Type | TypeString, { alias }?: {
     alias?: boolean;
 }): void;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import { Decimal } from 'decimal.js';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';
@@ -11,7 +11,7 @@ type SymbolHost = ComputeEngine & {
     strict: boolean;
     Nothing: Expression;
     lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
-    _declareSymbolValue(name: MathJsonSymbol, def: Partial<ValueDefinition>): BoxedDefinition;
+    _declareSymbolValue(name: MathJsonSymbol, def: Partial<ValueDefinition>, scope?: import('./global-types').Scope): BoxedDefinition;
     error(message: string | string[], where?: string): Expression;
 };
 type NumberHost = ComputeEngine & {

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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-latex-dictionary-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { LatexDictionaryEntry } from './latex-syntax/types';
 type DefaultDictionaryProvider = () => Readonly<LatexDictionaryEntry[]>;
 export declare class EngineLatexDictionaryState {

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { LatexDictionaryEntry, LibraryCategory } from './latex-syntax/types';
 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.52.0 */
+/* 0.53.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _bignum;

package/dist/types/compute-engine/engine-parse-entrypoint.d.ts

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import type { FormOption } from './types-serialization';
 export type ParseEntrypointOptions = Partial<ParseLatexOptions> & {

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

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

@@ -1,5 +1,4 @@
-/* 0.52.0 */
-import type { IComputeEngine, Scope, EvalContext } from './global-types';
+/* 0.53.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;
@@ -9,5 +8,3 @@ export declare function printStack(ce: IComputeEngine, options?: {
     details?: boolean;
     maxDepth?: number;
 }): void;
-export declare function lookupContext(ce: IComputeEngine, id: MathJsonSymbol): EvalContext | undefined;
-export declare function swapContext(ce: IComputeEngine, context: EvalContext): void;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 /**
  * Internal holder for simplification rules and their cache-staleness marker.
  *

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';
@@ -20,9 +20,9 @@ export declare function assign(id: string, value: AssignValue): void;
 export declare function assign(ids: {
     [id: string]: AssignValue;
 }): void;
-export declare function expand(expr: LatexString | ExpressionInput): Expression | null;
+export declare function expand(expr: LatexString | ExpressionInput): Expression;
 export declare function solve(expr: LatexString | ExpressionInput, vars?: string | Iterable<string> | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
-export declare function expandAll(expr: LatexString | ExpressionInput): Expression | null;
+export declare function expandAll(expr: LatexString | ExpressionInput): Expression;
 export declare function factor(expr: LatexString | ExpressionInput): Expression;
 export declare function compile<T extends string = 'javascript'>(expr: LatexString | ExpressionInput, options: Parameters<typeof compileExpr>[1] & {
     to?: T;

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS
@@ -11,27 +11,33 @@ import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scop
  * (e.g. `["Function", ["Block", ["Add", "_", 1]], "_"]`).
  *
  *
- * #### DURING BOXING (in makeLambda())
- *
- * During the boxing/canonicalization phase of a function
- * (`["Function"]` expression or operator of expression):
+ * #### DURING CANONICALIZATION (in canonicalFunctionLiteralArguments())
  *
  * 1/ If not a `["Function"]` expression, the expression is rewritten
  *    to a `["Function"]` expression with anonymous parameters
- * 2/ A new scope is created
- * 3/ The function parameters are declared in the scope
- * 4/ The function body is boxed in the context of the scope and the scope
- *    is associated with the function
+ * 2/ A `Block` scope is created
+ * 3/ The function parameters are declared in the Block's scope
+ * 4/ The function body is canonicalized in the context of the scope.
+ *    The Block's localScope captures the defining scope as its parent.
  *
  *
  * #### DURING EVALUATION (executing the result of makeLambda())
  *
- * 1/ The arguments are evaluated in the current scope
- * 2/ The context is swapped to the function scope
- * 3/ The function parameters are set to the value of the arguments
- * 4/ The function body is evaluated in the context of the function scope
- * 5/ The context is swapped back to the current scope
- * 6/ The result of the function body is returned
+ * 1/ The arguments are evaluated in the **calling** scope
+ * 2/ A fresh scope is created per call, with parent = the **defining**
+ *    scope (body.localScope.parent), giving true lexical scoping
+ * 3/ The function parameters are declared in the fresh scope
+ * 4/ body.localScope is temporarily re-parented to chain through the
+ *    fresh scope: bigOpScope → bodyScope → freshScope → capturedScope.
+ *    Param bindings in bodyScope (stale, from canonicalization) are
+ *    temporarily hidden so they don't shadow freshScope's values.
+ *    This lets nested scoped expressions (Sum, Product) find params
+ *    by walking up their static scope chain.
+ * 5/ The function body is evaluated in the context of the fresh scope
+ * 6/ If the result contains Function literals, they are rebound to
+ *    close over the fresh scope (closure capture)
+ * 7/ The fresh scope is discarded; body.localScope.parent is restored
+ * 8/ The result is returned
  *
  */
 /**
@@ -87,6 +93,19 @@ export declare function canonicalFunctionLiteralArguments(ce: ComputeEngine, ops
  * - the symbol for a function, e.g. `Sin`.
  */
 export declare function apply(fn: Expression, args: ReadonlyArray<Expression>): Expression;
+/**
+ * Evaluate a sequence of statements, handling Return/Break/Continue.
+ *
+ * Used by both:
+ * - `evaluateBlock` in control-structures.ts (Block evaluation handler)
+ * - `makeLambda` below (iterates body.ops directly instead of calling
+ *   body.evaluate(), because body is a Block whose _localScope has param
+ *   bindings from canonicalization — declared with type 'unknown' but no
+ *   value. If body.evaluate() were called, Block would push its _localScope
+ *   as the eval context, and lookup() would find those stale bindings
+ *   before reaching the freshScope where actual param values live.)
+ */
+export declare function evaluateStatements(ce: ComputeEngine, ops: Iterable<Expression>): Expression;
 /**
  * Return a lambda function, assuming a scoped environment has been
  * created and there is a single numeric argument

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -25,7 +25,6 @@ export { JavaScriptTarget } from './compilation/javascript-target';
 export { GLSLTarget } from './compilation/glsl-target';
 export { PythonTarget } from './compilation/python-target';
 export { IntervalJavaScriptTarget } from './compilation/interval-javascript-target';
-export { IntervalGLSLTarget } from './compilation/interval-glsl-target';
 export { BaseCompiler } from './compilation/base-compiler';
 import type { LanguageTarget } from './compilation/types';
 import { compile as _compile } from './compilation/compile-expression';
@@ -112,9 +111,8 @@ export declare class ComputeEngine implements IComputeEngine {
     /**
      * The stack of evaluation contexts.
      *
-     * An **evaluation context** contains bindings of symbols to their
-     * values, assumptions, and the matching scope.
-     *
+     * An **evaluation context** tracks the current lexical scope and
+     * assumptions. Symbol values are stored in their definitions, not here.
      */
     _evalContextStack: EvalContext[];
     /** The current evaluation context */
@@ -301,7 +299,7 @@ export declare class ComputeEngine implements IComputeEngine {
      * ```typescript
      * const ce = new ComputeEngine();
      * console.log(ce.listCompilationTargets());
-     * // → ['javascript', 'glsl', 'interval-js', 'interval-glsl']
+     * // → ['javascript', 'glsl', 'wgsl', 'interval-js']
      * ```
      */
     listCompilationTargets(): string[];
@@ -569,10 +567,7 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     _declareSymbolOperator(name: string, def: OperatorDefinition, scope?: Scope): BoxedDefinition;
     /**
-     *
-     * Create a new lexical scope and matching evaluation context and add it
-     * to the evaluation context stack.
-     *
+     * Push a new lexical scope (and its evaluation context) onto the stack.
      */
     pushScope(scope?: Scope, name?: string): void;
     /**
@@ -599,13 +594,6 @@ export declare class ComputeEngine implements IComputeEngine {
      * @internal
      */
     _setSymbolValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
-    /**
-     * Set a value directly in the current context's values map.
-     * This is used for assumptions so that the value is scoped to the current
-     * evaluation context and is automatically removed when the scope is popped.
-     * @internal
-     */
-    _setCurrentContextValue(id: MathJsonSymbol, value: Expression | boolean | number | undefined): void;
     /**
      * Declare a symbol in the current lexical scope: specify their type and
      * other attributes, including optionally a value.
@@ -725,15 +713,6 @@ export declare class ComputeEngine implements IComputeEngine {
         matches: OEISSequenceInfo[];
         terms: number[];
     }>;
-    /**
-     * Return an evaluation context in which the symbol is defined.
-     */
-    lookupContext(id: MathJsonSymbol): EvalContext | undefined;
-    /**  Find the context in the stack frame, and set the stack frame to
-     * it. This is used to evaluate expressions in the context of
-     * a different scope.
-     */
-    _swapContext(context: EvalContext): void;
     /**
      * Assign a value to a symbol in the current scope.
      * Use `undefined` to reset the symbol to no value.

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

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

@@ -1,4 +1,4 @@
-/* 0.52.0 */
+/* 0.53.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.52.0 */
+/* 0.53.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

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

@@ -1,2 +1,2 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.52.0 */
+/* 0.53.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;