@cortex-js/compute-engine 0.58.0 → 0.59.0

package/dist/types/compute-engine/compilation/gpu-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * GPU shader operators shared by GLSL and WGSL.
@@ -33,14 +33,24 @@ export declare function compileGPUMatrix(args: ReadonlyArray<Expression>, compil
  * GPU gamma function using Lanczos approximation (g=7, n=9 coefficients).
  *
  * Uses reflection formula for z < 0.5 and Lanczos for z >= 0.5.
- * Valid for both GLSL and WGSL (uses standard math builtins).
+ * GLSL syntax.
  */
-export declare const GPU_GAMMA_PREAMBLE = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)\n  float w = z;\n  if (z < 0.5) w = 1.0 - z;\n  w -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (w + 1.0);\n  x += -1259.1392167224028 / (w + 2.0);\n  x += 771.32342877765313 / (w + 3.0);\n  x += -176.61502916214059 / (w + 4.0);\n  x += 12.507343278686905 / (w + 5.0);\n  x += -0.13857109526572012 / (w + 6.0);\n  x += 9.9843695780195716e-6 / (w + 7.0);\n  x += 1.5056327351493116e-7 / (w + 8.0);\n  float t = w + 7.5;\n  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) return PI / (sin(PI * z) * g);\n  return g;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+export declare const GPU_GAMMA_PREAMBLE_GLSL = "\nfloat _gpu_gamma(float z) {\n  const float PI = 3.14159265358979;\n  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)\n  float w = z;\n  if (z < 0.5) w = 1.0 - z;\n  w -= 1.0;\n  float x = 0.99999999999980993;\n  x += 676.5203681218851 / (w + 1.0);\n  x += -1259.1392167224028 / (w + 2.0);\n  x += 771.32342877765313 / (w + 3.0);\n  x += -176.61502916214059 / (w + 4.0);\n  x += 12.507343278686905 / (w + 5.0);\n  x += -0.13857109526572012 / (w + 6.0);\n  x += 9.9843695780195716e-6 / (w + 7.0);\n  x += 1.5056327351493116e-7 / (w + 8.0);\n  float t = w + 7.5;\n  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) return PI / (sin(PI * z) * g);\n  return g;\n}\n\nfloat _gpu_gammaln(float z) {\n  // Stirling asymptotic expansion for ln(Gamma(z)), z > 0\n  float z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
+/**
+ * GPU Gamma function preamble (WGSL syntax). WGSL has no implicit GLSL-style
+ * `float`/braceless-`if` syntax, so a `_WGSL` variant is required (the GLSL
+ * preamble does not compile as WGSL).
+ */
+export declare const GPU_GAMMA_PREAMBLE_WGSL = "\nfn _gpu_gamma(z: f32) -> f32 {\n  let PI = 3.14159265358979;\n  var w = z;\n  if (z < 0.5) { w = 1.0 - z; }\n  w = w - 1.0;\n  var x = 0.99999999999980993;\n  x = x + 676.5203681218851 / (w + 1.0);\n  x = x + -1259.1392167224028 / (w + 2.0);\n  x = x + 771.32342877765313 / (w + 3.0);\n  x = x + -176.61502916214059 / (w + 4.0);\n  x = x + 12.507343278686905 / (w + 5.0);\n  x = x + -0.13857109526572012 / (w + 6.0);\n  x = x + 9.9843695780195716e-6 / (w + 7.0);\n  x = x + 1.5056327351493116e-7 / (w + 8.0);\n  let t = w + 7.5;\n  let g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;\n  if (z < 0.5) { return PI / (sin(PI * z) * g); }\n  return g;\n}\n\nfn _gpu_gammaln(z: f32) -> f32 {\n  let z3 = z * z * z;\n  return z * log(z) - z - 0.5 * log(z)\n    + 0.5 * log(2.0 * 3.14159265358979)\n    + 1.0 / (12.0 * z)\n    - 1.0 / (360.0 * z3)\n    + 1.0 / (1260.0 * z3 * z * z);\n}\n";
 /**
  * GPU error function using Abramowitz & Stegun approximation.
- * Maximum error: |epsilon(x)| <= 1.5e-7.
+ * Maximum error: |epsilon(x)| <= 1.5e-7. GLSL syntax.
+ */
+export declare const GPU_ERF_PREAMBLE_GLSL = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+/**
+ * GPU error function preamble (WGSL syntax). See GPU_GAMMA_PREAMBLE_WGSL.
  */
