@cortex-js/compute-engine 0.30.1 → 0.31.0

package/dist/types/common/type/parser.d.ts

@@ -0,0 +1,45 @@
+/* 0.31.0 */
+import { TypeNode } from './ast-nodes';
+import { TypeResolver } from './types';
+export declare class Parser {
+    private lexer;
+    private typeResolver;
+    private current;
+    constructor(input: string, options?: {
+        typeResolver?: TypeResolver;
+    });
+    error(message: string, suggestion?: string): never;
+    errorAtToken(token: Token, message: string, suggestion?: string): never;
+    private advance;
+    private match;
+    private expect;
+    private createNode;
+    parseType(): TypeNode;
+    private checkForNakedFunctionSignature;
+    private parseUnionType;
+    private parseIntersectionType;
+    private parsePrimaryType;
+    private parseFunctionSignature;
+    private parseArgument;
+    private parseNamedElement;
+    private parseListType;
+    private parseListTypeImpl;
+    private parseVectorType;
+    private parseMatrixType;
+    private parseTensorType;
+    private parseDimensions;
+    private parseDimension;
+    private parseDimensionWithX;
+    private parseTupleType;
+    private parseRecordType;
+    private parseRecordEntry;
+    private parseDictionaryType;
+    private parseSetType;
+    private parseCollectionType;
+    private parseExpressionType;
+    private parseSymbolType;
+    private parseNumericType;
+    private parsePrimitiveType;
+    private parseValue;
+    private parseTypeReference;
+}

package/dist/types/common/type/primitive.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** All the types representing numeric values */
 export declare const NUMERIC_TYPES: NumericPrimitiveType[];
 export declare const INDEXED_COLLECTION_TYPES: PrimitiveType[];

package/dist/types/common/type/serialize.d.ts

@@ -1,2 +1,2 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
 /** Return true if lhs is a subtype of rhs */

package/dist/types/common/type/type-builder.d.ts

@@ -0,0 +1,32 @@
+/* 0.31.0 */
+import { Type, TypeResolver } from './types';
+export declare class TypeBuilder implements ASTVisitor<Type> {
+    private typeResolver;
+    constructor(typeResolver?: TypeResolver);
+    buildType(node: TypeNode): Type;
+    visitFunctionSignature(node: FunctionSignatureNode): Type;
+    visitUnionType(node: UnionTypeNode): Type;
+    visitIntersectionType(node: IntersectionTypeNode): Type;
+    visitNegationType(node: NegationTypeNode): Type;
+    visitGroupType(node: GroupTypeNode): Type;
+    visitListType(node: ListTypeNode): Type;
+    visitVectorType(node: VectorTypeNode): Type;
+    visitMatrixType(node: MatrixTypeNode): Type;
+    visitTensorType(node: TensorTypeNode): Type;
+    visitTupleType(node: TupleTypeNode): Type;
+    visitRecordType(node: RecordTypeNode): Type;
+    visitDictionaryType(node: DictionaryTypeNode): Type;
+    visitSetType(node: SetTypeNode): Type;
+    visitCollectionType(node: CollectionTypeNode): Type;
+    visitExpressionType(node: ExpressionTypeNode): Type;
+    visitSymbolType(node: SymbolTypeNode): Type;
+    visitNumericType(node: NumericTypeNode): Type;
+    visitPrimitiveType(node: PrimitiveTypeNode): Type;
+    visitTypeReference(node: TypeReferenceNode): Type;
+    visitValue(node: ValueNode): Type;
+    private buildNamedElement;
+    private buildDimension;
+    private buildValue;
+    private isAnyType;
+}
+export declare function buildTypeFromAST(node: TypeNode, typeResolver?: TypeResolver): Type;

package/dist/types/common/type/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type

package/dist/types/common/type/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** Convert two or more types into a more specific type that is a subtype of
  *  all the input types. The resulting type is usually more constrained and
  *  only encompasses values that belong to both input types.

package/dist/types/common/utils.d.ts

