Enum ValidationError 

pub enum ValidationError {
    UnknownSection {
        key: String,
        entity_type: String,
        declared: Vec<String>,
        suggestion: Option<String>,
    },
    UnknownMetadata {
        key: String,
        entity_type: String,
        declared: Vec<String>,
        suggestion: Option<String>,
    },
    InvalidEnumValue {
        field: String,
        value: String,
        allowed: Vec<String>,
        field_description: Option<String>,
        suggestion: Option<String>,
        type_write_rules: Vec<String>,
        entity_type: String,
    },
    ReadOnlyField {
        field: String,
    },
    SectionNotUpdatable {
        section: String,
        entity_type: String,
    },
    InvalidRelationshipType {
        input: String,
        allowed: Vec<RelationshipHint>,
        suggestion: Option<String>,
    },
    InvalidRelationshipShape {
        rel_type: String,
        from_type: String,
        to_type: String,
        allowed_source_types: Vec<String>,
        allowed_target_types: Vec<String>,
        suggestion: Option<RelationshipHint>,
    },
    SectionContentInvalid {
        section: String,
        embedded_heading: String,
    },
    EmptyUndeclaredHeading {
        section: String,
        heading: String,
        entity_type: String,
    },
    UnterminatedFence {
        section: String,
        fence: String,
    },
    SectionContentControlByte {
        section: String,
        control_char: char,
        codepoint: u32,
        byte_offset: usize,
    },
    InvalidFieldValue {
        field: String,
        value: String,
        expected_type: String,
        expected_format: Option<String>,
        field_description: Option<String>,
        entity_type: String,
    },
}

A typed CRUD-time validation failure. Mirrors the wire-format error codes the MCP layer surfaces; the engine adapters convert each variant into their own error type.

Variants

UnknownSection

UNKNOWN_SECTION: section key not declared on the type and not absorbed by a catch_all section.

Fields

key: String

entity_type: String

declared: Vec<String>

suggestion: Option<String>

UnknownMetadata

UNKNOWN_METADATA: metadata key not declared on the type.

Fields

key: String

entity_type: String

declared: Vec<String>

suggestion: Option<String>

InvalidEnumValue

INVALID_ENUM_VALUE: enum-typed metadata field rejected the supplied value.

Fields

field: String

value: String

allowed: Vec<String>

field_description: Option<String>

suggestion: Option<String>

type_write_rules: Vec<String>

entity_type: String

ReadOnlyField

READ_ONLY_FIELD: caller tried to set or unset a read-only metadata key (mem, id, type) on update.

Fields

field: String

SectionNotUpdatable

SECTION_NOT_UPDATABLE: the section is not in the type’s updatable_fields allowlist, or it is the virtual relationships surface (which is managed by memstead_relate, not memstead_update).

Fields

section: String

entity_type: String

InvalidRelationshipType

INVALID_REL_TYPE: the relationship name is not declared in the active schema and the schema runs in strict mode. Open-mode schemas admit unknown names with a warning instead — see [check_relationship_strict_or_open].

Fields

input: String

allowed: Vec<RelationshipHint>

suggestion: Option<String>

InvalidRelationshipShape

INVALID_REL_SHAPE: the edge’s (from_type, to_type) pair violates the schema’s declared source_types / target_types for this relationship. Only fires for shape-pinned edges; an edge with empty constraint lists admits any pair.

Fields

rel_type: String

from_type: String

to_type: String

allowed_source_types: Vec<String>

allowed_target_types: Vec<String>

suggestion: Option<RelationshipHint>

SectionContentInvalid

SECTION_CONTENT_INVALID: a section body contains a ^## line (level-2 heading) which the entity’s compose-then-reparse pipeline would interpret as a section delimiter. Without this guard a caller can inject content into a different section by embedding a heading in another section’s body. Deeper headings (### and below) are allowed — the parser anchors only on level 2.

Fields

section: String

embedded_heading: String

EmptyUndeclaredHeading

EMPTY_UNDECLARED_HEADING: caller-supplied content carries a heading the type does not declare with NO body under it (consistency-sweep 04/01, criterion 7). The catch-all builder skips empty content, so such a heading is dropped on the write that accepts it: the caller is told now rather than discovering the loss afterwards.

