Go extension seams

Go's extension-tier names: documented, reachable, not portable.

Extension-tier names are part of this binding’s documented surface but are not harmonized across bindings, and may change in a minor release (API_SPEC.md §7 ).

277 names.

`Analysis`

type · canonical name analysis

type Analysis struct {
	ID             string             `json:"id"`
	Description    *string            `json:"description,omitempty"`
	InitialState   map[string]float64 `json:"initial_state,omitempty"`
	Parameters     map[string]float64 `json:"parameters,omitempty"`
	TimeSpan       TimeSpan           `json:"time_span"`
	ParameterSweep *ParameterSweep    `json:"parameter_sweep,omitempty"`
	Plots          []Plot             `json:"plots,omitempty"`
	// ExpressionTemplateImports are raw §9.7.2 import entries injected into the
	// ENCLOSING component's template scope for THIS analysis's run only (esm-spec
	// §9.7.10 form C / §6.7). Authored per-run config (a peer of Parameters), so
	// it DOES survive parse → emit; consumed only by an ephemeral per-run build,
	// which this binding does not perform.
	ExpressionTemplateImports []any `json:"expression_template_imports,omitempty"`
}

Analysis is an inline illustrative analysis of how to run a component.

Source · Go docs

`Assertion`

type · canonical name assertion

type Assertion struct {
	Variable  string     `json:"variable"`
	Time      float64    `json:"time"`
	Expected  float64    `json:"expected"`
	Tolerance *Tolerance `json:"tolerance,omitempty"`
	// Coords pins a spatial-point evaluation: index-set/dimension name → numeric
	// coordinate. Mutually exclusive with Reduce (esm-spec §6.6.5).
	Coords map[string]float64 `json:"coords,omitempty"`
	// Reduce collapses the spatial field to a scalar before comparison
	// ("integral"/"mean"/"max"/"min"/"L2_error"/"Linf_error"; esm-spec §6.6.5).
	Reduce string `json:"reduce,omitempty"`
	// Reference is the analytic/precomputed solution required by error-norm
	// reductions: an inline Expression or a from_file shape (esm-spec §6.6.5).
	Reference any `json:"reference,omitempty"`
}

Assertion is a single scalar (variable, time, expected) check inside a Test. PDE-aware variants pin a spatial point via coords or reduce the field to a scalar via reduce (esm-spec §6.6.5); coords and reduce are mutually exclusive. Error-norm reductions require a reference solution. These extra fields round-trip verbatim; this binding does not evaluate them.

Source · Go docs

`BuildReferenceGraphFromModel`

function · canonical name build_reference_graph_from_model

func BuildReferenceGraphFromModel(model *Model, modelName string, indexSets map[string]IndexSet) (*ReferenceGraph, error)

BuildReferenceGraphFromModel is the typed convenience over BuildReferenceGraph: it renders model and the document’s index_sets registry to their raw views and resolves against those.

Source · Go docs

`CadenceClassifier`

type · canonical name cadence_classifier

type CadenceClassifier struct {
	// contains filtered or unexported fields
}

func (c *CadenceClassifier) CheckExpectCadence() []error

func (c *CadenceClassifier) CheckNoContinuousRelational() []error

func (c *CadenceClassifier) Classify(expr Expression) (Cadence, error)

func (c *CadenceClassifier) LeafSeeds() (map[string]Cadence, error)

func (c *CadenceClassifier) SeedLeaf(leaf Expression) (Cadence, error)

CadenceClassifier derives cadence classes for one model. Build it with NewCadenceClassifier; it memoises observed-leaf resolution, so reuse one instance across a model’s equations rather than rebuilding it per node.

Methods

func (c *CadenceClassifier) CheckExpectCadence() []error

CheckExpectCadence walks every equation of the model and asserts that wherever a node carries an expect_cadence annotation the derived class agrees (CONFORMANCE_SPEC §5.7.6 guard 3). The annotation is a checked assertion, not a control input: it changes no semantics, and a disagreement is a defect.

func (c *CadenceClassifier) CheckNoContinuousRelational() []error

CheckNoContinuousRelational is §5.7.6 guard 2: a distinct/join/skolem/rank/argmin/argmax node (or a distinct aggregate) that classifies CONTINUOUS is rejected — state-dependent topology may not run per step in v1.

func (c *CadenceClassifier) Classify(expr Expression) (Cadence, error)

Classify derives an expression’s cadence class: for a leaf, its seed; for an operator node, the join over its children (§5.7.3). For a gather index(A, e…) the index expressions are classed independently of the array, which is simply what “join over children” already does — no special case is needed, and the stencil split falls out of it.

func (c *CadenceClassifier) LeafSeeds() (map[string]Cadence, error)

LeafSeeds returns the derived seed of every declared variable of the model, keyed by name — the observable form of the §5.7.2 table, useful for diagnostics and for a conformance adapter.

func (c *CadenceClassifier) SeedLeaf(leaf Expression) (Cadence, error)

SeedLeaf derives a leaf’s cadence from its ROLE, per the §5.7.2 seed table.

Source · Go docs

`CadenceConst`

constant · canonical name cadence_const

const CadenceConst Cadence = iota

CadenceConst never changes: evaluated once and folded into the artifact.

Source · Go docs

`CadenceContinuous`

constant · canonical name cadence_continuous

const CadenceContinuous

CadenceContinuous changes every step: evaluated on every RHS call.

Source · Go docs

`CadenceDiscrete`

constant · canonical name cadence_discrete

const CadenceDiscrete

CadenceDiscrete changes only at discrete events, and is piecewise-constant between them: evaluated at setup and on each refresh, memoized between.

Source · Go docs

`CallbackCoupling`

type · canonical name callback_coupling

type CallbackCoupling struct {
	Type        string         `json:"type"` // "callback"
	CallbackID  string         `json:"callback_id"`
	Config      map[string]any `json:"config,omitempty"`
	Description *string        `json:"description,omitempty"`
}

func (c CallbackCoupling) CouplingType() string

CallbackCoupling represents callback-based coupling

Methods

func (c CallbackCoupling) CouplingType() string

Source · Go docs

`CodeAmbiguousOutputName`

constant · canonical name code_ambiguous_output_name

const CodeAmbiguousOutputName = "ambiguous_output_name"

CodeAmbiguousOutputName: an output name that matches no variable exactly and whose last dotted segment is shared by more than one variable (CONFORMANCE_SPEC §5.17.4). This binding has no output derivation; the constant exists because the code vocabulary is uniform across bindings.

— Diagnostic codes: §9.6 expression templates — declaration, application and body expansion (raised via newETErr from lower_expression_templates.go, out_of_line_templates.go and template_compose.go). —

Source · Go docs

`CodeAmbiguousSubsystemRef`

constant · canonical name code_ambiguous_subsystem_ref

const CodeAmbiguousSubsystemRef = "ambiguous_subsystem_ref"

CodeAmbiguousSubsystemRef: a subsystem ref resolves to a file holding other than exactly one top-level system; §4.7 requires exactly one.

— Diagnostic codes: §4.7 subsystem refs. Shared with the structural validator, which reports the same two conditions for a document whose refs were never resolved (tests/invalid/subsystem_ref_not_found.esm, subsystem_ref_ambiguous.esm; the names are pinned by tests/invalid/expected_errors.json). —

Source · Go docs

`CodeApplyExpressionTemplateBindingsMismatch`

constant · canonical name code_apply_expression_template_bindings_mismatch

const CodeApplyExpressionTemplateBindingsMismatch = "apply_expression_template_bindings_mismatch"

CodeApplyExpressionTemplateBindingsMismatch: the supplied bindings do not match the template’s declared parameters — a missing parameter, or a binding naming a parameter the template does not declare.

