@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import type { Rational } from '../numerics/types';
-export declare function asRadical(expr: BoxedExpression): Rational | null;
+export declare function asRadical(expr: Expression): Rational | null;
 /**
  *
  * Produce the canonical form of the operands of a Power expression, returning either the operation
@@ -19,8 +19,8 @@ export declare function asRadical(expr: BoxedExpression): Rational | null;
  * @param b
  * @returns
  */
-export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;
-export declare function canonicalRoot(a: BoxedExpression, b: BoxedExpression | number): BoxedExpression;
+export declare function canonicalPower(a: Expression, b: Expression): Expression;
+export declare function canonicalRoot(a: Expression, b: Expression | number): Expression;
 /**
  * The power function.
  *
@@ -30,9 +30,9 @@ export declare function canonicalRoot(a: BoxedExpression, b: BoxedExpression | n
  * See https://docs.sympy.org/latest/modules/core.html#sympy.core.power.Pow
  *
  */
-export declare function pow(x: BoxedExpression, exp: number | BoxedExpression, { numericApproximation }: {
+export declare function pow(x: Expression, exp: number | Expression, { numericApproximation }: {
     numericApproximation: boolean;
-}): BoxedExpression;
-export declare function root(a: BoxedExpression, b: BoxedExpression, { numericApproximation }: {
+}): Expression;
+export declare function root(a: Expression, b: Expression, { numericApproximation }: {
     numericApproximation: boolean;
-}): BoxedExpression;
+}): Expression;

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

@@ -1,11 +1,8 @@
-/* 0.35.6 */
-export type AsciiMathSerializer = (expr: BoxedExpression, precedence?: number) => string;
+/* 0.50.1 */
+export type AsciiMathSerializer = (expr: Expression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;
-    operators: Record<string, [
-        string | ((expr: BoxedExpression) => string),
-        number
-    ]>;
-    functions: Record<string, string | ((expr: BoxedExpression, serialize: AsciiMathSerializer) => string)>;
+    operators: Record<string, [string | ((expr: Expression) => string), number]>;
+    functions: Record<string, string | ((expr: Expression, serialize: AsciiMathSerializer) => string)>;
 };
-export declare function toAsciiMath(expr: BoxedExpression, options?: Partial<AsciiMathOptions>, precedence?: number): string;
+export declare function toAsciiMath(expr: Expression, options?: Partial<AsciiMathOptions>, precedence?: number): string;

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

