Struct PersistentRuntimeDriver 

pub struct PersistentRuntimeDriver { /* private fields */ }

Persistent runtime driver — durable InputState via RuntimeStore.

Implementations

impl PersistentRuntimeDriver

pub fn new( runtime_id: LogicalRuntimeId, store: Arc<dyn RuntimeStore>, blob_store: Arc<dyn BlobStore>, ) -> Self

Create a new persistent runtime driver.

pub fn inner_ref(&self) -> &EphemeralRuntimeDriver

Get immutable reference to the inner ephemeral driver.

pub fn set_silent_comms_intents(&mut self, intents: Vec<String>)

Set the list of comms intents that should be silently accepted (delegates to inner).

pub fn is_idle(&self) -> bool

Check if the runtime is idle (delegates to inner).

pub fn is_idle_or_attached(&self) -> bool

Check if the runtime is idle or attached (delegates to inner).

pub fn attach(&mut self) -> Result<(), RuntimeStateTransitionError>

Attach an executor (Idle → Attached). Delegates to inner.

pub fn detach( &mut self, ) -> Result<Option<RuntimeState>, RuntimeStateTransitionError>

Detach an executor (Attached → Idle). Delegates to inner.

pub fn start_run( &mut self, run_id: RunId, ) -> Result<(), RuntimeStateTransitionError>

Start a new run (delegates to inner).

pub fn complete_run(&mut self) -> Result<RunId, RuntimeStateTransitionError>

Complete a run (delegates to inner).

pub fn drain_events(&mut self) -> Vec<RuntimeEventEnvelope>

Get pending events (delegates to inner).

pub fn take_wake_requested(&mut self) -> bool

Check and clear wake flag (delegates to inner).

pub fn take_process_requested(&mut self) -> bool

Check and clear immediate processing flag (delegates to inner).

pub fn dequeue_next(&mut self) -> Option<(InputId, Input)>

Dequeue next input (delegates to inner).

pub fn dequeue_by_id(&mut self, input_id: &InputId) -> Option<(InputId, Input)>

Dequeue a specific input by ID (delegates to inner).

pub fn persisted_input(&self, input_id: &InputId) -> Option<&Input>

Look up the persisted input for a given ID (delegates to inner).

pub fn has_queued_input_outside(&self, excluded: &[InputId]) -> bool

pub fn stage_input( &mut self, input_id: &InputId, run_id: &RunId, ) -> Result<(), InputLifecycleError>

Stage input (delegates to inner).

pub fn stage_batch( &mut self, input_ids: &[InputId], run_id: &RunId, ) -> Result<(), InputLifecycleError>

Stage a batch of inputs atomically (delegates to inner).

pub fn apply_input( &mut self, input_id: &InputId, run_id: &RunId, ) -> Result<(), InputLifecycleError>

Apply input (delegates to inner).

pub fn rollback_staged( &mut self, input_ids: &[InputId], ) -> Result<(), InputLifecycleError>

Roll back staged inputs (delegates to inner).

pub fn consume_inputs( &mut self, input_ids: &[InputId], run_id: &RunId, ) -> Result<(), InputLifecycleError>

Consume applied inputs without completing a runtime run.

pub async fn abandon_pending_inputs( &mut self, reason: InputAbandonReason, ) -> Result<usize, RuntimeDriverError>

pub async fn recycle_preserving_work( &mut self, ) -> Result<usize, RuntimeDriverError>

Recycle the in-memory driver shell while preserving canonical pending work from durable runtime truth.

Unlike reset(), this must not abandon queued/staged work.

Trait Implementations

impl RuntimeDriver for PersistentRuntimeDriver

fn accept_input<'life0, 'async_trait>( &'life0 mut self, input: Input, ) -> Pin<Box<dyn Future<Output = Result<AcceptOutcome, RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Accept an input into the runtime.

fn on_runtime_event<'life0, 'async_trait>( &'life0 mut self, event: RuntimeEventEnvelope, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle a runtime event (from the event bus).

fn on_run_event<'life0, 'async_trait>( &'life0 mut self, event: RunEvent, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle a run event (from core).

fn on_runtime_control<'life0, 'async_trait>( &'life0 mut self, command: RuntimeControlCommand, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handle a runtime control command.

fn recover<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<RecoveryReport, RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Recover from a crash/restart.

fn retire<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<RetireReport, RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retire the runtime (no new input, abandon pending).

fn reset<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<ResetReport, RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reset the runtime (abandon all pending input, drain queue).

fn destroy<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<DestroyReport, RuntimeDriverError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Destroy the runtime (terminal state, abandon all pending input).

fn runtime_state(&self) -> RuntimeState

Get the current runtime state.

fn input_state(&self, input_id: &InputId) -> Option<&InputState>

Get the state of a specific input.

fn active_input_ids(&self) -> Vec<InputId>

List all non-terminal input IDs.