-export declare const GPU_ERF_PREAMBLE = "\nfloat _gpu_erf(float x) {\n  float ax = abs(x);\n  float t = 1.0 / (1.0 + 0.3275911 * ax);\n  float y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  float result = 1.0 - y * exp(-ax * ax);\n  return x < 0.0 ? -result : result;\n}\n\nfloat _gpu_erfinv(float x) {\n  float pi = 3.14159265358979;\n  float x2 = x * x;\n  float x3 = x * x2;\n  float x5 = x3 * x2;\n  float x7 = x5 * x2;\n  float x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
+export declare const GPU_ERF_PREAMBLE_WGSL = "\nfn _gpu_erf(x: f32) -> f32 {\n  let ax = abs(x);\n  let t = 1.0 / (1.0 + 0.3275911 * ax);\n  let y = ((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;\n  let result = 1.0 - y * exp(-ax * ax);\n  if (x < 0.0) { return -result; }\n  return result;\n}\n\nfn _gpu_erfinv(x: f32) -> f32 {\n  let pi = 3.14159265358979;\n  let x2 = x * x;\n  let x3 = x * x2;\n  let x5 = x3 * x2;\n  let x7 = x5 * x2;\n  let x9 = x7 * x2;\n  return sqrt(pi) * 0.5 * (x + (pi / 12.0) * x3 + (7.0 * pi * pi / 480.0) * x5 + (127.0 * pi * pi * pi / 40320.0) * x7 + (4369.0 * pi * pi * pi * pi / 5806080.0) * x9);\n}\n";
 /**
  * GPU Heaviside step function preamble (GLSL syntax).
  * Returns 0 for x<0, 0.5 at x=0, 1 for x>0.

package/dist/types/compute-engine/compilation/interval-javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * JavaScript interval arithmetic compilation target
  *
  * Compiles mathematical expressions to JavaScript code using interval arithmetic
@@ -61,9 +61,9 @@ export declare class ComputeEngineIntervalFunction extends Function {
         gammaln: typeof import("../interval").gammaln;
         factorial: typeof import("../interval").factorial;
         factorial2: typeof import("../interval").factorial2;
-        binomial: typeof import("../interval/elementary").binomial;
-        gcd: typeof import("../interval/elementary").gcd;
-        lcm: typeof import("../interval/elementary").lcm;
+        binomial: typeof import("../interval").binomial;
+        gcd: typeof import("../interval").gcd;
+        lcm: typeof import("../interval").lcm;
         chop: typeof import("../interval/elementary").chop;
         erf: typeof import("../interval/elementary").erf;
         erfc: typeof import("../interval/elementary").erfc;

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
 import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
 import { choose } from '../boxed-expression/expand';

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * Source code in the target language
  */

package/dist/types/compute-engine/compilation/wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { BigDecimal } from '../big-decimal';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

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

@@ -1,3 +1,3 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _precision;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;
 export declare function pushEvalContext(ce: IComputeEngine, scope: Scope, name?: string): void;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

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

@@ -1,6 +1,14 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
- * Internal holder for simplification rules and their cache-staleness marker.
+ * Internal holder for a rule array and its cache-staleness marker.
+ *
+ * Despite its name, this class is rule-agnostic and backs all three
+ * engine rule stores: `ce.simplificationRules`, `ce.solveRules` and
+ * `ce.harmonizationRules`.
+ *
+ * Note: mutation detection is length-based, so a same-length in-place
+ * element replacement is not detected. Use the property setter (full
+ * replacement) for that.
  *
  * @internal
  */

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { Type, TypeString } from '../common/type/types';
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

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

@@ -0,0 +1,13 @@
+/* 0.59.0 */
+import type { FungrimLoadOptions, FungrimLoadReport, FungrimRuleData } from './types';
+/** The compiled artifact (the whole slice, bundled as JSON). */
+export declare const FUNGRIM_CORE: FungrimRuleData;
+/**
+ * Load the compiled Fungrim identities into a Compute Engine instance.
+ *
+ * Synchronous and idempotent per engine: a second call with an overlapping
+ * selection skips the already-loaded rule ids. Shell declarations go into
+ * the **current** scope — call `loadIdentities` before declaring user
+ * symbols that could shadow shell heads.
+ */
+export declare function loadIdentities(ce: IComputeEngine, options?: FungrimLoadOptions): FungrimLoadReport;

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

