@cortex-js/compute-engine 0.51.0 → 0.52.0

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

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

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

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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

@@ -0,0 +1,18 @@
+/* 0.52.0 */
+type ComplexResult = {
+    re: number;
+    im: number;
+};
+type CompileFn = (expr: Expression) => {
+    run?: ((vars: Record<string, number>) => number | ComplexResult) | undefined;
+};
+/** @internal */
+export declare function _setCompile(fn: CompileFn): void;
+/**
+ * Stochastic equality check: evaluate both expressions at random sample points
+ * and compare results (both real and imaginary parts). Returns `true` if they
+ * agree at all informative points, `false` if they disagree, or `undefined`
+ * if no informative points were found.
+ */
+export declare function stochasticEqual(a: Expression, b: Expression): boolean | undefined;
+export {};

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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,9 +1,10 @@
-/* 0.51.0 */
+/* 0.52.0 */
+import type { NumericValue } from '../numeric-value/types';
 /** Preferred guard for runtime expressions. */
 export declare function isExpression(x: unknown): x is Expression;
 export declare function isNumber(expr: Expression | null | undefined): expr is Expression & NumberLiteralInterface;
-export declare function isSymbol(expr: Expression | null | undefined): expr is Expression & SymbolInterface;
-export declare function isFunction(expr: Expression | null | undefined): expr is Expression & FunctionInterface;
+export declare function isSymbol(expr: Expression | null | undefined, name?: string): expr is Expression & SymbolInterface;
+export declare function isFunction(expr: Expression | null | undefined, operator?: string): expr is Expression & FunctionInterface;
 export declare function isString(expr: Expression | null | undefined): expr is Expression & StringInterface;
 export declare function isTensor(expr: Expression | null | undefined): expr is Expression & TensorInterface;
 /** @deprecated Use `isExpression()` instead. */
@@ -11,9 +12,9 @@ export declare function isBoxedExpression(x: unknown): x is Expression;
 /** @deprecated Use `isNumber()` instead. */
 export declare function isBoxedNumber(expr: Expression | null | undefined): expr is Expression & NumberLiteralInterface;
 /** @deprecated Use `isSymbol()` instead. */
-export declare function isBoxedSymbol(expr: Expression | null | undefined): expr is Expression & SymbolInterface;
+export declare function isBoxedSymbol(expr: Expression | null | undefined, name?: string): expr is Expression & SymbolInterface;
 /** @deprecated Use `isFunction()` instead. */
-export declare function isBoxedFunction(expr: Expression | null | undefined): expr is Expression & FunctionInterface;
+export declare function isBoxedFunction(expr: Expression | null | undefined, operator?: string): expr is Expression & FunctionInterface;
 /** @deprecated Use `isString()` instead. */
 export declare function isBoxedString(expr: Expression | null | undefined): expr is Expression & StringInterface;
 /** @deprecated Use `isTensor()` instead. */
@@ -21,11 +22,17 @@ export declare function isBoxedTensor(expr: Expression | null | undefined): expr
 export declare function isDictionary(expr: Expression | null | undefined): expr is Expression & DictionaryInterface;
 export declare function isCollection(expr: Expression | null | undefined): expr is Expression & CollectionInterface;
 export declare function isIndexedCollection(expr: Expression | null | undefined): expr is Expression & IndexedCollectionInterface;
