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 load_plugin_from_source( &self, source: &str, name: &str, is_typescript: bool, ) -> Result<()>

Load a plugin from source code directly (blocking).

If a plugin with the same name is already loaded, it will be unloaded first (hot-reload semantics).

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

pub fn call_streaming_callback( &self, callback_id: JsCallbackId, result_json: String, done: bool, )

Call a streaming callback with partial data (does not consume the callback). When done is true, the callback is cleaned up on the JS side.

Trait Implementations

impl Drop for PluginThreadHandle

fn drop(&mut self)

Executes the destructor for this type.