@@ -0,0 +1,160 @@
+/* 0.59.0 */
+import type { BoxedSubstitution } from '../types-serialization';
+/** Raw MathJSON — the artifact is plain JSON. */
+export type FungrimMathJson = unknown;
+/**
+ * A declarative guard specification, compiled offline from a corpus entry's
+ * assumptions (FUNGRIM-PLAN-5-LOADER.md §2.2). The runtime loader turns each
+ * spec into a tri-valued condition closure; every predicate must return a
+ * definitive positive for the rule to fire (fail-closed).
+ */
+export type GuardSpec = {
+    k: 'type';
+    wc: string;
+    t: 'integer' | 'real' | 'rational' | 'complex';
+} | {
+    k: 'cmp';
+    wc: string;
+    op: 'gt' | 'ge' | 'lt' | 'le';
+    bound: FungrimMathJson;
+}
+/**
+ * Phase 3: comparison over a part extractor of the substituted value —
+ * `Greater(Re(z), 0)`, `Less(Abs(q), 1)`, `Element(Im(z), Interval(a,b))`.
+ * Literal substitutions fold numerically; symbol substitutions consult the
+ * Track-3 part-bound assumption facts.
+ */
+ | {
+    k: 'part-cmp';
+    wc: string;
+    part: 're' | 'im' | 'abs' | 'arg';
+    op: 'gt' | 'ge' | 'lt' | 'le';
+    bound: FungrimMathJson;
+}
+/**
+ * Phase 3: membership in an inert or compound set (`HH`, explicit
+ * `Set(…)`, `Union(…)`). Fires only on a literal `True` from the Element
+ * evaluation — for inert shells like `HH` (no `contains` handler) that is
+ * the Track-3 stored-membership exact-match path
+ * (`assume(Element(tau, HH))`); literals can never discharge those.
+ */
+ | {
+    k: 'member';
+    wc: string;
+    set: FungrimMathJson;
+} | {
+    k: 'ne';
+    lhs: FungrimMathJson;
+    rhs: FungrimMathJson;
+} | {
+    k: 'eval';
+    pred: FungrimMathJson;
+};
+/** Corpus entry class of a compiled rule. */
+export type FungrimRuleClass = 'specific-value' | 'identity';
+/** Which engine rule store a compiled rule is routed to. */
+export type FungrimRuleTarget = 'simplify' | 'solve' | 'harmonization';
+/**
+ * One compiled rule record from the artifact. `match`/`replace` are stored
+ * in CANONICAL-form MathJSON: the loader must box them canonically (in a
+ * scope where the wildcards carry their guard-implied types) before handing
+ * them to the engine.
+ */
+export type CompiledFungrimRule = {
+    /** `'fungrim:<entry-id>'` — surfaces in `simplify()` steps' `because`. */
+    id: string;
+    match: FungrimMathJson;
+    replace: FungrimMathJson;
+    guards: GuardSpec[];
+    purpose: RulePurpose;
+    target: FungrimRuleTarget;
+    class: FungrimRuleClass;
+    /** Heads referenced by the rule (for shell pruning and diagnostics). */
+    heads: string[];
+    /** Corpus topics (for load-time filtering). */
+    topics: string[];
+};
+/** A pruned shell declaration: a head referenced by the compiled rules that
+ *  is not a Compute Engine built-in. */
+export type FungrimShellDeclaration = {
+    signature: string;
+    description?: string;
+    arity?: number | number[];
+};
+/** Provenance and compile-time statistics baked into the artifact. */
+export type FungrimManifest = {
+    schemaVersion: number;
+    generator: string;
+    upstream: {
+        name: string;
+        snapshotSha256: string | null;
+        translator: string | null;
+    };
+    slice: {
+        classes: string[];
+        guardLevels: string[];
+        entries: number;
+    };
+    counts: {
+        rules: number;
+        byPurpose: Record<string, number>;
+        byClass: Record<string, number>;
+        byTarget: Record<string, number>;
+    };
+    /** Offline skip counts by reason (guard-uncompilable, compat-signature,
+     *  wildcard-loss, no-fire, duplicate-undirected, lhs-not-value-form, …). */
+    ledger: Record<string, number>;
+};
+/** The shape of the compiled artifact (`fungrim-core-data.json`). */
+export type FungrimRuleData = {
+    manifest: FungrimManifest;
+    declarations: Record<string, FungrimShellDeclaration>;
+    rules: CompiledFungrimRule[];
+};
+/**
+ * Debug hook invoked when a rule's condition fails specifically because a
+ * guard predicate returned `undefined` (unknown) — as opposed to a
+ * definitive negative. Converts "the rule silently didn't fire" into an
+ * actionable trace (FUNGRIM-PLAN-5-LOADER.md §2.8).
+ */
+export type FungrimGuardUndecidedHandler = (ruleId: string, wildcards: BoxedSubstitution) => void;
+/** Options for `loadIdentities()` (FUNGRIM-PLAN-5-LOADER.md §2.1). */
+export type FungrimLoadOptions = {
+    /** Only load rules tagged with at least one of these corpus topics. */
+    topics?: ReadonlyArray<string>;
+    /** Only load rules of these classes. */
+    classes?: ReadonlyArray<FungrimRuleClass>;
+    /** Only load rules with these purposes. */
+    purposes?: ReadonlyArray<RulePurpose>;
+    /** When `true`, rules targeting the solve/harmonization stores are routed
+     *  to `ce.solveRules`/`ce.harmonizationRules`. **Default**: `false`
+     *  (such rules are skipped with reason `'solve-disabled'`). */
+    solve?: boolean;
+    /** Debug hook for guard predicates that return `undefined`. */
+    onGuardUndecided?: FungrimGuardUndecidedHandler;
+    /** Alternate compiled artifact (testing, future per-family data modules).
+     *  **Default**: the bundled `FUNGRIM_CORE` artifact. */
+    data?: FungrimRuleData;
+};
+/** The report returned by `loadIdentities()` (FUNGRIM-PLAN-5-LOADER.md §2.8). */
+export type FungrimLoadReport = {
+    /** Number of rules registered by this call. */
+    loaded: number;
+    byTarget: Record<FungrimRuleTarget, number>;
+    byPurpose: Record<RulePurpose, number>;
+    /** Shell heads newly declared in the current scope by this call. */
+    declared: string[];
+    /** Runtime skips: selection filters, already-loaded ids, boxing failures
+     *  in the user's environment. */
+    skipped: {
+        id: string;
+        reason: string;
+    }[];
+    /** Baked-in offline skip counts by reason, from the artifact manifest —
+     *  what the *corpus* contains vs. what this artifact can do. */
+    compileLedger: Record<string, number>;
+};
+export type IdentitiesLoadOptions = FungrimLoadOptions;
+export type IdentitiesLoadReport = FungrimLoadReport;
+export type IdentitiesRuleData = FungrimRuleData;
+export type IdentitiesGuardUndecidedHandler = FungrimGuardUndecidedHandler;

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

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

