@cortex-js/compute-engine 0.35.6 → 0.50.1

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

@@ -0,0 +1,164 @@
+/* 0.50.1 */
+import type { TypeReference } from '../common/type/types';
+import type { BoxedType } from '../common/type/boxed-type';
+import type { LatexString } from './latex-syntax/types';
+import type { BoxedSubstitution } from './types-kernel-serialization';
+/** @category Assumptions */
+export interface Assumption<Expr = unknown, CE = unknown> {
+    isPositive: boolean | undefined;
+    isNonNegative: boolean | undefined;
+    isNegative: boolean | undefined;
+    isNonPositive: boolean | undefined;
+    isNumber: boolean | undefined;
+    isInteger: boolean | undefined;
+    isRational: boolean | undefined;
+    isReal: boolean | undefined;
+    isComplex: boolean | undefined;
+    isImaginary: boolean | undefined;
+    isFinite: boolean | undefined;
+    isInfinite: boolean | undefined;
+    isNaN: boolean | undefined;
+    isZero: boolean | undefined;
+    matches(t: BoxedType): boolean | undefined;
+    isGreater(other: Expr): boolean | undefined;
+    isGreaterEqual(other: Expr): boolean | undefined;
+    isLess(other: Expr): boolean | undefined;
+    isLessEqual(other: Expr): boolean | undefined;
+    isEqual(other: Expr): boolean | undefined;
+    toExpression(ce: CE, x: MathJsonSymbol): Expr;
+}
+/** @category Assumptions */
+export interface ExpressionMapInterface<U, Expr = unknown> {
+    has(expr: Expr): boolean;
+    get(expr: Expr): U | undefined;
+    set(expr: Expr, value: U): void;
+    delete(expr: Expr): void;
+    clear(): void;
+    [Symbol.iterator](): IterableIterator<[Expr, U]>;
+    entries(): IterableIterator<[Expr, U]>;
+}
+/** @category Assumptions */
+export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+/** Options for `Expression.evaluate()`
+ *
+ * @category Boxed Expression
+ */
+export type EvaluateOptions<Expr = unknown> = {
+    /**
+     * If `true`, the evaluation returns a numeric approximation of the expression,
+     * when possible.
+     *
+     * If `false`, the evaluation returns an exact value, when possible.
+     *
+     * **Default**: `false`
+     */
+    numericApproximation: boolean;
+    /**
+     * If `false`, and the result is a lazy collection, the collection remains
+     * lazy and is not materialized.
+     *
+     * If `true`, and the collection is finite, it is fully materialized.
+     *
+     * If an integer, evaluate at most that many elements.
+     *
+     * If a pair of integers `[n, m]`, and the collection is finite, evaluate
+     * the first `n` and last `m` elements.
+     *
+     * **Default**: `false`
+     */
+    materialization: boolean | number | [number, number];
+    /** Cancellation signal for long-running evaluations. */
+    signal: AbortSignal;
+    /**
+     * Temporary named argument bindings used while evaluating this expression.
+     */
+    withArguments: Record<MathJsonSymbol, Expr>;
+};
+/**
+ * Given an expression and set of wildcards, return a replacement expression.
+ *
+ * @category Rules
+ */
+export type RuleReplaceFunction<Expr = unknown> = (expr: Expr, wildcards: BoxedSubstitution<Expr>) => Expr | undefined;
+/** @category Rules */
+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>;
+/** @category Rules */
+export type RuleStep<Expr = unknown> = {
+    value: Expr;
+    because: string;
+};
+/** @category Rules */
+export type RuleSteps<Expr = unknown> = RuleStep<Expr>[];
+/**
+ * A rule describes how to transform an expression matching `match`
+ * into a new expression produced by `replace`.
+ *
+ * - `x-1` \( \to \) `1-x`
+ * - `(x+1)(x-1)` \( \to \) `x^2-1`
+ *
+ * Match and replace patterns can be provided as LaTeX strings or expressions.
+ * Rules can also be implemented with callback functions.
+ *
+ * ## Wildcards
+ *
+ * In expression patterns:
+ * - `_` matches one expression.
+ * - `_x`, `_a`, ... match one expression and bind it by name.
+ * - `__x` matches one or more expressions.
+ * - `___x` matches zero or more expressions.
+ *
+ * ## Variations
+ *
+ * If `useVariations` is true, rules may match equivalent variants
+ * (for example matching `x` against `a + x`).
+ *
+ * @category Rules
+ */
+export type Rule<Expr = unknown, SemiExpr = unknown, CE = unknown> = string | RuleFunction<Expr> | {
+    match?: LatexString | SemiExpr | Expr;
+    replace: LatexString | SemiExpr | RuleReplaceFunction<Expr> | RuleFunction<Expr>;
+    condition?: LatexString | RuleConditionFunction<Expr, CE>;
+    useVariations?: boolean;
+    id?: string;
+    onBeforeMatch?: (rule: Rule<Expr, SemiExpr, CE>, expr: Expr) => void;
+    onMatch?: (rule: Rule<Expr, SemiExpr, CE>, expr: Expr, replace: Expr | RuleStep<Expr>) => void;
+};
+/** @category Rules */
+export type BoxedRule<Expr = unknown, CE = unknown> = {
+    readonly _tag: 'boxed-rule';
+    match: undefined | Expr;
+    replace: Expr | RuleReplaceFunction<Expr> | RuleFunction<Expr>;
+    condition: undefined | RuleConditionFunction<Expr, CE>;
+    useVariations?: boolean;
+    id?: string;
+    onBeforeMatch?: (rule: Rule<Expr, unknown, CE>, expr: Expr) => void;
+    onMatch?: (rule: Rule<Expr, unknown, CE>, expr: Expr, replace: Expr | RuleStep<Expr>) => void;
+};
+/** @category Rules */
+export type BoxedRuleSet<Expr = unknown, CE = unknown> = {
+    rules: ReadonlyArray<BoxedRule<Expr, CE>>;
+};
+/**
+ * The argument of `ce.assign()` can be a primitive, an expression,
+ * or a function that computes an expression from arguments.
+ *
+ * @category Compute Engine
+ */
+export type AssignValue<Expr = unknown, SemiExpr = unknown, CE = unknown> = boolean | number | bigint | SemiExpr | ((args: ReadonlyArray<Expr>, options: EvaluateOptions<Expr> & {
+    engine: CE;
+}) => Expr) | undefined;
+/** @category Definitions */
+export type Scope<Binding = unknown> = {
+    parent: Scope<Binding> | null;
+    bindings: Map<string, Binding>;
+    types?: Record<string, TypeReference>;
+};
+/** @category Compute Engine */
+export type EvalContext<Expr = unknown, Binding = unknown> = {
+    lexicalScope: Scope<Binding>;
+    assumptions: ExpressionMapInterface<boolean, Expr>;
+    values: Record<string, Expr | undefined>;
+    name: undefined | string;
+};

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