@@ -1,2 +1,23 @@
-/* 0.30.1 */
+/* 0.31.0 */
+ *
+ * <!--
+ * !@consider?
+ * - In terms of BoxedExpressions - optimizations which are always desirable to take place are
+ * possible...
+ *  ^Perhaps then, a wrapper BoxedExpr. utility for specifying these permutations via 'condition'
+ *  would be apt...?
+ *
+ * - ^If wishing to take adv. of this, the 'condition' callback would likely benefit from a second parameter typed as a collection
+ * ('Set' if enforcing unique) with all hitherto (arbitrary representations) of generated
+ * permutations.
+ *  (See commented snippets within function signature below.)
+ * -->
+ *
+ * @export
+ * @template T
+ * @param xs
+ * @param [condition]
+ * @returns
+ */
+export declare function permutations<T>(xs: ReadonlyArray<T>, condition?: (xs: ReadonlyArray<T>) => boolean): ReadonlyArray<ReadonlyArray<T>>;
 export declare function hidePrivateProperties(obj: any): void;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -140,7 +140,7 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     N(): BoxedExpression;
     compile(options?: {
-        to?: 'javascript';
+        to?: 'javascript' | 'wgsl' | 'python' | 'webassembly';
         functions?: Record<MathJsonSymbol, string | ((...any: any[]) => any)>;
         vars?: Record<MathJsonSymbol, string>;
         imports?: ((...any: any[]) => any)[];
@@ -152,9 +152,9 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    xcontains(_rhs: BoxedExpression): boolean | undefined;
+    contains(_rhs: BoxedExpression): boolean | undefined;
     subsetOf(_target: BoxedExpression, _strict: boolean): boolean | undefined;
-    get xsize(): number | undefined;
+    get count(): number | undefined;
     get isEmptyCollection(): boolean | undefined;
     get isFiniteCollection(): boolean | undefined;
     each(): Generator<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { Decimal } from 'decimal.js';
 import type { BoxedExpression } from '../global-types';
 export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: BoxedExpression): Rational | null;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export type AsciiMathSerializer = (expr: BoxedExpression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';
 /**

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

@@ -1,7 +1,7 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
-import { Expression } from '../../math-json/types';
+import { DictionaryValue, Expression } from '../../math-json/types';
 /**
  * BoxedDictionary
  *
@@ -10,13 +10,15 @@ export declare class BoxedDictionary extends _BoxedExpression implements Diction
     [Symbol.toStringTag]: string;
     private readonly _keyValues;
     private _type;
-    constructor(ce: ComputeEngine, keyValues: Record<string, SemiBoxedExpression> | BoxedExpression, options?: {
+    /** 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?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
     private _initFromRecord;
     private _initFromExpression;
     get json(): Expression;
+    toMathJson(options: Readonly<JsonSerializationOptions>): Expression;
     get hash(): number;
     get operator(): string;
     get type(): BoxedType;
@@ -28,8 +30,8 @@ export declare class BoxedDictionary extends _BoxedExpression implements Diction
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    xcontains(_rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number | undefined;
+    contains(_rhs: BoxedExpression): boolean | undefined;
+    get count(): number | undefined;
     get isEmptyCollection(): boolean;
     get isFiniteCollection(): boolean;
     each(): Generator<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { SimplifyOptions, ReplaceOptions, PatternMatchOptions, BoxedExpression, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, EvaluateOptions, ComputeEngine, Metadata, Rule, Sign, Substitution, Scope, BoxedValueDefinition } from '../global-types';
 import { Type } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -122,8 +122,8 @@ export declare class BoxedFunction extends _BoxedExpression {
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    xcontains(rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number | undefined;
+    contains(rhs: BoxedExpression): boolean | undefined;
+    get count(): number | undefined;
     get isEmptyCollection(): boolean | undefined;
     get isFiniteCollection(): boolean | undefined;
     each(): Generator<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { Decimal } from 'decimal.js';
 import type { Expression, MathJsonNumberObject } from '../../math-json';
 import type { Rational, SmallInteger } from '../numerics/types';

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { OperatorDefinition, BoxedExpression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, ComputeEngine, Sign } from '../global-types';
 export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {

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

@@ -1,4 +1,107 @@
-/* 0.30.1 */
+/* 0.31.0 */
+ * # Pattern Matching Wildcards
+ *
+ * Patterns can contain wildcards that match parts of expressions. There are
+ * three types of wildcards:
+ *
+ * ## Universal Wildcard (`_` or `_name`)
+ * Matches exactly **one** expression element.
+ *
+ * - `_` - Anonymous wildcard (matches one element, not captured)
+ * - `_a`, `_x`, `_foo` - Named wildcard (matches one element, captured in substitution)
+ *
+ * **Examples:**
+ * - Pattern `['Add', '_a', 1]` matches `['Add', 'x', 1]` with `{_a: 'x'}`
+ * - Pattern `['Add', '_', '_']` matches any binary Add expression
+ *
+ * ## Sequence Wildcard (`__` or `__name`)
+ * Matches **one or more** expression elements.
+ *
+ * - `__` - Anonymous sequence (matches 1+ elements, not captured)
+ * - `__a`, `__args` - Named sequence (matches 1+ elements, captured as array)
+ *
+ * **Examples:**
+ * - Pattern `['Add', '__a']` matches `['Add', 1, 2, 3]` with `{__a: [1, 2, 3]}`
+ * - Pattern `['f', '__args']` captures all arguments of function f
+ *
+ * ## Optional Sequence Wildcard (`___` or `___name`)
+ * Matches **zero or more** expression elements.
+ *
+ * - `___` - Anonymous optional sequence (matches 0+ elements, not captured)
+ * - `___a`, `___rest` - Named optional sequence (matches 0+ elements, captured)
+ *
+ * **Examples:**
+ * - Pattern `['Add', 1, '___rest']` matches `['Add', 1]` with `{___rest: []}`
+ * - Pattern `['Add', 1, '___rest']` matches `['Add', 1, 2, 3]` with `{___rest: [2, 3]}`
+ *
+ * ## Validation Rules
+ *
+ * Consecutive multi-element wildcards (`__` or `___`) are **invalid** because
+ * there's no way to determine where one ends and the next begins:
+ *
+ * - **Invalid:** `['Add', '__a', '__b']` - How to split elements between `__a` and `__b`?
+ * - **Invalid:** `['Add', '___a', '___b']` - Same ambiguity
+ * - **Invalid:** `['Add', '__a', '___b']` - Same ambiguity
+ *
+ * However, multi-element wildcards followed by universal wildcards are **valid**
+ * because the single-element wildcard provides an anchor point:
+ *
+ * - **Valid:** `['Add', '__a', '_b']` - `_b` matches last element, `__a` gets the rest
+ * - **Valid:** `['Add', '___a', '_b', '___c']` - `_b` anchors the middle
+ *
+ * Use `validatePattern()` to check patterns for these invalid combinations.
+ *
+ * @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;
+/**
+ * Validate a pattern for invalid wildcard combinations.
+ *
+ * Throws an error if the pattern contains consecutive multi-element wildcards:
+ * - Sequence (`__`) followed by Sequence (`__`) or OptionalSequence (`___`)
+ * - OptionalSequence (`___`) followed by Sequence (`__`) or OptionalSequence (`___`)
+ *
+ * These patterns are ambiguous because there's no delimiter to determine where
+ * one sequence ends and the next begins.
+ *
+ * Sequence or OptionalSequence followed by universal Wildcard (`_`) is allowed
+ * because the single-element wildcard provides an anchor point.
+ *
+ * @param pattern - The pattern to validate
+ * @throws Error if the pattern contains invalid wildcard combinations
+ */
+export declare function validatePattern(pattern: BoxedExpression): void;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BoxedType } from '../../common/type/boxed-type';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { Type, TypeString } from '../../common/type/types';
 import type { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -158,8 +158,8 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    xcontains(rhs: BoxedExpression): boolean | undefined;
-    get xsize(): number;
+    contains(rhs: BoxedExpression): boolean | undefined;
+    get count(): number;
     get isEmptyCollection(): boolean;
     get isFiniteCollection(): boolean | undefined;
     each(): Generator<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, BoxedExpression, SimplifyOptions, PatternMatchOptions, Tensor } from '../global-types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';
@@ -67,8 +67,8 @@ export declare class BoxedTensor<T extends TensorDataType> extends _BoxedExpress
     isEqual(rhs: number | BoxedExpression): boolean | undefined;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
-    xcontains(other: BoxedExpression): boolean | undefined;
-    get xsize(): number;
+    contains(other: BoxedExpression): boolean | undefined;
+    get count(): number;
     each(): Generator<BoxedExpression>;
     at(index: number): BoxedExpression | undefined;
     match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { ConfigurationChangeListener } from '../../common/configuration-change';

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
     value: T | null;
     generation: number | undefined;
 };

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Ensure all expressions in the array are in canonical form
  */

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

