Enum EffectReplay 

pub enum EffectReplay {
    Done {
        output: Value,
        source: Option<String>,
        by: Option<Operator>,
        spend: Spend,
        declared: DeclaredOutput,
        content: Option<ContentVerdict>,
    },
    Failed {
        error: String,
        disposition: Disposition,
        spend: Spend,
        permanent: bool,
    },
    Refused {
        limit: String,
        used: String,
    },
    Denied {
        reason: String,
        action: String,
        resource: String,
    },
    Withheld {
        subject: String,
        reason: String,
    },
    Orphan {
        recovery: Recovery,
    },
}

What the journal has to say about one effect.

Variants

Done

It completed; here is what it returned, and what it cost.

The figure is recorded rather than recomputed, so a replayed run reaches the same budget verdict at the same point as the original.

Fields

output: Value

source: Option<String>

Who sent it, when the effect was an awaited inbound event.

Carried so a replayed run rebuilds the same provenance the live one had. Without it the two label the same value differently, and every taint gate downstream may reach a different verdict.

by: Option<Operator>

The operator this plane minted the awaited event for, when it did.

Read back so a wait can hold an answer to the act it names — a worklist decision’s decider must be the operator the decision was recorded under — on replay exactly as live.

spend: Spend

declared: DeclaredOutput

The trust and sensitivity the effect declared when it landed.

Read back for the same reason the spend is, and with a sharper consequence: these two are sourced from operator configuration rather than from code, so re-deriving them lets a catalogue edit relabel a value the run read months ago — with nothing diverging, because nothing about the call changed.

content: Option<ContentVerdict>

What the content rules decided when the output arrived: a refusal the step is handed again, a classification its label is joined with. Read back so no rule is evaluated on replay.

Failed

It failed, and the failure is part of history — including what that failure said about whether the call reached the outside world.

Fields

error: String

disposition: Disposition

spend: Spend

What the attempt consumed before failing.

Read back rather than recomputed so a replayed run reaches the same budget verdict at the same point — the same reason Done carries its spend.

permanent: bool

Whether the refusal was an answer no retry can change.

Read back rather than recomputed for the same reason the disposition is: the retry decision is replayed, and a replay that could not see this bit would expect a retry the live run never made.

Refused

A limit refused it before it started.

Distinct from Failed: nothing was attempted, and the run stopped because it was told to rather than because something broke.

Fields

limit: String

used: String

Denied

Policy refused it before it was attempted.

Distinct from Refused, which is a limit. Both stop the run without attempting anything, and an operator’s response to each is different: a budget is raised, a policy is argued with.

Fields

reason: String

action: String

resource: String

Withheld

The run’s authority was withdrawn at this hop, before it was announced.

Distinct from Refused: not a limit the run reached but a principal an operator withdrew, and the run pauses until the halt is lifted.

Fields

subject: String

reason: String

Orphan

It started and we do not know whether it landed.

The recorded Recovery is what decides whether re-performing it is safe. What history asked for is not here: it is on every entry rather than on this one variant, because the question what did the run do at this position is what a divergence has to answer, and a divergence can land on any of them.

Fields

recovery: Recovery

Implementations

impl EffectReplay

pub const fn spend(&self) -> Spend

What this state says the attempt cost so far.

Zero for the states that describe an attempt nobody made: a refusal, a denial and a withholding all stop a call before it starts, and an announcement with no terminal record has reported no figure yet.

Trait Implementations

impl Clone for EffectReplay

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 EffectReplay

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

Formats the value using the given formatter.

impl PartialEq for EffectReplay

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for EffectReplay