Struct TransitionState 

pub struct TransitionState {
    pub lifecycle: OperationLifecycle,
    pub resolved_config: ResolvedOperationConfig,
    pub root_kind: Option<RootKind>,
    pub focus: Option<ExecutionFocus>,
    pub last_observed_at_ms: WireU64,
    pub pending_effects: Vec<KernelEffect>,
    pub resolved_effects: Vec<ResolvedEffectState>,
    pub launch_tokens: Vec<LaunchTokenState>,
    pub accepted_inputs: Vec<AcceptedInputState>,
    pub accepted_cancellation: Option<AcceptedCancellationState>,
    pub terminal: Option<KernelTerminal>,
}

§12.1 · operation lifecycle, execution focus, the effect ledger, input replay, cancellation and the terminal.

The step sequence is deliberately not here: the checkpoint header already states base_step_seq and through_step_seq, and §12.1’s “the header must not duplicate sub-state” cuts both ways.

Fields

lifecycle: OperationLifecycle

resolved_config: ResolvedOperationConfig

The configuration the genesis record froze (§8.1, §15.2 item 8).

Here rather than “read it off the genesis record”, because §12.3 rule 6 lets an acked checkpoint reclaim the journal prefix including genesis: after that, the checkpoint is the only place the resolved configuration still exists, and every later step is planned against it. genesis_digest in the header keeps binding the identity; this carries the content.

root_kind: Option<RootKind>

Immutable after the root start commits (§6.1.5).

focus: Option<ExecutionFocus>

Where control is (§7.4). Moves only on a committed transition, so a checkpoint states it rather than deriving it.

last_observed_at_ms: WireU64

The operation’s only clock fact (§11.2): the newest accepted observed_at_ms. A restore must not accept an input that precedes it.

pending_effects: Vec<KernelEffect>

Effects published by committed records and not yet resolved. The home of pending effects — no other partition, and not the header.

resolved_effects: Vec<ResolvedEffectState>

Effects already answered, with the digest of the outcome that answered them. This is what makes a redelivered ResolveEffect a Replayed instead of a second record (DEC-1).

launch_tokens: Vec<LaunchTokenState>

Launch tokens the kernel minted with a SpawnTasks effect. Effect-resolution bookkeeping, not task state — the task table lives in SchedulerState.

accepted_inputs: Vec<AcceptedInputState>

§12.3 rule 7 · the input replay/dedupe ledger. An ack must never empty it: it is what turns a redelivery into an idempotent answer instead of a second durable record.

accepted_cancellation: Option<AcceptedCancellationState>

The cancellation this operation already accepted, so a retry of it is answered rather than refused by the terminal it created.

terminal: Option<KernelTerminal>

The committed terminal. The home of the terminal.

Trait Implementations

impl Clone for TransitionState

fn clone(&self) -> TransitionState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransitionState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransitionState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TransitionState

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TransitionState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TransitionState