Struct Store 

pub struct Store { /* private fields */ }

SQLite-backed store for checkpoint blobs and the canonical session head.

The struct name and every public method match lash_sqlite_store::Store exactly so consumers swap backends with a path rename. Internally it holds a single cloneable [SqliteConnection] (a tokio-rusqlite handle to one database thread) rather than the prior store’s tokio::sync::Mutex<rusqlite::Connection>.

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,

impl RuntimePersistence 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 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,

fn claim_ready_queued_work<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, owner_id: &'life2 str, 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,

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,

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,

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,

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

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,

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,

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,

fn claim_ready_queued_work_by_batch_ids<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, session_id: &'life1 str, owner_id: &'life2 str, boundary: QueuedWorkClaimBoundary, lease_ttl_ms: u64, batch_ids: &'life3 [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, Self: 'async_trait,

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