@@ -1,6 +1,61 @@
-/* 0.35.6 */
-import { MathJsonSymbol } from '../../math-json/types';
+/* 0.50.1 */
+import type { FormOption } from '../types-serialization';
+import type { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';
+/**
+ * ### THEORY OF OPERATIONS
+ *
+ *
+ * 1/ The result of boxing is canonical by default.
+ *
+ *   This is the most common need (i.e. to evaluate an expression you need it
+ *   in canonical form). Creating a boxed expression which is canonical from the
+ *   start avoid going through an intermediary step with a non-canonical
+ *   expression.
+ *
+ * 2/ When boxing (and canonicalizing), if the function is "scoped", a new
+ *    scope is created before the canonicalization, so that any declaration
+ *    are done within that scope. Example of scoped functions include `Block`
+ *    and `Sum`.
+ *
+ * 3/ When implementing an `evaluate()`:
+ * - if `bignumPreferred()` all operations should be done in bignum,
+ *    otherwise, they should all be done in machine numbers.
+ * - if a rational is encountered, preserve it
+ * - if a `Sqrt` of a rational is encountered, preserve it
+ * - if a `hold` constant is encountered, preserve it
+ * - if `numericApproximation` is false and one of the arguments is not exact,
+ *  return an approximation
+ * - if `numericApproximation` is true, always return an approximation
+ *
+ * NUMERIC APPROXIMATION = FALSE
+ * - 2 + 5 -> 7
+ * - 2 + 5/7 -> 19/7
+ * - 2 + √2 -> 2 + √2
+ * - 2 + √(5/7) -> 2 + √(5/7)
+ * - 5/7 + 9/11 -> 118/77
+ * - 5/7 + √2 -> 5/7 + √2
+ * - 10/14 + √(18/9) -> 5/7 + √2
+ * - √2 + √5 -> √2 + √5
+ * - √2 + √2 -> 2√2
+ * - sin(2) -> sin(2)
+ * - sin(pi/3) -> √3/2
+ * - 2 + 2.1 -> 2 + 2.1
+ *
+ * NUMERIC APPROXIMATION = TRUE
+ * - 2 + 2.1 -> 4.1
+ * - 2 + √2.1 -> 3.44914
+ * - 5/7 + √2.1 -> 2.16342
+ * - sin(2) + √2.1 -> 2.35844
+ */
+/**
+ * Translate a public `FormOption` to the internal
+ * `{ canonical, structural }` representation.
+ */
+export declare function formToInternal(form?: FormOption): {
+    canonical: CanonicalOptions;
+    structural: boolean;
+};
 /**
  * Given a name and a set of arguments, return a boxed function expression.
  *
@@ -8,16 +63,16 @@ import { NumericValue } from '../numeric-value/types';
  *
  * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops: readonly SemiBoxedExpression[], options?: {
+export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops: readonly ExpressionInput[], options?: {
     metadata?: Metadata;
     canonical?: CanonicalOptions;
     structural?: boolean;
     scope?: Scope;
-}): BoxedExpression;
+}): Expression;
 /**
  * Notes about the boxed form:
  *
- * [1] Expression with an operator of `Number`, `String`, `Symbol` and `Dictionary`
+ * [1] MathJsonExpression with an operator of `Number`, `String`, `Symbol` and `Dictionary`
  *      are converted to the corresponding atomic expression.
  *
  * [2] Expressions with an operator of `Complex` are converted to a (complex) number
@@ -39,9 +94,9 @@ export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops
  * Note that this function should only be called from `ce.box()`
  *
  */
-export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
+export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | ExpressionInput, options?: {
     canonical?: CanonicalOptions;
     structural?: boolean;
     scope?: Scope;
-}): BoxedExpression;
-export declare function semiCanonical(ce: ComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>, scope?: Scope): ReadonlyArray<BoxedExpression>;
+}): Expression;
+export declare function semiCanonical(ce: ComputeEngine, xs: ReadonlyArray<ExpressionInput>, scope?: Scope): ReadonlyArray<Expression>;

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