Source · Go docs

`CodeApplyExpressionTemplateInvalidDeclaration`

constant · canonical name code_apply_expression_template_invalid_declaration

const CodeApplyExpressionTemplateInvalidDeclaration = "apply_expression_template_invalid_declaration"

CodeApplyExpressionTemplateInvalidDeclaration: an apply_expression_template node is structurally malformed — a missing or non-string template, a bindings payload that is not an object, or a binding entry whose key is not a non-empty string.

Source · Go docs

`CodeApplyExpressionTemplateRecursiveBody`

constant · canonical name code_apply_expression_template_recursive_body

const CodeApplyExpressionTemplateRecursiveBody = "apply_expression_template_recursive_body"

CodeApplyExpressionTemplateRecursiveBody: a template’s body applies the template itself, directly or through a cycle of applications.

Source · Go docs

`CodeApplyExpressionTemplateUnknownTemplate`

constant · canonical name code_apply_expression_template_unknown_template

const CodeApplyExpressionTemplateUnknownTemplate = "apply_expression_template_unknown_template"

CodeApplyExpressionTemplateUnknownTemplate: an apply_expression_template names a template neither declared locally nor exported by any import in scope.

Source · Go docs

`CodeApplyExpressionTemplateVersionTooOld`

constant · canonical name code_apply_expression_template_version_too_old

const CodeApplyExpressionTemplateVersionTooOld = "apply_expression_template_version_too_old"

CodeApplyExpressionTemplateVersionTooOld: a file declaring esm < 0.4.0 carries expression_templates or apply_expression_template.

Source · Go docs

`CodeArrayShapeMismatch`

constant · canonical name code_array_shape_mismatch

const CodeArrayShapeMismatch = "array_shape_mismatch"

CodeArrayShapeMismatch: an operand of a bare array-level expression carries a declared index set that the expression’s result is not shaped over, so there is no axis to align it to (esm-spec §4.3.4, §9.6.6; CONFORMANCE_SPEC §7.1).

Source · Go docs

`CodeCadenceContinuousRelational`

constant · canonical name code_cadence_continuous_relational

const CodeCadenceContinuousRelational = "cadence_continuous_relational"

Cadence-partition diagnostic codes.

Source · Go docs

`CodeCadenceExpectMismatch`

constant · canonical name code_cadence_expect_mismatch

const CodeCadenceExpectMismatch = "cadence_expect_mismatch"

Cadence-partition diagnostic codes.

Source · Go docs

`CodeCadenceObservedCycle`

constant · canonical name code_cadence_observed_cycle

const CodeCadenceObservedCycle = "cadence_observed_cycle"

CodeCadenceObservedCycle is the CADENCE-pass sighting of the same defect esm-spec §4.9.6 gives the structural validator: a dependency cycle among a model’s observed definitions, with the §4.3.1.1 recurrence self-edge exempted on candidacy. It is a *CadenceError raised while classifying, so Validate never sees it; the validator-track counterpart is validate_observed_cycle.go’s observed_cycle, which is what tests/invalid/expected_errors.json pins. Keep the two in step — in particular the self-edge gate, which both take from recurrenceCandidateVars.

Cadence-partition diagnostic codes.

Source · Go docs

`CodeCallbackUnregistered`

constant · canonical name code_callback_unregistered

const CodeCallbackUnregistered = "callback_unregistered"

CodeCallbackUnregistered: an equation reads a callback coupling variable and no callback supplies it at construction (esm-spec §9.6.6). Go does not simulate, so it never raises this.

— Diagnostic codes: expression EVALUATION (EvaluationError, raised from expression.go). unlowered_operator is a cross-binding wire code — Julia and TypeScript emit exactly this string — so it belongs in the registry rather than at the call site. —

Source · Go docs

`CodeClosedFunctionArity`

constant · canonical name code_closed_function_arity

const CodeClosedFunctionArity = "closed_function_arity"

CodeClosedFunctionArity: a closed function received the wrong number or kind of arguments, or an empty table.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeClosedFunctionOverflow`

constant · canonical name code_closed_function_overflow

const CodeClosedFunctionOverflow = "closed_function_overflow"

CodeClosedFunctionOverflow: an integer-valued result overflows Int32.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeCompilerRefusedRule`

constant · canonical name code_compiler_refused_rule

const CodeCompilerRefusedRule = "compiler_refused_rule"

CodeCompilerRefusedRule: the chosen compiler cannot run this document. Raised at build, naming the compiler, the rule (an equation or an observed, component-qualified) and the reason.

Source · Go docs

`CodeCompilerUnavailable`

constant · canonical name code_compiler_unavailable

const CodeCompilerUnavailable = "compiler_unavailable"

CodeCompilerUnavailable: the named compiler is in the vocabulary, but this binding, build or process cannot provide it; the message names what to load or build. Never answered by running a different compiler (esm-libraries-spec §2.5.10).

Source · Go docs

`CodeCompilerUnknown`

constant · canonical name code_compiler_unknown

const CodeCompilerUnknown = "compiler_unknown"

CodeCompilerUnknown: esm_problem’s compiler option named a value outside the closed vocabulary of API_SPEC §5.8 (interpreter, native, xla, mtk, sympy).

Source · Go docs

`CodeConstUnitsVersionTooOld`

constant · canonical name code_const_units_version_too_old

const CodeConstUnitsVersionTooOld = "const_units_version_too_old"

CodeConstUnitsVersionTooOld: a document declaring esm < 1.2.0 carries units on an expression node.

— Diagnostic codes: §4.8.5 declared units on a const node (raised via newETErr from units.go). —

Source · Go docs

`CodeCoupleMultiplicativeNoTendency`

constant · canonical name code_couple_multiplicative_no_tendency

const CodeCoupleMultiplicativeNoTendency = "couple_multiplicative_no_tendency"

CodeCoupleMultiplicativeNoTendency: a couple connector equation applies the multiplicative transform to a to target that has no D(to) equation in the flattened system — a parameter, an observed, an algebraic unknown, or an undefined name. Both esm-spec §10.3 and §4.7.2 define multiplicative against the target’s EXISTING ODE right-hand side, so there is nothing to multiply and the operation has no meaning. Silently dropping the connector equation — what this binding did before — is the one outcome a coupling mis-specification must not have: the document declares a coupling and the flattened system carries no trace of it.

additive deliberately has NO counterpart code: zero is the additive identity, so an additive term against an absent tendency simply becomes the tendency. There is no multiplicative identity that would do the same.

— Diagnostic codes: §10.3 / esm-libraries-spec §4.7.2 couple connector semantics (raised from flatten.go’s applyCouple). —

Source · Go docs

`CodeCouplingEdgeUnknownRole`

constant · canonical name code_coupling_edge_unknown_role

const CodeCouplingEdgeUnknownRole = "coupling_edge_unknown_role"

CodeCouplingEdgeUnknownRole: a coupling edge inside the library references a role name the library does not declare.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingImportBindNotAComponent`

constant · canonical name code_coupling_import_bind_not_a_component

const CodeCouplingImportBindNotAComponent = "coupling_import_bind_not_a_component"

CodeCouplingImportBindNotAComponent: a role binding names something that is not a component of the importing document.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingImportNotLibrary`

constant · canonical name code_coupling_import_not_library

const CodeCouplingImportNotLibrary = "coupling_import_not_library"

CodeCouplingImportNotLibrary: a coupling_import resolves to a file that is not a coupling library.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingImportRoleUnbound`

constant · canonical name code_coupling_import_role_unbound

const CodeCouplingImportRoleUnbound = "coupling_import_role_unbound"

CodeCouplingImportRoleUnbound: a role the imported library declares is left unbound by the importing document.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingImportUnknownRole`

