//! SMH-SPEC-SPEC0001: concrete durable frontend backends, no wire protocol. #[cfg(test)] mod tests; use crate::runtime::RuntimeConfig; use crate::storage::StorageWorker; use smith::config::Config; use smith::error::{Result, SmithError}; use smith::id::EntryId; use smith_core::agent::TurnOutcome; use smith_core::control::{AccessMode, Admission, DurableControl, DurableExecutor, WorkReceipt}; use smith_core::store::SessionReader; use std::path::{Path, PathBuf}; use std::sync::Arc; /// Writer control sharing exactly the executor's serialized storage authority. /// Cloning control never clones a writer or starts provider work. #[derive(Clone)] pub struct WriterControl { storage: Arc, } /// Blocking executor; owning control separately keeps abort and inspection live. pub struct SessionExecutor { storage: Arc, config: RuntimeConfig, } /// Open writer authority without provider, credential, or plugin preparation. /// Unresolved roots remain inspectable and block new foreground admissions. /// /// # Errors /// Returns session-open, writer-lock, integrity, or storage faults. pub fn writer_backend(config: RuntimeConfig) -> Result<(WriterControl, SessionExecutor)> { let storage = Arc::new(StorageWorker::start(config.session_path.clone())); storage .open(Config::default_valid()) .map_err(crate::runtime::execution_access_error)?; Ok(( WriterControl { storage: Arc::clone(&storage), }, SessionExecutor { storage, config }, )) } impl DurableControl for WriterControl { fn access_mode(&self) -> AccessMode { AccessMode::Writer } fn admit(&self, text: &str, key: Option<&str>) -> Result { self.storage.admit_foreground(text, key) } fn execution_phase(&self) -> Result> { self.storage.execution_phase() } fn admit_notification( &self, root: EntryId, text: &str, key: Option<&str>, delivery: smith_core::agent::Delivery, ) -> Result { self.storage.admit_notification(root, text, key, delivery) } fn inspect(&self, id: EntryId) -> Result> { self.storage.inspect_work(id) } fn abort(&self, id: Option) -> Result { self.storage.abort(id) } } impl DurableExecutor for SessionExecutor { fn execute( &mut self, id: EntryId, observe: &mut dyn FnMut(&smith::stream::StreamEvent), ) -> Result { crate::runtime::execute_on_storage(&self.config, id, &self.storage, observe) } } /// Inspection-only backend; no runtime config, provider preparation, or file creation. pub struct ReadOnlyControl { path: PathBuf, frame_bytes_max: usize, } impl ReadOnlyControl { /// Open an existing session for inspection only. /// /// # Errors /// Rejects missing files, invalid sessions, and read failures without repairing them. pub fn open(path: &Path) -> Result { let frame_bytes_max = Config::default_valid().frame_bytes_max; SessionReader::open(path)?.validate_work(frame_bytes_max)?; Ok(Self { path: path.to_owned(), frame_bytes_max, }) } } fn read_only() -> SmithError { SmithError::Session { code: smith::error::SessionCode::SessionIncompleteContext, message: "read-only access rejects admission and work abort".into(), } } impl DurableControl for ReadOnlyControl { fn access_mode(&self) -> AccessMode { AccessMode::ReadOnly } fn admit(&self, _text: &str, _key: Option<&str>) -> Result { Err(read_only()) } fn inspect(&self, id: EntryId) -> Result> { SessionReader::open(&self.path)?.inspect_work(id, self.frame_bytes_max) } fn abort(&self, _id: Option) -> Result { Err(read_only()) } }