Struct Store 

pub struct Store { /* private fields */ }

SQLite-backed store for checkpoint blobs, runtime session state, and Lashlang artifacts.

This is the first-party local implementation of the runtime store traits. Internally it holds a single cloneable [SqliteConnection] (a tokio-rusqlite handle to one database thread).

Implementations

impl Store

pub async fn put_blob(&self, content: &[u8]) -> BlobRef

pub async fn put_artifact_blob( &self, descriptor: BlobArtifactDescriptor, content: &[u8], ) -> BlobRef

pub async fn get_blob(&self, blob_ref: &BlobRef) -> Option<Vec<u8>>

pub async fn put_typed_blob<T: Serialize>(&self, value: &T) -> BlobRef

pub async fn put_typed_artifact_blob<T: Serialize>( &self, descriptor: BlobArtifactDescriptor, value: &T, ) -> BlobRef

pub async fn get_typed_blob<T: DeserializeOwned>( &self, blob_ref: &BlobRef, ) -> Option<T>

pub async fn put_checkpoint( &self, checkpoint: &HydratedSessionCheckpoint, ) -> StoredSessionCheckpoint

pub async fn get_checkpoint( &self, blob_ref: &BlobRef, ) -> Option<HydratedSessionCheckpoint>

pub async fn append_usage_deltas(&self, entries: &[TokenLedgerEntry])

pub async fn load_usage_deltas(&self) -> Vec<TokenLedgerEntry>

impl Store

pub async fn replace_session_graph(&self, graph: &SessionGraph)

pub async fn append_session_graph_nodes(&self, nodes: &[SessionNodeRecord])

pub async fn load_session_graph(&self) -> SessionGraph

pub async fn gc_unreachable(&self) -> GcReport

impl Store

pub async fn open(path: &Path) -> Result<Self>

pub async fn open_with_options( path: &Path, options: StoreOptions, ) -> Result<Self>

pub async fn open_readonly(path: &Path) -> Result<Self>

Open the local database read-only. Used by export/resume call sites that must never mutate the source.

pub async fn load_picker_info(&self) -> Option<SessionPickerInfo>

pub async fn memory() -> Result<Self>

pub async fn memory_with_options(options: StoreOptions) -> Result<Self>

pub async fn save_session_head_meta(&self, meta: SessionHeadMeta)

pub async fn load_session_head_meta(&self) -> Option<SessionHeadMeta>

pub async fn save_session_head(&self, head: SessionHead)

pub async fn load_session_head(&self) -> Option<SessionHead>

pub async fn head_copy_from_store(&self, source: &Store)

pub async fn save_session_meta(&self, meta: SessionMeta)

pub async fn load_session_meta(&self) -> Option<SessionMeta>

Trait Implementations

impl AttachmentManifest for Store

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(&self, attachment_id: &AttachmentId) -> Result<(), StoreError>

Remove a manifest row entirely. Called by the GC coordinator after the corresponding bytes have been removed from the backing AttachmentStore.

impl LashlangArtifactStore for Store

fn durability_tier(&self) -> DurabilityTier

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

fn put_module_artifact<'life0, 'life1, 'async_trait>( &'life0 self, artifact: &'life1 ModuleArtifact, ) -> Pin<Box<dyn Future<Output = Result<(), ArtifactStoreError>> + Send + 'async_trait>>

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

fn get_module_artifact<'life0, 'life1, 'async_trait>( &'life0 self, module_ref: &'life1 ModuleRef, ) -> Pin<Box<dyn Future<Output = Result<Option<Arc<ModuleArtifact>>, ArtifactStoreError>> + Send + 'async_trait>>

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

fn put_artifact_bytes<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, artifact_ref: &'life1 str, descriptor: &'life2 str, bytes: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), ArtifactStoreError>> + Send + 'async_trait>>

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

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

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

impl ProcessExecutionEnvStore for Store

fn durability_tier(&self) -> DurabilityTier

fn put_process_execution_env<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, env_ref: &'life1 ProcessExecutionEnvRef, bytes: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), PluginError>> + Send + 'async_trait>>

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

fn get_process_execution_env<'life0, 'life1, 'async_trait>( &'life0 self, env_ref: &'life1 ProcessExecutionEnvRef, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, PluginError>> + Send + 'async_trait>>

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

impl QueuedWorkStore for Store

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

where Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Store

fn durability_tier(&self) -> DurabilityTier

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

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

where Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait,

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

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

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

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

impl SessionExecutionLeaseStore for Store

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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Release a session execution lease fenced by its completion token.

impl StoreMaintenance for Store

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait,

Delete blobs no longer reachable from any retained root.

impl TurnInputStore for Store

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

where Self: 'async_trait, 'life0: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: '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 Self: 'async_trait, 'life0: 'async_trait, 'life1: '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.