@cortex-js/compute-engine 0.35.6 → 0.50.0

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

@@ -0,0 +1,25 @@
+/* 0.50.0 */
+import type { Expression, JSSource } from '../global-types';
+import type { CompileTarget, CompilationResult } from './types';
+type CompileExpressionOptions = {
+    to?: string;
+    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)>;
+    vars?: Record<MathJsonSymbol, JSSource>;
+    imports?: unknown[];
+    preamble?: string;
+    fallback?: boolean;
+};
+/**
+ * Compile a boxed expression.
+ *
+ * Returns a `CompilationResult` with the generated source code and,
+ * for JS-executable targets, a `run` function.
+ *
+ * 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 {};

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

@@ -1,63 +1,34 @@
-/* 0.35.6 */
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+/* 0.50.0 */
+import type { CompiledFunctions } from './types';
+import { GPUShaderTarget } from './gpu-target';
 /**
- * GLSL language target implementation
+ * GLSL (OpenGL Shading Language) compilation target.
+ *
+ * Extends the shared GPU base class with GLSL-specific function names,
+ * C-style function declarations, and `#version`-based shader structure.
  */
-export declare class GLSLTarget implements LanguageTarget {
-    getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions;
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    /**
-     * Compile to GLSL source code (not executable)
-     *
-     * GLSL doesn't run in JavaScript, so this returns source code as a string
-     * rather than an executable function.
-     */
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
-    /**
-     * Compile an expression to GLSL source code
-     *
-     * Returns the GLSL code as a string.
-     */
-    compile(expr: BoxedExpression, options?: CompilationOptions): string;
-    /**
-     * Create a complete GLSL function from an expression
-     *
-     * @param expr - The expression to compile
-     * @param functionName - Name of the GLSL function
-     * @param returnType - GLSL return type (e.g., 'float', 'vec3')
-     * @param parameters - Parameter declarations (e.g., [['x', 'float'], ['y', 'vec3']])
-     */
-    compileFunction(expr: BoxedExpression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
-    /**
-     * Create a complete GLSL shader from expressions
-     *
-     * @param options - Shader compilation options
-     */
+export declare class GLSLTarget extends GPUShaderTarget {
+    protected readonly languageId = "glsl";
+    protected getLanguageSpecificFunctions(): CompiledFunctions<Expression>;
+    compileFunction(expr: Expression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
     compileShader(options: {
-        /** Shader type: 'vertex' or 'fragment' */
         type: 'vertex' | 'fragment';
-        /** GLSL version (e.g., '300 es', '330', '450') */
         version?: string;
-        /** Input variables (attributes or varyings) */
         inputs?: Array<{
             name: string;
             type: string;
         }>;
-        /** Output variables */
         outputs?: Array<{
             name: string;
             type: string;
         }>;
-        /** Uniform variables */
         uniforms?: Array<{
             name: string;
             type: string;
         }>;
-        /** Main function body expressions */
         body: Array<{
             variable: string;
-            expression: BoxedExpression;
+            expression: Expression;
         }>;
     }): string;
 }

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

@@ -0,0 +1,50 @@
+/* 0.50.0 */
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
+/**
+ * GPU shader operators shared by GLSL and WGSL.
+ *
+ * Both languages use identical C-style operators for arithmetic,
+ * comparison, and logical operations.
+ */
+export declare const GPU_OPERATORS: CompiledOperators;
+/**
+ * GPU shader functions shared by GLSL and WGSL.
+ *
+ * Both languages share identical built-in math functions. Language-specific
+ * functions (inversesqrt naming, mod, vector constructors) are provided
+ * by subclass overrides.
+ */
+export declare const GPU_FUNCTIONS: CompiledFunctions<Expression>;
+/**
+ * Abstract base class for GPU shader compilation targets.
+ *
+ * Provides shared operators, math functions, constants, and number formatting
+ * for both GLSL and WGSL. Subclasses implement language-specific details:
+ * function naming differences, vector constructors, function declaration
+ * syntax, and shader structure.
+ */
+export declare abstract class GPUShaderTarget implements LanguageTarget<Expression> {
+    /** Language identifier (e.g., 'glsl', 'wgsl') */
+    protected abstract readonly languageId: string;
+    /**
+     * Return language-specific function overrides.
+     *
+     * These are merged on top of the shared GPU_FUNCTIONS, allowing
+     * subclasses to override specific entries (e.g., `Inversesqrt`, `Mod`, `List`).
+     */
+    protected abstract getLanguageSpecificFunctions(): CompiledFunctions<Expression>;
+    /**
+     * Create a complete function declaration in the target language.
+     */
+    abstract compileFunction(expr: Expression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
+    /**
+     * Create a complete shader program in the target language.
+     */
+    abstract compileShader(options: Record<string, unknown>): string;
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions<Expression>;
+    getConstants(): Record<string, string>;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
+}

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * GLSL interval arithmetic compilation target
  *
  * Compiles mathematical expressions to GLSL code using interval arithmetic
@@ -9,26 +9,26 @@
  *
  * @module compilation/interval-glsl-target
  */
-import type { BoxedExpression } from '../global-types';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+import type { Expression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GLSL interval arithmetic target implementation.
  */
-export declare class IntervalGLSLTarget implements LanguageTarget {
+export declare class IntervalGLSLTarget implements LanguageTarget<Expression> {
     getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions;
+    getFunctions(): CompiledFunctions<Expression>;
     /**
      * Get the GLSL interval library code.
      *
      * This should be included in shaders that use interval arithmetic.
      */
     getLibrary(): string;
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
     /**
-     * Compile an expression to GLSL interval code.
+     * Compile an expression to GLSL interval code string.
      */
-    compile(expr: BoxedExpression, options?: CompilationOptions): string;
+    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
     /**
      * Create a complete GLSL interval function from an expression.
      *
@@ -36,14 +36,14 @@ export declare class IntervalGLSLTarget implements LanguageTarget {
      * @param functionName - Name of the GLSL function
      * @param parameters - Parameter names (each becomes a vec2 interval input)
      */
-    compileFunction(expr: BoxedExpression, functionName: string, parameters: string[]): string;
+    compileFunction(expr: Expression, functionName: string, parameters: string[]): string;
     /**
      * Create a complete GLSL fragment shader for interval function plotting.
      *
      * @param expr - The expression to compile
      * @param options - Shader options
      */
-    compileShaderFunction(expr: BoxedExpression, options?: {
+    compileShaderFunction(expr: Expression, options?: {
         functionName?: string;
         version?: string;
         parameters?: string[];

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic
@@ -6,8 +6,8 @@
  *
  * @module compilation/interval-javascript-target
  */
-import type { BoxedExpression } from '../global-types';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+import type { Expression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * JavaScript function that wraps compiled interval arithmetic code.
  *
@@ -97,9 +97,9 @@ export declare class ComputeEngineIntervalFunction extends Function {
 /**
  * Interval arithmetic JavaScript target implementation.
  */
-export declare class IntervalJavaScriptTarget implements LanguageTarget {
+export declare class IntervalJavaScriptTarget implements LanguageTarget<Expression> {
     getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions;
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    getFunctions(): CompiledFunctions<Expression>;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
 }

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

@@ -0,0 +1,54 @@
+/* 0.50.0 */
+ * WGSL interval arithmetic compilation target
+ *
+ * Compiles mathematical expressions to WGSL code using interval arithmetic
+ * for reliable function evaluation in WebGPU shaders.
+ *
+ * Intervals are represented as vec2f(lo, hi).
+ * Status flags use f32 constants for shader compatibility.
+ *
+ * Since WGSL does not support function overloading, internal vec2f-parameter
+ * implementations use a `_v` suffix (e.g., `ia_add_v`), while the public
+ * IntervalResult wrappers keep the base name (e.g., `ia_add`).
+ *
+ * @module compilation/interval-wgsl-target
+ */
+import type { Expression } from '../global-types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
+/**
+ * WGSL interval arithmetic target implementation.
+ */
+export declare class IntervalWGSLTarget implements LanguageTarget<Expression> {
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions<Expression>;
+    /**
+     * Get the WGSL interval library code.
+     *
+     * This should be included in shaders that use interval arithmetic.
+     */
+    getLibrary(): string;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    /**
+     * Compile an expression to WGSL interval code string.
+     */
+    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
+    /**
+     * Create a complete WGSL interval function from an expression.
+     *
+     * @param expr - The expression to compile
+     * @param functionName - Name of the WGSL function
+     * @param parameters - Parameter names (each becomes a vec2f interval input)
+     */
+    compileFunction(expr: Expression, functionName: string, parameters: string[]): string;
+    /**
+     * Create a complete WGSL compute shader for interval function evaluation.
+     *
+     * @param expr - The expression to compile
+     * @param options - Shader options
+     */
+    compileShaderFunction(expr: Expression, options?: {
+        functionName?: string;
+        parameters?: string[];
+    }): string;
+}

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

@@ -1,8 +1,8 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
 import { gamma, gammaln } from '../numerics/special-functions';
 import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
-import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompiledExecutable } from './types';
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * JavaScript-specific function extension that provides system functions
  */
@@ -60,9 +60,9 @@ export declare class ComputeEngineFunctionLiteral extends Function {
 /**
  * JavaScript language target implementation
  */
-export declare class JavaScriptTarget implements LanguageTarget {
+export declare class JavaScriptTarget implements LanguageTarget<Expression> {
     getOperators(): CompiledOperators;
-    getFunctions(): CompiledFunctions;
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    getFunctions(): CompiledFunctions<Expression>;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
 }

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

@@ -0,0 +1,61 @@
+/* 0.50.0 */
+import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
+/**
+ * Python/NumPy language target implementation
+ *
+ * Generates Python code that uses NumPy for mathematical operations.
+ * The generated code is compatible with NumPy arrays and supports
+ * vectorized operations.
+ */
+export declare class PythonTarget implements LanguageTarget<Expression> {
+    /** Whether to include 'import numpy as np' in generated code */
+    private includeImports;
+    /** Whether to use scipy.special for advanced functions */
+    private useScipy;
+    constructor(options?: {
+        includeImports?: boolean;
+        useScipy?: boolean;
+    });
+    getOperators(): CompiledOperators;
+    getFunctions(): CompiledFunctions<Expression>;
+    createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
+    /**
+     * Compile to Python source code (not executable in JavaScript)
+     *
+     * Returns Python code as a string. To execute it, use Python runtime.
+     */
+    compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
+    /**
+     * Compile an expression to Python source code
+     *
+     * Returns the Python code as a string.
+     */
+    compileToSource(expr: Expression, _options?: CompilationOptions<Expression>): string;
+    /**
+     * Create a complete Python function from an expression
+     *
+     * @param expr - The expression to compile
+     * @param functionName - Name of the Python function
+     * @param parameters - Parameter names (e.g., ['x', 'y', 'z'])
+     * @param docstring - Optional docstring for the function
+     */
+    compileFunction(expr: Expression, functionName: string, parameters: string[], docstring?: string): string;
+    /**
+     * Create a vectorized NumPy function from an expression
+     *
+     * The generated function will work with both scalar values and NumPy arrays.
+     *
+     * @param expr - The expression to compile
+     * @param functionName - Name of the Python function
+     * @param parameters - Parameter names
+     * @param docstring - Optional docstring
+     */
+    compileVectorized(expr: Expression, functionName: string, parameters: string[], docstring?: string): string;
+    /**
+     * Create a lambda function from an expression
+     *
+     * @param expr - The expression to compile
+     * @param parameters - Parameter names
+     */
+    compileLambda(expr: Expression, parameters: string[]): string;
+}

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

@@ -1,5 +1,4 @@
-/* 0.35.6 */
-import type { BoxedExpression } from '../global-types';
+/* 0.50.0 */
 /**
  * Source code in the target language
  */
@@ -7,7 +6,7 @@ export type TargetSource = string;
 /**
  * A compiled function that can be executed
  */
-export type CompiledFunction = string | ((args: ReadonlyArray<BoxedExpression>, compile: (expr: BoxedExpression) => TargetSource, target: CompileTarget) => TargetSource);
+export type CompiledFunction<Expr = unknown> = string | ((args: ReadonlyArray<Expr>, compile: (expr: Expr) => TargetSource, target: CompileTarget<Expr>) => TargetSource);
 /**
  * Mapping of operators to their target language representation and precedence
  */
@@ -18,17 +17,17 @@ export type CompiledOperators = Record<MathJsonSymbol, [
 /**
  * Mapping of function names to their target language implementation
  */
-export type CompiledFunctions = {
-    [id: MathJsonSymbol]: CompiledFunction;
+export type CompiledFunctions<Expr = unknown> = {
+    [id: MathJsonSymbol]: CompiledFunction<Expr>;
 };
 /**
  * Target language compilation configuration
  */
-export interface CompileTarget {
+export interface CompileTarget<Expr = unknown> {
     /** Get operator representation for the target language */
     operators?: (op: MathJsonSymbol) => [op: string, prec: number] | undefined;
     /** Get function implementation for the target language */
-    functions?: (id: MathJsonSymbol) => CompiledFunction | undefined;
+    functions?: (id: MathJsonSymbol) => CompiledFunction<Expr> | undefined;
     /** Get variable representation for the target language */
     var: (id: MathJsonSymbol) => string | undefined;
     /** Format string literals for the target language */
@@ -47,26 +46,30 @@ export interface CompileTarget {
 /**
  * Base interface for language-specific compilation targets
  */
-export interface LanguageTarget {
+export interface LanguageTarget<Expr = unknown> {
     /** Get the default operators for this language */
     getOperators(): CompiledOperators;
     /** Get the default functions for this language */
-    getFunctions(): CompiledFunctions;
+    getFunctions(): CompiledFunctions<Expr>;
     /** Create a CompileTarget for this language */
-    createTarget(options?: Partial<CompileTarget>): CompileTarget;
-    /** Compile an expression to executable code in this language */
-    compileToExecutable(expr: BoxedExpression, options?: CompilationOptions): CompiledExecutable;
+    createTarget(options?: Partial<CompileTarget<Expr>>): CompileTarget<Expr>;
+    /** Compile an expression to this language */
+    compile(expr: Expr, options?: CompilationOptions<Expr>): CompilationResult;
 }
 /**
  * Options for compilation
  */
-export interface CompilationOptions {
+export interface CompilationOptions<Expr = unknown> {
     /**
      * Target language for compilation.
      *
      * Built-in targets:
      * - `'javascript'` (default) - Compile to JavaScript
      * - `'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()`.
      *
@@ -99,7 +102,7 @@ export interface CompilationOptions {
      * const code = expr.compile({ target: customTarget });
      * ```
      */
-    target?: CompileTarget;
+    target?: CompileTarget<Expr>;
     /**
      * Custom operator mappings. Can be:
      * - A partial object mapping operator names to [operator, precedence] tuples
@@ -128,13 +131,15 @@ export interface CompilationOptions {
     preamble?: string;
 }
 /**
- * A compiled expression that can be executed
+ * Result of compiling an expression
  */
-export interface CompiledExecutable {
-    /** Execute the compiled code */
-    (...args: any[]): any;
-    /** Get the source code */
-    toString(): string;
-    /** Flag indicating this is a compiled expression */
-    isCompiled: true;
+export interface CompilationResult {
+    /** Target language name */
+    target: string;
+    /** Whether compilation succeeded (vs falling back to interpretation) */
+    success: boolean;
+    /** Generated source code */
+    code: string;
+    /** Executable function (present for JS-executable targets only) */
+    run?: (...args: number[]) => number;
 }

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

@@ -0,0 +1,41 @@
+/* 0.50.0 */
+import type { CompiledFunctions } from './types';
+import { GPUShaderTarget } from './gpu-target';
+/**
+ * WGSL (WebGPU Shading Language) compilation target.
+ *
+ * Extends the shared GPU base class with WGSL-specific function names,
+ * `fn` declaration syntax, and `@vertex`/`@fragment`/`@compute` shader
+ * structure with struct-based I/O.
+ */
+export declare class WGSLTarget extends GPUShaderTarget {
+    protected readonly languageId = "wgsl";
+    protected getLanguageSpecificFunctions(): CompiledFunctions<Expression>;
+    compileFunction(expr: Expression, functionName: string, returnType: string, parameters: Array<[name: string, type: string]>): string;
+    compileShader(options: {
+        type: 'vertex' | 'fragment' | 'compute';
+        inputs?: Array<{
+            name: string;
+            type: string;
+            location?: number;
+            builtin?: string;
+        }>;
+        outputs?: Array<{
+            name: string;
+            type: string;
+            location?: number;
+            builtin?: string;
+        }>;
+        uniforms?: Array<{
+            name: string;
+            type: string;
+            group?: number;
+            binding?: number;
+        }>;
+        workgroupSize?: [number, number?, number?];
+        body: Array<{
+            variable: string;
+            expression: Expression;
+        }>;
+    }): string;
+}

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.
@@ -8,6 +8,6 @@
  * to the `simplify` function.
  *
  */
-export declare function costFunction(expr: BoxedExpression): number;
-export declare function leafCount(expr: BoxedExpression): number;
+export declare function costFunction(expr: Expression): number;
+export declare function leafCount(expr: Expression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;

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

@@ -0,0 +1,6 @@
+/* 0.50.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;
+export declare function assumeFn(ce: IComputeEngine, predicate: Expression): AssumeResult;
+export declare function forget(ce: IComputeEngine, symbol: undefined | MathJsonSymbol | MathJsonSymbol[]): void;

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

@@ -0,0 +1,6 @@
+/* 0.50.0 */
+    private _entries;
+    getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
+    invalidate(cacheName: string): void;
+    purgeValues(): void;
+}

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

@@ -0,0 +1,6 @@
+/* 0.50.0 */
+export type CommonSymbolTable = {
+    [symbol: string]: null | Expression;
+};
+export declare function initializeCommonSymbols(engine: ComputeEngine, commonSymbols: CommonSymbolTable): void;
+export declare function resetCommonSymbols(commonSymbols: CommonSymbolTable): void;

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

@@ -0,0 +1,17 @@
+/* 0.50.0 */
+import type { LanguageTarget } from './compilation/types';
+/**
+ * Internal registry for compilation targets.
+ *
+ * Keeps compilation target registration concerns out of ComputeEngine.
+ *
+ * @internal
+ */
+export declare class CompilationTargetRegistry {
+    private readonly _targets;
+    register(name: string, target: LanguageTarget<Expression>): void;
+    get(name: string): LanguageTarget<Expression> | undefined;
+    list(): string[];
+    unregister(name: string): void;
+    registerDefaults(): void;
+}

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

@@ -0,0 +1,15 @@
+/* 0.50.0 */
+type ResetHooks = {
+    refreshNumericConstants: () => void;
+    resetCommonSymbols: () => void;
+    purgeCaches: () => void;
+};
+export declare class EngineConfigurationLifecycle {
+    private _generation;
+    private _tracker;
+    get generation(): number;
+    set generation(value: number);
+    reset(hooks: ResetHooks): void;
+    listen(listener: ConfigurationChangeListener): () => void;
+}
+export {};

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

@@ -0,0 +1,19 @@
+/* 0.50.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';
+export declare function lookupDefinition(ce: IComputeEngine, id: MathJsonSymbol): undefined | BoxedDefinition;
+export declare function declareSymbolValue(ce: IComputeEngine, name: MathJsonSymbol, def: Partial<ValueDefinition>, scope?: Scope): BoxedDefinition;
+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;
+export declare function declareFn(ce: IComputeEngine, arg1: string | {
+    [id: string]: Type | TypeString | Partial<SymbolDefinition>;
+}, arg2?: Type | TypeString | Partial<SymbolDefinition>, scope?: Scope): IComputeEngine;
+export declare function assignFn(ce: IComputeEngine, arg1: string | {
+    [id: string]: AssignValue;
+}, arg2?: AssignValue): IComputeEngine;