Skip to main content

Crate earthsci_ast

Crate earthsci_ast 

Source
Expand description

§earthsci-ast - Rust Implementation

This crate provides Rust types and utilities for the EarthSciML Abstract Syntax Tree Format (ESM).

§Features

  • Core: Parse, serialize, Markdown and Typst source text, substitute, validate schema
  • Analysis: Unit checking, equation counting, structural validation
  • CLI Tool: Command-line interface for validation and conversion
  • WASM: WebAssembly compilation for web use

§Example

use earthsci_ast::{EsmFile, load_string, to_json};

// Load an ESM file
let esm_data = r#"
{
  "esm": "2.0.0",
  "metadata": {
    "name": "test_model"
  },
  "models": {
    "simple": {
      "variables": {},
      "equations": []
    }
  }
}
"#;
let esm_file: EsmFile = load_string(esm_data)?;

// Save back to JSON
let json = to_json(&esm_file)?;

Re-exports§

pub use performance::CompactExpr;
pub use performance::PerformanceError;

Modules§

extension
The tier-2 extension seam
intern
Load-scoped structural interning (hash-consing) of ExpressionNodes.
performance
Experimental performance utilities (benchmark support).
precision
The evaluator’s working precision — domain.element_type (esm-spec §11.3). Public because the contract it implements ("Float32" means per-operation binary32 rounding) is observable, and a host embedding the evaluator needs to be able to name it. Working precision of the evaluator — domain.element_type (esm-spec §11.3).
precision_infer
Static precision inference: propagate ModelVariable.element_type over an expression tree and mark the boundaries (esm-spec §11.3.1).
provider
Data-provider consumption + cadence wiring — the refresh executor (bead ess-14f.9 / RS-R1, plan esio-consumer-rust-plan; parent ess-14f).
simulate_array
Native array runtime for faq, makearray, index, reshape, transpose, concat, and broadcast expression nodes (gt-oxr).

Structs§

