Struct LspMultiplexer 

pub struct LspMultiplexer {
    pub project_root: PathBuf,
    pub workspace_roots: Vec<(Language, PathBuf)>,
    /* private fields */
}

Manages LSP server instances — one per language (multi-root) or per-root (LRU fallback).

Concurrency model: each language has its own Arc<Mutex<LanguageState>>. Callers acquire a per-language OwnedMutexGuard for the duration of LSP I/O. Different languages can be queried concurrently — no global lock is held during I/O.

Lazy startup: servers are started on first query, not at daemon boot. Crash recovery: exponential backoff for multi-root, silent removal for LRU.

Fields

project_root: PathBuf

Read-only after daemon start. Never mutated after new() is called.

workspace_roots: Vec<(Language, PathBuf)>

Implementations

impl LspMultiplexer

pub fn new( project_root: PathBuf, workspace_roots: Vec<(Language, PathBuf)>, ) -> Self

Create a new multiplexer for a project.

Pre-populates per-language slots for all known languages so the languages map never needs to grow after construction.

pub fn set_diagnostic_store(&self, store: Arc<DiagnosticStore>)

Attach a diagnostic store so all new LSP clients collect diagnostics.

Must be called before the first query. Subsequent calls are no-ops.

pub fn set_max_lru_sessions(&self, max: usize)

Set the maximum number of concurrent LRU sessions (from config).

pub fn set_max_language_servers(&self, max: usize)

Set the maximum number of concurrent language server processes (from config).

pub fn set_priority_roots(&self, roots: HashSet<PathBuf>)

Set priority workspace roots that are exempt from LRU eviction.

pub fn priority_roots(&self) -> HashSet<PathBuf>

Get the priority workspace roots.

pub async fn get_or_start( &self, lang: Language, ) -> Result<OwnedMutexGuard<LanguageState>>

Acquire a per-language guard for the given language, booting the server if needed.

The returned guard holds the per-language mutex for the duration of LSP I/O. Other languages remain accessible concurrently.

Errors

Returns an error if the server cannot be started or has permanently failed.

pub async fn route_for_file( &self, file_path: &Path, ) -> Result<OwnedMutexGuard<LanguageState>>

Route a file to its language server, attaching the workspace folder if needed.

Returns a per-language guard that the caller holds during LSP I/O.

Errors

Returns an error if language cannot be detected or server fails to start.

pub async fn attach_all_workspaces(&self, lang: Language) -> Result<()>

Attach all discovered workspace folders for a language.

Acquires the per-language lock internally.

Errors

Returns an error if the server is not running or attachment fails.

pub async fn attach_all_workspaces_with_guard( &self, lang: Language, guard: &mut OwnedMutexGuard<LanguageState>, ) -> Result<()>

Attach all workspaces using an already-held language guard.

Use this variant when you already hold the per-language lock.

Errors

Returns an error if attachment fails.

pub fn find_nearest_workspace( &self, file_path: &Path, lang: Language, ) -> Option<PathBuf>

Find the nearest discovered workspace root for a file.

pub fn unique_languages(&self) -> Vec<Language>

Get all unique languages detected in the project.

pub async fn warm_priority_roots(&self) -> Result<()>

Pre-warm LRU sessions for priority workspace roots.

Errors

Returns an error if a session fails to boot (non-fatal, logged by caller).

pub fn active_languages(&self) -> Vec<Language>

Get all active (running) languages.

pub fn status(&self) -> Vec<ServerStatus>

Get status info for all known languages. Uses try_lock — busy languages show as “ready”.

pub fn readiness(&self) -> Readiness

Readiness summary: how many languages have running servers.

pub fn is_ready(&self, lang: Language) -> bool

Check if a language has a running session (best-effort, non-blocking).

pub fn workspace_roots(&self) -> &[(Language, PathBuf)]

Get all known workspace roots.

pub fn project_root(&self) -> &Path

Get the project root.

pub async fn shutdown_all(&self)

Shut down all active LSP sessions.

pub async fn restart_language(&self, lang: Language) -> Result<()>

Shut down and clear the server for a language so it will be re-booted on next query.

Errors

Returns Err if the language is not registered in this multiplexer.

pub fn language_lock(&self, lang: Language) -> Result<Arc<Mutex<LanguageState>>>

Get the Arc<Mutex<LanguageState>> for a language.

Errors

Returns Err if the language has no registered slot in this multiplexer.