@@ -0,0 +1,147 @@
+/* 0.50.1 */
+export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+/**
+ * Options to control serialization to MathJSON when using
+ * `Expression.toMathJson()`.
+ *
+ * @category Serialization
+ */
+export type JsonSerializationOptions = {
+    /**
+     * If true, serialization applies readability transforms.
+     * Example: `["Power", "x", 2]` -> `["Square", "x"]`.
+     */
+    prettify: boolean;
+    /**
+     * Function names to exclude from prettified output.
+     * Excluded functions are replaced by equivalent non-prettified forms.
+     */
+    exclude: string[];
+    /**
+     * Which expression kinds can use shorthand output.
+     *
+     * **Default**: `["all"]`
+     */
+    shorthands: ('all' | 'number' | 'symbol' | 'function' | 'string' | 'dictionary')[];
+    /**
+     * Metadata fields to include. When metadata is included, shorthand notation
+     * is disabled for affected nodes.
+     */
+    metadata: ('all' | 'wikidata' | 'latex')[];
+    /**
+     * If true, detect and serialize repeating decimals (for example `0.(3)`).
+     *
+     * **Default**: `true`
+     */
+    repeatingDecimal: boolean;
+    /**
+     * Maximum significant digits to serialize.
+     * - `"max"`: all available digits
+     * - `"auto"`: use compute-engine precision
+     *
+     * **Default**: `"auto"`
+     */
+    fractionalDigits: 'auto' | 'max' | number;
+};
+/**
+ * Control how a pattern is matched to an expression.
+ *
+ * ## Wildcards
+ * - Universal (`_` or `_name`): exactly one element
+ * - Sequence (`__` or `__name`): one or more elements
+ * - Optional Sequence (`___` or `___name`): zero or more elements
+ *
+ * @category Pattern Matching
+ */
+export type PatternMatchOptions<T = unknown> = {
+    /**
+     * Preset bindings for named wildcards. Useful to enforce consistency
+     * across repeated wildcard occurrences.
+     */
+    substitution?: BoxedSubstitution<T>;
+    /**
+     * If true, match recursively in sub-expressions; otherwise only at
+     * the top level.
+     */
+    recursive?: boolean;
+    /**
+     * If true, allow structurally equivalent variations to match.
+     * If false, require structural identity.
+     */
+    useVariations?: boolean;
+    /**
+     * If true (default), commutative operators may match with permuted operands.
+     * If false, operand order must match exactly.
+     */
+    matchPermutations?: boolean;
+};
+/**
+ * Options for `Expression.replace()`.
+ *
+ * @category Boxed Expression
+ */
+export type ReplaceOptions = {
+    /**
+     * If true, apply rules to all sub-expressions.
+     * If false, only the top-level expression is considered.
+     */
+    recursive: boolean;
+    /**
+     * If true, stop after the first matching rule.
+     * If false, continue applying remaining rules.
+     */
+    once: boolean;
+    /**
+     * If true, rules may match equivalent variants.
+     * Can be powerful but may introduce recursion hazards.
+     */
+    useVariations: boolean;
+    /**
+     * If true (default), commutative matches may permute operands.
+     * If false, matching is order-sensitive.
+     */
+    matchPermutations: boolean;
+    /**
+     * Repeat rule application up to this limit when `once` is false.
+     */
+    iterationLimit: number;
+    /**
+     * Canonicalization policy after replacement.
+     */
+    canonical: CanonicalOptions;
+};
+/**
+ * Canonical normalization transforms.
+ *
+ * @category Boxed Expression
+ */
+export type CanonicalForm = 'InvisibleOperator' | 'Number' | 'Multiply' | 'Add' | 'Power' | 'Divide' | 'Flatten' | 'Order';
+/** @category Boxed Expression */
+export type CanonicalOptions = boolean | CanonicalForm | CanonicalForm[];
+/**
+ * Controls how expressions are created.
+ *
+ * @category Boxed Expression
+ */
+export type FormOption = 'canonical' | 'structural' | 'raw' | CanonicalForm | CanonicalForm[];
+/**
+ * Metadata that can be associated with a MathJSON expression.
+ *
+ * @category Boxed Expression
+ */
+export type Metadata = {
+    latex?: string | undefined;
+    wikidata?: string | undefined;
+};
+/**
+ * A substitution maps wildcard symbols to bound values.
+ *
+ * @category Pattern Matching
+ */
+export type Substitution<T = unknown> = {
+    [symbol: string]: T;
+};
+/**
+ * @category Pattern Matching
+ */
+export type BoxedSubstitution<T = unknown> = Substitution<T>;

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

