Struct CellServer 

pub struct CellServer {
    pub registry: Arc<StoreRegistry>,
    pub handler_registry: Arc<HandlerRegistry>,
    pub relationship_manager: Arc<RelationshipManager>,
    pub postgres_producer: Option<PostgresProducerHandle>,
    pub search_index: Arc<SearchIndex>,
    pub persisters: Arc<PersisterRouter>,
    pub host_id: Uuid,
    /* private fields */
}

Cell-based Myko server.

Uses hyphae cells for reactive queries and reports instead of actors.

Fields

registry: Arc<StoreRegistry>

Central entity store registry

handler_registry: Arc<HandlerRegistry>

Handler registry for items, queries, and reports

relationship_manager: Arc<RelationshipManager>

Relationship manager for cascade operations

postgres_producer: Option<PostgresProducerHandle>

Optional Postgres producer handle

search_index: Arc<SearchIndex>

Full-text search index

persisters: Arc<PersisterRouter>

Persister routing (default + per-entity overrides)

host_id: Uuid

Server host ID

Implementations

impl CellServer

pub fn builder() -> CellServerBuilder

Create a new server builder.

pub fn new(config: CellServerConfig) -> Self

Create a new cell-based server.

pub fn start_peer_registry(&self, config: Option<PeerRegistryConfig>)

Start the peer registry for federation.

pub fn has_peer_registry(&self) -> bool

Check if peer registry is running.

pub fn registry(&self) -> Arc<StoreRegistry>

Get the store registry.

pub fn handler_registry(&self) -> Arc<HandlerRegistry>

Get the handler registry.

pub fn ctx(&self) -> CellServerCtx

Get a server context for module use.

pub fn postgres_history_store( &self, ) -> Result<Option<PostgresHistoryStore>, String>

Create a Postgres-backed history store for replay/windback operations.

pub fn init_postgres_and_wait(&self, timeout: Duration) -> Result<(), String>

Initialize Postgres replay/listener and wait for catch-up.

pub fn establish_relations(&self)

Establish relationship invariants.

pub fn is_ready(&self) -> bool

Check if the server is ready to accept connections.

pub async fn run(&self) -> Result<(), Box<dyn Error + Send + Sync>>

Run the server with full initialization.

pub async fn run_ws_loop(&self) -> Result<(), Box<dyn Error + Send + Sync>>

Run just the WebSocket accept loop.