Struct DWBaseEngine 

pub struct DWBaseEngine<S, V, T, G, E> {
    pub storage: S,
    pub vector: V,
    pub stream: T,
    pub gatekeeper: G,
    pub embedder: E,
    pub reflex_index: ReflexIndex,
    /* private fields */
}

Orchestrator tying together engine components.

Fields

storage: S

vector: V

stream: T

gatekeeper: G

embedder: E

reflex_index: ReflexIndex

Implementations

impl<S, V, T, G, E> DWBaseEngine<S, V, T, G, E>

pub fn new(storage: S, vector: V, stream: T, gatekeeper: G, embedder: E) -> Self

pub fn with_reflex_index( storage: S, vector: V, stream: T, gatekeeper: G, embedder: E, reflex_index: ReflexIndex, ) -> Self

impl<S, V, T, G, E> DWBaseEngine<S, V, T, G, E>

where S: StorageEngine, V: VectorEngine, T: StreamEngine, G: Gatekeeper, E: Embedder,

pub fn world_archived(&self, world: &WorldKey) -> Result<bool>

pub fn worlds(&self) -> Result<Vec<WorldKey>>

List known worlds, excluding archived ones by default.

pub fn worlds_filtered(&self, include_archived: bool) -> Result<Vec<WorldKey>>

List known worlds with optional archived inclusion.

pub fn index_status(&self) -> Vec<IndexMetadata>

pub async fn remember(&self, new_atom: NewAtom) -> Result<AtomId>

Remember (persist) a new atom submitted by a worker.

pub async fn ask(&self, question: Question) -> Result<Answer>

Answer a question based on stored atoms.

pub fn list_ids_in_window( &self, world: &WorldKey, window: &TimeWindow, ) -> Result<Vec<AtomId>>

Return atom ids for a world within a time window.

pub fn storage_ready(&self) -> bool

Shallow readiness probe: returns true if storage is reachable.

pub fn max_index_rebuild_lag_ms(&self) -> Option<u64>

Maximum rebuild lag (ms) across worlds that are rebuilding or not ready.

pub fn get_atoms(&self, ids: &[AtomId]) -> Result<Vec<Atom>>

Fetch atoms by id using the underlying storage engine.

pub async fn ingest_remote_atoms(&self, atoms: Vec<Atom>) -> Result<Vec<AtomId>>

Ingest atoms received from peers; idempotent (skips existing ids).

pub fn gc_once(&self, _max_disk_mb: Option<u64>) -> Result<usize>

Run garbage collection once for all worlds. Returns number of atoms evicted.

pub async fn observe(&self, atom: Atom) -> Result<()>

Observe (ingest) an atom and publish it to streams.

pub async fn replay( &self, world: WorldKey, filter: AtomFilter, ) -> Result<Vec<Atom>>

Replay atoms for a world using a filter.

pub async fn manage_world(&self, action: WorldAction) -> Result<()>

Perform a world-level action (create/archive/resume).