Struct FrameworkComponents 

pub struct FrameworkComponents {

    pub scheduler: Scheduler,
    pub peer_state: PeerState,
    pub request_tracker: RequestTracker,
    pub inbound_dedup: InboundDedup,
    pub address_book: AddressBook,
    pub rtt_tracker: RttTracker,
    pub outbound_queue: OutboundQueue,
    pub event_source: EventSource,
    pub serialize_queue: SerializeQueue,
    pub hold_table: HoldTable,
    pub record_buffer: RecordBuffer,
    pub pending_app_events: Vec<AppEvent>,
    pub counters: HashMap<String, u64>,
    pub rng: Box<dyn RngU64Source>,
    pub any_fired_groups: HashSet<String>,
    pub deadline_match_fired: HashSet<(u64, u64)>,
    pub pending_peer_resolve_failures: Vec<(Option<PeerId>, OpRef)>,
    pub inbound_contexts: HashMap<ExecId, InboundContext>,
}

docs/ENGINE.md §3 bundle of framework primitives. Split-borrowed into each dispatch_atomic call’s RuntimeResourceRef.

Fields

scheduler: Scheduler

Sorted timer heap. Sleep/Interval/Pulse syscalls schedule entries here; Phase 4 of the poll cycle drains matured timers and re-fires their consumer ops.

peer_state: PeerState

Consolidated per-peer state: named concurrency gate, policy + health governor, and exponential backoff. Component authors reach the three sub-primitives through peer_state.{gate, governor, backoff}.

request_tracker: RequestTracker

In-flight wire-request → CommandId map + token minter.

inbound_dedup: InboundDedup

Sliding-window seen-message tracker.

address_book: AddressBook

PeerId → Address mapping.

rtt_tracker: RttTracker

Per-NodeSiteId adaptive RTT tracker driving deadline derivation for every wire round-trip the engine observes. Fed by Engine::wire_send_tracked on send + by the response path on completion.

outbound_queue: OutboundQueue

FIFO of wire envelopes ready to ship.

event_source: EventSource

Registered EventKind → ComponentTag subscriptions.

serialize_queue: SerializeQueue

Named-FIFO map for Serialize.Enqueue / Dequeue.

hold_table: HoldTable

Named-slot value buffer for Hold.Stash / Flush.

record_buffer: RecordBuffer

Per-name bounded ring buffer for Record.

pending_app_events: Vec<AppEvent>

App events pending Phase 8 emission.

counters: HashMap<String, u64>

Per-Node counters bumped by IncrMetric syscalls.

rng: Box<dyn RngU64Source>

u64 RNG source used by the RngU64 syscall.

any_fired_groups: HashSet<String>

Per-group first-arrival latch for the Any syscall. Once a group fires, subsequent arrivals are absorbed without re-firing. Cleared on snapshot restore via the framework reset.

deadline_match_fired: HashSet<(u64, u64)>

Per-(OpRef, ExecId) latch for the DeadlineMatch syscall. First invocation per execution determines the winner (then if non-empty, otherwise timeout); subsequent invocations inside the same execution are absorbed. New executions start fresh — the latch is keyed by ExecId, not just OpRef, so a DeadlineMatch op fires once per logical execution rather than once per Node lifetime.

pending_peer_resolve_failures: Vec<(Option<PeerId>, OpRef)>

Peer-resolution failures captured during wire::Send dispatch when the destination PeerId either isn’t in the AddressBook or maps to an empty address list. The engine drains this in Phase 8 and surfaces each entry as both a EngineStep::PeerResolveFailed and a bus InfraEvent::PeerResolveFailure. Per docs/ADDRESSING.md.

inbound_contexts: HashMap<ExecId, InboundContext>

Per-ExecId inbound envelope context. Populated by Engine::route_envelope when a wire envelope arrives; read by RX gates (PeerHealthGateRx, BackoffGateRx) for src-peer filtering and by wire.Send for in-chain correlation token reuse + Dapper-style elapsed-time accounting.

Implementations

impl FrameworkComponents

pub fn new() -> Self

Construct a fresh bundle.

Trait Implementations

impl Default for FrameworkComponents

fn default() -> Self

Returns the “default value” for a type.