@cortex-js/compute-engine 0.57.0 → 0.59.0

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { MathJsonExpression, 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.57.0 */
+/* 0.59.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { OperatorDefinition, Expression, BoxedOperatorDefinition, CollectionHandlers, CompiledExpression, EvaluateOptions, IComputeEngine as ComputeEngine, Sign } from '../global-types';
 export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition {
@@ -19,6 +19,12 @@ export declare class _BoxedOperatorDefinition implements BoxedOperatorDefinition
     scoped: boolean;
     signature: BoxedType;
     inferredSignature: boolean;
+    /** True if this operator definition was created from a user-defined
+     * function literal (e.g. via `ce.assign('f', ce.parse('x \\mapsto x^2'))`).
+     * Used to enable auto-broadcasting when applied to indexed collections.
+     * @internal
+     */
+    _isLambda: boolean;
     type?: (ops: ReadonlyArray<Expression>, options: {
         engine: ComputeEngine;
     }) => BoxedType | Type | TypeString | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * # Pattern Matching Wildcards
  *
  * Patterns can contain wildcards that match parts of expressions. There are

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
 import type { Type, TypeString } from '../../common/type/types';
 import type { OneOf } from '../../common/one-of';
 import { BoxedType } from '../../common/type/boxed-type';
@@ -164,8 +164,8 @@ export declare class BoxedSymbol extends _BoxedExpression implements SymbolInter
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
     contains(rhs: Expression): boolean | undefined;
-    get count(): number;
-    get isEmptyCollection(): boolean;
+    get count(): number | undefined;
+    get isEmptyCollection(): boolean | undefined;
     get isFiniteCollection(): boolean | undefined;
     each(): Generator<Expression>;
     at(index: number): Expression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { IComputeEngine as ComputeEngine, TensorDataType, Metadata, BoxedBaseDefinition, BoxedOperatorDefinition, BoxedSubstitution, EvaluateOptions, Expression, SimplifyOptions, PatternMatchOptions, Tensor, TensorInterface } from '../global-types';
 import { BoxedType } from '../../common/type/boxed-type';
 import { NumericValue } from '../numeric-value/types';

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
     value: T | null;
     generation: number | undefined;
 };

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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.57.0 */
+/* 0.59.0 */
 export declare function canonicalForm(expr: Expression, forms: CanonicalOptions, scope?: Scope): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 type ExpandFn = (expr: Expression) => Expression;
 /** @internal */
 export declare function _setExpand(fn: ExpandFn): void;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Leaf module for shared constants used across boxed-expression modules.
  * No imports from sibling modules to avoid circular dependencies.
  */

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

