fix(editor): prevent duplicate Linux clipboard commands

Cargo.lock

@@ -4261,7 +4261,6 @@ dependencies = [
 name = "ide-clipboard"
 version = "0.1.40"
 dependencies = [
- "gtk",
  "objc2 0.6.5",
  "objc2-app-kit 0.3.2",
  "objc2-foundation 0.3.2",

README.md

@@ -76,6 +76,4 @@ the [official plugins](plugins/official). The plugin API is still a preview.
 
 [Apache 2.0](LICENSE). Bundled third-party assets are listed in [`THIRD_PARTY_LICENSES.md`](THIRD_PARTY_LICENSES.md).
 
-
-
 <sub>Not affiliated with JetBrains. IntelliJ IDEA is a trademark of JetBrains s.r.o.</sub>

crates/ide-agent/src/tests.rs

@@ -366,35 +366,6 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentMan
     )
 }
 
-#[tokio::test(flavor = "multi_thread")]
-async fn saved_conversation_reads_do_not_start_or_load_the_agent() {
-    let tmp = tempfile::tempdir().unwrap();
-    let agent = Arc::new(FakeAgent::default());
-    let mgr = manager(tmp.path(), agent.clone());
-    let task = mgr
-        .create(NewAgentTask {
-            project_root: None,
-            prompt: text("Review the saved conversation"),
-            provider: "claude".into(),
-            config: Vec::new(),
-            isolation: Isolation::Local,
-            base: None,
-        })
-        .await
-        .unwrap();
-    wait_for(&mgr, &task.id, AgentStatus::NeedsInput).await;
-    mgr.shutdown();
-    let restored_agent = Arc::new(FakeAgent::default());
-    let restored = manager(tmp.path(), restored_agent.clone());
-    assert!(!restored.entries(&task.id, None).unwrap().is_empty());
-    assert!(restored_agent.calls.lock().is_empty());
-    assert!(restored.entries("missing-task", None).is_err());
-    assert!(restored.entries(&task.id, Some("missing-subagent".into())).is_err());
-    restored.task(&task.id).unwrap().state.lock().conversation = Conversation::default();
-    assert!(restored.entries(&task.id, None).unwrap().is_empty());
-    restored.shutdown();
-}
-
 #[cfg(unix)]
 #[tokio::test(flavor = "multi_thread")]
 async fn claude_commands_before_session_are_fetched_once_and_saved() {

crates/ide-build/src/maven.rs

@@ -16,8 +16,6 @@ use std::io::Read;
 use std::path::{Path, PathBuf};
 use std::sync::{Mutex, OnceLock};
 
-pub mod sources;
-
 /// Phases shown under "Lifecycle" (IDEA's default list).
 pub const LIFECYCLE: &[&str] =
     &["clean", "validate", "compile", "test", "package", "verify", "install", "site", "deploy"];

crates/ide-build/src/maven/sources.rs

@@ -1,124 +0,0 @@
-//! On-demand sources resolution using the project's Maven launcher and repositories.
-
-use super::MavenProject;
-use crate::process;
-use ide_core::{CancellationToken, IdeError, IdeResult};
-use std::path::{Component, Path, PathBuf};
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct Artifact {
-    pub group: String,
-    pub name: String,
-    pub version: String,
-    pub sources: PathBuf,
-}
-
-/// Resolve only jars inside the selected local repository, including custom repositories.
-pub fn artifact(jar: &Path, repository: &Path) -> Option<Artifact> {
-    let relative = jar.strip_prefix(repository).ok()?;
-    let parts: Vec<&str> = relative
-        .components()
-        .map(|c| match c {
-            Component::Normal(s) => s.to_str(),
-            _ => None,
-        })
-        .collect::<Option<_>>()?;
-    if parts.len() < 4 {
-        return None;
-    }
-    let n = parts.len();
-    let (name, version, file) = (parts[n - 3], parts[n - 2], parts[n - 1]);
-    let valid = |s: &str| {
-        !s.is_empty() && s != "." && s != ".." && s.chars().all(|c| c.is_ascii_alphanumeric() || "_.-".contains(c))
-    };
-    if !parts[..n - 1].iter().all(|s| valid(s)) || file != format!("{name}-{version}.jar") {
-        return None;
-    }
-    Some(Artifact {
-        group: parts[..n - 3].join("."),
-        name: name.into(),
-        version: version.into(),
-        sources: jar.with_file_name(format!("{name}-{version}-sources.jar")),
-    })
-}
-
-pub fn download(
-    root: &Path,
-    project: &MavenProject,
-    artifact: &Artifact,
-    repository: &Path,
-    cancel: &CancellationToken,
-) -> IdeResult<Option<PathBuf>> {
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
-    if artifact.sources.is_file() {
-        return Ok(Some(artifact.sources.clone()));
-    }
-    let mut args = vec!["-B".into(), "-N".into(), "-Dstyle.color=never".into()];
-    args.extend(project.options.clone());
-    args.extend([
-        format!("-Dmaven.repo.local={}", repository.display()),
-        "org.apache.maven.plugins:maven-dependency-plugin:3.8.1:get".into(),
-        format!("-Dartifact={}:{}:{}:jar:sources", artifact.group, artifact.name, artifact.version),
-        "-Dtransitive=false".into(),
-    ]);
-    let output = process::run(&project.command, &args, &root.join(&project.dir), &project.env, cancel, |_, _| {})?;
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
-    if artifact.sources.is_file() {
-        return Ok(Some(artifact.sources.clone()));
-    }
-    let coordinate = format!("{}:{}:jar:sources:{}", artifact.group, artifact.name, artifact.version);
-    if output.success
-        || output.text.lines().any(|line| {
-            line.contains(&coordinate) && (line.contains("Could not find artifact") || line.contains("was not found"))
-        })
-    {
-        return Ok(None);
-    }
-    Err(IdeError::unavailable(
-        output.text.lines().rev().take(20).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>().join("\n"),
-    ))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn resolves_sources_coordinates_from_maven_layouts() {
-        for repository in ["/home/me/.m2/repository", "/tmp/project repo", "C:/Users/me/.m2/repository"] {
-            for (group, name, version) in [
-                ("org/apache/commons", "commons-lang3", "3.17.0"),
-                ("com/example", "example-lib", "1.0-SNAPSHOT"),
-                ("single", "lib", "1.0.0-rc.1"),
-            ] {
-                let repository = Path::new(repository);
-                let dir = repository.join(group).join(name).join(version);
-                let found = artifact(&dir.join(format!("{name}-{version}.jar")), repository).unwrap();
-                assert_eq!(found.group, group.replace('/', "."));
-                assert_eq!(found.name, name);
-                assert_eq!(found.version, version);
-                assert_eq!(found.sources, dir.join(format!("{name}-{version}-sources.jar")));
-            }
-        }
-    }
-
-    #[test]
-    fn rejects_non_artifacts_and_paths_outside_the_repository() {
-        let repository = Path::new("/m2/repository");
-        for path in [
-            "/m2/repository-other/g/a/1/a-1.jar",
-            "/m2/repository/g/a/1/a-1-sources.jar",
-            "/m2/repository/g/a/1/other.jar",
-            "/m2/repository/g/a/../a-1.jar",
-            "/m2/repository/g/a/1/a-1.pom",
-            "/m2/repository/g/a-1.jar",
-            "/gradle/caches/modules-2/files-2.1/g/a/1/hash/a-1.jar",
-        ] {
-            assert_eq!(artifact(Path::new(path), repository), None, "{path}");
-        }
-    }
-}

crates/ide-clipboard/Cargo.toml

@@ -11,6 +11,3 @@ license.workspace = true
 objc2 = { version = "0.6", default-features = false, features = ["std"] }
 objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSDictionary", "NSEnumerator", "NSObject", "NSString", "NSURL", "NSValue"] }
 objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSPasteboard"] }
-
-[target.'cfg(target_os = "linux")'.dependencies]
-gtk = "0.18"

crates/ide-clipboard/src/lib.rs

@@ -21,12 +21,6 @@
 
 use std::path::PathBuf;
 
-/// Replaces every clipboard flavor with plain text. `owner` is the calling window
-/// handle on Windows, ignored elsewhere. Call on the main thread on macOS and Linux.
-pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
-    imp::set_text(text, owner)
-}
-
 /// Size of `DROPFILES`: `pFiles`, `pt` (two `LONG`s), `fNC`, `fWide`.
 const HEADER: usize = 20;
 
