@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * EL-4: Convert known infinite integer sets to their equivalent Limits bounds.
  * Returns undefined if the set cannot be converted to a Limits form.
@@ -37,8 +37,8 @@ export type IndexingSet = {
  * @param indexingSet
  * @returns
  */
-export declare function normalizeIndexingSet(indexingSet: BoxedExpression): IndexingSet;
-export declare function normalizeIndexingSets(ops: ReadonlyArray<BoxedExpression>): IndexingSet[];
+export declare function normalizeIndexingSet(indexingSet: Expression): IndexingSet;
+export declare function normalizeIndexingSets(ops: ReadonlyArray<Expression>): IndexingSet[];
 export declare function indexingSetCartesianProduct(indexingSets: IndexingSet[]): number[][];
 /**
  * Calculates the cartesian product of two arrays.
@@ -62,12 +62,12 @@ export declare function cartesianProduct(array1: number[], array2: number[]): nu
  * - [Tuple, "x", 1, 10] -> ["Limits", "x", 1, 10]
  *
  */
-export declare function canonicalLimitsSequence(ops: ReadonlyArray<BoxedExpression>, options: {
+export declare function canonicalLimitsSequence(ops: ReadonlyArray<Expression>, options: {
     engine: ComputeEngine;
-}): BoxedExpression[];
-export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
+}): Expression[];
+export declare function canonicalLimits(ops: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
-}): BoxedExpression | null;
+}): Expression | null;
 /** Return a limit/indexing set in canonical form as a `Limits` expression
  * with:
  * - `index` (a symbol), `Nothing` if none is present
@@ -79,8 +79,8 @@ export declare function canonicalLimits(ops: ReadonlyArray<BoxedExpression>, { e
  * Assume we are in the context of a big operator
  * (i.e. `pushScope()` has been called)
  */
-export declare function canonicalIndexingSet(expr: BoxedExpression): BoxedExpression | undefined;
-export declare function canonicalBigop(bigOp: string, body: BoxedExpression, indexingSets: BoxedExpression[], scope: Scope | undefined): BoxedExpression | null;
+export declare function canonicalIndexingSet(expr: Expression): Expression | undefined;
+export declare function canonicalBigop(bigOp: string, body: Expression, indexingSets: Expression[], scope: Scope | undefined): Expression | null;
 /**
  * A special symbol used to signal that a BigOp could not be evaluated
  * because the domain is non-enumerable (e.g., infinite set, unknown symbol).
@@ -97,7 +97,7 @@ export type BigOpResult<T> = {
 } | {
     status: 'non-enumerable';
     reason: string;
-    domain?: BoxedExpression;
+    domain?: Expression;
 } | {
     status: 'error';
     reason: string;
@@ -117,7 +117,7 @@ export type BigOpResult<T> = {
  * Returns either the reduced value, or `typeof NON_ENUMERABLE_DOMAIN` if the
  * domain cannot be enumerated (in which case the expression should remain symbolic).
  */
-export declare function reduceBigOp<T>(body: BoxedExpression, indexes: ReadonlyArray<BoxedExpression>, fn: (acc: T, x: BoxedExpression) => T | null, initial: T): Generator<T | typeof NON_ENUMERABLE_DOMAIN | undefined>;
+export declare function reduceBigOp<T>(body: Expression, indexes: ReadonlyArray<Expression>, fn: (acc: T, x: Expression) => T | null, initial: T): Generator<T | typeof NON_ENUMERABLE_DOMAIN | undefined>;
 /**
  * Result type for reduceElementIndexingSets to distinguish between
  * successful evaluation, non-enumerable domains (keep symbolic), and errors.
@@ -128,7 +128,7 @@ export type ReduceElementResult<T> = {
 } | {
     status: 'non-enumerable';
     reason: string;
-    domain?: BoxedExpression;
+    domain?: Expression;
 } | {
     status: 'error';
     reason: string;

package/dist/types/compute-engine/numeric-value/big-numeric-value.d.ts

@@ -1,8 +1,8 @@
-/* 0.35.6 */
-import { BigNumFactory, NumericValue, NumericValueData } from './types';
+/* 0.50.1 */
+import type { BigNumFactory, SmallInteger } from '../numerics/types';
+import { NumericValue, NumericValueData } from './types';
 import { ExactNumericValue } from './exact-numeric-value';
