Struct InMemorySessionStore 

pub struct InMemorySessionStore { /* private fields */ }

Implementations

impl InMemorySessionStore

pub fn new() -> InMemorySessionStore

pub fn with_clock(clock: Arc<dyn Clock>) -> InMemorySessionStore

Trait Implementations

impl AttachmentManifest for InMemorySessionStore

fn record_intent(&self, intent: AttachmentIntent) -> Result<(), StoreError>

fn commit_refs( &self, session_id: &str, attachment_ids: &[AttachmentId], ) -> Result<(), StoreError>

Mark a set of attachment ids as committed (i.e. now referenced by a durable session-graph commit). Backends that store commits and manifest in the same database stamp this inside the commit transaction; the trait-level method is the out-of-band entry point for hosts that want to commit an id outside the normal turn-commit flow.

fn list_uncommitted( &self, older_than_epoch_ms: u64, ) -> Result<Vec<AttachmentManifestEntry>, StoreError>

Return manifest entries whose intent has aged past older_than_epoch_ms without ever being committed. Hosts run this periodically to find orphans left by crashes between record_intent and the next turn commit.

fn forget_aged_uncommitted_intents( &self, intent_grace_cutoff_epoch_ms: u64, ) -> Result<(), StoreError>

Atomically forget every uncommitted intent whose intent_at_epoch_ms is at or before intent_grace_cutoff_epoch_ms — the crash-orphan reconciliation GC runs before it snapshots the root set.

fn forget( &self, session_id: &str, attachment_id: &AttachmentId, ) -> Result<(), StoreError>

Remove one session’s manifest row. Called by the session facade when a turn releases an attachment, and by delete_session when a whole session’s refs are dropped. The bytes themselves die later via GC once no session references them.

fn holds_ref( &self, session_id: &str, attachment_id: &AttachmentId, ) -> Result<bool, StoreError>

Whether this manifest holds a live ref — an intent or a commit — for (session_id, attachment_id).

fn has_live_ref_for_id( &self, attachment_id: &AttachmentId, intent_grace_cutoff_epoch_ms: u64, ) -> Result<bool, StoreError>

Whether this manifest currently holds a GC-live ref for attachment_id — a committed ref, or an uncommitted intent younger than intent_grace_cutoff_epoch_ms (intent_at_epoch_ms > cutoff). Aged uncommitted intents (crash orphans) do NOT count.

fn list_all_refs(&self) -> Result<Vec<AttachmentId>, StoreError>

Every live attachment ref (intent or committed) this manifest instance can see, deduplicated. For a global manifest table (Postgres) this spans all sessions; for a per-session database (SQLite) it is that session’s refs, which the factory-level AttachmentRootSet unions across every session database at sweep time. Feeds mark-and-sweep GC.

impl Default for InMemorySessionStore

fn default() -> InMemorySessionStore

Returns the “default value” for a type.

impl QueuedWorkStore for InMemorySessionStore