AffectEquation
Equation that modifies state/parameters when event fires
AssertionResult
Outcome of one §6.6.5 inline-test assertion evaluated through the simulation pathway. actual is the computed reduction value (None when the simulation or reduction itself failed); message carries the diff or error text for non-passing results. Field-for-field identical to the Julia AssertionResult / Python AssertionResult, and Serialize-able so conformance runners can record it directly.
AxisCut
One decomposed horizontal index set: its name and its period, when the axis is periodic.
CallbackSet
The callbacks declared on a EsmProblem.
ClassSummary
Annotated-node counts by derived class — the golden class_summary.
Classification
One model’s complete §6.3.1 classification, computed once. Every name list is sorted.
CompilerReport
What built a Problem’s right-hand side, per rule (API_SPEC §5.8).
CompilerRuleReport
Where ONE rule of a Problem landed, and at what cadence (API_SPEC §5.8, “Every Problem reports what ran”).
ComponentGraph
Component graph representing model structure
ComponentMetadata
Summary counts a component node carries (esm-libraries-spec §4.8.1).
ComponentNode
Node in the component graph
ConstructSource
One construct of a document’s source text: where its content is in the document the text reads as, and where the text writes it.
ContinuousEvent
Continuous event that fires on zero-crossings
Contribution
One summand of a flattened equation’s right-hand side, with its authors (esm-libraries-spec §4.7.5, “Per-term provenance”).
CoordPlan
A CF dimension coordinate (§8.3): a 1-D coordinate variable named exactly like its dimension, its values, and its CF attributes. Field-for- field the shape of earthsciio::format::WriteCoord.
Coordinate
One entry of the document-scoped EsmFile::coordinates registry (RFC streaming-output-sinks §8.3): marks an existing data array — or an inline literal vector — as a physical coordinate and attaches CF metadata.
CouplingEdge
Edge in the component graph
CouplingImportOptions
Options controlling how coupling_import refs are resolved at flatten.
CouplingRole
A coupling-library formal component role (esm-spec §10.9). Present only in a coupling-library file’s top-level coupling_roles map; each entry carries an optional human-readable description. Roles are formal parameters (names, not types), bound to actual components at a coupling_import.
DaeError
Error returned by apply_dae_contract / discretize when the RFC §12 DAE binding contract cannot be satisfied.
DaeInfo
Summary of DAE classification stamped onto metadata.dae_info by discretize() per RFC §12.
DataSource
Generic, runtime-agnostic description of an external data source (esm-spec §8).
DataSourceBinding
Binds a parameter to ONE variable of a data_sources entry (esm-spec §8.5). The 0.x DataLoaderVariable minus units: the units are the parameter’s own, declared once on the parameter instead of twice.
DataSourceDeterminism
Reproducibility contract a loader advertises to bindings (esm-spec §8.9.2).
DataSourceLocation
File discovery configuration. Describes how to locate data files at runtime via URL templates with date/variable substitutions.
DataSourceMetadata
Free-form metadata about a data loader.
DataSourceTemporal
Temporal coverage and record layout for a data source.
Decomposition
The horizontal decomposition a tile cuts (RFC U3 §1): the decomposed index sets and the face sets that stagger off them, (face set, cell set). Every other index set is whole on every tile.
DependencyEdge
Edge representing dependencies between variables in an expression graph
DimensionPromotionRecord
Record of a dimension promotion applied during flattening.
DiscreteEvent
Discrete event that can modify the system
DiscretizeOptions
Options for discretize. The §11 pipeline options (max passes, strict unrewritten) will be added when that pipeline lands; today only the DAE knob exists.
DiscretizedFrom
Provenance stamp written to metadata.discretized_from by discretize() per RFC §12: identifies the source document the discretized one came from.
Domain
Spatial/temporal domain specification
EnsembleProblem
A EsmProblem plus a per-trajectory rewrite, and the family it stands for (§2.5.8) — the canonical form for parameter sweeps, Monte Carlo over declared distributions, and perturbed initial conditions.
Equation
Differential equation
EsmFile
Top-level ESM file structure
EsmProblem
A simulation problem: a document, an interval, and the bindings that fix the document rather than the run.
ExactScale
The EXACT scale of a unit relative to SI (esm-spec §4.8.1 “Scales are EXACT”).
ExpressionGraph
Expression graph representing variable dependencies within expressions
ExpressionGraphOptions
Settings for expression_graph_with_options.
ExpressionNode
Expression node representing an operator with operands.
FlattenMetadata
Provenance metadata for a flattening pipeline run.
FlattenedSystem
Spec-compliant flattened coupled system (§4.7.5).
FloatKeyError
Raised when a relational key contains a floating-point (or otherwise non-integer / out-of-domain) component, violating CONFORMANCE_SPEC.md §5.5.1 rule 1 (“floats are forbidden in keys”). Normalise the value to an integer / categorical ID before the build-time pre-pass.
ForcingSet
The forcing a program evaluation reads (API_SPEC §5.8): one immutable buffer per RhsProgram::forcing_slots entry, stamped with a process-unique epoch. Refresh is a swap: Self::replace makes a new set (a new epoch) sharing every other buffer, and a call on the new set re-runs what reads forcing. Cheap to clone; Send + Sync.
ForcingSlot
One buffer of a ForcingSet: the variable it serves, its shape, and its kind. The buffer holds shape’s element count (one for a 0-d slot), column-major, first index fastest.
FunctionalUpdate
A registered handler computing a parameter’s new value when its update fires (esm-spec §5.5). The 0.x event functional_affect, relocated onto the parameter it writes — which is why it needs no modified_params list: it writes exactly one thing, the parameter carrying it.
GridPlan
One grid: a set of variables sharing a spatial-dim signature, with the coordinates and dimension lengths that describe it (RFC §9). The RFC’s recommended decomposition is one Sink — one store or group — per grid.
HaloReport
RhsProgram::halo’s report (RFC U3 §3): for each state the program reads and each decomposed or face index set on its shape, keyed (variable, index set), how far the owned output reaches into it: lo cells below the owned box, hi above it.
InlineTestOptions
Per-document overrides for run_inline_tests_paths, returned by its options_for callback.
Integrator
A stepping integrator (§2.5.6) — the same lifecycle solve performs internally, exposed for callers that need to interleave their own work with the integration: the coupling driver in a host model, an interactive session, a progress UI.
Kernel
A compiled kernel (API_SPEC §5.8). Send + Sync; a clone shares it.
KernelBlock
One output’s block of a kernel’s out (0-based offset).
KernelSet
The kernels of one compile_kernels call, sharing one u / z layout, one parameter vector and one forcing signature.
KernelSpec
A kernel spec: a name, the parameters that read dt, and the outputs.
KernelWorkspace
A kernel’s buffers, one per concurrent caller. Send, not Sync.
LaneBlock
One variable’s block in a lane program’s inputs (API_SPEC §5.8, “Lanes”): its index sets outside the lane sets, their extents, and its offset in units of lanes. Element e (1-based, column-major over sets) of lane l is at slot (offset + e - 1)·L + l (l 0-based in Rust).
LaneInputs
The per-lane buffers of a lane program’s pre-gather plan: one run of capacity values per hoisted read. Filled by LaneProgram::gather_lane_inputs, read by LaneProgram::eval_gathered_into, which reads the forcing set they were gathered from. Send, like a workspace.
LaneLayout
A lane program’s u and aux layout, with the lane sets a column of cells indexes and the capacity L.
LaneProgram
A lane program (RFC U3 §6). Send + Sync + Clone; it reads the forcing sets of the program it was built from.
LoadOptions
Options controlling how load_string_with_options / load_document_with_options / load_path_with_options parse an ESM file (esm-spec §9.7).
LoaderField
One provider-served loaded field the flattened system consumes (esm-spec §8.5; esm-libraries-spec §4.7.5 step 4 loader_fields).
MaterializationPoint
A materialization point: where the frontier cut fires (§5.7.4). Either an expr_edge cadence drop inside a hot/per-event RHS, or an output_buffer — a top-level CONST equation whose entire output folds into the artifact.
MathError
Why parse_math refused a text, and where in it.
Metadata
Metadata section
MigrationError
Migration error that occurs when migration fails.
Model
ODE-based model component
ModelAnalysis
Inline illustrative analysis of how to run the enclosing component (schema Analysis): run configuration plus plots derived from the result. Carried by Model::analyses and ReactionSystem::analyses, the same way ModelTest serves both components’ tests.
ModelTest
Inline validation test for a Model.
ModelTestAssertion
A single scalar (variable, time, expected) check inside a ModelTest, or one of its §6.6.5 PDE-aware variants: coords point-samples an array state at physical coordinates, reduce collapses the variable’s spatial field to a scalar (L2_error/Linf_error against reference, or the pure collapsers integral/mean/max/min). coords and reduce are mutually exclusive per the schema.
ModelVariable
Variable within a model
Operator
Runtime operator reference
OutputMeta
The document slice a streaming writer needs so it can name axes and emit CF coordinates (RFC §7–§8) without importing the document model. Distilled from an EsmFile by derive_output_meta; the Rust mirror of Julia’s OutputMeta.
OutputPlan
The full derived output plan: every grid the run produces.
ParamSlot
One positional parameter of a program: p[k] is RhsProgram::parameters[k].
ParameterSweep
A parameter-sweep specification on a ModelAnalysis (schema ParameterSweep). Only Cartesian-product sweeps exist: the run count is the product of the dimensions’ lengths.
Partition
The partition of one model: the class summary, the materialization-point set, and the hot-tree / per-event-handler emptiness (§5.7.5 three execution outputs). Guards (§5.7.6) are checked during partition_model; a violation is an Err.
Plot
A plot specification of a ModelAnalysis (schema Plot). Structural information only — axes, series selection, value reductions; styling is the viewer’s concern.
PlotAxis
Axis specification of an analysis Plot (schema PlotAxis).
PlotSeries
A single named series of a multi-series line/scatter Plot (schema PlotSeries).
PlotValue
A scalar value derived from a trajectory, used for heatmap / color channels (schema PlotValue). Exactly one of at_time / reduce should be given.
PrepareError
A build-time preparation failure.
PrepareProgress
How far along an in-flight build is, handed to crate::problem::ProblemOptions::progress at every phase boundary AND at every unit of work inside the two phases that dominate a large build.
ProblemOptions
Build-time bindings for esm_problem — everything that fixes a document rather than a run.
Progress
How far along an in-flight integration is, handed to SolveOptions::progress once per accepted step.
ProviderGate
A provider-key ⇒ engine gate: per-NATIVE-axis selection plus the LOADER variable tails the gate applies to.
PushdownRewriteError
A malformed gate/record encountered while deriving provider gates (mirrors the Julia RefreshError sites in pushdown_rewrite.jl and the Python PushdownRewriteError).
Rational
A dimension exponent.
Reaction
Chemical reaction
ReactionSystem
Reaction network component
ReferenceEdge
A directed source → target edge: source references / depends on target.
ReferenceGraph
The resolved reference DAG for one model — the partition pass’s input.
ReferenceVertex
A vertex in the reference graph, addressed by a kind-namespaced key.
Remake
The substitutions remake applies. Every field is optional; an omitted field is inherited unchanged.
RhsProgram
A compiled right-hand side, possibly restricted to one operator’s terms and writes (API_SPEC §5.8). Made by rhs_program.
RhsSelection
Which terms and which variables an operator keeps (API_SPEC §5.8, select). None keeps every term, or writes every state.
RhsWorkspace
The per-call buffers of one program (API_SPEC §5.8): reused across calls, so a warm call allocates nothing. Made by the program that runs it, and usable only with that program (or a clone of it), one call at a time. It may move between threads (Send); it is not Sync.
SchemaError
A schema validation error
ScopedContext
Context for hierarchical scoped reference resolution
Solution
A simulation result.
SolutionMetadata
Provenance metadata for a Solution.
SolveOptions
Per-run knobs for crate::problem::solve.
Solver
Document-scoped, OPTIONAL solver hints (esm-spec §2.2).
SolverTimeSpan
solver.time_span (esm-spec §2.2.7): the {start, end} shape of tests[].time_span (TimeSpan), except that each bound may also be an RFC 3339 UTC timestamp, so it is a separate type rather than f64 bounds.
Species
Chemical species in a reaction system. Keyed by name in the parent map.
StateBlock
One state variable’s block of u (API_SPEC §5.8): shape column-major from flat_offset, first index fastest.
StoichiometricEntry
Species with stoichiometric coefficient.
StripSet
The construct classes esm_problem strips (API_SPEC §5.8). Combine with |; the empty set is the default and changes nothing.
StrippedConstructs
What strip removed (API_SPEC §5.8, “The stripped object”). Empty when nothing was requested or nothing was found.
StrippedEvent
One removed event, flattened and namespaced.
StrippedResidual
One stripped implicit equation, as the residual lhs - rhs.
StrippedUpdate
One stripped parameter and its update rules.
StructuralError
A structural validation error
SweepDimension
One axis of a ParameterSweep (schema SweepDimension): exactly one of values / range is present.
SweepRange
Generated range of values for one SweepDimension (schema SweepRange).
TileBlock
One variable’s block in a tile’s (or a whole-domain program’s) inputs (API_SPEC §5.8, “Tile layout”): a column-major block over its storage box, first index fastest.
TileBox
One tile’s owned box and storage box, one inclusive range per decomposed index set, in global 1-based indices; a periodic storage range is unwrapped (it may run below 1 or past N).
TileLayout
A program’s u and aux layout (API_SPEC §5.8): the written variables’ blocks, then the read-only ones, each list in flat-layout order.
TileProgram
One tile of a RhsProgram (RFC U3 §4): it reads u and aux over their storage boxes and writes only the owned rows of du.
TimeSpan
Simulation time interval used by inline model tests.
Tolerance
Numerical comparison tolerance used by inline model tests.
Unit
Represents a physical unit with dimensions
UnitFinding
A single dimensional finding produced while propagating an expression.
UnitParseFailure
A declared unit string that denotes no real unit.
UnitWarning
A dimensional-analysis finding surfaced by validation.
UpdateValue
The value form of an update rule: exactly one of expression, from, or handler (esm-spec §5.4, “What: exactly one value form”). Modelled as three options rather than an enum so the flattened round trip stays verbatim; the “exactly one” constraint is a schema-layer check.
ValidationResult
Result of structural validation
ValueInventionError
A value-invention build-time materialisation error (the Rust analog of Julia’s TreeWalkError value-invention codes).
ValueInventionResult
Result of materialize_value_invention.
VarGridding
The gridded layout of one output base-variable, derived from the flat state-element names (RFC §7).
VarPlan
One output variable: what a writer declares, plus the inversion that fills it. Field-for-field the shape of earthsciio::format::WriteVar once Self::gridding has scattered the trajectory into data.
VariableNode
Node representing a variable in an expression graph
ZBlock
One block of the z layout.

