Struct DispatchEnvelope 

pub struct DispatchEnvelope {
    pub schema_version: String,
    pub request: CallbackRequest,
    pub payloads: Vec<PayloadEnvelope>,
}

Wire shape carrying a CallbackRequest and the opaque PayloadEnvelope bodies a dispatch is delivering with.

The lifecycle contract distinguishes two concerns:

• the request a client receives describing what is happening (event kind, frame context, CallbackRequest::payload_refs pointing at named/sized/digested payloads), and
• the envelope bodies the request refers to.

Until issue #22 the CLI and the subprocess invoker only transported the request — the envelopes were not delivered, so subprocess clients could not reach payload bodies and negotiation never saw real placement inputs. DispatchEnvelope is the transport-boundary shape that carries both:

{
  "schema_version": "lifeloop.v0.1",
  "request": { "...CallbackRequest...": "..." },
  "payloads": [ { "...PayloadEnvelope...": "..." } ]
}

Lifeloop does not parse payloads[].body — it is transported verbatim, consistent with the spec rule that bodies are opaque (docs/specs/lifecycle-contract/body.md, “Opaque Payload Envelope”). payloads is omitted on the wire when empty.

Fields

schema_version: String

request: CallbackRequest

payloads: Vec<PayloadEnvelope>

Implementations

impl DispatchEnvelope

pub fn new(request: CallbackRequest, payloads: Vec<PayloadEnvelope>) -> Self

Construct a dispatch envelope at the canonical schema version.

pub fn validate(&self) -> Result<(), ValidationError>

Validate the envelope: schema version, the inner request, and each carried payload. Cross-correlation between request.payload_refs and payloads[] is intentionally not enforced here — a request may declare refs that are delivered out-of-band, and clients may receive bodies the request did not list (e.g. degraded fallback bodies). Cross-correlation belongs in negotiation/receipt synthesis, not the transport boundary.

Trait Implementations

impl Clone for DispatchEnvelope

fn clone(&self) -> DispatchEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DispatchEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DispatchEnvelope

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DispatchEnvelope

fn eq(&self, other: &DispatchEnvelope) -> 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 DispatchEnvelope

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DispatchEnvelope

impl StructuralPartialEq for DispatchEnvelope