Enum KernelPreparation 

pub enum KernelPreparation<Record, Step> {
    Prepared(PreparedTransition<Record, Step>),
    Replayed(ReplayedTransition<Record, Step>),
    Rejected(RejectedTransition),
}

The result of preparing one input.

Generic over the durable record and the planned step: Task 6 owns those two contracts, and this task fixes only the shape of the result — which arms exist, and what each may carry.

Variants

Prepared(PreparedTransition<Record, Step>)

A new record was built and is waiting for the host to append it and then commit the token.

Replayed(ReplayedTransition<Record, Step>)

This input maps onto a record that already exists. No new record is produced and step_seq points at the existing one.

Two triggers, one shape:

1. input-level replay — the same input_id with the same canonical payload;
2. effect-level dedup (DEC-1) — a new input_id resolving an already-completed effect with the same payload; the cancellation dedup branch behaves identically.

The second trigger is the one that used to be reported as Prepared while returning the old step_seq. A host then built a transaction whose step_seq did not increase, its CAS successor check rejected it as an integrity error, and the run died — a live dead end on the only durable host.

Rejected(RejectedTransition)

Nothing was accepted, nothing was staged, no state moved.

Implementations

impl<Record, Step> KernelPreparation<Record, Step>

pub fn record(&self) -> Option<&Record>

pub fn token(&self) -> Option<&PrepareToken>

Only a Prepared transition has something to commit.

pub fn step(&self) -> Option<&Step>

pub fn step_seq(&self) -> Option<WireU64>

The sequence of the record this preparation refers to. Prepared does not have one yet — its record is not in the journal until the host appends it.

pub fn fault(&self) -> Option<&KernelFault>

pub fn is_zero_mutation(&self) -> bool

Whether this preparation left the operation byte-identical. True for exactly the rejected arm — the type-level statement of the zero-mutation rule.

pub fn is_retryable(&self) -> bool

Whether the host may re-submit the same input_id unchanged.

Trait Implementations

impl<Record, Step> Clone for KernelPreparation<Record, Step>

where Record: Clone, Step: Clone,

fn clone(&self) -> KernelPreparation<Record, Step>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Record, Step> Debug for KernelPreparation<Record, Step>

where Record: Debug, Step: Debug,

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

Formats the value using the given formatter.

impl<'de, Record, Step> Deserialize<'de> for KernelPreparation<Record, Step>

where Record: Deserialize<'de>, Step: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Record, Step> PartialEq for KernelPreparation<Record, Step>

where Record: PartialEq, Step: PartialEq,

fn eq(&self, other: &KernelPreparation<Record, Step>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<Record, Step> Serialize for KernelPreparation<Record, Step>

where Record: Serialize, Step: Serialize,

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<Record, Step> StructuralPartialEq for KernelPreparation<Record, Step>

where Record: PartialEq, Step: PartialEq,