Enums§

Alg
Which solver family to use inside diffsol.
AutoRecords
Carrier for the "auto" literal in RecordsPerFile.
AxisSel
One axis of the NEUTRAL per-axis selection handed to a gated provider — the Rust spelling of the Python engine’s "all" | [0-based indices] form.
BoundaryKind
Per-dimension boundary policy for an out-of-range const-array stencil gather Mirrors the Julia _CONST_BOUNDARY_KINDS (:periodic / :clamp / :error): a gather at a 1-based index outside 1..=n resolves declaratively per the dimension’s policy instead of panicking.
Cadence
The cadence lattice (CONFORMANCE_SPEC.md §5.7.1): const ⊏ discrete ⊏ continuous. The derived Ord is the lattice order (variants declared low-to-high), so class(node) = max over inputs is just Iterator::max.
CanonicalizeError
Errors raised during canonicalization (per RFC §5.4.6 / §5.4.7).
CompileError
Errors raised when building a compiled model from a flattened system.
Compiler
Which strategy builds a Problem’s right-hand side (API_SPEC §5.8, esm-libraries-spec §2.5.10).
ComponentType
Type of component in the graph.
CouplingEntry
Coupling entry with discriminated union based on type field
DataSourceKind
Structural kind of a data loader dataset.
DependencyRelationship
PROVENANCE of a dependency — which structural site produced it, NOT a classification of the operators involved. An equation edge is always Additive (even for w ~ u * v) and a definition edge always Multiplicative (even for w ~ u + v).
DeriveError
Error type for ODE derivation operations
Dimension
Base physical dimensions — the eight canonical axes shared across the bindings (m kg s mol K A cd rad).
DiscreteEventTrigger
Trigger condition for discrete events
Distribution
A parameter’s value drawn from a probability distribution rather than fixed (esm-spec §6.3, schema Distribution). The closed set is normal, lognormal, uniform — bindings implement exactly these and reject anything else.
DistributionParam
A distribution’s location/scale parameter: a number for a scalar parameter, an array for a vector-valued one.
DocumentFormat
Which source format a document is written in.
EdgeKind
The three kinds of reference edge (RFC §6.1 “Propagation”).
EditError
Errors that can occur during editing operations
EquationDimensionVerdict
The dimensional analyser’s verdict on one equation, in the form a report prints: checked and consistent, provably inconsistent, or not checked.
EsmError
Main error type for the ESM format library
EventKind
"continuous" or "discrete".
Expr
Mathematical expression: a number literal, variable reference, or operator node.
FlattenError
Errors raised by flatten and flatten_model during spec-compliant coupled-system flattening.
Flow
What a SolveOptions::progress observer wants the integrator to do next.
GateAxis
One native axis of a loader selection — the vocabulary shared by a data loader’s declared select.axes (esm-spec §8.9) and by the pushdown record’s gate template. JSON spellings, in the same order as the variants:
InlineValue
A default / override VALUE: either a scalar, or inline row-major nested array data (esm-spec §6.3, §6.6.2 — the NumericArrayLiteral of the schema).
KernelOutput
One output of a kernel spec (API_SPEC §5.8, “Kernel specs”).
Key
A relational key component: an integer / categorical ID, or a tuple thereof. This is the orderable, float-free domain over which the five primitives operate.
LaneKind
The locality a lane program evaluates over (RFC U3 §6), with the index sets one lane’s cells column names, in order.
LhsForm
What an equation’s LHS says about the unknown it names (esm-spec §6.3.1).
Num
A numeric value for group_aggregate. Unlike Key, values may be floating-point (only keys are float-forbidden, rule 1). Integer aggregates stay integer (so a sum serialises as 5, not 5.0); a float anywhere in a bucket promotes the reduction to f64.
OutputError
Failure deriving an OutputPlan — the output-side mirror of the loader seam’s errors. Every variant names the offending variable or dimension: a mislabeled axis is silently wrong science, so these fail loudly.
ParameterUpdate
One update rule: WHEN a parameter refreshes, and WHAT from (esm-spec §5.4). Every kind except wiener carries exactly one value form — expression, from, or handler — held in the flattened UpdateValue; wiener carries none, because the parameter’s distribution IS its value.
ParameterUpdateSpec
A parameter’s update behaviour (esm-spec §5.4, schema ParameterUpdateSpec): EITHER a single rule, OR an ordered array of two or more applied in declaration order.
PlotY
A Plot’s y field (schema Plot.y oneOf): a single axis, or an array of axes for inline multi-series line/scatter plots. Untagged: an object is the single-axis form, an array the multi-series form — the two JSON shapes never collide.
PreparePhase
Which stage of the build crate::problem::esm_problem is in when it reports.
ProblemInput
What esm_problem can be built from: a path on disk, a raw JSON document, a typed document, or an already-flattened system.
RecordsPerFile
Number of records per file — an integer, or the literal "auto".
ReferenceResolutionError
A reference could not be resolved, or the reference graph has a cycle.
RegionBound
One bound of a makearray region box (esm-spec §4.3.2).
ReturnCode
Why a solve stopped — the SciML ReturnCode vocabulary (esm-libraries-spec.md §2.5.3).
Rhs
Whether esm_problem compiles a right-hand side.
RhsError
Why a program evaluation (eval_into) failed.
ScaleFactor
One factor of an ExactScale: a prime number, or π.
SemiringOp
An associative + commutative semiring combiner for group_aggregate (rule 5). Every registry ⊕ is one of these, so input and bucket order can never change the result.
SimulateError
Errors raised building an crate::problem::EsmProblem or running crate::problem::solve.
SlotKind
What a forcing slot carries.
StepStatus
Whether an Integrator has more to do.
StructuralErrorCode
Error codes for structural validation
SystemKind
The derived system kind (esm-spec §6.3.1).
TermOrigin
Who authored one Contribution to a flattened equation (esm-libraries-spec §4.7.5, “Per-term provenance”).
TimePoint
One bound of a SolverTimeSpan, kept in its authored form.
UnitConversion
Multiplicative factor (number) or Expression AST used to convert source- file values to the declared units.
UnitError
Error types for unit operations
UnitSeverity
Severity of a dimensional finding — the cross-binding policy that decides whether a finding blocks validation.
VariableBound
One bound of a model variable (esm-spec §6.3.2): the lb or ub field.
VariableKind
Type/kind of variable, as the graph renders it.
VariableMapTransform
A variable_map coupling transform (esm-spec §10.4): either one of the NAMED transform strings ("param_to_var", "identity", "additive", "multiplicative", "conversion_factor") or an Expression evaluated on the source value(s) in the flattened coupled system’s scope (the regridding form).
VariableType
Type of model variable (esm-spec §6.3). There are two declared types and no third: everything else a solver needs — which unknowns are ODE states, which parameters are Brownian — is DERIVED by [crate::classification], never declared.
VertexKind
The three kinds of vertex in the reference graph.

