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

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

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

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<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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