Struct Append 

pub struct Append {
    pub run: RunId,
    pub case: Option<CaseId>,
    pub step: Option<StepId>,
    pub phase: Phase,
    pub effect_key: Option<EffectKey>,
    pub kind: RecordKind,
    /* private fields */
}

What the runtime hands the store. Seq, chain links, and hashing are the store’s job, because only it knows the run’s current head.

Fields

run: RunId

case: Option<CaseId>

step: Option<StepId>

phase: Phase

effect_key: Option<EffectKey>

kind: RecordKind

Implementations

impl Append

pub fn new(run: RunId, kind: RecordKind) -> Self

pub fn step(self, s: StepId) -> Self

pub fn phase(self, p: Phase) -> Self

pub fn case(self, c: CaseId) -> Self

pub fn effect(self, k: EffectKey) -> Self

pub fn from_body(body: RecordBody) -> Self

Rebuild the append that produced a body.

The inverse of the crate-private into_body, and the whole of what a restore needs: seq and epoch are supplied by the write path, and everything else travels here. Written as a function rather than left to each caller because the field list is the thing that would drift — a restore that forgot phase would replay a compensation as a forward record, and the chain would hash differently for a reason no diff shows.

Ungated, unlike into_body below: a restore reads an export rather than a store, so it is reachable in a build with no backend compiled in.

pub fn restored(record: Record) -> Self

The append that puts a verified record back exactly as it was written.

The store stores and hashes the bytes the record carries and indexes the body it reads from those bytes through its own upcaster — never the append’s fields, which a caller can change after this — so a record restored across a shape change hashes as it did in the export. A body re-sealed instead would be this build’s serialization of the lifted shape: new bytes, a new hash, and a chain that is no longer the one exported.

pub fn written(&self) -> Option<&[u8]>

The written bytes a restore carries, which a store keeps rather than re-sealing; None on every runtime write.

Trait Implementations

impl Clone for Append

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Append

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

Formats the value using the given formatter.