constant · canonical name code_coupling_import_unknown_role

const CodeCouplingImportUnknownRole = "coupling_import_unknown_role"

CodeCouplingImportUnknownRole: a coupling_import binds a role the imported library does not declare.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingImportUnresolved`

constant · canonical name code_coupling_import_unresolved

const CodeCouplingImportUnresolved = "coupling_import_unresolved"

CodeCouplingImportUnresolved: a coupling_import names a file that does not exist, is not readable, or was never resolved before use.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingLibraryIllegalPayload`

constant · canonical name code_coupling_library_illegal_payload

const CodeCouplingLibraryIllegalPayload = "coupling_library_illegal_payload"

CodeCouplingLibraryIllegalPayload: a coupling library file carries a payload §10.11 forbids there (a component, a non-coupling_roles block, or a role entry of the wrong shape).

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingLibraryNestedImport`

constant · canonical name code_coupling_library_nested_import

const CodeCouplingLibraryNestedImport = "coupling_library_nested_import"

CodeCouplingLibraryNestedImport: a coupling library itself declares a coupling import; §10.11 admits no nesting.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeCouplingRoleUnused`

constant · canonical name code_coupling_role_unused

const CodeCouplingRoleUnused = "coupling_role_unused"

CodeCouplingRoleUnused: a role the library declares is referenced by none of its coupling edges, so binding it could have no effect.

— Diagnostic codes: §10.9-§10.11 coupling libraries / coupling_import (raised via newETErr from coupling_imports.go). —

Source · Go docs

`CodeDataSourceUnbound`

constant · canonical name code_data_source_unbound

const CodeDataSourceUnbound = "data_source_unbound"

CodeDataSourceUnbound: a data-fed parameter (an update of kind: "data", esm-spec §5.4/§8.5) reached a build with nothing bound to it – no provider, no loaded array, no caller-supplied p value (esm-spec §9.6.6, CONFORMANCE_SPEC §5.46). The complement of ErrorDataSourceUndefined, which this binding DOES raise: that is the validator’s finding about a source name resolving to nothing, this is the build’s finding about a source that resolves and that nothing supplied data for. Go does not simulate, so nothing here raises it; the constant keeps the §9.6.6 vocabulary uniform.

Source · Go docs

`CodeDerivedIndexSetUnmaterialized`

constant · canonical name code_derived_index_set_unmaterialized

const CodeDerivedIndexSetUnmaterialized = "derived_index_set_unmaterialized"

CodeDerivedIndexSetUnmaterialized: an expression ranges over a kind: "derived" index set whose producer could not be materialized at build (esm-spec §9.6.6). Registered for the cross-binding vocabulary; this binding has no simulator, so nothing here raises it.

Source · Go docs

`CodeDomainUnitMismatch`

constant · canonical name code_domain_unit_mismatch

const CodeDomainUnitMismatch = "domain_unit_mismatch"

CodeDomainUnitMismatch: an identity-transform variable_map coupling whose from and to variables carry declared, non-empty, and DIFFERENT units (esm-spec §4.7.6). Mirrors the flatten-time DomainUnitMismatch the evaluating bindings raise (Julia _check_variable_map_units, Python _check_variable_map_units, Rust FlattenError::DomainUnitMismatch).

validate_static_checks.go holds static-validation checks for defects that are decidable from the SINGLE document (no evaluator, no solver, no other file). Their pinned (code, path) tuples live in tests/invalid/expected_errors.json, and these checks make Go’s Validate reject each with exactly that pin:

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeDuplicateReactionSpecies`

constant · canonical name code_duplicate_reaction_species

const CodeDuplicateReactionSpecies = "duplicate_reaction_species"

CodeDuplicateReactionSpecies is a warning-level code: a species appears more than once in a reaction’s substrate/product list. Advisory only — it does not invalidate the document.

— Diagnostic codes: structural validation, peers of the Error* block above. —

Source · Go docs

`CodeEditEntityNotFound`

constant · canonical name code_edit_entity_not_found

const CodeEditEntityNotFound = "entity_not_found"

CodeEditEntityNotFound: an edit names a variable, equation, reaction, species, event, coupling entry, or component that does not exist.

Source · Go docs

`CodeEditInvalidOperation`

constant · canonical name code_edit_invalid_operation

const CodeEditInvalidOperation = "invalid_operation"

CodeEditInvalidOperation: an edit is refused for a reason other than the two above (e.g. it would empty a collection the schema requires to be non-empty).

Source · Go docs

`CodeEditVariableInUse`

constant · canonical name code_edit_variable_in_use

const CodeEditVariableInUse = "variable_in_use"

CodeEditVariableInUse: a removal would strand a live reference to the removed name.

Source · Go docs

`CodeElementTypeUncarried`

constant · canonical name code_element_type_uncarried

const CodeElementTypeUncarried = "element_type_uncarried"

CodeElementTypeUncarried: a declared working precision reaches a construct that cannot carry it (esm-spec §4.7 “Working precision crosses a mount”, §11.3.1) — a mounted leaf’s domain.element_type that must be written onto a reaction system, whose species and parameters have no per-variable element_type.

Source · Go docs

`CodeGeometryManifoldInvalid`

constant · canonical name code_geometry_manifold_invalid

const CodeGeometryManifoldInvalid = "geometry_manifold_invalid"

CodeGeometryManifoldInvalid: a geometry kernel declares a manifold that is not one of the spec’s manifold kinds, or one inconsistent with the coordinates it is given.

Source · Go docs

`CodeIndexedDefinitionUnsupportedForm`

constant · canonical name code_indexed_definition_unsupported_form

const CodeIndexedDefinitionUnsupportedForm = "indexed_definition_unsupported_form"

CodeIndexedDefinitionUnsupportedForm: a bare-index observed definition index(V, k…) ~ rhs outside the runnable form (the RHS is not a faq whose output_idx names the subscripts in order), refused when a simulating binding builds the model. Go does not simulate, so it never raises this; the constant exists because the code table is cross-language uniform.

— Diagnostic codes: running an arrayed definition (esm-spec §6.3.1). —

Source · Go docs

`CodeInterpAxisLengthMismatch`

constant · canonical name code_interp_axis_length_mismatch

const CodeInterpAxisLengthMismatch = "interp_axis_length_mismatch"

CodeInterpAxisLengthMismatch: an interp axis length does not match the table’s.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeInterpAxisTooShort`

constant · canonical name code_interp_axis_too_short

const CodeInterpAxisTooShort = "interp_axis_too_short"

CodeInterpAxisTooShort: an interp axis has fewer than two points.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeInterpNaNInAxis`

constant · canonical name code_interp_na_n_in_axis

const CodeInterpNaNInAxis = "interp_nan_in_axis"

CodeInterpNaNInAxis: an interp axis contains a NaN.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeInterpNonMonotonicAxis`

constant · canonical name code_interp_non_monotonic_axis

const CodeInterpNonMonotonicAxis = "interp_non_monotonic_axis"