@@ -0,0 +1,140 @@
+/* 0.59.0 */
+/**
+ * Constraint subjects (FUNGRIM-PLAN-3-ASSUMPTIONS.md §2).
+ *
+ * The assumptions system keys facts not just on bare symbols, but on a small
+ * algebra of "subjects": a symbol, or one of the four part-extractors
+ * (`Real`, `Imaginary`, `Abs`, `Argument`) applied to exactly a bare symbol.
+ *
+ * This module is a leaf: it only imports types from `global-types` and the
+ * runtime type guards. Do not add imports that could create cycles.
+ */
+/** The "part" of a symbol that a constraint subject refers to. */
+export type SubjectPart = 'self' | 're' | 'im' | 'abs' | 'arg';
+/**
+ * A constraint subject: either a symbol itself (`part: 'self'`) or a
+ * part-extractor (`Real`, `Imaginary`, `Abs`, `Argument`) applied to a
+ * bare symbol.
+ */
+export type Subject = {
+    symbol: string;
+    part: SubjectPart;
+};
+/**
+ * Recognize a canonical subject term:
+ * - a bare symbol → `{ symbol, part: 'self' }`
+ * - `Real(x)`, `Imaginary(x)`, `Abs(x)`, `Argument(x)` where `x` is a bare
+ *   symbol → `{ symbol: x, part: 're'|'im'|'abs'|'arg' }`
+ *
+ * Nothing deeper is recognized: `Real(z + w)` is **not** a subject, nor is
+ * `Abs(Real(z))`.
+ */
+export declare function subjectOf(expr: Expression): Subject | undefined;
+/**
+ * A stable string key for a subject, for indexing: `"self:x"`, `"re:s"`,
+ * `"im:tau"`, `"abs:q"`, `"arg:z"`.
+ */
+export declare function subjectKey(subject: Subject): string;
+/** Convert a `string | Subject` argument to a `Subject` ('self' part). */
+export declare function toSubject(subjectOrSymbol: string | Subject): Subject;
+/**
+ * True if `expr` is exactly the subject term for `subject` (a bare symbol
+ * for `part: 'self'`, or the corresponding part-extractor applied to the
+ * symbol otherwise).
+ */
+export declare function matchesSubject(expr: Expression, subject: Subject): boolean;
+/** Numeric (real, finite) value of a number literal term, or undefined. */
+export declare function finiteNumericValue(term: Expression | undefined): number | undefined;
+/**
+ * Extract the bound contribution of a single normalized inequality
+ * assumption — `Less(lhs, 0)` or `LessEqual(lhs, 0)` — for `subject`.
+ *
+ * Recognized lhs shapes (mirroring the historical symbol-only logic, with
+ * the bare symbol generalized to a subject term):
+ *
+ * - `Negate(subject)` → lower bound 0 (i.e. `subject > 0` / `subject ≥ 0`)
+ * - `subject` → upper bound 0
+ * - `Add(..., Negate(subject), ..., k…)` with numeric terms summing to
+ *   `k ≠ 0` → lower bound `k`
+ * - `Add(..., subject, ..., k…)` with numeric terms summing to `k ≠ 0` →
+ *   upper bound `-k`
+ *
+ * Returns `undefined` if the assumption carries no bound for `subject`.
+ *
+ * NOTE: as in the historical implementation, non-numeric extra terms in an
+ * `Add` are ignored when summing the constant. Callers should treat the
+ * result as a best-effort bound (this matches the pre-existing behavior of
+ * `getInequalityBoundsFromAssumptions`).
+ */
+export declare function boundsFromNormalizedInequality(assumption: Expression, subject: Subject): IntervalBounds | undefined;
+/**
+ * Merge `from` into `into`, keeping the tightest bounds.
+ *
+ * Semantics match the historical accumulation in
+ * `getInequalityBoundsFromAssumptions`: a candidate replaces the current
+ * bound only when it is strictly tighter (`isGreater`/`isLess` returning
+ * exactly `true`); ties keep the existing strictness.
+ */
+export declare function mergeTightestBounds(into: IntervalBounds, from: IntervalBounds): void;
+/** Facts indexed for a single subject. */
+export type SubjectFacts = {
+    bounds: IntervalBounds;
+    /** Values `v` for which `NotEqual(subject, v)` is assumed. */
+    notEqual: Expression[];
+};
+/** Membership facts for a single symbol. */
+export type MembershipFacts = {
+    /** Set expressions `S` for which `Element(symbol, S)` is assumed. */
+    in: Expression[];
+    /** Set expressions `S` for which `NotElement(symbol, S)` is assumed. */
+    notIn: Expression[];
+};
+/**
+ * A derived, read-only index over the scoped assumptions `ExpressionMap`.
+ *
+ * The `ExpressionMap` remains the single source of truth; this index is
+ * rebuilt lazily whenever the assumptions change (see `getFactIndex`).
+ * Consumers must treat it as immutable.
+ */
+export type FactIndex = {
+    bySubject: Map<string, SubjectFacts>;
+    membership: Map<string, MembershipFacts>;
+};
+/**
+ * Lazily-built, cached index over the current context's assumptions.
+ *
+ * - Returns a shared empty index (cheaply, with no cache machinery) when
+ *   there are no assumptions — hot paths with zero assumptions pay only an
+ *   emptiness check.
+ * - Otherwise, the index is cached per engine and invalidated when
+ *   `ce._generation` changes (bumped by `assume()`, `forget()`,
+ *   declarations…), when the assumptions map object changes (scope
+ *   push/pop), or when the number of stored assumptions changes (direct
+ *   `.set()`/`.delete()` on the map).
+ *
+ * The returned index must be treated as read-only.
+ */
+export declare function getFactIndex(ce: ComputeEngine): FactIndex;
+/**
+ * Fast emptiness check for the assumptions store. The P3 query hooks
+ * (relational operators, sgn fallbacks, membership lookups, symbol
+ * predicates) are gated on this so that zero-assumption engines pay only
+ * an (empty) iterator check before any subject or index work.
+ */
+export declare function hasAssumptions(ce: ComputeEngine): boolean;
+/**
+ * Decide a comparison of a subject against the numeric constant `k` from
+ * the subject's assumed interval bounds (design §5.1a).
+ *
+ * Strict three-valued discipline (design §5.2): returns `true` only when
+ * the bounds entail the comparison, `false` only when they refute it, and
+ * `undefined` otherwise.
+ */
+export declare function decideComparisonFromBounds(bounds: IntervalBounds, k: number, query: 'less' | 'lessEqual' | 'greater' | 'greaterEqual'): boolean | undefined;
+/**
+ * Derive a `Sign` from assumed interval bounds (design §5.1b — the
+ * `Real`/`Imaginary`/`Abs`/`Argument` sgn fallbacks).
+ *
+ * Returns a sign only when the bounds entail it; `undefined` otherwise.
+ */
+export declare function signFromBounds(bounds: IntervalBounds): Sign | undefined;

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  *
  * Optionally make all the arguments canonical (default).

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.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/inequality-bounds.d.ts

