@cortex-js/compute-engine 0.51.1 → 0.52.0

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

@@ -1,4 +1,4 @@
-/* 0.51.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 0.52.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,8 +1,8 @@
-/* 0.51.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.
  *
@@ -58,6 +59,16 @@ export declare class ComputeEngineIntervalFunction extends Function {
         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;
@@ -107,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.1 */
+/* 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,4 +1,4 @@
-/* 0.51.1 */
+/* 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, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
 import { choose } from '../boxed-expression/expand';
@@ -347,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.1 */
+/* 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.1 */
+/* 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
@@ -143,11 +143,85 @@ export interface CompilationOptions<Expr = unknown> {
     realOnly?: boolean;
 }
 /**
- * Result of compiling an expression
+ * Built-in targets that produce an executable `run` function.
  */
-export interface CompilationResult {
+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.
+ *
+ * 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 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 */
@@ -164,20 +238,14 @@ export interface CompilationResult {
      */
     preamble?: string;
     /**
-     * Executable function (present for JS-executable targets only).
-     *
-     * For plain expressions, call with a vars object:
-     * ```typescript
-     * result.run({ x: 0.5 })
-     * ```
-     *
-     * For `Function` (lambda) expressions, call with positional arguments:
-     * ```typescript
-     * result.run(0.5)
-     * ```
+     * 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)`
      */
-    run?: (...args: unknown[]) => number | {
-        re: number;
-        im: number;
-    };
-}
+    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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 0.52.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

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

@@ -1,4 +1,4 @@
-/* 0.51.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 0.52.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

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

@@ -1,4 +1,4 @@
-/* 0.51.1 */
+/* 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.1 */
+/* 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.1 */
+/* 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.1 */
+/* 0.52.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.51.1 */
+/* 0.52.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.51.1 */
+/* 0.52.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,7 +1,8 @@
-/* 0.51.1 */
+/* 0.52.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';
+import type { CompilationResult } from './compilation/types';
 /** @internal Called by index.ts to register the ComputeEngine class,
  *  avoiding a circular dependency (index.ts re-exports this file). */
 export declare function _setComputeEngineClass(cls: new () => IComputeEngine): void;
@@ -23,4 +24,10 @@ 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 factor(expr: LatexString | ExpressionInput): Expression;
-export declare function compile(expr: LatexString | ExpressionInput, options?: Parameters<typeof compileExpr>[1]): ReturnType<typeof compileExpr>;
+export declare function compile<T extends string = 'javascript'>(expr: LatexString | ExpressionInput, options: Parameters<typeof compileExpr>[1] & {
+    to?: T;
+    realOnly: true;
+}): CompilationResult<T, number>;
+export declare function compile<T extends string = 'javascript'>(expr: LatexString | ExpressionInput, options?: Parameters<typeof compileExpr>[1] & {
+    to?: T;
+}): CompilationResult<T>;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.51.1 */
+/* 0.52.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.51.1 */
+/* 0.52.0 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';

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

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