Constants§

DEFAULT_ABSTOL
The canonical default absolute tolerance — Julia’s. Rust’s was 1e-8. See DEFAULT_RELTOL.
DEFAULT_RELTOL
The canonical default relative tolerance.
ERROR_CODES
The [codes] registry in ENUMERABLE form: (constant name, code string) for every diagnostic code this binding emits, in declaration order (grouped by the pass that emits it, as the [codes] module is).
LIBRARY_VERSION
This crate’s OWN version — NOT the .esm format version, which is SCHEMA_VERSION. The two are unrelated numbers. Every binding exposes both, under these two names.
SCHEMA_VERSION
ESM schema version supported by this implementation. Must track the version in esm-schema.json’s $id / esm-spec.md; the schema_version_matches_bundled_schema test enforces it, and parse::library_version() (major-compat gating) derives from it.
UNIT_FINDING_ANALYSIS
See UNIT_FINDING_DIMENSIONAL_MISMATCH.
UNIT_FINDING_DIMENSIONAL_MISMATCH
The cross-binding code values a dimensional finding can carry, as surfaced on crate::validate::UnitWarning::code. Mirrors Go’s UnitFinding* constants (pkg/earthsci-ast-go/pkg/esm/units.go) and TypeScript’s UnitWarning['code'] union (pkg/earthsci-ast-ts/src/units.ts).
UNIT_FINDING_DIMENSIONLESS_LITERAL
A check site the CURRENT neutral-literal rule passes or skips fails once a nonzero bare numeric literal is read as dimensionless at scale 1 (esm-spec §4.8.6). A WARNING at this stage: validity is decided by the current rule alone.
UNIT_FINDING_UNPARSEABLE
See UNIT_FINDING_DIMENSIONAL_MISMATCH.

Traits§

