Trait RuntimeStore 

pub trait RuntimeStore: Send + Sync {
    // Required methods
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;
    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;

    // Provided methods
    fn session_persistence_profile(&self) -> RuntimeSessionPersistenceProfile { ... }
    fn session_boundary_authority_read_cost(
        &self,
    ) -> RuntimeSessionAuthorityReadCost { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    fn supports_compaction_projection_outbox(&self) -> bool { ... }
    fn auth_authority_key(&self) -> Option<String> { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    fn persist_auth_oauth_flow_snapshot(
        &self,
        snapshot_json: &[u8],
    ) -> Result<(), RuntimeStoreError> { ... }
    fn load_auth_oauth_flow_snapshot(
        &self,
    ) -> Result<Option<Vec<u8>>, RuntimeStoreError> { ... }
    fn update_auth_oauth_flow_snapshot(
        &self,
        _update: &mut AuthOAuthFlowSnapshotUpdate<'_>,
    ) -> Result<(), RuntimeStoreError> { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    fn persist_input_states_atomically<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        _runtime_id: &'life1 LogicalRuntimeId,
        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 { ... }
    fn input_state_batch_cas_implementation_profile(
        &self,
    ) -> InputStateBatchCasImplementationProfile { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
    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 { ... }
}

Required Methods

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.

Session-control snapshots update durable session authority without producing a RunBoundaryReceipt.

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.

Implementations compare the exact current authority with boundary.expected_authority() and write the already-materialized successor bytes once. If the exact successor authority is already current, return it without another physical write. Any other current authority conflicts. Stores must not decode the Session or reconstruct rewrite semantics; those proofs are sealed before this mechanical CAS. Exact successor compaction intents must match already-committed, non-finalized outbox rows inside the same lock or transaction.

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.

All writes MUST commit in a single atomic operation. If session_store_key is Some, validates that the snapshot belongs to that session and, for stores that physically share a SessionStore table, writes that table in the same transaction. Runtime snapshot authority remains keyed only by runtime_id; session_store_key must not create a raw session UUID runtime alias. Compaction intents must be inserted as pending outbox rows in this same boundary. An intent whose exact outbox identity is already finalized is a stale snapshot replay and must be rejected without mutating any part of the boundary.

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.

A row whose persisted bytes no longer decode under this binary’s contract is surfaced as InputStateRow::Corrupt instead of failing the whole load: one damaged row must not make every other durable input unreadable. The store never drops or rewrites the damaged row; the caller owns the per-row skip/fail policy (RuntimeStore::load_input_states_strict is the fail-on-any projection).

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<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.

Compatibility-only. A head-canonical implementation must return RuntimeStoreError::SessionPersistenceAuthorityConflict once a canonical authority row exists; returning a frozen migration BLOB would resurrect its predecessor as current truth.

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.

This is used only as a fail-closed quarantine path when transcript rewrite audit failure makes the runtime snapshot itself invalid recovery authority and the service cannot restore the previous snapshot. An ordinary downstream compatibility-projection failure must retain the already-committed runtime snapshot for retry. Head-canonical stores must refuse this whole-document mutation.

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.

Used by fail-closed recovery when a rejected transcript-rewrite snapshot must be restored to its prior audited value. Implementations must compare and write atomically so recovery cannot overwrite newer runtime authority. Head-canonical stores must refuse this whole-document mutation.

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.

This is the conditional variant of the fail-closed quarantine path. Head-canonical stores must refuse this whole-document mutation.

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 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_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.

Implementations return only the opaque bytes previously obtained from MachineLifecycleCommit::store_record. The runtime crate decodes these bytes through load_runtime_state or internal recovery helpers; stores must not promote compatibility rows or bare runtime states into lifecycle authority.

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.

Writes runtime state, generated runtime binding facts, and all input state updates in a single atomic operation. MachineLifecycleCommit has no public constructor, so this cannot be used by compatibility callers to pick runtime truth. If a runtime session catalog entry exists, its runtime-state projection must advance to MachineLifecycleCommit::runtime_state in the same operation.

Provided Methods

fn session_persistence_profile(&self) -> RuntimeSessionPersistenceProfile

Durable session representation owned by this store.

Every backend carrier must choose explicitly. WholeBlobV1 materializes and writes the accumulated session document at each boundary, so its ordinary persistence cost is O(document). HeadCanonicalV1 commits the prepared head/suffix mutation and small runtime authority incrementally. Every profile must implement [RuntimeSessionAuthorityOps::commit_prepared_session_boundary] directly; there is no checkpoint-derived or whole-blob compatibility bridge.

fn session_boundary_authority_read_cost( &self, ) -> RuntimeSessionAuthorityReadCost

Declared cost of Self::load_session_boundary_authority.

The carrier default is deliberately unsupported. Backends opt in only after maintaining authority separately from the document body.

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.

Every backend carrier must override this operation. Only the backend can allocate the next physical revision and atomically bind it to the exact body/head, catalog projection, receipts, input rows, and lifecycle effects. A generic implementation cannot honestly mint store-issued authority.

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.

Implementations may expose this only as a bounded authority-row read. There is intentionally no default fallback through Self::load_session_snapshot: callers poll this seam during reconciliation, so parsing a WholeBlob body here would turn degraded operation into an invisible O(document) loop.

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.

This is the source for resume/rewrite payload verification. Polling callers must use Self::load_whole_blob_store_authority instead.

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.

Implementations compare only WholeBlobStoreAuthority. They must not derive currentness from Session checkpoint metadata or reread/compare a whole document.

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.

Only a backend that atomically owns runtime authority and canonical session rows can implement this. The default refuses instead of accepting caller-supplied session/head facts.

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.

The row token in each opaque result lets a supported-floor missing conversation digest be enriched in the same transaction as recovery.

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.

Only a backend that owns runtime authority and the physical session head in one atomic resource may implement this. The generic WholeBlob profile has no way to recheck an external SessionStore row and therefore refuses rather than presenting a partial commit as converged recovery.

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 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_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.

expected_revision = None means the authority row must be absent. Stores enforce only exact CAS, row uniqueness, and atomicity; the generated machine decides sequence allocation and application order.

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.

The AuthMachine owns admission/consume semantics; this payload snapshot carries the PKCE verifier and device-code correlation data needed to rehydrate active flows after a persistent runtime process restart.

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.

Stores that support OAuth snapshots must override this with a lock, transaction, or compare-and-swap boundary. A load/compute/persist fallback is not safe for admission, capacity, or consume claims.

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.

The acknowledgement and removal of this exact intent from the authoritative persisted session snapshot MUST occur in one atomic boundary. The finalized outbox row remains as a tombstone so later snapshot writes can reject stale metadata replay.

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.

This is the machine-terminal counterpart to Self::atomic_apply: the mutated session snapshot, boundary receipt, generated machine lifecycle record, and input/outbox state must become visible in one transaction. Implementations must never compose this from separate atomic_apply and commit_machine_lifecycle calls.

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_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.

Recovery reads these to (a) derive the next boundary sequence for a recovered commit (an interrupted tool loop can already have committed BoundaryContinue receipts before losing only its final boundary) and (b) recover the exact contributing input identities the run already bound durably. The default probes ascending sequences through RuntimeStore::load_boundary_receipt; backends with range reads should override it.

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.

Each row digest is a target-local compare token: recovery carries it back on fenced InputStatePersistenceRecords. The snapshot’s set token additionally fences inserts, removals, and terminality changes, including the empty-set case where there are no per-row tokens to CAS.

Implementations that apply recovery MUST recompute the snapshot from the same complete, runtime-scoped nonterminal index/set inside the transaction that writes the boundary. A different set token fails the whole boundary with RuntimeStoreError::RecoveryInputSetConflict; implementations MUST also enforce every InputStatePersistenceRecord::expected_row_digest in that transaction, failing with RuntimeStoreError::InputRowVersionConflict on mismatch.

There is deliberately no compatibility derivation from decoded rows: reserializing a bundle proves only the current serializer’s canonical representation, not the exact bytes the backend observed and will CAS. A backend must override this method only when it can return and enforce tokens for its actual stored-row representation. Wrappers and custom stores that cannot do so fail closed, and durable-tail recovery maps this typed absence of fencing capability to Unfenceable.

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.

This is a durable single-owner fact: when clear_session_snapshot_if_current matches and DELETEs a rejected runtime snapshot, the same atomic boundary records the quarantine marker. A subsequent live snapshot write clears it. Recovery reads this to decide whether a store-only projection may stand in for an absent runtime snapshot. The default is fail-safe (false): stores that cannot record the marker durably never claim a snapshot is quarantined.

fn persist_input_states_atomically<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _runtime_id: &'life1 LogicalRuntimeId, 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 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 input_state_batch_cas_implementation_profile( &self, ) -> InputStateBatchCasImplementationProfile

Durable realization profile for Self::compare_and_swap_input_states_atomically.

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.

Expected and replacement batches must contain the same unique keys and at most MAX_INPUT_STATE_BATCH_CAS rows. If every current row already equals its replacement, implementations return InputStateBatchCasOutcome::Swapped without rewriting it; this makes a committed store-first transaction retryable after caller cancellation or acknowledgement loss. Missing rows, mixed expected/replacement images, and any other changed durable rows return InputStateBatchCasOutcome::Stale without writing a replacement. Implementations must hold one lock/transaction across the complete comparison and write set. Replacement 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_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.

Implementations must compare the target rows first, then retain both the target transaction and the external authority guard until every replacement is committed. This is the cold-registration recovery seam: a process whose lease expires or is superseded must never overwrite input work recovered by its successor.

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.

Unlike ordinary bounded input CAS, this seam has no total-row cap and MUST compare expected_revision even when replacements is empty. The empty case is the absence-fence path: a concurrent first insert must make it stale. Each replacement additionally carries the exact predecessor-row digest returned in Self::load_input_states_with_versions.

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.

Implementations MUST execute the external fence even for an empty replacement set, after comparing the store-owned revision and before committing. This prevents a zero-row bootstrap from bypassing either the absence witness or its runtime-authority lease.

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.

Implementations MUST maintain a unique (runtime_id, key) -> input_id mapping atomically with every input-row insert, update, and delete. Presence and absence are authoritative only when the store proves, in the same backend snapshot as the keyed lookup, that every source row for the runtime has an unambiguous indexable key identity. A corrupt or otherwise unindexable row must return RuntimeStoreError::InputIdempotencyIndexUncertain for both hits and misses; it must never be treated as absence or ignored behind another indexed owner. A full input-history scan is not a conforming implementation. The returned digest binds the exact stored row bytes observed with the index lookup.

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.

Results have exactly the request’s cardinality and order; a missing key occupies its corresponding None slot. Duplicate keys and batches larger than MAX_INPUT_STATE_BATCH_CAS are rejected. Implementations must perform one bounded backend read rather than repeatedly materializing a whole-blob ledger.

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.

Results are strictly ordered by InputId, contain only ids greater than the stable exclusive after cursor, and contain at most limit entries. Implementations must maintain a store-owned index transactionally with input-state writes; scanning or decoding the accumulated input ledger inside this method violates the contract.

The result is discovery only. Callers must hydrate and validate each owner’s exact declared recipient batch through Self::load_input_states_by_ids.

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.

This is the recovery/reconciliation read surface. Custom stores must implement it explicitly; the default is capability-unavailable rather than inferring a total observation from the older strict decoder.

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.

Built-in stores atomically compare the raw-content version and publish the machine-authorized replacement. Binding, generation, fence, and run atoms belong to the dead process that wrote the observed row; they are not durable high-waters and may be cleared by an exact-version cold-normalization CAS. The caller retains the prior raw digest for output-only diagnostics. Conflicts are ordinary level-triggered re-observation; unsupported or malformed bytes return RuntimeStoreError::MachineLifecycleRepairBlocked.

When a runtime session catalog entry already exists, an applied CAS must advance its runtime-state projection in the same atomic operation.

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.

This is the conditional-registration store seam. Built-in stores call write_fence inside the row lock/transaction after the exact raw-row comparison and immediately before publication. Custom stores must opt in explicitly; the default is capability-unavailable rather than an unfenced fallback to compare_and_swap_machine_lifecycle. An applied fence must also advance an existing runtime session catalog entry to the replacement state in that same operation. This includes an already-exact lifecycle row: the applied fence heals a stale catalog projection before returning FencedMachineLifecycleCasOutcome::AlreadyExact.

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.

The lifecycle record, input-state updates, and ops snapshot deletion MUST commit in one store transaction (or one indivisible in-memory critical section). A terminal lifecycle record with the old ops epoch still present is forbidden: recovery would otherwise resurrect stale operation/cursor authority after unregister. The commit also carries the exact retired ops epoch; implementations MUST atomically retain a durable deletion-wins fence for it, and every later persist_ops_lifecycle for that epoch must return RuntimeStoreError::OpsLifecycleEpochRetired rather than recreate the row. Implementations must also be idempotent so retry after a process crash following commit converges on the same terminal lifecycle with no ops snapshot and the same epoch fence.

Ok(()) means the whole finalization is visible. Every error except RuntimeStoreError::UnregisterFinalizationOutcomeUnknown MUST mean none of it is visible. A backend with an ambiguous commit acknowledgement must first resolve that ambiguity internally by reading its transaction authority. It may use the typed unknown error only when it cannot prove either the exact final state or the exact pre-transaction state; callers then retry without a durable rollback. The opaque token also proves the generated DeleteSnapshot verdict and bundles the exact lifecycle and input rows selected by the machine.

The returned future is also a cancellation boundary: after it is dropped, no mutation from that invocation may become visible later. An implementation may leave the prior pair untouched or finish the entire atomic commit before cancellation is observable, but it must not detach a background write that can cross a same-runtime-ID replacement. If a runtime session catalog entry exists, its runtime-state projection is part of this same atomic finalization and is selected from UnregisterFinalizationCommit::lifecycle_store_record.

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.

The absence check, optional insert, and canonical read MUST share one store transaction (or one indivisible in-memory critical section). Concurrent initializer calls for the same runtime must therefore all observe the same epoch: exactly one candidate may become durable and every losing caller receives that winner’s snapshot. The machine’s stable registration transaction separately spans this store call through map publication/removal; this method is not a distributed machine lease. Implementations must also reject a candidate whose epoch is already covered by the unregister deletion-wins fence.

Cancellation may leave the candidate as the canonical empty row: no bindings escape before this await completes, and the next registrar adopts the returned durable epoch. A cancelled invocation must never overwrite a row that was already present.

There is intentionally no load-then-persist default. Custom stores that support durable ops lifecycle state must implement this atomic boundary or fail closed with RuntimeStoreError::Unsupported.

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 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 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.

The blob is deliberately separate from runtime_mob_host_bindings: boot recovery must never mistake a revoke retry receipt for a live binding or revive the materialized-member rows that the revoke removed. The typed receipt and its transition witness live mob-side; this store treats it as opaque bytes.

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.

This is the durable terminal boundary for host revocation. A crash before it leaves the binding retryable; a crash after it leaves no binding/member rows to revive and an exact receipt to replay.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl RuntimeStore for InMemoryRuntimeStore