Enum WalRecordContent 

pub enum WalRecordContent {
    Submit {
        seq: u64,
        instance: InstanceId,
        principal: Principal,
        actor: Option<EntityId>,
        caps_at_submit: u64,
        at: Tick,
        action_type_code: TypeCode,
        action_bytes: Vec<u8>,
        allocated_id: ScheduledActionId,
    },
    Step {
        seq: u64,
        instance: InstanceId,
        popped_id: ScheduledActionId,
        now: Tick,
        session_caps: u64,
        verdict: StepVerdict,
        post_state_digest: [u8; 32],
    },
}

Kind-discriminated canonical content of a WAL record. The serde variant tag is the record WalRecordKind and the first hashed body field. The CIL records only non-reproducible facts: exogenous submissions and per-step verdicts + post-state digest — every deterministic effect (child schedules, signal routing, internal ids) is re-derived on replay.

Variants

Submit

Exogenous admission of an external action — the only non-reproducible scheduling input (internal Op::ScheduleAction schedules are re-derived by re-executing the parent, never logged).

Fields

seq: u64

Monotonic record sequence within this WAL.

instance: InstanceId

Instance the action was submitted to.

principal: Principal

Principal the external caller submitted under.

actor: Option<EntityId>

Submitting entity, if any (feeds ActionContext::actor, so it is canonical input and chain-hashed).

caps_at_submit: u64

Capability ceiling granted to this submission — bounds the action’s effective caps at execution (replay reconstructs it).

at: Tick

Tick the action is scheduled for.

action_type_code: TypeCode

Type code of the submitted action.

action_bytes: Vec<u8>

Canonical action bytes (replay deserializes from these).

allocated_id: ScheduledActionId

ScheduledActionId the kernel minted — replay re-injects with this exact id so the id sequence is reproduced verbatim.

Step

One step_one pop: which entry ran, when, under what operator session ceiling, with what verdict, and the full-state digest afterward (the bit-identity witness).

Fields

seq: u64

Monotonic record sequence within this WAL.

instance: InstanceId

Instance the step ran against.

popped_id: ScheduledActionId

ScheduledActionId popped this step (scheduler-order witness).

now: Tick

Tick the step ran at.

session_caps: u64

Operator session capability ceiling in force at step time — the final intersection applied over the action’s resolved caps. It is a non-reproducible per-step operator input (like caps_at_submit is per submission), so it is recorded for the verdict to be re-derivable on replay.

verdict: StepVerdict

Step outcome — replay must re-reach this exact verdict.

post_state_digest: [u8; 32]

BLAKE3 digest of the instance’s full post-step state; replay measures the replayed instance and asserts equality (A1).

Trait Implementations

impl Clone for WalRecordContent

fn clone(&self) -> WalRecordContent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WalRecordContent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WalRecordContent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for WalRecordContent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.