ExpressionGraphInput
Trait for types that can build expression graphs
Graph
The graph kinds the esm-libraries-spec §4.8.3 text exporters render.
PrepareProvider
The CONST data-provider contract the build pipeline consumes: one provider feeds ONE field (the providers["<ModelPath>.<param>"] convention shared with the Julia/Python bindings). A gated provider may additionally honour a pushed- down per-axis selection; one that cannot is fetched whole and sliced engine-side (the fallback matches the pushdown result exactly).
TimeOriginSource
What the §2.2.7 clock accessors read a time origin from: a document, or its domain alone (esm-spec §2.2.7).

Functions§

add_coupling
Add a coupling entry to an ESM file
add_equation
Add an equation to a model
add_model
Add a new model to an ESM file
add_reaction
Add a reaction to a reaction system
add_reaction_system
Add a reaction system to an ESM file
add_species
Add a species to a reaction system
add_variable
Add a variable to a model
algebraic_unknowns
Unknowns constrained only implicitly (H*H*SO4 ~ Ksp).
apply_dae_contract
Run the RFC §12 DAE binding contract on esm in place and return the classification summary.
apply_scope_injections
esm-spec §9.7.10 forms A + B: fold any scope-directed injection — a subsystem-ref edge’s injected import list (form A) or a coupling entry’s injection map (form B) — into the target components’ own expression_template_imports, in place, so the ordinary import resolver + §9.6.3 fixpoint lower the target under the consumer-chosen discretization. Runs BEFORE resolve_template_machinery; form B target diagnostics (template_inject_target_*) surface here.
apply_value_invention
The combined front-door applied to a typed model: rewrite the derived index sets to their materialised dense extents and drop the value-invention equations. After this the existing resolver / array compiler handles the model with no value-invention-specific path.
brownian_parameters
Parameters whose update.kind is wiener — the SDE noise sources.
build_reference_graph
Resolve the reference edges of one model value into a graph, against the document-scoped index_sets registry.
build_reference_graph_with_index_setsDeprecated
Deprecated alias of build_reference_graph.
build_unit_env
Build a HashMap<String, Unit> environment from model variable metadata, together with a list of warnings for any variables whose declared unit string could not be parsed.
callbacks
The callbacks declared on prob (§2.5.4).
can_migrate
Whether migrate supports this version pair — i.e. whether to_version is among supported_migration_targets(from_version).
canonical_index_set_json
Canonical byte form of an index set (CONFORMANCE_SPEC.md §5.5.3): the distinct rows, each tuple serialised as a JSON array, in §5.5.1 sorted order, as compact JSON (, / : separators, no spaces, UTF-8, no \uXXXX escaping). Two conforming bindings MUST produce byte-for-byte identical output for the same input multiset.
canonical_json
Emit the canonical on-wire JSON form of an expression (§5.4.6).
canonicalize
Canonicalize an Expr tree per RFC §5.4. Returns a new tree; input is not mutated.
canonicalize_document
The document-level canonical step: every units string of a decoded document (the JSON value to_json writes and load_document reads) takes the canonical unit spelling (esm-spec §4.8.2, Lean Esm.Units.canon).
capture_coupling_diagnostics
Run f, collecting the WARNING-level coupling diagnostics it emits instead of printing them, and return them alongside its result.
check_assertion
The esm-spec §6.6.3 pass predicate — actual == expected, or both values FINITE and |a − e| ≤ max(atol, rtol·max(|a|, |e|)) — the same predicate the Julia / Python run_inline_tests use (see also CONFORMANCE_SPEC §5.20). This is Julia isapprox.
check_dimensional_consistency
Check dimensional consistency of an equation
check_equation_dimensions
Dimension-check an equation, returning EVERY finding.
check_expression_dimensions
Dimension-check a standalone expression (an observed variable’s defining expression), returning EVERY finding.
classify
Derive a node’s cadence class. For a leaf, seed it. For an operator node, class = max over child classes — which, for a gather index(A, e…), is max(class(A), class(e…)): the index expressions are classed independently of the array, so a stencil splits (§5.7.3 gather rule).
compile_array
Two-step entry point for array/spatial files: CONSUME the parsed EsmFile and compile it into the array runtime’s crate::simulate_array::ArrayCompiled, which the caller then solves with crate::simulate_array::ArrayCompiled::solve. The one-shot crate::problem::esm_problem borrows file and so keeps it alive for the whole build; for a large expanded discretization the typed file is on the order of the compiled rules themselves, and taking the file by value both lets it die before the solve AND lets the single-model build move the observed bodies into the compiled rules instead of deep-copying them (crate::simulate_array::ArrayCompiled::from_file_owned).
compile_kernels
Compile specs against prob’s (stripped) build (API_SPEC §5.8). The reserved name rhs, with no outputs, is the stripped right-hand side.
component_exists
Check if a component exists in the ESM file
component_graph
Build a component graph from an ESM file
compose
Concatenate two callback sets into a new one.
compute_fold
Compute a single CONST-folded buffer and return its canonical byte form. label is the buffer name (the default array key when spec.array is absent); spec is the golden’s per-buffer fold descriptor (fold kind + optional array); inputs is the CONST-fold input block (the document literals — the fixtures are value-free, so the values live in the manifest).
constant_parameters
Parameters with neither a distribution nor an update — plain constants.
contains
Check if an expression contains a specific variable
convert_units
Convert between compatible units
default_dae_support
Resolve the effective default for dae_support from the environment: ESM_DAE_SUPPORT=0 (or false/no/off) disables DAE support. Anything else (including unset) defaults to enabled.
deprecated_records_per_sample_sites
The JSON pointers at which the deprecated records_per_sample is written in file (esm-spec §8.5.1), sorted by plain byte order: /data_sources/<S>/temporal/records_per_sample, /models/<M>[/subsystems/<S>…]/variables/<v>/update[/<i>]/from/records_per_sample and /reaction_systems/<R>[/subsystems/<S>…]/parameters/<p>/update[/<i>]/from/records_per_sample (/<i> only for an array-form update). Loading a document for which this is non-empty warns once, deprecated_records_per_sample. Runs on every load, so a subsystem is scanned as raw JSON for the key, never decoded.
derive_odes
Generate ODE model from a reaction system
derive_output_gridding
Invert the flat state-element names into one VarGridding per output base-variable (RFC §7), the flat index of a name being its position in slot_names — the shape Solution::state_variable_names already has.
derive_output_meta
Distill a run document into OutputMeta — the Rust mirror of Julia’s derive_output_meta. Reads only the document (no build artifacts), so it composes with derive_output_gridding.
derive_output_plan
Derive the whole output plan for a run.
desugar_pushdown
Recognise the projection-pushdown pattern in esm’s named model and, when it matches, return a NEW document (Cow::Owned) with the four constructs desugared in (a kind:"derived" index set, a distinct:true overlap-gated producer aggregate, a member_factor const parameter, and an inspectable gated_select record) plus the reduction axis of the matched E / A / conc nodes re-pointed onto the generated derived set. Returns the input UNCHANGED (Cow::Borrowed) when no model is selected, the pattern does not match, or the reduction’s semiring is not the additive (+, 0) monoid (the soundness guard).
discrete_parameters
Parameters carrying any OTHER update — piecewise-constant between refreshes.
discretize
Top-level discretize() entry point per RFC §11/§12 for the rust binding.
distinct
Set semantics over rows: sort by the §5.5.1 total order, then drop adjacent duplicates (rule 2). The returned order is the sorted order — never first-seen / insertion order. A pure function of the input multiset, so duplicate, reversed, and permuted inputs all collapse to the identical output.
ephemeral_injected_file
esm-spec §9.7.10 form C: build a throwaway EsmFile in which component model_name has the test’s imports (raw §9.7.2 entries) appended to its own expression_template_imports, so the ordinary import resolver + §9.6.3 fixpoint lower its rewrite-targets under the test-chosen discretization. The persisted file is never mutated. When source_path is Some, the raw base is re-read from it (relative refs resolve against its directory); otherwise it is re-serialized from the loaded file (base_dir anchors the injected refs). This is what lets one test suite exercise a discretization-agnostic PDE leaf under several schemes with no conflict between tests. Mirrors the Julia reference (inline_tests.jl _ephemeral_injected_file).
equation_dimension_verdict
Classify one equation the way check_equation_dimensions judges it, and say WHY when it could not be judged.
error_code_names
Every diagnostic code string in ERROR_CODES, sorted. Handy for cross-binding vocabulary diffs and for asserting in a test that a raise site uses a registered code. Mirrors Julia’s error_code_names().
esm_problem
Build a EsmProblem (§2.5.2).
evaluate
Evaluate a scalar AST expression against a map of float variable bindings.
evaluate_cellwise
Evaluate an array-valued expression (elementwise ops over array-producing faq/makearray nodes — e.g. a grid-geometry template expanded by a §9.7 import, or a §6.6.5 analytic reference) at each 1-based integer cell of cells, returning one f64 per cell.
expand_coupling_imports
Expand every coupling_import entry in file.coupling into concrete edges, splicing them in the position of the import entry (esm-spec §10.10.3). Returns the effective coupling array, or None if the file has no coupling block. Non-import entries pass through untouched; a file with no coupling_import entries returns a clone of file.coupling verbatim.
expression_graph
Build an expression graph from various ESM components
expression_graph_with_options
Build an expression graph with explicit ExpressionGraphOptions.
expression_names
The variable names an expression or an equation uses, in order of first use: its string leaves under lhs, rhs and args. These are the names to give print_math to show an expression on its own, with its names declared.
field_reduce
Collapse a spatial field to the scalar a §6.6.5 reduce assertion compares (esm-spec §6.6.5); semantics identical to the Julia / Python references:
flatten
Flatten a coupled EsmFile into a single unified FlattenedSystem.
flatten_model
Flatten a single Model as a convenience wrapper around flatten.
flatten_with_options
Flatten with explicit CouplingImportOptions controlling how coupling_import refs resolve (esm-spec §10.10.3). When the file carries no coupling_import entry this is identical to flatten; otherwise the import entries are expanded into concrete edges — spliced in position — as a §4.7.5 sub-step before the coupling-rule step, and flattening proceeds over the expanded coupling sequence. The coupling_import source entry is not mutated on the caller’s file; the expansion operates on an internal clone.
forcing_from_sample
The buffer of slot built from one provider sample: the check and the conversion crate::esm_problem applies to a sample from a provider in ProblemOptions::providers, so a runtime that builds its own ForcingSets from provider samples gets, bit for bit, the buffer RhsProgram::default_forcing holds for the same sample (API_SPEC §5.8, “Forcing sets”).
format_canonical_float
Format a finite f64 per RFC §5.4.6.
free_parameters
Extract all free parameters from an expression
free_variables
Extract all free variables from an expression
get_component_type
Get the type of a component
get_supported_migration_targetsDeprecated
Deprecated alias of supported_migration_targets.
group_aggregate
Group-by + semiring aggregate (rule 5). Bucket rows by their Key (hashing only to bucket, via IndexMap), combine each group’s Num values with the semiring op (⊕), and emit (key, aggregate) pairs sorted by the canonical key.
group_gridding_by_grid
Partition output variables into GRIDS by their spatial-dim signature (RFC §9): variables over the same set of axes form one grid, so an atmosphere over [lev, lat, lon] and an ocean over [depth, lat, lon] split by construction. The signature is the SORTED SET of a variable’s dim_names, so axis order does not fragment a grid, and every scalar (empty signature) lands in one shared 0-D grid. Groups come back in first-seen signature order.
has_coupling_import
True when file carries at least one coupling_import entry in its coupling array.
init
Build a stepping integrator for prob (§2.5.6).
initial_state
The initial state prob integrates from, one value per state element, aligned with EsmProblem::state_variable_names.
is_coupling_library_doc
True when raw has the coupling-library-file FORM (top-level coupling_roles, esm-spec §10.9). Presence of that key is the sole positive identifier of the file kind; purity is checked separately at the import edge.
is_ode_state
Membership test for ode_states.
is_template_library_doc
True when raw has the template-library-file FORM (top-level expression_templates, esm-spec §9.7.1). Purity (no models / reaction systems / loaders / coupling / domain) is checked separately at import edges.
load_document
Load and parse an ESM document that is ALREADY parsed as a serde_json::Value — the same document a .esm file holds, just already decoded. Runs the identical pipeline load_string runs (subsystem-ref resolution, version gates, schema validation, §9.7 template machinery, typed deserialization).
load_document_with_options
load_document with explicit LoadOptions (base path for relative refs, loader-API metaparameter bindings; esm-spec §9.7.6).
load_path
Load an ESM file from a filesystem path.
load_path_with_options
Load an ESM file from a filesystem path, binding the root document’s open metaparameters at the loader API (esm-spec §9.7.6 binding site 4). The file’s own directory anchors relative subsystem and template-import refs.
load_string
Load and parse an ESM file from JSON string
load_string_with_options
Load and parse an ESM file from a JSON string with explicit LoadOptions (base path for relative refs, loader-API metaparameter bindings; esm-spec §9.7.6).
lower_enums
Lower every enum-op node in file to a {op: "const", value: <int>} node using the document’s top-level enums block, returning a NEW document. file is left untouched.
lower_enums_mut
lower_enums, applied in place. The _mut spelling API_SPEC.md §8 item 15 assigns to a mutating variant (Julia spells the same thing lower_enums!).
lower_enums_raw
Lower every enum-op node in value to a {op: "const", value: <int>} node using the file’s top-level enums block. Mutates value in place.
lower_reactions_to_equations
Lower a reaction network to an ODE equation list.
materialize_value_invention
Run the build-time value-invention engine over a raw model document.
migrate
Migrate an ESM file from the version it declares to target_version.
model_unit_env
The unit environment a model’s equations are checked against, as one map: its own declarations (build_unit_env) plus every scoped reference its expressions can make, with the precedence of [ComponentUnitEnv]. The parse failures returned are the model’s own.
observed_definition_json
An observed unknown’s defining RHS, read from a model held as RAW JSON.
observed_definitions
Each observed unknown’s defining RHS, keyed by name.
observed_field
The build-time field named name, from prob’s construction.
observed_trajectories
observed_trajectory for several names, in ONE pass over the output grid.
observed_trajectory
The trajectory of the observed variable name over sol’s output grid.
observed_unknowns
Unknowns defined by a bare-variable LHS (y ~ f(…)) — eliminable, materializable.
ode_states
Unknowns appearing under D(·, t) on some equation LHS.
parse_cell_key
Split a flat state-element name into (base, 1-based indices), or None when it is not a well-formed cell key (no bracket suffix, an empty base name, or a non-integer index). The exact inverse of the "{name}[{i},{j}]" formatting in simulate_array::compile::build_slot_tables, and the Rust twin of Julia’s _parse_cell_key / Python’s equivalent.
parse_document
Read an ESM document written in the given format.
parse_document_with_sources
Read an ESM document as parse_document does, with where each of its constructs is: one ConstructSource per pointer, in the order the text writes them. A construct that reads as several entries (a display holding several equations, a container of initialization equations or constraints, a table of declarations) gives one per entry, all with its span. Prose, front matter and anything else that is not a construct of the format gives none.
parse_markdown
Read a Markdown ESM document (Source.Md.parseMd). The result is in canonical form.
parse_math
Read one expression, or one equation, written as math under a set of declared names: LaTeX for DocumentFormat::Markdown (Math.parseLatex), Typst math for DocumentFormat::Typst (Math.parseTypst). The inverse of print_math: parse_math(&print_math(e, names, f), names, f) is e in canonical form.
parse_typst
Read a Typst ESM document (Source.Typ.parseTyp). See parse_markdown.
parse_unit
Parse a unit string into a Unit struct
partition_model
Run the cadence-partition pass over one model: classify every annotated node, derive the materialization frontier (both thresholds), check the guards (expect-cadence agreement, no CONTINUOUS relational, acyclic ≤DISCRETE graph), and report the three execution outputs’ emptiness. The model is the inner models.<name> object (use model_with_loaders to attach the document’s data_sources first when the model reads loader-seeded variables).
plan_dimension_coordinates
Resolve the coordinates registry (§8.3) into the CF dimension coordinates for a set of VarGriddings — the Rust mirror of Julia’s plan_dimension_coordinates.
print_document
Print an ESM document in the given format.
print_markdown
Print an ESM document as Markdown (Source.Md.printMd).
print_math
Print one expression, or one equation, as math under a set of declared names: LaTeX for DocumentFormat::Markdown (Math.printLatex), Typst math for DocumentFormat::Typst (Math.printTypst).
print_typst
Print an ESM document as Typst (Source.Typ.printTyp). See print_markdown.
pushdown_coupling_pairs
The (external name, model variable) routings of a raw document: which external field feeds which declared array.
pushdown_provider_gates
Provider-key ⇒ engine gate, derived from doc’s rewrite record (metadata.x_esd.pushdown.gated_select).
pushdown_record
The rewrite’s provenance record metadata.x_esd.pushdown (written by desugar_pushdown), or None when doc carries none. This is the record the engine reads BACK to derive provider gates.
reject_solver_external_pre_v13
Reject solver.external in a file declaring esm < 1.3.0.
reject_solver_pre_v11
Reject a top-level solver block in a file declaring esm < 1.1.0.
reject_solver_time_span_pre_v13
Reject solver.time_span in a file declaring esm < 1.3.0.
reject_template_imports_pre_v08
expression_template_imports, top-level expression_templates (template-library files), and metaparameters arrive at esm: 0.8.0; files declaring an earlier version that carry any of them are rejected with template_import_version_too_old (esm-spec §9.6.5). Mirrors [reject_expression_templates_pre_v04] for the §9.7 constructs.
remake
A NEW EsmProblem with changes applied and everything else shared (§2.5.5).
remove_coupling
Remove a coupling entry from an ESM file by index
remove_equation
Remove an equation from a model by index
remove_model
Remove a model from an ESM file
remove_reaction
Remove a reaction from a reaction system by index
remove_species
Remove a species from a reaction system
remove_variable
Remove a variable from a model
replace_coupling
Replace a coupling entry in an ESM file
replace_equation
Replace an equation in a model
resolve_references
Resolve reference edges for every model in document.
resolve_subsystem_refs
Resolve every subsystem { "ref": ... } in a TYPED document, in place.
resolve_subsystem_refs_raw
Resolve all subsystem references in a parsed JSON value representing an ESM file.
resolve_subsystem_refs_with_metaparameters
Like resolve_subsystem_refs_raw, but with the loader-API metaparameter bindings (esm-spec §9.7.6 site 4) available, so a §4.7 subsystem-edge binding EXPRESSION (NTGT = NX*NY, §9.7.6 site 3) folds against the root document’s closed metaparameter environment (defaults overlaid with the API bindings) at the mount. Mirrors the Python resolve_model_refs(..., parent_metaparameters=root_meta_env).
resolve_template_machinery
Resolve every esm-spec §9.7 construct of the ROOT document raw_data (relative import refs resolve against base_path): imports recursively with per-edge instantiation, index_sets merge, metaparameter close (metaparameters is the loader-API binding site 4; already-closed edge bindings win, then API bindings, then defaults) and fold, expression-position substitution, and — for a root library file — §9.7.3 body-reference validation.
resolve_time_span
The run interval, most specific first (esm-spec §2.2.7, by the §2.2.2 order):
resolve_tolerance
esm-spec §6.6.4, resolved PER FIELD over FOUR levels: assertion > test > model > the implementation default. Each of rel and abs independently takes its value from the innermost level that declares it; the default supplies rel = 1e-6 and no abs bound to whatever is still undeclared after the three document levels. Identical to the Julia _resolve_tolerance reference and the Python _resolve_tolerance. Returns (rtol, atol).
resolve_tolerances
Resolve integration tolerances most-specific first (esm-spec §2.2.2):
rhs_program
The right-hand side prob compiled, as a program RhsProgram::select, RhsProgram::halo, RhsProgram::tile and RhsProgram::lanes accept (API_SPEC §5.8). Its names are the flattened (dot-namespaced) names on every route; it writes every state.
run_inline_tests
Run every inline test (esm-spec §6.6, including the §6.6.5 PDE assertions) of the selected model(s) of file through the official simulation pathway (crate::problem::esm_problem / crate::problem::solve, the array runtime), and return one AssertionResult per assertion — carrying the ACTUAL reduction value alongside pass/fail, so conformance harnesses can record and cross-compare the numbers.
run_inline_tests_filtered
run_inline_tests_with_providers restricted to the tests whose id CONTAINS test_filter.
run_inline_tests_paths
Run the inline tests of every document in paths, asking options_for for each document’s options.
run_inline_tests_with_base_dir
run_inline_tests with an explicit base_dir anchoring from_file reference paths (esm-spec §6.6.5, pinned convention: relative to the .esm file’s directory). None resolves relative paths against the working directory — callers that loaded the document from a path should pass that path’s parent, matching the Julia / Python bindings’ default.
run_inline_tests_with_options
run_inline_tests_filtered driven by a whole InlineTestOptions — the entry a CALLER with one loaded document and a full set of knobs wants.
run_inline_tests_with_providers
run_inline_tests_with_base_dir with the document’s data_sources actually INGESTED (esm-spec §8.9).
sampled_parameters
Parameters with a distribution and no update — drawn once at setup.
serialize_keys
Serialise an already-distinct, already-sorted slice of keys to the canonical compact-JSON index-set form (no further dedup/sort).
serialize_pairs
Serialise the (key, aggregate) output of group_aggregate to the canonical compact-JSON form, each pair as a two-element array [key, value].
simplify
Simplify an expression (basic symbolic simplification).
solve
Run prob to completion (§2.5.3).
solve_ensemble
Solve every trajectory of ens, in index order (§2.5.8).
solve_to_completion
Run integrator to completion (§2.5.6’s solve!).
solver_external_location
Where the document’s solver.external points (esm-spec §2.2.6), or Ok(None) when the document names no run configuration.
state_cells
Collect the (cell-index-tuple, row) pairs of one array state from the simulation’s element names (element_names[row] is the name of state row row, e.g. "Heat.u[3]"). Flattening prefixes element names with the owning model, and a coupled build may reuse the same bare array name across components (M1.u, M2.u); to avoid mixing every model’s cells into one field, the model-qualified stem wins — an exact model.variable / bare-variable stem match first, then a bare-suffix fallback reached only when no exact stem exists (a bare-keyed single-model build). This is the array analog of [scalar_slot]’s qualified-first two-pass resolution. Sorted by cell tuple so callers get a deterministic pairing.
step
Advance integrator by one grid point (§2.5.6’s step!).
stoichiometric_matrix
Generate stoichiometric matrix from a reaction system
stripped
What ProblemOptions::strip removed from prob, flattened and namespaced (API_SPEC §5.8, “The stripped object”). Empty when nothing was.
substitute
Substitute variables in an expression, returning a new expression.
substitute_in_model
Substitute variables in all expressions within a model (equations plus discrete/continuous events; other model fields are cloned unchanged).
substitute_in_model_with_context
substitute_in_model with scoped reference resolution.
substitute_in_reaction_system
Substitute variables in all reaction-rate expressions within a reaction system.
substitute_in_reaction_system_with_context
substitute_in_reaction_system with scoped reference resolution.
substitute_with_context
Substitute variables in an expression with scoped reference resolution (esm-spec §2.3.3).
supported_migration_targets
The schema versions from_version can be migrated to.
system_kind
The DERIVED system kind (esm-spec §6.3.1), which a binding uses when the system_kind field is absent and checks against when it is present.
time_origin
The time origin in seconds from the POSIX epoch (esm-spec §2.2.7): domain.temporal.reference_time, else domain.temporal.start, else the epoch itself, as W0 + f0 – whole seconds converted, the fraction added in binary64.
timestamp_to_seconds
timestamp as seconds from source’s time origin (esm-spec §2.2.7).
to_dot
Render graph as Graphviz DOT (esm-libraries-spec §4.8.3).
to_json
Serialize an ESM file to JSON string
to_json_compact
Serialize an ESM file to compact JSON string (no pretty printing)
to_json_graph
Render graph as a JSON adjacency-list document (esm-libraries-spec §4.8.3). Named to_json_graph, not to_json, because to_json is the DOCUMENT serializer (API_SPEC.md §8 item 2). See to_dot.
to_mermaid
Render graph as Mermaid (esm-libraries-spec §4.8.3). See to_dot.
update_model_metadata
Update model metadata
validate
Perform structural validation on an ESM file
validate_completeDeprecated
Deprecated alias of validate_text.
validate_equation_dimensions
Validate that an equation’s LHS and RHS have matching dimensions.
validate_text
Validate an ESM file completely (schema + structural validation)
write_path
Write an ESM file to path as pretty-printed JSON.

Type Aliases§

BuildProviderFactory
The build-time data providers one inline-test BUILD consumes, produced on demand.
CadenceError
A cadence-partition contract violation in a fixture or producer output (a wrong expect_cadence, a CONTINUOUS relational node, a from_faq cycle, a float topology key, or a malformed node).
CallbackFn
One callback. See the wasm32 twin for the documentation.
CompileDeprecated
The former spelling of Rhs, kept for one minor (API_SPEC §8 item 22).
CovarianceMatrix
Symmetric positive-semidefinite covariance matrix, row-major: entry [i][j] is the covariance of components i and j.
EnumLoweringError
Stable diagnostic codes raised by the enum-lowering pass. Mirrors the codes emitted by the TS / Python / Julia / Go bindings.
PrepareProgressFn
A build progress observer. See crate::problem::ProblemOptions::progress.
ProgressFn
A progress observer. See SolveOptions::progress.
ReferenceErrorDeprecated
Deprecated alias of ReferenceResolutionError.