@@ -1,21 +1,43 @@
-/* 0.57.0 */
+/* 0.59.0 */
+import { type Subject } from './constraint-subject';
 /**
- * Get inequality bounds for a symbol from the assumption database.
+ * Extract interval bounds for `symbol` from a condition expression.
  *
- * For example, if `x > 4` is assumed, this returns `{ lowerBound: 4, lowerStrict: true }`.
- * If `x <= 10` is assumed, this returns `{ upperBound: 10, upperStrict: false }`.
+ * Unlike `getInequalityBoundsFromAssumptions` (which reads the engine's
+ * assumption DB), this function operates directly on an AST shape:
+ *
+ * - bare comparisons (`Less`, `LessEqual`, `Greater`, `GreaterEqual`),
+ *   including chained forms like `Less(a, x, b)`
+ * - `And(c1, c2, ...)` of supported shapes
+ * - `When(e, cond)` — unwraps to `cond`
+ * - `Multiply(f, When(...), ...)` — the Desmos parse shape for
+ *   `f(x)\{a < x < b\}`; bounds from each `When` factor are merged
+ *
+ * Returns `undefined` if `expr` doesn't carry interval information for
+ * `symbol`, or if the information is not a simple lower-upper pair.
+ */
+export declare function extractIntervalBounds(expr: Expression, symbol: string): IntervalBounds | undefined;
+/**
+ * Get inequality bounds for a subject from the assumption database.
+ *
+ * For example, if `x > 4` is assumed, this returns `{ lower: 4, lowerStrict: true }`.
+ * If `x <= 10` is assumed, this returns `{ upper: 10, upperStrict: false }`.
+ *
+ * The subject may be a bare symbol (pass the symbol name, or a `Subject`
+ * with `part: 'self'`) or a part-extractor of a symbol, e.g.
+ * `{ symbol: 's', part: 're' }` for facts about `Real(s)`
+ * (see `constraint-subject.ts`).
  *
  * Note: Assumptions are normalized to forms like:
  * - `x > 4` becomes `Less(Add(Negate(x), 4), 0)` i.e., `4 - x < 0`
  * - `x > 0` becomes `Less(Negate(x), 0)` i.e., `-x < 0`
+ * - `Re(s) > 1` becomes `Less(Add(Negate(Real(s)), 1), 0)`
+ *
+ * The result is derived from the cached fact index (see `getFactIndex`),
+ * so repeated queries against unchanged assumptions cost a lookup.
  *
  * @param ce - The compute engine instance
- * @param symbol - The symbol name to query
- * @returns An object with lowerBound, upperBound, and strictness flags
+ * @param subject - The symbol name or `Subject` to query
+ * @returns The `IntervalBounds` (same shape used by `extractIntervalBounds`).
  */
-export declare function getInequalityBoundsFromAssumptions(ce: ComputeEngine, symbol: string): {
-    lowerBound?: Expression;
-    lowerStrict?: boolean;
-    upperBound?: Expression;
-    upperStrict?: boolean;
-};
+export declare function getInequalityBoundsFromAssumptions(ce: ComputeEngine, subject: string | Subject): IntervalBounds;

package/dist/types/compute-engine/boxed-expression/init-lazy-refs.d.ts

@@ -1 +1 @@
-/* 0.57.0 */
+/* 0.59.0 */

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

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

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function canonicalNegate(expr: Expression): Expression;
 /**
  * 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.57.0 */