The boundary is exactly the complement of the catch-all exemption validate_section_content grants: an undeclared heading WITH a body survives verbatim and is accepted, one without a body does not survive and is refused. The exemption and this refusal are the same rule read from its two sides.

Fields

section: String

heading: String

entity_type: String

UnterminatedFence

UNTERMINATED_FENCE: caller-supplied section content ends inside a fenced code block that never closes (consistency-sweep 04/02, criterion 1). Nothing about the parse is wrong: an open fence’s range runs to end of text in CommonMark, so every ## line the generator writes after this section lands inside the fence, is masked, and is absorbed into this section’s body on the next read. The sections then render as empty and the entity reads as healthy.

The sibling guard ValidationError::SectionContentInvalid refuses content that would BECOME a delimiter; this one refuses content that would HIDE one. Both are about the same seam from opposite sides, and neither can see the other’s case: a fence opener is not a heading line, and the heading guard’s own mask is what renders the hidden heading invisible to it.

The oracle is markdown::closing_fence_if_unterminated, the referee’s existing sentinel probe. No second fence model is written here.

Fields

section: String

fence: String

SectionContentControlByte

SECTION_CONTENT_INVALID (control-byte sub-case): a section body contains a control character other than tab (\t) or newline (\n). A NUL especially makes git classify the .md blob as binary, defeating the diffable-markdown invariant the storage model rests on, and downstream text tooling truncates at it. Shares the wire code with the heading-injection case (both are SECTION_CONTENT_INVALID) — the control_char/byte_offset recovery fields discriminate it from embedded_heading. Mirrors the title control-char guard (refuse with an actionable hint, not silent strip). \t and \n stay legal; the verbatim-escape contract is untouched (this screens a byte class, it does not de-escape).

Fields

section: String

control_char: char

The offending control character (a char, since the body is already valid UTF-8 — a NUL is U+0000).

codepoint: u32

Its Unicode scalar value, surfaced as a number for unambiguous machine reading (the string form JSON-escapes).

byte_offset: usize

Byte offset into the section body — matches the od -c view a caller uses to locate the byte.

InvalidFieldValue

INVALID_FIELD_VALUE: a non-enum typed metadata field received a value that does not parse as its declared type — a Date field given "not-a-real-date" or "", or a Number field given non-numeric text. Distinct from INVALID_ENUM_VALUE (the key and type are valid but the value is out of an enum’s vocabulary) and UNKNOWN_METADATA_FIELD (the key is not declared): here the key and field-type are valid but the value is malformed for the type. Without this check the value round-trips raw and corrupts range-filter results (a non-date string sorts lexically against real dates, so *_after matches it).

Fields

field: String

value: String

expected_type: String

expected_format: Option<String>

field_description: Option<String>

entity_type: String

Implementations

impl ValidationError

pub fn code(&self) -> &'static str

Stable UPPER_SNAKE_CASE wire code for this validation sub-variant. Single source of truth — both EngineError::code() (via the Validation(_) arm) and the MCP validation_envelope mapper read from here, so the wire code cannot drift between channels.

pub fn details(&self) -> Value

Structured recovery payload for this validation sub-variant. The payload mirrors the variant’s declared fields so callers branching on code can read the same shape validation_envelope ships on the MCP wire. Returned shape is documented in the MCP tool descriptions — see Errors: blocks on memstead_create / memstead_update / memstead_relate.

pub fn prose_render(&self) -> String

Render rich, fully-inlined recovery prose for the agent-visible text channel. Closes the asymmetry where warnings render their structured details inline but errors collapse details.X references to a “+N more — see details.X” pointer pointing at a channel the agent’s MCP client doesn’t surface to the model. The structured details() channel is unchanged — this method only governs result.content[0].text. Display stays terse for logs and tracing::warn! consumers.

Trait Implementations

impl Clone for ValidationError

fn clone(&self) -> ValidationError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ValidationError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for ValidationError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for ValidationError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ValidationError> for EngineError

fn from(source: ValidationError) -> Self

Converts to this type from the input type.