@@ -0,0 +1,23 @@
+/* 0.50.1 */
+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, };
+/**
+ * A substitution describes the values of the wildcards in a pattern so that
+ * the pattern is equal to a target expression.
+ *
+ * A substitution can also be considered a more constrained version of a
+ * rule whose `match` is always a symbol.
+ *
+ * @category Pattern Matching
+ */
+export type Substitution<T = ExpressionInput> = KernelSubstitution<T>;
+/**
+ * @category Pattern Matching
+ */
+export type BoxedSubstitution<T = Expression> = KernelBoxedSubstitution<T>;
+/**
+ * Control how a pattern is matched to an expression.
+ *
+ * @category Pattern Matching
+ */
+export type PatternMatchOptions<T = Expression> = KernelPatternMatchOptions<T>;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-export * from '../math-json/types';
+/* 0.50.1 */
+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';
 export type * from './latex-syntax/types';

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

@@ -1,7 +1,20 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export { ComputeEngine } from './compute-engine/index';
-export * from './compute-engine/types';
-export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompiledExecutable, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';
+export type * from './compute-engine/types';
+export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compute-engine/compilation/types';
 export { JavaScriptTarget } from './compute-engine/compilation/javascript-target';
+export { GPUShaderTarget } from './compute-engine/compilation/gpu-target';
 export { GLSLTarget } from './compute-engine/compilation/glsl-target';
