Enum FrameKind 

#[non_exhaustive]
pub enum FrameKind {
    Snippet,
    Symbol,
    Fact,
    Doc,
    Memory,
    Episode,
    Graph,
    Unknown(String),
}

What kind of thing a frame represents (SPEC.md §6).

Why this is not a closed enum

The protocol guarantees no flag day inside a major family: a contextgraph/1.0 host and a contextgraph/1.1 host interoperate, and minor versions may add vocabulary. A closed enum contradicts that guarantee twice over. A frame carrying a kind introduced in 1.1 would fail to deserialize on a 1.0 host — not degrade, fail — and every exhaustive match in downstream Rust would break the day a variant was added.

So FrameKind follows the same shape as EgressScope: a closed base vocabulary of seven kinds, plus an Unknown variant that preserves the original string. A host that does not recognize a kind can still parse the frame, route it, budget it, cite it, and re-serialize it byte-identically.

That last property is why Unknown carries a String rather than being a bare unit variant with #[serde(other)]. #[serde(other)] collapses every unrecognized value into one variant and discards the original, so a host relaying a frame it did not fully understand would silently rewrite "kind": "trajectory" to something else on the way out. A forward-compat mechanism that corrupts data in a relay is worse than the failure it replaces.

#[non_exhaustive]

The attribute forces downstream match expressions to carry a wildcard arm, which makes every future kind addition a non-breaking change for every consumer. It is a one-time cost paid now so the version promise holds forever after.

Not Copy

Preserving an unknown kind’s string means the type owns an allocation, so it cannot be Copy. Forward compatibility is a protocol guarantee; Copy was an ergonomic convenience. When the two conflict the guarantee wins.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Snippet

Symbol

Fact

Doc

Memory

Episode

Graph

Unknown(String)

A kind this revision does not define — most likely one introduced by a later minor version of the same major family. The original wire string is retained verbatim so the frame round-trips unchanged.

A host MUST NOT reject a frame for carrying an unknown kind. It may decline to specialize its handling — that is a rendering decision, not a validity one.

Implementations

impl FrameKind

pub const KNOWN: &'static [&'static str]

Every kind this revision names — a registry, not a restriction.

pub fn as_str(&self) -> &str

The canonical wire string of this kind.

pub fn from_wire(kind: impl Into<String>) -> Self

Parse a wire string: a known base name maps to its variant, anything else to Unknown. Never fails — an unrecognized kind is a frame a host cannot specialize, not a frame it must refuse.

pub fn is_known(&self) -> bool

Whether this kind is one of the seven this revision defines.

Trait Implementations

impl Clone for FrameKind

fn clone(&self) -> FrameKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FrameKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FrameKind

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for FrameKind

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

Formats the value using the given formatter.

impl Eq for FrameKind

impl Hash for FrameKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for FrameKind

fn cmp(&self, other: &FrameKind) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl PartialEq for FrameKind

fn eq(&self, other: &FrameKind) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for FrameKind

fn partial_cmp(&self, other: &FrameKind) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for FrameKind

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FrameKind