CodeInterpNonMonotonicAxis: an interp axis is not strictly increasing.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeInvalidBroadcastFn`

constant · canonical name code_invalid_broadcast_fn

const CodeInvalidBroadcastFn = "invalid_broadcast_fn"

CodeInvalidBroadcastFn: a broadcast node’s fn is absent, does not name a scalar operator, or is applied to an argument count that operator’s §4.2 arity does not admit (esm-spec §4.3.4, §9.6.6). The value analogue of unknown_closed_function: broadcast is the one op whose OPERATOR is carried as data, so no op-keyed check reaches it, and an unchecked fn was discarded silently rather than failing.

Source · Go docs

`CodeInvalidEnumArg`

constant · canonical name code_invalid_enum_arg

const CodeInvalidEnumArg = "invalid_enum_arg"

CodeInvalidEnumArg: an enum node argument is not a string.

— Diagnostic codes: §9.3 enum lowering (raised via newEnumLoweringError from lower_enums.go). —

Source · Go docs

`CodeInvalidEnumArity`

constant · canonical name code_invalid_enum_arity

const CodeInvalidEnumArity = "invalid_enum_arity"

CodeInvalidEnumArity: an enum node does not carry exactly two arguments.

— Diagnostic codes: §9.3 enum lowering (raised via newEnumLoweringError from lower_enums.go). —

Source · Go docs

`CodeJoinKeyInvalidType`

constant · canonical name code_join_key_invalid_type

const CodeJoinKeyInvalidType = "join_key_invalid_type"

CodeJoinKeyInvalidType: a value-equality join key column draws from a categorical index set whose members contain a float (not portably equality-comparable across bindings) or a null (unmatchable as a key). RFC semiring-faq-unified-ir §5.3 / §5.7 rule 1; CONFORMANCE_SPEC §5.5.1.

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeJoinSideAmbiguous`

constant · canonical name code_join_side_ambiguous

const CodeJoinSideAmbiguous = "join_side_ambiguous"

CodeJoinSideAmbiguous: an on key for which the DOCUMENT does not determine a range symbol – its index set is drawn by more than one of the node’s ranges and the clause names no syms (CONFORMANCE_SPEC §5.5.8).

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeJoinSymsUnknownSymbol`

constant · canonical name code_join_syms_unknown_symbol

const CodeJoinSymsUnknownSymbol = "join_syms_unknown_symbol"

CodeJoinSymsUnknownSymbol: a join.syms entry that is not a range symbol of the node (CONFORMANCE_SPEC §5.5.8).

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeMakearrayRegionInverted`

constant · canonical name code_makearray_region_inverted

const CodeMakearrayRegionInverted = "makearray_region_inverted"

CodeMakearrayRegionInverted: a makearray region’s stop precedes its start, so the region denotes no cells (esm-spec §4.3.5).

Source · Go docs

`CodeMetaparamNameConflict`

constant · canonical name code_metaparam_name_conflict

const CodeMetaparamNameConflict = "metaparameter_name_conflict"

CodeMetaparamNameConflict: a metaparameter name collides with a name already bound in the scope the template expands into (esm-spec §9.6.6).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeMetaparamTypeError`

constant · canonical name code_metaparam_type_error

const CodeMetaparamTypeError = "metaparameter_type_error"

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeMetaparamUnbound`

constant · canonical name code_metaparam_unbound

const CodeMetaparamUnbound = "metaparameter_unbound"

CodeMetaparamUnbound: a metaparameter reachable in an expanded template body has no binding — neither from the metaparameters block nor from an import’s rebind (esm-spec §9.6.6).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeMissingDataSourceKind`

constant · canonical name code_missing_data_source_kind

const CodeMissingDataSourceKind = "missing_data_source_kind"

A data source entry requires kind and source.url_template. A source declares no variables; the file variable and units are checked on the consuming PARAMETER instead – by the schema, since both are required there.

— Diagnostic codes: structural validation, peers of the Error* block above. —

Source · Go docs

`CodeMissingDataSourceURLTemplate`

constant · canonical name code_missing_data_source_url_template

const CodeMissingDataSourceURLTemplate = "missing_data_source_url_template"

— Diagnostic codes: structural validation, peers of the Error* block above. —

Source · Go docs

`CodeMountFormUnsupported`

constant · canonical name code_mount_form_unsupported

const CodeMountFormUnsupported = "mount_form_unsupported"

CodeMountFormUnsupported: a §4.7 {ref} mount at a form this binding does not implement — here, a top-level reaction_systems.<k> {ref} (esm-spec §4.7 “Two mount forms, one mechanism”). Refused at load, pointing at the entry, rather than decoded as an empty reaction system.

Source · Go docs

`CodeOperatorComposeAmbiguousBareName`

constant · canonical name code_operator_compose_ambiguous_bare_name

const CodeOperatorComposeAmbiguousBareName = "operator_compose_ambiguous_bare_name"

CodeOperatorComposeAmbiguousBareName: the bare-name fallback (§4.7.1 step 3) would unify two STATE variables. Each carries its own INITIAL CONDITION and the merge keeps only one, so the choice decides what the flattened system integrates from — and the document, which bound them on a shared local name alone, has not expressed it. Deciding it silently is how flipping an entry’s systems order came to change the answer. A match where only ONE side is a state is not ambiguous: the state owns it.

— Diagnostic codes: §10.3 / esm-libraries-spec §4.7.2 couple connector semantics (raised from flatten.go’s applyCouple). —

Source · Go docs

`CodeOperatorComposeNoMerge`

constant · canonical name code_operator_compose_no_merge

const CodeOperatorComposeNoMerge = "operator_compose_no_merge"

CodeOperatorComposeNoMerge is an ERROR (esm-libraries-spec §4.7.1 step 5): an operator_compose entry merged NONE of the equations Systems

\[1\]

authored, which makes it indistinguishable from an entry that is not there — the operator integrates a private decoupled system from its own defaults, the other system receives no contribution, and the only evidence is a state count one too high. An operator that genuinely contributes only states of its own declares that with require_match: false and is then permitted.

— Diagnostic codes: §10.3 / esm-libraries-spec §4.7.2 couple connector semantics (raised from flatten.go’s applyCouple). —

Source · Go docs

`CodeOperatorComposePartialMerge`

constant · canonical name code_operator_compose_partial_merge

const CodeOperatorComposePartialMerge = "operator_compose_partial_merge"

CodeOperatorComposePartialMerge is WARNING-level: some but not all of Systems

\[1\]

’s equations landed. Unlike a zero merge this is indistinguishable from an operator that legitimately contributes states of its own ALONGSIDE the ones it does merge, so the format cannot call it a defect; an author who knows better says so with require_match.

— Diagnostic codes: §10.3 / esm-libraries-spec §4.7.2 couple connector semantics (raised from flatten.go’s applyCouple). —

Source · Go docs

`CodeOperatorComposeRequireMatchUnmatched`

constant · canonical name code_operator_compose_require_match_unmatched

const CodeOperatorComposeRequireMatchUnmatched = "operator_compose_require_match_unmatched"

CodeOperatorComposeRequireMatchUnmatched: an operator_compose entry declared require_match: true and one of Systems

\[1\]

’s equations found no equation of Systems

\[0\]

to land on (esm-libraries-spec §4.7.1 step 5). A PARTIAL match fails too: there is no “some is enough” reading an author could rely on — the seven-of-twelve-species case is exactly the defect the flag exists to catch. Refused at FLATTEN, not at validate: the document is schema-valid and structurally valid, and only the merge knows the answer.

— Diagnostic codes: §10.3 / esm-libraries-spec §4.7.2 couple connector semantics (raised from flatten.go’s applyCouple). —

Source · Go docs

`CodeRaggedValuesNotGathered`

constant · canonical name code_ragged_values_not_gathered

const CodeRaggedValuesNotGathered = "ragged_values_not_gathered"

CodeRaggedValuesNotGathered: a faq that is not a value-invention node ranges over a kind: "ragged" index set, but its body never reads that set’s values array. The range binds the POSITION k in 1..offsets

\[parent\]

, not a member, so the body reads positions where the author meant members (esm-spec §4.3.1 “Ragged ranges”).

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeRangeBoxInvalid`

constant · canonical name code_range_box_invalid