+export { WGSLTarget } from './compute-engine/compilation/wgsl-target';
+export { PythonTarget } from './compute-engine/compilation/python-target';
+export { IntervalJavaScriptTarget } from './compute-engine/compilation/interval-javascript-target';
+export { IntervalGLSLTarget } from './compute-engine/compilation/interval-glsl-target';
+export { IntervalWGSLTarget } from './compute-engine/compilation/interval-wgsl-target';
 export { BaseCompiler } from './compute-engine/compilation/base-compiler';
+export { parse, simplify, evaluate, N, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './compute-engine/free-functions';
+export { isExpression, isNumber, isSymbol, isFunction, isString, isTensor, isDictionary, isCollection, isIndexedCollection, isBoxedExpression, isBoxedNumber, isBoxedSymbol, isBoxedFunction, isBoxedString, isBoxedTensor, } from './compute-engine/boxed-expression/type-guards';
+export type { BoxedNumber } from './compute-engine/boxed-expression/boxed-number';
+export type { BoxedSymbol } from './compute-engine/boxed-expression/boxed-symbol';
+export type { BoxedFunction } from './compute-engine/boxed-expression/boxed-function';
+export type { BoxedString } from './compute-engine/boxed-expression/boxed-string';
+export type { BoxedTensor } from './compute-engine/boxed-expression/boxed-tensor';

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * 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.35.6 */
+/* 0.50.1 */
  * The following properties can be added to any MathJSON expression
  * to provide additional information about the expression.
  *
@@ -99,7 +99,7 @@ export type MathJsonStringObject = {
 } & MathJsonAttributes;
 /** @category MathJSON */
 export type MathJsonFunctionObject = {
-    fn: [MathJsonSymbol, ...Expression[]];
+    fn: [MathJsonSymbol, ...MathJsonExpression[]];
 } & MathJsonAttributes;
 /** @category MathJSON */
 export type DictionaryValue = boolean | number | string | ExpressionObject | ReadonlyArray<DictionaryValue>;
@@ -119,4 +119,4 @@ export type ExpressionObject = MathJsonNumberObject | MathJsonStringObject | Mat
  *
  * @category MathJSON
  */
-export type Expression = ExpressionObject | number | MathJsonSymbol | string | readonly [MathJsonSymbol, ...Expression[]];
+export type MathJsonExpression = ExpressionObject | number | MathJsonSymbol | string | readonly [MathJsonSymbol, ...MathJsonExpression[]];

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

@@ -1,24 +1,24 @@
-/* 0.35.6 */
-export declare const MISSING: Expression;
-export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumberObject;
-export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumberObject;
-export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbolObject;
-export declare function isStringObject(expr: Expression | null): expr is MathJsonStringObject;
-export declare function isDictionaryObject(expr: Expression | null): expr is MathJsonDictionaryObject;
-export declare function isFunctionObject(expr: Expression | null): expr is MathJsonFunctionObject;
-export declare function isExpressionObject(expr: Expression | null): expr is ExpressionObject;
+/* 0.50.1 */
+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;
+export declare function isSymbolObject(expr: MathJsonExpression | null): expr is MathJsonSymbolObject;
+export declare function isStringObject(expr: MathJsonExpression | null): expr is MathJsonStringObject;
+export declare function isDictionaryObject(expr: MathJsonExpression | null): expr is MathJsonDictionaryObject;
+export declare function isFunctionObject(expr: MathJsonExpression | null): expr is MathJsonFunctionObject;
+export declare function isExpressionObject(expr: MathJsonExpression | null): expr is ExpressionObject;
 /**
  * Returns true if `expr` has at least one recognized metadata property
  * (`latex` or `wikidata`) with a non-undefined value.
  */
-export declare function hasMetaData(expr: Expression | null): expr is ExpressionObject & Partial<MathJsonAttributes>;
+export declare function hasMetaData(expr: MathJsonExpression | null): expr is ExpressionObject & Partial<MathJsonAttributes>;
 /**  If expr is a string literal, return it.
  *
  * A string literal is a JSON string that begins and ends with
  * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
  */
-export declare function stringValue(expr: Expression | null | undefined): string | null;
-export declare function stripText(expr: Expression | null | undefined): Expression | null;
+export declare function stringValue(expr: MathJsonExpression | null | undefined): string | null;
+export declare function stripText(expr: MathJsonExpression | null | undefined): MathJsonExpression | null;
 /**
  * The operator of a function is symbol.
  *
@@ -27,24 +27,24 @@ export declare function stripText(expr: Expression | null | undefined): Expressi
  * Examples:
  * * `["Negate", 5]`  -> `"Negate"`
  */
-export declare function operator(expr: Expression | null | undefined): MathJsonSymbol;
+export declare function operator(expr: MathJsonExpression | null | undefined): MathJsonSymbol;
 /**
  * Return the arguments of a function, or an empty array if not a function
  * or no arguments.
  */
-export declare function operands(expr: Expression | null | undefined): ReadonlyArray<Expression>;
+export declare function operands(expr: MathJsonExpression | null | undefined): ReadonlyArray<MathJsonExpression>;
 /** Return the nth operand of a function expression */
-export declare function operand(expr: Expression | null, n: 1 | 2 | 3): Expression | null;
-export declare function nops(expr: Expression | null | undefined): number;
-export declare function unhold(expr: Expression | null): Expression | null;
-export declare function symbol(expr: Expression | null | undefined): string | null;
-export declare function dictionaryFromExpression(expr: Expression | null): null | MathJsonDictionaryObject;
-export declare function dictionaryFromEntries(dict: Record<string, Expression>): Expression;
+export declare function operand(expr: MathJsonExpression | null, n: 1 | 2 | 3): MathJsonExpression | null;
+export declare function nops(expr: MathJsonExpression | null | undefined): number;
+export declare function unhold(expr: MathJsonExpression | null): MathJsonExpression | null;
+export declare function symbol(expr: MathJsonExpression | null | undefined): string | null;
+export declare function dictionaryFromExpression(expr: MathJsonExpression | null): null | MathJsonDictionaryObject;
+export declare function dictionaryFromEntries(dict: Record<string, MathJsonExpression>): MathJsonExpression;
 /**
  *  CAUTION: `machineValue()` will return a truncated value if the number
  *  has a precision outside of the machine range.
  */
-export declare function machineValue(expr: Expression | null | undefined): number | null;
+export declare function machineValue(expr: MathJsonExpression | null | undefined): number | null;
 /**
  * Return a rational (numer over denom) representation of the expression,
  * if possible, `null` otherwise.
@@ -57,29 +57,29 @@ export declare function machineValue(expr: Expression | null | undefined): numbe
  *
  * The denominator is always > 0.
  */
-export declare function rationalValue(expr: Expression | undefined | null): [number, number] | null;
+export declare function rationalValue(expr: MathJsonExpression | undefined | null): [number, number] | null;
 /**
  * Apply a substitution to an expression.
  */
-export declare function subs(expr: Expression, s: {
-    [symbol: string]: Expression;
-}): Expression;
+export declare function subs(expr: MathJsonExpression, s: {
+    [symbol: string]: MathJsonExpression;
+}): MathJsonExpression;
 /**
  * Apply a function to the arguments of a function and return an array of T
  */
-export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
+export declare function mapArgs<T>(expr: MathJsonExpression, fn: (x: MathJsonExpression) => T): T[];
 /**
  * Assuming that op is an associative operator, fold lhs or rhs
  * if either are the same operator.
  */
-export declare function foldAssociativeOperator(op: string, lhs: Expression, rhs: Expression): Expression;
+export declare function foldAssociativeOperator(op: string, lhs: MathJsonExpression, rhs: MathJsonExpression): MathJsonExpression;
 /** Return the elements of a sequence, or null if the expression is not a sequence. The sequence can be optionally enclosed by a`["Delimiter"]` expression  */
-export declare function getSequence(expr: Expression | null | undefined): ReadonlyArray<Expression> | null;
+export declare function getSequence(expr: MathJsonExpression | null | undefined): ReadonlyArray<MathJsonExpression> | null;
 /** `Nothing` or the empty sequence (`["Sequence"]`) */
-export declare function isEmptySequence(expr: Expression | null | undefined): expr is null | undefined;
-export declare function missingIfEmpty(expr: Expression | null | undefined): Expression;
+export declare function isEmptySequence(expr: MathJsonExpression | null | undefined): expr is null | undefined;
+export declare function missingIfEmpty(expr: MathJsonExpression | null | undefined): MathJsonExpression;
 /** The number of leaves (atomic expressions) in the expression */
-export declare function countLeaves(expr: Expression | null): number;
+export declare function countLeaves(expr: MathJsonExpression | null): number;
 /** True if the string matches the expected pattern for a number */
 export declare function matchesNumber(s: string): boolean;
 /** True if the string matches the expected pattern for a symbol */

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

@@ -1,3 +1,3 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export { isSymbolObject, isStringObject, isFunctionObject, stringValue, operator, operand, symbol, mapArgs, dictionaryFromExpression, } from './math-json/utils';
-export declare const version = "0.35.6";
+export declare const version = "0.50.1";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.35.6",
+  "version": "0.50.1",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",
@@ -11,6 +11,7 @@
     "snapshot": "bash ./scripts/test.sh snapshot",
     "version": "bash ./scripts/version.sh",
     "test": "bash ./scripts/test.sh",
+    "check:deps": "madge --circular --extensions ts src/compute-engine && echo 'No runtime circular dependencies found (type-only cycles are expected)'",
     "lint": "eslint src --ext .ts --fix && prettier --write 'src/**/*.{ts,js,css,md}'",
     "typecheck": "bash ./scripts/typecheck.sh"
   },
