Enum KernelEvent 

#[non_exhaustive]
pub enum KernelEvent {
    ActionExecuted {
        instance: InstanceId,
        action_type: TypeCode,
        at: Tick,
    },
    ActionFailed {
        instance: InstanceId,
        action_type: TypeCode,
        reason: Bytes,
    },
    EffectFailed {
        instance: InstanceId,
        reason: Bytes,
    },
    ObserverPanic {
        observer_index: u16,
    },
    ObserverEvicted {
        observer_index: u16,
        panic_at_seq: u64,
        panic_count_before_eviction: u32,
    },
    SignalDropped {
        target: InstanceId,
        route: RouteId,
        reason: SignalDropReason,
    },
    ModuleForceUnloaded {
        route_id: RouteId,
        live_refs_at_unload: u32,
    },
    ActionDeferredToNextTick {
        action_id: ScheduledActionId,
        reason: DeferReason,
    },
    ObserversFlushed {
        barrier_ticket: u64,
        event_count: u32,
    },
    DomainEventEmitted {
        instance: InstanceId,
        actor: Option<EntityId>,
        event_type_code: TypeCode,
        bytes: Bytes,
    },
}

Top-level kernel-emitted event. Routed through observer filters and recorded in WAL (chunks 3b/c+).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

ActionExecuted

An action completed dispatch successfully.

Fields

instance: InstanceId

Instance where the action ran.

action_type: TypeCode

Type code of the executed action.

at: Tick

Tick at which step() processed the action.

ActionFailed

Action compute() failed (panic or error). reason is opaque bytes.

Fields

instance: InstanceId

Instance where the action was attempted.

action_type: TypeCode

Type code of the failing action.

reason: Bytes

Opaque failure reason — kernel does not interpret.

EffectFailed

Effect application failed during dispatcher.

Fields

instance: InstanceId

Instance where the effect was being applied.

reason: Bytes

Opaque failure reason (e.g. b"budget_exceeded" from memory-budget enforcement).

ObserverPanic

Observer panicked during on_event. Bounded payload — observer_index only, no panic message (covert channel closed).

Fields

observer_index: u16

Index of the panicking observer in the registry.

ObserverEvicted

First-panic eviction (A22).

Fields

observer_index: u16

Index of the evicted observer.

panic_at_seq: u64

Sequence number of the event that triggered the panic.

panic_count_before_eviction: u32

Panic count before eviction (always 1 under the first-panic policy).

SignalDropped

Cross-instance signal dropped (reserved variant for the SendSignal rate-limit (deferred); constructible today for tests).

Fields

target: InstanceId

Target instance the signal was destined for.

route: RouteId

Route discriminant.

reason: SignalDropReason

Why the kernel dropped the signal.

ModuleForceUnloaded

Module force-unloaded via force_unload cap path.

Fields

route_id: RouteId

Route id whose inflight_refs were drained.

live_refs_at_unload: u32

Sum of live refs that were dropped across instances.

ActionDeferredToNextTick

Action deferred to the next tick (reserved variant).

Fields

action_id: ScheduledActionId

Id of the deferred scheduled action.

reason: DeferReason

Why the action was deferred.

ObserversFlushed

BestEffort durability barrier flushed pending observer events.

Fields

barrier_ticket: u64

Caller-supplied barrier ticket.

event_count: u32

Number of events drained at this barrier.

DomainEventEmitted

Domain Op::EmitEvent produced an event payload.

Fields

instance: InstanceId

Instance that emitted the event.

actor: Option<EntityId>

Optional originating entity.

event_type_code: TypeCode

Event type discriminant.

bytes: Bytes

Canonical bytes of the event payload.

Trait Implementations

impl Clone for KernelEvent

fn clone(&self) -> KernelEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KernelEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KernelEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for KernelEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.