Struct SessionRuntime 

pub struct SessionRuntime { /* private fields */ }

The session-type runtime cursor + credit window.

Held by each side of a connection — the server runtime is initialised with the server-role type, the client with the dual. Every transition is local: there is no cross-process synchronisation here; the carrier delivers frames in order and the two cursors stay in lock step because they were initialised from a duality-checked pair.

Serialize + Deserialize — §Fase 41.g sealed-snapshot resume. The serialised form is a stable JSON object containing the schema (so resume can verify the protocol hasn’t been swapped), the residual cursor, and the live credit window. Encoded once via Self::seal into the AAD-bound cognitive_states ciphertext; decoded by Self::resume after the §40.k EnvelopeEncryption::decrypt verifies the (tenant, session, flow) binding.

Implementations

impl SessionRuntime

pub fn new(schema: SessionType, budget: Option<u64>) -> Self

Create a runtime for the given role’s session type. budget mirrors the socket’s credit(k); pass None for the unbounded fragment (statically equivalent to omitting backpressure:).

pub fn schema(&self) -> &SessionType

The original session type — useful for error messages and logs.

pub fn cursor(&self) -> &SessionType

The current residual cursor — always head-unfolded.

pub fn credit(&self) -> Option<CreditWindow>

The dynamic credit window snapshot (or None for the unbounded fragment).

pub fn is_complete(&self) -> bool

true once the cursor reaches end — both sides should now close the carrier cleanly. The runtime rejects further actions after this point with ProtocolError::AlreadyComplete.

pub fn seal(&self) -> Option<SealedRuntime>

Serialise the live runtime state into a stable JSON envelope — the plaintext the §40.t cognitive_states AAD-bound ciphertext wraps. Carries the schema (so resume can verify the protocol hasn’t been swapped under the connection), the residual cursor, and the live credit window snapshot.

Symmetric with Self::resume: runtime.seal() then SessionRuntime::resume(sealed, declared_schema) round-trips when the declared schema matches.

Returns None if and only if the cursor is already at End — a completed dialogue has no residual to seal, so no snapshot is issued (the caller should evict() the prior snapshot instead).

pub fn resume( sealed: SealedRuntime, declared_schema: &SessionType, ) -> Result<Self, ResumeError>

Reconstruct a SessionRuntime from a sealed snapshot, validating the schema matches what the route declares now (defence against protocol-swap attacks where an attacker reuses a sealed snapshot against a different socket whose declaration drifted).

On success the returned runtime resumes from the exact cursor + credit window the disconnected one left behind. The carrier driver then runs the producer/consumer loop as usual.

pub fn try_send(&mut self, got: &str) -> Result<(), ProtocolError>

Producer step !A.S → S. Succeeds iff:

1. the cursor is Send { payload, … } with payload == got;
2. the credit window (if any) has available > 0 — otherwise the §41.c “no rule at n=0” axiom fires. On success the cursor advances (unfolded) and one credit is consumed (when the window is present).

pub fn try_recv(&mut self, got: &str) -> Result<(), ProtocolError>

Consumer step ?A.S → S. The peer just produced an !A.S frame. Symmetric to [try_send] — payload must match, the cursor advances, and one credit is refilled (if a window is present).

pub fn try_select(&mut self, label: &str) -> Result<(), ProtocolError>

Internal choice (⊕) — we select the labelled arm. Cursor must be Select { arms } containing label; on success the cursor advances into that arm’s continuation.

pub fn try_offer(&mut self, label: &str) -> Result<(), ProtocolError>

External choice (&) — the peer selected this label; we accept. Cursor must be Branch { arms } containing label.

pub fn try_end(&mut self) -> Result<(), ProtocolError>

end step — terminates the dialogue. Cursor must already be End; otherwise the peer is signalling termination mid-protocol.

Trait Implementations

impl Clone for SessionRuntime

fn clone(&self) -> SessionRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SessionRuntime

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SessionRuntime

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SessionRuntime

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

where __S: Serializer,

Serialize this value into the given Serde serializer.