-import { Expression } from '../../math-json/types';
-import { SmallInteger } from '../numerics/types';
+import { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 export declare class BigNumericValue extends NumericValue {
     __brand: 'BigNumericValue';
@@ -12,7 +12,7 @@ export declare class BigNumericValue extends NumericValue {
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): ExactNumericValue | undefined;
-    toJSON(): Expression;
+    toJSON(): MathJsonExpression;
     toString(): string;
     clone(value: number | Decimal | NumericValueData): BigNumericValue;
     private _makeExact;

package/dist/types/compute-engine/numeric-value/exact-numeric-value.d.ts

@@ -1,7 +1,7 @@
-/* 0.35.6 */
-import { Rational, SmallInteger } from '../numerics/types';
-import { BigNumFactory, ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
-import { Expression } from '../../math-json/types';
+/* 0.50.1 */
+import { type BigNumFactory, Rational, SmallInteger } from '../numerics/types';
+import { ExactNumericValueData, NumericValue, NumericValueFactory } from './types';
+import { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 /**
  * An ExactNumericValue is the sum of a Gaussian imaginary and the product of
@@ -28,7 +28,7 @@ export declare class ExactNumericValue extends NumericValue {
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
-    toJSON(): Expression;
+    toJSON(): MathJsonExpression;
     clone(value: number | ExactNumericValueData): ExactNumericValue;
     /** Object.toString() */
     toString(): string;

package/dist/types/compute-engine/numeric-value/machine-numeric-value.d.ts

@@ -1,7 +1,7 @@
-/* 0.35.6 */
-import { BigNumFactory, NumericValue, NumericValueData } from './types';
-import type { Expression } from '../../math-json/types';
-import type { SmallInteger } from '../numerics/types';
+/* 0.50.1 */
+import type { BigNumFactory, SmallInteger } from '../numerics/types';
+import { NumericValue, NumericValueData } from './types';
+import type { MathJsonExpression } from '../../math-json/types';
 import { NumericPrimitiveType } from '../../common/type/types';
 export declare class MachineNumericValue extends NumericValue {
     __brand: 'MachineNumericValue';
@@ -12,7 +12,7 @@ export declare class MachineNumericValue extends NumericValue {
     get type(): NumericPrimitiveType;
     get isExact(): boolean;
     get asExact(): NumericValue | undefined;
-    toJSON(): Expression;
+    toJSON(): MathJsonExpression;
     toString(): string;
     clone(value: number | Decimal | NumericValueData): MachineNumericValue;
     get re(): number;

package/dist/types/compute-engine/numeric-value/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  *
  * ## THEORY OF OPERATIONS
  *
@@ -26,7 +26,6 @@
 import { Decimal } from 'decimal.js';
 import type { Rational, SmallInteger } from '../numerics/types';
 import { NumericPrimitiveType } from '../../common/type/types';
-export type BigNumFactory = (value: Decimal.Value) => Decimal;
 /** The value is equal to `(decimal * rational * sqrt(radical)) + im * i`
  * @category Numerics */
 export type ExactNumericValueData = {
@@ -111,6 +110,6 @@ export declare abstract class NumericValue {
     /** Object.toPrimitive() */
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
     /** Object.toJSON */
-    toJSON(): any;
+    toJSON(): unknown;
     print(): void;
 }

package/dist/types/compute-engine/numerics/bigint.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function bigint(a: Decimal | number | bigint | string): bigint | null;

package/dist/types/compute-engine/numerics/expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
-export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
+/* 0.50.1 */
+export declare function bigintValue(expr: MathJsonExpression | null | undefined): bigint | null;
 /** Output a shorthand if possible */
-export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): Expression;
+export declare function numberToExpression(num: number | bigint, fractionalDigits?: string | number): MathJsonExpression;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** An interval is a continuous set of real numbers */
 export type Interval = {
     start: number;
@@ -6,7 +6,7 @@ export type Interval = {
     end: number;
     openEnd: boolean;
 };
-export declare function interval(expr: BoxedExpression): Interval | undefined;
+export declare function interval(expr: Expression): Interval | undefined;
 export declare function intervalContains(int: Interval, val: number): boolean;
 /** Return true if int1 is a subset of int2 */
 export declare function intervalSubset(int1: Interval, int2: Interval): boolean;

package/dist/types/compute-engine/numerics/monte-carlo.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     estimate: number;
     error: number;
 };

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function lcm(a: bigint, b: bigint): bigint;
 /** Return `[factor, root]` such that
  * pow(n, 1/exponent) = factor * pow(root, 1/exponent)

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function gcd(a: BigNum, b: BigNum): BigNum;
 export declare function lcm(a: BigNum, b: BigNum): BigNum;
 export declare function factorial2(ce: IBigNum, n: BigNum): BigNum;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

package/dist/types/compute-engine/numerics/numeric.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const DEFAULT_TOLERANCE = 1e-10;

package/dist/types/compute-engine/numerics/primes.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function primeFactors(n: number): {
     [factor: number]: number;
 };

package/dist/types/compute-engine/numerics/rationals.d.ts

@@ -1,7 +1,7 @@
-/* 0.35.6 */
-export declare function isRational(x: any | null): x is Rational;
-export declare function isMachineRational(x: any | null): x is [SmallInteger, SmallInteger];
-export declare function isBigRational(x: any | null): x is [bigint, bigint];
+/* 0.50.1 */
+export declare function isRational(x: unknown | null): x is Rational;
+export declare function isMachineRational(x: unknown | null): x is [SmallInteger, SmallInteger];
+export declare function isBigRational(x: unknown | null): x is [bigint, bigint];
 export declare function isZero(x: Rational): boolean;
 export declare function isPositive(x: Rational): boolean;
 export declare function isOne(x: Rational): boolean;

package/dist/types/compute-engine/numerics/richardson.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

package/dist/types/compute-engine/numerics/special-functions.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
@@ -26,3 +26,122 @@ export declare function erfc(x: number): number;
 export declare function erf(x: number): number;
 export declare function bigGammaln(ce: ComputeEngine, z: BigNum): BigNum;
 export declare function bigGamma(ce: ComputeEngine, z: BigNum): BigNum;
+/**
+ * Bignum Digamma function ψ(z) = d/dz ln(Γ(z))
+ * Same algorithm as machine `digamma`: reflection for negative z,
+ * recurrence to shift z > 7, then asymptotic expansion with Bernoulli numbers.
+ */
+export declare function bigDigamma(ce: ComputeEngine, z: BigNum): BigNum;
+/**
+ * Bignum Trigamma function ψ₁(z) = d/dz ψ(z) = d²/dz² ln(Γ(z))
+ * Same recurrence/asymptotic structure as digamma but for the second derivative.
+ */
+export declare function bigTrigamma(ce: ComputeEngine, z: BigNum): BigNum;
+/**
+ * Bignum Polygamma function ψₙ(z) = dⁿ/dzⁿ ψ(z)
+ * Delegates to bigDigamma/bigTrigamma for n=0,1.
+ * For n ≥ 2, uses recurrence + asymptotic expansion.
+ */
+export declare function bigPolygamma(ce: ComputeEngine, n: BigNum, z: BigNum): BigNum;
+/**
+ * Bignum Beta function B(a, b) = Γ(a)Γ(b)/Γ(a+b)
+ * Uses bigGamma directly.
+ */
+export declare function bigBeta(ce: ComputeEngine, a: BigNum, b: BigNum): BigNum;
+/**
+ * Bignum Riemann zeta function ζ(s)
+ * Uses Cohen-Villegas-Zagier acceleration (same algorithm as machine version).
+ */
+export declare function bigZeta(ce: ComputeEngine, s: BigNum): BigNum;
+/**
+ * Bignum Lambert W function W₀(x): principal branch satisfying W(x)·e^{W(x)} = x.
+ * Uses Halley's method with adaptive precision tolerance.
+ */
+export declare function bigLambertW(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Digamma function ψ(x) = d/dx ln(Γ(x)) = Γ'(x)/Γ(x)
+ * Uses recurrence to shift x > 7 then asymptotic expansion.
+ */
+export declare function digamma(x: number): number;
+/**
+ * Trigamma function ψ₁(x) = d/dx ψ(x) = d²/dx² ln(Γ(x))
+ * Uses recurrence + asymptotic expansion.
+ */
+export declare function trigamma(x: number): number;
+/**
+ * Polygamma function ψₙ(x) = dⁿ/dxⁿ ψ(x)
+ * PolyGamma(0, x) = Digamma(x), PolyGamma(1, x) = Trigamma(x)
+ * For n ≥ 2, uses recurrence + asymptotic expansion.
+ */
+export declare function polygamma(n: number, x: number): number;
+/**
+ * Beta function B(a, b) = Γ(a)Γ(b)/Γ(a+b)
+ * Uses gamma directly for small args (more accurate) and gammaln for large.
+ */
+export declare function beta(a: number, b: number): number;
+/**
+ * Riemann zeta function ζ(s) = Σ_{n=1}^∞ 1/n^s
+ * Uses Borwein's algorithm for convergence acceleration.
+ */
+export declare function zeta(s: number): number;
+/**
+ * Lambert W function W₀(x): the principal branch satisfying W(x)·e^{W(x)} = x.
+ * Uses Halley's method with appropriate initial guesses.
+ */
+export declare function lambertW(x: number): number;
+/**
+ * Bessel function of the first kind J_n(x) for integer order n.
+ *
+ * Uses power series for small |x|, asymptotic expansion for large |x|,
+ * and Miller's backward recurrence for intermediate values.
+ *
+ * Reference: Abramowitz & Stegun, Ch. 9; NIST DLMF 10.2, 10.17
+ */
+export declare function besselJ(n: number, x: number): number;
+/**
+ * Bessel function of the second kind Y_n(x) for integer order n.
+ *
+ * Y_0 and Y_1 computed directly via series/integrals, higher orders via
+ * forward recurrence: Y_{n+1}(x) = (2n/x)Y_n(x) - Y_{n-1}(x).
+ *
+ * Reference: NIST DLMF 10.8, 10.17
+ */
+export declare function besselY(n: number, x: number): number;
+/**
+ * Modified Bessel function of the first kind I_n(x) for integer order n.
+ *
+ * I_n(x) = i^{-n} J_n(ix) — uses power series for small |x|,
+ * scaled Miller's recurrence for intermediate, asymptotic for large |x|.
+ *
+ * Reference: NIST DLMF 10.25, 10.40
+ */
+export declare function besselI(n: number, x: number): number;
+/**
+ * Modified Bessel function of the second kind K_n(x) for integer order n.
+ *
+ * K_0 and K_1 computed via series, higher orders via forward recurrence:
+ * K_{n+1}(x) = (2n/x)K_n(x) + K_{n-1}(x).
+ *
+ * Reference: NIST DLMF 10.31, 10.40
+ */
+export declare function besselK(n: number, x: number): number;
+/**
+ * Airy function of the first kind Ai(x).
+ *
+ * For x < 0 and small |x|, uses power series.
+ * For large positive x, uses asymptotic: Ai(x) ~ e^{-ξ}/(2√π x^{1/4})
+ * For large negative x, uses asymptotic oscillatory form.
+ * For moderate x, uses power series with sufficient terms.
+ *
+ * Reference: NIST DLMF 9.2, 9.7
+ */
+export declare function airyAi(x: number): number;
+/**
+ * Airy function of the second kind Bi(x).
+ *
+ * Similar structure to Ai(x) but with different coefficients
+ * and asymptotic behavior (Bi grows for positive x).
+ *
+ * Reference: NIST DLMF 9.2, 9.7
+ */
+export declare function airyBi(x: number): number;

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

@@ -1,5 +1,4 @@
-/* 0.35.6 */
-import type { BigNum } from './types';
+/* 0.50.1 */
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(bignum: BigNumFactory, values: Iterable<BigNum>): BigNum;
 export declare function median(values: Iterable<number>): number;

package/dist/types/compute-engine/numerics/strings.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function numberToString(num: number | bigint, fractionalDigits?: number | string): string;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6
@@ -18,6 +18,8 @@ export type Rational = [SmallInteger, SmallInteger] | [bigint, bigint];
 /** @category Numerics */
 export type BigNum = Decimal;
 /** @category Numerics */
+export type BigNumFactory = (value: Decimal.Value) => Decimal;
+/** @category Numerics */
 export interface IBigNum {
     readonly _BIGNUM_NAN: BigNum;
     readonly _BIGNUM_ZERO: BigNum;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * OEIS (Online Encyclopedia of Integer Sequences) Integration
  *
  * This module provides functions to look up sequences in the OEIS database
@@ -6,7 +6,7 @@
  *
  * @see https://oeis.org
  */
-import type { ComputeEngine, BoxedExpression } from './global-types';
+import type { IComputeEngine as ComputeEngine, Expression } from './global-types';
 /**
  * Result from an OEIS lookup operation.
  */
@@ -69,7 +69,7 @@ export declare function lookupOEISById(id: string, options?: OEISOptions): Promi
  * @param options - Optional configuration
  * @returns Promise resolving to array of matching sequences
  */
-export declare function lookupSequence(ce: ComputeEngine, terms: (number | BoxedExpression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+export declare function lookupSequence(ce: ComputeEngine, terms: (number | Expression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
 /**
  * Check if a defined sequence matches an OEIS sequence.
  *

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

@@ -1,10 +1,10 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * Utilities for declarative sequence definitions.
  *
  * This module provides functions to create subscriptEvaluate handlers
  * from sequence definitions (base cases + recurrence relation).
  */
-import type { BoxedExpression, ComputeEngine, SequenceDefinition, SequenceStatus, SequenceInfo } from './global-types';
+import type { Expression, IComputeEngine as ComputeEngine, SequenceDefinition, SequenceStatus, SequenceInfo } from './global-types';
 /**
  * Create a subscriptEvaluate handler from a sequence definition.
  *
@@ -17,10 +17,10 @@ import type { BoxedExpression, ComputeEngine, SequenceDefinition, SequenceStatus
  * - Single-index: `F_{10}` with subscript as a number
  * - Multi-index: `P_{5,2}` with subscript as `Sequence(5, 2)`
  */
-export declare function createSequenceHandler(ce: ComputeEngine, name: string, def: SequenceDefinition): (subscript: BoxedExpression, options: {
+export declare function createSequenceHandler(ce: ComputeEngine, name: string, def: SequenceDefinition): (subscript: Expression, options: {
     engine: ComputeEngine;
     numericApproximation?: boolean;
-}) => BoxedExpression | undefined;
+}) => Expression | undefined;
 /**
  * Validate a sequence definition.
  */
@@ -32,41 +32,41 @@ export declare function validateSequenceDefinition(ce: ComputeEngine, name: stri
  * Add a base case for a single-index sequence definition.
  * e.g., from `L_0 := 1`
  */
-export declare function addSequenceBaseCase(ce: ComputeEngine, name: string, index: number, value: BoxedExpression): void;
+export declare function addSequenceBaseCase(ce: ComputeEngine, name: string, index: number, value: Expression): void;
 /**
  * Add a base case for a multi-index sequence definition.
  * e.g., from `P_{0,0} := 1` or `P_{n,0} := 1`
  *
  * @param key - The base case key, e.g., '0,0' for exact or 'n,0' for pattern
  */
-export declare function addMultiIndexBaseCase(ce: ComputeEngine, name: string, key: string, value: BoxedExpression): void;
+export declare function addMultiIndexBaseCase(ce: ComputeEngine, name: string, key: string, value: Expression): void;
 /**
  * Add a recurrence relation for a single-index sequence definition.
  * e.g., from `L_n := L_{n-1} + 1`
  *
- * We store the recurrence as a LaTeX string rather than a BoxedExpression
+ * We store the recurrence as a LaTeX string rather than a Expression
  * because the expression may have been parsed before the symbol was declared
  * with subscriptEvaluate. Storing as LaTeX allows us to re-parse fresh when
  * creating the handler, ensuring proper binding.
  */
-export declare function addSequenceRecurrence(ce: ComputeEngine, name: string, variable: string, expr: BoxedExpression): void;
+export declare function addSequenceRecurrence(ce: ComputeEngine, name: string, variable: string, expr: Expression): void;
 /**
  * Add a recurrence relation for a multi-index sequence definition.
  * e.g., from `P_{n,k} := P_{n-1,k-1} + P_{n-1,k}`
  *
  * @param variables - The index variable names, e.g., ['n', 'k']
  */
-export declare function addMultiIndexRecurrence(ce: ComputeEngine, name: string, variables: string[], expr: BoxedExpression): void;
+export declare function addMultiIndexRecurrence(ce: ComputeEngine, name: string, variables: string[], expr: Expression): void;
 /**
  * Check if expression contains self-reference to sequence name.
  * e.g., `a_{n-1}` when defining sequence 'a'
  */
-export declare function containsSelfReference(expr: BoxedExpression, seqName: string): boolean;
+export declare function containsSelfReference(expr: Expression, seqName: string): boolean;
 /**
  * Extract the index variable from a subscript expression.
  * e.g., from `n-1` extract 'n', from `2*k` extract 'k'
  */
-export declare function extractIndexVariable(subscript: BoxedExpression): string | undefined;
+export declare function extractIndexVariable(subscript: Expression): string | undefined;
 /**
  * Get the status of a sequence definition.
  *
@@ -99,7 +99,7 @@ export declare function clearSequenceCache(ce: ComputeEngine, name?: string): vo
  * For single-index sequences, keys are numbers.
  * For multi-index sequences, keys are comma-separated strings (e.g., '5,2').
  */
-export declare function getSequenceCache(ce: ComputeEngine, name: string): Map<number | string, BoxedExpression> | undefined;
+export declare function getSequenceCache(ce: ComputeEngine, name: string): Map<number | string, Expression> | undefined;
 /**
  * Generate a list of sequence terms from start to end (inclusive).
  *
@@ -117,4 +117,4 @@ export declare function getSequenceCache(ce: ComputeEngine, name: string): Map<n
  * // → [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
  * ```
  */
-export declare function generateSequenceTerms(ce: ComputeEngine, name: string, start: number, end: number, step?: number): BoxedExpression[] | undefined;
+export declare function generateSequenceTerms(ce: ComputeEngine, name: string, start: number, end: number, step?: number): Expression[] | undefined;

package/dist/types/compute-engine/symbolic/antiderivative.d.ts

@@ -1,3 +1,3 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** Calculate the antiderivative of fn, as an expression (not a function) */
-export declare function antiderivative(fn: BoxedExpression, index: string): BoxedExpression;
+export declare function antiderivative(fn: Expression, index: string): Expression;

package/dist/types/compute-engine/symbolic/derivative.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  *
  * @param fn The function to differentiate, a function literal.
@@ -6,7 +6,7 @@
  * @returns a function expression representing the derivative of `fn` with
  * respect to the variables in `degrees`.
  */
-export declare function derivative(fn: BoxedExpression, order: number): BoxedExpression | undefined;
+export declare function derivative(fn: Expression, order: number): Expression | undefined;
 /**
  * Calculate the partial derivative of an expression with respect to a
  * variable, `v`.
@@ -30,4 +30,4 @@ export declare function derivative(fn: BoxedExpression, order: number): BoxedExp
  * @param depth - Internal recursion depth counter (do not pass manually)
  * @returns The derivative expression, or `undefined` if unable to differentiate
  */
-export declare function differentiate(expr: BoxedExpression, v: string, depth?: number): BoxedExpression | undefined;
+export declare function differentiate(expr: Expression, v: string, depth?: number): Expression | undefined;

package/dist/types/compute-engine/symbolic/distribute.d.ts

@@ -1,5 +1,5 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  *
  */
-export declare function distribute(expr: BoxedExpression, g?: string, f?: string): BoxedExpression;
+export declare function distribute(expr: Expression, g?: string, f?: string): Expression;

package/dist/types/compute-engine/symbolic/fu-cost.d.ts

@@ -1,20 +1,20 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,
  * with secondary consideration for overall expression complexity.
  */
-import type { BoxedExpression } from '../global-types';
+import type { Expression } from '../global-types';
 /**
  * Count the number of trigonometric function occurrences in an expression.
  * This is the primary metric for the Fu algorithm.
  */
-export declare function countTrigFunctions(expr: BoxedExpression): number;
+export declare function countTrigFunctions(expr: Expression): number;
 /**
  * Count the number of leaves (atoms) in an expression.
  * Includes symbols, numbers, and function names.
  */
-export declare function countLeaves(expr: BoxedExpression): number;
+export declare function countLeaves(expr: Expression): number;
 /**
  * The default trig cost function for the Fu algorithm.
  *
@@ -25,8 +25,8 @@ export declare function countLeaves(expr: BoxedExpression): number;
  * This ensures that expressions with fewer trig functions are always
  * preferred, even if they have slightly more total operations.
  */
-export declare function trigCost(expr: BoxedExpression): number;
-export type TrigCostFunction = (expr: BoxedExpression) => number;
+export declare function trigCost(expr: Expression): number;
+export type TrigCostFunction = (expr: Expression) => number;
 /**
  * Default cost function for the Fu algorithm
  */