const CodeRangeBoxInvalid = "range_box_invalid"

CodeRangeBoxInvalid: a malformed decomposition, tile box or lane-set list.

Source · Go docs

`CodeRangeGlobalLocality`

constant · canonical name code_range_global_locality

const CodeRangeGlobalLocality = "range_global_locality"

CodeRangeGlobalLocality: a tile restriction or halo report meets a 0-d state write, or a contraction, scan or data-dependent gather along a decomposed axis.

Source · Go docs

`CodeRangeHaloInsufficient`

constant · canonical name code_range_halo_insufficient

const CodeRangeHaloInsufficient = "range_halo_insufficient"

CodeRangeHaloInsufficient: a tile reads an in-domain cell outside its storage box with no periodic image in it (API_SPEC §5.8, “Range-restricted right-hand sides”).

Source · Go docs

`CodeRangeSelectionWritesIncomplete`

constant · canonical name code_range_selection_writes_incomplete

const CodeRangeSelectionWritesIncomplete = "range_selection_writes_incomplete"

CodeRangeSelectionWritesIncomplete: an operator selection’s writes omits a variable one of its selected contributions writes.

Source · Go docs

`CodeRefCycle`

constant · canonical name code_ref_cycle

const CodeRefCycle = "E_REF_CYCLE"

CodeRefCycle: a directed cycle exists among the reference edges.

Source · Go docs

`CodeRefDuplicateNodeID`

constant · canonical name code_ref_duplicate_node_id

const CodeRefDuplicateNodeID = "E_REF_DUPLICATE_NODE_ID"

CodeRefDuplicateNodeID: two expression nodes in the same document share an explicit id.

Source · Go docs

`CodeRefUndeclaredIndexSet`

constant · canonical name code_ref_undeclared_index_set

const CodeRefUndeclaredIndexSet = "E_REF_UNDECLARED_INDEX_SET"

CodeRefUndeclaredIndexSet: an undeclared name in a ranges[*].from.

Source · Go docs

`CodeRefUnknownFAQNode`

constant · canonical name code_ref_unknown_faq_node

const CodeRefUnknownFAQNode = "E_REF_UNKNOWN_FAQ_NODE"

CodeRefUnknownFAQNode: a kind:"derived" index set’s from_faq names no node id in the document.

Source · Go docs

`CodeRefUnresolvedJoinFactor`

constant · canonical name code_ref_unresolved_join_factor

const CodeRefUnresolvedJoinFactor = "E_REF_UNRESOLVED_JOIN_FACTOR"

CodeRefUnresolvedJoinFactor: a join.on factor reference names nothing in the node’s scope.

Source · Go docs

`CodeRelationalNodeInContinuous`

constant · canonical name code_relational_node_in_continuous

const CodeRelationalNodeInContinuous = "relational_node_in_continuous"

CodeRelationalNodeInContinuous: a relational / value-invention aggregate (distinct: true under bool_and_or) whose key/expr reads a declared STATE variable, so the cadence partition classes the node CONTINUOUS and guard 2 (no relational engine on the hot path) forbids it. RFC §6.1, CONFORMANCE_SPEC §5.7.6 guard 2.

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeRewriteRuleNonterminating`

constant · canonical name code_rewrite_rule_nonterminating

const CodeRewriteRuleNonterminating = "rewrite_rule_nonterminating"

CodeRewriteRuleNonterminating: the rewrite fixpoint did not converge within MAX_REWRITE_PASSES passes (esm-spec §9.6.3).

Source · Go docs

`CodeSearchsortedNaNInTable`

constant · canonical name code_searchsorted_na_n_in_table

const CodeSearchsortedNaNInTable = "searchsorted_nan_in_table"

CodeSearchsortedNaNInTable: a searchsorted table contains a NaN.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeSearchsortedNonMonotonic`

constant · canonical name code_searchsorted_non_monotonic

const CodeSearchsortedNonMonotonic = "searchsorted_non_monotonic"

CodeSearchsortedNonMonotonic: a searchsorted table is not non-decreasing.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeSolverExternalUnresolved`

constant · canonical name code_solver_external_unresolved

const CodeSolverExternalUnresolved = "solver_external_unresolved"

CodeSolverExternalUnresolved: solver.external carries ${ (esm-spec §2.2.6).

Source · Go docs

`CodeSolverExternalVersionTooOld`

constant · canonical name code_solver_external_version_too_old

const CodeSolverExternalVersionTooOld = "solver_external_version_too_old"

CodeSolverExternalVersionTooOld: solver.external in a file declaring esm < 1.3.0 (esm-spec §2.2.4).

Source · Go docs

`CodeSolverTimeSpanInvalid`

constant · canonical name code_solver_time_span_invalid

const CodeSolverTimeSpanInvalid = "solver_time_span_invalid"

CodeSolverTimeSpanInvalid: solver.time_span does not describe an interval – end not after start, a timestamp naming no calendar day, or an unreadable time origin (esm-spec §2.2.7).

Source · Go docs

`CodeSolverTimeSpanVersionTooOld`

constant · canonical name code_solver_time_span_version_too_old

const CodeSolverTimeSpanVersionTooOld = "solver_time_span_version_too_old"

CodeSolverTimeSpanVersionTooOld: solver.time_span in a file declaring esm < 1.3.0 (esm-spec §2.2.4).

Source · Go docs

`CodeSolverVersionTooOld`

constant · canonical name code_solver_version_too_old

const CodeSolverVersionTooOld = "solver_version_too_old"

CodeSolverVersionTooOld: a top-level solver block in a file declaring esm < 1.1.0 (esm-spec §2.2.4).

Source · Go docs

`CodeSubsystemIndexSetConflict`

constant · canonical name code_subsystem_index_set_conflict

const CodeSubsystemIndexSetConflict = "subsystem_index_set_conflict"

CodeSubsystemIndexSetConflict: a referenced subsystem declares an index set that conflicts with a same-named set already in the parent document.

Source · Go docs

`CodeSubsystemIndexSetRenameUnknownName`

constant · canonical name code_subsystem_index_set_rename_unknown_name

const CodeSubsystemIndexSetRenameUnknownName = "subsystem_index_set_rename_unknown_name"

CodeSubsystemIndexSetRenameUnknownName: a mount edge’s index_set_rename names an index set the RESOLVED mounted document does not declare (esm-spec §4.7 “Mount-edge index-set renaming”) — the mount-edge mirror of template_import_rename_unknown_name.

Source · Go docs

`CodeSubsystemIndexSetRenameUnsupportedMountForm`

constant · canonical name code_subsystem_index_set_rename_unsupported_mount_form

const CodeSubsystemIndexSetRenameUnsupportedMountForm = "subsystem_index_set_rename_unsupported_mount_form"

CodeSubsystemIndexSetRenameUnsupportedMountForm: index_set_rename on a mount form that does not implement it (esm-spec §4.7 “Mount-edge index-set renaming”, “Where it applies”). The field is a legal SubsystemRef property at either mount form, but a binding whose top-level models.<k> {ref} inliner cannot apply it MUST say so rather than merge the leaf under its pre-rename axis names. Go does not inline a top-level {ref} at all, so it never raises this; the constant exists because the code table is cross-language uniform.

Source · Go docs

`CodeSubsystemRefIsCouplingLibrary`

constant · canonical name code_subsystem_ref_is_coupling_library

const CodeSubsystemRefIsCouplingLibrary = "subsystem_ref_is_coupling_library"

CodeSubsystemRefIsCouplingLibrary: a subsystem ref resolves to a COUPLING library (§10.9) rather than to a document declaring a system.

Source · Go docs

`CodeSubsystemRefIsTemplateLibrary`

constant · canonical name code_subsystem_ref_is_template_library

const CodeSubsystemRefIsTemplateLibrary = "subsystem_ref_is_template_library"

CodeSubsystemRefIsTemplateLibrary: a subsystem ref resolves to a TEMPLATE library (§9.7) rather than to a document declaring a system.

Source · Go docs

`CodeTableAxisNaN`

constant · canonical name code_table_axis_na_n

const CodeTableAxisNaN = "table_axis_nan"

CodeTableAxisNaN: an axis’s values carries a non-finite entry; §9.5.1 requires strictly-increasing FINITE floats.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

A CROSS-BINDING vocabulary: every binding raises these same strings from its own §9.5.3 lowering, so they belong in the shared registry rather than beside the pass. Only the codes THIS binding actually emits are declared — the remaining §9.5.5 codes (table_axis_non_monotonic, table_data_nan, table_outputs_length_mismatch, table_axis_duplicate_name, table_outputs_duplicate_name) are load-time table-well-formedness checks this binding does not perform, and a constant for a code nothing raises would advertise a diagnostic it cannot report. —

Source · Go docs

`CodeTableDataShapeMismatch`

constant · canonical name code_table_data_shape_mismatch

const CodeTableDataShapeMismatch = "table_data_shape_mismatch"

CodeTableDataShapeMismatch: data’s nesting does not match the shape axes (and outputs, when present) imply, so the selected output names no sub-array.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTableInterpolationAxesMismatch`

constant · canonical name code_table_interpolation_axes_mismatch

const CodeTableInterpolationAxesMismatch = "table_interpolation_axes_mismatch"

CodeTableInterpolationAxesMismatch: interpolation and the axis count disagree — linear and nearest require 1 axis, bilinear 2.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTableLookupAxisNameMismatch`

constant · canonical name code_table_lookup_axis_name_mismatch

const CodeTableLookupAxisNameMismatch = "table_lookup_axis_name_mismatch"

CodeTableLookupAxisNameMismatch: the key set of table_lookup.axes does not match the axis names the referenced table declares — or the node carries positional args, which §9.5.2 requires to be empty.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTableLookupOutputOutOfRange`

constant · canonical name code_table_lookup_output_out_of_range

const CodeTableLookupOutputOutOfRange = "table_lookup_output_out_of_range"

CodeTableLookupOutputOutOfRange: table_lookup.output selects no output of the referenced table — an index past len(outputs) (or past 0 for a single-output table), a name absent from outputs, or a non-integer / non-string selector.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTableLookupUnknownTable`

constant · canonical name code_table_lookup_unknown_table

const CodeTableLookupUnknownTable = "table_lookup_unknown_table"

CodeTableLookupUnknownTable: a table_lookup names no table, or one the document’s function_tables block does not declare.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTableOutOfBoundsUnsupported`

constant · canonical name code_table_out_of_bounds_unsupported

const CodeTableOutOfBoundsUnsupported = "table_out_of_bounds_unsupported"

CodeTableOutOfBoundsUnsupported: the referenced table declares out_of_bounds: "error", which this binding does not implement. Per esm-spec §9.5.3a the lookup is REFUSED at the point it would otherwise lower — answering it under the "clamp" mode the binding does have would return a number the author did not ask for with nothing in the result to say so. The document still LOADS and still round-trips; it simply does not evaluate.

— Diagnostic codes: §9.5 sampled function tables — the §9.5.3 table_lookup lowering (raised via newTableLookupError from lower_table_lookup.go).

Source · Go docs

`CodeTemplateBodyExpansionTooDeep`

constant · canonical name code_template_body_expansion_too_deep

const CodeTemplateBodyExpansionTooDeep = "template_body_expansion_too_deep"

CodeTemplateBodyExpansionTooDeep: nested template application exceeded the expansion depth budget — the non-cyclic guard against unbounded growth.

Source · Go docs

`CodeTemplateBodyReferencesCouplingRewrittenVariable`

constant · canonical name code_template_body_references_coupling_rewritten_variable

const CodeTemplateBodyReferencesCouplingRewrittenVariable = "template_body_references_coupling_rewritten_variable"

CodeTemplateBodyReferencesCouplingRewrittenVariable: a SURVIVING registry body names a variable a coupling rule rewrote out of the flattened equations — a variable_map’s substituted target, or a spelling an operator_compose renaming match deleted (esm-spec §9.6.4, CONFORMANCE_SPEC §5.35). The body is authored source no equation walk reaches, and it expands at the BUILD boundary, so it is REFUSED rather than resolved: rewriting it would silently diverge from the expand-at-load image of the same document.

Source · Go docs

`CodeTemplateConstraintUnknownIndexSet`

constant · canonical name code_template_constraint_unknown_index_set

const CodeTemplateConstraintUnknownIndexSet = "template_constraint_unknown_index_set"

CodeTemplateConstraintUnknownIndexSet: a template’s constraints entry names an index set absent from the document index_sets registry.

Source · Go docs

`CodeTemplateImportCycle`

constant · canonical name code_template_import_cycle

const CodeTemplateImportCycle = "template_import_cycle"

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportIndexSetConflict`

constant · canonical name code_template_import_index_set_conflict

const CodeTemplateImportIndexSetConflict = "template_import_index_set_conflict"

CodeTemplateImportIndexSetConflict: a merged index_sets name collides with a non-deep-equal definition (esm-spec §9.7.5). This binding does not raise it yet; the constant exists because the §9.6.6 table is cross-language uniform.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportIsCouplingLibrary`

constant · canonical name code_template_import_is_coupling_library

const CodeTemplateImportIsCouplingLibrary = "template_import_is_coupling_library"

CodeTemplateImportIsCouplingLibrary: a template import resolves to a COUPLING library (§10.9). The two library kinds are imported through different blocks and are not interchangeable.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportNameConflict`

constant · canonical name code_template_import_name_conflict

const CodeTemplateImportNameConflict = "template_import_name_conflict"

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportNotLibrary`

constant · canonical name code_template_import_not_library

const CodeTemplateImportNotLibrary = "template_import_not_library"

CodeTemplateImportNotLibrary: an import resolves to a file that is not a template library (it declares components, or declares no expression_templates / coupling_roles block at all).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportRebindUnknownName`

constant · canonical name code_template_import_rebind_unknown_name

const CodeTemplateImportRebindUnknownName = "template_import_rebind_unknown_name"

CodeTemplateImportRebindUnknownName: a rebind key names no metaparameter the imported library declares.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportRenameCollision`

constant · canonical name code_template_import_rename_collision

const CodeTemplateImportRenameCollision = "template_import_rename_collision"

CodeTemplateImportRenameCollision: a rename target collides with a name already in scope (another import’s export, or a local declaration).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportRenameInvalid`

constant · canonical name code_template_import_rename_invalid

const CodeTemplateImportRenameInvalid = "template_import_rename_invalid"

CodeTemplateImportRenameInvalid: an import’s rename / rebind entry is malformed — not an object, or an entry whose key or value is not a non-empty string.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportRenameUnknownName`

constant · canonical name code_template_import_rename_unknown_name

const CodeTemplateImportRenameUnknownName = "template_import_rename_unknown_name"

CodeTemplateImportRenameUnknownName: a rename key names nothing the imported library exports.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportUnknownName`

constant · canonical name code_template_import_unknown_name

const CodeTemplateImportUnknownName = "template_import_unknown_name"

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportUnresolved`

constant · canonical name code_template_import_unresolved

