Struct PluginManager 

pub struct PluginManager { /* private fields */ }

Unified plugin manager that abstracts over the plugin system.

When the plugins feature is enabled, this wraps PluginThreadHandle. When disabled, all methods are no-ops.

Implementations

impl PluginManager

pub fn new( enable: bool, command_registry: Arc<RwLock<CommandRegistry>>, dir_context: DirectoryContext, theme_cache: Arc<RwLock<HashMap<String, Value>>>, ) -> Self

Create a new plugin manager.

When plugins feature is enabled and enable is true, spawns the plugin thread. Otherwise, creates a no-op manager.

pub fn test_inject_command(&mut self, command: PluginCommand)

Inject a PluginCommand into the manager’s pending queue as if it had arrived from the plugin thread. Returned by the next process_commands() call.

Intended for tests that need to deterministically reproduce renderer/plugin races (e.g. the mid-render process_commands path in Editor::render) without spinning up the real plugin runtime. Production code should not call this.

pub fn is_active(&self) -> bool

Check if the plugin system is active (has a running plugin thread, or — in tests — has commands queued via Self::test_inject_command).

pub fn is_alive(&self) -> bool

Check if the plugin thread is still alive

pub fn check_thread_health(&mut self)

Check thread health and panic if the plugin thread died due to a panic. This propagates plugin thread panics to the calling thread. Call this periodically (e.g., in wait loops) to fail fast on plugin errors.

pub fn load_plugins_from_dir(&self, dir: &Path) -> Vec<String>

Load plugins from a directory.

pub fn load_plugins_from_dir_with_config( &self, dir: &Path, plugin_configs: &HashMap<String, PluginConfig>, ) -> (Vec<String>, HashMap<String, PluginConfig>)

Load plugins from a directory with config support. Returns (errors, discovered_plugins) where discovered_plugins is a map of plugin name -> PluginConfig with paths populated.

pub fn unload_plugin(&self, name: &str) -> Result<()>

Unload a plugin by name.

pub fn load_plugin(&self, path: &Path) -> Result<()>

Load a single plugin by path.

pub fn load_plugin_from_source( &self, source: &str, name: &str, is_typescript: bool, ) -> Result<()>

Load a plugin from source code directly (no file I/O).

If a plugin with the same name is already loaded, it will be unloaded first (hot-reload semantics). This is used for “Load Plugin from Buffer”.

pub fn run_hook(&self, hook_name: &str, args: HookArgs)

Run a hook (fire-and-forget).

pub fn deliver_response(&self, response: PluginResponse)

Deliver a response to a pending async plugin operation.

pub fn process_commands(&mut self) -> Vec<PluginCommand>

Process pending plugin commands (non-blocking).

pub fn process_commands_until_hook_completed( &mut self, hook_name: &str, timeout: Duration, ) -> Vec<PluginCommand>

Process commands, blocking until HookCompleted for the given hook arrives. See PluginThreadHandle::process_commands_until_hook_completed for details.

pub fn state_snapshot_handle(&self) -> Option<Arc<RwLock<EditorStateSnapshot>>>

Get the state snapshot handle for updating editor state.

pub fn search_handles_handle(&self) -> Option<SearchHandleRegistry>

Streaming-search handle registry shared with the plugin runtime. Producers spawned by BeginSearch look up the handle here and write directly into its SearchHandleState; consumers (the plugin) drain the same state via _searchHandleTake.

pub fn execute_action_async( &self, action_name: &str, ) -> Option<Result<Receiver<Result<()>>>>

Execute a plugin action asynchronously.

pub fn list_plugins(&self) -> Vec<TsPluginInfo>

List all loaded plugins.

pub fn plugin_declarations(&self) -> Vec<(String, String)>

Collect the isolated-declarations .d.ts emit of every loaded plugin that produced one. Returns (plugin_name, d_ts_source) pairs — callers use this to assemble plugins.d.ts.

Available in all builds: without the plugins feature it returns an empty vec, letting editor_init call this unconditionally.

pub fn reload_plugin(&self, name: &str) -> Result<()>

Reload a plugin by name.

pub fn load_plugins_from_dir_with_config_request( &self, dir: &Path, plugin_configs: &HashMap<String, PluginConfig>, ) -> Option<Receiver<PluginsDirLoadResult>>

Submit a “load plugins from dir with config” request without blocking. Returns None when the plugin runtime is inactive (no thread), or when the request couldn’t be submitted. Used by the startup async-load path.

pub fn load_plugin_from_source_request( &self, source: &str, name: &str, is_typescript: bool, ) -> Option<Receiver<Result<()>>>

Submit a “load plugin from source” request without blocking. Returns None when the plugin runtime is inactive.

pub fn list_plugins_request(&self) -> Option<Receiver<Vec<TsPluginInfo>>>

Submit a “list plugins” request without blocking. Submitted after a batch of dir-load requests, this guarantees the response covers every plugin loaded by that batch (FIFO request channel).

pub fn has_hook_handlers(&self, hook_name: &str) -> bool

Check if any handlers are registered for a hook.

Blocking call (round-trips through the plugin thread). Suitable for rare events (mouse clicks, command dispatch). For per-render gating use has_subscribers instead — it reads a shared registry directly.

pub fn has_subscribers(&self, hook_name: &str) -> bool

Non-blocking variant of has_hook_handlers. Reads the shared event_handlers registry directly — safe to call on the hot render path. Returns false when plugins are disabled.

pub fn resolve_callback(&self, callback_id: JsCallbackId, result_json: String)

Resolve an async callback in the plugin runtime

pub fn reject_callback(&self, callback_id: JsCallbackId, error: String)

Reject an async callback in the plugin runtime