fn enqueue_queued_work<'life0, 'async_trait>( &'life0 self, batch: QueuedWorkBatchDraft, ) -> Pin<Box<dyn Future<Output = Result<QueuedWorkBatch, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

Persist a queued-work batch for later claiming.

fn claim_leading_ready_session_command<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim a leading ready session-command batch for owner_id.

fn claim_ready_queued_work<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, boundary: QueuedWorkClaimBoundary, lease_ttl_ms: u64, max_batches: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim the next ready turn-work group for owner_id.

fn renew_queued_work_claim<'life0, 'life1, 'async_trait>( &'life0 self, claim: &'life1 QueuedWorkClaim, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<QueuedWorkClaim, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Extend the lease on a held queued-work claim.

fn abandon_queued_work_claim<'life0, 'life1, 'async_trait>( &'life0 self, claim: &'life1 QueuedWorkClaim, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Release a held queued-work claim without completing it.

fn cancel_queued_work_batch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, batch_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkBatch>, StoreError>> + Send + 'async_trait>>

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

Remove an unclaimed queued-work batch from durable ingress.

fn list_queued_work<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueuedWorkBatch>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

List all queued-work batches for a session, including batches held by a live claim.

fn list_pending_queued_work<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<QueuedWorkBatch>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

List queued-work batches that are still pending presentation/editing.

fn claim_ready_queued_work_by_batch_ids<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, boundary: QueuedWorkClaimBoundary, lease_ttl_ms: u64, batch_ids: &'life4 [String], ) -> Pin<Box<dyn Future<Output = Result<Option<QueuedWorkClaim>, StoreError>> + Send + 'async_trait>>

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

Claim a specific ready batch set selected from the durable queue.

impl SessionCommitStore for InMemorySessionStore

fn load_session<'life0, 'async_trait>( &'life0 self, scope: SessionReadScope, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedSessionRead>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

fn load_node<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SessionNodeRecord>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

fn commit_runtime_state<'life0, 'async_trait>( &'life0 self, commit: RuntimeCommit, ) -> Pin<Box<dyn Future<Output = Result<RuntimeCommitResult, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

fn save_session_meta<'life0, 'async_trait>( &'life0 self, meta: SessionMeta, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

fn load_session_meta<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<SessionMeta>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

fn durability_tier(&self) -> DurabilityTier

Durability tier this session store provides; defaults to DurabilityTier::Inline.

impl SessionExecutionLeaseStore for InMemorySessionStore

fn try_claim_session_execution_lease<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLeaseClaimOutcome, StoreError>> + Send + 'async_trait>>

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

Try to claim the durable single-writer execution lane for session_id.

fn reclaim_session_execution_lease<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, owner: &'life2 LeaseOwnerIdentity, observed_holder: &'life3 SessionExecutionLeaseFence, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLeaseClaimOutcome, StoreError>> + Send + 'async_trait>>

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

Reclaim an unexpired session execution lease whose observed holder is definitely dead according to persisted local-process liveness metadata.

fn renew_session_execution_lease<'life0, 'life1, 'async_trait>( &'life0 self, fence: &'life1 SessionExecutionLeaseFence, lease_ttl_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<SessionExecutionLease, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Extend a live session execution lease owned by the caller.

fn release_session_execution_lease<'life0, 'life1, 'async_trait>( &'life0 self, completion: &'life1 SessionExecutionLeaseCompletion, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Release a session execution lease fenced by its completion token.

impl StoreMaintenance for InMemorySessionStore

fn tombstone_nodes<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Mark graph nodes as tombstoned so reads exclude them until vacuum physically removes them.

fn vacuum<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<VacuumReport, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

Physically delete tombstoned graph-node rows and prune terminal pending-turn-input evidence rows. See VacuumReport.

fn gc_unreachable<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GcReport, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

Delete blobs no longer reachable from any retained root.

impl TurnInputStore for InMemorySessionStore

fn enqueue_pending_turn_input<'life0, 'async_trait>( &'life0 self, draft: PendingTurnInputDraft, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInput, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, InMemorySessionStore: 'async_trait,

Persist model-visible user input into the pending turn-input lifecycle.

fn list_pending_turn_inputs<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingTurnInput>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

List pending user inputs for UI reconciliation and queue preview.

fn cancel_pending_turn_inputs<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, targets: &'life2 [PendingTurnInputCancelTarget], ) -> Pin<Box<dyn Future<Output = Result<Vec<PendingTurnInputCancelResult>, StoreError>> + Send + 'async_trait>>

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

Atomically cancel a list of pending user inputs by input id or source key.

fn cancel_pending_turn_input_suffix<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, anchor: &'life2 PendingTurnInputCancelTarget, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInputSuffixCancelOutcome, StoreError>> + Send + 'async_trait>>

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

Atomically cancel the same-session runtime-admission suffix from an anchor.

fn claim_active_turn_inputs<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, turn_id: &'life4 str, checkpoint: CheckpointKind, lease_ttl_ms: u64, max_inputs: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<TurnInputClaim>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, InMemorySessionStore: 'async_trait,

Claim active-turn input at a checkpoint for the live turn id.

fn claim_next_turn_inputs<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, session_execution_lease: &'life2 SessionExecutionLeaseFence, owner: &'life3 LeaseOwnerIdentity, lease_ttl_ms: u64, max_inputs: usize, ) -> Pin<Box<dyn Future<Output = Result<Option<TurnInputClaim>, StoreError>> + Send + 'async_trait>>

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

Claim queued next-turn input at idle.

fn abandon_turn_input_claim<'life0, 'life1, 'async_trait>( &'life0 self, claim: &'life1 TurnInputClaim, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, InMemorySessionStore: 'async_trait,

Abandon a held pending-turn-input claim so it can be reclaimed.

fn cancel_pending_turn_input<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, input_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<PendingTurnInputCancelOutcome, StoreError>> + Send + 'async_trait>>

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

Cancel an unclaimed pending user input by id.