Enum Frame 

pub enum Frame {
    Send {
        payload_type: String,
        data: Value,
    },
    Select {
        label: String,
    },
    End,
    Error {
        code: String,
        detail: String,
    },
}

One frame on the wire — exactly one operational step.

#[serde(tag = "kind", rename_all = "lowercase")] is intentional: the kind discriminator is the closed catalog send | select | end | error. Anything else is malformed.

Variants

Send

!A.S advance: the sender produces a value of type A (named by the canonical payload string; the JSON data carries the value). On the receiver side this triggers a try_recv(A) on its cursor.

Fields

payload_type: String

Canonical payload type name — must equal the cursor’s Payload for the step. Validated at the receiver.

data: Value

The value carried by the step. Opaque at this layer (no schema enforcement beyond presence + JSON well-formedness); payload-shape validation is a future fase (e.g. typed-data integration with axonstore).

Select

⊕{ℓᵢ:Sᵢ} advance: the chooser names a labelled branch. On the receiver side this triggers a try_offer(ℓ) on its cursor (whose type at this point is &{ℓᵢ:Sᵢ}).

Fields

label: String

The chosen label — must be a key in the cursor’s arms.

End

end — the dialogue terminates. Both halves transition to End. No further frames are accepted from either side; the carrier (WebSocket) closes cleanly with code 1000 normal closure.

Error

Out-of-band protocol error — emitted by either side just before closing the carrier with code 1002 protocol error. Carries a short machine-readable code + a human detail message so the peer can diagnose the divergence without re-running its analysis.

Fields

code: String

Short stable identifier — see ProtocolError::code.

detail: String

Free-form human-readable detail.

Implementations

impl Frame

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

The fixed runtime tag of this frame’s kind, used in ProtocolError::UnexpectedFrame for cursor / frame mismatch diagnostics. Stable in both the wire (tag value) and the runtime (matching the closed catalog).

pub fn to_wire(&self) -> String

Serialise to a JSON string, prefixed with the wire-version tag in the outer envelope: every frame on the wire is one line of {"v":1,"kind":"…",…} — the version is the first key so a linewise log scan can reject pre-handshake junk without parsing.

We splice the version into the head of the serialised inner object rather than building a serde_json::Map: the default Map sorts keys alphabetically (BTreeMap-backed without preserve_order), which would land "kind" before "v". The splice is total — the inner serialisation is always a JSON object for this enum (every variant has a kind tag), so the leading { is guaranteed.

pub fn from_wire(s: &str) -> Result<Frame, ProtocolError>

Parse a wire string into a Frame. Validates the version tag and the closed kind catalog; returns ProtocolError::MalformedFrame on any divergence (including pre-1.0 shapes, unknown kind, missing required fields).

Trait Implementations

impl Clone for Frame

fn clone(&self) -> Frame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Frame

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Frame

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Frame

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Frame

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Frame