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 input_state_batch_cas_implementation_profile( &self, ) -> InputStateBatchCasImplementationProfile

Durable realization profile for Self::compare_and_swap_input_states_atomically.

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

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

Load the exact generated runtime-delivery authority record.

fn load_runtime_delivery_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, delivery_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RuntimeDeliveryStoreRecord>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load one durable runtime-delivery inbox row by stable identity.

fn compare_and_swap_runtime_delivery_authority<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_revision: Option<u64>, replacement: RuntimeDeliveryAuthorityRecord, inserted_delivery: Option<RuntimeDeliveryStoreRecord>, ) -> Pin<Box<dyn Future<Output = Result<RuntimeDeliveryAuthorityCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

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

Compare-and-swap generated delivery authority and optionally insert one inbox row in the same atomic boundary.

fn list_runtime_delivery_records<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, after_sequence: u64, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<RuntimeDeliveryStoreRecord>, RuntimeStoreError>> + Send + 'async_trait>>

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

List durable inbox rows in generated sequence order.

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: SerializedSessionSnapshot, ) -> 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_prepared_whole_blob_rewrite_boundary<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, boundary: PreparedWholeBlobRewriteStoreParts, ) -> Pin<Box<dyn Future<Output = Result<WholeBlobStoreAuthority, RuntimeStoreError>> + Send + 'async_trait>>

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

Commit one valid-by-construction WholeBlob transcript-rewrite boundary.

fn atomic_apply<'life0, 'life1, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, session_delta: Option<SerializedSessionSnapshot>, 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: SerializedSessionSnapshot, 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<InputStateRow>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load all input states for a runtime, one row outcome per stored row.

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_committed_boundary_receipts<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunBoundaryReceipt>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load every durably committed boundary receipt for one run, in ascending sequence order.

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

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

Load one authoritative snapshot of all and only nonterminal input-state rows, with the exact domain-prefixed SHA-256 digest of each row’s stored bytes and a set/absence token over the complete ordered set.

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

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

Load the latest committed whole-blob session snapshot for a runtime.

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. Idempotency-key ownership follows the trait’s complete-final-image contract, including valid swaps between rows in this batch.

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 compare_and_swap_recovery_input_states_atomically<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_revision: RecoveryInputSetRevision, mutations: &'life2 [RecoveryInputStateMutation], ) -> Pin<Box<dyn Future<Output = Result<InputStateBatchCasOutcome, RuntimeStoreError>> + Send + 'async_trait>>

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

Atomically publish machine-normalized recovery input rows only while the exact store-owned input-set revision observed with the source rows remains current.

fn compare_and_swap_recovery_input_states_atomically_with_fence<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, expected_revision: RecoveryInputSetRevision, mutations: &'life2 [RecoveryInputStateMutation], 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,

Revision-fenced recovery input publication while an external runtime authority fence is held across the target transaction.

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 load_input_state_by_idempotency_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, key: &'life2 IdempotencyKey, ) -> Pin<Box<dyn Future<Output = Result<Option<ExactInputStateObservation>, RuntimeStoreError>> + Send + 'async_trait>>

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

Resolve one historical or live input through the store-owned idempotency-key index.

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

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

Load an exact bounded set of input rows from one backend snapshot.

fn load_pending_terminal_owner_ids_page<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, after: Option<&'life2 InputId>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<InputId>, RuntimeStoreError>> + Send + 'async_trait>>

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

Discover canonical owner ids for unfinished terminal work.

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 session_persistence_profile(&self) -> RuntimeSessionPersistenceProfile

Durable session representation owned by this store.

fn session_boundary_authority_read_cost( &self, ) -> RuntimeSessionAuthorityReadCost

Declared cost of Self::load_session_boundary_authority.

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

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

Commit one valid-by-construction prepared session boundary.

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

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

Load the versioned session authority for a runtime.

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

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

Observe only the fixed-size store-issued WholeBlob identity.

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

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

Atomically pair the WholeBlob body with its store-issued identity.

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

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

Commit one typed WholeBlob successor only while its exact store-issued predecessor remains current.

fn delete_runtime_session_catalog_entry<'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 one exact runtime’s catalog projection.

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

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

Load one bounded, body-free runtime session catalog entry.

fn list_runtime_session_catalog_entries<'life0, 'async_trait>( &'life0 self, filter: SessionFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<RuntimeSessionCatalogEntry>, RuntimeStoreError>> + Send + 'async_trait>>

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

List body-free catalog entries in deterministic updated-descending, session-id-ascending order.

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

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

Write one typed provisional WholeBlob candidate exactly once.

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

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

Atomically load one provisional authority and its candidate body.

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

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

Discard only the exact provisional candidate named by expected.

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

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

Persist one exact HeadCanonical provisional intent before the physical SessionStore CAS it authorizes.

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

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

Load only the fixed-size HeadCanonical provisional authority.

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

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

Discard only the exact HeadCanonical provisional authority supplied.

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

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

Load one store-owned durable-tail source from a single verified authority/physical-head snapshot.

fn load_durable_tail_recovery_receipts<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, run_id: &'life2 RunId, ) -> Pin<Box<dyn Future<Output = Result<Vec<PreparedRecoveryReceiptSource>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load every exact original receipt row for one store-derived recovery candidate run, ordered by boundary sequence.

fn load_committed_recovery_boundary<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, runtime_id: &'life1 LogicalRuntimeId, candidate_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CommittedRecoveryBoundary>, RuntimeStoreError>> + Send + 'async_trait>>

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

Load the durable exact-retry witness for one recovery candidate.

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_input_states_strict<'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,

Strict projection of RuntimeStore::load_input_states: every row must decode; the first corrupt row fails the whole load with its row identity in the typed error.

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.