Struct InMemoryRuntimeStore 

pub struct InMemoryRuntimeStore { /* private fields */ }

In-memory runtime store. Thread-safe via tokio::sync::Mutex.

Implementations

impl InMemoryRuntimeStore

pub fn new() -> Self

Trait Implementations

impl Clone for InMemoryRuntimeStore

fn clone(&self) -> InMemoryRuntimeStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InMemoryRuntimeStore

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

Formats the value using the given formatter.

impl Default for InMemoryRuntimeStore

fn default() -> Self

Returns the “default value” for a type.

impl RuntimeStore for InMemoryRuntimeStore

fn supports_compaction_projection_outbox(&self) -> bool

Whether RuntimeStore::atomic_apply durably records typed compaction projection intents in the same boundary as the session rewrite. Unknown/custom stores fail closed by default.

fn persist_auth_oauth_flow_snapshot( &self, snapshot_json: &[u8], ) -> Result<(), RuntimeStoreError>

Persist the runtime-owned OAuth login-flow payload snapshot.

fn load_auth_oauth_flow_snapshot( &self, ) -> Result<Option<Vec<u8>>, RuntimeStoreError>

Load the runtime-owned OAuth login-flow payload snapshot, if present.

fn update_auth_oauth_flow_snapshot( &self, update: &mut AuthOAuthFlowSnapshotUpdate<'_>, ) -> Result<(), RuntimeStoreError>

Atomically update the runtime-owned OAuth login-flow payload snapshot.

fn commit_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Atomically persist a session snapshot that is not a run boundary.

fn commit_session_transcript_rewrite_snapshot<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, commit: &'life2 TranscriptRewriteCommit, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically persist a same-session transcript rewrite snapshot.

fn atomic_apply<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: Option<SessionDelta>, receipt: RunBoundaryReceipt, input_updates: Vec<InputStatePersistenceRecord>, session_store_key: Option<SessionId>, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Atomically persist session delta + receipt + input state updates.

fn load_pending_compaction_projections<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<CompactionProjectionIntent>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load exact compaction projection intents committed by atomic_apply but not yet acknowledged as finalized by the memory store.

fn mark_compaction_projection_finalized<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, projection: &'life2 CompactionProjectionId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Idempotently acknowledge post-commit memory finalization.

fn atomic_apply_with_machine_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: SessionDelta, receipt: RunBoundaryReceipt, machine_lifecycle: MachineLifecycleCommit, input_updates: Vec<InputStatePersistenceRecord>, session_store_key: SessionId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Atomically persist a failed-but-applied runtime turn.

fn load_input_states<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Vec<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load all input states for a runtime.

fn load_boundary_receipt<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, run_id: &'life2 RunId, sequence: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<RunBoundaryReceipt>, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a specific boundary receipt.

fn load_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load the latest committed session snapshot for a runtime, if any.

fn clear_session_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Remove the latest committed session snapshot for a runtime.

fn replace_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_current: &'life2 [u8], replacement: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Replace the latest committed session snapshot only if it still matches expected_current.

fn clear_session_snapshot_if_current<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_current: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Remove the latest committed session snapshot only if it still matches expected_current.

fn is_runtime_projection_quarantined<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

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

Report whether the runtime-projection fallback for runtime_id is quarantined.

fn persist_input_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, state: &'life2 InputStatePersistenceRecord, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persist a single input state (for durable-before-ack).

fn persist_input_states_atomically<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, records: &'life2 [InputStatePersistenceRecord], ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically persist a batch of machine-authorized input shell updates. Used by per-input terminal outboxes so an N-input batch can never expose a mixed provisional/finalized or finalized/published phase.

fn compare_and_swap_input_states_atomically<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected: &'life2 [StoredInputState], replacements: &'life3 [InputStatePersistenceRecord], ) -> Pin<Box<dyn Future<Output = Result<InputStateBatchCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically replace an exact set of input-state rows only when every currently persisted row is byte-identical to its expected StoredInputState serialization.

fn compare_and_swap_input_states_atomically_with_fence<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected: &'life2 [StoredInputState], replacements: &'life3 [InputStatePersistenceRecord], write_fence: Arc<dyn RuntimeStoreWriteFence>, ) -> Pin<Box<dyn Future<Output = Result<FencedInputStateBatchCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically replace an exact input-state batch while an external authority fence is held across the target write.

