use std::cell::{RefCell, RefMut};use std::rc::Rc;use std::sync::Arc; use anyhow::anyhow;use rquickjs::Context;use warp_js::{JsFunctionId, JsFunctionRegistry, SerializedJsValue}; cfg_if::cfg_if! {    if #[cfg(feature = "completions_v2")] {        use warp_completer::signatures::CommandSignature;         use crate::plugin::service::{            RegisterCommandSignatureRequest, RegisterCommandSignatureService,        };    }} /// A handle on a single JS plugin.////// We use a `Rc<RefCell<_>>` to make it possible for the plugin "API" (JS functions implemented in/// Rust) _and_ native Rust logic to share ownership over the plugin "state".  We know that, since/// JS is singlethreaded, the JS-side logic will never actually ask for a mutable borrow at the same/// time as host-side Rust.#[derive(Clone)]pub struct PluginHandle(Rc<RefCell<Plugin>>); impl PluginHandle {    pub(super) fn new(        app_service_callers: AppServiceCallers,        on_registered_js_function_callback: impl Fn(JsFunctionId) + 'static,    ) -> Self {        Self(Rc::new(RefCell::new(Plugin::new(            app_service_callers,            on_registered_js_function_callback,        ))))    }     pub(super) fn get_mut(&self) -> RefMut<'_, Plugin> {        (*self.0).borrow_mut()    }} /// Container struct for holding ipc `ServiceCaller` dependencies of `Plugin`.pub(super) struct AppServiceCallers {    #[cfg(feature = "completions_v2")]    register_command_signatures_caller:        Box<dyn ipc::ServiceCaller<RegisterCommandSignatureService>>,} impl AppServiceCallers {    pub fn new(#[allow(unused_variables)] app_client: Arc<ipc::Client>) -> Self {        Self {            #[cfg(feature = "completions_v2")]            register_command_signatures_caller: ipc::service_caller::<                RegisterCommandSignatureService,            >(app_client),        }    }} /// Represents logic and functionality implemented by a Plugin in JS.////// Conceptually, this an intermediate abstraction between plugin JS and "host-side" Rust.////// Concretely, this can generally be viewed as a wrapper around functions implemented by the/// plugin in JavaScript, exposing APIs to call such JS functions from Rust.////// This ultimately the main backing data structure behind the JS plugin API exposed to plugins/// (see [`super::js_api`]).pub(super) struct Plugin {    app_services: AppServiceCallers,    js_function_registry: JsFunctionRegistry,} impl Plugin {    /// Handles the given `request` and returns its corresponding response.    ///    /// Generally, should return a `PluginResponse` enum variant that matches the request variant.    pub(super) fn handle_request(        &mut self,        request: PluginRequest,        ctx: &Context,    ) -> anyhow::Result<PluginResponse> {        match request {            PluginRequest::CallJsFunction { id, input } => self                .call_js_function(input, &id, ctx)                .map(|serialized_value| PluginResponse::CallJsFunctionResult {                    output: serialized_value,                }),        }    }     /// Registers the given command signatures.    #[cfg(feature = "completions_v2")]    pub(super) fn register_command_signatures(&mut self, signatures: Vec<CommandSignature>) {        if let Err(e) = warpui::r#async::block_on(            self.app_services                .register_command_signatures_caller                .call(RegisterCommandSignatureRequest { signatures }),        ) {            log::warn!("Failed to register command signature: {e:?}");        }    }     pub(super) fn js_function_registry_mut(&mut self) -> &mut JsFunctionRegistry {        &mut self.js_function_registry    }     /// Calls the js function with the given function_id and input, if registered.    ///    /// The function with the given `function_id` is expected to be registered in this `Plugin`'s    /// `JsFunctionRegistry`. If the function_id has no registered function, returns an error.    fn call_js_function(        &mut self,        input: SerializedJsValue,        function_id: &JsFunctionId,        ctx: &Context,    ) -> anyhow::Result<SerializedJsValue> {        let Some(function) = self.js_function_registry.get_function(function_id) else {            return Err(anyhow!(                "Attempted to call unregistered JS Function with ID {:?}.",                function_id            ));        };        Ok(ctx.with(|ctx| function.call(input, &mut self.js_function_registry, ctx))?)    }     fn new(        app_services: AppServiceCallers,        on_registered_js_function_callback: impl Fn(JsFunctionId) + 'static,    ) -> Self {        Self {            js_function_registry: JsFunctionRegistry::new()                .on_registered_js_function(on_registered_js_function_callback),            app_services,        }    }} /// A request to be served by a plugin.#[derive(Debug, Clone)]pub(super) enum PluginRequest {    /// Request for execution of a JS function with the contained `id` and `input` to be passed as    /// a parameter. `input` should be the serialized bytes representation of the    /// `IntoPluginJs`-implementing Rust struct to be passed to the JS function.    CallJsFunction {        id: JsFunctionId,        input: SerializedJsValue,    },} /// The response to a PluginRequest.#[derive(Debug)]pub(super) enum PluginResponse {    /// Result of JS function execution requested via `PluginRequest::CallJsFunction`.    CallJsFunctionResult {        /// The serialized bytes representation of the `FromPluginJs`-implementing Rust value that        /// is the return value of the JS function.        ///        /// If this response is coming from a thread that does "host" the JS function (e.g. it was        /// registered by a different plugin), this is `None`.        output: SerializedJsValue,    },}