const CodeTemplateImportUnresolved = "template_import_unresolved"

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateImportVersionTooOld`

constant · canonical name code_template_import_version_too_old

const CodeTemplateImportVersionTooOld = "template_import_version_too_old"

CodeTemplateImportVersionTooOld: a file declaring esm < 0.8.0 carries expression_template_imports, top-level expression_templates, or metaparameters (esm-spec §9.6.5).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateInjectTargetNotComponent`

constant · canonical name code_template_inject_target_not_component

const CodeTemplateInjectTargetNotComponent = "template_inject_target_not_component"

CodeTemplateInjectTargetNotComponent: an injection target resolves to something that is not an injectable component.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateInjectTargetUnknown`

constant · canonical name code_template_inject_target_unknown

const CodeTemplateInjectTargetUnknown = "template_inject_target_unknown"

CodeTemplateInjectTargetUnknown: an injection target names a component the document does not declare.

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeTemplateLibraryIllegalPayload`

constant · canonical name code_template_library_illegal_payload

const CodeTemplateLibraryIllegalPayload = "template_library_illegal_payload"

CodeTemplateLibraryIllegalPayload: a document carries top-level expression_templates beside models / reaction_systems / data_sources / coupling / domain, which a template-library file never declares (esm-spec §9.7.1).

— Diagnostic codes: §9.7 template imports / §9.6.6 metaparameters (raised via newETErr from template_imports.go and subsystem_ref.go). —

Source · Go docs

`CodeUndefinedIndexSet`

constant · canonical name code_undefined_index_set

const CodeUndefinedIndexSet = "undefined_index_set"

CodeUndefinedIndexSet: an aggregate ranges entry {from: NAME} names an index set that is not a key of the document index_sets registry. No implicit interval is inferred for an undeclared name (RFC §5.2).

join_key_invalid_type — an aggregate value-equality join whose key column draws from a categorical index set with a float or null member.
domain_unit_mismatch — an identity variable_map coupling whose from/to variables carry declared, non-empty, DIFFERENT units.
relational_node_in_continuous — a distinct/bool_and_or aggregate whose key/expr reads a STATE variable (value-invention in a continuous context).
undefined_index_set — an aggregate ranges entry {from: NAME} naming a set absent from the document index_sets registry.

Every finding is emitted at the CONTAINING EXPRESSION FIELD (/models/M/equations/i/lhs or /rhs, or /coupling/i) — the same pointer convention the reference-integrity findings use.

Source · Go docs

`CodeUnevaluableOperator`

constant · canonical name code_unevaluable_operator

const CodeUnevaluableOperator = "unevaluable_operator"

CodeUnevaluableOperator: evaluation reached an op that IS in the esm-spec §4.2 evaluable core but that this evaluator has no rule for (esm-spec §9.6.6): an array/query or value-invention op, or an enum that should have been lowered at load. The complement of CodeUnloweredOperator.

Source · Go docs

`CodeUnknownClosedFunction`

constant · canonical name code_unknown_closed_function

const CodeUnknownClosedFunction = "unknown_closed_function"

CodeUnknownClosedFunction: an fn node names a function outside the closed registry.

— Diagnostic codes: §9.2 closed-function registry (raised via newClosedFunctionError from registered_functions.go). —

Source · Go docs

`CodeUnknownEnum`

constant · canonical name code_unknown_enum

const CodeUnknownEnum = "unknown_enum"

CodeUnknownEnum: an enum node names an enum the file does not declare.

— Diagnostic codes: §9.3 enum lowering (raised via newEnumLoweringError from lower_enums.go). —

Source · Go docs

`CodeUnknownEnumSymbol`

constant · canonical name code_unknown_enum_symbol

const CodeUnknownEnumSymbol = "unknown_enum_symbol"

CodeUnknownEnumSymbol: an enum node names a symbol its enum does not declare.

— Diagnostic codes: §9.3 enum lowering (raised via newEnumLoweringError from lower_enums.go). —

Source · Go docs

`CodeUnknownExpressionType`

constant · canonical name code_unknown_expression_type

const CodeUnknownExpressionType = "unknown_expression_type"

— Diagnostic codes: structural validation, peers of the Error* block above. —

Source · Go docs

`CodeUnloweredOperator`

constant · canonical name code_unlowered_operator

const CodeUnloweredOperator = "unlowered_operator"

CodeUnloweredOperator: evaluation reached a rewrite-target op — one OUTSIDE the esm-spec §4.2 evaluable core (a spatial or right-hand-side D, grad, a user op) — that no rewrite rule eliminated.

Source · Go docs

`CodeUnresolvedSubsystemRef`

constant · canonical name code_unresolved_subsystem_ref

const CodeUnresolvedSubsystemRef = "unresolved_subsystem_ref"

CodeUnresolvedSubsystemRef: a subsystem ref names a file that does not exist / is not readable, or that was never resolved before validation.

Source · Go docs

`CodeUnsupportedConstruct`

constant · canonical name code_unsupported_construct

const CodeUnsupportedConstruct = "unsupported_construct"

CodeUnsupportedConstruct: a continuous or discrete event, or an implicit equation, reached an evaluator that cannot run it (esm-spec §9.6.6). Go does not simulate, so it never raises this; the constant keeps the §9.6.6 vocabulary uniform.

Source · Go docs

`CodeValidationFailed`

constant · canonical name code_validation_failed

const CodeValidationFailed = "validation_failed"

— Diagnostic codes: structural validation, peers of the Error* block above. —

Source · Go docs

`ComponentAdjacency`

type · canonical name component_adjacency

type ComponentAdjacency struct {
	Neighbor ComponentNode
	Edge     CouplingEdge
}

ComponentAdjacency is one entry returned by ComponentGraph.Adjacency: a neighbouring component node and the coupling edge that reaches it.

Source · Go docs

`ComponentCounts`

type · canonical name component_counts

type ComponentCounts struct {
	VarCount     int `json:"var_count"`
	EqCount      int `json:"eq_count"`
	SpeciesCount int `json:"species_count"`
}

ComponentCounts is a component node’s summary metadata (esm-libraries-spec §4.8.1). Exactly three counts are defined, and they mean different things for the two component types:

a MODEL carries VarCount = len(variables), EqCount = len(equations) and SpeciesCount = 0;
a REACTION SYSTEM carries VarCount = len(parameters), EqCount = len(reactions) — the reaction count IS the equation count, there is no fourth field — and SpeciesCount = len(species). The schema forbids a variables field on a reaction system and SpeciesCount already carries the species, so parameters is the only thing left for §4.8.1’s “variable count” to mean — and it is the exact analogue of a model’s variables, which likewise counts unknowns and parameters together.

Source · Go docs

`ComponentGraphFromFile`

function · canonical name component_graph_from_file

func ComponentGraphFromFile(file *ESMFile) *ComponentGraph

ComponentGraphFromFile creates a component graph from an ESM file.

Models and reaction systems are visited in sorted key order: ranging over the maps directly made the node and edge lists differ run to run, which is not a conformance failure (order is not pinned) but does make every rendered or diffed export nondeterministic.

Source · Go docs

`Connector`

type · canonical name connector

type Connector struct {
	Equations []ConnectorEquation `json:"equations"`
}

Connector represents the connector system for couple coupling

Source · Go docs

`ConnectorEquation`

type · canonical name connector_equation

type ConnectorEquation struct {
	From      string `json:"from"`
	To        string `json:"to"`
	Transform string `json:"transform"` // "additive", "multiplicative", "replacement"
	// Expression is OPTIONAL: esm-schema.json `$defs/ConnectorEquation` requires
	// only from/to/transform. Without `omitempty` the nil interface emitted
	// `"expression": null` into every connector equation authored without one —
	// an ADDED key, so a load → save did not just lose content, it invented it.
	Expression Expression `json:"expression,omitempty"`
}

