Struct ActionEnvelope 

pub struct ActionEnvelope {
    pub id: ActionId,
    pub action: EncodedAction,
    pub base_heads: Vec<[u8; 32]>,
    pub timestamp: i64,
    pub locus: ExecutionLocus,
    pub actor: Option<Vec<u8>>,
    pub context: Option<ActionContext>,
}

One replayable action, ready to cross a boundary.

Fields

id: ActionId

Unique id; its bytes are also the Automerge actor used to commit the action’s change, so replay reproduces the exact same change hash.

action: EncodedAction

The serialized action.

base_heads: Vec<[u8; 32]>

Document heads the action was authored against — a replica at exactly these heads replays to the identical document.

timestamp: i64

Commit timestamp (unix seconds), pinned so the change is byte-identical on origin and every replaying replica.

locus: ExecutionLocus

The action’s declared execution locus, carried so the transport can honor it.

actor: Option<Vec<u8>>

The participant that authored this action, when named — a person, an agent, or another session reached through crate::door.

These bytes become the Automerge actor the change commits under, so an edit from outside attributes in history exactly like a typed one. None is the app’s own dispatch (the ActionId-derived actor). Replay stays byte-identical either way, since the actor rides on the envelope rather than the applying replica. Optional on the wire so an envelope written before attribution existed still deserializes.

context: Option<ActionContext>

Human provenance used by history, search, and passive activity UI. It does not affect what the action is allowed to mutate; it is carried into the Automerge change message so it survives the transport log.

Implementations

impl ActionEnvelope

pub fn recorded_content(&self) -> Result<ContentParts, ActionError>

The content the change’s recorded action names (crate::executor::recorded_form): the large parts of an action over the history budget, which the committing device keeps in its content store so receivers can resolve them to replay. Empty for an action recorded whole.

Errors

A payload that is not JSON.

pub fn base_change_hashes(&self) -> Vec<ChangeHash>

The base heads as Automerge ChangeHashes.

pub fn actor(&self) -> ActorId

The actor this action’s change commits under: the authoring participant when named, else the ActionId-derived actor. Read off the envelope so a replaying replica never substitutes its own.

Trait Implementations

impl Clone for ActionEnvelope

fn clone(&self) -> ActionEnvelope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActionEnvelope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActionEnvelope

fn deserialize<__D>( __deserializer: __D, ) -> Result<ActionEnvelope, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ActionEnvelope

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ActionEnvelope

impl StructuralPartialEq for ActionEnvelope