@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -1,7 +1,7 @@
-/* 0.35.6 */
-import type { Expression, MathJsonSymbol } from '../../math-json/types';
-import { BoxedType, TypeString } from '../types';
-import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
+/* 0.50.1 */
+import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
+import type { TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 export type SymbolTable = {
     parent: SymbolTable | null;
     ids: {
@@ -36,7 +36,7 @@ export type DelimiterScale = 'normal' | 'scaled' | 'big' | 'none';
 /**
  * @category Latex Parsing and Serialization
  */
-export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'number-theory' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
+export type LibraryCategory = 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'core' | 'linear-algebra' | 'logic' | 'number-theory' | 'other' | 'physics' | 'polynomials' | 'relop' | 'statistics' | 'trigonometry';
 /**
  *
  * :::info[THEORY OF OPERATIONS]
@@ -167,35 +167,35 @@ export type ParseHandler = ExpressionParseHandler | SymbolParseHandler | Functio
 /**
  * @category Latex Parsing and Serialization
  */
-export type ExpressionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type ExpressionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type PrefixParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type PrefixParseHandler = (parser: Parser, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type SymbolParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type SymbolParseHandler = (parser: Parser, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type FunctionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type FunctionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type EnvironmentParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+export type EnvironmentParseHandler = (parser: Parser, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type PostfixParseHandler = (parser: Parser, lhs: Expression, until?: Readonly<Terminator>) => Expression | null;
+export type PostfixParseHandler = (parser: Parser, lhs: MathJsonExpression, until?: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type InfixParseHandler = (parser: Parser, lhs: Expression, until: Readonly<Terminator>) => Expression | null;
+export type InfixParseHandler = (parser: Parser, lhs: MathJsonExpression, until: Readonly<Terminator>) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
-export type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
+export type MatchfixParseHandler = (parser: Parser, body: MathJsonExpression) => MathJsonExpression | null;
 /**
  * @category Latex Parsing and Serialization
  */
@@ -250,14 +250,14 @@ export type BaseEntry = {
  * @category Latex Parsing and Serialization
  */
 export type DefaultEntry = BaseEntry & Trigger & {
-    parse?: Expression | ExpressionParseHandler;
+    parse?: MathJsonExpression | ExpressionParseHandler;
 };
 /**
  * @category Latex Parsing and Serialization
  */
 export type ExpressionEntry = BaseEntry & Trigger & {
     kind: 'expression';
-    parse?: Expression | ExpressionParseHandler;
+    parse?: MathJsonExpression | ExpressionParseHandler;
     precedence?: Precedence;
 };
 /**
@@ -344,7 +344,7 @@ export type SymbolEntry = BaseEntry & Trigger & {
     kind: 'symbol';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: Precedence;
-    parse: Expression | SymbolParseHandler;
+    parse: MathJsonExpression | SymbolParseHandler;
 };
 /**
  * A function is a symbol followed by:
@@ -358,7 +358,17 @@ export type SymbolEntry = BaseEntry & Trigger & {
  */
 export type FunctionEntry = BaseEntry & Trigger & {
     kind: 'function';
-    parse?: Expression | FunctionParseHandler;
+    parse?: MathJsonExpression | FunctionParseHandler;
+    /**
+     * How arguments are parsed:
+     * - `'enclosure'` (default): arguments must be enclosed in parentheses,
+     *   e.g. `\max(a, b)`.
+     * - `'implicit'`: arguments can be provided with or without parentheses,
+     *   e.g. `\det A` is parsed as `\det(A)`.
+     *   Bare arguments are parsed at multiplication precedence, so
+     *   `\det 2A + 1` is parsed as `\det(2A) + 1`.
+     */
+    arguments?: 'enclosure' | 'implicit';
 };
 /**
  *
@@ -522,7 +532,7 @@ export type ParseLatexOptions = NumberFormat & {
      * The `symbol` argument is a [valid symbol](/math-json/#symbols).
      *
      */
-    getSymbolType: (symbol: MathJsonSymbol) => BoxedType;
+    getSymbolType: (symbol: MathJsonSymbol) => BoxedType | TypeString;
     /**
      * This handler is invoked when the parser needs to determine if a symbol
      * has a custom subscript evaluation handler. If true, subscripts on this
@@ -541,7 +551,7 @@ export type ParseLatexOptions = NumberFormat & {
      * The handler should return an expression or `null` if the token is not
      * recognized.
      */
-    parseUnexpectedToken: (lhs: Expression | null, parser: Parser) => Expression | null;
+    parseUnexpectedToken: (lhs: MathJsonExpression | null, parser: Parser) => MathJsonExpression | null;
     /**
      * If true, the expression will be decorated with the LaTeX
      * fragments corresponding to each elements of the expression.
@@ -640,7 +650,7 @@ export interface Parser {
      */
     latex(start: number, end?: number): string;
     /** Return an error expression with the specified code and arguments */
-    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
+    error(code: string | [string, ...MathJsonExpression[]], fromToken: number): MathJsonExpression;
     /** If there are any space, advance the index until a non-space is encountered */
     skipSpace(): boolean;
     /** Skip over "visual space" which
@@ -669,7 +679,7 @@ export interface Parser {
      * Return `null` if none was found
      * Return `Nothing` if an empty group `{}` was found
      */
-    parseGroup(): Expression | null;
+    parseGroup(): MathJsonExpression | null;
     /**
      * Some LaTeX commands (but not all) can accept arguments as single
      * tokens (i.e. without braces), for example `^2`, `\sqrt3` or `\frac12`
@@ -684,15 +694,15 @@ export interface Parser {
      *
      * The excluded tokens include `!"#$%&(),/;:?@[]`|~", `\left`, `\bigl`, etc...
      */
-    parseToken(): Expression | null;
+    parseToken(): MathJsonExpression | null;
     /**
      * Parse an expression enclosed in a LaTeX optional group enclosed in square brackets `[]`.
      *
      * Return `null` if none was found.
      */
-    parseOptionalGroup(): Expression | null;
+    parseOptionalGroup(): MathJsonExpression | null;
     /** Parse an enclosure (open paren/close paren, etc..) and return the expression inside the enclosure */
-    parseEnclosure(): Expression | null;
+    parseEnclosure(): MathJsonExpression | null;
     /**
      * Some LaTeX commands have arguments that are not interpreted as
      * expressions, but as strings. For example, `\begin{array}{ccc}` (both
@@ -715,7 +725,7 @@ export interface Parser {
      * - a single LaTeX command: `\pi`
      * - a multi-letter symbol: `\operatorname{speed}`
      */
-    parseSymbol(until?: Partial<Terminator>): Expression | null;
+    parseSymbol(until?: Partial<Terminator>): MathJsonExpression | null;
     /**
      * Parse an expression in a tabular format, where rows are separated by `\\`
      * and columns by `&`.
@@ -723,7 +733,7 @@ export interface Parser {
      * Return rows of sparse columns: empty rows are indicated with `Nothing`,
      * and empty cells are also indicated with `Nothing`.
      */
-    parseTabular(): null | Expression[][];
+    parseTabular(): null | MathJsonExpression[][];
     /**
      * Parse an argument list, for example: `(12, x+1)` or `\left(x\right)`
      *
@@ -735,14 +745,14 @@ export interface Parser {
      * Return an array of expressions, one for each argument, or `null` if no
      * argument was found.
      */
-    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): ReadonlyArray<Expression> | null;
+    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): ReadonlyArray<MathJsonExpression> | null;
     /**
      * Parse a postfix operator, such as `'` or `!`.
      *
      * Prefix, infix and matchfix operators are handled by `parseExpression()`
      *
      */
-    parsePostfixOperator(lhs: Expression | null, until?: Partial<Terminator>): Expression | null;
+    parsePostfixOperator(lhs: MathJsonExpression | null, until?: Partial<Terminator>): MathJsonExpression | null;
     /**
      * Parse an expression:
      *
@@ -769,11 +779,11 @@ export interface Parser {
      *
      * `until` is `{ minPrec:0 }` by default.
      */
-    parseExpression(until?: Partial<Terminator>): Expression | null;
+    parseExpression(until?: Partial<Terminator>): MathJsonExpression | null;
     /**
      * Parse a number.
      */
-    parseNumber(): Expression | null;
+    parseNumber(): MathJsonExpression | null;
     /**
      * Boundaries are used to detect the end of an expression.
      *
@@ -791,7 +801,7 @@ export interface Parser {
     removeBoundary(): void;
     get atBoundary(): boolean;
     matchBoundary(): boolean;
-    boundaryError(msg: string | [string, ...Expression[]]): Expression;
+    boundaryError(msg: string | [string, ...MathJsonExpression[]]): MathJsonExpression;
 }
 /**
  *
@@ -855,14 +865,24 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
      *
      */
     missingSymbol: LatexString;
-    applyFunctionStyle: (expr: Expression, level: number) => DelimiterScale;
-    groupStyle: (expr: Expression, level: number) => DelimiterScale;
-    rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
-    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
-    logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
-    powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
-    numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
+    applyFunctionStyle: (expr: MathJsonExpression, level: number) => DelimiterScale;
+    groupStyle: (expr: MathJsonExpression, level: number) => DelimiterScale;
+    rootStyle: (expr: MathJsonExpression, level: number) => 'radical' | 'quotient' | 'solidus';
+    fractionStyle: (expr: MathJsonExpression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    logicStyle: (expr: MathJsonExpression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+    powerStyle: (expr: MathJsonExpression, level: number) => 'root' | 'solidus' | 'quotient';
+    numericSetStyle: (expr: MathJsonExpression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
 };
+/** @internal */
+export interface SerializerDictionaryEntry {
+    name?: string;
+}
+/** @internal */
+export interface SerializerDictionary {
+    ids: ReadonlyMap<string, SerializerDictionaryEntry>;
+    lookahead: number;
+    defs: readonly SerializerDictionaryEntry[];
+}
 /**
  *
  * An instance of `Serializer` is provided to the `serialize` handlers of custom
@@ -873,7 +893,7 @@ export type SerializeLatexOptions = NumberSerializationFormat & {
  */
 export interface Serializer {
     readonly options: Required<SerializeLatexOptions>;
-    readonly dictionary: IndexedLatexDictionary;
+    readonly dictionary: SerializerDictionary;
     /** "depth" of the expression:
      * - 0 for the root
      * - 1 for a subexpression of the root
@@ -887,9 +907,9 @@ export interface Serializer {
      */
     level: number;
     /** Output a LaTeX string representing the expression */
-    serialize: (expr: Expression | null | undefined) => string;
-    serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
-    serializeSymbol(expr: Expression): LatexString;
+    serialize: (expr: MathJsonExpression | null | undefined) => string;
+    serializeFunction(expr: MathJsonExpression, def?: SerializerDictionaryEntry): LatexString;
+    serializeSymbol(expr: MathJsonExpression): LatexString;
     /** Output `s` surrounded by delimiters.
      *
      * If `delimiters` is not specified, use `()`
@@ -899,23 +919,23 @@ export interface Serializer {
     /** A string with the arguments of expr fenced appropriately and separated by
      * commas.
      */
-    wrapArguments(expr: Expression): LatexString;
+    wrapArguments(expr: MathJsonExpression): LatexString;
     /** Add a group fence around the expression if it is
      * an operator of precedence less than or equal to `prec`.
      */
-    wrap: (expr: Expression | null | undefined, prec?: number) => LatexString;
+    wrap: (expr: MathJsonExpression | null | undefined, prec?: number) => LatexString;
     /** Add a group fence around the expression if it is
      * short (not a function)
      */
-    wrapShort(expr: Expression | null | undefined): LatexString;
+    wrapShort(expr: MathJsonExpression | null | undefined): LatexString;
     /** Styles */
-    applyFunctionStyle: (expr: Expression, level: number) => DelimiterScale;
-    groupStyle: (expr: Expression, level: number) => DelimiterScale;
-    rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
-    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
-    logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
-    powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
-    numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
+    applyFunctionStyle: (expr: MathJsonExpression, level: number) => DelimiterScale;
+    groupStyle: (expr: MathJsonExpression, level: number) => DelimiterScale;
+    rootStyle: (expr: MathJsonExpression, level: number) => 'radical' | 'quotient' | 'solidus';
+    fractionStyle: (expr: MathJsonExpression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    logicStyle: (expr: MathJsonExpression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+    powerStyle: (expr: MathJsonExpression, level: number) => 'root' | 'solidus' | 'quotient';
+    numericSetStyle: (expr: MathJsonExpression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
 }
 /** The `serialize` handler of a custom LaTeX dictionary entry can be
  * a function of this type.
@@ -923,4 +943,4 @@ export interface Serializer {
  * @category Latex Parsing and Serialization
  *
  */
-export type SerializeHandler = (serializer: Serializer, expr: Expression) => string;
+export type SerializeHandler = (serializer: Serializer, expr: MathJsonExpression) => string;

package/dist/types/compute-engine/latex-syntax/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function asLatexString(s: unknown): string | null;
 export declare function isRelationalOperator(name: string | undefined): boolean;
 export declare function isInequalityOperator(operator: string | undefined): boolean;

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

@@ -1,4 +1,3 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export type CanonicalArithmeticOperators = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Sqrt' | 'Root' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: SymbolDefinitions[];
-export declare function isPrime(expr: BoxedExpression): boolean | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const CALCULUS_LIBRARY: SymbolDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
 /**
@@ -8,7 +8,7 @@ export declare const COLLECTIONS_LIBRARY: SymbolDefinitions;
  * - arguments rounded to integers
  *
  */
-export declare function range(expr: BoxedExpression): [lower: number, upper: number, step: number];
+export declare function range(expr: Expression): [lower: number, upper: number, step: number];
 /** Return the last value in the range
  * - could be less that lower if step is negative
  * - could be less than upper if step is positive, for
@@ -22,6 +22,6 @@ export declare function rangeLast(r: [lower: number, upper: number, step: number
  * is returned. Otherwise, the result of the function is used as the new accumulator.
  * If the iteration completes, the final accumulator is returned.
  */
-export declare function reduceCollection<T>(collection: BoxedExpression, fn: (acc: T, next: BoxedExpression) => T | null, initial: T): Generator<T | undefined>;
+export declare function reduceCollection<T>(collection: Expression, fn: (acc: T, next: Expression) => T | null, initial: T): Generator<T | undefined>;
 export declare function fromRange(start: number, end: number): number[];
-export declare function sortedIndices(expr: BoxedExpression, fn?: BoxedExpression | undefined): number[] | undefined;
+export declare function sortedIndices(expr: Expression, fn?: Expression | undefined): number[] | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const COMBINATORICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const COMPLEX_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const CONTROL_STRUCTURES_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const CORE_LIBRARY: SymbolDefinitions[];

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

@@ -1,9 +1,22 @@
-/* 0.35.6 */
-import type { SymbolDefinitions, ComputeEngine } from '../global-types';
-export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly SymbolDefinitions[];
-export declare const LIBRARIES: {
-    [category in LibraryCategory]?: SymbolDefinitions | SymbolDefinitions[];
-};
+/* 0.50.1 */
+import type { SymbolDefinitions, IComputeEngine as ComputeEngine, LibraryDefinition } from '../global-types';
+/**
+ * The standard libraries bundled with the Compute Engine.
+ *
+ * Each entry bundles symbol/operator definitions with their LaTeX dictionary
+ * entries and declares dependencies on other libraries.
+ */
+export declare const STANDARD_LIBRARIES: LibraryDefinition[];
+/**
+ * Topological sort of libraries using Kahn's algorithm.
+ * Throws on cycle or missing dependency.
+ */
+export declare function sortLibraries(libs: LibraryDefinition[]): LibraryDefinition[];
+/**
+ * Return the standard libraries, optionally filtered by category name.
+ * Libraries are returned in dependency order (topologically sorted).
+ */
+export declare function getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly LibraryDefinition[];
 /**
  * Set the symbol table of the current context (`engine.context`) to `table`
  *

package/dist/types/compute-engine/library/linear-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/logic-analysis.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Quantifier domain helpers and boolean analysis functions.
  * Extracted from logic.ts for better code organization.
@@ -12,11 +12,11 @@
 export type ExtractDomainResult = {
     status: 'success';
     variable: string;
-    values: BoxedExpression[];
+    values: Expression[];
 } | {
     status: 'non-enumerable';
     variable: string;
-    domain: BoxedExpression;
+    domain: Expression;
     reason: string;
 } | {
     status: 'error';
@@ -31,52 +31,39 @@ export type ExtractDomainResult = {
  * - ["Element", "x", ["Set", 1, 2, 3], condition] → filtered values (EL-3)
  * Returns detailed result indicating success, non-enumerable domain, or error.
  */
-export declare function extractFiniteDomainWithReason(condition: BoxedExpression, ce: ComputeEngine): ExtractDomainResult;
-/**
- * Extract the finite domain from a quantifier's condition.
- * Supports:
- * - ["Element", "x", ["Set", 1, 2, 3]] → [1, 2, 3]
- * - ["Element", "x", ["Range", 1, 5]] → [1, 2, 3, 4, 5]
- * - ["Element", "x", ["Interval", 1, 5]] → [1, 2, 3, 4, 5] (integers only)
- * Returns null if the domain is not finite or not recognized.
- * @deprecated Use extractFiniteDomainWithReason for better error handling
- */
-export declare function extractFiniteDomain(condition: BoxedExpression, ce: ComputeEngine): {
-    variable: string;
-    values: BoxedExpression[];
-} | null;
+export declare function extractFiniteDomainWithReason(condition: Expression, ce: ComputeEngine): ExtractDomainResult;
 /**
  * Check if an expression contains a reference to a specific variable.
  */
-export declare function bodyContainsVariable(expr: BoxedExpression, variable: string): boolean;
+export declare function bodyContainsVariable(expr: Expression, variable: string): boolean;
 /**
  * For nested quantifiers like ∀x∈S. ∀y∈T. P(x,y), collect the inner domains.
  * Returns an array of {variable, values} for nested ForAll/Exists with finite domains.
  */
-export declare function collectNestedDomains(body: BoxedExpression, ce: ComputeEngine): {
+export declare function collectNestedDomains(body: Expression, ce: ComputeEngine): {
     variable: string;
-    values: BoxedExpression[];
+    values: Expression[];
 }[];
 /**
  * Get the innermost body of nested quantifiers.
  */
-export declare function getInnermostBody(body: BoxedExpression): BoxedExpression;
+export declare function getInnermostBody(body: Expression): Expression;
 /**
  * Evaluate ForAll over a Cartesian product of domains.
  * Returns True if the predicate holds for all combinations.
  */
 export declare function evaluateForAllCartesian(domains: {
     variable: string;
-    values: BoxedExpression[];
-}[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
+    values: Expression[];
+}[], body: Expression, ce: ComputeEngine): Expression | undefined;
 /**
  * Evaluate Exists over a Cartesian product of domains.
  * Returns True if the predicate holds for at least one combination.
  */
 export declare function evaluateExistsCartesian(domains: {
     variable: string;
-    values: BoxedExpression[];
-}[], body: BoxedExpression, ce: ComputeEngine): BoxedExpression | undefined;
+    values: Expression[];
+}[], body: Expression, ce: ComputeEngine): Expression | undefined;
 /**
  * Check if a boolean expression is satisfiable.
  *
@@ -115,7 +102,7 @@ export declare function evaluateExistsCartesian(domains: {
  * @returns `True` if satisfiable, `False` if unsatisfiable, or the
  *          unevaluated expression if the variable limit is exceeded
  */
-export declare function isSatisfiable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+export declare function isSatisfiable(expr: Expression, ce: ComputeEngine): Expression;
 /**
  * Check if a boolean expression is a tautology.
  *
@@ -152,7 +139,7 @@ export declare function isSatisfiable(expr: BoxedExpression, ce: ComputeEngine):
  * @returns `True` if a tautology, `False` if not, or the unevaluated
  *          expression if the variable limit is exceeded
  */
-export declare function isTautology(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+export declare function isTautology(expr: Expression, ce: ComputeEngine): Expression;
 /**
  * Generate a truth table for a boolean expression.
  *
@@ -186,7 +173,7 @@ export declare function isTautology(expr: BoxedExpression, ce: ComputeEngine): B
  * @returns A `List` of `List`s representing the truth table, or the
  *          unevaluated expression if the variable limit is exceeded
  */
-export declare function generateTruthTable(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
+export declare function generateTruthTable(expr: Expression, ce: ComputeEngine): Expression;
 /**
  * Find all prime implicants using the Quine-McCluskey algorithm.
  *
@@ -215,7 +202,7 @@ export declare function generateTruthTable(expr: BoxedExpression, ce: ComputeEng
  * @param ce - The ComputeEngine instance
  * @returns A Set of expressions representing prime implicants
  */
-export declare function findPrimeImplicants(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+export declare function findPrimeImplicants(expr: Expression, ce: ComputeEngine): Expression[] | null;
 /**
  * Find all prime implicates using the Quine-McCluskey algorithm.
  *
@@ -227,7 +214,7 @@ export declare function findPrimeImplicants(expr: BoxedExpression, ce: ComputeEn
  * @param ce - The ComputeEngine instance
  * @returns A Set of expressions representing prime implicates (clauses)
  */
-export declare function findPrimeImplicates(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression[] | null;
+export declare function findPrimeImplicates(expr: Expression, ce: ComputeEngine): Expression[] | null;
 /**
  * Find a minimal DNF (sum of products) using prime implicants.
  *
@@ -238,7 +225,7 @@ export declare function findPrimeImplicates(expr: BoxedExpression, ce: ComputeEn
  * @param ce - The ComputeEngine instance
  * @returns The minimal DNF, or null if too many variables
  */
-export declare function minimalDNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;
+export declare function minimalDNF(expr: Expression, ce: ComputeEngine): Expression | null;
 /**
  * Find a minimal CNF (product of sums) using prime implicates.
  *
@@ -246,4 +233,4 @@ export declare function minimalDNF(expr: BoxedExpression, ce: ComputeEngine): Bo
  * @param ce - The ComputeEngine instance
  * @returns The minimal CNF, or null if too many variables
  */
-export declare function minimalCNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression | null;
+export declare function minimalCNF(expr: Expression, ce: ComputeEngine): Expression | null;

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

@@ -1,7 +1,3 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const LOGIC_LIBRARY: SymbolDefinitions;
-export declare function simplifyLogicFunction(x: BoxedExpression): {
-    value: BoxedExpression;
-    because: string;
-} | undefined;
 export declare const LOGIC_FUNCTION_LIBRARY: SymbolDefinitions;

package/dist/types/compute-engine/library/number-theory.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const NUMBER_THEORY_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const POLYNOMIALS_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
-export declare function randomExpression(level?: number): Expression;
+/* 0.50.1 */
+export declare function randomExpression(level?: number): MathJsonExpression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const RELOP_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const SETS_LIBRARY: SymbolDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const STATISTICS_LIBRARY: SymbolDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolDefinitions[];

package/dist/types/compute-engine/library/type-handlers.d.ts

@@ -0,0 +1,4 @@
+/* 0.50.1 */
+import type { Type } from '../../common/type/types';
+/** Real inputs → finite_real, otherwise → finite_number. */
+export declare function numericTypeHandler(ops: ReadonlyArray<Expression>): Type;