Enum EngineStep 

pub enum EngineStep {
    OpCompleted {
        op_ref: OpRef,
        exec_id: ExecId,
        sites_written: Vec<NodeSiteId>,
    },
    AsyncSuspended {
        op_ref: OpRef,
        exec_id: ExecId,
        cmd_id: CommandId,
    },
    SendEnvelope(WireEnvelope),
    AppEvent {
        module_name: String,
        topic: String,
        value_bytes: Vec<u8>,
    },
    LifecycleFired {
        phase: String,
    },
    BootstrapComplete,
    WaitingOnBootstrap,
    OpFailed {
        op_ref: OpRef,
        exec_id: ExecId,
        error: OpError,
    },
    CycleBudgetExceeded {
        ops_invoked: usize,
    },
    OutboundDropped {
        count: usize,
    },
    WireDecodeFailed {
        hash: u64,
        payload_size: usize,
        detail: String,
    },
    WireReceiveFailed {
        src_peer: Option<PeerId>,
        fill_index: u32,
        actual_hash: u64,
        payload_size: usize,
        kind: WireReceiveErrorKind,
    },
    WireTimeout {
        wire_req_id: u64,
        target_site: NodeSiteId,
        started_at_ns: u64,
        parked_op: Option<CommandId>,
    },
    PeerBlocked {
        peer: PeerId,
        reason: BlockReason,
    },
    PeerDown {
        peer: PeerId,
    },
    PeerUp {
        peer: PeerId,
    },
    PeerResolveFailed {
        peer: Option<PeerId>,
        op_ref: OpRef,
        exec_id: ExecId,
    },
}

One step of work the engine performed during a poll cycle. Engine::poll returns Vec<EngineStep> capturing every event the host can observe.

Variants

OpCompleted

An Op completed successfully + wrote sites_written slots.

Fields

op_ref: OpRef

The completed Op.

exec_id: ExecId

The execution it belonged to.

sites_written: Vec<NodeSiteId>

Output sites the Op wrote.

AsyncSuspended

An Op suspended on a CommandId awaiting completion.

Fields

op_ref: OpRef

The suspended Op.

exec_id: ExecId

The execution it belonged to.

cmd_id: CommandId

The CommandId the Op returned.

SendEnvelope(WireEnvelope)

An outbound envelope is ready to ship.

AppEvent

An app-facing event was published. Carries the topic name (the function.output value name, or the AppEmit topic for mid-cycle emissions) plus the serialized value bytes. When the emitter is a Notify-style call with no payload, value_bytes is empty.

Fields

module_name: String

Module that emitted the event.

topic: String

Topic name - typically a function.output name for top-level surface, or an explicit topic for AppEmit.

value_bytes: Vec<u8>

Serialized payload - the slot value at the emission site, encoded via the type’s WireType::to_wire_bytes path. Empty for marker-only notifications.

LifecycleFired

A lifecycle phase fired. fills in the per-phase payload.

Fields

phase: String

Phase name (e.g. "Bootstrap", "PreShutdown").

BootstrapComplete

The single bootstrap FunctionCall the engine seeded at install completion drained to quiescence. Body ops fire on the same poll cycle once this step is emitted. Bootstrap is a one-shot per Node lifetime; a restored Node does not re-emit (its bootstrap pass already ran pre-snapshot).

WaitingOnBootstrap

At least one bootstrap-phase op returned DispatchResult::Async and the engine is waiting on its completion before activating body ops. The host drives the completion via the ingress and re-invokes Node::run_bootstrap.

OpFailed

An Op failed. The error is also published on the bus as InfraEvent::OpFailure.

Fields

op_ref: OpRef

The failed Op.

exec_id: ExecId

The execution it belonged to.

error: OpError

The failure detail.

CycleBudgetExceeded

cycle_op_budget was hit during a poll(). The engine yielded mid-cascade; the host should poll again to drain the remaining frontier. Emitted at most once per poll.

Fields

ops_invoked: usize

Number of op-invocations the cycle issued before yielding (== cycle_op_budget).

OutboundDropped

max_outbound_queue was hit since the previous poll; count envelopes were FIFO-dropped to make room. Emitted at most once per poll.

Fields

count: usize

Number of envelopes dropped since the last poll.

WireDecodeFailed

An inbound wire envelope’s payload could not be decoded. The envelope’s slot fill was dropped; this step lets the host observe the drop. Carries the same context as the matching InfraEvent::WireDecodeFailure on the bus.

Fields

hash: u64

Wire-type hash the envelope advertised (0 if the failure occurred before the hash could be read).

payload_size: usize

Length of the offending payload, in bytes.

detail: String

Human-readable failure detail.

WireReceiveFailed

An inbound wire fill failed the typed-decode step. Mirrors the bus’s crate::bus::InfraEvent::WireReceiveError so the host poll() caller observes the per-fill failure without subscribing to the bus. Other fills in the same envelope still deliver (partial-delivery semantics).

Fields

src_peer: Option<PeerId>

Sender of the failing envelope, if known.

fill_index: u32

Position of the failing fill within the envelope (0-based).

actual_hash: u64

The type_hash the sender stamped on the fill.

payload_size: usize

Length of the offending payload, in bytes.

kind: WireReceiveErrorKind

Which failure mode fired.

WireTimeout

A registered in-flight request entry was evicted by the engine’s per-poll RequestTracker::drain_stale sweep because its per-entry TTL elapsed without a matching response. The originator’s local DAG continuation parked behind parked_op (if Some) is failed with “chain timeout” via the same path async-suspension completions take.

Fields

wire_req_id: u64

The chain correlation token that timed out.

target_site: NodeSiteId

Destination site the request was dispatched to.

started_at_ns: u64

Engine-clock timestamp when the originating Send fired.

parked_op: Option<CommandId>

CommandId of the originator’s parked local op, if the request was registered with one.

PeerBlocked

An inbound envelope from peer was dropped by the crate::framework::PeerGovernor before any slot was written. path - the “first contact with IP” check the user flagged.

Fields

peer: PeerId

The peer whose envelope was rejected.

reason: BlockReason

Why the envelope was rejected.

PeerDown

A peer crossed below the failure threshold and is now marked down. Emitted at most once per transition.

Fields

peer: PeerId

The peer that went down.

PeerUp

A peer recovered after a failure streak.

Fields

peer: PeerId

The peer that came back up.

PeerResolveFailed

wire::Send could not resolve its destination peer’s addresses against the framework’s crate::framework::AddressBook. Either the peer is unknown, its address list is empty, or the Send op’s peer input didn’t carry a valid PeerId. The Send op produces no envelope; the host application reacts via this event. Mirrors InfraEvent::PeerResolveFailure on the bus - telemetry-tap parity with the /// PeerBlocked/PeerDown/PeerUp family.

Fields

peer: Option<PeerId>

The peer whose addresses could not be resolved. None when the Send op had no parseable peer input.

op_ref: OpRef

The Send op that failed to resolve.

exec_id: ExecId

Execution this Send belonged to.

Trait Implementations

impl Clone for EngineStep

fn clone(&self) -> EngineStep

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EngineStep

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

Formats the value using the given formatter.