@@ -47,6 +48,12 @@
       "import": "./dist/compute-engine.min.esm.js",
       "require": "./dist/compute-engine.min.umd.js",
       "default": "./dist/compute-engine.min.esm.js"
+    },
+    "./math-json": {
+      "types": "./dist/types/math-json.d.ts",
+      "import": "./dist/math-json.min.esm.js",
+      "require": "./dist/math-json.min.umd.js",
+      "default": "./dist/math-json.min.esm.js"
     }
   },
   "main": "./dist/compute-engine.min.esm.js",

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

@@ -1,10 +0,0 @@
-/* 0.35.6 */
-export declare class Terms {
-    private engine;
-    private terms;
-    constructor(ce: ComputeEngine, terms: ReadonlyArray<BoxedExpression>);
-    private add;
-    private find;
-    N(): BoxedExpression;
-    asExpression(): BoxedExpression;
-}

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

@@ -1,4 +0,0 @@
-/* 0.35.6 */
-export declare function canonicalInvisibleOperator(ops: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | null;

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

@@ -1,54 +0,0 @@
-/* 0.35.6 */
-export declare function evaluateAnd(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateOr(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateNot(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateEquivalent(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateImplies(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateXor(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateNand(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-export declare function evaluateNor(args: ReadonlyArray<BoxedExpression>, { engine: ce }: {
-    engine: ComputeEngine;
-}): BoxedExpression | undefined;
-/**
- * Convert a boolean expression to Negation Normal Form (NNF).
- * In NNF, negations only appear directly before variables (literals).
- * This is a prerequisite for CNF/DNF conversion.
- */
-export declare function toNNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
-/**
- * Convert a boolean expression to Conjunctive Normal Form (CNF).
- */
-export declare function toCNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
-/**
- * Convert a boolean expression to Disjunctive Normal Form (DNF).
- */
-export declare function toDNF(expr: BoxedExpression, ce: ComputeEngine): BoxedExpression;
-/**
- * Extract all propositional variables from a boolean expression.
- * Returns a sorted array of unique variable names.
- */
-export declare function extractVariables(expr: BoxedExpression): string[];
-/**
- * Evaluate a boolean expression with a given truth assignment.
- * Returns True, False, or undefined if the expression cannot be evaluated.
- */
-export declare function evaluateWithAssignment(expr: BoxedExpression, assignment: Record<string, boolean>, ce: ComputeEngine): BoxedExpression;
-/**
- * Generate all possible truth assignments for a list of variables.
- * Each assignment is a Record mapping variable names to boolean values.
- */
-export declare function generateAssignments(variables: string[]): Generator<Record<string, boolean>>;