+/**
+ * Return the numeric value if `expr` is a number literal, otherwise `undefined`.
+ *
+ * Convenience helper that combines `isNumber()` with `.numericValue` access.
+ */
+export declare function numericValue(expr: Expression | null | undefined): number | NumericValue | undefined;
 /**
  * Get the symbol name if `expr` is a symbol expression, otherwise `undefined`.
  *
  * Convenience helper that combines `isSymbol()` with `.symbol` access
- * so callers can write `sym(expr) === 'Pi'` instead of the more verbose
- * `isSymbol(expr) && expr.symbol === 'Pi'`.
+ * so callers can write `sym(expr) === 'Pi'` instead of
+ * `isSymbol(expr, 'Pi')`.
  */
 export declare function sym(expr: Expression | null | undefined): string | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -16,6 +16,31 @@ export declare class BaseCompiler {
      * Compile a block expression
      */
     private static compileBlock;
+    /**
+     * Compile a Loop expression with Element(index, Range(lo, hi)) indexing.
+     * Generates: (() => { for (let i = lo; i <= hi; i++) { body } })()
+     *
+     * The loop counter is always a raw number. For targets that wrap numeric
+     * values (e.g. interval-js wraps with `_IA.point()`), references to the
+     * loop index inside the body are wrapped via `target.number`.
+     */
+    private static compileForLoop;
+    /**
+     * Compile a loop body expression as statements (not wrapped in IIFE).
+     * Handles Break, Continue, Return as statements, and If as if-else when
+     * branches contain control flow.
+     */
+    private static compileLoopBody;
+    /**
+     * Create a target that compiles conditions as plain JS booleans.
+     * Used inside `compileLoopBody` so that `if (cond)` gets a real boolean,
+     * not an interval result object (which would always be truthy).
+     *
+     * Overrides comparison and logical operators to use plain JS, and
+     * numeric values/variables to use raw numbers (the loop counter is
+     * already a plain number).
+     */
+    private static scalarConditionTarget;
     /**
      * Compile loop constructs (Sum/Product)
      */

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

@@ -1,8 +1,8 @@
-/* 0.51.0 */
+/* 0.52.0 */
 import type { Expression, JSSource } from '../global-types';
 import type { CompileTarget, CompilationResult } from './types';
-type CompileExpressionOptions = {
-    to?: string;
+type CompileExpressionOptions<T extends string = string> = {
+    to?: T;
     target?: CompileTarget<Expression>;
     operators?: Partial<Record<MathJsonSymbol, [op: string, prec: number]>> | ((op: MathJsonSymbol) => [op: string, prec: number] | undefined);
     functions?: Record<MathJsonSymbol, JSSource | ((...args: unknown[]) => unknown)>;
@@ -10,6 +10,7 @@ type CompileExpressionOptions = {
     imports?: unknown[];
     preamble?: string;
     fallback?: boolean;
+    realOnly?: boolean;
 };
 /**
  * Compile a boxed expression.
@@ -17,9 +18,14 @@ type CompileExpressionOptions = {
  * Returns a `CompilationResult` with the generated source code and,
  * for JS-executable targets, a `run` function.
  *
+ * When `realOnly` is true, the return type of `run` is narrowed to `number`.
+ *
  * If the expression cannot be compiled, falls back to interpretation
  * (success: false, run: applicableN1) unless `options.fallback` is false,
  * in which case it throws.
  */
-export declare function compile(expr: Expression, options?: CompileExpressionOptions): CompilationResult;
+export declare function compile<T extends string = 'javascript'>(expr: Expression, options: CompileExpressionOptions<T> & {
+    realOnly: true;
+}): CompilationResult<T, number>;
+export declare function compile<T extends string = 'javascript'>(expr: Expression, options?: CompileExpressionOptions<T>): CompilationResult<T>;
 export {};

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
  * GLSL interval arithmetic compilation target
  *
  * Compiles mathematical expressions to GLSL code using interval arithmetic
@@ -24,7 +24,7 @@ export declare class IntervalGLSLTarget implements LanguageTarget<Expression> {
      */
     getLibrary(): string;
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'interval-glsl'>;
     /**
      * Compile an expression to GLSL interval code string.
      */

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic
@@ -8,6 +8,7 @@
  */
 import type { Expression } from '../global-types';
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
+import type { Interval, IntervalResult } from '../interval/types';
 /**
  * JavaScript function that wraps compiled interval arithmetic code.
  *
@@ -54,7 +55,20 @@ export declare class ComputeEngineIntervalFunction extends Function {
         max: typeof import("../interval").max;
         mod: typeof import("../interval").mod;
         remainder: typeof import("../interval").remainder;
+        heaviside: typeof import("../interval").heaviside;
         sign: typeof import("../interval").sign;
+        gamma: typeof import("../interval").gamma;
+        gammaln: typeof import("../interval").gammaln;
+        factorial: typeof import("../interval").factorial;
+        factorial2: typeof import("../interval").factorial2;
+        binomial: typeof import("../interval/elementary").binomial;
+        gcd: typeof import("../interval/elementary").gcd;
+        lcm: typeof import("../interval/elementary").lcm;
+        chop: typeof import("../interval/elementary").chop;
+        erf: typeof import("../interval/elementary").erf;
+        erfc: typeof import("../interval/elementary").erfc;
+        exp2: typeof import("../interval/elementary").exp2;
+        hypot: typeof import("../interval/elementary").hypot;
         sin: typeof import("../interval").sin;
         cos: typeof import("../interval").cos;
         tan: typeof import("../interval").tan;
@@ -80,6 +94,9 @@ export declare class ComputeEngineIntervalFunction extends Function {
         acoth: typeof import("../interval").acoth;
         acsch: typeof import("../interval").acsch;
         asech: typeof import("../interval").asech;
+        sinc: typeof import("../interval").sinc;
+        fresnelS: typeof import("../interval").fresnelS;
+        fresnelC: typeof import("../interval").fresnelC;
         less: typeof import("../interval").less;
         lessEqual: typeof import("../interval").lessEqual;
         greater: typeof import("../interval").greater;
@@ -101,5 +118,5 @@ export declare class IntervalJavaScriptTarget implements LanguageTarget<Expressi
     getOperators(): CompiledOperators;
     getFunctions(): CompiledFunctions<Expression>;
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'interval-js', IntervalResult | Interval>;
 }

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
  * WGSL interval arithmetic compilation target
  *
  * Compiles mathematical expressions to WGSL code using interval arithmetic
@@ -28,7 +28,7 @@ export declare class IntervalWGSLTarget implements LanguageTarget<Expression> {
      */
     getLibrary(): string;
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'interval-wgsl'>;
     /**
      * Compile an expression to WGSL interval code string.
      */

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

@@ -1,6 +1,6 @@
-/* 0.51.0 */
+/* 0.52.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 } 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 } 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 } from './types';
@@ -23,6 +23,7 @@ export declare class ComputeEngineFunction extends Function {
         factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -53,6 +54,9 @@ export declare class ComputeEngineFunction extends Function {
         besselK: typeof besselK;
         airyAi: typeof airyAi;
         airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
         binomial: typeof choose;
         fibonacci: typeof fibonacci;
         csin: (z: any) => {
@@ -187,6 +191,7 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -217,6 +222,9 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         besselK: typeof besselK;
         airyAi: typeof airyAi;
         airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
         binomial: typeof choose;
         fibonacci: typeof fibonacci;
         csin: (z: any) => {
@@ -339,7 +347,7 @@ export declare class JavaScriptTarget implements LanguageTarget<Expression> {
     getOperators(): CompiledOperators;
     getFunctions(): CompiledFunctions<Expression>;
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'javascript'>;
 }
 /**
  * Compute the nth Fibonacci number using iterative doubling.

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation
@@ -24,7 +24,7 @@ export declare class PythonTarget implements LanguageTarget<Expression> {
      *
      * Returns Python code as a string. To execute it, use Python runtime.
      */
-    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult<'python'>;
     /**
      * Compile an expression to Python source code
      *

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
 /**
  * Source code in the target language
  */
@@ -57,7 +57,7 @@ export interface LanguageTarget<Expr = unknown> {
     /** Create a CompileTarget for this language */
     createTarget(options?: Partial<CompileTarget<Expr>>): CompileTarget<Expr>;
     /** Compile an expression to this language */
-    compile(expr: Expr, options?: CompilationOptions<Expr>): CompilationResult;
+    compile(expr: Expr, options?: CompilationOptions<Expr>): CompilationResult<string, unknown>;
 }
 /**
  * Options for compilation
@@ -132,13 +132,96 @@ export interface CompilationOptions<Expr = unknown> {
     imports?: unknown[];
     /** Additional preamble code */
     preamble?: string;
+    /**
+     * When true, complex results (`{ re, im }`) are converted to real numbers:
+     * - If the imaginary part is zero, the real part is returned
+     * - Otherwise, `NaN` is returned
+     *
+     * This avoids object allocations for callers that only need real-valued
+     * results (e.g., plotting).
+     */
+    realOnly?: boolean;
+}
+/**
+ * Built-in targets that produce an executable `run` function.
+ */
+export type ExecutableTarget = 'javascript' | 'interval-js';
+/**
+ * Result of a complex number computation: `{ re, im }`.
+ */
+export type ComplexResult = {
+    re: number;
+    im: number;
+};
+/**
+ * Runner for compiled expressions — called with a variables object.
+ *
+ * ```typescript
+ * result.run({ x: 0.5, y: 1.0 })
+ * ```
+ */
+export type ExpressionRunner<R = number | ComplexResult> = (vars: Record<string, number>) => R;
+/**
+ * Runner for compiled lambda (`Function`) expressions — called with
+ * positional arguments.
+ *
+ * ```typescript
+ * result.run(0.5, 1.0)
+ * ```
+ */
+export type LambdaRunner<R = number | ComplexResult> = (...args: number[]) => R;
+/**
+ * Overloaded callable that accepts both calling conventions.
+ *
+ * Supports two calling styles:
+ * - **Expression**: `run({ x: 0.5 })` — pass a variables object
+ * - **Lambda**: `run(0.5, 1.0)` — pass positional arguments
+ *
+ * Check `calling` on the `CompilationResult` to know which convention
+ * the compiled expression actually uses.
+ */
+export interface CompiledRunner<R = number | ComplexResult> {
+    /** Call with a variables object (for compiled expressions) */
+    (vars: Record<string, number>): R;
+    /** Call with positional arguments (for compiled lambda expressions) */
+    (...args: number[]): R;
 }
 /**
- * Result of compiling an expression
+ * Result of compiling an expression.
+ *
+ * Two type parameters control the shape:
+ * - `T` — the target name. For executable targets (`'javascript'` |
+ *   `'interval-js'`), `run` and `calling` are guaranteed present.
+ * - `R` — the return type of `run`. Defaults to `number | ComplexResult`.
+ *   Pass `number` when `realOnly: true`.
+ *
+ * The `calling` field indicates which convention `run` uses:
+ * - `'expression'` — call with a vars object: `run({ x: 0.5 })`
+ * - `'lambda'` — call with positional args: `run(0.5, 1.0)`
+ *
+ * @example
+ * ```typescript
+ * // run is guaranteed, may return complex
+ * const js = compile(expr);
+ * js.run({ x: 0.5 });
+ *
+ * // run is guaranteed, returns number only
+ * const real = compile(expr, { realOnly: true });
+ * real.run({ x: 0.5 }); // number
+ *
+ * // check calling convention
+ * if (result.calling === 'lambda') {
+ *   result.run(0.5, 1.0);
+ * }
+ *
+ * // no run (source-only target)
+ * const py = compile(expr, { to: 'python' });
+ * py.code; // string
+ * ```
  */
-export interface CompilationResult {
+export type CompilationResult<T extends string = string, R = number | ComplexResult> = {
     /** Target language name */
-    target: string;
+    target: T;
     /** Whether compilation succeeded (vs falling back to interpretation) */
     success: boolean;
     /** Generated source code */
@@ -154,12 +237,15 @@ export interface CompilationResult {
      * target's `compileShaderFunction()` method directly.
      */
     preamble?: string;
-    /** Executable function (present for JS-executable targets only) */
-    run?: (...args: (number | {
-        re: number;
-        im: number;
-    })[]) => number | {
-        re: number;
-        im: number;
-    };
-}
+    /**
+     * How `run` should be called (present only for executable targets).
+     * - `'expression'` — call with a vars object: `run({ x: 0.5 })`
+     * - `'lambda'` — call with positional args: `run(0.5, 1.0)`
+     */
+    calling?: 'expression' | 'lambda';
+    /** Executable function (present for JS-executable targets only). */
+    run?: CompiledRunner<R>;
+} & (T extends ExecutableTarget ? {
+    calling: 'expression' | 'lambda';
+    run: CompiledRunner<R>;
+} : {});

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
 import { Decimal } from 'decimal.js';
 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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.0 */
 import type { IComputeEngine, Scope, EvalContext } from './global-types';
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;

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

@@ -1,4 +1,4 @@
-/* 0.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.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.51.0 */
+/* 0.52.0 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;