Struct EmbeddedKernelStore 

pub struct EmbeddedKernelStore { /* private fields */ }

Every kernel persistence port on one local store.

The engine behind it is chosen when the data directory is created and hidden behind the storage seam (historical ADR-018): SQLite for every store this binary can open. Cloning is cheap (shared engine handle). Commits are fsync-durable, so each successful port write survives kill -9; a crash mid-transaction loses only the in-flight transaction.

Implementations

impl EmbeddedKernelStore

pub async fn migrate_data_dir<F>( source_dir: &Path, destination_dir: &Path, derive: F, ) -> Result<(EmbeddedKernelStore, StoreMigrationReceipt), PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Compatibility entry point. No current layout requires migration.

pub async fn migrate_data_dir_to<F>( source_dir: &Path, destination_dir: &Path, destination_engine: StorageEngine, _derive: F, ) -> Result<(EmbeddedKernelStore, StoreMigrationReceipt), PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Compatibility entry point with an explicit destination engine.

pub async fn open_or_migrate_data_dir<F>( source_dir: &Path, destination_dir: &Path, derive: F, ) -> Result<(EmbeddedKernelStore, Option<StoreMigrationReceipt>), PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Reopen a completed destination or apply the compatibility migration.

pub async fn open_or_migrate_data_dir_to<F>( source_dir: &Path, destination_dir: &Path, destination_engine: StorageEngine, derive: F, ) -> Result<(EmbeddedKernelStore, Option<StoreMigrationReceipt>), PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Reopen a completed destination or apply the compatibility migration.

pub async fn migration_receipt( &self, ) -> Result<Option<StoreMigrationReceipt>, PortError>

A historical receipt stored by the migration that produced this store.

impl EmbeddedKernelStore

pub fn export_bundle_blocking(&self) -> Result<String, PortError>

Synchronous export for already-blocking operational paths such as Doctor. Async application paths should use Self::export_bundle.

pub async fn export_bundle(&self) -> Result<String, PortError>

Serializes the full event log as a JSON-Lines bundle: one header line followed by one event per line, in sequence order.

pub async fn export_bundle_for_abouts( &self, requested_abouts: &[String], ) -> Result<String, PortError>

Serializes only events rooted at one of requested_abouts.

Abouts are opaque routing identifiers: matching is exact, with no trimming, case folding, prefix expansion or other normalisation. The filtered stream keeps the store’s event order and each aggregate’s recorded revisions, then receives bundle-local positions starting at one. A missing requested about is refused before callers can create a destination file.

pub fn export_bundle_excluding_abouts_blocking( &self, excluded_abouts: &[String], ) -> Result<String, PortError>

Serializes every event except those rooted at one of excluded_abouts.

The mirror of Self::export_bundle_for_abouts, for the caller that knows what does not belong in a bundle rather than what does. A store holds content it did not author — a synced guide, say — and a bundle that is meant to carry authored memory has to be able to leave it out without first enumerating everything else. An excluded about that is absent is not an error: exclusion asks for a stream without something, and a store that never had it already satisfies that.

Abouts are opaque: matching is exact, with no trimming, case folding or prefix expansion.

pub async fn export_bundle_excluding_abouts( &self, excluded_abouts: &[String], ) -> Result<String, PortError>

The async form of Self::export_bundle_excluding_abouts_blocking.

pub async fn export_named_bundle( &self, snapshot_id: &str, ) -> Result<String, PortError>

Exports the same complete stream with a human-selected snapshot id. The id is metadata, not a filename: callers may store the bundle in git, an artifact store, or anywhere else without changing what it identifies.

pub async fn import_bundle<F>( &self, bundle: &str, derive: F, ) -> Result<ImportReport, PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Replays a bundle into this store. Fail-fast rules: the store must be empty (no merge semantics in v1 — ADR-011 rationale applies), the header must match supported formats, and every event must reproduce exactly the revision it was exported with.

impl EmbeddedKernelStore

pub async fn rebuild_projections<F>( &self, derive: F, ) -> Result<ProjectionRebuildReport, PortError>

where F: Fn(&ContextUpdatedEvent) -> Result<Vec<ProjectionMutation>, PortError> + Send + 'static,

Drops every projection table and rebuilds them by replaying the event log in sequence order — the recovery and migration story in one.

The mutation derivation is injected so this adapter stays free of application-layer dependencies; the composition root passes kmp_application::projection_mutations_for_context_event. The whole rebuild is one transaction: a crash mid-rebuild leaves the previous projections intact.