@@ -171,12 +165,8 @@ mod imp {
     /// Opens the clipboard as its owner: the list is written in full, so no
     /// owning window is needed.
     fn open() -> bool {
-        open_for(ptr::null_mut())
-    }
-
-    fn open_for(owner: Handle) -> bool {
         for _ in 0..OPEN_ATTEMPTS {
-            if unsafe { OpenClipboard(owner) } != 0 {
+            if unsafe { OpenClipboard(ptr::null_mut()) } != 0 {
                 return true;
             }
             std::thread::sleep(OPEN_RETRY);
@@ -240,29 +230,6 @@ mod imp {
         }
     }
 
-    pub fn set_text(text: &str, owner: usize) -> std::io::Result<()> {
-        let (memory, _) = global_text(text);
-        if memory.is_null() {
-            return Err(std::io::Error::last_os_error());
-        }
-        // SAFETY: ownership transfers only on success; otherwise we free the allocation.
-        unsafe {
-            if !open_for(owner as Handle) {
-                GlobalFree(memory);
-                return Err(std::io::Error::last_os_error());
-            }
-            let taken = EmptyClipboard() != 0 && !SetClipboardData(CF_UNICODETEXT, memory).is_null();
-            let error = std::io::Error::last_os_error();
-            CloseClipboard();
-            if taken {
-                Ok(())
-            } else {
-                GlobalFree(memory);
-                Err(error)
-            }
-        }
-    }
-
     pub fn set_files(paths: &[PathBuf]) -> bool {
         let bytes = encode(paths);
         if bytes.len() <= HEADER {
@@ -373,19 +340,6 @@ mod imp {
         })
     }
 
-    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
-        debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
-        autoreleasepool(|_| {
-            let board = NSPasteboard::generalPasteboard();
-            board.clearContents();
-            if board.setString_forType(&NSString::from_str(text), unsafe { NSPasteboardTypeString }) {
-                Ok(())
-            } else {
-                Err(std::io::Error::other("Cannot write clipboard text"))
-            }
-        })
-    }
-
     pub fn set_files(paths: &[PathBuf]) -> bool {
         debug_assert!(MainThreadMarker::new().is_some(), "NSPasteboard access requires the main thread");
         autoreleasepool(|_| {
@@ -416,19 +370,6 @@ mod imp {
 mod imp {
     use std::path::PathBuf;
 
-    pub fn set_text(text: &str, _owner: usize) -> std::io::Result<()> {
-        #[cfg(target_os = "linux")]
-        {
-            gtk::Clipboard::get(&gtk::gdk::SELECTION_CLIPBOARD).set_text(text);
-            Ok(())
-        }
-        #[cfg(not(target_os = "linux"))]
-        {
-            let _ = text;
-            Err(std::io::Error::other("Clipboard text is unavailable on this platform"))
-        }
-    }
-
     pub fn has_files() -> bool {
         false
     }

crates/ide-core/Cargo.toml

@@ -23,4 +23,4 @@ tempfile.workspace = true
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Globalization", "Win32_Security", "Win32_System_Diagnostics_ToolHelp", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_Threading"] }
+windows-sys = { version = "0.61", features = ["Wdk_System_SystemServices", "Win32_Foundation", "Win32_Globalization", "Win32_Security", "Win32_System_Diagnostics_ToolHelp", "Win32_System_IO", "Win32_System_Registry", "Win32_System_SystemInformation", "Win32_System_Threading"] }

crates/ide-core/src/event.rs

@@ -42,10 +42,6 @@ pub enum IdeEvent {
         created: Vec<crate::IpcPath>,
         modified: Vec<crate::IpcPath>,
         removed: Vec<crate::IpcPath>,
-        /// Subtrees whose ignore rules changed, after the matchers were rebuilt.
-        #[serde(default)]
-        #[specta(optional)]
-        ignore_rules: Vec<crate::IpcPath>,
     },
     /// Excluded or ignored folders whose contents changed; they stay out of `FsChanged`.
     ExcludedDirsChanged {

crates/ide-core/src/process.rs

@@ -104,8 +104,6 @@ fn signal_group(child: &Child, signal: libc::c_int) {
 #[cfg(windows)]
 const TREE_EXIT_WAIT: Duration = Duration::from_secs(5);
 
-#[cfg(windows)]
-pub use windows_job::Job;
 #[cfg(windows)]
 pub use windows_tree::ProcessTree;
 
@@ -253,167 +251,6 @@ mod windows_tree {
     }
 }
 
-/// A kernel job object over one launched process tree. Everything a launch starts joins
-/// the job by inheritance, so [`Job::terminate`] ends the whole tree — also processes
-/// started after the launch's snapshot was taken, orphans of a launcher that already
-/// exited (where a `taskkill /T /F` from the tracked pid no longer finds them), and
-/// processes born in the window a process-enumeration kill would miss. Spawns assign
-/// their root right after it starts; when the assignment fails (an enclosing job that
-/// disallows nesting, an already-exited pid), callers fall back to `taskkill /T /F`.
-#[cfg(windows)]
-mod windows_job {
-    use std::mem::size_of;
-    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
-    use windows_sys::Win32::Foundation::{ERROR_MORE_DATA, INVALID_HANDLE_VALUE};
-    use windows_sys::Win32::System::JobObjects::{
-        AssignProcessToJobObject, CreateJobObjectW, JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
-        JOBOBJECT_BASIC_LIMIT_INFORMATION, JOBOBJECT_BASIC_PROCESS_ID_LIST, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
-        JobObjectBasicProcessIdList, JobObjectExtendedLimitInformation, QueryInformationJobObject,
-        SetInformationJobObject, TerminateJobObject,
-    };
-    use windows_sys::Win32::System::Threading::{IO_COUNTERS, OpenProcess, PROCESS_SET_QUOTA, PROCESS_TERMINATE};
-
-    /// A job object holding one launch's processes. The handle is kept open for the
-    /// launch's lifetime: `KILL_ON_JOB_CLOSE` ends anything still in the job when the
-    /// launch record (a run entry, a debug session) is finally dropped.
-    pub struct Job(OwnedHandle);
-
-    impl Job {
-        /// Takes the just-started `child` into a new job, so everything it starts is in
-        /// there too. `None` when the job could not be made or the process rejected the
-        /// assignment (callers fall back to `taskkill /T /F` from the child's pid).
-        pub fn for_child(child: &std::process::Child) -> Option<Job> {
-            // SAFETY: the child's own handle is a live process handle.
-            Self::from_handle(child.as_raw_handle())
-        }
-
-        /// [`Job::for_child`] for a process known by its id (a PTY child, a follow-up run,
-        /// a `tokio` child). `None` when the id no longer names an openable process — a
-        /// caller that holds the child cannot have had it reaped, so this is a dead or
-        /// already-gone launch.
-        pub fn for_pid(pid: u32) -> Option<Job> {
-            // SAFETY: plain call; a non-null result is a process handle owned by the caller.
-            // Assignment needs `SET_QUOTA | TERMINATE` on the process.
-            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
-            if handle.is_null() {
-                return None;
-            }
-            // SAFETY: the handle was just opened and is owned here.
-            let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
-            Self::from_handle(handle.as_raw_handle())
-        }
-
-        fn from_handle(handle: RawHandle) -> Option<Job> {
-            // SAFETY: plain calls; a non-null result is a job handle owned by the caller.
-            let job = unsafe { CreateJobObjectW(std::ptr::null(), std::ptr::null()) };
-            if job.is_null() || job == INVALID_HANDLE_VALUE {
-                return None;
-            }
-            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
-            let job = unsafe { OwnedHandle::from_raw_handle(job) };
-            let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
-                BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION {
-                    PerProcessUserTimeLimit: 0,
-                    PerJobUserTimeLimit: 0,
-                    LimitFlags: JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
-                    MinimumWorkingSetSize: 0,
-                    MaximumWorkingSetSize: 0,
-                    ActiveProcessLimit: 0,
-                    Affinity: 0,
-                    PriorityClass: 0,
-                    SchedulingClass: 0,
-                },
-                IoInfo: IO_COUNTERS {
-                    ReadOperationCount: 0,
-                    WriteOperationCount: 0,
-                    OtherOperationCount: 0,
-                    ReadTransferCount: 0,
-                    WriteTransferCount: 0,
-                    OtherTransferCount: 0,
-                },
-                ProcessMemoryLimit: 0,
-                JobMemoryLimit: 0,
-                PeakProcessMemoryUsed: 0,
-                PeakJobMemoryUsed: 0,
-            };
-            // SAFETY: the job handle is owned here and `limits` is sized as the API requires.
-            let ok = unsafe {
-                SetInformationJobObject(
-                    job.as_raw_handle(),
-                    JobObjectExtendedLimitInformation,
-                    &mut limits as *mut _ as *const _,
-                    size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
-                )
-            };
-            if ok == 0 {
-                return None;
-            }
-            // SAFETY: the process handle belongs to the just-spawned child and outlives
-            // this call; the job handle is owned here.
-            let ok = unsafe { AssignProcessToJobObject(job.as_raw_handle(), handle) };
-            if ok == 0 {
-                return None;
-            }
-            Some(Job(job))
-        }
-
-        /// Adds another just-started root of the same launch to the job (a Go build's
-        /// follow-up run, a JVM a debug session starts itself). `false` when it did not
-        /// take; the process then relies on its own kill.
-        pub fn assign_pid(&self, pid: u32) -> bool {
-            // SAFETY: plain call; the handle is opened only to assign it, and the job
-            // handle is owned and valid.
-            let handle = unsafe { OpenProcess(PROCESS_SET_QUOTA | PROCESS_TERMINATE, 0, pid) };
-            if handle.is_null() {
-                return false;
-            }
-            // SAFETY: both handles are valid for the duration of the call.
-            let ok = unsafe { AssignProcessToJobObject(self.0.as_raw_handle(), handle) };
-            // SAFETY: the process handle was opened above and is owned here.
-            unsafe { drop(OwnedHandle::from_raw_handle(handle)) };
-            ok != 0
-        }
-
-        /// Terminates every process in the job. `false` when the call failed (the job
-        /// handle is invalid): callers then fall back to `taskkill /T /F`. Termination is
-        /// asynchronous; poll [`Job::is_running`] (bounded by [`TREE_EXIT_WAIT`]) until
-        /// the tree is gone.
-        pub fn terminate(&self) -> bool {
-            // SAFETY: a job handle owned here.
-            unsafe { TerminateJobObject(self.0.as_raw_handle(), 1) != 0 }
-        }
-
-        /// Whether any process of the launch is still in the job. When the job's state
-        /// cannot be read, reports gone: waits on this must not wedge, and a kill via
-        /// [`Job::terminate`] does not depend on the answer.
-        pub fn is_running(&self) -> bool {
-            // A list of one is the common case; `ERROR_MORE_DATA` says the real list is
-            // longer, which means there are processes.
-            let mut list = JOBOBJECT_BASIC_PROCESS_ID_LIST {
-                NumberOfAssignedProcesses: 0,
-                NumberOfProcessIdsInList: 0,
-                ProcessIdList: [0],
-            };
-            let mut returned = 0u32;
-            // SAFETY: the job handle is owned here and `list` is sized as the API requires.
-            let ok = unsafe {
-                QueryInformationJobObject(
-                    self.0.as_raw_handle(),
-                    JobObjectBasicProcessIdList,
-                    &mut list as *mut _ as *mut _,
-                    size_of::<JOBOBJECT_BASIC_PROCESS_ID_LIST>() as u32,
-                    &mut returned,
-                )
-            };
-            if ok != 0 {
-                list.NumberOfProcessIdsInList > 0
-            } else {
-                std::io::Error::last_os_error().raw_os_error() == Some(ERROR_MORE_DATA as i32)
-            }
-        }
-    }
-}
-
 /// Gives `cmd` the host's environment back when the IDE runs from an AppImage. `AppRun` and
 /// its hooks point `LD_LIBRARY_PATH`, `PATH`, `XDG_DATA_DIRS`, `GIO_MODULE_DIR`, `GTK_PATH`,
 /// `GST_PLUGIN_*`, ... into the mounted image for the IDE itself; a host program that
@@ -1119,66 +956,3 @@ mod kill_tests {
         assert!(started.elapsed() < Duration::from_secs(5));
     }
 }
-
-#[cfg(all(test, windows))]
-mod job_tests {
-    use super::*;
-    use std::os::windows::process::CommandExt;
-    use std::process::Stdio;
-    use std::time::Instant;
-
-    /// `cmd` that keeps a `ping` grandchild for a minute, like a launcher that started an
-    /// application: the job must reach both.
-    fn launch_tree() -> (std::process::Child, Job, ProcessTree) {
-        let mut cmd = Command::new("cmd");
-        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
-        let child = cmd.spawn().unwrap();
-        let job = Job::for_child(&child).expect("the job takes the launch");
-        let tree = ProcessTree::capture(child.id());
-        assert!(tree.is_running(), "cmd started a grandchild the job inherits");
-        (child, job, tree)
-    }
-
-    /// Termination is asynchronous: the job reports its processes gone while their
-    /// handles still wait, so wait on the handles (the reused-pid-proof oracle).
-    fn assert_gone(tree: &ProcessTree) {
-        let until = Instant::now() + Duration::from_secs(10);
-        while tree.is_running() {
-            assert!(Instant::now() < until, "the tree survived the job");
-            std::thread::sleep(Duration::from_millis(20));
-        }
-    }
-
-    #[test]
-    fn job_terminates_the_tree_the_root_started() {
-        let (mut child, job, tree) = launch_tree();
-        assert!(job.is_running());
-        assert!(job.terminate(), "TerminateJobObject succeeds");
-        // The captured tree's handles survive the root's death, so the wait below is the
-        // grandchild's, not a reused pid's.
-        assert_gone(&tree);
-        assert!(!job.is_running());
-        let _ = child.wait();
-    }
-
-    #[test]
-    fn a_later_spawned_root_joins_the_job() {
-        let (mut first, job, _) = launch_tree();
-        let mut cmd = Command::new("cmd");
-        cmd.args(["/D", "/S", "/C", "ping -n 60 127.0.0.1 >NUL"]).stdin(Stdio::null()).creation_flags(CREATE_NO_WINDOW);
-        let mut second = cmd.spawn().unwrap();
-        let second_tree = ProcessTree::capture(second.id());
-        assert!(job.assign_pid(second.id()), "the follow-up run joins the job");
-        assert!(job.terminate());
-        assert_gone(&second_tree);
-        let _ = first.wait();
-        let _ = second.wait();
-    }
-
-    #[test]
-    fn a_dead_pid_makes_no_job() {
-        // An id of a process this test cannot open (or that does not exist) gives no job,
-        // which is the callers' cue for the `taskkill /T /F` fallback.
-        assert!(Job::for_pid(u32::MAX).is_none());
-    }
-}

crates/ide-core/src/remote_settings.rs

@@ -201,18 +201,7 @@ pub struct PluginRunTarget {
     pub args: Vec<String>,
     pub workdir_args: Vec<String>,
     pub container_root: Option<String>,
-    pub commands: Vec<PluginCommandOverride>,
-}
-
-/// Per-command argv prefix and optional replacement working-directory arguments.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PluginCommandOverride {
-    pub name: String,
-    pub args: Vec<String>,
-    /// None inherits the target's list; Some([]) suppresses it.
-    #[serde(default)]
-    pub workdir_args: Option<Vec<String>>,
+    pub commands: Vec<(String, Vec<String>)>,
 }
 
 #[cfg(test)]

crates/ide-core/src/settings.rs

@@ -277,10 +277,6 @@ pub struct CustomKeymap {
 pub struct GeneralSettings {
     pub reopen_last_project: bool,
     pub confirm_exit: bool,
-    /// When on, the last window closes instead of showing the Welcome screen.
-    pub close_without_welcome: bool,
-    /// When on, closing a window drops its saved editor tabs, so they are not restored next time.
-    pub close_tabs_with_window: bool,
     /// Where Open… puts a project while one is open: `ask` | `new` | `same` | `attach`.
     pub open_project_in: String,
     /// Initial folder of the Open / Clone dialogs; empty = the OS default.
@@ -304,8 +300,6 @@ impl Default for GeneralSettings {
         Self {
             reopen_last_project: true,
             confirm_exit: true,
-            close_without_welcome: false,
-            close_tabs_with_window: false,
             open_project_in: "ask".into(),
             default_project_directory: String::new(),
             save_on_idle: false,
@@ -369,21 +363,6 @@ impl Default for NotificationGroupSettings {
     }
 }
 
-/// Where the Navigation Bar (the file path breadcrumbs) is shown. Mirrors
-/// IDEA's `View | Appearance | Navigation Bar` (Top / Status Bar / Don't show).
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum NavigationBarPosition {
-    /// Above the editor, below the main menu / toolbar.
-    Top,
-    /// In the footer, next to the status bar widgets — the default, matching
-    /// where the bar lived before the three-state choice existed.
-    #[default]
-    StatusBar,
-    /// Not shown at all.
-    Hidden,
-}
-
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct AppearanceSettings {
@@ -432,9 +411,6 @@ pub struct AppearanceSettings {
     /// View › Appearance › Toolbar; hidden leaves IDEA's compact window header.
     pub show_main_toolbar: bool,
     pub show_status_bar: bool,
-    /// View › Appearance › Navigation Bar: the file path breadcrumbs, shown in
-    /// the status bar by default, above the editor, or not at all.
-    pub navigation_bar: NavigationBarPosition,
     /// Status bar widgets shown (`true`) or hidden (`false`) by the user
     /// (status bar context menu); widgets not listed use their default.
     pub status_bar_widgets: BTreeMap<String, bool>,
@@ -507,7 +483,6 @@ impl Default for AppearanceSettings {
             widescreen_tool_windows: false,
             show_main_toolbar: true,
             show_status_bar: true,
-            navigation_bar: NavigationBarPosition::StatusBar,
             status_bar_widgets: BTreeMap::new(),
             main_toolbar: None,
         }
@@ -545,9 +520,6 @@ pub struct EditorSettings {
     /// Color Scheme › Language Defaults › Semantic highlighting: local variables and
     /// parameters get a colour derived from their name (IDEA's rainbow identifiers).
     pub semantic_highlighting: bool,
-    /// Docstring markup format whose tags and keywords the Python editor highlights
-    /// (`plain`, `rest`, `epytext`, `google`, `numpy`).
-    pub docstring_format: String,
     /// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
     pub rainbow_brackets: bool,
     pub ligatures: bool,
@@ -592,7 +564,6 @@ impl Default for EditorSettings {
             color_overrides: BTreeMap::new(),
             custom_schemes: BTreeMap::new(),
             semantic_highlighting: false,
-            docstring_format: "rest".into(),
             rainbow_brackets: false,
             ligatures: false,
             fallback_font: String::new(),
@@ -637,15 +608,6 @@ pub struct FileSettings {
     pub file_types: BTreeMap<String, FileTypeAssociation>,
     /// Override File Type: file (project-relative and `/`-separated, or absolute) → language id.
     pub file_type_overrides: BTreeMap<String, String>,
-    /// Compose detection choices, keyed by project-relative file path.
-    pub compose_file_overrides: BTreeMap<String, ComposeFileOverride>,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub enum ComposeFileOverride {
-    Kept,
-    Excluded,
 }
 
 /// One language's file name and hashbang patterns on top of its definition.
@@ -673,7 +635,6 @@ impl Default for FileSettings {
             local_history_max_mb: 512,
             file_types: BTreeMap::new(),
             file_type_overrides: BTreeMap::new(),
-            compose_file_overrides: BTreeMap::new(),
         }
     }
 }
@@ -695,7 +656,6 @@ pub struct LanguagesSettings {
     pub java: JavaSettings,
     pub ruby: RubySettings,
     pub markdown: MarkdownSettings,
-    pub arduino: ArduinoSettings,
 }
 
 impl Default for LanguagesSettings {
@@ -717,22 +677,10 @@ impl Default for LanguagesSettings {
             java: JavaSettings::default(),
             ruby: RubySettings::default(),
             markdown: MarkdownSettings::default(),
-            arduino: ArduinoSettings::default(),
         }
     }
 }
 
-/// Arduino tool discovery paths and default board FQBN, configured in `settings.toml`.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(default, rename_all = "camelCase")]
-pub struct ArduinoSettings {
-    pub cli: String,
-    pub clangd: String,
-    pub language_server: String,
-    pub cli_config: String,
-    pub fqbn: String,
-}
-
 /// Languages & Frameworks › Markdown. Like IDEA's, it is application-level only.
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
@@ -1235,26 +1183,6 @@ impl Settings {
 mod tests {
     use super::*;
 
-    #[test]
-    fn window_close_settings_default_off_and_round_trip() {
-        for old in [r#"{}"#, r#"{"general":{"confirmExit":false}}"#] {
-            let settings: Settings = serde_json::from_str(old).unwrap();
-            assert!(!settings.general.close_without_welcome);
-            assert!(!settings.general.close_tabs_with_window);
-        }
-        for close_window in [false, true] {
-            for close_tabs in [false, true] {
-                let mut settings = Settings::default();
-                settings.general.close_without_welcome = close_window;
-                settings.general.close_tabs_with_window = close_tabs;
-                let json = serde_json::to_value(&settings).unwrap();
-                assert_eq!(json["general"]["closeWithoutWelcome"], close_window);
-                assert_eq!(json["general"]["closeTabsWithWindow"], close_tabs);
-                assert_eq!(serde_json::from_value::<Settings>(json).unwrap().general, settings.general);
-            }
-        }
-    }
-
     #[test]
     fn cmake_profile_argument_arrays_round_trip() {
         let mut settings = Settings::default();
@@ -1317,21 +1245,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn docstring_format_defaults_and_round_trips() {
-        let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
-        assert_eq!(old.editor.docstring_format, "rest");
-        assert_eq!(Settings::default().editor.docstring_format, "rest");
-        for format in ["plain", "rest", "epytext", "google", "numpy"] {
-            let mut settings = Settings::default();
-            settings.editor.docstring_format = format.into();
-            let json = serde_json::to_value(&settings).unwrap();
-            assert_eq!(json["editor"]["docstringFormat"], format);
-            let restored: Settings = serde_json::from_value(json).unwrap();
-            assert_eq!(restored.editor.docstring_format, format);
-        }
-    }
-
     #[test]
     fn tool_window_badges_default_on_and_round_trip() {
         let old: Settings = serde_json::from_str(r#"{"appearance":{"showToolWindowNames":true}}"#).unwrap();

crates/ide-dap/src/adapter.rs

@@ -525,10 +525,9 @@ async fn spawn_adapter(
         cmd.env("PATH", path);
     }
     ide_core::process::prepare(cmd.as_std_mut());
-    // Every adapter leads its own process group: the program an adapter launches itself
-    // (java-debug's JVM) joins the group, so a forced stop reaches the whole tree with
-    // one `kill(-pgid)`. On Windows the same coverage comes from the session's job object.
-    ide_core::process::own_group(cmd.as_std_mut());
+    if spec.adapter == "rdbg" {
+        ide_core::process::own_group(cmd.as_std_mut());
+    }
     cmd.args(args)
         .envs(spec.env.iter().map(|(k, v)| (k, v)))
         .current_dir(&spec.cwd)

crates/ide-dap/src/lib.rs

@@ -1160,7 +1160,7 @@ impl DebugManager {
         if own_terminate && !graceful {
             // Signal before anything else: waiting on a request the adapter may not answer
             // would delay the shutdown the console is supposed to show.
-            crate::session::signal_debuggee(s, false).await;
+            crate::session::signal_debuggee(s, false);
         }
         if graceful {
             // java-debug sends `terminated` only after it has drained the program's console

crates/ide-dap/src/session.rs

@@ -45,13 +45,6 @@ pub(crate) struct Session {
     pub debuggees: Mutex<Vec<Child>>,
     /// The terminal a `runInTerminal` program runs in: typed input goes to it.
     pub program: Mutex<Option<ProgramTerminal>>,
-    /// The job object over the adapter and everything it started: the program an adapter
-    /// like java-debug launches is its child, so a forced stop (and the session's
-    /// cleanup) ends the whole tree even when the adapter exited first and the reported
-    /// pid no longer names it. `None` when the assignment failed; the kill then falls
-    /// back to the captured process tree.
-    #[cfg(windows)]
-    pub job: Mutex<Option<ide_core::process::Job>>,
     /// Set once `configurationDone` was sent; breakpoint updates go out live after that.
     pub configured: AtomicBool,
     pub initialized: watch::Sender<bool>,
@@ -98,10 +91,6 @@ impl Session {
         port: Option<u16>,
         child: Option<Child>,
     ) -> Self {
-        // Before `child` moves into the session: the adapter is the root of the job, so
-        // everything it starts (java-debug's JVM) is in there by inheritance.
-        #[cfg(windows)]
-        let job = child.as_ref().and_then(tokio::process::Child::id).and_then(ide_core::process::Job::for_pid);
         Self {
             id,
             owner,
@@ -116,8 +105,6 @@ impl Session {
             adapter_process: Mutex::new(child),
             debuggees: Mutex::new(Vec::new()),
             program: Mutex::new(None),
-            #[cfg(windows)]
-            job: Mutex::new(job),
             configured: AtomicBool::new(false),
             initialized: watch::channel(false).0,
             startup_cancel: ide_core::CancellationToken::new(),
@@ -295,24 +282,6 @@ impl Session {
     /// Kills the adapter and every debuggee we started.
     pub fn kill_processes(&self) {
         self.kotlin_relay.lock().take();
-        #[cfg(unix)]
-        if self.request == "launch" {
-            for group in launch_groups(self) {
-                ide_core::process::kill_tree_of(group as u32);
-            }
-        }
-        // The job first: it ends the adapter and everything it started (the program
-        // java-debug launched is its child), members included that the stop's captured
-        // tree never saw. An empty job is unaffected, and whatever survives this session
-        // dies when the handle closes (`KILL_ON_JOB_CLOSE`).
-        #[cfg(windows)]
-        if let Some(job) = self.job.lock().as_ref() {
-            job.terminate();
-        }
-        #[cfg(windows)]
-        if let Some(tree) = self.stop_tree.lock().as_ref() {
-            tree.terminate();
-        }
         if let Some(mut c) = self.adapter_process.lock().take() {
             if self.adapter == "rdbg"
                 && let Some(pid) = c.id()
@@ -326,9 +295,6 @@ impl Session {
         }
         if let Some(mut program) = self.program.lock().take() {
             let _ = program.child.kill();
-            let _ = std::thread::Builder::new().name("openidea-debug-reap".into()).spawn(move || {
-                let _ = program.child.wait();
-            });
         }
     }
 }
@@ -380,36 +346,18 @@ fn process_tree(pid: i32) -> Vec<i32> {
 /// Asks the program itself to exit (`force` = SIGKILL) without ending the adapter session:
 /// its output keeps flowing over DAP while it shuts down. The first call remembers the pid
 /// tree, because the reported pid may die before its program does.
-pub(crate) async fn signal_debuggee(s: &Arc<Session>, force: bool) {
-    if s.request != "launch" {
+pub(crate) fn signal_debuggee(s: &Arc<Session>, force: bool) {
+    let pid = s.debuggee_pid.load(Ordering::Acquire);
+    if pid <= 0 {
         return;
     }
-    #[cfg(not(windows))]
-    let pid = s.debuggee_pid.load(Ordering::Acquire);
     #[cfg(unix)]
     {
-        let needs_tree = pid > 0 && s.stop_pids.lock().is_empty();
-        if needs_tree {
-            let tree = tokio::task::spawn_blocking(move || process_tree(pid as i32)).await.unwrap_or_default();
-            *s.stop_pids.lock() = tree;
+        let mut known = s.stop_pids.lock();
+        if known.is_empty() {
+            *known = process_tree(pid as i32);
         }
-        let known = s.stop_pids.lock();
         let signal = if force { libc::SIGKILL } else { libc::SIGTERM };
-        if force {
-            // A forced stop kills the launch: every root the session spawned leads its own
-            // process group (`own_group` at spawn), so one signal reaches the program and
-            // everything it started, even processes born after the snapshot below was
-            // taken — the adapter's program is in the adapter's group. The session's own
-            // JVM roots (Kotlin) and `runInTerminal` programs lead groups of their own.
-            // The roots are unreaped until the session drops them, so their ids (and the
-            // groups named by them) cannot have been reused yet.
-            for group in launch_groups(s) {
-                // SAFETY: plain syscalls on the processes this session started.
-                if unsafe { libc::kill(-group, libc::SIGKILL) } != 0 {
-                    unsafe { libc::kill(group, libc::SIGKILL) };
-                }
-            }
-        }
         // Children first: the shell that started the program would otherwise reparent it.
         for p in known.iter().rev() {
             // SAFETY: plain syscall on the processes this session started.
@@ -420,53 +368,15 @@ pub(crate) async fn signal_debuggee(s: &Arc<Session>, force: bool) {
     }
     #[cfg(windows)]
     {
-        // Console programs have no external graceful signal; the adapter gets its chance
-        // first. The job ends the program and everything it started, members included
-        // that the captured tree never saw.
-        if force {
-            if let Some(job) = s.job.lock().as_ref() {
-                job.terminate();
-            }
-            // A separately spawned program may have rejected assignment to the adapter's job.
-            if let Some(tree) = s.stop_tree.lock().as_ref() {
-                tree.terminate();
-            }
+        // Console programs have no external graceful signal; the adapter gets its chance first.
+        if force && let Some(tree) = s.stop_tree.lock().as_ref() {
+            tree.terminate();
         }
     }
     #[cfg(not(any(unix, windows)))]
     let _ = (pid, force);
 }
 
-/// The process groups the session spawned roots for: the adapter's (the program it
-/// launched is in it), the JVMs the session started itself, the `runInTerminal` program.
-#[cfg(unix)]
-fn launch_groups(s: &Session) -> Vec<libc::pid_t> {
-    let mut groups = Vec::new();
-    let mut push = |id: Option<u32>| {
-        if let Ok(pid) = libc::pid_t::try_from(id.unwrap_or(0)) {
-            groups.push(pid);
-        }
-    };
-    push(s.adapter_process.lock().as_ref().and_then(tokio::process::Child::id));
-    for child in s.debuggees.lock().iter() {
-        push(child.id());
-    }
-    push(s.program.lock().as_ref().and_then(|p| p.child.process_id()));
-    groups.retain(|g| *g > 0);
-    groups
-}
-
-/// Whether the launch is still running: the stop's captured tree when there is one,
-/// otherwise the session's job (the adapter and everything it started).
-#[cfg(windows)]
-fn launch_running(s: &Arc<Session>) -> bool {
-    if let Some(tree) = s.stop_tree.lock().as_ref() {
-        tree.is_running()
-    } else {
-        s.job.lock().as_ref().is_some_and(|job| job.is_running())
-    }
-}
-
 /// Waits until the program a `launch` session started is gone; a second Stop kills it.
 pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     if !terminate || s.request != "launch" {
@@ -480,19 +390,19 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     #[cfg(unix)]
     {
         use std::time::Instant;
-        let mut targets = s.stop_pids.lock().clone();
-        if targets.is_empty() {
-            targets = tokio::task::spawn_blocking(move || process_tree(pid as i32)).await.unwrap_or_default();
-        }
+        let targets = {
+            let known = s.stop_pids.lock();
+            if known.is_empty() { process_tree(pid as i32) } else { known.clone() }
+        };
         let alive = || targets.iter().any(|p| unsafe { libc::kill(*p, 0) } == 0);
         let deadline = Instant::now() + DEBUGGEE_EXIT_WAIT;
         while alive() {
             if s.stop_force.swap(false, Ordering::AcqRel) {
-                signal_debuggee(s, true).await;
+                signal_debuggee(s, true);
             }
             if Instant::now() >= deadline {
                 // The program ignored the terminate: do not leave it running.
-                signal_debuggee(s, true).await;
+                signal_debuggee(s, true);
                 break;
             }
             tokio::time::sleep(Duration::from_millis(50)).await;
@@ -502,12 +412,9 @@ pub(crate) async fn wait_for_debuggee(s: &Arc<Session>, terminate: bool) {
     {
         remember_debuggee(s).await;
         let deadline = std::time::Instant::now() + DEBUGGEE_EXIT_WAIT;
-        // The captured tree is the oracle when it was captured; otherwise the job (every
-        // process the launch started) is, so a failed capture can no longer end the wait
-        // while the program still holds its port.
-        while launch_running(s) {
+        while s.stop_tree.lock().as_ref().is_some_and(|tree| tree.is_running()) {
             if s.stop_force.swap(false, Ordering::AcqRel) || std::time::Instant::now() >= deadline {
-                signal_debuggee(s, true).await;
+                signal_debuggee(s, true);
             }
             tokio::time::sleep(Duration::from_millis(50)).await;
         }
@@ -790,14 +697,6 @@ pub(crate) fn run_in_terminal(s: &Arc<Session>, args: &Value) -> Result<Value, S
         }
     }
     let mut child = pair.slave.spawn_command(cmd).map_err(|e| format!("failed to start {program}: {e}"))?;
-    // The program joins the session's job, so Stop reaches what it starts (its children),
-    // though only the program itself is the session's child.
-    #[cfg(windows)]
-    if let Some(pid) = child.process_id()
-        && let Some(job) = s.job.lock().as_ref()
-    {
-        job.assign_pid(pid);
-    }
     drop(pair.slave);
     let reader = pair.master.try_clone_reader().map_err(|e| format!("terminal of {program}: {e}"))?;
     let writer = pair.master.take_writer().map_err(|e| format!("terminal of {program}: {e}"))?;
@@ -965,16 +864,7 @@ pub(crate) async fn start_kotlin_debuggee(s: &Arc<Session>, args: &mut Value) ->
             }
         }
     }
-    // A root the session spawns itself: its own process group on Unix (`kill(-pgid)` in a
-    // forced stop), the session's job on Windows, so a stop reaches what it forks.
-    ide_core::process::own_group(cmd.as_std_mut());
     let mut child = cmd.spawn()?;
-    #[cfg(windows)]
-    if let Some(pid) = child.id()
-        && let Some(job) = s.job.lock().as_ref()
-    {
-        job.assign_pid(pid);
-    }
     if let Some(err) = child.stderr.take() {
         forward_output(s, err, "stderr");
     }

crates/ide-dap/src/tests.rs

@@ -1963,55 +1963,3 @@ async fn rdbg_drains_test_output_after_dap_closes_before_killing_the_process() {
         IdeEvent::Debug { event: DebugEvent::Output { output, .. }, .. } if output == "test summary\n"
     )));
 }
-
-#[cfg(unix)]
-#[tokio::test]
-async fn cleanup_ends_the_adapter_tree_without_a_process_event() {
-    use tokio::io::AsyncBufReadExt;
-
-    let h = harness(Script::default());
-    let id = h.start(config()).await.unwrap();
-    let session = h.manager.session(id).unwrap();
-    let mut command = tokio::process::Command::new("python3");
-    ide_core::process::own_group(command.as_std_mut());
-    command
-        .args([
-            "-u",
-            "-c",
-            "import subprocess,sys,time; subprocess.Popen([sys.executable, '-u', '-c', \
-             \"import socket,time; s=socket.socket(); s.bind(('127.0.0.1',0)); s.listen(); \
-             print(s.getsockname()[1],flush=True); time.sleep(60)\"]); time.sleep(60)",
-        ])
-        .stdout(std::process::Stdio::piped());
-    let mut child = command.spawn().unwrap();
-    let mut lines = BufReader::new(child.stdout.take().unwrap()).lines();
-    let port: u16 = lines.next_line().await.unwrap().unwrap().parse().unwrap();
-    assert!(std::net::TcpListener::bind(("127.0.0.1", port)).is_err(), "the descendant holds the port");
-    let pid = child.id().unwrap();
-    *session.adapter_process.lock() = Some(child);
-    session.kill_processes();
-    let deadline = Instant::now() + Duration::from_secs(3);
-    while std::net::TcpListener::bind(("127.0.0.1", port)).is_err() {
-        if Instant::now() >= deadline {
-            ide_core::process::kill_tree_of(pid);
-            panic!("adapter cleanup left its descendant holding the port");
-        }
-        tokio::time::sleep(Duration::from_millis(20)).await;
-    }
-    h.manager.stop(id).await.unwrap();
-}
-
-#[cfg(unix)]
-#[tokio::test]
-async fn stop_detaches_from_an_attached_program() {
-    let mut child = std::process::Command::new("sleep").arg("60").spawn().unwrap();
-    let h = harness(Script { debuggee_pid: Some(child.id()), ..Default::default() });
-    let id = h.start(LaunchConfig { request: "attach".into(), ..config() }).await.unwrap();
-    h.manager.stop(id).await.unwrap();
-    let alive = child.try_wait().unwrap().is_none();
-    let _ = child.kill();
-    let _ = child.wait();
-    assert!(alive, "Stop killed the attached program");
-    assert!(!h.commands().contains(&"terminate".to_owned()));
-    assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
-}

crates/ide-github/src/model.rs

@@ -627,8 +627,8 @@ mod tests {
     #[test]
     fn finds_remote_by_repo() {
         let remotes = vec![
-            ide_vcs::Remote { name: "origin".into(), url: "[email protected]:me/App.git".into(), resolved_url: None },
-            ide_vcs::Remote { name: "upstream".into(), url: "https://github.com/org/app/".into(), resolved_url: None },
+            ide_vcs::Remote { name: "origin".into(), url: "[email protected]:me/App.git".into() },
+            ide_vcs::Remote { name: "upstream".into(), url: "https://github.com/org/app/".into() },
         ];
         assert_eq!(remote_for(&remotes, "me/app").map(|r| r.name.as_str()), Some("origin"));
         assert_eq!(remote_for(&remotes, "org/app").map(|r| r.name.as_str()), Some("upstream"));

crates/ide-host/src/data_dirs.rs

@@ -26,8 +26,10 @@ fn resolve_local(var: Option<OsString>, os: Option<PathBuf>, identifier: &str) -
         return Err(format!("{LOCAL_DATA_ENV} must be an absolute path: {}", root.display()));
     }
     let dir = root.join(identifier);
+    let probe = dir.join(".openidea-write-check");
     fs::create_dir_all(&dir)
-        .and_then(|()| tempfile::NamedTempFile::new_in(&dir).map(drop))
+        .and_then(|()| fs::write(&probe, b""))
+        .and_then(|()| fs::remove_file(&probe))
         .map_err(|error| format!("{LOCAL_DATA_ENV}: cannot write to {}: {error}", dir.display()))?;
     Ok(dir)
 }
@@ -325,53 +327,6 @@ mod tests {
         assert_ne!(resolve_local(Some(root.clone().into()), None, "dev-a").unwrap(), dir);
     }
 
-    #[test]
-    fn local_dir_preserves_an_existing_probe_file() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dir = tmp.path().join("id");
-        fs::create_dir(&dir).unwrap();
-        let probe = dir.join(".openidea-write-check");
-        fs::write(&probe, "keep").unwrap();
-        assert_eq!(resolve_local(Some(tmp.path().into()), None, "id").unwrap(), dir);
-        assert_eq!(fs::read_to_string(probe).unwrap(), "keep");
-        assert_eq!(fs::read_dir(dir).unwrap().count(), 1);
-    }
-
-    #[cfg(unix)]
-    #[test]
-    fn local_dir_preserves_an_existing_probe_symlink_and_its_target() {
-        let tmp = tempfile::tempdir().unwrap();
-        let dir = tmp.path().join("id");
-        fs::create_dir(&dir).unwrap();
-        let target = tmp.path().join("target");
-        fs::write(&target, "keep").unwrap();
-        let probe = dir.join(".openidea-write-check");
-        std::os::unix::fs::symlink(&target, &probe).unwrap();
-        assert_eq!(resolve_local(Some(tmp.path().into()), None, "id").unwrap(), dir);
-        assert_eq!(fs::read_to_string(target).unwrap(), "keep");
-        assert!(fs::symlink_metadata(probe).unwrap().file_type().is_symlink());
-        assert_eq!(fs::read_dir(dir).unwrap().count(), 1);
-    }
-
-    #[test]
-    fn local_dir_allows_concurrent_probes_for_the_same_identifier() {
-        let tmp = tempfile::tempdir().unwrap();
-        let barrier = std::sync::Barrier::new(8);
-        std::thread::scope(|scope| {
-            for _ in 0..8 {
-                let barrier = &barrier;
-                let root = tmp.path();
-                scope.spawn(move || {
-                    barrier.wait();
-                    for _ in 0..16 {
-                        assert_eq!(resolve_local(Some(root.into()), None, "id").unwrap(), root.join("id"));
-                    }
-                });
-            }
-        });
-        assert_eq!(fs::read_dir(tmp.path().join("id")).unwrap().count(), 0);
-    }
-
     #[test]
     fn local_dir_rejects_relative_and_unwritable_paths() {
         for relative in ["local", "./local", "../local"] {

crates/ide-host/src/ops/debug.rs

@@ -9,32 +9,6 @@ use std::path::PathBuf;
 
 /// Starts a session owned by this window: its events (and those of child sessions) go here only.
 pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
-    debug_start_request(host, window, config, None).await
-}
-
-pub async fn debug_start_request(
-    host: &Host,
-    window: &str,
-    config: LaunchConfig,
-    request: Option<ide_core::RequestId>,
-) -> IdeResult<DebugSessionId> {
-    let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
-    let result = debug_start_inner(host, window, config, &cancel).await;
-    if let Some(id) = request {
-        host.end_request(id);
-    }
-    result
-}
-
-async fn debug_start_inner(
-    host: &Host,
-    window: &str,
-    config: LaunchConfig,
-    cancel: &ide_core::CancellationToken,
-) -> IdeResult<DebugSessionId> {
-    if cancel.is_cancelled() {
-        return Err(ide_core::IdeError::cancelled());
-    }
     host.require_trust(window)?;
     let target_id = config
         .extra_json
@@ -43,7 +17,7 @@ async fn debug_start_inner(
         .and_then(|v| v.get("__runTarget").and_then(|v| v.as_str()).map(str::to_owned));
     if let Some(id) = target_id {
         let owner = SessionOwner::new(host.owner_window(window), host.window_sink(window));
-        return target::start(host, window, config, owner, id, cancel).await;
+        return target::start(host, window, config, owner, id).await;
     }
     let mut config = match_java_debug_encoding(config, cfg!(windows));
     if config.adapter == "debugpy"
@@ -418,9 +392,7 @@ pub async fn debug_redefine_classes(host: &Host, _window: &str, session: DebugSe
 
 /// Commands of this module the remote server answers.
 pub(crate) fn register(d: &mut Dispatcher) {
-    d.add("debug_start", |c| async move {
-        debug_start_request(&c.host, &c.window, c.arg("config")?, c.arg("request")?).await
-    });
+    d.add("debug_start", |c| async move { debug_start(&c.host, &c.window, c.arg("config")?).await });
     d.add("debug_set_breakpoints", |c| async move {
         debug_set_breakpoints(&c.host, &c.window, c.arg("path")?, c.arg("breakpoints")?).await
     });

crates/ide-host/src/ops/debug/target.rs

@@ -12,7 +12,6 @@ pub(super) async fn start(
     mut config: LaunchConfig,
     owner: SessionOwner,
     id: String,
-    cancel: &ide_core::CancellationToken,
 ) -> IdeResult<ide_core::DebugSessionId> {
     let project = host.project(window)?;
     let plugins =
@@ -34,23 +33,6 @@ pub(super) async fn start(
     {
         return Err(IdeError::invalid("This debugger does not support plugin run targets"));
     }
-    let program = config
-        .extra_json
-        .as_deref()
-        .and_then(|s| serde_json::from_str::<serde_json::Value>(s).ok())
-        .and_then(|v| v.get("__runTargetProgram").and_then(|p| p.as_str()).map(str::to_owned))
-        .or_else(|| config.program.clone())
-        .unwrap_or_else(|| dbg.command.clone());
-    let metadata = serde_json::from_value(json!({"id":"debug", "name":config.name, "kind":"shell", "command":program, "args":[], "cwd":config.cwd, "env":{}, "detected":false, "isTest":false}))
-        .map_err(|e| IdeError::invalid(e.to_string()))?;
-    let (validator, root, target, token) = (plugins.clone(), project.root.clone(), id.clone(), cancel.clone());
-    host.blocking(move || {
-        validator.prepare_run_target_launch(&root, &target, &metadata, ide_plugin::RunTargetOperation::Debug, &token)
-    })
-    .await?;
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
     let mapping = TargetMapping {
         paths: PathMapping::new(&project.root.to_string_lossy(), &container),
         external_prefix: format!(
@@ -66,7 +48,6 @@ pub(super) async fn start(
         .map_err(|e| IdeError::invalid(e.to_string()))?
         .unwrap_or(json!({}));
     extra.as_object_mut().ok_or_else(|| IdeError::invalid("invalid debug launch arguments"))?.remove("__runTarget");
-    extra.as_object_mut().unwrap().remove("__runTargetProgram");
     // DAP paths already use target coordinates; adapter-native mappings stay identity.
     if placement == "connect-back" {
         config.program = None;

crates/ide-host/src/ops/lsp.rs

@@ -197,7 +197,6 @@ fn plugin_completion(item: ide_plugin::CompletionItem) -> CompletionItem {
     CompletionItem {
         label: item.label,
         label_detail: None,
-        label_description: None,
         detail: item.detail,
         kind,
         documentation: item.documentation.map(|value| Markup { kind: "markdown".into(), value }),
@@ -585,82 +584,6 @@ pub async fn lsp_virtual_document(host: &Host, window: &str, uri: String) -> Ide
     host.project(window)?.lsp.virtual_document(&uri).await
 }
 
-/// Whether this class belongs to the project's Maven local repository.
-pub async fn lsp_can_download_sources(host: &Host, window: &str, uri: String) -> IdeResult<bool> {
-    let project = host.project(window)?;
-    if !project.is_trusted() {
-        return Ok(false);
-    }
-    let Some(jar) = ide_lsp::LspManager::library_archive(&uri) else { return Ok(false) };
-    host.blocking(move || {
-        let settings = project.settings.effective();
-        let repository = ide_sdk::apply::maven_local_repository(&project.root, &settings)
-            .or_else(ide_build::maven::default_local_repo);
-        Ok(repository.is_some_and(|repo| ide_build::maven::sources::artifact(&jar, &repo).is_some())
-            && ide_build::maven::has_projects(&project.root, &settings.languages.java.maven))
-    })
-    .await
-}
-
-/// Download with the project's Maven configuration, or attach an archive selected by the user.
-pub async fn lsp_library_sources(
-    host: &Host,
-    window: &str,
-    request: RequestId,
-    uri: String,
-    pos: Pos,
-    sources: Option<std::path::PathBuf>,
-) -> IdeResult<Option<Location>> {
-    host.require_trust(window)?;
-    let project = host.project(window)?;
-    let cancel = host.begin_project_request(window, request);
-    let result = async {
-        let sources = match sources {
-            Some(sources) => Some(sources),
-            None => {
-                let jar = ide_lsp::LspManager::library_archive(&uri)
-                    .ok_or_else(|| IdeError::invalid("not a library class"))?;
-                let project = project.clone();
-                let cancel = cancel.clone();
-                host.blocking(move || {
-                    let settings = project.settings.effective();
-                    let repository = ide_sdk::apply::maven_local_repository(&project.root, &settings)
-                        .or_else(ide_build::maven::default_local_repo)
-                        .ok_or_else(|| IdeError::unavailable("Maven local repository is unavailable"))?;
-                    let artifact = ide_build::maven::sources::artifact(&jar, &repository)
-                        .ok_or_else(|| IdeError::invalid("not an artifact in the Maven local repository"))?;
-                    let model = super::build::load(&project.root, &project.build_cache_dir(), &settings);
-                    let maven = model.maven.ok_or_else(|| IdeError::unavailable("no Maven project"))?;
-                    let owns = |p: &&ide_build::maven::MavenProject| {
-                        p.dependencies.iter().any(|d| d.group_id == artifact.group && d.artifact_id == artifact.name)
-                    };
-                    let mut owner = maven
-                        .projects
-                        .iter()
-                        .find(owns)
-                        .or_else(|| maven.projects.first())
-                        .cloned()
-                        .ok_or_else(|| IdeError::unavailable("no Maven project"))?;
-                    let profiles =
-                        settings.languages.java.maven.profiles(&ide_build::maven_profiles(&project.build_cache_dir()));
-                    if !profiles.is_empty() {
-                        owner.options.push(format!("-P{}", profiles.join(",")));
-                    }
-                    ide_build::maven::sources::download(&project.root, &owner, &artifact, &repository, &cancel)
-                })
-                .await?
-            }
-        };
-        match sources {
-            Some(sources) => project.lsp.library_source_location(&uri, sources, pos, &cancel).await,
-            None => Ok(None),
-        }
-    }
-    .await;
-    host.end_request(request);
-    result
-}
-
 /// Opens compiled classes through JDT, with project source taking priority on disk.
 pub async fn lsp_resolve_class_file(host: &Host, window: &str, path: std::path::PathBuf) -> IdeResult<String> {
     let archive = ide_vfs::split_archive_path(&path);
@@ -899,8 +822,6 @@ fn plugin_code_action(plugin: &str, root: &Path, a: ide_plugin::CodeAction) -> C
         .and_then(|r| serde_json::to_value(r).ok());
     CodeAction {
         title: a.title,
-        diagnostics: Vec::new(),
-        original_diagnostics: None,
         kind: a.kind,
         is_preferred: a.preferred,
         disabled_reason,
@@ -1725,14 +1646,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
         |c| async move { lsp_resolve_class_file(&c.host, &c.window, c.arg("path")?).await },
     );
     d.add("lsp_virtual_document", |c| async move { lsp_virtual_document(&c.host, &c.window, c.arg("uri")?).await });
-    d.add(
-        "lsp_can_download_sources",
-        |c| async move { lsp_can_download_sources(&c.host, &c.window, c.arg("uri")?).await },
-    );
-    d.add("lsp_library_sources", |c| async move {
-        lsp_library_sources(&c.host, &c.window, c.arg("request")?, c.arg("uri")?, c.arg("pos")?, c.arg("sources")?)
-            .await
-    });
     d.add("lsp_references", |c| async move {
         let on_partial = c.sender("onPartial")?;
         lsp_references(

crates/ide-host/src/ops/run.rs

@@ -203,22 +203,8 @@ pub fn apply_settings(host: &Host, window: &str, configs: Vec<RunConfig>) -> Ide
 }
 
 pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emit<OutputChunk>) -> IdeResult<RunInfo> {
-    start_request(host, window, config, on_output, None).await
-}
-
-pub async fn start_request(
-    host: &Host,
-    window: &str,
-    config: RunConfig,
-    on_output: Emit<OutputChunk>,
-    request: Option<ide_core::RequestId>,
-) -> IdeResult<RunInfo> {
-    let cancel = request.map(|id| host.begin_request(id)).unwrap_or_default();
     let operation = config.extras.params.get("plugin.operation").cloned();
-    let result = start_inner(host, window, config, on_output, &cancel).await;
-    if let Some(id) = request {
-        host.end_request(id);
-    }
+    let result = start_inner(host, window, config, on_output).await;
     if let (Ok(info), Some(operation), Some(plugins)) = (&result, operation, host.plugin_host()) {
         plugins.run_operation_started(window, &operation, info.id);
     }
@@ -230,11 +216,7 @@ async fn start_inner(
     window: &str,
     mut config: RunConfig,
     on_output: Emit<OutputChunk>,
-    cancel: &ide_core::CancellationToken,
 ) -> IdeResult<RunInfo> {
-    if cancel.is_cancelled() {
-        return Err(IdeError::cancelled());
-    }
     host.require_trust(window)?;
     let project = host.project(window)?;
     if config.extras.target.is_none() {
@@ -277,23 +259,7 @@ async fn start_inner(
                 host.plugin_host().ok_or_else(|| IdeError::not_found("plugin run target is no longer available"))?;
             let root = project.root.clone();
             let id = id.to_owned();
-            let token = cancel.clone();
-            let config = host
-                .blocking(move || {
-                    let operation =
-                        if config.extras.params.get("plugin.targetOperation").is_some_and(|op| op == "debug") {
-                            ide_plugin::RunTargetOperation::Debug
-                        } else if config.is_test {
-                            ide_plugin::RunTargetOperation::Test
-                        } else {
-                            ide_plugin::RunTargetOperation::Run
-                        };
-                    plugins.prepare_run_target_launch(&root, &id, &config, operation, &token)
-                })
-                .await?;
-            if cancel.is_cancelled() {
-                return Err(IdeError::cancelled());
-            }
+            let config = host.blocking(move || plugins.prepare_run_target(&root, &id, &config)).await?;
             project.require_trust()?;
             return host.processes.start(
                 &project.root,

crates/ide-host/src/ops/vcs/commands.rs

@@ -673,11 +673,10 @@ pub async fn vcs_rename_branch(
     repo: Option<PathBuf>,
     from: String,
     to: String,
-    unset_upstream: bool,
 ) -> IdeResult<()> {
     host.require_trust(window)?;
     let project = host.project(window)?;
-    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to, unset_upstream))).await
+    blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to))).await
 }
 
 pub async fn vcs_merge(host: &Host, window: &str, repo: Option<PathBuf>, branch: String) -> IdeResult<()> {
@@ -996,17 +995,7 @@ pub async fn vcs_rebase_with(
 
 pub async fn vcs_remotes(host: &Host, window: &str, repo: Option<PathBuf>) -> IdeResult<Vec<Remote>> {
     let project = LogAccess::new(host, window, repo.as_deref());
-    blocking(move || {
-        let mut remotes = project.with_log_repo_at(repo.as_deref(), |r| r.remotes())?;
-        for r in &mut remotes {
-            let resolved = ide_ssh::resolve_ssh_remote_url(&r.url);
-            if resolved != r.url {
-                r.resolved_url = Some(resolved);
-            }
-        }
-        Ok(remotes)
-    })
-    .await
+    blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.remotes())).await
 }
 
 pub async fn vcs_edit_remote(host: &Host, window: &str, repo: Option<PathBuf>, edit: RemoteEdit) -> IdeResult<()> {
@@ -1390,8 +1379,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
         vcs_restore_branch(&c.host, &c.window, c.arg("repo")?, c.arg("deleted")?).await
     });
     d.add("vcs_rename_branch", |c| async move {
-        vcs_rename_branch(&c.host, &c.window, c.arg("repo")?, c.arg("from")?, c.arg("to")?, c.arg("unset_upstream")?)
-            .await
+        vcs_rename_branch(&c.host, &c.window, c.arg("repo")?, c.arg("from")?, c.arg("to")?).await
     });
     d.add("vcs_merge", |c| async move { vcs_merge(&c.host, &c.window, c.arg("repo")?, c.arg("branch")?).await });
     d.add("vcs_rebase", |c| async move { vcs_rebase(&c.host, &c.window, c.arg("repo")?, c.arg("onto")?).await });

crates/ide-host/src/plugins/intellij.rs

@@ -78,25 +78,6 @@ pub fn read_source(path: &Path) -> IdeResult<IntellijThemeSource> {
 /// The theme plugins of the JetBrains IDEs (and Android Studio) of this user,
 /// the themes their IDEs are set to first.
 pub fn installed_themes() -> Vec<InstalledIntellijTheme> {
-    find_installed(&latest_product_versions(local_ide_dirs()))
-}
-
-/// The settings folder of a JetBrains IDE (or Android Studio) of this user.
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct InstalledIdeSettings {
-    /// The IDE and its version: `IntelliJ IDEA 2025.2`.
-    pub ide: String,
-    /// What Import Settings reads.
-    pub path: IpcPath,
-}
-
-/// The settings folders of the JetBrains IDEs of this user, most recently used first.
-pub fn installed_ide_settings() -> Vec<InstalledIdeSettings> {
-    settings_folders(&local_ide_dirs())
-}
-
-fn local_ide_dirs() -> Vec<IdeDir> {
     let Some(home) = dirs::home_dir() else { return Vec::new() };
     let layout = if cfg!(target_os = "macos") {
         Layout::Mac
@@ -105,65 +86,7 @@ fn local_ide_dirs() -> Vec<IdeDir> {
     } else {
         Layout::Xdg
     };
-    ide_dirs(layout, &home, |key| std::env::var_os(key))
-}
-
-fn settings_folders(ides: &[IdeDir]) -> Vec<InstalledIdeSettings> {
-    let mut used: Vec<_> =
-        ides.iter().filter_map(|ide| settings_modified(&ide.config).map(|time| (ide, time))).collect();
-    used.sort_by(|(a, at), (b, bt)| {
-        bt.cmp(at).then_with(|| a.label.cmp(&b.label)).then_with(|| a.config.cmp(&b.config))
-    });
-    used.into_iter()
-        .map(|(ide, _)| InstalledIdeSettings { ide: ide.label.clone(), path: ide.config.clone().into() })
-        .collect()
-}
-
-fn settings_modified(config: &Path) -> Option<std::time::SystemTime> {
-    let options = config.join("options");
-    // Match the folder reader: never count links or walk below the settings directories.
-    if !config.symlink_metadata().ok()?.is_dir() || !options.symlink_metadata().ok()?.is_dir() {
-        return None;
-    }
-    let mut modified = None;
-    let mut customised = false;
-    for entry in std::fs::read_dir(&options).ok()?.flatten() {
-        let path = entry.path();
-        if !entry.file_type().is_ok_and(|t| t.is_file())
-            || !path.extension().is_some_and(|e| e.eq_ignore_ascii_case("xml"))
-        {
-            continue;
-        }
-        let Ok(meta) = entry.metadata() else { continue };
-        modified = modified.max(meta.modified().ok());
-        // Startup bookkeeping can exist before the user has changed any settings.
-        let name = entry.file_name();
-        customised |= meta.len() > 0
-            && !matches!(
-                name.to_str(),
-                Some(
-                    "other.xml"
-                        | "nonRoamable.xml"
-                        | "early-access-registry.xml"
-                        | "applicationInfo.xml"
-                        | "updates.xml"
-                        | "usage.statistics.xml"
-                )
-            );
-    }
-    customised |= ["keymaps", "codestyles", "colors", "templates", "inspection"].iter().any(|sub| {
-        let dir = config.join(sub);
-        dir.symlink_metadata().is_ok_and(|m| m.is_dir())
-            && std::fs::read_dir(dir).into_iter().flatten().flatten().any(|entry| {
-                entry.file_type().is_ok_and(|t| t.is_file())
-                    && entry.metadata().is_ok_and(|m| m.len() > 0)
-                    && entry
-                        .path()
-                        .extension()
-                        .is_some_and(|e| e.eq_ignore_ascii_case("xml") || e.eq_ignore_ascii_case("icls"))
-            })
-    });
-    customised.then(|| modified.or_else(|| options.metadata().ok()?.modified().ok()).unwrap_or(std::time::UNIX_EPOCH))
+    find_installed(&ide_dirs(layout, &home, |key| std::env::var_os(key)))
 }
 
 fn read(path: &Path) -> Result<IntellijThemeSource, String> {
@@ -499,7 +422,8 @@ struct IdeDir {
     plugins: PathBuf,
 }
 
-/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest version first.
+/// The settings folders of JetBrains IDEs and Android Studio (2020.1 and later), newest first, one
+/// per product: its newest version's (an upgrade leaves the older ones behind).
 fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>) -> Vec<IdeDir> {
     let var = |key: &str| env(key).filter(|v| !v.is_empty()).map(PathBuf::from);
     let (config_root, data_root) = match layout {
@@ -539,14 +463,9 @@ fn ide_dirs(layout: Layout, home: &Path, env: impl Fn(&str) -> Option<OsString>)
         }
     }
     out.sort_by(|a, b| b.version.cmp(&a.version).then_with(|| a.label.cmp(&b.label)));
-    out
-}
-
-/// Theme discovery only uses the newest version of each product.
-fn latest_product_versions(mut ides: Vec<IdeDir>) -> Vec<IdeDir> {
     let mut products = std::collections::HashSet::new();
-    ides.retain(|ide| products.insert(ide.product.clone()));
-    ides
+    out.retain(|ide| products.insert(ide.product.clone()));
+    out
 }
 
 /// `IntelliJIdea2025.2` → (`IntelliJIdea`, (2025, 2), `2025.2`).
@@ -868,16 +787,15 @@ mod tests {
         };
         let mac = mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.2"));
         mk(home.join("Library/Application Support/JetBrains/Toolbox"));
-        // Settings import keeps every version; theme discovery uses only the newest.
+        // An upgrade leaves the older version's folder behind: only the newest of a product counts.
         mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2024.3"));
         mk(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10"));
         let dirs = ide_dirs(Layout::Mac, home, |_| None);
-        assert_eq!(dirs.len(), 3);
+        assert_eq!(dirs.len(), 1);
         assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.10");
-        assert_eq!(latest_product_versions(dirs).len(), 1);
         std::fs::remove_dir(home.join("Library/Application Support/JetBrains/IntelliJIdea2025.10")).unwrap();
         let dirs = ide_dirs(Layout::Mac, home, |_| None);
-        assert_eq!(dirs.len(), 2);
+        assert_eq!(dirs.len(), 1);
         assert_eq!(dirs[0].label, "IntelliJ IDEA 2025.2");
         assert_eq!((dirs[0].config.clone(), dirs[0].plugins.clone()), (mac.clone(), mac.join("plugins")));
 
@@ -963,107 +881,4 @@ mod tests {
         assert_eq!(found, [theme("shallow-id", "Shallow", false, true), theme("deep-sea-id", "Deep Sea", true, false)]);
         assert!(find_installed(&[]).is_empty());
     }
-
-    #[test]
-    fn unused_newer_versions_do_not_hide_settings() {
-        let tmp = tempfile::tempdir().unwrap();
-        for (layout, root) in [
-            (Layout::Mac, "Library/Application Support"),
-            (Layout::Windows, "AppData/Roaming"),
-            (Layout::Xdg, ".config"),
-        ] {
-            let root = tmp.path().join(root).join("JetBrains");
-            let used = root.join("IntelliJIdea2024.3");
-            let fresh = root.join("IntelliJIdea2025.2");
-            write(&used.join("options/editor.xml"), b"<application><component name=\"EditorSettings\"/></application>");
-            std::fs::create_dir_all(&fresh).unwrap();
-            let expected = vec![InstalledIdeSettings { ide: "IntelliJ IDEA 2024.3".into(), path: used.into() }];
-            assert_eq!(settings_folders(&ide_dirs(layout, tmp.path(), |_| None)), expected);
-            write(&fresh.join("options/other.xml"), b"<application/>");
-            write(&fresh.join("options/early-access-registry.xml"), b"<application/>");
-            assert_eq!(settings_folders(&ide_dirs(layout, tmp.path(), |_| None)), expected);
-        }
-    }
-
-    #[test]
-    fn settings_candidates_keep_used_versions_and_sort_by_options_modification() {
-        let tmp = tempfile::tempdir().unwrap();
-        let root = tmp.path().join("Library/Application Support/JetBrains");
-        let put = |product: &str, file: &str, seconds| {
-            let path = root.join(product).join(file);
-            write(&path, b"<application/>");
-            std::fs::File::open(path)
-                .unwrap()
-                .set_modified(std::time::UNIX_EPOCH + std::time::Duration::from_secs(seconds))
-                .unwrap();
-        };
-        put("IntelliJIdea2025.2", "options/editor.xml", 100);
-        put("IntelliJIdea2024.3", "options/editor.xml", 200);
-        put("IntelliJIdea2024.3", "options/editor-font.xml", 400);
-        put("PyCharm2025.1", "options/editor.xml", 300);
-        // Directory times and unrelated files do not change options-file ordering.
-        write(&root.join("IntelliJIdea2025.2/options/README.txt"), b"recent");
-        let dirs = ide_dirs(Layout::Mac, tmp.path(), |_| None);
-        let found = settings_folders(&dirs);
-        assert_eq!(
-            found.iter().map(|s| s.ide.as_str()).collect::<Vec<_>>(),
-            ["IntelliJ IDEA 2024.3", "PyCharm 2025.1", "IntelliJ IDEA 2025.2"]
-        );
-        assert_eq!(found[0].path, root.join("IntelliJIdea2024.3"));
-        assert_eq!(latest_product_versions(dirs).len(), 2);
-    }
-
-    #[test]
-    fn skips_empty_and_startup_only_settings_but_keeps_custom_schemes() {
-        let tmp = tempfile::tempdir().unwrap();
-        let config = tmp.path();
-        assert!(settings_modified(config).is_none());
-        std::fs::create_dir(config.join("options")).unwrap();
-        assert!(settings_modified(config).is_none());
-        for file in ["other", "nonRoamable", "early-access-registry", "applicationInfo", "updates", "usage.statistics"]
-        {
-            write(
-                &config.join(format!("options/{file}.xml")),
-                b"<application><component name=\"Startup\"/></application>",
-            );
-        }
-        write(&config.join("options/editor.xml"), b"");
-        write(&config.join("options/nested/editor.xml"), b"<application/>");
-        for sub in ["keymaps", "codestyles", "colors", "templates", "inspection"] {
-            std::fs::create_dir(config.join(sub)).unwrap();
-            write(&config.join(sub).join("README.txt"), b"not settings");
-        }
-        assert!(settings_modified(config).is_none());
-        for (sub, file) in [
-            ("keymaps", "custom.xml"),
-            ("codestyles", "custom.xml"),
-            ("colors", "custom.icls"),
-            ("templates", "custom.xml"),
-            ("inspection", "custom.xml"),
-        ] {
-            let path = config.join(sub).join(file);
-            write(&path, b"<custom/>");
-            assert!(settings_modified(config).is_some(), "{sub} is a user setting");
-            std::fs::remove_file(path).unwrap();
-        }
-    }
-
-    #[test]
-    fn lists_the_settings_folders_of_ides_that_have_been_run() {
-        let tmp = tempfile::tempdir().unwrap();
-        let ide = |label: &str, product: &str, version: (u32, u32)| {
-            let config = tmp.path().join(format!("{product}{}.{}", version.0, version.1));
-            IdeDir { label: label.into(), product: product.into(), version, config: config.clone(), plugins: config }
-        };
-        let used = ide("IntelliJ IDEA 2025.2", "IntelliJIdea", (2025, 2));
-        let fresh = ide("PyCharm 2025.1", "PyCharm", (2025, 1));
-        let used_config = used.config.clone();
-        write(&used_config.join("options/editor.xml"), b"<application/>");
-        std::fs::create_dir_all(&fresh.config).unwrap();
-        assert_eq!(
-            settings_folders(&[used, fresh]),
-            [InstalledIdeSettings { ide: "IntelliJ IDEA 2025.2".into(), path: used_config.into() }]
-        );
-        assert!(settings_folders(&[]).is_empty());
-    }
 }

crates/ide-host/src/plugins/mod.rs

@@ -143,8 +143,6 @@ struct Meta {
     retry_at: Option<Instant>,
     /// The component exports `syntax-provider` (known once activated).
     has_syntax: bool,
-    /// Known before activation can publish target registrations.
-    has_run_target_validation: bool,
     /// Next `on-schedule` activation.
     next_schedule: Option<Instant>,
     /// The trusted publisher of a signed installed package.
@@ -166,7 +164,6 @@ impl Meta {
             failures: 0,
             retry_at: None,
             has_syntax: false,
-            has_run_target_validation: false,
             publisher: None,
             next_schedule: None,
         }
@@ -1435,20 +1432,6 @@ impl PluginHost {
         cancel: Option<&ide_core::CancellationToken>,
         f: impl Fn(&mut Runtime, Invocation) -> Result<R, CallError> + Clone + Send + 'static,
     ) -> IdeResult<R> {
-        self.code_call_with_budget(id, invocation, what, cancel, None, f)
-    }
-
-    fn code_call_with_budget<R: Send + 'static>(
-        &self,
-        id: &str,
-        invocation: Invocation,
-        what: &str,
-        cancel: Option<&ide_core::CancellationToken>,
-        budget: Option<Duration>,
-        f: impl Fn(&mut Runtime, Invocation) -> Result<R, CallError> + Clone + Send + 'static,
-    ) -> IdeResult<R> {
-        let deadline = budget.map(|budget| Instant::now() + budget);
-        let fallback = ide_core::CancellationToken::new();
         let plugin = self.get(id)?;
         let client = invocation.client.clone();
         {
@@ -1489,25 +1472,10 @@ impl PluginHost {
             }
             let started = Instant::now();
             let (call, inv) = (f.clone(), invocation.clone());
-            let result = match (deadline, cancel) {
-                (Some(deadline), cancel) => actor.call_bounded(
-                    cancel.unwrap_or(&fallback),
-                    Duration::from_millis(50),
-                    deadline.saturating_duration_since(Instant::now()),
-                    move |rt| call(rt, inv),
-                ),
-                (None, Some(cancel)) => {
-                    actor.call_cancellable(cancel, Duration::from_millis(50), move |rt| call(rt, inv))
-                }
-                (None, None) => actor.call(None, move |rt| call(rt, inv)),
+            let result = match cancel {
+                Some(cancel) => actor.call_cancellable(cancel, Duration::from_millis(50), move |rt| call(rt, inv)),
+                None => actor.call(None, move |rt| call(rt, inv)),
             };
-            if deadline.is_some() && matches!(result, Err(ActorError::SoftTimeout)) {
-                self.reap(&plugin, &actor, client.as_deref());
-                return Err(IdeError::new(
-                    ide_core::error::ErrorKind::TimedOut,
-                    format!("plugin {id:?} timed out while {what}"),
-                ));
-            }
             if matches!(result, Err(ActorError::Cancelled)) {
                 self.reap(&plugin, &actor, client.as_deref());
                 return Err(IdeError::cancelled());
@@ -2555,7 +2523,6 @@ impl PluginHost {
                 return Err(IdeError::internal(format!("plugin {:?} {e}", plugin.id())));
             }
         };
-        plugin.meta.lock().has_run_target_validation = rt.has_run_target_validation();
         let crash = match rt.activate() {
             Ok(_) => None,
             Err(CallError::Trap(e)) => Some(format!("activation {e}")),

crates/ide-host/src/plugins/run_targets.rs

@@ -101,28 +101,6 @@ impl PluginHost {
         root: &Path,
         id: &str,
         config: &ide_run::RunConfig,
-    ) -> IdeResult<ide_run::RunConfig> {
-        self.prepare_target(root, id, config, None)
-    }
-
-    /// Prepares a user launch, including the optional plugin validation gate.
-    pub fn prepare_run_target_launch(
-        &self,
-        root: &Path,
-        id: &str,
-        config: &ide_run::RunConfig,
-        operation: ide_plugin::RunTargetOperation,
-        cancel: &ide_core::CancellationToken,
-    ) -> IdeResult<ide_run::RunConfig> {
-        self.prepare_target(root, id, config, Some((operation, cancel)))
-    }
-
-    fn prepare_target(
-        &self,
-        root: &Path,
-        id: &str,
-        config: &ide_run::RunConfig,
-        launch: Option<(ide_plugin::RunTargetOperation, &ide_core::CancellationToken)>,
     ) -> IdeResult<ide_run::RunConfig> {
         if !self.shared.workspace().is_some_and(|w| w.trusted(root)) {
             return Err(IdeError::new(ide_core::error::ErrorKind::PermissionDenied, "project is not trusted"));
@@ -135,50 +113,7 @@ impl PluginHost {
             .cloned()
             .ok_or_else(|| IdeError::not_found("plugin run target is no longer available"))?;
         let program = self.program_for_project(&target.plugin_id, &target.target.program, Some(root))?;
-        let wrapped = ide_remote::plugin_target::prepare(root, &target.target, &program, config)?;
-        let validates = self.get(&target.plugin_id)?.meta.lock().has_run_target_validation;
-        if let Some((operation, cancel)) = launch
-            && validates
-        {
-            if cancel.is_cancelled() {
-                return Err(IdeError::cancelled());
-            }
-            let info = ide_plugin::RunTargetLaunch {
-                operation,
-                program: ide_run::wrap::program_name(&config.command),
-                cwd: wrapped.cwd.as_ref().unwrap().to_string_lossy().into_owned(),
-            };
-            let project_root = root.to_path_buf();
-            let invocation =
-                ide_plugin::Invocation { workspace_root: Some(project_root.clone()), ..Default::default() };
-            let (target_id, timeout) = (target.target.id.clone(), self.limits.timeout);
-            let result = self.code_call_with_budget(
-                &target.plugin_id,
-                invocation,
-                "validating the run target",
-                Some(cancel),
-                Some(timeout),
-                move |rt, _| {
-                    rt.validate_run_target(
-                        project_root.to_string_lossy().into_owned(),
-                        target_id.clone(),
-                        info.clone(),
-                        timeout,
-                    )
-                },
-            );
-            match result {
-                Ok(Ok(())) => {}
-                Ok(Err(message)) => return Err(IdeError::invalid(format!("{}: {message}", target.plugin_name))),
-                Err(error) if error.kind == ide_core::error::ErrorKind::Cancelled => return Err(error),
-                Err(error) => return Err(IdeError::unavailable(format!("{}: {error}", target.plugin_name))),
-            }
-            if cancel.is_cancelled() {
-                return Err(IdeError::cancelled());
-            }
-            self.program_for_project(&target.plugin_id, &target.target.program, Some(root))?;
-        }
-        Ok(wrapped)
+        ide_remote::plugin_target::prepare(root, &target.target, &program, config)
     }
 }
 

crates/ide-host/src/project.rs

@@ -412,7 +412,6 @@ impl Host {
                 Box::new(move |batch| {
                     let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
                     let (ignored, ignored_gone) = ignored_changes(batch);
-                    index.ignore_rules_changed(&batch.ignore_rules);
                     index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
                     kotlin_bridge.files_changed(changed.iter().chain(&batch.removed));
                     phpstan.files_removed(batch.removed.iter());
@@ -1310,7 +1309,6 @@ fn content_root_watcher(
         Box::new(move |batch| {
             let changed: Vec<PathBuf> = batch.created.iter().chain(&batch.modified).cloned().collect();
             let (ignored, ignored_gone) = ignored_changes(batch);
-            index.ignore_rules_changed(&batch.ignore_rules);
             index.update(&[&changed[..], &ignored].concat(), &[&batch.removed[..], &ignored_gone].concat());
             // A workspace member's PHP language level follows its own composer.json.
             if composer_changed(&root, changed.iter().chain(&batch.removed)) {

crates/ide-host/src/rpc.rs

@@ -262,7 +262,7 @@ impl Dispatcher {
         .add("run_system_env", |_| async move { Ok(ide_run::system_env()) })
         .add("run_start", |c| async move {
             let on_output = c.channel("onOutput")?;
-            ops::run::start_request(&c.host, &c.window, c.arg("config")?, on_output, c.arg("request")?).await
+            ops::run::start(&c.host, &c.window, c.arg("config")?, on_output).await
         })
         .add("run_stop", |c| async move { ops::run::stop(&c.host, &c.window, c.arg("id")?) })
         .add("run_stdin", |c| async move { ops::run::stdin(&c.host, c.arg("id")?, &c.arg::<String>("data")?) })

crates/ide-host/src/trust.rs

@@ -247,7 +247,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
             | "clipboard_has_files"
             | "clipboard_image"
             | "clipboard_set_file_list"
-            | "clipboard_write_text"
             | "jdk_download_vendors"
             | "jdk_download_releases"
             | "jdk_download_location"
@@ -455,11 +454,3 @@ impl TrustStore {
         Ok(TrustStatus { decided: trusted || state.restricted.contains(&root), root: root.into(), trusted })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn restricted_mode_allows_clipboard_write_text() {
-        assert!(super::restricted_command_allowed("clipboard_write_text"));
-    }
-}

crates/ide-host/tests/plugin_workbench.rs

@@ -352,203 +352,3 @@ async fn plugin_run_targets_register_prompt_route_revalidate_and_withdraw() {
     assert!(plugins.run_targets(&f.root).is_empty());
     plugins.shutdown();
 }
-
-#[cfg(unix)]
-#[tokio::test(flavor = "multi_thread")]
-async fn run_target_api15_overrides_and_frozen_api14_registration() {
-    use ide_host::plugins::{Consent, PluginHost};
-    use ide_plugin::{Invocation, Limits, PluginEngine};
-    use std::os::unix::fs::PermissionsExt;
-    let f = Harness::new();
-    f.host.set_project_trust(&f.root, true, false).await.unwrap();
-    let plugins = Arc::new(
-        PluginHost::new(f._tmp.path().join("plugins"), Arc::new(|_: Option<&str>, _| {}), Limits::default()).unwrap(),
-    );
-    plugins.set_workspace(Some(Arc::new(f.workspace())));
-    f.host.set_plugin_host(&plugins);
-    let fixtures = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures");
-    let engine = PluginEngine::new().unwrap();
-    let legacy = engine.compile(&fixtures.join("run-target-api14/dist/plugin.wasm")).unwrap();
-    assert_eq!(engine.check_component(&legacy).unwrap().unwrap().to_string(), "1.4.0");
-    let tool = f._tmp.path().join("wrapper");
-    std::fs::write(&tool, "#!/bin/sh\nexit 0\n").unwrap();
-    std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
-    let invocation =
-        || Invocation { client: Some("main".into()), workspace_root: Some(f.root.clone()), ..Default::default() };
-    let config: ide_run::RunConfig = serde_json::from_value(serde_json::json!({
-        "id":"composer", "name":"Composer", "kind":"shell", "command":"composer", "args":["install"],
-        "env":{}, "detected":false, "isTest":false,
-    }))
-    .unwrap();
-    for (plugin, command) in [("run-target-api14", "target"), ("execution", "target-overrides")] {
-        plugins.install_from_dir(&fixtures.join(plugin), &Consent::all()).unwrap();
-        assert!(plugins.run_command(plugin, command, Some("empty"), invocation()).is_err());
-        plugins.choose_program(plugin, "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
-        let cases = if plugin == "execution" {
-            vec![
-                ("empty", vec!["composer", "install"]),
-                ("own", vec!["composer", "--working-dir=/container", "install"]),
-                ("inherit", vec!["composer", "--cwd=/container", "install"]),
-            ]
-        } else {
-            vec![("inherit", vec!["composer", "--cwd=/container", "install"])]
-        };
-        for (arg, expected) in cases {
-            plugins.run_command(plugin, command, Some(arg), invocation()).unwrap();
-            let target = plugins.run_targets(&f.root).into_iter().find(|t| t.plugin_id == plugin).unwrap();
-            let wrapped = plugins
-                .prepare_run_target_launch(
-                    &f.root,
-                    &target.id,
-                    &config,
-                    ide_plugin::RunTargetOperation::Run,
-                    &Default::default(),
-                )
-                .unwrap();
-            assert_eq!(wrapped.args, expected);
-            assert_eq!(PathBuf::from(wrapped.command), tool);
-            assert_eq!(wrapped.cwd.unwrap(), f.root);
-            let php = ide_run::RunConfig { command: "php".into(), args: vec!["x.php".into()], ..config.clone() };
-            assert_eq!(
-                plugins.prepare_run_target(&f.root, &target.id, &php).unwrap().args,
-                ["wrapped", "--cwd=/container", "php", "x.php"]
-            );
-        }
-        if plugin == "execution" {
-            assert!(plugins.run_command(plugin, command, Some("invalid"), invocation()).is_err());
-            // A failed replacement retains the previous valid registration.
-            assert_eq!(plugins.run_targets(&f.root).iter().filter(|t| t.plugin_id == plugin).count(), 1);
-        }
-        plugins.set_capability(plugin, "process:execution-tool", false).unwrap();
-        assert!(plugins.run_targets(&f.root).iter().all(|t| t.plugin_id != plugin));
-        assert!(plugins.run_command(plugin, command, None, invocation()).is_err());
-        plugins.choose_program(plugin, "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
-        f.host.set_project_trust(&f.root, false, false).await.unwrap();
-        assert!(plugins.run_command(plugin, command, None, invocation()).unwrap_err().to_string().contains("trusted"));
-        f.host.set_project_trust(&f.root, true, false).await.unwrap();
-    }
-    plugins.shutdown();
-}
-
-#[cfg(unix)]
-#[tokio::test(flavor = "multi_thread")]
-async fn run_target_validation_gates_launches_and_preserves_selection() {
-    use ide_host::plugins::{Consent, PluginHost};
-    use ide_plugin::{Invocation, Limits, RunTargetOperation};
-    use std::os::unix::fs::PermissionsExt;
-    use std::time::Duration;
-    let f = Harness::new();
-    f.host.set_project_trust(&f.root, true, false).await.unwrap();
-    let plugins = Arc::new(
-        PluginHost::new(
-            f._tmp.path().join("plugins"),
-            Arc::new(|_: Option<&str>, _| {}),
-            Limits {
-                timeout: Duration::from_millis(200),
-                idle_timeout: Some(Duration::from_millis(20)),
-                restart_backoff: Duration::ZERO,
-                ..Default::default()
-            },
-        )
-        .unwrap(),
-    );
-    plugins.set_workspace(Some(Arc::new(f.workspace())));
-    f.host.set_plugin_host(&plugins);
-    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/execution");
-    plugins.install_from_dir(&fixture, &Consent::all()).unwrap();
-    let tool = f._tmp.path().join("wrapper");
-    std::fs::write(&tool, "#!/bin/sh\ntouch spawned\n").unwrap();
-    std::fs::set_permissions(&tool, std::fs::Permissions::from_mode(0o755)).unwrap();
-    plugins.choose_program("execution", "process:execution-tool", Some(&f.root), Some(&tool)).unwrap();
-    let invocation =
-        || Invocation { client: Some("main".into()), workspace_root: Some(f.root.clone()), ..Default::default() };
-    let config: ide_run::RunConfig = serde_json::from_value(serde_json::json!({
-        "id":"composer", "name":"Composer", "kind":"shell", "command":"/tools/composer", "args":["install"],
-        "env":{"SECRET":"not sent"}, "detected":false, "isTest":false,
-    }))
-    .unwrap();
-    for id in ["allow", "refuse", "long-refusal", "timeout", "trap"] {
-        plugins.run_command("execution", "target", Some(id), invocation()).unwrap();
-    }
-    let targets = plugins.run_targets(&f.root);
-    let id = |name: &str| targets.iter().find(|t| t.target.id == name).unwrap().id.clone();
-    for operation in [RunTargetOperation::Run, RunTargetOperation::Test, RunTargetOperation::Debug] {
-        plugins.prepare_run_target_launch(&f.root, &id("allow"), &config, operation, &Default::default()).unwrap();
-        let snapshot = plugins.run_command("execution", "validation", None, invocation()).unwrap().unwrap();
-        assert_eq!(snapshot, format!("{}|allow|{operation:?}|composer|{}", f.root.display(), f.root.display()));
-    }
-    tokio::time::sleep(Duration::from_millis(30)).await;
-    plugins.tick();
-    assert_eq!(plugins.info_of("execution").unwrap().status, ide_host::plugins::PluginStatus::Inactive);
-    plugins
-        .prepare_run_target_launch(&f.root, &id("allow"), &config, RunTargetOperation::Run, &Default::default())
-        .unwrap();
-    assert!(plugins.info_of("execution").unwrap().stats.reclaims > 0);
-    // Non-launch consumers (LSP and document reads) do not invoke validation.
-    assert!(plugins.prepare_run_target(&f.root, &id("refuse"), &config).is_ok());
-    let selected = id("refuse");
-    ide_host::plugins::run_targets::answer(&f.host, &plugins, "main", &selected, true).unwrap();
-    for is_test in [false, true] {
-        let mut config = config.clone();
-        config.is_test = is_test;
-        config.extras.target = Some(selected.clone());
-        let error = ide_host::ops::run::start(&f.host, "main", config, Arc::new(|_| {})).await.unwrap_err();
-        assert!(error.message.contains("Plugin execution tests: Project runtime is stopped"), "{error}");
-        assert!(f.host.processes.list().is_empty());
-        assert!(!f.root.join("spawned").exists());
-        assert_eq!(f.host.project("main").unwrap().settings.effective().run.default_target, selected);
-        assert_eq!(plugins.run_targets(&f.root).len(), targets.len());
-    }
-    for adapter in ["php-debug", "debugpy"] {
-        let launch = ide_dap::LaunchConfig {
-            name: "Refused debug".into(),
-            adapter: adapter.into(),
-            request: "launch".into(),
-            program: Some("app.php".into()),
-            args: Vec::new(),
-            cwd: Some(f.root.clone().into()),
-            env: Default::default(),
-            extra_json: Some(serde_json::json!({"__runTarget":selected, "__runTargetProgram":"php"}).to_string()),
-        };
-        let error = ide_host::ops::debug::debug_start(&f.host, "main", launch).await.unwrap_err();
-        assert!(error.message.contains("Project runtime is stopped"), "{adapter}: {error}");
-        assert!(f.host.debugger.sessions(None).is_empty());
-    }
-    let error = plugins
-        .prepare_run_target_launch(&f.root, &id("long-refusal"), &config, RunTargetOperation::Run, &Default::default())
-        .unwrap_err();
-    assert!(error.message.len() < 4200);
-    let request = ide_core::RequestId(2408);
-    let mut cfg = config.clone();
-    cfg.extras.target = Some(id("timeout"));
-    let worker = f.host.clone();
-    let pending = tokio::spawn(async move {
-        ide_host::ops::run::start_request(&worker, "main", cfg, Arc::new(|_| {}), Some(request)).await
-    });
-    tokio::time::sleep(Duration::from_millis(30)).await;
-    f.host.cancel_request(request);
-    assert_eq!(pending.await.unwrap().unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);
-    for name in ["timeout", "trap"] {
-        let started = std::time::Instant::now();
-        let error = plugins
-            .prepare_run_target_launch(&f.root, &id(name), &config, RunTargetOperation::Run, &Default::default())
-            .unwrap_err();
-        assert!(error.message.contains("Plugin execution tests"), "{error}");
-        if name == "timeout" {
-            assert!(error.message.contains("timed out"), "{error}");
-            assert!(started.elapsed() < Duration::from_secs(2), "background tasks must not extend validation");
-        }
-        assert!(f.host.processes.list().is_empty());
-    }
-    // A cancelled launch never enters the wrapper.
-    let cancel = ide_core::CancellationToken::new();
-    cancel.cancel();
-    assert_eq!(
-        plugins
-            .prepare_run_target_launch(&f.root, &id("allow"), &config, RunTargetOperation::Run, &cancel)
-            .unwrap_err()
-            .kind,
-        ide_core::error::ErrorKind::Cancelled
-    );
-    plugins.shutdown();
-}

crates/ide-host/tests/plugins.rs

@@ -3694,6 +3694,31 @@ fn listing_while_projects_change_does_not_deadlock() {
     }
 }
 
+/// Excalidraw: a web custom editor beside the text editor, with its fonts,
+/// file icon, template and language — no code.
+#[test]
+fn official_excalidraw_installs_and_serves_its_page() {
+    let tmp = tempfile::tempdir().unwrap();
+    let pkg = with_stand_in_page(&official("excalidraw"), tmp.path());
+    let f = fixture(Limits::default());
+    let info = f.install(&pkg);
+    assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
+    let page = f.host.web_page("openidea.excalidraw", "canvas").unwrap();
+    let (rev, entry) = page.path.strip_prefix("openidea.excalidraw/").unwrap().split_once('/').unwrap();
+    assert_eq!(entry, "web/index.html");
+    let html = f.host.web_file("openidea.excalidraw", &format!("{rev}/{entry}")).unwrap();
+    let html = String::from_utf8(html.bytes).unwrap();
+    // Relative URLs only: the page is served from the package.
+    let script = html.split("src=\"").nth(1).unwrap().split('"').next().unwrap();
+    assert!(script.starts_with("./assets/"), "{script}");
+    assert!(f.host.web_file("openidea.excalidraw", &format!("{rev}/web/{}", &script[2..])).is_ok());
+    let font = f.host.web_file("openidea.excalidraw", &format!("{rev}/web/fonts/Virgil/Virgil-Regular.woff2")).unwrap();
+    assert_eq!(font.mime, "font/woff2");
+    assert_eq!(f.host.ui_items("customEditors")[0].decl["layout"], "preview");
+    assert!(f.host.languages().iter().any(|l| l.id.as_str() == "excalidraw"));
+    assert_eq!(f.host.assets("openidea.excalidraw", "fileIcon/excalidraw/").unwrap().len(), 2);
+}
+
 /// A copy of the official plugin at `src` in `dir`, with a stand-in for its
 /// built page (`web/` is built by plugins/build.sh, not checked in; build.sh
 /// checks what the build produces): an entry loading a script and a font by
@@ -3735,18 +3760,7 @@ fn official_graphviz_turns_its_pages_reports_into_problems() {
     assert_eq!(info.status, PluginStatus::Inactive, "{:?}", info.error);
     assert_eq!(f.host.ui_items("customEditors")[0].decl["layout"], "split");
     assert!(f.host.languages().iter().any(|l| l.id.as_str() == "dot"));
-    assert_eq!(f.host.assets("openidea.graphviz", "fileIcon/graphviz/").unwrap().len(), 2);
-    let page = f.host.web_page("openidea.graphviz", "preview").unwrap();
-    let (rev, entry) = page.path.strip_prefix("openidea.graphviz/").unwrap().split_once('/').unwrap();
-    assert_eq!(entry, "web/index.html");
-    let html = f.host.web_file("openidea.graphviz", &format!("{rev}/{entry}")).unwrap();
-    let html = String::from_utf8(html.bytes).unwrap();
-    // Relative URLs only: the page is served from the package.
-    let script = html.split("src=\"").nth(1).unwrap().split('"').next().unwrap();
-    assert!(script.starts_with("./assets/"), "{script}");
-    assert!(f.host.web_file("openidea.graphviz", &format!("{rev}/web/{}", &script[2..])).is_ok());
-    let font = f.host.web_file("openidea.graphviz", &format!("{rev}/web/fonts/Virgil/Virgil-Regular.woff2")).unwrap();
-    assert_eq!(font.mime, "font/woff2");
+    assert!(f.host.web_page("openidea.graphviz", "preview").is_ok());
 
     std::fs::write(f.project.join("flow.dot"), "digraph {\n  a -> \n}\n").unwrap();
     let editor = f.workspace.open("flow.dot", &[]);

crates/ide-host/tests/remote_plugins.rs

@@ -548,7 +548,7 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     let bin = tmp.path().join("bin");
     std::fs::create_dir(&bin).unwrap();
     let executable = bin.join("execution-tool");
-    std::fs::write(&executable, "#!/bin/sh\nif [ \"$1\" = wrapped ]; then printf '<%s>\\n' \"$@\" > \"$PWD/wrapped.txt\"; exit; fi\nif [ \"$1\" = composer ]; then printf '<%s>\\n' \"$@\" > \"$PWD/composer.txt\"; exit; fi\nread line\nprintf '%s\\n' \"$line\"\n").unwrap();
+    std::fs::write(&executable, "#!/bin/sh\nif [ \"$1\" = wrapped ]; then printf '<%s>\\n' \"$@\" > \"$PWD/wrapped.txt\"; exit; fi\nread line\nprintf '%s\\n' \"$line\"\n").unwrap();
     std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755)).unwrap();
     let path_var = {
         let bin = bin.clone();
@@ -599,17 +599,9 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     )
     .await
     .unwrap();
-    invoke(
-        &peer,
-        "plugin_run_command",
-        json!({"pluginId":"execution", "commandId":"target-overrides", "arg":"empty", "editor":null}),
-    )
-    .await
-    .unwrap();
     let targets = invoke(&peer, "plugin_run_targets", json!({})).await.unwrap();
     assert_eq!(targets.as_array().unwrap().len(), 1);
     assert_eq!(targets[0]["pluginId"], "execution");
-    assert_eq!(targets[0]["target"]["commands"][0]["workdirArgs"], json!([]));
     assert!(desktop.run_targets(&project).is_empty());
     let id = targets[0]["id"].as_str().unwrap();
     let settings = invoke(&peer, "plugin_answer_run_target", json!({"id":id, "useTarget":false})).await.unwrap();
@@ -622,10 +614,6 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
         "<wrapped>\n<--cwd=/container>\n<php>\n<x.php>\n<literal ; $(touch bad)>\n"
     );
     assert!(!project.join("bad").exists());
-    let composer = json!({"id":"composer", "name":"Composer", "kind":"shell", "command":"composer", "args":["install"], "env":{}, "detected":false, "isTest":false, "target":id});
-    invoke(&peer, "run_start", json!({"config":composer, "onOutput":{"$channel":39}})).await.unwrap();
-    until("remote composer override", 5, || project.join("composer.txt").exists()).await;
-    assert_eq!(std::fs::read_to_string(project.join("composer.txt")).unwrap(), "<composer>\n<install>\n");
     invoke(
         &peer,
         "plugin_run_command",
@@ -634,28 +622,6 @@ async fn api14_stage3_remote_terminal_pins_and_exit_events_stay_on_the_execution
     .await
     .unwrap();
     assert_eq!(invoke(&peer, "plugin_run_targets", json!({})).await.unwrap(), json!([]));
-    invoke(
-        &peer,
-        "plugin_run_command",
-        json!({"pluginId":"execution", "commandId":"target", "arg":"refuse", "editor":null}),
-    )
-    .await
-    .unwrap();
-    let targets = invoke(&peer, "plugin_run_targets", json!({})).await.unwrap();
-    let refused = targets[0]["id"].as_str().unwrap();
-    std::fs::remove_file(project.join("wrapped.txt")).unwrap();
-    let config = json!({"id":"refused", "name":"Refused", "kind":"shell", "command":"php", "args":[], "env":{}, "detected":false, "isTest":false, "target":refused});
-    let error = invoke(&peer, "run_start", json!({"config":config, "onOutput":{"$channel":40}})).await.unwrap_err();
-    assert!(error.to_string().contains("Project runtime is stopped"), "{error}");
-    assert!(!project.join("wrapped.txt").exists());
-    assert!(desktop.run_targets(&project).is_empty());
-    invoke(
-        &peer,
-        "plugin_run_command",
-        json!({"pluginId":"execution", "commandId":"untarget", "arg":"refuse", "editor":null}),
-    )
-    .await
-    .unwrap();
     client.plugin_events.lock().clear();
     client.events.lock().clear();
     let runner = peer.clone();

crates/ide-host/tests/trust.rs

@@ -48,7 +48,6 @@ async fn application_commands_work_in_restricted_projects_and_without_a_project(
         "clipboard_has_files",
         "clipboard_image",
         "clipboard_set_file_list",
-        "clipboard_write_text",
         "jdk_download_vendors",
         "jdk_download_releases",
         "jdk_download_location",

crates/ide-host/tests/workspace_edits.rs

@@ -197,8 +197,6 @@ async fn code_actions_skip_a_command_no_server_provides_after_their_edit() {
     let info = ops::doc::open(&host, "main", file.clone()).await.unwrap();
     // Optimize Imports as vtsls offers it: the edit, then a command its client runs itself.
     let action = |edit: bool| CodeAction {
-        diagnostics: Vec::new(),
-        original_diagnostics: None,
         title: "Organize Imports".into(),
         kind: Some("source.organizeImports".into()),
         is_preferred: false,

crates/ide-index/src/filter.rs

@@ -138,10 +138,6 @@ impl PathFilter {
         &self.config.0 == extra_roots && self.config.1 == excludes
     }
 
-    pub(crate) fn reload(&self) -> Self {
-        Self::new(&self.root, &self.config.0, &self.config.1)
-    }
-
     pub(crate) fn root(&self) -> &Path {
         &self.root
     }

crates/ide-index/src/lib.rs

@@ -332,28 +332,6 @@ impl ProjectIndex {
         }
     }
 
-    /// Refreshes ignore matchers and indexed entries in the affected subtrees.
-    pub fn ignore_rules_changed(&self, dirs: &[PathBuf]) {
-        let filter = self.shared.filter();
-        let mut affected = Vec::new();
-        for dir in dirs {
-            let path = if dir.is_absolute() { dir.clone() } else { self.root.join(dir) };
-            let path = dunce::canonicalize(&path).unwrap_or(path);
-            for root in filter.roots() {
-                if path.starts_with(root) {
-                    affected.push(path.clone());
-                    break;
-                }
-                if root.starts_with(&path) {
-                    affected.push(root.to_path_buf());
-                }
-            }
-        }
-        if !affected.is_empty() {
-            self.shared.enqueue(Job::IgnoreRules(affected));
-        }
-    }
-
     /// Boost for "recent files" ranking.
     /// Records a recently opened file; a virtual document's URI (library
     /// class) is kept verbatim, like IDEA lists library classes in Recent Files.

crates/ide-index/src/tests.rs

@@ -750,66 +750,3 @@ fn persisted_symbols_do_not_load_through_escaping_symlink_ancestors() {
     assert!(symbols(&idx, "old_symbol", SymbolFilter::All).is_empty());
     assert_eq!(initial.lock()[0], 0, "unsafe cached symbols must never be published");
 }
-
-#[test]
-fn rule_changes_refresh_only_the_affected_index_subtree() {
-    for (rule, subtree) in [(".git/info/exclude", ""), ("sub/.gitignore", "sub"), ("sub/.ignore", "sub")] {
-        let fx = Fixture::new(&[
-            (".git/HEAD", "ref: refs/heads/main\n"),
-            ("sub/generated/file.ts", "export function generated() {}\n"),
-            ("sub/local.ts", "export function localOnly() {}\n"),
-            ("other/keep.ts", "export function keep() {}\n"),
-        ]);
-        fx.write(rule, "");
-        let idx = fx.open();
-        assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
-        fx.write(rule, "generated/\nlocal.ts\n");
-        let dirs = [fx.root.join(subtree)];
-        idx.ignore_rules_changed(&dirs);
-        assert!(idx.wait_idle(WAIT));
-        assert!(files(&idx, "file.ts").is_empty(), "{rule}: ignored directory remained indexed");
-        assert_eq!(files(&idx, "local.ts"), ["sub/local.ts"]);
-        assert!(symbols(&idx, "localOnly", SymbolFilter::All).is_empty());
-        assert_eq!(files(&idx, "keep.ts"), ["other/keep.ts"]);
-
-        fx.write(rule, "");
-        idx.ignore_rules_changed(&dirs);
-        assert!(idx.wait_idle(WAIT));
-        assert_eq!(files(&idx, "file.ts"), ["sub/generated/file.ts"]);
-        assert_eq!(symbols(&idx, "localOnly", SymbolFilter::All), ["localOnly"]);
-        // The cached root matcher must also follow the rules for later watcher updates.
-        let fresh = fx.write("sub/generated/new.ts", "export function fresh() {}\n");
-        idx.update(&[fresh], &[]);
-        assert!(idx.wait_idle(WAIT));
-        assert_eq!(files(&idx, "new.ts"), ["sub/generated/new.ts"]);
-    }
-}
-
-#[test]
-fn repository_rule_changes_refresh_members_of_an_unindexed_container() {
-    let fx = Fixture::new(&[
-        (".git/HEAD", "ref: refs/heads/main\n"),
-        (".git/info/exclude", ""),
-        ("member/generated/item.txt", "x"),
-    ]);
-    let idx = ProjectIndex::open(
-        &fx.root,
-        &fx.cache,
-        IndexRoots { include_root: false, folders: vec![fx.root.join("member")] },
-        vec![],
-        Arc::new(LanguageRegistry::load(None).unwrap()),
-        Arc::new(Syntax::new()),
-        Arc::new(NullSink),
-    )
-    .unwrap();
-    assert!(idx.wait_idle(WAIT));
-    assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
-    fx.write(".git/info/exclude", "generated/\n");
-    idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
-    assert!(idx.wait_idle(WAIT));
-    assert!(files(&idx, "item.txt").is_empty());
-    fx.write(".git/info/exclude", "");
-    idx.ignore_rules_changed(std::slice::from_ref(&fx.root));
-    assert!(idx.wait_idle(WAIT));
-    assert_eq!(files(&idx, "item.txt"), ["member/generated/item.txt"]);
-}

crates/ide-index/src/worker.rs

@@ -26,7 +26,6 @@ pub(crate) enum Job {
     SaveRecent,
     /// The roots or excludes changed: scan again (unchanged files are kept).
     Rescan,
-    IgnoreRules(Vec<PathBuf>),
     /// File types changed: re-parse the indexed files whose language under the
     /// previous registry differs from the current one.
     Reparse(std::sync::Arc<LanguageRegistry>),
@@ -213,10 +212,6 @@ impl Shared {
     }
 
     fn full_scan(&self) {
-        self.scan(None);
-    }
-
-    fn scan(&self, dirs: Option<&[PathBuf]>) {
         let started = Instant::now();
         self.indexing.store(true, Ordering::SeqCst);
         self.emit_state();
@@ -232,11 +227,7 @@ impl Shared {
 
         let filter = self.filter();
         let mut found = Vec::new();
-        let roots: Vec<&Path> = match dirs {
-            Some(dirs) => dirs.iter().map(PathBuf::as_path).collect(),
-            None => filter.roots().collect(),
-        };
-        for root in roots {
+        for root in filter.roots() {
             found.extend(filter.walk(root, &self.cancelled));
         }
         if self.is_cancelled() {
@@ -246,12 +237,7 @@ impl Shared {
         let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
             let d = self.data.read();
             let todo = found.iter().filter(|f| d.get(&f.path).is_none_or(|e| e.stale_for(f))).collect();
-            let stale = d
-                .paths()
-                .filter(|p| dirs.is_none_or(|dirs| dirs.iter().any(|dir| p.starts_with(dir))))
-                .filter(|p| !seen.contains(p.as_path()))
-                .cloned()
-                .collect();
+            let stale = d.paths().filter(|p| !seen.contains(p.as_path())).cloned().collect();
             (todo, stale)
         };
         if !stale.is_empty() {
@@ -395,7 +381,6 @@ impl Shared {
         let mut removed: Vec<PathBuf> = Vec::new();
         let mut save_recent = false;
         let mut rescan = false;
-        let mut rule_dirs = Vec::new();
         let mut reparse: Vec<std::sync::Arc<LanguageRegistry>> = Vec::new();
         for job in jobs {
             match job {
@@ -403,29 +388,9 @@ impl Shared {
                 Job::Removed(p) => removed.extend(p),
                 Job::SaveRecent => save_recent = true,
                 Job::Rescan => rescan = true,
-                Job::IgnoreRules(dirs) => rule_dirs.extend(dirs),
                 Job::Reparse(before) => reparse.push(before),
             }
         }
-        if !rule_dirs.is_empty() {
-            {
-                let mut filter = self.filter.write();
-                *filter = std::sync::Arc::new(filter.reload());
-            }
-            rule_dirs.sort();
-            rule_dirs.dedup();
-            let mut roots: Vec<PathBuf> = Vec::new();
-            for dir in rule_dirs {
-                if !roots.iter().any(|root| dir.starts_with(root)) {
-                    roots.push(dir);
-                }
-            }
-            if !rescan {
-                self.scan(Some(&roots));
-                changed.retain(|p| !roots.iter().any(|root| p.starts_with(root)));
-                removed.retain(|p| !roots.iter().any(|root| p.starts_with(root)));
-            }
-        }
         if rescan {
             // The scan also picks up whatever `changed` / `removed` reported.
             self.full_scan();

crates/ide-language/src/lib.rs

@@ -14,7 +14,7 @@ mod markers;
 pub mod plugin_point;
 mod registry;
 mod syntax;
-pub use markers::{arduino_sketch_root, is_arduino_sketch_dir, marked_root};
+pub use markers::marked_root;
 pub use plugin_point::PluginLanguages;
 pub use registry::{FileTypes, LanguageRegistry};
 pub use syntax::{

crates/ide-language/src/markers.rs

@@ -19,27 +19,6 @@ pub fn marked_root(project_root: Option<&Path>, file: &Path, markers: &[String])
     best
 }
 
-/// `dir` contains at least one `.ino` regular file.
-pub fn is_arduino_sketch_dir(dir: &Path) -> bool {
-    std::fs::read_dir(dir).is_ok_and(|entries| {
-        entries.flatten().any(|entry| {
-            entry.path().extension().is_some_and(|ext| ext.eq_ignore_ascii_case("ino"))
-                && entry.file_type().is_ok_and(|kind| kind.is_file())
-        })
-    })
-}
-
-/// Nearest enclosing directory of `path` (including `path` when it is already a
-/// directory) within `project` that contains a `.ino` file.
-pub fn arduino_sketch_root(project: &Path, path: &Path) -> Option<PathBuf> {
-    let start = usize::from(!path.is_dir());
-    path.ancestors()
-        .skip(start)
-        .take_while(|dir| dir.starts_with(project))
-        .find(|dir| is_arduino_sketch_dir(dir))
-        .map(Path::to_path_buf)
-}
-
 /// `dir` contains `marker`: a relative path, a file name pattern with one
 /// `*` (`*.csproj`), or a TOML file name (no pattern) and a dotted table it
 /// must contain (`pyproject.toml#tool.ruff`).

crates/ide-language/src/registry.rs

@@ -70,7 +70,6 @@ const BUILTIN: &[(&str, &str)] = &[
     ("proto", include_str!("../../../languages/proto.toml")),
     ("python", include_str!("../../../languages/python.toml")),
     ("r", include_str!("../../../languages/r.toml")),
-    ("restructuredtext", include_str!("../../../languages/restructuredtext.toml")),
     ("ruby", include_str!("../../../languages/ruby.toml")),
     ("rust", include_str!("../../../languages/rust.toml")),
     ("sass", include_str!("../../../languages/sass.toml")),
@@ -563,7 +562,6 @@ mod tests {
         "R",
         "RPM Changes",
         "RPM Spec",
-        "reStructuredText",
         "Ruby",
         "SAS",
         "Scala",
@@ -630,12 +628,6 @@ mod tests {
         let asciidoc = reg.get(&LanguageId::new("asciidoc")).unwrap();
         assert_eq!(asciidoc.ui_mode.as_deref(), Some("AsciiDoc"));
         assert_eq!(asciidoc.line_comment.as_deref(), Some("//"));
-        for path in ["guide.rst", "README.RST"] {
-            assert_eq!(detect(&reg, path), "restructuredtext");
-        }
-        let rst = reg.get(&LanguageId::new("restructuredtext")).unwrap();
-        assert_eq!(rst.ui_mode.as_deref(), Some("reStructuredText"));
-        assert_eq!(rst.line_comment.as_deref(), Some(".."));
         assert_eq!(reg.detect(Path::new("script"), Some("#!/usr/bin/env python3")).as_str(), "python");
         assert_eq!(detect(&reg, "README"), "plaintext");
         assert_eq!(detect(&reg, "unknown.zzz"), "plaintext");
@@ -1007,11 +999,11 @@ mod tests {
     }
 
     #[test]
-    fn astro_server_leaves_typescript_sdk_resolution_to_the_launcher() {
+    fn astro_server_reads_the_project_typescript() {
         let reg = reg();
         let ls = &reg.get(&LanguageId::new("astro")).unwrap().language_servers[0];
         let tsdk = ls.initialization_options.as_ref().and_then(|o| o.get("typescript")?.get("tsdk")?.as_str());
-        assert_eq!(tsdk, None);
+        assert_eq!(tsdk, Some("node_modules/typescript/lib"));
     }
 
     #[test]

crates/ide-language/src/syntax/cache.rs

@@ -206,7 +206,6 @@ impl SyntaxCache {
                 // their trees join the cache.
                 .or_else(|| self.syntax.web_outline(lang, text))
                 .or_else(|| super::external::outline(lang, text))
-                .or_else(|| self.syntax.builtin_outline(lang, text))
             },
         )
     }

crates/ide-language/src/syntax/mod.rs

@@ -9,7 +9,6 @@ mod highlight;
 pub(crate) mod lines;
 mod literals;
 mod outline;
-mod rst;
 mod selection;
 mod sfc;
 mod web;
@@ -178,15 +177,9 @@ impl Syntax {
             let query = g.outline_query()?;
             Some(outline::outline(g, query, tree, text))
         })
-        .or_else(|| self.builtin_outline(lang, text))
         .unwrap_or_default()
     }
 
-    /// Outline for languages without a grammar that have a built-in parser.
-    fn builtin_outline(&self, lang: &LanguageId, text: &str) -> Option<Vec<OutlineItem>> {
-        (lang.as_str() == "restructuredtext" && text.len() <= MAX_PARSE_BYTES).then(|| rst::outline(text))
-    }
-
     /// Outline of an HTML container document (html, vue, svelte, jsp): `None`
     /// for every other language, CSS containers included.
     pub(crate) fn web_outline(&self, lang: &LanguageId, text: &str) -> Option<Vec<OutlineItem>> {

crates/ide-language/src/syntax/rst.rs

@@ -1,131 +0,0 @@
-//! reStructuredText section titles for the outline. No bundled grammar nests
-//! sections (tree-sitter-rst emits them flat), so levels follow docutils: each
-//! adornment style (character, with or without overline) takes the next level
-//! the first time it appears.
-
-use super::lines::LineIndex;
-use ide_core::{OutlineItem, SymbolKind};
-
-struct Line<'a> {
-    start: usize,
-    text: &'a str,
-}
-
-struct Heading {
-    level: usize,
-    start: usize,
-    end: usize,
-    name_start: usize,
-    name_end: usize,
-}
-
-pub(crate) fn outline(text: &str) -> Vec<OutlineItem> {
-    let lines: Vec<Line> = text
-        .split_inclusive('\n')
-        .scan(0, |at, raw| {
-            let start = *at;
-            *at += raw.len();
-            Some(Line { start, text: raw.trim_end_matches(['\n', '\r']) })
-        })
-        .collect();
-    let mut heads = headings(&lines);
-    for k in 0..heads.len() {
-        let end = heads[k + 1..].iter().find(|h| h.level <= heads[k].level).map_or(text.len(), |h| h.start);
-        heads[k].end = heads[k].start + text[heads[k].start..end].trim_end().len();
-    }
-    let index = LineIndex::new(text);
-    let mut i = 0;
-    nest(&heads, &mut i, None, text, &index)
-}
-
-fn headings(lines: &[Line]) -> Vec<Heading> {
-    let mut styles: Vec<(char, bool)> = Vec::new();
-    let mut out = Vec::new();
-    let mut push = |style: (char, bool), start: usize, title: &Line| {
-        let level = styles.iter().position(|&s| s == style).unwrap_or_else(|| {
-            styles.push(style);
-            styles.len() - 1
-        });
-        let name = title.text.trim();
-        let name_start = title.start + (title.text.len() - title.text.trim_start().len());
-        out.push(Heading { level, start, end: 0, name_start, name_end: name_start + name.len() });
-    };
-    // A title starts a new block: it follows a blank line, the start, or another title.
-    let mut at_block_start = true;
-    let mut i = 0;
-    while i < lines.len() {
-        let line = &lines[i];
-        if line.text.trim().is_empty() {
-            at_block_start = true;
-            i += 1;
-            continue;
-        }
-        if at_block_start {
-            if let Some(over) = adornment(line.text) {
-                if let [title, under, ..] = &lines[i + 1..]
-                    && !title.text.trim().is_empty()
-                    && adornment(title.text).is_none()
-                    && adornment(under.text) == Some(over)
-                    && fits(title.text.trim_end(), over.1)
-                {
-                    push((over.0, true), line.start, title);
-                    i += 3;
-                    continue;
-                }
-            } else if !line.text.starts_with([' ', '\t'])
-                && !starts_body_element(line.text)
-                && let Some(under) = lines.get(i + 1).and_then(|l| adornment(l.text))
-                && fits(line.text.trim_end(), under.1)
-            {
-                push((under.0, false), line.start, line);
-                i += 2;
-                continue;
-            }
-        }
-        // Indented lines (literal blocks after `::`, directive bodies, quotes)
-        // never hold titles: they are skipped here because adornments and
-        // underlined titles must start in column 0.
-        at_block_start = false;
-        i += 1;
-    }
-    out
-}
-
-/// `(character, length)` of a line made of one repeated ASCII punctuation character.
-fn adornment(line: &str) -> Option<(char, usize)> {
-    let line = line.trim_end();
-    let c = line.chars().next().filter(char::is_ascii_punctuation)?;
-    line.chars().all(|x| x == c).then_some((c, line.len()))
-}
-
-/// docutils accepts a short adornment (with a warning) unless it is shorter
-/// than 4 characters, which reads as ordinary text instead.
-// ponytail: counts chars, not display columns; wide CJK titles get a looser check.
-fn fits(title: &str, adornment_len: usize) -> bool {
-    adornment_len >= title.chars().count() || adornment_len >= 4
-}
-
-/// Lines docutils parses as another body element before trying a title:
-/// explicit markup (`..`, `__`), bullets, field lists, doctests, line blocks.
-fn starts_body_element(line: &str) -> bool {
-    let marker = |m: &str| line == m || line.strip_prefix(m).is_some_and(|r| r.starts_with(' '));
-    ["..", "__", "-", "*", "+", "•", ">>>", "|"].into_iter().any(marker)
-        || (line.starts_with(':') && line[1..].find(':').is_some_and(|k| k > 0 && marker(&line[..k + 2])))
-}
-
-fn nest(heads: &[Heading], i: &mut usize, parent: Option<usize>, text: &str, index: &LineIndex) -> Vec<OutlineItem> {
-    let mut items = Vec::new();
-    while let Some(h) = heads.get(*i).filter(|h| parent.is_none_or(|p| h.level > p)) {
-        *i += 1;
-        items.push(OutlineItem {
-            name: text[h.name_start..h.name_end].to_owned(),
-            detail: None,
-            kind: SymbolKind::Key,
-            range: index.range(h.start, h.end),
-            selection_range: index.range(h.name_start, h.name_end),
-            children: nest(heads, i, Some(h.level), text, index),
-            visibility: None,
-        });
-    }
-    items
-}

crates/ide-language/src/syntax/tests.rs

@@ -1638,91 +1638,3 @@ fn script_outlines_compose_positions_across_multiple_blocks() {
 fn script_outline_attaches_to_case_insensitive_html_tags() {
     check_outline("html", "<SCRIPT>function boot() {}</SCRIPT>", "Field SCRIPT\n  Function boot");
 }
-
-#[test]
-fn outline_restructuredtext_levels_follow_first_use_of_each_adornment() {
-    let src = "\
-=========
- Project
-=========
-
-Install
-~~~~~~~
-
-From source
------------
-
-Literal block::
-
-    Not a title
-    -----------
-
-Intro
---
-
-A paragraph
-with a line
-------------
-
-.. comment
------------
-
-Usage
-~~~~~
-
-.. note::
-
-   Indented
-   --------
-
-Short underline, still a title
-------
-
-Underline only
-==============
-";
-    check_outline(
-        "restructuredtext",
-        src,
-        "
-        Key Project
-          Key Install
-            Key From source
-          Key Usage
-            Key Short underline, still a title
-              Key Underline only
-        ",
-    );
-    let items = syntax().outline(&lang("restructuredtext"), src);
-    let project = &items[0];
-    assert_eq!(project.range.start, Pos::new(0, 0));
-    assert_eq!((project.selection_range.start, project.selection_range.end), (Pos::new(1, 1), Pos::new(1, 8)));
-    let install = &project.children[0];
-    assert_eq!((install.range.start, install.range.end), (Pos::new(4, 0), Pos::new(23, 11)));
-    assert!(syntax().outline(&lang("restructuredtext"), "Title\n\n").is_empty());
-}
-
-#[test]
-fn outline_restructuredtext_unicode_crlf_and_cached_edits() {
-    use ide_core::DocId;
-    use std::sync::Arc;
-
-    let src = "=========\r\n 中文😀\r\n=========\r\n\r\n子章节\r\n------\r\n\r\nBody\r\n\r\nOther\r\n------\r\n";
-    let id = DocId::next();
-    let language = lang("restructuredtext");
-    let cache = SyntaxCache::new(Arc::new(Syntax::new()));
-    cache.open(id, &language, 0);
-    let items = cache.outline(id, &language, 0, src);
-    assert_eq!(items, syntax().outline(&language, src));
-    assert_eq!(items[0].name, "中文😀");
-    assert_eq!(items[0].selection_range, Range::new(Pos::new(1, 1), Pos::new(1, 5)));
-    assert_eq!(items[0].children[0].name, "子章节");
-    assert_eq!(items[0].children[0].selection_range, Range::new(Pos::new(4, 0), Pos::new(4, 3)));
-    assert_eq!(items[0].children[0].range.end, Pos::new(7, 4));
-    assert_eq!(items[0].children[1].name, "Other");
-    let edited = src.replace("子章节", "新章节😀");
-    let updated = cache.outline(id, &language, 1, &edited);
-    assert_eq!(updated, syntax().outline(&language, &edited));
-    assert_eq!(updated[0].children[0].selection_range.end, Pos::new(4, 5));
-    assert_ne!(items, updated);
-}

crates/ide-lsp/src/arduino.rs

@@ -1,210 +0,0 @@
-//! Arduino sketches need their own board context, including their C/C++ sources.
-
-use crate::LspManager;
-use crate::server::Server;
-use ide_core::{LanguageId, Location};
-use serde_json::Value;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-
-pub(crate) const SERVER: &str = "arduino-language-server";
-
-pub(crate) fn sketch_root(project: &Path, file: &Path) -> Option<PathBuf> {
-    ide_language::arduino_sketch_root(project, file)
-}
-
-pub(crate) fn configure_client_capabilities(capabilities: &mut Value) {
-    // Arduino's proxy cannot decode the boolean full form, panics on inlayHint (#225),
-    // and cannot handle clangd's semanticTokens refresh request (#125).
-    for section in ["textDocument", "workspace"] {
-        if let Some(section) = capabilities[section].as_object_mut() {
-            section.remove("semanticTokens");
-            section.remove("inlayHint");
-        }
-    }
-    // ALS uses go.bug.st/lsp (LSP 3.14) which requires a `range` field on `lsp.TextEdit`.
-    // Clangd returns `InsertReplaceEdit` (`insert` + `replace`) when `insertReplaceSupport` is advertised,
-    // causing ALS to drop the connection with "json: undefined required field range into lsp.TextEdit".
-    if let Some(completion) = capabilities.get_mut("textDocument").and_then(|t| t.get_mut("completion"))
-        && let Some(item) = completion.get_mut("completionItem").and_then(|c| c.as_object_mut())
-    {
-        item.remove("insertReplaceSupport");
-    }
-}
-
-pub(crate) fn sanitize_server_capabilities(capabilities: &mut Value) {
-    // Arduino Language Server's request dispatcher advertises documentSymbol and
-    // workspaceSymbol, but panics with "not implemented" / "unimplemented" when called.
-    // Tree-sitter handles C++ outline/symbols in OpenIDEA without hitting ALS.
-    if let Some(obj) = capabilities.as_object_mut() {
-        obj.remove("documentSymbolProvider");
-        obj.remove("workspaceSymbolProvider");
-    }
-}
-
-impl LspManager {
-    pub(crate) fn arduino_servers(&self, language: &LanguageId, path: &Path) -> Option<Vec<Arc<Server>>> {
-        if !matches!(language.as_str(), "c" | "cpp") {
-            return None;
-        }
-        let configs = self.language_servers(&LanguageId::new("arduino"));
-        let cfg = configs.iter().find(|cfg| cfg.name == SERVER)?;
-        let project = self.project_root_for(path);
-        if sketch_root(&project, path).is_some() {
-            let server = self.server_for(cfg, &LanguageId::new("arduino"), path);
-            server.add_language(language);
-            let mut servers = vec![server];
-            servers.extend(
-                self.language_servers(language)
-                    .iter()
-                    .filter(|cfg| cfg.name != "clangd" && cfg.name != SERVER)
-                    .filter(|cfg| {
-                        !cfg.require_root_marker
-                            || crate::launch::marked_root(&project, path, &cfg.root_markers).is_some()
-                    })
-                    .map(|cfg| self.server_for(cfg, language, path)),
-            );
-            return Some(servers);
-        }
-        if !path.starts_with(&project)
-            && let Some(server) = self.origin_server(&crate::uri::path_to_uri_string(path))
-            && server.name == SERVER
-        {
-            return Some(vec![server]);
-        }
-        None
-    }
-
-    pub(crate) fn note_arduino_sources(&self, server: &Arc<Server>, locations: &[Location]) {
-        if server.name != SERVER {
-            return;
-        }
-        let mut origins = None;
-        for location in locations {
-            let path: &Path = &location.path;
-            if location.uri.is_none() && !path.starts_with(self.project_root_for(path)) {
-                origins
-                    .get_or_insert_with(|| self.virtual_origins.lock())
-                    .insert(crate::uri::path_to_uri_string(path), server.id);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn bundled_server_allows_diagnostics() {
-        let registry = ide_language::LanguageRegistry::load(None).unwrap();
-        let language = registry.get(&LanguageId::new("arduino")).unwrap();
-        let cfg = language.language_servers.iter().find(|cfg| cfg.name == SERVER).unwrap();
-        assert!(crate::caps::Restriction::new(SERVER, &cfg.features, &cfg.code_action_kinds).diagnostics());
-    }
-
-    #[tokio::test]
-    async fn inspection_checks_the_sketch_server_and_root_for_all_sources() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let sketch = root.join("examples/blink");
-        std::fs::create_dir_all(&sketch).unwrap();
-        std::fs::write(sketch.join("blink.ino"), "").unwrap();
-        let registry = Arc::new(ide_language::LanguageRegistry::load(None).unwrap());
-        let manager = LspManager::new(root.to_path_buf(), registry, Arc::new(|_: ide_core::IdeEvent| {}));
-        let expected_root = sketch.clone();
-        manager.set_config_hook(Box::new(move |cfg, server_root| {
-            cfg.command = std::env::current_exe().unwrap().to_string_lossy().into_owned();
-            if cfg.name != SERVER || server_root != expected_root {
-                cfg.launch_error = Some("unavailable".into());
-            }
-        }));
-        for name in ["blink.ino", "helper.cpp", "helper.h"] {
-            assert!(manager.serves_path(&sketch.join(name)), "{name}");
-        }
-        assert!(!manager.serves_path(&root.join("main.cpp")));
-    }
-
-    #[test]
-    fn nested_sketches_keep_separate_board_roots() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let inner = root.join("examples/blink");
-        std::fs::create_dir_all(inner.join("src")).unwrap();
-        std::fs::write(root.join("main.ino"), "").unwrap();
-        std::fs::write(inner.join("blink.ino"), "").unwrap();
-        assert_eq!(sketch_root(root, &inner.join("blink.ino")), Some(inner.clone()));
-        assert_eq!(sketch_root(root, &inner.join("src/helper.cpp")), Some(inner));
-        assert_eq!(sketch_root(root, &root.join("helper.h")), Some(root.to_path_buf()));
-        assert_eq!(sketch_root(&root.join("examples"), &root.join("other.cpp")), None);
-    }
-
-    #[test]
-    fn ordinary_cpp_projects_and_ino_named_directories_are_not_sketches() {
-        let dir = tempfile::tempdir().unwrap();
-        std::fs::create_dir(dir.path().join("not-a-file.ino")).unwrap();
-        assert_eq!(sketch_root(dir.path(), &dir.path().join("main.cpp")), None);
-    }
-
-    #[tokio::test]
-    async fn cpp_routing_is_scoped_to_sketches_and_respects_disabled_arduino() {
-        let dir = tempfile::tempdir().unwrap();
-        let root = dir.path();
-        let sketch = root.join("examples/blink");
-        std::fs::create_dir_all(&sketch).unwrap();
-        std::fs::write(sketch.join("blink.ino"), "").unwrap();
-        let registry = Arc::new(ide_language::LanguageRegistry::load(None).unwrap());
-        let manager = LspManager::new(root.to_path_buf(), registry, Arc::new(|_: ide_core::IdeEvent| {}));
-        let cpp = LanguageId::new("cpp");
-        let sketch_servers = manager.servers_for(&cpp, &sketch.join("helper.cpp"));
-        assert_eq!(sketch_servers.iter().map(|s| s.name.as_str()).collect::<Vec<_>>(), [SERVER]);
-        assert_eq!(sketch_servers[0].root, sketch);
-        assert!(sketch_servers[0].languages().contains(&LanguageId::new("arduino")));
-        assert_eq!(manager.servers_for(&cpp, &root.join("main.cpp"))[0].name, "clangd");
-        manager.set_servers_hook(Box::new(
-            |language, defined| {
-                if language.as_str() == "arduino" { Vec::new() } else { defined.to_vec() }
-            },
-        ));
-        assert_eq!(manager.servers_for(&cpp, &sketch.join("helper.cpp"))[0].name, "clangd");
-    }
-
-    #[test]
-    fn capabilities_are_sanitized_for_arduino_proxy_quirks() {
-        let mut client = serde_json::json!({
-            "textDocument": {
-                "semanticTokens": { "dynamicRegistration": false },
-                "inlayHint": { "dynamicRegistration": false },
-                "completion": {
-                    "completionItem": {
-                        "snippetSupport": true,
-                        "insertReplaceSupport": true
-                    }
-                }
-            },
-            "workspace": {
-                "semanticTokens": { "refreshSupport": true },
-                "inlayHint": { "refreshSupport": true }
-            }
-        });
-        configure_client_capabilities(&mut client);
-        assert!(client["textDocument"].get("semanticTokens").is_none());
-        assert!(client["textDocument"].get("inlayHint").is_none());
-        assert!(client["textDocument"]["completion"]["completionItem"].get("insertReplaceSupport").is_none());
-        assert_eq!(client["textDocument"]["completion"]["completionItem"]["snippetSupport"], true);
-        assert!(client["workspace"].get("semanticTokens").is_none());
-        assert!(client["workspace"].get("inlayHint").is_none());
-
-        let mut server = serde_json::json!({
-            "documentSymbolProvider": {},
-            "workspaceSymbolProvider": {},
-            "completionProvider": { "triggerCharacters": ["."] },
-            "hoverProvider": true
-        });
-        sanitize_server_capabilities(&mut server);
-        assert!(server.get("documentSymbolProvider").is_none());
-        assert!(server.get("workspaceSymbolProvider").is_none());
-        assert!(server.get("completionProvider").is_some());
-        assert!(server.get("hoverProvider").is_some());
-    }
-}

crates/ide-lsp/src/convert.rs

@@ -301,7 +301,6 @@ pub fn completion_item(conv: &Conv, path: &Path, item: lsp::CompletionItem, serv
     let mut out = CompletionItem {
         label: item.label.clone(),
         label_detail: None,
-        label_description: None,
         detail: None,
         kind: None,
         documentation: None,
@@ -350,9 +349,6 @@ pub fn overlay_completion(conv: &Conv, path: &Path, out: &mut CompletionItem, it
     if let Some(d) = label_details.and_then(|d| d.detail) {
         out.label_detail = Some(d);
     }
-    if let Some(d) = description.clone() {
-        out.label_description = Some(d);
-    }
     if let Some(d) = detail.or(description) {
         out.detail = Some(d);
     }
@@ -429,12 +425,10 @@ pub fn lsp_completion_item(text: &DocText, enc: Encoding, item: &CompletionItem)
     });
     lsp::CompletionItem {
         label: item.label.clone(),
-        label_details: (item.label_detail.is_some() || item.label_description.is_some()).then(|| {
-            lsp::CompletionItemLabelDetails {
-                detail: item.label_detail.clone(),
-                description: item.label_description.clone(),
-            }
-        }),
+        label_details: item
+            .label_detail
+            .clone()
+            .map(|detail| lsp::CompletionItemLabelDetails { detail: Some(detail), description: None }),
         kind: item.kind.map(lsp_completion_kind),
         detail: item.detail.clone(),
         documentation: item.documentation.as_ref().map(lsp_documentation),
@@ -568,18 +562,10 @@ pub fn lsp_command(c: &Command) -> lsp::Command {
     }
 }
 
-pub fn code_action(
-    conv: &Conv,
-    path: &Path,
-    a: lsp::CodeActionOrCommand,
-    server: ServerId,
-    server_name: &str,
-) -> CodeAction {
+pub fn code_action(conv: &Conv, a: lsp::CodeActionOrCommand, server: ServerId) -> CodeAction {
     match a {
         lsp::CodeActionOrCommand::Command(c) => CodeAction {
             title: c.title.clone(),
-            diagnostics: Vec::new(),
-            original_diagnostics: None,
             kind: None,
             is_preferred: false,
             disabled_reason: None,
@@ -590,13 +576,6 @@ pub fn code_action(
         },
         lsp::CodeActionOrCommand::CodeAction(a) => CodeAction {
             title: a.title,
-            original_diagnostics: a.diagnostics.as_ref().and_then(|d| serde_json::to_string(d).ok()),
-            diagnostics: a
-                .diagnostics
-                .unwrap_or_default()
-                .into_iter()
-                .map(|d| diagnostic(conv, path, d, server_name))
-                .collect(),
             kind: a.kind.map(|k| k.as_str().to_owned()),
             is_preferred: a.is_preferred.unwrap_or(false),
             disabled_reason: a.disabled.map(|d| d.reason),
@@ -612,7 +591,7 @@ pub fn lsp_code_action(a: &CodeAction) -> lsp::CodeAction {
     lsp::CodeAction {
         title: a.title.clone(),
         kind: a.kind.clone().map(lsp::CodeActionKind::from),
-        diagnostics: a.original_diagnostics.as_deref().and_then(|d| serde_json::from_str(d).ok()),
+        diagnostics: None,
         edit: None,
         command: a.command.as_ref().map(lsp_command),
         is_preferred: a.is_preferred.then_some(true),
@@ -1088,66 +1067,6 @@ mod tests {
     use super::*;
     use serde_json::json;
 
-    #[test]
-    fn code_action_diagnostics_use_ide_coordinates_and_round_trip_for_resolve() {
-        let path = Path::new("/go.mod");
-        let conv = Conv::new(Encoding::Utf8, |_| Some(Arc::new(DocText::new("😀 dependency"))));
-        let raw: lsp::Diagnostic = serde_json::from_value(json!({
-            "range": { "start": { "line": 0, "character": 5 }, "end": { "line": 0, "character": 15 } },
-            "message": "github.com/sergi/go-diff is not used in this module",
-            "severity": 2,
-            "code": 123,
-            "source": "go mod tidy",
-            "data": { "fix": "remove" }
-        }))
-        .unwrap();
-        let incoming = lsp::CodeAction {
-            title: "Remove dependency: github.com/sergi/go-diff".into(),
-            diagnostics: Some(vec![raw.clone()]),
-            ..Default::default()
-        };
-        let action = code_action(&conv, path, lsp::CodeActionOrCommand::CodeAction(incoming), ServerId(1), "gopls");
-        assert_eq!(action.diagnostics, vec![diagnostic(&conv, path, raw.clone(), "gopls")]);
-        assert_eq!(action.diagnostics[0].range, Range::new(Pos::new(0, 3), Pos::new(0, 13)));
-        assert_eq!(action.diagnostics[0].code.as_deref(), Some("123"));
-        let action: CodeAction = serde_json::from_value(serde_json::to_value(action).unwrap()).unwrap();
-        assert_eq!(lsp_code_action(&action).diagnostics, Some(vec![raw.clone()]));
-        let resolved = merge_code_action(&conv, action, lsp::CodeAction::default());
-        assert_eq!(lsp_code_action(&resolved).diagnostics, Some(vec![raw]));
-        assert_eq!(resolved.diagnostics.len(), 1);
-    }
-
-    #[test]
-    fn code_actions_without_diagnostics_keep_them_absent_for_resolve() {
-        let conv = Conv::utf16();
-        for incoming in [
-            lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction { title: "Fix".into(), ..Default::default() }),
-            lsp::CodeActionOrCommand::Command(lsp::Command {
-                title: "Fix".into(),
-                command: "fix".into(),
-                arguments: None,
-            }),
-        ] {
-            let action = code_action(&conv, Path::new("/a"), incoming, ServerId(1), "srv");
-            assert!(action.diagnostics.is_empty());
-            assert!(lsp_code_action(&action).diagnostics.is_none());
-        }
-        let raw = lsp::Diagnostic::new_simple(lsp::Range::default(), "problem".into());
-        let expected = diagnostic(&conv, Path::new("/a"), raw.clone(), "srv");
-        let action = code_action(
-            &conv,
-            Path::new("/a"),
-            lsp::CodeActionOrCommand::CodeAction(lsp::CodeAction {
-                diagnostics: Some(vec![raw]),
-                ..Default::default()
-            }),
-            ServerId(1),
-            "srv",
-        );
-        assert_eq!(action.diagnostics, vec![expected]);
-        assert_eq!(action.diagnostics[0].source.as_deref(), Some("srv"));
-    }
-
     #[test]
     fn merged_rename_edits_keep_the_first_servers_ones() {
         let edit = |l: u32, c: u32, text: &str| TextEdit {
@@ -1290,8 +1209,7 @@ mod tests {
         assert_eq!(a.insert_text, "println!($0)");
         assert!(a.is_snippet);
         assert_eq!(a.label_detail.as_deref(), Some("(…)"));
-        assert_eq!(a.label_description.as_deref(), Some("std"));
-        assert_eq!(a.detail.as_deref(), Some("std"), "no `detail` from the server: the description stands in");
+        assert_eq!(a.detail.as_deref(), Some("std"));
         assert_eq!(a.kind, Some(CompletionKind::Function));
         assert_eq!(a.replace_range, Some(Range::new(p(0, 4), p(0, 6))));
         assert_eq!(a.replace_range_tab, Some(Range::new(p(0, 4), p(0, 9))));
@@ -1307,9 +1225,6 @@ mod tests {
         let back = lsp_completion_item(&text, Encoding::Utf16, &a);
         assert_eq!(back.data, Some(json!({"k": 1})));
         assert!(matches!(back.text_edit, Some(lsp::CompletionTextEdit::InsertAndReplace(_))));
-        let details = back.label_details.expect("label details survive the resolve round trip");
-        assert_eq!(details.detail.as_deref(), Some("(…)"));
-        assert_eq!(details.description.as_deref(), Some("std"));
     }
 
     #[test]
@@ -1340,10 +1255,6 @@ mod tests {
             let item = completion_item(&Conv::utf16(), Path::new("/Main.java"), items[0].clone(), ServerId(1));
             assert_eq!(item.replace_range, Some(Range::new(p(2, 19), p(2, end))));
             assert_eq!(item.replace_range_tab, None);
-            // The list shows `print (Object obj)` and `void`; the long signature is only for the docs panel.
-            assert_eq!(item.label_detail.as_deref(), Some("(Object obj)"));
-            assert_eq!(item.label_description.as_deref(), Some("void"));
-            assert_eq!(item.detail.as_deref(), Some("PrintStream.print(Object obj) : void"));
             assert_eq!(item.filter_text.as_deref(), Some("print(Object obj) : void"));
             assert_eq!(item.insert_text, "print(${0});");
             assert!(item.is_snippet);

crates/ide-lsp/src/inspect.rs

@@ -63,17 +63,6 @@ impl LspManager {
     /// run doesn't prompt to install every language it meets.
     pub fn serves_path(&self, path: &Path) -> bool {
         let lang = self.languages.detect(path, None);
-        let arduino = if lang.as_str() == "arduino" {
-            Some(self.servers_for(&lang, path))
-        } else {
-            self.arduino_servers(&lang, path)
-        };
-        if let Some(servers) = arduino {
-            return servers.iter().any(|server| {
-                let cfg = self.configured(server);
-                cfg.launch_error.is_none() && self.launcher.available(&cfg, &server.root)
-            });
-        }
         self.language_servers(&lang).iter().any(|ls| {
             if ls.require_root_marker
                 && crate::launch::marked_root(&self.project_root, path, &ls.root_markers).is_none()

crates/ide-lsp/src/lib.rs

@@ -7,7 +7,6 @@
 //! never `lsp-types`, so the IPC surface stays stable.
 
 mod angular;
-mod arduino;
 mod caps;
 mod clang_tidy;
 mod convert;
@@ -503,12 +502,10 @@ impl LspManager {
     fn server_for(&self, cfg: &LanguageServerConfig, language: &LanguageId, path: &Path) -> Arc<Server> {
         let shared = is_local_jdtls(cfg).then(|| self.jdtls_workspace_state());
         let mut servers = self.servers.lock();
-        let project = self.project_root_for(path);
-        let sketch = (cfg.name == arduino::SERVER).then(|| arduino::sketch_root(&project, path)).flatten();
         let root = if shared.as_ref().is_some_and(|state| state.shared) {
             self.project_root.clone()
         } else {
-            sketch.or_else(|| launch::find_root(&project, path, &cfg.root_markers)).unwrap_or_else(|| {
+            launch::find_root(&self.project_root_for(path), path, &cfg.root_markers).unwrap_or_else(|| {
                 // Outside the project (library sources, …): reuse a running instance.
                 servers
                     .iter()
@@ -533,9 +530,6 @@ impl LspManager {
     /// only while all servers listed before it are missing. One that requires a
     /// root marker serves only files below one, and stands in for no other.
     fn servers_for(&self, language: &LanguageId, path: &Path) -> Vec<Arc<Server>> {
-        if let Some(servers) = self.arduino_servers(language, path) {
-            return servers;
-        }
         let mut out = Vec::new();
         let mut available_before = false;
         for sc in &self.language_servers(language) {
@@ -781,11 +775,7 @@ impl LspManager {
                 if let Some(info) = result.get("serverInfo") {
                     tracing::info!("{} initialized: {info}", server.name);
                 }
-                let mut caps_val = result.get("capabilities").cloned().unwrap_or_else(|| json!({}));
-                if server.name == arduino::SERVER {
-                    arduino::sanitize_server_capabilities(&mut caps_val);
-                }
-                let mut caps = ServerCaps::parse(caps_val);
+                let mut caps = ServerCaps::parse(result.get("capabilities").cloned().unwrap_or_else(|| json!({})));
                 let cfg = server.effective_config();
                 caps.restrict(caps::Restriction::new(&server.name, &cfg.features, &cfg.code_action_kinds));
                 caps
@@ -931,9 +921,6 @@ impl LspManager {
             "capabilities": caps::client_capabilities(),
             "trace": "off",
         });
-        if server.name == arduino::SERVER {
-            arduino::configure_client_capabilities(&mut params["capabilities"]);
-        }
         if server.name == "gopls" {
             params["capabilities"]["experimental"]["interactiveResolve"] = json!({ "inputTypes": ["string"] });
         }
@@ -1573,7 +1560,6 @@ impl LspManager {
                     let locs = convert::goto_response(&self.conv(t.enc()), r);
                     let locs = library_sources(snap, pos, locs).await;
                     self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
-                    self.note_arduino_sources(&t.server, &locs);
                     let locs = merge_locations(first, locs);
                     if !locs.is_empty() {
                         return Ok(locs);
@@ -1802,7 +1788,6 @@ impl LspManager {
                     .collect();
                 let locations: Vec<Location> = classified.iter().map(|r| r.location.clone()).collect();
                 self.note_virtual(&t.server, locations.iter().map(|l| l.uri.as_deref()));
-                self.note_arduino_sources(&t.server, &locations);
                 Ok(References { locations, classified, incomplete: widened.incomplete, libraries_skipped })
             }
             .await;
@@ -1870,7 +1855,6 @@ impl LspManager {
                         locs.retain(|l| !declarations.contains(l));
                     }
                     self.note_virtual(&t.server, locs.iter().map(|l| l.uri.as_deref()));
-                    self.note_arduino_sources(&t.server, &locs);
                     acc.locations.extend(locs);
                     acc.incomplete = acc.incomplete.or(w.incomplete);
                 }
@@ -2074,8 +2058,7 @@ impl LspManager {
                             .unwrap_or_default()
                             .into_iter()
                             .map(|a| {
-                                let mut action =
-                                    convert::code_action(&conv, &snap.path, a, t.server.id, &t.server.name);
+                                let mut action = convert::code_action(&conv, a, t.server.id);
                                 self.tag_injected_origin(doc, &mut action.data);
                                 self.tag_injected_command(doc, action.server, &mut action.command);
                                 action
@@ -2952,64 +2935,6 @@ impl LspManager {
             .cloned()
     }
 
-    /// The binary archive behind a library document, never its displayed tab title.
-    pub fn library_archive(uri: &str) -> Option<PathBuf> {
-        if virtual_doc::scheme(uri) == "jar" {
-            return library_source::parse(uri).map(|e| e.jar);
-        }
-        virtual_doc::description(uri).filter(|p| p.ends_with(".jar") && Path::new(p).is_absolute()).map(PathBuf::from)
-    }
-
-    /// Open an attached archive at the declaration under the decompiled editor's caret.
-    pub async fn library_source_location(
-        &self,
-        uri: &str,
-        sources: PathBuf,
-        pos: Pos,
-        cancel: &CancellationToken,
-    ) -> IdeResult<Option<Location>> {
-        let previous = tokio::select! {
-            result = self.virtual_document(uri) => result?,
-            _ = cancel.cancelled() => return Err(IdeError::cancelled()),
-        };
-        let name = previous
-            .text
-            .lines()
-            .nth(pos.line as usize)
-            .and_then(|line| library_source::identifier_at(line, pos.col))
-            .map(str::to_owned);
-        let original = uri.to_owned();
-        let archive = sources.clone();
-        let found = tokio::task::spawn_blocking(move || {
-            library_source::source_in_archive(&original, &archive).map(|(uri, text)| {
-                let range = name.as_deref().map(|n| library_source::declaration_range(&text, n)).unwrap_or_default();
-                Location { path: uri.clone().into(), uri: Some(uri), range }
-            })
-        })
-        .await
-        .map_err(|e| IdeError::internal(e.to_string()))?;
-        if cancel.is_cancelled() {
-            return Err(IdeError::cancelled());
-        }
-        if found.is_some() {
-            if virtual_doc::scheme(uri) == "jdt" {
-                let result = self
-                    .jdtls_command_cancellable(
-                        &self.project_root,
-                        "java.project.updateSourceAttachment",
-                        vec![json!({ "classFileUri": uri, "attributes": { "sourceAttachmentPath": sources } })],
-                        cancel,
-                    )
-                    .await?;
-                if let Some(error) = result.get("errorMessage").and_then(Value::as_str).filter(|s| !s.is_empty()) {
-                    return Err(IdeError::unavailable(error));
-                }
-            }
-            self.virtual_docs.lock().remove(uri);
-        }
-        Ok(found)
-    }
-
     /// Contents of a virtual document, from the server that owns `uri`:
     /// `workspace/textDocumentContent` (LSP 3.18) when the server serves the
     /// scheme, jdtls' `java/classFileContents` for `jdt:` URIs. A `jar:` entry
@@ -3387,7 +3312,6 @@ impl LspManager {
                 .filter(|a| {
                     !wanted.iter().any(|w| w.id == a.server.id)
                         && (configs.iter().any(|c| c.fallback && c.name == a.server.name)
-                            || (a.server.name == "clangd" && wanted.iter().any(|s| s.name == arduino::SERVER))
                             || !configs
                                 .iter()
                                 .any(|c| c.name == a.server.name && c.target_key == a.server.config.target_key))

crates/ide-lsp/src/library_source.rs

@@ -79,27 +79,6 @@ pub(crate) fn class_source(uri: &str) -> Option<(String, String)> {
     None
 }
 
-pub(crate) fn source_in_archive(uri: &str, sources: &Path) -> Option<(String, String)> {
-    let jar = if uri.starts_with("jdt://contents/") {
-        let path = uri.split('?').next()?.strip_prefix("jdt://contents/")?;
-        let parts: Vec<_> = path.split('/').collect();
-        let [_, package, file] = parts.as_slice() else { return None };
-        let file = percent_decode_str(file).decode_utf8().ok()?;
-        let name = file.strip_suffix(".class").or_else(|| file.strip_suffix(".java"))?;
-        let package = percent_decode_str(package).decode_utf8().ok()?.replace('.', "/");
-        JarEntry {
-            prefix: "jar:file://".into(),
-            jar: sources.to_owned(),
-            entry: if package.is_empty() { format!("{name}.class") } else { format!("{package}/{name}.class") },
-        }
-    } else {
-        parse(uri)?
-    };
-    let class = jar.entry.strip_suffix(".class")?;
-    let (entry, text) = source_entry(sources, class)?;
-    Some((jar.uri_of(sources, &entry), text))
-}
-
 /// Sources jars of the artifact `jar`: `<name>-sources.jar` next to it (Maven
 /// repository), or in a sibling hash folder (Gradle `files-2.1/<g>/<a>/<v>/<hash>/`).
 fn sources_jars(jar: &Path) -> Vec<PathBuf> {
@@ -160,20 +139,7 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
     const KEYWORDS: [&str; 9] = ["fun", "class", "interface", "object", "val", "var", "typealias", "enum", "record"];
     let is_ident = |c: char| c.is_alphanumeric() || c == '_' || c == '$';
     let mut fallback = None;
-    let mut block_comment = false;
     for (line_no, line) in text.lines().enumerate() {
-        let trimmed = line.trim_start();
-        if block_comment {
-            block_comment = !trimmed.contains("*/");
-            continue;
-        }
-        if trimmed.starts_with("/*") {
-            block_comment = !trimmed.contains("*/");
-            continue;
-        }
-        if trimmed.starts_with("//") || trimmed.starts_with('*') {
-            continue;
-        }
         let mut from = 0;
         while let Some(i) = line[from..].find(name) {
             let start = from + i;
@@ -195,11 +161,8 @@ pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
             if words.iter().any(|w| KEYWORDS.contains(w)) {
                 return range;
             }
-            let java_member = after == Some('(')
-                && !head.trim_end().ends_with('.')
-                && !head.trim().is_empty()
-                && !head.contains(['=', '('])
-                && !words.iter().any(|w| matches!(*w, "return" | "throw" | "new" | "yield" | "assert"));
+            let java_member =
+                after == Some('(') && !head.trim_end().ends_with('.') && !head.trim().is_empty() && !head.contains('=');
             if java_member && fallback.is_none() {
                 fallback = Some(range);
             }
@@ -264,24 +227,6 @@ mod tests {
         assert_eq!(parse("jar:///no/entry.jar"), None);
     }
 
-    #[test]
-    fn opens_selected_archives_for_jdt_and_jar_classes() {
-        let tmp = tempfile::tempdir().unwrap();
-        let sources = tmp.path().join("library sources.zip");
-        jar(&sources, &[("p/Lib.java", "package p; public class Lib { class Inner {} }")]);
-        for uri in [
-            "jdt://contents/lib-1.jar/p/Lib.class?=project/escaped-jar-path",
-            "jdt://contents/lib-1.jar/p/Lib.java?=project/escaped-jar-path",
-            "jar:file:///m2/g/lib/1/lib-1.jar!/p/Lib$Inner.class",
-        ] {
-            let (uri, text) = source_in_archive(uri, &sources).unwrap();
-            assert!(uri.ends_with("library%20sources.zip!/p/Lib.java"), "{uri}");
-            assert!(text.contains("class Lib"));
-        }
-        assert!(source_in_archive("jdt://contents/lib.jar/p/Missing.class", &sources).is_none());
-        assert!(source_in_archive("csharp:/p/App.csproj/decompiled/Lib.cs", &sources).is_none());
-    }
-
     #[test]
     fn finds_the_source_of_each_kind_of_class_in_maven_and_gradle_caches() {
         let tmp = tempfile::tempdir().unwrap();
@@ -340,8 +285,6 @@ mod tests {
         assert_eq!(at(java, "run"), (3, 49, 52), "the member, not the call in its body");
         assert_eq!(at("val x = 1", "missing"), (0, 0, 0));
         assert_eq!(at("// é\nfun ü() {}", "ü"), (1, 4, 5), "UTF-16 columns");
-        let java = "class Lib {\n    boolean caller(String s) { return isBlank(s); }\n    /**\n     * Changed signature from isBlank(String) to isBlank(CharSequence).\n     */\n    public static boolean isBlank(CharSequence cs) { return false; }\n}\n";
-        assert_eq!(at(java, "isBlank"), (5, 26, 33), "the declaration, not a call or Javadoc signature");
     }
 
     #[test]

crates/ide-lsp/src/types.rs

@@ -2,7 +2,7 @@
 
 use ide_core::event::ServerStatus;
 use ide_core::settings::ExternalFormatter;
-use ide_core::{Diagnostic, Location, Range, ServerId, SymbolKind, TextEdit, WorkspaceEdit};
+use ide_core::{Location, Range, ServerId, SymbolKind, TextEdit, WorkspaceEdit};
 use serde::{Deserialize, Serialize};
 use specta::Type;
 
@@ -49,11 +49,7 @@ pub struct CompletionItem {
     pub label: String,
     /// e.g. `(req: CreateOrderRequest)` shown right after the label.
     pub label_detail: Option<String>,
-    /// `labelDetails.description`: a return type or module path, shown right-aligned. Servers
-    /// such as JDT.LS also send the whole signature as `detail`, which would repeat the label.
-    pub label_description: Option<String>,
-    /// The signature or type when the server sent no `label_description`; the documentation panel
-    /// shows it either way.
+    /// e.g. return type, shown right-aligned.
     pub detail: Option<String>,
     pub kind: Option<CompletionKind>,
     pub documentation: Option<Markup>,
@@ -197,14 +193,6 @@ pub struct InlineCompletionItem {
 #[serde(rename_all = "camelCase")]
 pub struct CodeAction {
     pub title: String,
-    /// Diagnostics this action fixes, in IDE coordinates.
-    #[serde(default)]
-    #[specta(optional)]
-    pub diagnostics: Vec<Diagnostic>,
-    /// Original server diagnostics, including encoding and data, for codeAction/resolve.
-    #[serde(default)]
-    #[specta(optional)]
-    pub original_diagnostics: Option<String>,
     /// LSP kind, e.g. `quickfix`, `refactor.extract`, `source.organizeImports`.
     pub kind: Option<String>,
     pub is_preferred: bool,

crates/ide-lsp/tests/mock_server.rs

@@ -1301,7 +1301,7 @@ async fn completion_mapping_merge_and_resolve() {
             "isIncomplete": false,
             "itemDefaults": { "data": { "from": "defaults" } },
             "items": [{
-                "label": "bar", "kind": 2, "detail": "fn() -> u8", "labelDetails": { "detail": "()", "description": "u8" },
+                "label": "bar", "kind": 2, "detail": "fn() -> u8", "labelDetails": { "detail": "()" },
                 "textEdit": { "newText": "bar()$0", "insert": {"start":{"line":0,"character":12},"end":{"line":0,"character":14}},
                               "replace": {"start":{"line":0,"character":12},"end":{"line":0,"character":15}} },
                 "insertTextFormat": 2, "sortText": "0001"
@@ -1322,7 +1322,6 @@ async fn completion_mapping_merge_and_resolve() {
     assert_eq!(bar.insert_text, "bar()$0");
     assert!(bar.is_snippet);
     assert_eq!(bar.label_detail.as_deref(), Some("()"));
-    assert_eq!(bar.label_description.as_deref(), Some("u8"));
     assert_eq!(bar.replace_range, Some(rng(0, 12, 0, 14)));
     assert_eq!(bar.replace_range_tab, Some(rng(0, 12, 0, 15)));
     assert_eq!(bar.data, Some(json!({ "from": "defaults" })));
@@ -1338,13 +1337,9 @@ async fn completion_mapping_merge_and_resolve() {
     assert_eq!(resolved.documentation.as_ref().unwrap().value, "**docs**");
     assert_eq!(resolved.additional_edits[0].new_text, "use foo;\n");
     assert_eq!(resolved.insert_text, "bar()$0", "fields absent from the resolve reply are kept");
-    assert_eq!(resolved.label_detail.as_deref(), Some("()"));
-    assert_eq!(resolved.label_description.as_deref(), Some("u8"));
-    assert_eq!(resolved.detail.as_deref(), Some("fn() -> u8"));
     assert_eq!(resolved.replace_range_tab, Some(rng(0, 12, 0, 15)));
     let sent = &a.requested("completionItem/resolve")[0];
     assert_eq!(sent["data"], json!({ "from": "defaults" }));
-    assert_eq!(sent["labelDetails"], json!({ "detail": "()", "description": "u8" }));
     assert_eq!(sent["textEdit"]["replace"]["end"]["character"], 15);
 
     // Server b has no resolve support: the item comes back unchanged.
@@ -1449,7 +1444,7 @@ async fn diagnostics_become_events_and_feed_code_actions() {
     s.respond(
         "textDocument/codeAction",
         json!([
-            { "title": "Remove", "kind": "quickfix", "isPreferred": true, "data": { "id": 7 }, "diagnostics": [diag(0)] },
+            { "title": "Remove", "kind": "quickfix", "isPreferred": true, "data": { "id": 7 } },
             { "title": "Run", "command": "mock.run", "arguments": [1] }
         ]),
     );
@@ -1464,9 +1459,6 @@ async fn diagnostics_become_events_and_feed_code_actions() {
     assert_eq!(actions.len(), 2);
     assert_eq!(actions[0].kind.as_deref(), Some("quickfix"));
     assert!(actions[0].is_preferred);
-    assert_eq!(actions[0].diagnostics[0].range, rng(0, 4, 0, 10));
-    assert_eq!(actions[0].diagnostics[0].message, "unused variable");
-    assert!(actions[1].diagnostics.is_empty());
     assert_eq!(actions[1].command.as_ref().unwrap().command, "mock.run");
     let req = &s.requested("textDocument/codeAction")[0];
     assert_eq!(req["context"]["only"], json!(["quickfix"]));
@@ -1476,8 +1468,6 @@ async fn diagnostics_become_events_and_feed_code_actions() {
 
     let resolved = h.mgr.resolve_code_action(doc, actions[0].clone()).await.unwrap();
     assert_eq!(s.requested("codeAction/resolve")[0]["data"], json!({ "id": 7 }));
-    assert_eq!(s.requested("codeAction/resolve")[0]["diagnostics"], json!([diag(0)]));
-    assert_eq!(resolved.diagnostics, actions[0].diagnostics);
     let edit = resolved.edit.unwrap();
     assert!(
         matches!(&edit.files[0], FileEdit::Edit { path: p, edits, .. } if p == &path && edits[0].range == rng(0, 0, 1, 0))

crates/ide-plugin/src/actor.rs

@@ -196,7 +196,7 @@ impl Actor {
         grace: Duration,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
-        self.call_cancellable_before(cancel, grace, None, false, f)
+        self.call_cancellable_before(cancel, grace, None, f)
     }
 
     /// A cancellable editor call: queued work expires after `soft`, and a
@@ -209,18 +209,7 @@ impl Actor {
         soft: Duration,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
-        self.call_cancellable_before(cancel, grace, Some(Instant::now() + soft), false, f)
-    }
-
-    /// A launch gate's deadline also interrupts running host calls and background tasks.
-    pub fn call_bounded<R: Send + 'static>(
-        &self,
-        cancel: &ide_core::CancellationToken,
-        grace: Duration,
-        timeout: Duration,
-        f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
-    ) -> Result<R, ActorError> {
-        self.call_cancellable_before(cancel, grace, Some(Instant::now() + timeout), true, f)
+        self.call_cancellable_before(cancel, grace, Some(Instant::now() + soft), f)
     }
 
     fn call_cancellable_before<R: Send + 'static>(
@@ -228,7 +217,6 @@ impl Actor {
         cancel: &ide_core::CancellationToken,
         grace: Duration,
         deadline: Option<Instant>,
-        hard_deadline: bool,
         f: impl FnOnce(&mut Runtime) -> Result<R, CallError> + Send + 'static,
     ) -> Result<R, ActorError> {
         let (reply, result) = mpsc::sync_channel(1);
@@ -272,7 +260,7 @@ impl Actor {
             match result.recv_timeout(Duration::from_millis(5)) {
                 Ok(outcome) if cancelled_at.is_some() => {
                     drop(outcome);
-                    return Err(if cancel.is_cancelled() { ActorError::Cancelled } else { ActorError::SoftTimeout });
+                    return Err(ActorError::Cancelled);
                 }
                 Ok(outcome) => return outcome,
                 Err(mpsc::RecvTimeoutError::Disconnected) => {
@@ -280,21 +268,19 @@ impl Actor {
                 }
                 Err(mpsc::RecvTimeoutError::Timeout) => {}
             }
-            let timed_out = hard_deadline && deadline.is_some_and(|t| Instant::now() >= t);
-            if !cancel.is_cancelled() && !timed_out {
+            if !cancel.is_cancelled() {
                 if deadline.is_some_and(|t| Instant::now() >= t) && !*running.lock().unwrap_or_else(|e| e.into_inner())
                 {
                     return Err(ActorError::SoftTimeout);
                 }
                 continue;
             }
-            let failure = || if cancel.is_cancelled() { ActorError::Cancelled } else { ActorError::SoftTimeout };
             match cancelled_at {
                 None => {
                     cancelled_at = Some(Instant::now());
                     let running = running.lock().unwrap_or_else(|e| e.into_inner());
                     if !*running {
-                        return Err(failure());
+                        return Err(ActorError::Cancelled);
                     }
                     self.cancel.cancel_soft();
                 }
@@ -304,7 +290,7 @@ impl Actor {
                     if *running {
                         self.cancel();
                     }
-                    return Err(failure());
+                    return Err(ActorError::Cancelled);
                 }
                 Some(_) => {}
             }

crates/ide-plugin/src/execution.rs

@@ -151,19 +151,3 @@ pub enum PluginTestEvent {
     Output(TestOutput),
     Other { kind: String, data: String },
 }
-
-/// Operation about to launch through a plugin-owned run target (API 1.5).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum RunTargetOperation {
-    Run,
-    Debug,
-    Test,
-}
-
-/// Launch metadata available to a target validator; arguments and environment are omitted.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct RunTargetLaunch {
-    pub operation: RunTargetOperation,
-    pub program: String,
-    pub cwd: String,
-}

crates/ide-plugin/src/runtime.rs

@@ -18,7 +18,6 @@ use crate::types::{
 };
 use crate::wit_host::injections_bindings::exports::openidea::plugin::injections as wit_inj;
 use crate::wit_host::language_features_bindings::exports::openidea::plugin::language_features as wit_lf;
-use crate::wit_host::run_target_validation_bindings::exports::openidea::plugin::run_target_validation as wit_rtv;
 use crate::wit_host::{
     bindings, commit_checks_bindings, details_bindings, endpoints_bindings, file_actions_bindings, hover_bindings,
     indexing_bindings, inlay_bindings, providers_bindings, semantic_bindings, syntax_bindings, views_bindings,
@@ -926,7 +925,6 @@ pub struct Runtime {
 
 /// What the component exports: the `plugin` world, plus optional interfaces.
 struct Exports {
-    run_target_validation: Option<wit_rtv::Guest>,
     language_features: Option<wit_lf::Guest>,
     injections: Option<wit_inj::Guest>,
     plugin: bindings::Plugin,
@@ -1064,7 +1062,6 @@ impl Runtime {
         let endpoint_indices = wit_endpoints::GuestIndices::new(&pre).ok();
         let configs_indices = wit_configs::GuestIndices::new(&pre).ok();
         let tests_indices = wit_tests::GuestIndices::new(&pre).ok();
-        let validation_indices = wit_rtv::GuestIndices::new(&pre).ok();
         let lf_indices = wit_lf::GuestIndices::new(&pre).ok();
         let inj_indices = wit_inj::GuestIndices::new(&pre).ok();
         let mcp_indices =
@@ -1076,8 +1073,6 @@ impl Runtime {
         let test_results = tests_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let language_features = lf_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let injections = inj_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
-        let run_target_validation =
-            validation_indices.map(|i| i.load(&mut store, &instance)).transpose().map_err(api_hint)?;
         let plugin = plugin_indices.load(&mut store, &instance).map_err(api_hint)?;
         let syntax = match syntax_indices {
             Some(indices) => Some(indices.load(&mut store, &instance).map_err(api_hint)?),
@@ -1130,7 +1125,6 @@ impl Runtime {
         Ok(Self {
             store,
             exports: Exports {
-                run_target_validation,
                 language_features,
                 injections,
                 plugin,
@@ -1155,37 +1149,6 @@ impl Runtime {
         })
     }
 
-    pub fn has_run_target_validation(&self) -> bool {
-        self.exports.run_target_validation.is_some()
-    }
-
-    /// Missing optional validators allow the launch without a guest call.
-    pub fn validate_run_target(
-        &mut self,
-        root: String,
-        target: String,
-        launch: crate::RunTargetLaunch,
-        timeout: Duration,
-    ) -> Result<Result<(), String>, CallError> {
-        if self.exports.run_target_validation.is_none() {
-            return Ok(Ok(()));
-        }
-        let invocation = Invocation { workspace_root: Some(root.clone().into()), ..Default::default() };
-        let launch = wit_rtv::LaunchInfo {
-            operation: match launch.operation {
-                crate::RunTargetOperation::Run => wit_rtv::Operation::Run,
-                crate::RunTargetOperation::Debug => wit_rtv::Operation::Debug,
-                crate::RunTargetOperation::Test => wit_rtv::Operation::Test,
-            },
-            program: launch.program,
-            cwd: launch.cwd,
-        };
-        self.call(invocation, timeout, |e, store| {
-            e.run_target_validation.as_ref().unwrap().call_validate(store, &root, &target, &launch)
-        })
-        .map(|r| r.map_err(|message| clip(message, 4096)))
-    }
-
     /// Complete configurations from the optional API 1.4 export.
     pub fn run_configurations(
         &mut self,

crates/ide-plugin/src/wit_host.rs

@@ -1878,72 +1878,31 @@ impl From<bindings::openidea::plugin::views::ContentTabReply> for crate::Content
     }
 }
 
-impl StoreData {
-    fn register_plugin_run_target(
-        &mut self,
-        project: Resource<ProjectRes>,
-        target: crate::PluginRunTarget,
-    ) -> Fallible<()> {
-        if let Err(e) = self.require(Capability::Process(target.program.clone())) {
-            return Ok(Err(e));
-        }
-        let root = self.table.get(&project)?.root.clone();
-        Ok(self.host.register_run_target(&root, target).map_err(to_wit))
-    }
-}
-
 impl bindings::openidea::plugin::run_targets::Host for StoreData {
     fn register(
         &mut self,
         project: Resource<ProjectRes>,
         target: bindings::openidea::plugin::run_targets::RunTarget,
     ) -> Fallible<()> {
-        self.register_plugin_run_target(
-            project,
-            crate::PluginRunTarget {
-                id: target.id,
-                name: target.name,
-                program: target.program,
-                args: target.args,
-                workdir_args: target.workdir_args,
-                container_root: target.container_root,
-                commands: target
-                    .commands
-                    .into_iter()
-                    .map(|(name, args)| ide_core::remote_settings::PluginCommandOverride {
-                        name,
-                        args,
-                        workdir_args: None,
-                    })
-                    .collect(),
-            },
-        )
-    }
-    fn register_with_overrides(
-        &mut self,
-        project: Resource<ProjectRes>,
-        target: bindings::openidea::plugin::run_targets::RunTargetWithOverrides,
-    ) -> Fallible<()> {
-        self.register_plugin_run_target(
-            project,
-            crate::PluginRunTarget {
-                id: target.id,
-                name: target.name,
-                program: target.program,
-                args: target.args,
-                workdir_args: target.workdir_args,
-                container_root: target.container_root,
-                commands: target
-                    .commands
-                    .into_iter()
-                    .map(|c| ide_core::remote_settings::PluginCommandOverride {
-                        name: c.name,
-                        args: c.args,
-                        workdir_args: c.workdir_args,
-                    })
-                    .collect(),
-            },
-        )
+        if let Err(e) = self.require(Capability::Process(target.program.clone())) {
+            return Ok(Err(e));
+        }
+        let root = self.table.get(&project)?.root.clone();
+        Ok(self
+            .host
+            .register_run_target(
+                &root,
+                crate::PluginRunTarget {
+                    id: target.id,
+                    name: target.name,
+                    program: target.program,
+                    args: target.args,
+                    workdir_args: target.workdir_args,
+                    container_root: target.container_root,
+                    commands: target.commands,
+                },
+            )
+            .map_err(to_wit))
     }
     fn unregister(&mut self, project: Resource<ProjectRes>, id: String) -> wasmtime::Result<()> {
         let root = self.table.get(&project)?.root.clone();
@@ -2335,8 +2294,3 @@ pub(crate) mod mcp_bindings {
         },
     });
 }
-
-/// Optional API 1.5 run-target launch validation.
-pub(crate) mod run_target_validation_bindings {
-    wasmtime::component::bindgen!({ world: "run-target-validator", path: "../../wit" });
-}

crates/ide-plugin/tests/fixtures/api14/dist/plugin.wasm.sources

@@ -1 +1 @@
-023542d758cd359aa4d1282b95ddd2edca9fcf746862700705dd637b3e524571
+9963d6606bb6b859bebe1f55892488944f6d5e3308e6c0109f38f4b1a67b01f5

crates/ide-plugin/tests/fixtures/commit/dist/plugin.wasm.sources

@@ -1 +1 @@
-ef4cedb7ab9caa7a5a597fa8bd302e4e10607989c575af1ca0c237f2d8bb06c8
+7ab9937fdb2e78d0d62d9b85b78a0a6d9511224f85908c3a5a5e9c0d4b5e7e14

crates/ide-plugin/tests/fixtures/data-tools/dist/plugin.wasm.sources

@@ -1 +1 @@
-c215812502ccbb85b08efb9da234e6e9709deb84a492b41e771c61d4c38a05fb
+cf1f91d8accf8339bf6e22bef5067bfe3cba75d38cd30d8748b0aa451ee2495b

crates/ide-plugin/tests/fixtures/detail-views/dist/plugin.wasm.sources

@@ -1 +1 @@
-52efdb99877cded6fc5357d80f722975e314610b9d2bc91979b4b4cb05d8cdb8
+12ad7d649d752f2a40b28dee718a3e04b64597496ab43787c084e3cb774ccfe6

crates/ide-plugin/tests/fixtures/diagnostics/dist/plugin.wasm.sources

@@ -1 +1 @@
-0fb78e5c48f267e529ceb719ceb1e5aca82f2288071e9a0cc14809c27e7cd15a
+4bfce353b3c94490c5f95a046cd2371042b243c326bd63c65619e1489d7ab889

crates/ide-plugin/tests/fixtures/endpoints/dist/plugin.wasm.sources

@@ -1 +1 @@
-5a4c7a37b5ff83d62dcc3da616da3712113fa6257e834f51705a4f7e417e519a
+cfbd6aac217a7baea907affe4e1e7f89d1330843398e913e68b71f3a99cfb71b

crates/ide-plugin/tests/fixtures/execution/dist/plugin.wasm.sources

@@ -1 +1 @@
-e5598d719f6e66790858758718842e4474747c6e14eb3e1c29c4584b26279ef6
+dcf00138820979f523bd93e1f6b08c627c6f061ae5b6e91b340646f905593cf3

crates/ide-plugin/tests/fixtures/execution/plugin.toml

@@ -1,7 +1,7 @@
 id = "execution"
 name = "Plugin execution tests"
 version = "0.1.0"
-engines.openidea = "^1.5"
+engines.openidea = "^1.4"
 wasm = "dist/plugin.wasm"
 activation = ["on-command:*"]
 [capabilities]
@@ -50,11 +50,3 @@ title = "target"
 [[contributes.commands]]
 id = "untarget"
 title = "untarget"
-
-[[contributes.commands]]
-id = "target-overrides"
-title = "target-overrides"
-
-[[contributes.commands]]
-id = "validation"
-title = "validation"

crates/ide-plugin/tests/fixtures/execution/src/lib.rs

@@ -20,32 +20,6 @@ impl Plugin for Execution {
                 )?;
                 Ok(None)
             }
-            "target-overrides" => {
-                let project = ctx.project().ok_or_else(|| Error::Invalid("no project".into()))?;
-                let workdir_args = match arg {
-                    Some("empty") => Some(vec![]),
-                    Some("own") => Some(vec!["--working-dir={cwd}".into()]),
-                    Some("invalid") => Some(vec!["bad\0arg".into()]),
-                    _ => None,
-                };
-                host::register_run_target_with_overrides(
-                    &project,
-                    &PluginRunTargetWithOverrides {
-                        id: "wrapper".into(),
-                        name: "Execution target".into(),
-                        program: "execution-tool".into(),
-                        args: vec!["wrapped".into()],
-                        workdir_args: vec!["--cwd={cwd}".into()],
-                        container_root: Some("/container".into()),
-                        commands: vec![PluginCommandOverride {
-                            name: "composer".into(),
-                            args: vec!["composer".into()],
-                            workdir_args,
-                        }],
-                    },
-                )?;
-                Ok(None)
-            }
             "untarget" => {
                 host::unregister_run_target(&ctx.project().unwrap(), arg.unwrap_or("wrapper"));
                 Ok(None)
@@ -79,7 +53,6 @@ impl Plugin for Execution {
                 Ok(None)
             }
             "events" => host::storage::get("events"),
-            "validation" => host::storage::get("validation"),
             _ => Err(Error::NotFound(id.into())),
         }
     }
@@ -148,25 +121,4 @@ impl TestResults for Execution {
         ]
     }
 }
-impl RunTargetValidation for Execution {
-    fn validate(&mut self, project: &str, target: &str, launch: &RunTargetLaunch) -> Result<(), String> {
-        host::storage::set(
-            "validation",
-            &format!("{project}|{target}|{:?}|{}|{}", launch.operation, launch.program, launch.cwd),
-        )
-        .unwrap();
-        match target {
-            "refuse" => Err("Project runtime is stopped".into()),
-            "long-refusal" => Err("x".repeat(10000)),
-            "trap" => panic!("validator failed"),
-            "timeout" => {
-                let _task = host::begin_task("Validation", true);
-                loop {
-                    std::hint::spin_loop();
-                }
-            }
-            _ => Ok(()),
-        }
-    }
-}
-register_plugin!(Execution, run_configurations, test_results, run_target_validation);
+register_plugin!(Execution, run_configurations, test_results);

crates/ide-plugin/tests/fixtures/file-templates/dist/plugin.wasm.sources

@@ -1 +1 @@
-18a37beb12a0a3da68345314f7bfbb9521e8819702ef50a1c81f29bc3112c997
+98e0e01e8405ae7501e89c0dab06e6672b5240a831b19e8fbf0604a3171b31e9

crates/ide-plugin/tests/fixtures/files-events/dist/plugin.wasm.sources

@@ -1 +1 @@
-c464178ead4043d49d10e63430436f9e261b211b1a7ff18d146ed244975baf7d
+fcee11f27ff9ae0038e8067712e269ccd49423372f692e9351c24f82906aafad

crates/ide-plugin/tests/fixtures/grouped-views/dist/plugin.wasm.sources

@@ -1 +1 @@
-655bbe70bf3280a6e301255955d3e99e68b29242538b60060f61082977019212
+5c777d7b146277fa803587d1788a7359b08478def00c4574dd565d784200e39a

crates/ide-plugin/tests/fixtures/hello/dist/plugin.wasm.sources

@@ -1 +1 @@
-2987ca7af6f5ae800ed3bcf826b7f85b713371cb6efa483953e0a4974248f61f
+825b9ee483796efd24fcfe358b94f4667d87e311475769ec9e41ba9af6d03a6a

crates/ide-plugin/tests/fixtures/hover/dist/plugin.wasm.sources

@@ -1 +1 @@
-ff914b1c3ae4709c86e8138cdc84ea500ebde77ac09dcd3722faeffeb25b3454
+45b8cbd2ed7635ce04651937574dde9cf441dd619d76b8996f522c671950eaee

crates/ide-plugin/tests/fixtures/indexer/dist/plugin.wasm.sources

@@ -1 +1 @@
-8db8367b3e0872ebcb03b7f37a55fa1510f52e7f40eb07e401a40a0019349eb8
+e456b7ddf087ffbf2df62431bf9df47fad1929079c99a941a5deaf30599109f9

crates/ide-plugin/tests/fixtures/inlay-hints/dist/plugin.wasm.sources

@@ -1 +1 @@
-8ec23043c138a4fe9ba13cdaf13b78b56032eea14f48caddde6e5016226e3d28
+e0d8b590ad6ffd9569c6362802b2be909cb34b37b18cc8cc8492f9c460610e20

crates/ide-plugin/tests/fixtures/jobs/dist/plugin.wasm.sources

@@ -1 +1 @@
-cde70a51050b29cbf553df08c6aadb660be51c9146ec1d3e186de55a3130a7c1
+d2512203db3e5c6df93e9ccd5ff8daed8f1ebd28462b8caf7d500e814d3b6671

crates/ide-plugin/tests/fixtures/language-features/dist/plugin.wasm.sources

@@ -1 +1 @@
-21ac46f028c4a151b1f89eac12ad8894d1dbc84a3489f3054dec239c87de5e4a
+b32da5137b552cfad2557716343ed8ac9236b34fec018e3f2facc7b78b67e72a

crates/ide-plugin/tests/fixtures/misbehave/dist/plugin.wasm.sources

@@ -1 +1 @@
-7981067231363be183e28e9aa0dd8cffb430783080c702a1843c361187b3f267
+ae58467cdb6e98a491d739884eee96d239f80451de749950d81f4fd480edba58

crates/ide-plugin/tests/fixtures/path-events/dist/plugin.wasm.sources

@@ -1 +1 @@
-e4fafd8b7ea6d9bb6d10836c8fc133a58277f68e293410d221372bced719a192
+e378c85a4fe395c7b172065a33a2f15ad76852ac42d4099d2cf1f64540e13143

crates/ide-plugin/tests/fixtures/private-dir/dist/plugin.wasm.sources

@@ -1 +1 @@
-c6d9a0c72cf63c1a4ddb9cb45fa7eaf2cd4d6e14d6977b6e834196ad526f0a2a
+23dc9ab1affb5b0c0166a5bb2bffb8a273a5c9eed0c06d402f16a1440b835639

crates/ide-plugin/tests/fixtures/run-target-api14/README.md

@@ -1,8 +0,0 @@
-# Frozen API 1.4 run-target guest
-
-`dist/plugin.wasm` is the execution fixture shipped in OpenIDEA v0.1.40,
-from commit `37c2a6048eea89d4f6db645622612358b643862b`, built against API 1.4.
-The manifest exposes its `target` command under a separate plugin id.
-Keep this binary frozen: rebuilding it with the current SDK would stop testing
-released guests. Its source is `crates/ide-plugin/tests/fixtures/execution/src/lib.rs`
-at that commit. It registers a Composer override inheriting the shared cwd arguments.

crates/ide-plugin/tests/fixtures/run-target-api14/plugin.toml

@@ -1,12 +0,0 @@
-id = "run-target-api14"
-name = "Frozen API 1.4 run target"
-version = "0.1.0"
-engines.openidea = "^1.4"
-wasm = "dist/plugin.wasm"
-activation = ["on-command:*"]
-[capabilities]
-required = ["project.read"]
-optional = ["process:execution-tool"]
-[[contributes.commands]]
-id = "target"
-title = "target"