@@ -1,44 +1,45 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
-import { DictionaryValue, Expression } from '../../math-json/types';
+import { DictionaryValue, MathJsonExpression } from '../../math-json/types';
 /**
  * BoxedDictionary
  *
  */
 export declare class BoxedDictionary extends _BoxedExpression implements DictionaryInterface {
+    readonly _kind = "dictionary";
     [Symbol.toStringTag]: string;
     private readonly _keyValues;
     private _type;
     /** The input to the constructor is either a ["Dictionary", ["KeyValuePair", ..., ...], ...] expression or a record of key-value pairs */
-    constructor(ce: ComputeEngine, keyValues: Record<string, DictionaryValue> | BoxedExpression, options?: {
+    constructor(ce: ComputeEngine, keyValues: Record<string, DictionaryValue> | Expression, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
     private _initFromRecord;
     private _initFromExpression;
-    get json(): Expression;
-    toMathJson(options: Readonly<JsonSerializationOptions>): Expression;
+    get json(): MathJsonExpression;
+    toMathJson(options: Readonly<JsonSerializationOptions>): MathJsonExpression;
     get hash(): number;
     get operator(): string;
     get type(): BoxedType;
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get value(): BoxedExpression | undefined;
+    get value(): Expression | undefined;
     get complexity(): number;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    contains(_rhs: BoxedExpression): boolean | undefined;
+    contains(_rhs: Expression): boolean | undefined;
     get count(): number | undefined;
     get isEmptyCollection(): boolean;
     get isFiniteCollection(): boolean;
-    each(): Generator<BoxedExpression>;
-    get(key: string): BoxedExpression | undefined;
+    each(): Generator<Expression>;
+    get(key: string): Expression | undefined;
     has(key: string): boolean;
     get keys(): string[];
-    get entries(): [string, BoxedExpression][];
-    get values(): BoxedExpression[];
-    match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
+    get entries(): [string, Expression][];
+    get values(): Expression[];
+    match(pattern: Expression, _options?: PatternMatchOptions): BoxedSubstitution | null;
 }

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition } from '../global-types';
+/* 0.50.1 */
+import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, Expression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, IComputeEngine as ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition, FunctionInterface } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';
@@ -15,7 +15,8 @@ import { _BoxedExpression } from './abstract-boxed-expression';
  * The definition contains its signature and its evaluation handler.
  *
  */
-export declare class BoxedFunction extends _BoxedExpression {
+export declare class BoxedFunction extends _BoxedExpression implements FunctionInterface {
+    readonly _kind = "function";
     private readonly _operator;
     private readonly _ops;
     private _def;
@@ -33,7 +34,7 @@ export declare class BoxedFunction extends _BoxedExpression {
     private _valueN;
     private _sgn;
     private _type;
-    constructor(ce: ComputeEngine, operator: string, ops: ReadonlyArray<BoxedExpression>, options?: {
+    constructor(ce: ComputeEngine, operator: string, ops: ReadonlyArray<Expression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
         structural?: boolean;
@@ -47,28 +48,28 @@ export declare class BoxedFunction extends _BoxedExpression {
     infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
     bind(): void;
     reset(): void;
-    get value(): BoxedExpression | undefined;
+    get value(): Expression | undefined;
     get isCanonical(): boolean;
     get isPure(): boolean;
     get isConstant(): boolean;
     get constantValue(): number | boolean | string | object | undefined;
-    get json(): Expression;
+    get json(): MathJsonExpression;
     get operator(): string;
-    get ops(): ReadonlyArray<BoxedExpression>;
+    get ops(): ReadonlyArray<Expression>;
     get nops(): number;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
+    get op1(): Expression;
+    get op2(): Expression;
+    get op3(): Expression;
     get isScoped(): boolean;
     get localScope(): Scope | undefined;
     get isValid(): boolean;
     /** Note: if the expression is not canonical, this will return a canonical
      * version of the expression in the current lexical scope.
      */
-    get canonical(): BoxedExpression;
-    get structural(): BoxedExpression;
+    get canonical(): Expression;
+    get structural(): Expression;
     get isStructural(): boolean;
-    toNumericValue(): [NumericValue, BoxedExpression];
+    toNumericValue(): [NumericValue, Expression];
     /**
      * Note: the result is bound to the current scope, not the scope of the
      * original expression.
@@ -76,9 +77,9 @@ export declare class BoxedFunction extends _BoxedExpression {
      */
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    }): Expression;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): Expression | null;
+    match(pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;
     has(v: string | string[]): boolean;
     get sgn(): Sign | undefined;
     get isNaN(): boolean | undefined;
@@ -90,19 +91,19 @@ export declare class BoxedFunction extends _BoxedExpression {
     get isNonNegative(): boolean | undefined;
     get isNegative(): boolean | undefined;
     get isNonPositive(): boolean | undefined;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
+    get numerator(): Expression;
+    get denominator(): Expression;
+    get numeratorDenominator(): [Expression, Expression];
+    neg(): Expression;
+    inv(): Expression;
+    abs(): Expression;
+    add(rhs: number | Expression): Expression;
+    mul(rhs: NumericValue | number | Expression): Expression;
+    div(rhs: number | Expression): Expression;
+    pow(exp: number | Expression): Expression;
+    root(exp: number | Expression): Expression;
+    sqrt(): Expression;
+    ln(semiBase?: number | Expression): Expression;
     get complexity(): number | undefined;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get operatorDefinition(): BoxedOperatorDefinition | undefined;
@@ -111,30 +112,30 @@ export declare class BoxedFunction extends _BoxedExpression {
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
     get isReal(): boolean | undefined;
-    get isFunctionExpression(): boolean;
+    get isFunctionExpression(): true;
     /** The type of the value of the function */
     get type(): BoxedType;
     /** The shape of the tensor (dimensions), derived from the type */
     get shape(): number[];
     /** The rank of the tensor (number of dimensions), derived from the type */
     get rank(): number;
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
-    N(): BoxedExpression;
-    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression> | Record<string, BoxedExpression> | Array<Record<string, BoxedExpression>>;
+    simplify(options?: Partial<SimplifyOptions>): Expression;
+    evaluate(options?: Partial<EvaluateOptions>): Expression;
+    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<Expression>;
+    N(): Expression;
+    solve(vars?: Iterable<string> | string | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    contains(rhs: BoxedExpression): boolean | undefined;
+    contains(rhs: Expression): boolean | undefined;
     get count(): number | undefined;
     get isEmptyCollection(): boolean | undefined;
     get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(index: number): BoxedExpression | undefined;
-    get(index: BoxedExpression | string): BoxedExpression | undefined;
-    indexWhere(predicate: (element: BoxedExpression) => boolean): number | undefined;
-    subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
-    _computeValue(options?: Partial<EvaluateOptions>): () => BoxedExpression;
-    _computeValueAsync(options?: Partial<EvaluateOptions>): () => Promise<BoxedExpression>;
+    each(): Generator<Expression>;
+    at(index: number): Expression | undefined;
+    get(index: Expression | string): Expression | undefined;
+    indexWhere(predicate: (element: Expression) => boolean): number | undefined;
+    subsetOf(rhs: Expression, strict: boolean): boolean;
+    _computeValue(options?: Partial<EvaluateOptions>): () => Expression;
+    _computeValueAsync(options?: Partial<EvaluateOptions>): () => Promise<Expression>;
 }

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

@@ -1,16 +1,17 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { Decimal } from 'decimal.js';
-import type { Expression, MathJsonNumberObject } from '../../math-json';
+import type { MathJsonExpression, MathJsonNumberObject } from '../../math-json';
 import type { Rational, SmallInteger } from '../numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/types';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, BoxedExpression, PatternMatchOptions, ReplaceOptions, SimplifyOptions } from '../global-types';
+import type { BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, IComputeEngine as ComputeEngine, Metadata, Rule, Sign, Substitution, Expression, PatternMatchOptions, ReplaceOptions, SimplifyOptions, NumberLiteralInterface } from '../global-types';
 /**
  * BoxedNumber
  *
  */
-export declare class BoxedNumber extends _BoxedExpression {
+export declare class BoxedNumber extends _BoxedExpression implements NumberLiteralInterface {
+    readonly _kind = "number";
     protected readonly _value: SmallInteger | NumericValue;
     private _hash;
     /**
@@ -29,7 +30,7 @@ export declare class BoxedNumber extends _BoxedExpression {
         metadata?: Metadata;
     });
     get hash(): number;
-    get json(): Expression;
+    get json(): MathJsonExpression;
     get operator(): string;
     get isPure(): boolean;
     get isCanonical(): boolean;
@@ -48,32 +49,32 @@ export declare class BoxedNumber extends _BoxedExpression {
      */
     valueOf(): number | string;
     get numericValue(): number | NumericValue;
-    get isNumberLiteral(): boolean;
+    get isNumberLiteral(): true;
     get re(): number;
     get im(): number;
     get bignumRe(): Decimal | undefined;
     get bignumIm(): Decimal | undefined;
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    get value(): BoxedExpression;
+    neg(): Expression;
+    inv(): Expression;
+    abs(): Expression;
+    add(rhs: number | Expression): Expression;
+    mul(rhs: NumericValue | number | Expression): Expression;
+    div(rhs: number | Expression): Expression;
+    pow(exp: number | Expression): Expression;
+    root(exp: number | Expression): Expression;
+    sqrt(): Expression;
+    ln(semiBase?: number | Expression): Expression;
+    get value(): Expression;
     get type(): BoxedType;
     get sgn(): Sign | undefined;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    get numerator(): Expression;
+    get denominator(): Expression;
+    get numeratorDenominator(): [Expression, Expression];
     subs(sub: Substitution, options?: {
         canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): BoxedExpression | null;
-    match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    }): Expression;
+    replace(rules: BoxedRuleSet | Rule | Rule[], options?: Partial<ReplaceOptions>): Expression | null;
+    match(pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;
     /** x > 0, same as `isGreater(0)` */
     get isPositive(): boolean | undefined;
     /** x >= 0, same as `isGreaterEqual(0)` */
@@ -91,13 +92,13 @@ export declare class BoxedNumber extends _BoxedExpression {
     get isInteger(): boolean;
     get isRational(): boolean;
     get isReal(): boolean;
-    is(other: BoxedExpression | number | bigint | boolean): boolean;
-    get canonical(): BoxedExpression;
+    is(other: Expression | number | bigint | boolean): boolean;
+    get canonical(): Expression;
     get isStructural(): boolean;
-    get structural(): BoxedExpression;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
-    evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
-    N(): BoxedExpression;
+    get structural(): Expression;
+    toNumericValue(): [NumericValue, Expression];
+    simplify(options?: Partial<SimplifyOptions>): Expression;
+    evaluate(options?: Partial<EvaluateOptions>): Expression;
+    N(): Expression;
 }
 export declare function canonicalNumber(ce: ComputeEngine, value: number | bigint | string | Decimal | Complex | Rational | NumericValue | MathJsonNumberObject): number | NumericValue;

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { BoxedType } from '../../common/type/boxed-type';
-import type { OperatorDefinition, BoxedExpression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, Sign } from '../global-types';
+import type { OperatorDefinition, Expression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, IComputeEngine as ComputeEngine, Sign } from '../global-types';
 export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {
     engine: ComputeEngine;
     name: string;
@@ -10,7 +10,7 @@ export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition
     broadcastable: boolean;
     associative: boolean;
     commutative: boolean;
-    commutativeOrder: ((a: BoxedExpression, b: BoxedExpression) => number) | undefined;
+    commutativeOrder: ((a: Expression, b: Expression) => number) | undefined;
     idempotent: boolean;
     involution: boolean;
     pure: boolean;
@@ -19,34 +19,34 @@ export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition
     scoped: boolean;
     signature: BoxedType;
     inferredSignature: boolean;
-    type?: (ops: ReadonlyArray<BoxedExpression>, options: {
+    type?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
     }) => BoxedType | Type | TypeString | undefined;
-    sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
+    sgn?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
     }) => Sign | undefined;
-    eq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
-    neq?: (a: BoxedExpression, b: BoxedExpression) => boolean | undefined;
-    even?: (ops: ReadonlyArray<BoxedExpression>, options: {
+    eq?: (a: Expression, b: Expression) => boolean | undefined;
+    neq?: (a: Expression, b: Expression) => boolean | undefined;
+    even?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
     }) => boolean | undefined;
-    canonical?: (ops: ReadonlyArray<BoxedExpression>, options: {
+    canonical?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
-    }) => BoxedExpression | null;
-    evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
+    }) => Expression | null;
+    evaluate?: (ops: ReadonlyArray<Expression>, options: Partial<EvaluateOptions> & {
         engine: ComputeEngine;
-    }) => BoxedExpression | undefined;
-    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
+    }) => Expression | undefined;
+    evaluateAsync?: (ops: ReadonlyArray<Expression>, options?: Partial<EvaluateOptions> & {
         engine?: ComputeEngine;
-    }) => Promise<BoxedExpression | undefined>;
-    evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
+    }) => Promise<Expression | undefined>;
+    evalDimension?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
-    }) => BoxedExpression;
-    compile?: (expr: BoxedExpression) => CompiledExpression;
+    }) => Expression;
+    compile?: (expr: Expression) => CompiledExpression;
     collection?: CollectionHandlers;
     constructor(ce: ComputeEngine, name: string, def: OperatorDefinition);
     /** For debugging */
