Struct PluginThreadHandle 

pub struct PluginThreadHandle { /* private fields */ }

Handle to the plugin thread for sending requests

Implementations

impl PluginThreadHandle

pub fn spawn(services: Arc<dyn PluginServiceBridge>) -> Result<Self>

Create a new plugin thread and return its handle

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 to detect plugin thread failures.

pub fn deliver_response(&self, response: PluginResponse)

Deliver a response to a pending async operation in the plugin

This is called by the editor after processing a command that requires a response.

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

Load a plugin from a file (blocking)

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

Load all plugins from a directory (blocking)

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

Load all plugins from a directory with config support (blocking) 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 (blocking)

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

Reload a plugin (blocking)

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

Execute a plugin action (non-blocking)

Returns a receiver that will receive the result when the action completes. The caller should poll this while processing commands to avoid deadlock.

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

Run a hook (non-blocking, fire-and-forget)

This is the key improvement: hooks are now non-blocking. The plugin thread will execute them asynchronously and any results will come back via the PluginCommand channel.

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

Check if any handlers are registered for a hook (blocking)

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

List all loaded plugins (blocking)

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

Process pending plugin commands (non-blocking)

Returns immediately with any pending commands by polling the command queue directly. This does not require the plugin thread to respond, avoiding deadlocks.

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.

After the render loop fires a hook like lines_changed, the plugin thread processes it and sends back commands (AddConceal, etc.) followed by a HookCompleted sentinel. This method waits for that sentinel so the render has all conceal/overlay updates before painting the frame.

Returns all non-sentinel commands collected while waiting. Falls back to non-blocking drain if the timeout expires.

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

Get the state snapshot handle for editor to update

pub fn shutdown(&mut self)

Shutdown the plugin thread

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

Resolve an async callback in the plugin runtime Called by the app when async operations (SpawnProcess, Delay) complete

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

Reject an async callback in the plugin runtime Called by the app when async operations fail

Trait Implementations

impl Drop for PluginThreadHandle

fn drop(&mut self)

Executes the destructor for this type.