Struct Driver 

pub struct Driver<R, E> { /* private fields */ }

Mechanical loop that performs the directives the sans-I/O kernel issues.

This is a reference runtime skeleton. It drives one step synchronously — claim, execute, settle — and never heartbeats or reclaims within a step: it does not extend a lease while its executor runs (so a long-running pact’s lease can expire mid-step), and it settles by matching the retainer rather than re-claiming. It is therefore safe for pacts shorter than the lease (the lease never expires mid-step) and for single-worker use (no concurrent claimer can reclaim an expired lease mid-step). A workload that is both long-running and multi-worker should compose its own loop over the Registry contract (which includes heartbeat); the lifecycle kernel deliberately models no in-flight heartbeat.

Implementations

impl<R, E> Driver<R, E>

pub fn new( registry: R, executor: E, dockets: impl IntoIterator<Item = String>, ) -> Self

Build a driver from a registry, an executor, and docket names.

pub fn registry(&self) -> &R

Borrow the registry used by this driver.

pub fn executor(&self) -> &E

Borrow the executor used by this driver.

impl<R, E> Driver<R, E>

where R: Registry, E: Executor,

pub fn step(&mut self) -> Result<Step, DriverError<R::Error, E::Error>>

Perform one claim, execute, and settle step by driving the kernel: the kernel decides each directive; the driver performs it and feeds a notice back, deciding no lifecycle outcome itself.