+/* 0.59.0 */
 import { BigDecimal } from '../../big-decimal';
 import type { Rational } from '../numerics/types';
 import type { Expression, ExpressionInput } from '../global-types';

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 import { DEFAULT_COMPLEXITY } from './constants';
 export { DEFAULT_COMPLEXITY };

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
  * Leaf module for wildcard pattern utility functions.
  *
  * These are extracted from boxed-patterns.ts to break circular dependencies:

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * The total degree of an expression is the sum of the
  * positive integer degrees of the factors in the expression:

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export { totalDegree, maxDegree, lex, revlex } from './polynomial-degree';
 /**
  * Coefficient of a univariate (single variable) polynomial.

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

@@ -1,2 +1,2 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function isPrime(expr: Expression): boolean | undefined;

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

@@ -0,0 +1,112 @@
+/* 0.59.0 */
+ * Operator-indexed rule dispatch (FUNGRIM-PLAN-2-RULES.md §2.1, Feature A).
+ *
+ * This is an INTERNAL side table: the public `BoxedRuleSet` type is
+ * unchanged. The index is keyed (via a `WeakMap`) on the identity of the
+ * boxed `rules` array, so engine-cached rule sets (which produce a fresh
+ * array on each cache invalidation) get one index build per cache
+ * generation, with no extra invalidation plumbing.
+ *
+ * ## Soundness
+ *
+ * The index partitions rules into:
+ * - `byHead`: rules whose match pattern has a literal, head-faithful
+ *   operator — only tried when the subject expression's operator (or one of
+ *   its cross-head compatible operators, see `HEAD_COMPAT`) selects that
+ *   bucket;
+ * - `alwaysTry`: rules that may apply to expressions of any shape.
+ *
+ * The classification must exactly mirror the cross-head special cases in
+ * `match.ts`, otherwise the index could skip a rule that would have fired.
+ * Each special case is annotated below with the `match.ts` location it
+ * mirrors. Anything unclassifiable is conservatively `alwaysTry`.
+ *
+ * This module is a LEAF module: it imports only types from `global-types`
+ * and the runtime type guards. Do not add imports that could create
+ * circular dependencies.
+ */
+import type { BoxedRule, Expression } from '../global-types';
+/** A rule paired with its position in the original rule array. */
+export type OrdinalRule = {
+    rule: BoxedRule;
+    ordinal: number;
+};
+export interface RuleIndex {
+    /** Rules whose match pattern has a literal, head-faithful operator,
+     *  bucketed by that operator. Each bucket is in ascending ordinal order. */
+    byHead: ReadonlyMap<string, ReadonlyArray<OrdinalRule>>;
+    /** Functional rules, non-function-expression patterns, wildcard-headed
+     *  patterns, and effective-variations rules with variant-capable
+     *  arithmetic heads. In ascending ordinal order. */
+    alwaysTry: ReadonlyArray<OrdinalRule>;
+    /** `rules.length` at build time; staleness guard against in-place
+     *  mutation of the rule array. */
+    count: number;
+}
+/**
+ * Pattern heads that `matchVariations()` (match.ts:333-440) can match across
+ * heads — e.g. expression `x` matches pattern `Add(0, x)`. A rule with one of
+ * these pattern heads and effective `useVariations` may match an expression
+ * of *any* operator, so it must be `alwaysTry` in that case.
+ *
+ * - 'Negate'   — match.ts:353 (0 → -x)
+ * - 'Add'      — match.ts:359 (x → 0+x; a-b → a+(-b))
+ * - 'Subtract' — match.ts:372 (a → a-0; -a → 0-a)
+ * - 'Multiply' — match.ts:385 (x → 1·x; -x → -1·x; x/a → (1/a)·x)
+ * - 'Divide'   — match.ts:403 (x → x/1)
+ * - 'Square'   — match.ts:409 (Power(x,2) → Square(x))
+ * - 'Exp'      — match.ts:415 (Power(E,x) → Exp(x))
+ * - 'Power'    — match.ts:421 (Square(x), Exp(x), x → Power(x,1))
+ *
+ * All other pattern heads return `null` from `matchVariations()`, i.e.
+ * non-arithmetic heads are safely indexable even under variations.
+ */
+export declare const VARIANT_CAPABLE: ReadonlySet<string>;
+/**
+ * Cross-head special cases in `matchOnce()` that are ALWAYS active
+ * (independent of `useVariations`): maps a subject expression's operator to
+ * the additional pattern-head buckets that must be consulted.
+ *
+ * - expr `Multiply` → pattern `Divide` — match.ts:158-197
+ *   (`Multiply(Rational(1,n), x)` matches `Divide` patterns)
+ * - expr `Divide`   → pattern `Power`  — match.ts:199-218
+ *   (`Divide(1, x)` matches `Power` patterns, i.e. x^-1)
+ * - expr `Root`     → pattern `Power`  — match.ts:220-236
+ *   (`Root(x, n)` matches `Power` patterns, i.e. x^(1/n))
+ *
+ * Plus, handled directly in `candidateRules()`: a number literal must
+ * consult the `Divide` bucket — match.ts:142-156 (rational literals like
+ * `3/2` match `Divide` patterns).
+ *
+ * Also mirrored in classification (not here): a pattern head starting with
+ * `_` (wildcard operator) matches any function — match.ts:238-244 — so such
+ * rules are `alwaysTry`.
+ */
+export declare const HEAD_COMPAT: ReadonlyMap<string, ReadonlyArray<string>>;
+/** Below this rule count, `getRuleIndex()` returns `undefined` and callers
+ *  fall back to the plain linear scan (index overhead not worth it). */
+export declare const DEFAULT_MIN_INDEX_SIZE = 8;
+/**
+ * Get (build + memoize) the index for a boxed rule array.
+ *
+ * `variations` selects the classification used when the *call-level*
+ * `options.useVariations` is `true` (rule-level `useVariations` is folded in
+ * at build time for both indexes). Below `minSize` (default 8) returns
+ * `undefined` and callers fall back to the linear scan.
+ */
+export declare function getRuleIndex(rules: ReadonlyArray<BoxedRule>, variations: boolean, minSize?: number): RuleIndex | undefined;
+/**
+ * Candidate rules for `expr`, in original declaration order, with
+ * ordinal > `fromOrdinal`.
+ *
+ * Implemented as an ordinal-merge of:
+ * - `alwaysTry`,
+ * - `byHead[expr.operator]`,
+ * - the `HEAD_COMPAT[expr.operator]` buckets, and
+ * - the `Divide` bucket when `expr` is a number literal (match.ts:142-156).
+ *
+ * A rule hinted with several `operators` may appear in more than one
+ * consulted bucket; duplicates are removed during the merge (distinct rules
+ * never share an ordinal).
+ */
+export declare function candidateRules(index: RuleIndex, expr: Expression, fromOrdinal: number): Generator<OrdinalRule>;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare const ConditionParent: {
     boolean: string;
     string: string;
@@ -102,6 +102,7 @@ export declare function checkConditions(x: Expression, conditions: string[]): bo
  */
 export declare function boxRules(ce: ComputeEngine, rs: Rule | ReadonlyArray<Rule | BoxedRule> | BoxedRuleSet | undefined | null, options?: {
     canonical?: boolean;
+    purpose?: RulePurpose;
 }): BoxedRuleSet;
 /**
  * Apply a rule to an expression, assuming an incoming substitution

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { IComputeEngine as ComputeEngine, Expression, JsonSerializationOptions } from '../global-types';
 interface ProductLike {
     asRationalExpression(): Expression;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare function sgn(expr: Expression): Sign | undefined;
 /**
  * Sign `s` is > 0.

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 type InternalSimplifyOptions = SimplifyOptions & {
     useVariations: boolean;
 };

package/dist/types/compute-engine/boxed-expression/solve-linear-system.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /**
  * Solve a system of linear equations.
  *

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * MathJsonExpression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 type ComplexResult = {
     re: number;
     im: number;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** Assuming x in an expression in radians, convert to current angular unit. */
 export declare function radiansToAngle(x: Expression | undefined): Expression | undefined;
 export declare function evalTrig(name: string, op: Expression | undefined): Expression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { NumericValue } from '../numeric-value/types';
 /** Preferred guard for runtime expressions. */
 export declare function isExpression(x: unknown): x is Expression;

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import { Type } from '../../common/type/types';
 import { NumericValue } from '../numeric-value/types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  * Check that the number of arguments is as expected.

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

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 /** If a collection has fewer than this many elements, eagerly evaluate it.
  *
  * For example, evaluate the Union of two sets with 10 elements each will

package/dist/types/compute-engine/compilation/base-compiler.d.ts

@@ -1,4 +1,4 @@
-/* 0.57.0 */
+/* 0.59.0 */
 import type { CompileTarget, TargetSource } from './types';
 /**
  * Base compiler class containing language-agnostic compilation logic
@@ -48,6 +48,13 @@ export declare class BaseCompiler {
      *    GLSL (no dynamic arrays, no push).  A compile-time error is thrown.
      *    TODO(E3-GLSL): support GLSL multi-Element via a pre-declared fixed-size
      *    array or by unrolling when bounds are known at compile time.
+     *
+     * Known issue (imperative form): the IIFE generated by form (1) has no
+     * `return` statement, so `Loop(body, Element(i, Range(lo, hi)))` compiled
+     * to JS evaluates to `undefined` at runtime, while CE evaluation returns a
+     * `List` of body values. See `test/compute-engine/a1-c1-compile-parity.test.ts`
+     * ("Loop compiles in JS") for the verify-only test that locks in the
+     * current behavior.
      */
     private static compileForLoop;
     /**