@@ -1,2 +1,2 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions, scope?: Scope): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Structural equality of boxed expressions.
  */

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  *
  * Make all the arguments canonical.

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
  * account for the 'lazy' property of the operator definition:
  *

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).
@@ -8,5 +8,12 @@
  *
  * If the expression does not match the pattern, it returns `null`.
  *
+ * <!--
+ * @consider?
+ * - pattern 'validation' (not quite the right term in this context) here? In a similar way to the
+ * check/condition supplied in 'matchPermutation()'? (i.e. inspect for redundant sequences of
+ * wildcard combinations).
+ * -->
+ *
  */
 export declare function match(subject: BoxedExpression, pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { Decimal } from 'decimal.js';
 import type { Rational } from '../numerics/types';
 import type { BoxedExpression, SemiBoxedExpression } from '../global-types';

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -46,3 +46,60 @@ export declare function maxDegree(expr: BoxedExpression): number;
  */
 export declare function lex(expr: BoxedExpression): string;
 export declare function revlex(expr: BoxedExpression): string;
+/**
+ * Get the degree of a polynomial in a specific variable.
+ * Returns -1 if the expression is not a polynomial in the variable.
+ *
+ * Examples:
+ * - `polynomialDegree(x^3 + 2x + 1, 'x')` → 3
+ * - `polynomialDegree(x*y + y^2, 'x')` → 1
+ * - `polynomialDegree(sin(x), 'x')` → -1 (not a polynomial)
+ */
+export declare function polynomialDegree(expr: BoxedExpression, variable: string): number;
+/**
+ * Extract coefficients of a univariate polynomial.
+ * Returns an array where index i contains the coefficient of x^i.
+ * Returns null if the expression is not a polynomial in the variable.
+ *
+ * Examples:
+ * - `getPolynomialCoefficients(x^3 + 2x + 1, 'x')` → [1, 2, 0, 1]
+ * - `getPolynomialCoefficients(3x^2 - x + 5, 'x')` → [5, -1, 3]
+ */
+export declare function getPolynomialCoefficients(expr: BoxedExpression, variable: string): BoxedExpression[] | null;
+/**
+ * Construct a polynomial expression from its coefficients.
+ * coeffs[i] is the coefficient of x^i.
+ *
+ * Examples:
+ * - `fromCoefficients([1, 2, 0, 1], 'x')` → x^3 + 2x + 1
+ * - `fromCoefficients([5, -1, 3], 'x')` → 3x^2 - x + 5
+ */
+export declare function fromCoefficients(coeffs: BoxedExpression[], variable: string): BoxedExpression;
+/**
+ * Polynomial long division.
+ * Returns [quotient, remainder] such that dividend = divisor * quotient + remainder.
+ * Returns null if inputs are not valid polynomials or divisor is zero.
+ *
+ * Examples:
+ * - `polynomialDivide(x^3-1, x-1, 'x')` → [x^2+x+1, 0]
+ * - `polynomialDivide(x^3+2x+1, x+1, 'x')` → [x^2-x+3, -2]
+ */
+export declare function polynomialDivide(dividend: BoxedExpression, divisor: BoxedExpression, variable: string): [BoxedExpression, BoxedExpression] | null;
+/**
+ * Compute the GCD of two polynomials using the Euclidean algorithm.
+ * Returns a monic polynomial (leading coefficient = 1).
+ *
+ * Examples:
+ * - `polynomialGCD(x^2-1, x-1, 'x')` → x-1
+ * - `polynomialGCD(x^3-1, x^2-1, 'x')` → x-1
+ */
+export declare function polynomialGCD(a: BoxedExpression, b: BoxedExpression, variable: string): BoxedExpression;
+/**
+ * Cancel common polynomial factors in a rational expression (Divide).
+ * Returns the simplified expression.
+ *
+ * Examples:
+ * - `cancelCommonFactors((x^2-1)/(x-1), 'x')` → x+1
+ * - `cancelCommonFactors((x+1)/(x^2+3x+2), 'x')` → 1/(x+2)
+ */
+export declare function cancelCommonFactors(expr: BoxedExpression, variable: string): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 import { NumericValue } from '../numeric-value/types';
 import type { Rational } from '../numerics/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.30.1 */
+/* 0.31.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;
@@ -117,7 +117,7 @@ export declare function applyRule(rule: Readonly<BoxedRule>, expr: BoxedExpressi
  * and the set of rules that were applied.
  *
  * The `replace` function can be used to apply a rule to a non-canonical
- * expression. @fixme: account for options.canonical
+ * expression.
  *
  */
 export declare function replace(expr: BoxedExpression, rules: Rule | (Rule | BoxedRule)[] | BoxedRuleSet, options?: Partial<ReplaceOptions>): RuleSteps;