fn load_input_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, input_id: &'life2 InputId, ) -> Pin<Box<dyn Future<Output = Result<Option<StoredInputState>, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a single input state.

fn observe_machine_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<MachineLifecycleObservation, RuntimeStoreError>> + Send + 'async_trait>>

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

Observe one physical machine-lifecycle row without collapsing corrupt or future-version bytes into absence.

fn compare_and_swap_machine_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected: MachineLifecycleExpectedVersion, replacement: MachineLifecycleCommit, ) -> Pin<Box<dyn Future<Output = Result<MachineLifecycleCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

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

Replace exactly one machine-lifecycle row when it is absent or still has the observed raw-content version.

fn compare_and_swap_machine_lifecycle_with_fence<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected: MachineLifecycleExpectedVersion, replacement: MachineLifecycleCommit, write_fence: Arc<dyn RuntimeStoreWriteFence>, ) -> Pin<Box<dyn Future<Output = Result<FencedMachineLifecycleCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

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

Replace exactly one lifecycle row while an external authority fence is held across the target write.

fn load_machine_lifecycle_record<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load the last persisted machine lifecycle record bytes, if any.

fn commit_machine_lifecycle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, commit: MachineLifecycleCommit, input_states: &'life2 [InputStatePersistenceRecord], ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically commit machine-owned lifecycle state changes.

fn commit_unregister_finalization<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, finalization: UnregisterFinalizationCommit, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Atomically publish final unregister lifecycle truth and retire the matching ops-lifecycle epoch.

fn persist_ops_lifecycle<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, snapshot: &'life2 PersistedOpsSnapshot, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persist a snapshot of the ops lifecycle registry state.

fn initialize_ops_lifecycle_if_absent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, candidate: &'life2 PersistedOpsSnapshot, ) -> Pin<Box<dyn Future<Output = Result<PersistedOpsSnapshot, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically initialize the ops lifecycle row if it is absent and return the canonical durable snapshot.

fn load_ops_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedOpsSnapshot>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load a previously persisted ops lifecycle snapshot.

fn delete_ops_lifecycle<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, ) -> Pin<Box<dyn Future<Output = Result<(), RuntimeStoreError>> + Send + 'async_trait>>

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

Delete a previously persisted ops lifecycle snapshot.

fn auth_authority_key(&self) -> Option<String>

Stable key for process-local auth/OAuth authority reuse across reopened handles for the same durable store.

fn load_mob_host_binding<'life0, 'life1, 'async_trait>( &'life0 self, mob_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load the persisted host-binding record blob for mob_id, if any.

fn list_mob_host_bindings<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Vec<u8>)>, RuntimeStoreError>> + Send + 'async_trait>>

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

List every persisted host-binding row (boot recovery).

fn put_mob_host_binding_if_absent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, mob_id: &'life1 str, record_json: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert the host-binding row for mob_id iff absent. Returns whether the row was inserted.

fn compare_and_put_mob_host_binding<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, mob_id: &'life1 str, expected_json: &'life2 [u8], next_json: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace the host-binding row for mob_id iff the stored blob equals expected_json. Returns whether the swap applied.

fn delete_mob_host_binding<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, mob_id: &'life1 str, expected_json: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete the host-binding row for mob_id iff the stored blob equals expected_json. Returns whether a row was deleted.

fn load_mob_host_revocation<'life0, 'life1, 'async_trait>( &'life0 self, mob_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load the durable receipt for an already-completed host revocation.

fn list_mob_host_revocations<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Vec<u8>)>, RuntimeStoreError>> + Send + 'async_trait>>

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

List durable host-revocation receipts for boot recovery of exact reply-loss retries. Receipts are not bindings and carry no member revival rows.

fn revoke_mob_host_binding<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, mob_id: &'life1 str, expected_binding_json: &'life2 [u8], receipt_json: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, RuntimeStoreError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically delete the expected active binding and publish its revoke receipt. Returns false when the expected binding did not match; in that case neither write is visible.