ConnectorEquation represents a single equation in a connector

Source · Go docs

`CouplingKind`

type · canonical name coupling_kind

type CouplingKind string

CouplingKind identifies the kind of coupling a component-graph edge represents.

Source · Go docs

`CouplingKindCouple`

constant · canonical name coupling_kind_couple

const CouplingKindCouple CouplingKind = "couple"

CouplingKindCouple marks an edge built from a couple coupling entry (esm-spec §10.1, §10.3): the two systems are joined through explicit connector equations.

Source · Go docs

`CouplingKindOperatorCompose`

constant · canonical name coupling_kind_operator_compose

const CouplingKindOperatorCompose CouplingKind = "operator_compose"

CouplingKindOperatorCompose marks an edge built from an operator_compose coupling entry (esm-spec §10.1): matching time derivatives are identified and their right-hand sides added together.

Source · Go docs

`CouplingKindVariableMap`

constant · canonical name coupling_kind_variable_map

const CouplingKindVariableMap CouplingKind = "variable_map"

CouplingKindVariableMap marks an edge built from a variable_map coupling entry (esm-spec §10.1, §10.4): a parameter in one system is replaced by a variable from another, or by an expression computed from it.

Source · Go docs

`DataSourceExtent`

type · canonical name data_source_extent

type DataSourceExtent struct {
	Metaparameter string `json:"metaparameter"`
}

DataSourceExtent binds a source’s delivered record count to a metaparameter (esm-spec 8.9.4).

Source · Go docs

`DataSourceRecordFilter`

type · canonical name data_source_record_filter

type DataSourceRecordFilter struct {
	RequireFinite []string `json:"require_finite,omitempty"`
}

DataSourceRecordFilter names the file variables whose value must be finite for a record of a points source to be delivered (esm-spec 8.9.3).

Source · Go docs

`DefaultIndepVar`

constant · canonical name default_indep_var

const DefaultIndepVar = "t"

— Spec default: the independent variable when Domain.IndependentVariable is unset (esm-spec §11; dae.go defaults to this). —

Source · Go docs

`DetailedValidationResult`

type · canonical name detailed_validation_result

type DetailedValidationResult struct {
	Valid    bool                `json:"valid"`
	Messages []ValidationMessage `json:"messages,omitempty"`
}

DetailedValidationResult holds the legacy (message-oriented) validation results returned by ValidateStructural. New callers should prefer Validate (or ValidateText for unparsed JSON), which returns the code-bearing ValidationResult.

Source · Go docs

`DiagnosticError`

error · canonical name diagnostic_error

type DiagnosticError interface {
	error
	DiagnosticCode() string
}

DiagnosticError is implemented by the package’s code-bearing error types (EvaluationError, ExpressionTemplateError, RuleEngineError, EnumLoweringError, ClosedFunctionError, CoupleMultiplicativeNoTendencyError, tableLookupError, OperatorComposeNoMergeError, OperatorComposeAmbiguousBareNameError, OperatorComposeRequireMatchError). It lets a caller recover the stable diagnostic code from any of them uniformly — errors.As(err, &de) then de.DiagnosticCode() — without switching over the concrete types. All ten render Error() in the shared “

\[code\]

message” form.

Source · Go docs

`Dimensionless`

constant · canonical name dimensionless

var Dimensionless = Dimension{}

Dimensionless is the zero vector.

Source · Go docs

`DistributionLognormal`

constant · canonical name distribution_lognormal

const DistributionLognormal = "lognormal"

Distribution kind literals (esm-spec 6.3).

Source · Go docs

`DistributionNormal`

constant · canonical name distribution_normal

const DistributionNormal = "normal"

Distribution kind literals (esm-spec 6.3).

Source · Go docs

`DistributionUniform`

constant · canonical name distribution_uniform

const DistributionUniform = "uniform"

Distribution kind literals (esm-spec 6.3).

Source · Go docs

`EdgeKindFromFAQ`

constant · canonical name edge_kind_from_faq

const EdgeKindFromFAQ EdgeKind = "from_faq"

EdgeKindFromFAQ: kind:"derived" index set → the node that materializes it (from_faq).

Source · Go docs

`EdgeKindJoinFactor`

constant · canonical name edge_kind_join_factor

const EdgeKindJoinFactor EdgeKind = "join_factor"

EdgeKindJoinFactor: aggregate node → a factor named by join.on.

Source · Go docs

`EdgeKindRangeFrom`

constant · canonical name edge_kind_range_from

const EdgeKindRangeFrom EdgeKind = "range_from"

EdgeKindRangeFrom: aggregate node → the index set it iterates (ranges[*].from).

Source · Go docs

`EmitReferencePreserving`

function · canonical name emit_reference_preserving

func EmitReferencePreserving(jsonStr, basePath string, metaparameters map[string]int64) (string, error)

EmitReferencePreserving loads jsonStr under Option B and emits the canonical, self-contained reference-preserving document (esm-spec §9.6.4 rule 5, §9.6.7): surviving call sites verbatim, materialized template registries, imports consumed, esm: 0.9.0 version stamp. The byte-identity cross-binding surface — output is byte-identical to the Julia-generated emitted.esm goldens.

Source · Go docs

`EquationBalance`

type · canonical name equation_balance

type EquationBalance struct {
	// Unknowns are the model's declared unknowns, sorted. (Declaration order is
	// what the shared corpus's `details` happens to show, but Go's variable map
	// does not preserve it, so this list is sorted for determinism. The pin
	// contract compares (code, path) pairs, not details.)
	Unknowns []string
	// Equations is the number of entries in the model's `equations` block.
	Equations int
	// MissingEquationsFor names the unknowns that no equation LHS credits — the
	// diagnostic detail that preserves the discriminating power of the removed
	// `missing_observed_expr`, since it names exactly the unknowns that code used
	// to name.
	MissingEquationsFor []string
	// ExtraEquationsFor names non-unknown targets an equation LHS credits.
	ExtraEquationsFor []string
}

EquationBalance is the outcome of the esm-spec §4.9.4 balance check.

Source · Go docs

`ErrCanonicalDivByZero`

error · canonical name err_canonical_div_by_zero

var ErrCanonicalDivByZero = errors.New("E_CANONICAL_DIVBY_ZERO")

Error codes per discretization RFC §5.4.6 / §5.4.7.

Source · Go docs

`ErrCanonicalNonFinite`

error · canonical name err_canonical_non_finite

var ErrCanonicalNonFinite = errors.New("E_CANONICAL_NONFINITE")

Error codes per discretization RFC §5.4.6 / §5.4.7.

Source · Go docs

`ErrCanonicalUnsupportedField`

error · canonical name err_canonical_unsupported_field

var ErrCanonicalUnsupportedField = errors.New("E_CANONICAL_UNSUPPORTED_FIELD")

ErrCanonicalUnsupportedField is returned by CanonicalJSON when a node carries a set field outside the closed emissible set {op,args,wrt,dim,fn,name,value} (arg/bindings tolerated) — the node has no faithful canonical JSON in the pinned encoding. Matches the Julia reference’s E_CANONICAL_UNSUPPORTED_FIELD (see canonicalize.jl).

Error codes per discretization RFC §5.4.6 / §5.4.7.

Source · Go docs

`ErrorArrayDefaultWithoutShape`

constant · canonical name error_array_default_without_shape

const ErrorArrayDefaultWithoutShape = "array_default_without_shape"

ErrorArrayDefaultWithoutShape is inline array data as the default of a variable that declares no shape (esm-spec §6.3). Inline array data is a SHAPED variable’s value, so with no shape there is nothing for the array to fill (tests/invalid/array_default_without_shape.esm).