-    toJSON(): any;
+    toJSON(): Record<string, unknown>;
     infer(sig: Type): void;
     update(def: OperatorDefinition): void;
     onConfigurationChange(): void;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * # Pattern Matching Wildcards
  *
  * Patterns can contain wildcards that match parts of expressions. There are
@@ -53,41 +53,9 @@
  *
  * @module boxed-patterns
  */
-import type { BoxedSymbol } from './boxed-symbol';
-import type { BoxedExpression } from '../global-types';
-/**
- * Check if an expression is a wildcard (universal, sequence, or optional sequence).
- *
- * @param expr - The expression to check
- * @returns `true` if the expression is any type of wildcard
- */
-export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
-/**
- * Get the string representation of a wildcard expression.
- *
- * Returns the wildcard symbol including its name (if any):
- * - `'_'` for anonymous universal wildcard
- * - `'_a'` for named universal wildcard
- * - `'__'` for anonymous sequence wildcard
- * - `'__args'` for named sequence wildcard
- * - `'___'` for anonymous optional sequence wildcard
- * - `'___rest'` for named optional sequence wildcard
- *
- * @param expr - The expression to get the wildcard name from
- * @returns The wildcard string, or `null` if not a wildcard
- */
-export declare function wildcardName(expr: BoxedExpression): string | null;
-/**
- * Determine the type of wildcard.
- *
- * @param expr - A BoxedExpression or wildcard symbol string
- * @returns
- * - `'Wildcard'` - Universal wildcard (`_` or `_name`), matches exactly one element
- * - `'Sequence'` - Sequence wildcard (`__` or `__name`), matches one or more elements
- * - `'OptionalSequence'` - Optional sequence (`___` or `___name`), matches zero or more elements
- * - `null` - Not a wildcard
- */
-export declare function wildcardType(expr: BoxedExpression | string): 'Wildcard' | 'Sequence' | 'OptionalSequence' | null;
+import type { Expression } from '../global-types';
+import { isWildcard, wildcardName, wildcardType } from './pattern-utils';
+export { isWildcard, wildcardName, wildcardType };
 /**
  * Validate a pattern for invalid wildcard combinations.
  *
@@ -104,4 +72,4 @@ export declare function wildcardType(expr: BoxedExpression | string): 'Wildcard'
  * @param pattern - The pattern to validate
  * @throws Error if the pattern contains invalid wildcard combinations
  */
-export declare function validatePattern(pattern: BoxedExpression): void;
+export declare function validatePattern(pattern: Expression): void;

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

@@ -1,11 +1,12 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedString
  *
  */
-export declare class BoxedString extends _BoxedExpression {
+export declare class BoxedString extends _BoxedExpression implements StringInterface {
+    readonly _kind = "string";
     [Symbol.toStringTag]: string;
     private readonly _string;
     private _utf8Buffer?;
@@ -17,11 +18,11 @@ export declare class BoxedString extends _BoxedExpression {
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get value(): BoxedExpression;
+    get value(): Expression;
     get type(): BoxedType;
     get complexity(): number;
     get string(): string;
     get buffer(): Uint8Array;
     get unicodeScalars(): number[];
-    match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
+    match(pattern: Expression, _options?: PatternMatchOptions): BoxedSubstitution | null;
 }