@cortex-js/compute-engine 0.58.0 → 0.59.0

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

@@ -1,27 +1,47 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { BigNum } from './types';
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
 /**
- * Inverse Error Function.
+ * Inverse Error Function, accurate to full machine (double) precision.
  *
+ * Winitzki's approximation (~3 correct digits) refined with Newton's
+ * method on the full-precision `erf()`:
+ *    y ← y − (erf(y) − x)·(√π/2)·e^{y²}
+ * Each iteration doubles the number of correct digits, so 4 iterations
+ * reach machine precision.
+ *
+ * (Previously used a 6-term truncated Maclaurin series, which was only
+ * ~4-digit accurate at x = 0.5 and diverged badly for |x| → 1.)
  */
 export declare function erfInv(x: number): number;
 /**
- * Trivial function, used when compiling.
+ * Complementary error function, erfc(x) = 1 - erf(x), accurate to full
+ * machine (double) precision.
+ *
+ * For |x| < 2 the value is computed as `1 - erf(x)` (no significant
+ * cancellation). For larger |x|, `1 - erf(x)` would lose all precision
+ * (erf(x) ≈ 1), so erfc is computed directly from a continued fraction
+ * (DLMF 7.9.3) evaluated with the modified Lentz algorithm.
+ *
+ * References:
+ * - NIST DLMF: https://dlmf.nist.gov/7.9
  */
 export declare function erfc(x: number): number;
 /**
- * An approximation of the gaussian error function, Erf(), using
- * Abramowitz and Stegun approximation.
+ * The Gauss error function, erf(x), accurate to full machine (double)
+ * precision.
+ *
+ * Computed from the well-conditioned Maclaurin series (DLMF 7.6.2):
+ *   erf(x) = (2/√π) e^{-x²} Σ_{n≥0} 2^n x^{2n+1} / (1·3·5···(2n+1))
+ * All terms are positive, so there is no subtractive cancellation. For
+ * |x| ≥ 6 the result rounds to ±1 (erfc(6) ≈ 2.15e-17, below machine eps).
  *
- * Thoughts for future improvements:
- * - https://math.stackexchange.com/questions/321569/approximating-the-error-function-erf-by-analytical-functions
- * - https://en.wikipedia.org/wiki/Error_function#Approximation_with_elementary_functions
-
+ * (Previously used the 5-term Abramowitz & Stegun rational approximation,
+ * which was only ~7-digit accurate.)
  *
  * References:
- * - NIST: https://dlmf.nist.gov/7.24#i
+ * - NIST DLMF: https://dlmf.nist.gov/7.6
  */
 export declare function erf(x: number): number;
 /**
@@ -185,3 +205,51 @@ export declare function fresnelS(x: number): number;
 export declare function fresnelC(x: number): number;
 /** Unnormalized cardinal sine: sinc(x) = sin(x)/x, sinc(0) = 1. */
 export declare function sinc(x: number): number;