@@ -1,11 +1,11 @@
-/* 0.58.0 */
+/* 0.59.0 */
 import { BigDecimal } from '../big-decimal';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
 import type { OneOf } from '../common/one-of';
 import type { ConfigurationChangeListener } from '../common/configuration-change';
 import type { MathJsonExpression, MathJsonSymbol, MathJsonNumberObject } from '../math-json/types';
-import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition, OperatorInfo, SymbolInfo } from './global-types';
+import type { ValueDefinition, OperatorDefinition, AngularUnit, AssignValue, AssumeResult, Expression, BoxedRule, BoxedRuleSet, BoxedSubstitution, CanonicalOptions, Metadata, Rule, RulePurpose, Scope, EvalContext, ExpressionInput, IComputeEngine, ILatexSyntax, BoxedDefinition, SymbolDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, LibraryDefinition, OperatorInfo, SymbolInfo } from './global-types';
 import type { LibraryCategory, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/types';
 import type { BigNum, Rational } from './numerics/types';
 import { ExactNumericValueData, NumericValue, NumericValueData } from './numeric-value/types';
@@ -92,6 +92,10 @@ export declare class ComputeEngine implements IComputeEngine {
     private _cost?;
     /** @internal Backing state for simplificationRules */
     private _simplificationRules;
+    /** @internal Backing state for solveRules */
+    private _solveRules;
+    /** @internal Backing state for harmonizationRules */
+    private _harmonizationRules;
     /** @internal Registry of compilation targets */
     private _compilationTargets;
     /** @internal Fu trigonometric simplification algorithm */
@@ -112,6 +116,8 @@ export declare class ComputeEngine implements IComputeEngine {
     get contextStack(): ReadonlyArray<EvalContext>;
     set contextStack(stack: ReadonlyArray<EvalContext>);
     /** @internal */
+    private __typeResolver;
+    /** @internal */
     get _typeResolver(): TypeResolver;
     /**
      * Declare a new type in the current scope.
@@ -445,6 +451,43 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get simplificationRules(): Rule[];
     set simplificationRules(rules: 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 a copy of the built-in root-finding rules.
+     *
+     * Add custom rules with `push()`:
+     * ```ts
+     * ce.solveRules.push({
+     *   match: ['Add', ['Tan', '_x'], '__b'],
+     *   replace: ['Arctan', ['Negate', '__b']],
+     *   condition: ({ __b }) => !__b.has('_x'),
+     * });
+     * ```
+     *
+     * Or replace entirely:
+     * ```ts
+     * ce.solveRules = myCustomRules;
+     * ```
+     */
+    get solveRules(): Rule[];
+    set solveRules(rules: 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`: the unknown is
+     * the wildcard `_x`; `push()` to extend, assign to replace.
+     */
+    get harmonizationRules(): Rule[];
+    set harmonizationRules(rules: Rule[]);
     /**
      * Return definition matching the symbol, starting with the current
      * lexical scope and going up the scope chain.
@@ -738,6 +781,9 @@ export declare class ComputeEngine implements IComputeEngine {
     }): Expression;
     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;
     /**
      * Return a set of built-in rules.

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Elementary interval functions (sqrt, pow, exp, ln, abs, floor, ceil, min, max, mod)
  *
  * @module interval/elementary
@@ -173,15 +173,23 @@ export declare function factorial(x: Interval | IntervalResult): IntervalResult;
 export declare function factorial2(x: Interval | IntervalResult): IntervalResult;
 /**
  * Binomial coefficient C(n, k) on intervals.
- * Both arguments are rounded to nearest integer. Monotonic in n for fixed k.
+ *
+ * Both arguments are rounded to nearest integer. C(n, k) is not monotone in k
+ * (it peaks at k ≈ n/2), so the enclosure enumerates the integer grid.
  */
 export declare function binomial(n: Interval | IntervalResult, k: Interval | IntervalResult): IntervalResult;
 /**
  * GCD on intervals. Both arguments rounded to nearest integer.
+ *
+ * gcd is not monotone (e.g. gcd(6, 5) = 1 sits between gcd(6, 6) = 6 and
+ * gcd(6, 4) = 2), so the enclosure enumerates the integer grid.
  */
 export declare function gcd(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
 /**
  * LCM on intervals. Both arguments rounded to nearest integer.
+ *
+ * lcm is not monotone (e.g. lcm(2, 5) = 10 exceeds lcm(2, 6) = 6), so the
+ * enclosure enumerates the integer grid.
  */
 export declare function lcm(a: Interval | IntervalResult, b: Interval | IntervalResult): IntervalResult;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Interval arithmetic library for reliable function evaluation
  *
  * This module provides interval versions of mathematical operations
@@ -16,7 +16,7 @@ import { less as _less, lessEqual as _lessEqual, greater as _greater, greaterEqu
 export type { Interval, IntervalResult, BoolInterval } from './types';
 export { ok, point, containsExtremum, unionResults, mergeDomainClip, isPoint, containsZero, isPositive, isNegative, isNonNegative, isNonPositive, width, midpoint, getValue, unwrap, unwrapOrPropagate, } from './util';
 export { add, sub, mul, div, negate, _mul } from './arithmetic';
-export { sqrt, square, pow, powInterval, exp, ln, log10, log2, abs, floor, ceil, round, fract, trunc, min, max, mod, remainder, heaviside, sign, gamma, gammaln, factorial, factorial2, } from './elementary';
+export { sqrt, square, pow, powInterval, exp, ln, log10, log2, abs, floor, ceil, round, fract, trunc, min, max, mod, remainder, heaviside, sign, gamma, gammaln, factorial, factorial2, binomial, gcd, lcm, } from './elementary';
 export { sin, cos, tan, cot, sec, csc, asin, acos, atan, atan2, sinh, cosh, tanh, asinh, acosh, atanh, acot, acsc, asec, coth, csch, sech, acoth, acsch, asech, sinc, fresnelS, fresnelC, } from './trigonometric';
 export { less, lessEqual, greater, greaterEqual, equal, notEqual, and, or, not, piecewise, clamp, } from './comparison';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Trigonometric interval functions
  *
  * @module interval/trigonometric

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Interval arithmetic types for reliable function evaluation
  *
  * @module interval/types

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

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Utility functions for interval arithmetic
  *
  * @module interval/util

package/dist/types/compute-engine/latex-syntax/dictionary/default-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
  * Default LaTeX dictionary assembly.
  *
  * This file imports all individual domain dictionaries and assembles them

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-colors.d.ts

@@ -1,4 +1,4 @@
-/* 0.58.0 */
+/* 0.59.0 */
 /**
  * LaTeX dictionary for color constructors and conversions.
  *

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-complex.d.ts

@@ -1,2 +1,2 @@
-/* 0.58.0 */
+/* 0.59.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;