impl EmbeddedKernelStore

pub fn open(data_dir: &Path) -> Result<EmbeddedKernelStore, PortError>

Opens (or initializes) the store inside data_dir, applying the ADR-012 fail-fast rules before touching the engine. A fresh directory gets the default engine; an existing one opens with the engine it was created with.

pub fn open_with_engine( data_dir: &Path, engine: StorageEngine, ) -> Result<EmbeddedKernelStore, PortError>

open with the engine chosen: a fresh directory is created for SQLite, and an existing one must already be engine — a store is never reinterpreted as another engine’s.

pub fn engine_of(data_dir: &Path) -> Result<StorageEngine, PortError>

The engine a data directory was created with, without opening it.

pub async fn event_log_stats(&self) -> Result<(u64, u64), PortError>

Number of events in the append-only log and the highest sequence — audit surface used by recovery checks and operational tooling.

pub fn compact_data_dir(data_dir: &Path) -> Result<bool, PortError>

Compacts the store file in place, reclaiming free pages left by past transactions (e.g. after a projection rebuild). Requires exclusive access: call it with no other store handle open on the same data directory.

Trait Implementations

impl Clone for EmbeddedKernelStore

fn clone(&self) -> EmbeddedKernelStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ContextEventStore for EmbeddedKernelStore

async fn append( &self, event: ContextUpdatedEvent, expected_revision: u64, ) -> Result<u64, PortError>

Append an event. Fails with PortError::Conflict if expected_revision does not match the current revision for this (root_node_id, role) aggregate.

async fn current_revision( &self, root_node_id: &str, role: &str, ) -> Result<u64, PortError>

Returns the current revision for the aggregate, or 0 if no events exist.

async fn current_content_hash( &self, root_node_id: &str, role: &str, ) -> Result<Option<String>, PortError>

Returns the content hash of the last accepted event, or None if no events exist.

async fn find_by_idempotency_key( &self, key: &str, ) -> Result<Option<IdempotentOutcome>, PortError>

Checks if an event with this idempotency key was already accepted.

impl Debug for EmbeddedKernelStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl GraphNeighborhoodReader for EmbeddedKernelStore

async fn load_neighborhood( &self, root_node_id: &str, depth: u32, ) -> Result<Option<NodeNeighborhood>, PortError>

async fn load_scoped_neighborhood( &self, request: &NeighborhoodRequest, ) -> Result<Option<NodeNeighborhood>, PortError>

Loads a neighbourhood already narrowed by the axes the caller resolved.

async fn load_context_path( &self, root_node_id: &str, target_node_id: &str, subtree_depth: u32, ) -> Result<Option<ContextPathNeighborhood>, PortError>

impl MemoryAboutIndexReader for EmbeddedKernelStore

async fn list_memory_abouts(&self) -> Result<Vec<String>, PortError>

async fn list_memory_abouts_by_dimensions( &self, dimension_ids: &[String], ) -> Result<Vec<String>, PortError>

impl NodeDetailReader for EmbeddedKernelStore

async fn load_node_detail( &self, node_id: &str, ) -> Result<Option<NodeDetailProjection>, PortError>

async fn load_node_details_batch( &self, node_ids: Vec<String>, ) -> Result<Vec<Option<NodeDetailProjection>>, PortError>

impl NodeRelationshipReader for EmbeddedKernelStore

async fn load_node_relationships( &self, node_id: &str, ) -> Result<Option<NodeRelationships>, PortError>

impl ProcessedEventStore for EmbeddedKernelStore

async fn has_processed( &self, consumer_name: &str, event_id: &str, ) -> Result<bool, PortError>

async fn record_processed( &self, consumer_name: &str, event_id: &str, ) -> Result<(), PortError>

impl ProjectionCheckpointStore for EmbeddedKernelStore

async fn load_checkpoint( &self, consumer_name: &str, stream_name: &str, ) -> Result<Option<ProjectionCheckpoint>, PortError>

async fn save_checkpoint( &self, checkpoint: ProjectionCheckpoint, ) -> Result<(), PortError>

impl ProjectionWriter for EmbeddedKernelStore

async fn apply_mutations( &self, mutations: Vec<ProjectionMutation>, ) -> Result<(), PortError>

impl SnapshotStore for EmbeddedKernelStore

async fn save_bundle_with_options( &self, bundle: &KmpBundle, options: SnapshotSaveOptions, ) -> Result<(), PortError>

fn save_bundle( &self, bundle: &KmpBundle, ) -> impl Future<Output = Result<(), PortError>> + Send