+/**
+ * Bignum error function. Precision scales with `BigDecimal.precision`.
+ *
+ * - |x| ≤ √((p+10)·ln 10): Maclaurin series (DLMF 7.6.2), no cancellation.
+ * - beyond: erf(x) rounds to ±1 at the working precision
+ *   (erfc(x) < e^{−x²} ≤ 10^{−(p+10)}).
+ */
+export declare function bigErf(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum complementary error function.
+ * Precision scales with `BigDecimal.precision`.
+ *
+ * - x² log10(e) ≤ p+10: computed as 1 − erf(x) with the working precision
+ *   raised by the x²·log10(e) digits lost to cancellation.
+ * - beyond: the asymptotic series (DLMF 7.12.1), which by construction of
+ *   the switchover delivers ≥ p+10 digits there.
+ */
+export declare function bigErfc(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum inverse error function: y such that erf(y) = x, for x ∈ [−1, 1].
+ * Precision scales with `BigDecimal.precision`.
+ *
+ * Newton iteration on `bigErf`:
+ *    y ← y − (erf(y) − x)·(√π/2)·e^{y²}
+ * seeded from the machine-precision Winitzki estimate (~3 digits; each
+ * iteration doubles the digits). Note that erfInv is intrinsically
+ * ill-conditioned as |x| → 1 (|dy/dx| = (√π/2)e^{y²}): the result is the
+ * best possible for the given input, but tiny perturbations of x near ±1
+ * produce large changes in y.
+ */
+export declare function bigErfInv(ce: ComputeEngine, x: BigNum): BigNum;
+/**
+ * Bignum unnormalized cardinal sine: sinc(x) = sin(x)/x, sinc(0) = 1.
+ * Precision scales with `BigDecimal.precision` (sin uses the engine's
+ * 1100-digit π for argument reduction).
+ */
+export declare function bigSinc(x: BigNum): BigNum;
+/**
+ * Bignum Fresnel sine integral S(x). Precision scales with
+ * `BigDecimal.precision`: Taylor series for πx²/2·log10(e) ≤ p+20 (with
+ * raised working precision to absorb the alternating-series cancellation),
+ * asymptotic expansion beyond (where it delivers ≥ p+10 digits).
+ */
+export declare function bigFresnelS(x: BigNum): BigNum;
+/**
+ * Bignum Fresnel cosine integral C(x). Same switchover as `bigFresnelS`.
+ */
+export declare function bigFresnelC(x: BigNum): BigNum;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function mean(values: Iterable<number>): number;
 export declare function bigMean(values: Iterable<BigDecimal>): BigDecimal;
 export declare function median(values: Iterable<number>): number;

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

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 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.58.0 */
+/* 0.59.0 */
 /** @internal */
 type IsInteger<N extends number> = `${N}` extends `${string}.${string}` ? never : `${N}` extends `-${string}.${string}` ? never : number;
 /** A `SmallInteger` is an integer < 1e6

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Unit registry: dimension vectors, SI base units, prefixes, and conversion.
  *
  * A DimensionVector encodes the exponents for each of the 7 SI base

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * OEIS (Online Encyclopedia of Integer Sequences) Integration
  *
  * This module provides functions to look up sequences in the OEIS database

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Utilities for declarative sequence definitions.
  *
  * This module provides functions to create subscriptEvaluate handlers

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

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

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  *
  * @param fn The function to differentiate, a function literal.

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  *
  */

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Cost functions for the Fu trigonometric simplification algorithm.
  *
  * The primary objective is to minimize the number of trigonometric functions,

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Fu Algorithm Transformation Rules
  *
  * Programmatic implementations of TR1-TR22 from the Fu trigonometric

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Fu Algorithm for Trigonometric Simplification
  *
  * Implementation of the algorithm by Fu, Zhong, and Zeng:

package/dist/types/compute-engine/symbolic/logic-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function evaluateAnd(args: ReadonlyArray<Expression>, { engine: ce }: {
     engine: ComputeEngine;
 }): Expression | undefined;

package/dist/types/compute-engine/symbolic/simplify-abs.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function simplifyAbs(x: Expression): RuleStep | undefined;
 /**
  * Simplify expressions where Abs appears as the base of a power.

package/dist/types/compute-engine/symbolic/simplify-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Division simplification rules consolidated from simplify-rules.ts.
  *

package/dist/types/compute-engine/symbolic/simplify-factorial.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Extracts base + integer offset from an expression.
  * - Symbol `n` → { base: n, offset: 0 }

package/dist/types/compute-engine/symbolic/simplify-hyperbolic.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function simplifyHyperbolic(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/symbolic/simplify-infinity.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Infinity simplification rules consolidated from simplify-rules.ts.
  * Handles ~20 patterns for simplifying expressions involving infinity.

package/dist/types/compute-engine/symbolic/simplify-log.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Logarithm simplification rules consolidated from simplify-rules.ts.
  * Handles ~30 patterns for simplifying Ln and Log expressions.

package/dist/types/compute-engine/symbolic/simplify-logic.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function simplifyLogicFunction(x: Expression): {
     value: Expression;
     because: string;

package/dist/types/compute-engine/symbolic/simplify-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Power simplification rules consolidated from simplify-rules.ts.
  * Handles ~25 patterns for simplifying Power expressions.

package/dist/types/compute-engine/symbolic/simplify-product.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Product simplification rules extracted from simplify-rules.ts.
  * Handles 13 patterns for simplifying Product expressions.

package/dist/types/compute-engine/symbolic/simplify-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * # Performance Optimization Notes for Simplification Rules
  *

package/dist/types/compute-engine/symbolic/simplify-sum.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Sum simplification rules extracted from simplify-rules.ts.
  * Handles 16 patterns for simplifying Sum expressions.

package/dist/types/compute-engine/symbolic/simplify-trig.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function simplifyTrig(x: Expression): RuleStep | undefined;

package/dist/types/compute-engine/tensor/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { Expression, IComputeEngine as ComputeEngine, DataTypeMap, TensorDataType, TensorField } from '../global-types';
 /** @category Tensors */
 export declare function makeTensorField<DT extends keyof DataTypeMap>(ce: ComputeEngine, dtype: DT): TensorField<DataTypeMap[DT]>;

package/dist/types/compute-engine/tensor/tensors.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /** @category Tensors */
 export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> implements Tensor<DT> {
     private ce;
@@ -6,8 +6,8 @@ export declare abstract class AbstractTensor<DT extends keyof DataTypeMap> imple
      * Return a tuple of tensors that have the same dtype.
      * If necessary, one of the two input tensors is upcast.
      *
-     * The shape of the tensors is reshaped to a compatible
-     * shape. If the shape is not compatible, `undefined` is returned.
+     * This harmonizes only the *dtype*; it does not reshape. Element-wise
+     * callers (see `broadcast`) must ensure the shapes are compatible.
      *
      * @param lhs
      * @param rhs

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonSymbol, MathJsonNumberObject } from '../math-json';
 import type { Type, TypeString, TypeResolver } from '../common/type/types';
@@ -10,8 +10,9 @@ import type { BigNum, Rational } from './numerics/types';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Metadata, CanonicalOptions, FormOption, BoxedSubstitution } from './types-serialization';
 import type { AngularUnit, SymbolDefinition, OperatorDefinition, ValueDefinition, BoxedDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions } from './types-definitions';
-import type { AssumeResult, Rule as KernelRule, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, RuleStep as KernelRuleStep, AssignValue as KernelAssignValue, Scope as KernelScope, EvalContext as KernelEvalContext } from './types-kernel-evaluation';
+import type { AssumeResult, Rule as KernelRule, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, RulePurpose, RuleStep as KernelRuleStep, AssignValue as KernelAssignValue, Scope as KernelScope, EvalContext as KernelEvalContext } from './types-kernel-evaluation';
 import type { LanguageTarget, CompilationResult } from './compilation/types';
+export type { RulePurpose } from './types-kernel-evaluation';
 type Rule = KernelRule<Expression, ExpressionInput, IComputeEngine>;
 type BoxedRule = KernelBoxedRule<Expression, IComputeEngine>;
 type BoxedRuleSet = KernelBoxedRuleSet<Expression, IComputeEngine>;
@@ -100,6 +101,19 @@ export interface IComputeEngine {
      *  Initialized to the built-in simplification rules.
      *  Users can `push()` additional rules or replace the entire array. */
     simplificationRules: Rule[];
+    /** The rules used by `solve()` to find roots of univariate expressions.
+     *  Each rule matches a normalized equation `f(_x) = 0` — the unknown is
+     *  the wildcard `_x` — and `replace` produces a root expression.
+     *  Conditions should reject matches where other wildcards capture `_x`.
+     *  Candidate roots are validated against the original equation, so an
+     *  over-eager template degrades to a no-op rather than a wrong answer.
+     *  Initialized to the built-in root-finding rules; `push()` to extend,
+     *  assign to replace. */
+    solveRules: Rule[];
+    /** The rules used by `solve()` to transform an equation into equivalent,
+     *  easier-to-solve forms before root-finding (e.g. `ln f(x) → f(x) - 1`).
+     *  Same conventions and extension pattern as `solveRules`. */
+    harmonizationRules: Rule[];
     strict: boolean;
     expr(expr: NumericValue | ExpressionInput, options?: {
         form?: FormOption;
@@ -174,6 +188,9 @@ export interface IComputeEngine {
     type(type: Type | TypeString | BoxedType): BoxedType;
     rules(rules: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
         canonical?: boolean;
+        /** Default purpose applied to any rule in the set that doesn't carry
+         *  its own `purpose` tag (a per-rule tag takes precedence). */
+        purpose?: RulePurpose;
     }): BoxedRuleSet;
     getRuleSet(id?: 'harmonization' | 'solve-univariate' | 'standard-simplification'): BoxedRuleSet | undefined;
     pushScope(scope?: Scope, name?: string): void;
@@ -419,4 +436,3 @@ declare module './types-definitions' {
     interface ComputeEngine extends IComputeEngine {
     }
 }
-export {};

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { IComputeEngine as ComputeEngine } from './types-engine';
 import type { Expression, ExpressionInput } from './types-expression';
 import type { Assumption as KernelAssumption, AssumeResult, AssignValue as KernelAssignValue, BoxedRule as KernelBoxedRule, BoxedRuleSet as KernelBoxedRuleSet, EvaluateOptions as KernelEvaluateOptions, EvalContext as KernelEvalContext, ExpressionMapInterface as KernelExpressionMapInterface, Rule as KernelRule, RuleConditionFunction as KernelRuleConditionFunction, RuleFunction as KernelRuleFunction, RuleReplaceFunction as KernelRuleReplaceFunction, RuleStep as KernelRuleStep, RuleSteps as KernelRuleSteps, Scope as KernelScope } from './types-kernel-evaluation';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { OneOf } from '../common/one-of';
 import type { MathJsonExpression, MathJsonNumberObject, MathJsonStringObject, MathJsonSymbolObject, MathJsonFunctionObject, MathJsonSymbol, MathJsonDictionaryObject } from '../math-json';
 import type { Type, TypeString } from '../common/type/types';
@@ -1065,26 +1065,29 @@ export interface Expression {
      *
      * - If no rules apply, return `null`.
      *
-     * See also `expr.subs()` for a simple substitution of symbols.
+     * The `form` option controls the form of *replacements*. The deprecated
+     * `canonical` option is also accepted for backward compatibility; only one
+     * of the two may be specified.
      *
-     * Procedure for the determining the canonical-status of the input expression and replacements:
+     * When neither `form` nor `canonical` is specified, the form of each
+     * replacement is determined as follows:
+     * 1. the form of the replacement produced by the rule, if it has a
+     *    non-`'raw'` form;
+     * 2. otherwise, the form of the expression being replaced;
+     * 3. otherwise, the replacement is left in its raw form.
      *
-     * - If `options.canonical` is set, the *entire expr.* is canonicalized to this degree: whether
-     * the replacement occurs at the top-level, or within/recursively.
-     *
-     * - If otherwise, the *direct replacement will be canonical* if either the 'replaced' expression
-     * is canonical, or the given replacement (- is a Expression and -) is canonical.
-     * Notably also, if this replacement takes place recursively (not at the top-level), then exprs.
-     * containing the replaced expr. will still however have their (previous) canonical-status
-     * *preserved*... unless this expr. was previously non-canonical, and *replacements have resulted
-     * in canonical operands*. In this case, an expr. meeting this criteria will be updated to
-     * canonical status. (Canonicalization is opportunistic here, in other words).
+     * While the form applies directly to replaced sub-expressions only, a
+     * non-`'raw'` form also propagates 'opportunistically' up the expression
+     * tree: an expression whose operands all share a form after replacement
+     * assumes that form as well. (Specifying `form: 'raw'` disables this
+     * propagation.)
      *
      * :::info[Note]
-     * Applicable to canonical and non-canonical expressions.
+     * Applicable to input expressions of any form.
      *
      * To match a specific symbol (not a wildcard pattern), the `match` must be
      * a `Expression` (e.g., `{ match: ce.expr('x'), replace: ... }`).
+     *
      * For simple symbol substitution, consider using `subs()` instead.
      * :::
      */

package/dist/types/compute-engine/types-kernel-evaluation.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { TypeReference } from '../common/type/types';
 import type { BoxedType } from '../common/type/boxed-type';
 import type { LatexString } from './latex-syntax/types';
@@ -80,10 +80,27 @@ export type RuleReplaceFunction<Expr = unknown> = (expr: Expr, wildcards: BoxedS
 export type RuleConditionFunction<Expr = unknown, CE = unknown> = (wildcards: BoxedSubstitution<Expr>, ce: CE) => boolean;
 /** @category Rules */
 export type RuleFunction<Expr = unknown> = (expr: Expr) => undefined | Expr | RuleStep<Expr>;
+/**
+ * The purpose of a rule determines how its result is treated by
+ * the simplification cost policy:
+ *
+ * - `'simplify'`: the result must pass the cost gate (the default;
+ *   today's behavior — results that grow the expression are discarded).
+ * - `'transform'`: a mathematically-preferred rewrite; exempt from the
+ *   cost gate (accepted by `simplify()` even if structurally larger).
+ * - `'expand'`: growth-by-design (series, argument expansion); skipped by
+ *   `simplify()`, but reachable via `expr.replace()` and future expand APIs.
+ *
+ * @category Rules
+ */
+export type RulePurpose = 'simplify' | 'transform' | 'expand';
 /** @category Rules */
 export type RuleStep<Expr = unknown> = {
     value: Expr;
     because: string;
+    /** The purpose of the rule that produced this step, stamped by
+     * `applyRule` from the firing rule. */
+    purpose?: RulePurpose;
 };
 /** @category Rules */
 export type RuleSteps<Expr = unknown> = RuleStep<Expr>[];
@@ -117,6 +134,13 @@ export type Rule<Expr = unknown, SemiExpr = unknown, CE = unknown> = string | Ru
     replace: LatexString | SemiExpr | RuleReplaceFunction<Expr> | RuleFunction<Expr>;
     condition?: LatexString | RuleConditionFunction<Expr, CE>;
     useVariations?: boolean;
+    /** Dispatch hint: this rule can only ever apply to expressions whose
+     *  operator is one of these. Used to index the rule; semantics are
+     *  unchanged (the rule is simply never tried on other operators). */
+    operators?: ReadonlyArray<string>;
+    /** How the result of this rule is treated by the simplification cost
+     *  policy. See {@linkcode RulePurpose}. **Default**: `'simplify'`. */
+    purpose?: RulePurpose;
     id?: string;
     onBeforeMatch?: (rule: Rule<Expr, SemiExpr, CE>, expr: Expr) => void;
     onMatch?: (rule: Rule<Expr, SemiExpr, CE>, expr: Expr, replace: Expr | RuleStep<Expr>) => void;
@@ -128,6 +152,13 @@ export type BoxedRule<Expr = unknown, CE = unknown> = {
     replace: Expr | RuleReplaceFunction<Expr> | RuleFunction<Expr>;
     condition: undefined | RuleConditionFunction<Expr, CE>;
     useVariations?: boolean;
+    /** Dispatch hint: this rule can only ever apply to expressions whose
+     *  operator is one of these. Used to index the rule; semantics are
+     *  unchanged (the rule is simply never tried on other operators). */
+    operators?: ReadonlyArray<string>;
+    /** How the result of this rule is treated by the simplification cost
+     *  policy. See {@linkcode RulePurpose}. **Default**: `'simplify'`. */
+    purpose?: RulePurpose;
     id?: string;
     onBeforeMatch?: (rule: Rule<Expr, unknown, CE>, expr: Expr) => void;
     onMatch?: (rule: Rule<Expr, unknown, CE>, expr: Expr, replace: Expr | RuleStep<Expr>) => void;

package/dist/types/compute-engine/types-kernel-serialization.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /**
  * Options to control serialization to MathJSON when using
@@ -126,9 +126,51 @@ export type ReplaceOptions = {
      */
     iterationLimit: number;
     /**
-     * Canonicalization policy after replacement.
+     * Canonical-status of replaced sub-expressions.
+     *
+     * Equivalent to `form`: `true` maps to `'canonical'`, `false` to `'raw'`,
+     * and a `CanonicalForm` (or array of them) is used as-is. Specifying both
+     * `canonical` and `form` is an error.
+     *
+     * @deprecated Use `form` instead, which covers a wider range of forms.
+     */
+    canonical?: CanonicalOptions;
+    /**
+     * The form (`'canonical'`, `'structural'`, `'raw'`, or specific canonical
+     * transforms) applied to *replaced* sub-expressions.
+     *
+     * The form does not automatically apply to the entire input expression.
+     * However, a non-`'raw'` form propagates upward through the expression tree:
+     * an expression whose operands all share a form after replacement assumes
+     * that form as well.
+     *
+     * To guarantee a form for the *entire* result, either ensure the input is
+     * already in the requested form before replacing, or request the form on the
+     * result after replacement (e.g. with `.canonical`).
+     *
+     * If no `form` (or `canonical`) option is specified, the form of each
+     * replacement is determined by the rule itself: see `replace()`.
+     *
+     * Note: a `'raw'` form does not undo a form the replacement already has,
+     * e.g. when a `RuleFunction` returns an expression that is already
+     * canonical.
+     */
+    form: FormOption;
+    /**
+     * Traversal direction through the expression tree, for both rule matching
+     * and replacement:
+     *
+     * - `'left-right'` (default): post-order traversal — left sub-tree first,
+     *   depth-first (LRN).
+     * - `'right-left'`: reverse post-order — right sub-tree first, depth-first
+     *   (RLN).
+     *
+     * In both cases the root (input) expression is visited last.
+     *
+     * The direction is only observable for order-sensitive rules, e.g. a
+     * `RuleFunction` whose replacements depend on visit order.
      */
-    canonical: CanonicalOptions;
+    direction: 'left-right' | 'right-left';
 };
 /**
  * Canonical normalization transforms.

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { BoxedSubstitution as KernelBoxedSubstitution, CanonicalForm, CanonicalOptions, FormOption, Hold, JsonSerializationOptions, Metadata, PatternMatchOptions as KernelPatternMatchOptions, ReplaceOptions, Substitution as KernelSubstitution } from './types-kernel-serialization';
 export type { Hold, JsonSerializationOptions, ReplaceOptions, CanonicalForm, CanonicalOptions, FormOption, Metadata, };
 /**

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export type { MathJsonExpression, MathJsonAttributes, MathJsonNumberObject, MathJsonSymbolObject, MathJsonStringObject, MathJsonFunctionObject, DictionaryValue, MathJsonDictionaryObject, ExpressionObject, MathJsonSymbol, } from '../math-json/types';
 export * from '../common/type/boxed-type';
 export * from '../common/type/types';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export { ComputeEngine } from './compute-engine/index';
 export type * from './compute-engine/types';
 export { LatexSyntax, parse as parseLatex, serialize as serializeLatex, } from './compute-engine/latex-syntax/latex-syntax';

package/dist/types/core.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export { ComputeEngine } from './compute-engine/index';
 export type * from './compute-engine/types';
 export type { Interval, IntervalResult, BoolInterval, } from './compute-engine/interval/types';

package/dist/types/identities.d.ts

@@ -0,0 +1,3 @@
+/* 0.59.0 */
+export { loadIdentities, FUNGRIM_CORE } from './compute-engine/fungrim/loader';
+export type { IdentitiesLoadOptions, IdentitiesLoadReport, IdentitiesRuleData, IdentitiesGuardUndecidedHandler, FungrimLoadOptions, FungrimLoadReport, FungrimRuleData, FungrimGuardUndecidedHandler, FungrimManifest, FungrimShellDeclaration, FungrimRuleClass, FungrimRuleTarget, FungrimMathJson, CompiledFungrimRule, GuardSpec, } from './compute-engine/fungrim/types';

package/dist/types/interval.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export type { Interval, IntervalResult, BoolInterval, } from './compute-engine/interval/types';
 export { ok, point, containsExtremum, unionResults, mergeDomainClip, isPoint, containsZero, isPositive, isNegative, isNonNegative, isNonPositive, width, midpoint, getValue, unwrap, unwrapOrPropagate, } from './compute-engine/interval/util';
 export { add, sub, mul, div, negate, _mul, } from './compute-engine/interval/arithmetic';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Entry point for `@cortex-js/compute-engine/latex-syntax`.
  *
  * Provides standalone LaTeX <-> MathJSON parsing and serialization
@@ -11,4 +11,4 @@ export type { LatexSyntaxOptions } from './compute-engine/latex-syntax/latex-syn
 export { LATEX_DICTIONARY, CORE_DICTIONARY, SYMBOLS_DICTIONARY, ALGEBRA_DICTIONARY, ARITHMETIC_DICTIONARY, COMPLEX_DICTIONARY, TRIGONOMETRY_DICTIONARY, CALCULUS_DICTIONARY, LINEAR_ALGEBRA_DICTIONARY, STATISTICS_DICTIONARY, LOGIC_DICTIONARY, SETS_DICTIONARY, INEQUALITIES_DICTIONARY, UNITS_DICTIONARY, OTHERS_DICTIONARY, PHYSICS_DICTIONARY, } from './compute-engine/latex-syntax/dictionary/default-dictionary';
 export type { LatexDictionaryEntry, LatexDictionary, SerializeLatexOptions, ParseLatexOptions, LatexString, } from './compute-engine/latex-syntax/types';
 export type { MathJsonExpression } from './math-json/types';
-export declare const version = "0.58.0";
+export declare const version = "0.59.0";

package/dist/types/math-json/symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Return true if the string is a valid symbol.
  *
  * Check for symbols matching a profile of [Unicode UAX31](https://unicode.org/reports/tr31/)

package/dist/types/math-json/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare const MISSING: MathJsonExpression;
 export declare function isNumberExpression(expr: MathJsonExpression | null): expr is number | string | MathJsonNumberObject;
 export declare function isNumberObject(expr: MathJsonExpression | null): expr is MathJsonNumberObject;