@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -1,11 +1,11 @@
-/* 0.35.6 */
-import type { BoxedExpression, ComputeEngine } from '../global-types';
+/* 0.50.1 */
+import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.
  *
  * Converts the arguments to canonical, and flattens the sequence.
  */
-export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, count: number): ReadonlyArray<BoxedExpression>;
+export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<Expression>, count: number): ReadonlyArray<Expression>;
 /**
  * Validation of arguments is normally done by checking the signature of the
  * function vs the arguments of the expression. However, we have a fastpath
@@ -22,21 +22,21 @@ export declare function checkArity(ce: ComputeEngine, ops: ReadonlyArray<BoxedEx
  *
  * Flattens sequence expressions.
  */
-export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, options?: number | {
+export declare function checkNumericArgs(ce: ComputeEngine, ops: ReadonlyArray<Expression>, options?: number | {
     count?: number;
     flatten?: string;
-}): ReadonlyArray<BoxedExpression>;
+}): ReadonlyArray<Expression>;
 /**
  * Check that an argument is of the expected type.
  *
  * Converts the arguments to canonical
  */
-export declare function checkType(ce: ComputeEngine, arg: BoxedExpression | undefined | null, type: Type | undefined): BoxedExpression;
-export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<BoxedExpression>, types: Type[]): ReadonlyArray<BoxedExpression>;
+export declare function checkType(ce: ComputeEngine, arg: Expression | undefined | null, type: Type | undefined): Expression;
+export declare function checkTypes(ce: ComputeEngine, args: ReadonlyArray<Expression>, types: Type[]): ReadonlyArray<Expression>;
 /**
  * Check that the argument is pure.
  */
-export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | BoxedExpression | undefined | null): BoxedExpression;
+export declare function checkPure(ce: ComputeEngine, arg: Expression | Expression | undefined | null): Expression;
 /**
  *
  * If the arguments match the parameters, return null.
@@ -54,5 +54,5 @@ export declare function checkPure(ce: ComputeEngine, arg: BoxedExpression | Boxe
  * -->
  *
  */
-export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<BoxedExpression> | null;
-export declare function spellCheckMessage(expr: BoxedExpression): string;
+export declare function validateArguments(ce: ComputeEngine, ops: ReadonlyArray<Expression>, signature: Type, lazy?: boolean, threadable?: boolean): ReadonlyArray<Expression> | null;
+export declare function spellCheckMessage(expr: Expression): string;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** 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
@@ -9,8 +9,8 @@
  *
  */
 export declare const MAX_SIZE_EAGER_COLLECTION = 100;
-export declare function isFiniteIndexedCollection(col: BoxedExpression): boolean;
-export declare function repeat(value: BoxedExpression, count?: number): Iterator<BoxedExpression>;
+export declare function isFiniteIndexedCollection(col: Expression): boolean;
+export declare function repeat(value: Expression, count?: number): Iterator<Expression>;
 /**
  * Zips together multiple collections into a single iterator.
  *
@@ -24,7 +24,7 @@ export declare function repeat(value: BoxedExpression, count?: number): Iterator
  * }
  * ```
  */
-export declare function zip(items: ReadonlyArray<BoxedExpression>): Iterator<BoxedExpression[]>;
+export declare function zip(items: ReadonlyArray<Expression>): Iterator<Expression[]>;
 /**
  * Default collection handlers suitable for collections that store their
  * elements as operands.

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -7,11 +7,11 @@ export declare class BaseCompiler {
     /**
      * Compile an expression to target language source code
      */
-    static compile(expr: BoxedExpression | undefined, target: CompileTarget, prec?: number): TargetSource;
+    static compile(expr: Expression | undefined, target: CompileTarget<Expression>, prec?: number): TargetSource;
     /**
      * Compile a function expression
      */
-    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<BoxedExpression>, prec: number, target: CompileTarget): TargetSource;
+    static compileExpr(engine: ComputeEngine, h: string, args: ReadonlyArray<Expression>, prec: number, target: CompileTarget<Expression>): TargetSource;
     /**
      * Compile a block expression
      */

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

@@ -0,0 +1,25 @@
+/* 0.50.1 */
+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.1 */
+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.1 */
+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.1 */
  * 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.1 */
  * 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.1 */
+ * 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.1 */
 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.1 */
+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.1 */
 /**
  * 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,26 @@ 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;
+    /**
+     * 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.
+     */
+    preamble?: 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.1 */
+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.1 */
 /**
  * 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;