fix(ui): remember splitter positions in the Git and other tool windows

SplitGroup only remembers sizes with a storageKey, and none of the Git views
passed one, so the Commit, Local Changes, Log, Stash/Shelf and revision
splitters went back to their defaults whenever the view was recreated. Give
them, the Commit dialog, and the Todo, Find, Problems, Usages, Build, HTTP
Client and Dependency Analyzer splits a key, with stable panel ids.

A view whose preview pane comes and goes keys its sizes per panel set;
SplitGroup now applies that set's saved sizes when the key changes, once the
panels have registered, so toggling a preview restores its size without
remounting the view.

Cargo.lock

@@ -4269,7 +4269,6 @@ dependencies = [
 name = "ide-dap"
 version = "0.1.45"
 dependencies = [
- "base64 0.22.1",
  "futures",
  "ide-core",
  "ide-heap",
@@ -4288,7 +4287,6 @@ dependencies = [
  "specta",
  "tempfile",
  "tokio",
- "tokio-tungstenite",
  "tracing",
  "tracing-subscriber",
  "windows-sys 0.61.2",

crates/ide-agent/src/acp/discover.rs

@@ -17,30 +17,11 @@ const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else
 
 /// Opens `session/new`, reads `configOptions`, and records per-model `thought_level` choices.
 pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
-    let prefer_stored = crate::provider::prefer_stored_copilot_auth();
-    match run_once(shared, spec, prefer_stored).await {
-        Err(err)
-            if !prefer_stored
-                && crate::provider::is_copilot_provider(&spec.id)
-                && crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
-                && super::auth_required(0, &err) =>
-        {
-            let retry = run_once(shared, spec, true).await;
-            if retry.is_ok() {
-                crate::provider::mark_prefer_stored_copilot_auth();
-            }
-            retry
-        }
-        other => other,
-    }
-}
-
-async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
     let root = shared.paths.project_root.clone();
     let launch = spec.clone();
     let launch = tokio::task::spawn_blocking({
         let root = root.clone();
-        move || launch.resolve_for_launch_with_copilot_env(&root, strip_ambient)
+        move || launch.resolve_for_launch(&root)
     })
     .await
     .map_err(|e| e.to_string())?;

crates/ide-agent/src/provider.rs

@@ -120,18 +120,10 @@ impl ProviderSpec {
     }
 
     /// Resolve once before connecting, so authentication guidance names that same install.
-    pub(crate) fn resolve_for_launch(self, cwd: &Path) -> Self {
-        let strip = prefer_stored_copilot_auth();
-        self.resolve_for_launch_with_copilot_env(cwd, strip)
-    }
-
-    pub(crate) fn resolve_for_launch_with_copilot_env(mut self, cwd: &Path, strip_ambient_tokens: bool) -> Self {
+    pub(crate) fn resolve_for_launch(mut self, cwd: &Path) -> Self {
         if self.driver != Driver::Acp {
             self.command = crate::native::newest_install(&self.command);
         }
-        if is_copilot_provider(&self.id) {
-            self.env = sanitized_copilot_env(&self.env, strip_ambient_tokens);
-        }
         let program = ide_jsonrpc::resolve_spawn_program(&self.command, &self.env);
         self.command =
             if program.components().count() > 1 && !program.is_absolute() { cwd.join(program) } else { program }
@@ -141,69 +133,6 @@ impl ProviderSpec {
     }
 }
 
-const AMBIENT_COPILOT_AUTH_VARS: [&str; 3] = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
-static PREFER_STORED_COPILOT_AUTH: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
-
-pub(crate) fn is_copilot_provider(id: &str) -> bool {
-    id == "copilot" || id.starts_with("copilot-")
-}
-
-pub(crate) fn prefer_stored_copilot_auth() -> bool {
-    PREFER_STORED_COPILOT_AUTH.load(std::sync::atomic::Ordering::Acquire)
-}
-
-pub(crate) fn mark_prefer_stored_copilot_auth() {
-    PREFER_STORED_COPILOT_AUTH.store(true, std::sync::atomic::Ordering::Release);
-}
-
-pub(crate) fn has_unconfigured_copilot_ambient_token(spec_env: &[(String, String)]) -> bool {
-    AMBIENT_COPILOT_AUTH_VARS.iter().any(|&key| {
-        !spec_env.iter().any(|(k, v)| k == key && !v.is_empty())
-            && ambient_copilot_env_value(key).is_some_and(|v| !v.is_empty())
-    })
-}
-
-fn ambient_copilot_env_value(key: &str) -> Option<String> {
-    ide_core::process::shell_env()
-        .find(|(k, _)| *k == key)
-        .map(|(_, v)| v.to_string_lossy().into_owned())
-        .or_else(|| ide_core::process::host_var_os(key).map(|v| v.to_string_lossy().into_owned()))
-}
-
-/// Builds child environment overrides for `copilot`:
-/// - Always clears ambient classic PATs (`ghp_…`), which Copilot CLI unconditionally rejects
-///   (`"Classic PATs are not supported"`) instead of falling back to Keychain / `gh` login.
-/// - When `strip_ambient_tokens` is true, clears unconfigured ambient `GITHUB_TOKEN` / `GH_TOKEN` /
-///   `COPILOT_GITHUB_TOKEN` so Copilot uses its stored login (`~/.copilot` or `gh auth` keyring),
-///   while preserving any token explicitly configured in OpenIDEA's agent `spec_env`.
-pub(crate) fn sanitized_copilot_env(
-    spec_env: &[(String, String)],
-    strip_ambient_tokens: bool,
-) -> Vec<(String, String)> {
-    sanitize_copilot_env_with(spec_env, strip_ambient_tokens, ambient_copilot_env_value)
-}
-
-pub(crate) fn sanitize_copilot_env_with(
-    spec_env: &[(String, String)],
-    strip_ambient_tokens: bool,
-    lookup: impl Fn(&str) -> Option<String>,
-) -> Vec<(String, String)> {
-    let mut out = Vec::with_capacity(spec_env.len() + AMBIENT_COPILOT_AUTH_VARS.len());
-    for key in AMBIENT_COPILOT_AUTH_VARS {
-        let explicit = spec_env.iter().any(|(k, v)| k == key && !v.is_empty());
-        if explicit {
-            continue;
-        }
-        if let Some(val) = lookup(key).filter(|v| !v.is_empty())
-            && (strip_ambient_tokens || val.trim().starts_with("ghp_"))
-        {
-            out.push((key.to_owned(), String::new()));
-        }
-    }
-    out.extend(spec_env.iter().cloned());
-    out
-}
-
 fn render_login_hint(spec: &ProviderSpec, program: &Path, on_path: Option<&Path>, windows: bool) -> String {
     let Some(builtin) = builtin_spec(&spec.id) else { return spec.login_hint.clone() };
     let prefix = format!("Run `{}", builtin.command);
@@ -1172,23 +1101,4 @@ mod tests {
         import_acp(dir.path(), None, "not json").unwrap_err();
         assert!(import_acp(dir.path(), None, "{}").unwrap().is_empty());
     }
-
-    #[test]
-    fn sanitizes_classic_pats_and_ambient_tokens_while_preserving_explicit_agent_env() {
-        let lookup = |k: &str| match k {
-            "GITHUB_TOKEN" => Some("ghp_classic_pat_123".into()),
-            "GH_TOKEN" => Some("gho_oauth_token_456".into()),
-            _ => None,
-        };
-        assert_eq!(sanitize_copilot_env_with(&[], false, lookup), vec![("GITHUB_TOKEN".into(), String::new())]);
-        assert_eq!(
-            sanitize_copilot_env_with(&[], true, lookup),
-            vec![("GH_TOKEN".into(), String::new()), ("GITHUB_TOKEN".into(), String::new())]
-        );
-        let explicit = vec![("GH_TOKEN".into(), "github_pat_custom".into())];
-        assert_eq!(
-            sanitize_copilot_env_with(&explicit, true, lookup),
-            vec![("GITHUB_TOKEN".into(), String::new()), ("GH_TOKEN".into(), "github_pat_custom".into())]
-        );
-    }
 }

crates/ide-build/src/compile/mod.rs

@@ -53,8 +53,6 @@ pub enum BuildSystem {
     TypeScript,
     #[serde(rename = "cmake")]
     CMake,
-    #[serde(rename = "dotnet")]
-    Dotnet,
 }
 
 /// One command of a build.
@@ -167,8 +165,6 @@ fn detect_dir(dir: &Path, model: &BuildModel, root: &Path) -> Option<BuildSystem
         || has(dir, &["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"])
     {
         Some(BuildSystem::Gradle)
-    } else if dotnet_target(dir).is_some() {
-        Some(BuildSystem::Dotnet)
     } else if has(dir, &["Cargo.toml"]) {
         Some(BuildSystem::Cargo)
     } else if has(dir, &["go.mod", "go.work"]) {
@@ -229,7 +225,7 @@ pub fn plan(
         .or((!model.gradle.is_empty()).then_some(BuildSystem::Gradle))
         .or_else(|| model.maven.as_ref().filter(|m| !m.projects.is_empty()).map(|_| BuildSystem::Maven))
         .ok_or_else(|| {
-            IdeError::not_found("no supported build system (Maven, Gradle, .NET, Cargo, Go, TypeScript, CMake) found")
+            IdeError::not_found("no supported build system (Maven, Gradle, Cargo, Go, TypeScript, CMake) found")
         })?;
     let module = module_dir.as_deref().filter(|d| *d != root);
     let title = match module {
@@ -248,7 +244,6 @@ pub fn plan(
         BuildSystem::Go => go_steps(file.and_then(Path::parent).unwrap_or(&dir), kind)?,
         BuildSystem::TypeScript => ts_steps(&dir, kind),
         BuildSystem::CMake => cmake_steps(&dir, kind, cmake.and_then(<[_]>::first)),
-        BuildSystem::Dotnet => dotnet_steps(&dir, kind)?,
     };
     Ok(BuildPlan { system, title, steps })
 }
@@ -456,33 +451,6 @@ fn has_build_script(dir: &Path) -> bool {
         .is_some_and(|v| v.pointer("/scripts/build").is_some_and(serde_json::Value::is_string))
 }
 
-/// The solution (`.sln` / `.slnx`) or project (`.csproj` / `.fsproj` / `.vbproj`) file `dir`
-/// builds: a solution first, then a project; the first by name when there are several.
-fn dotnet_target(dir: &Path) -> Option<PathBuf> {
-    let mut files: Vec<PathBuf> =
-        std::fs::read_dir(dir).ok()?.flatten().map(|e| e.path()).filter(|p| p.is_file()).collect();
-    files.sort();
-    let ext = |p: &Path| p.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
-    let solution = files.iter().find(|p| matches!(ext(p).as_str(), "sln" | "slnx"));
-    solution.or_else(|| files.iter().find(|p| matches!(ext(p).as_str(), "csproj" | "fsproj" | "vbproj"))).cloned()
-}
-
-/// `dotnet build` of the directory's solution or project; Rebuild skips incremental builds,
-/// Build Artifacts publishes. The summary that repeats every message is left out.
-fn dotnet_steps(dir: &Path, kind: BuildKind) -> IdeResult<Vec<BuildStep>> {
-    let target = dotnet_target(dir).ok_or_else(|| IdeError::not_found("no .NET solution or project found"))?;
-    let target = target.file_name().map_or_else(String::new, |n| n.to_string_lossy().into_owned());
-    let verb = if kind == BuildKind::Artifacts { "publish" } else { "build" };
-    let mut step = BuildStep::new("dotnet", &[verb, &target, "-nologo", "-clp:NoSummary"], dir, Format::Msbuild);
-    if kind == BuildKind::Rebuild {
-        step.args.push("--no-incremental".into());
-    }
-    // The classic console logger prints the canonical `file(line,col): error` lines; the
-    // terminal logger (.NET 8+) only appears on a terminal, but rules it out for older SDKs too.
-    step.env.insert("MSBUILDTERMINALLOGGER".into(), "off".into());
-    Ok(vec![step])
-}
-
 fn ts_steps(dir: &Path, kind: BuildKind) -> Vec<BuildStep> {
     let script = has_build_script(dir);
     if script && (kind == BuildKind::Artifacts || !dir.join("tsconfig.json").is_file()) {
@@ -1173,24 +1141,6 @@ mod tests {
             ("pnpm", &["run".to_owned(), "build".to_owned()][..])
         );
 
-        // .NET: the solution, else the project; a module build is the file's project. An ASP.NET
-        // project's package.json (its front end) doesn't make it a TypeScript build.
-        let net = tmp.path().join("net");
-        write(&net, "App.sln", "");
-        write(&net, "src/Api/Api.csproj", "<Project/>");
-        write(&net, "src/Api/package.json", "{}");
-        write(&net, "src/Api/Program.cs", "");
-        let p = plan(&net, &BuildModel::default(), BuildKind::Build, None, None).unwrap();
-        assert_eq!(p.system, BuildSystem::Dotnet);
-        assert_eq!(p.steps[0].args, ["build", "App.sln", "-nologo", "-clp:NoSummary"]);
-        assert_eq!(p.steps[0].env["MSBUILDTERMINALLOGGER"], "off");
-        let p = plan(&net, &BuildModel::default(), BuildKind::Rebuild, Some(&net.join("src/Api/Program.cs")), None)
-            .unwrap();
-        assert_eq!(p.steps[0].args, ["build", "Api.csproj", "-nologo", "-clp:NoSummary", "--no-incremental"]);
-        assert_eq!(p.steps[0].cwd, net.join("src/Api"));
-        let p = plan(&net, &BuildModel::default(), BuildKind::Artifacts, None, None).unwrap();
-        assert_eq!(p.steps[0].args[0], "publish");
-
         let cm = tmp.path().join("cm");
         write(&cm, "CMakeLists.txt", "project(app)");
         let args = |p: &BuildPlan| p.steps.iter().map(|s| s.args.join(" ")).collect::<Vec<_>>();

crates/ide-build/src/compile/parse.rs

@@ -25,8 +25,6 @@ pub(crate) enum Format {
     Go,
     /// GCC / Clang (through `cmake --build`): `src/a.cpp:12:5: error: msg`.
     Gcc,
-    /// MSBuild (`dotnet build`): `C:\p\A.cs(12,5): error CS1002: msg [C:\p\App.csproj]`.
-    Msbuild,
 }
 
 /// What a printed column counts.
@@ -270,43 +268,6 @@ fn tsc_line(line: &str) -> Option<RawMessage> {
     Some(m)
 }
 
-/// MSBuild's canonical form: `path(12,5): error CS1002: msg [project]`, `path(12,5,12,9): …`,
-/// or `path : error NU1101: msg [project]` for a project-level message (no position).
-/// The path may contain spaces (`C:\Users\Jane Doe\…`); "error" / "warning" are never localized.
-fn msbuild_line(line: &str) -> Option<RawMessage> {
-    let line = line.trim();
-    // The project the message came from, appended by the console logger.
-    let line = match line.rfind(" [") {
-        Some(i) if line.ends_with(']') => &line[..i],
-        _ => line,
-    };
-    let (head, severity, rest) =
-        [(" error ", Severity::Error), (" warning ", Severity::Warning)].into_iter().find_map(|(word, severity)| {
-            let i = line.find(&format!(":{word}"))?;
-            Some((&line[..i], severity, &line[i + word.len() + 1..]))
-        })?;
-    let (code, msg) = rest.split_once(':')?;
-    let code = code.trim();
-    if code.is_empty() || code.contains(' ') {
-        return None;
-    }
-    let head = head.trim_end();
-    let (path, pos) = match head.strip_suffix(')').and_then(|h| h.rsplit_once('(')) {
-        Some((path, pos)) => (path, pos.split(',').map(num).collect::<Vec<_>>()),
-        None => (head, Vec::new()),
-    };
-    let at = |i: usize| pos.get(i).copied().flatten();
-    // `MSBUILD : error MSB1009` and the like name no file.
-    let file = path.rsplit(['/', '\\']).next().is_some_and(|n| n.contains('.'));
-    let mut m = RawMessage::new(severity, msg.trim(), ColUnit::Utf16);
-    if file {
-        m.path = Some(path.trim().to_owned());
-        (m.line, m.col, m.end_line, m.end_col) = (at(0), at(1), at(2), at(3));
-    }
-    m.code = Some(code.to_owned());
-    Some(m)
-}
-
 /// go: `./a.go:12:5: msg` (errors only; `go vet` style `a.go:12: msg` too).
 fn go_line(line: &str) -> Option<RawMessage> {
     let (path, ln, col, rest) = path_line_col(line)?;
@@ -443,7 +404,6 @@ impl OutputParser {
             Format::Tsc => tsc_line(&line),
             Format::Go => go_line(&line),
             Format::Gcc => gcc_line(&line),
-            Format::Msbuild => msbuild_line(&line),
             Format::Cargo => None,
         };
         if let Some(msg) = parsed {
@@ -591,27 +551,6 @@ mod tests {
         assert!(plain.messages.is_empty() && plain.console.is_none());
     }
 
-    #[test]
-    fn msbuild_canonical_messages() {
-        let out = parse(
-            Format::Msbuild,
-            "  Determining projects to restore...\n\
-             C:\\Users\\Jane Doe\\App\\Program.cs(12,5): error CS1002: ; expected [C:\\Users\\Jane Doe\\App\\App.csproj]\n\
-             /p/App/Models/User.cs(3,8,3,12): warning CS0168: The variable 'e' is declared but never used [/p/App/App.csproj]\n\
-             /p/App/App.csproj : error NU1101: Unable to find package Foo. [/p/App/App.csproj]\n\
-             MSBUILD : error MSB1009: Project file does not exist.\n\
-             Build FAILED.\n",
-        );
-        assert_eq!(out.len(), 4, "{out:?}");
-        assert_eq!(pos(&out[0]), (Severity::Error, "C:\\Users\\Jane Doe\\App\\Program.cs", 12, Some(5)));
-        assert_eq!((out[0].code.as_deref(), out[0].text.as_str()), (Some("CS1002"), "; expected"));
-        assert_eq!(pos(&out[1]), (Severity::Warning, "/p/App/Models/User.cs", 3, Some(8)));
-        assert_eq!((out[1].end_line, out[1].end_col), (Some(3), Some(12)));
-        assert_eq!((out[2].path.as_deref(), out[2].line), (Some("/p/App/App.csproj"), None));
-        assert_eq!(out[2].text, "Unable to find package Foo.");
-        assert_eq!((out[3].path.as_deref(), out[3].code.as_deref()), (None, Some("MSB1009")));
-    }
-
     #[test]
     fn tsc_plain_and_pretty() {
         let out = parse(

crates/ide-core/src/event.rs

@@ -118,10 +118,6 @@ pub enum IdeEvent {
     LanguageServer {
         server: ServerId,
         name: String,
-        /// What the user sees as the server when another program serves in its place.
-        #[serde(default)]
-        #[specta(optional)]
-        label: Option<String>,
         status: ServerStatus,
         message: Option<String>,
     },

crates/ide-core/src/jsonc.rs

@@ -1,10 +1,8 @@
 //! JSON with comments (`devcontainer.json`, `deno.jsonc`, `tsconfig.json`): turned
 //! into plain JSON for `serde_json`.
 
-/// Strips `//` and `/* */` comments, trailing commas and a leading byte order mark (Visual
-/// Studio writes one into `launchSettings.json`) so JSONC parses as JSON.
+/// Strips `//` and `/* */` comments and trailing commas so JSONC parses as JSON.
 pub fn strip(src: &str) -> String {
-    let src = src.strip_prefix('\u{feff}').unwrap_or(src);
     let mut out = String::with_capacity(src.len());
     let mut chars = src.chars().peekable();
     let mut in_str = false;
@@ -89,10 +87,4 @@ mod tests {
         assert_eq!(v["url"], "https://x.dev//y /* no */");
         assert_eq!(v["q"], "say \"hi\",");
     }
-
-    #[test]
-    fn drops_a_byte_order_mark() {
-        let v: serde_json::Value = serde_json::from_str(&strip("\u{feff}{ \"a\": 1 }")).unwrap();
-        assert_eq!(v["a"], 1);
-    }
 }

crates/ide-core/src/settings.rs

@@ -1092,8 +1092,7 @@ impl Default for ExternalFormatterSettings {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct PythonSettings {
-    /// Project interpreter executable; empty = auto-detect (project venv, else `python3`);
-    /// `target:<run-target-id>` = the Python of a Docker or Compose run target.
+    /// Project interpreter executable; empty = auto-detect (project venv, else `python3`).
     pub interpreter: String,
     /// Activate the interpreter's virtualenv in new terminal sessions.
     pub activate_virtualenv: bool,
@@ -1122,17 +1121,6 @@ impl Default for PythonSettings {
     }
 }
 
-impl PythonSettings {
-    /// What `interpreter` starts with when the project interpreter is a run target's.
-    pub const TARGET_PREFIX: &str = "target:";
-
-    /// The run target whose Python is the project interpreter (`target:<id>`), if one is.
-    pub fn run_target(&self) -> Option<&str> {
-        let id = self.interpreter.trim().strip_prefix(Self::TARGET_PREFIX)?.trim();
-        (!id.is_empty()).then_some(id)
-    }
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
 #[serde(default, rename_all = "camelCase")]
 pub struct PhpSettings {
@@ -1554,16 +1542,6 @@ impl Settings {
 mod tests {
     use super::*;
 
-    #[test]
-    fn python_interpreter_may_name_a_run_target() {
-        let python = |interpreter: &str| PythonSettings { interpreter: interpreter.into(), ..Default::default() };
-        assert_eq!(python("target:web").run_target(), Some("web"));
-        assert_eq!(python(" target: web ").run_target(), Some("web"));
-        for local in ["", "target:", "/usr/bin/python3", ".venv/bin/python", "targets/python"] {
-            assert_eq!(python(local).run_target(), None, "{local}");
-        }
-    }
-
     #[test]
     fn removed_one_themes_read_as_islands_themes() {
         let settings: Settings = serde_json::from_str(

crates/ide-dap/Cargo.toml

@@ -7,8 +7,6 @@ license.workspace = true
 
 [dependencies]
 futures.workspace = true
-tokio-tungstenite.workspace = true
-base64.workspace = true
 tempfile.workspace = true
 ide-core.workspace = true
 ide-language.workspace = true

crates/ide-dap/src/js_cdp.rs

@@ -1,528 +0,0 @@
-//! Replacing the responses a debugged page receives. js-debug hands out a WebSocket that
-//! speaks the browser's own protocol (`requestCDPProxy`); over it the browser is told to hold
-//! the requests whose URL matches a rule (`Fetch.enable`) and each held request is answered
-//! here, with the rule's response or by letting it through.
-//!
-//! A held request stays held until it is answered, so interception is always switched off
-//! (`Fetch.disable`) before the connection is given up: a page whose requests nobody answers hangs.
-
-use crate::{DebugManager, DebugSessionId, REQUEST_TIMEOUT, js_debug};
-use base64::Engine;
-use futures::{SinkExt, StreamExt};
-use ide_core::{IdeError, IdeResult};
-use serde::{Deserialize, Serialize};
-use serde_json::{Value, json};
-use specta::Type;
-use std::collections::HashMap;
-use tokio::sync::{oneshot, watch};
-use tokio_tungstenite::tungstenite::{Message, http::StatusCode};
-
-/// A response given in place of the server's to every request whose URL contains `url_contains`.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct JsResponseRule {
-    pub url_contains: String,
-    pub status: u16,
-    pub content_type: String,
-    pub body: String,
-}
-
-/// The browser's URL pattern (`*` any text, `?` one character, `\` escapes) for "contains `part`".
-pub(crate) fn url_pattern(part: &str) -> String {
-    let mut pattern = String::with_capacity(part.len() + 2);
-    pattern.push('*');
-    for c in part.chars() {
-        if matches!(c, '*' | '?' | '\\') {
-            pattern.push('\\');
-        }
-        pattern.push(c);
-    }
-    pattern.push('*');
-    pattern
-}
-
-pub(crate) fn rule_for<'a>(rules: &'a [JsResponseRule], url: &str) -> Option<&'a JsResponseRule> {
-    rules.iter().find(|rule| url.contains(&rule.url_contains))
-}
-
-/// What to tell the browser about a request it holds: the first matching rule's response, or
-/// to send the request on. Every held request gets one of the two.
-pub(crate) fn answer(held: &Value, rules: &[JsResponseRule]) -> (&'static str, Value) {
-    let request_id = held.get("requestId").and_then(Value::as_str).unwrap_or_default();
-    let url = held.pointer("/request/url").and_then(Value::as_str).unwrap_or_default();
-    let Some(rule) = rule_for(rules, url) else {
-        return ("Fetch.continueRequest", json!({ "requestId": request_id }));
-    };
-    let header = |name: &str, value: &str| json!({ "name": name, "value": value });
-    // A page on another origin only reads a response that names its origin. The server would
-    // say so; the response given in its place has to.
-    let mut cross_origin = Vec::new();
-    if let Some(origin) = request_header(held, "Origin") {
-        cross_origin.push(header("Access-Control-Allow-Origin", origin));
-        cross_origin.push(header("Access-Control-Allow-Credentials", "true"));
-    }
-    let method = held.pointer("/request/method").and_then(Value::as_str).unwrap_or_default();
-    // The browser's question before such a request: allowed here, the server may not exist.
-    if method == "OPTIONS"
-        && let Some(asked) = request_header(held, "Access-Control-Request-Method")
-    {
-        cross_origin.push(header("Access-Control-Allow-Methods", asked));
-        if let Some(asked) = request_header(held, "Access-Control-Request-Headers") {
-            cross_origin.push(header("Access-Control-Allow-Headers", asked));
-        }
-        let allowed = json!({
-            "requestId": request_id,
-            "responseCode": 204,
-            "responsePhrase": phrase(204),
-            "responseHeaders": cross_origin,
-        });
-        return ("Fetch.fulfillRequest", allowed);
-    }
-    let mut headers = vec![header("Content-Type", &rule.content_type)];
-    headers.extend(cross_origin);
-    let replaced = json!({
-        "requestId": request_id,
-        "responseCode": rule.status,
-        "responsePhrase": phrase(rule.status),
-        "responseHeaders": headers,
-        "body": base64::engine::general_purpose::STANDARD.encode(rule.body.as_bytes()),
-    });
-    ("Fetch.fulfillRequest", replaced)
-}
-
-/// A header of the held request; the browser reports names as the page wrote them.
-fn request_header<'a>(held: &'a Value, name: &str) -> Option<&'a str> {
-    held.pointer("/request/headers")?.as_object()?.iter().find(|(key, _)| key.eq_ignore_ascii_case(name))?.1.as_str()
-}
-
-/// The browser refuses a response without a phrase when it has none of its own for the status.
-fn phrase(status: u16) -> &'static str {
-    StatusCode::from_u16(status).ok().and_then(|status| status.canonical_reason()).unwrap_or("Unknown")
-}
-
-fn interception(rules: &[JsResponseRule]) -> Value {
-    let patterns: Vec<Value> = rules
-        .iter()
-        .map(|rule| json!({ "urlPattern": url_pattern(&rule.url_contains), "requestStage": "Request" }))
-        .collect();
-    json!({ "patterns": patterns })
-}
-
-/// Applies `rules` to the page behind js-debug's CDP proxy at `ws_url` until their sender is
-/// dropped (the session is gone) or the proxy closes the connection. The browser holds
-/// requests only while there are rules. `ready` hears whether the proxy reports held
-/// requests at all; nothing is held before it has agreed to.
-pub(crate) async fn serve(
-    ws_url: String,
-    mut rules: watch::Receiver<Vec<JsResponseRule>>,
-    ready: oneshot::Sender<Result<(), String>>,
-) {
-    let socket = match tokio_tungstenite::connect_async(ws_url.as_str()).await {
-        Ok((socket, _)) => socket,
-        Err(e) => {
-            let _ = ready.send(Err(e.to_string()));
-            return;
-        }
-    };
-    let (mut write, mut read) = socket.split();
-    let mut last_id = 0u64;
-    let mut call = |method: &str, params: Value| {
-        last_id += 1;
-        (last_id, Message::text(json!({ "id": last_id, "method": method, "params": params }).to_string()))
-    };
-
-    let (subscription, subscribe) = call("JsDebug.subscribe", json!({ "events": ["Fetch.requestPaused"] }));
-    let subscribed = tokio::time::timeout(REQUEST_TIMEOUT, async {
-        write.send(subscribe).await.map_err(|e| e.to_string())?;
-        loop {
-            let reply = read.next().await.ok_or("the connection closed")?.map_err(|e| e.to_string())?;
-            let Some(reply) = reply.to_text().ok().and_then(|text| serde_json::from_str::<Value>(text).ok()) else {
-                continue;
-            };
-            if reply.get("id").and_then(Value::as_u64) != Some(subscription) {
-                continue;
-            }
-            break match reply.get("error") {
-                Some(error) => Err(error.get("message").and_then(Value::as_str).unwrap_or("refused").to_owned()),
-                None => Ok(()),
-            };
-        }
-    })
-    .await
-    .unwrap_or_else(|_| Err("no answer".to_owned()));
-    if let Err(why) = subscribed {
-        let _ = ready.send(Err(why));
-        let _ = write.close().await;
-        return;
-    }
-    let _ = ready.send(Ok(()));
-
-    let mut current = rules.borrow_and_update().clone();
-    let mut holding = !current.is_empty();
-    if holding && write.send(call("Fetch.enable", interception(&current)).1).await.is_err() {
-        return;
-    }
-    // The request each sent replacement is for, by command id, until the browser has taken it.
-    let mut replacing: HashMap<u64, String> = HashMap::new();
-    loop {
-        tokio::select! {
-            changed = rules.changed() => {
-                if changed.is_err() {
-                    break;
-                }
-                current = rules.borrow_and_update().clone();
-                let (_, command) = match (current.is_empty(), holding) {
-                    (true, false) => continue,
-                    (true, true) => call("Fetch.disable", json!({})),
-                    (false, _) => call("Fetch.enable", interception(&current)),
-                };
-                holding = !current.is_empty();
-                if write.send(command).await.is_err() {
-                    return;
-                }
-            }
-            message = read.next() => {
-                // The proxy closed (the page or the session ended): nothing is held any more.
-                let Some(Ok(message)) = message else { return };
-                let Ok(text) = message.to_text() else { continue };
-                let Ok(message) = serde_json::from_str::<Value>(text) else { continue };
-                if let Some(id) = message.get("id").and_then(Value::as_u64) {
-                    // The browser did not take the replacement: let the request through, or
-                    // it stays held and the page waits for it.
-                    if let Some(request_id) = replacing.remove(&id)
-                        && message.get("error").is_some()
-                    {
-                        let (_, go_on) = call("Fetch.continueRequest", json!({ "requestId": request_id }));
-                        if write.send(go_on).await.is_err() {
-                            return;
-                        }
-                    }
-                    continue;
-                }
-                if message.get("method").and_then(Value::as_str) != Some("Fetch.requestPaused") {
-                    continue;
-                }
-                let Some(held) = message.get("params") else { continue };
-                let Some(request_id) = held.get("requestId").and_then(Value::as_str) else { continue };
-                let (method, params) = answer(held, &current);
-                let (id, command) = call(method, params);
-                if method == "Fetch.fulfillRequest" {
-                    replacing.insert(id, request_id.to_owned());
-                }
-                if write.send(command).await.is_err() {
-                    return;
-                }
-            }
-        }
-    }
-    if holding {
-        let _ = write.send(call("Fetch.disable", json!({})).1).await;
-    }
-    let _ = write.close().await;
-}
-
-impl DebugManager {
-    /// Makes `rules` the page's response rules; none switches the replacing off. The first
-    /// rules of a session open the connection to js-debug's CDP proxy, later ones go over it.
-    /// An error means the rules are not applied.
-    pub async fn js_set_response_overrides(&self, s: DebugSessionId, rules: Vec<JsResponseRule>) -> IdeResult<()> {
-        let session = self.session(s)?;
-        if !js_debug::is_page(&session) {
-            return Err(IdeError::unavailable("this debug session is not a page in a browser"));
-        }
-        // Held to the end: two callers at once would each open a connection.
-        let mut applied = session.js_overrides.lock().await;
-        if applied.as_ref().is_some_and(|sender| sender.send(rules.clone()).is_ok()) {
-            return Ok(());
-        }
-        // No connection yet, or the proxy closed it.
-        applied.take();
-        if rules.is_empty() {
-            return Ok(());
-        }
-        let refused =
-            |why: String| IdeError::unavailable(format!("the JavaScript debugger has no browser connection: {why}"));
-        if !js_debug::launched(&session).await {
-            return Err(refused("the page's debug session did not finish starting".into()));
-        }
-        let proxy = session
-            .conn
-            .request_timeout("requestCDPProxy", json!({}), REQUEST_TIMEOUT)
-            .await
-            .map_err(|e| refused(e.to_string()))?;
-        let (Some(host), Some(port)) =
-            (proxy.get("host").and_then(Value::as_str), proxy.get("port").and_then(Value::as_u64))
-        else {
-            return Err(refused("no address".into()));
-        };
-        let path = proxy.get("path").and_then(Value::as_str).unwrap_or_default();
-        let (sender, receiver) = watch::channel(rules);
-        let (ready, is_ready) = oneshot::channel();
-        tokio::spawn(serve(format!("ws://{host}:{port}{path}"), receiver, ready));
-        match is_ready.await {
-            Ok(Ok(())) => {
-                *applied = Some(sender);
-                Ok(())
-            }
-            Ok(Err(why)) => Err(refused(why)),
-            Err(_) => Err(refused("no answer".into())),
-        }
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-    use futures::{SinkExt, StreamExt};
-    use serde_json::json;
-    use tokio::sync::mpsc;
-    use tokio_tungstenite::tungstenite::Message;
-
-    pub(crate) fn rule(url_contains: &str, status: u16, body: &str) -> JsResponseRule {
-        JsResponseRule {
-            url_contains: url_contains.into(),
-            status,
-            content_type: "application/json".into(),
-            body: body.into(),
-        }
-    }
-
-    #[test]
-    fn a_part_of_a_url_becomes_a_pattern_that_matches_it_anywhere() {
-        assert_eq!(url_pattern("api/items"), "*api/items*");
-        // The pattern's own wildcards and escape character are taken literally.
-        assert_eq!(url_pattern(r"a*b?c\d"), r"*a\*b\?c\\d*");
-    }
-
-    #[test]
-    fn the_first_rule_whose_text_is_in_the_url_answers() {
-        let rules = [rule("api/items", 201, "{\"a\":\"é\"}"), rule("api", 500, "later")];
-        assert_eq!(rule_for(&rules, "http://h/api/items?x=1").map(|r| r.status), Some(201));
-        assert_eq!(rule_for(&rules, "http://h/api/users").map(|r| r.status), Some(500));
-        assert!(rule_for(&rules, "http://h/logo.png").is_none());
-
-        let (command, params) = answer(&held("7", "http://h/api/items")["params"], &rules);
-        assert_eq!(command, "Fetch.fulfillRequest");
-        assert_eq!(
-            params,
-            json!({
-                "requestId": "7",
-                "responseCode": 201,
-                "responsePhrase": "Created",
-                "responseHeaders": [{ "name": "Content-Type", "value": "application/json" }],
-                // base64 of the UTF-8 text `{"a":"é"}`
-                "body": "eyJhIjoiw6kifQ==",
-            })
-        );
-        // A request the browser held that no rule is for goes on to the network.
-        assert_eq!(
-            answer(&held("8", "http://h/logo.png")["params"], &rules),
-            ("Fetch.continueRequest", json!({ "requestId": "8" }))
-        );
-    }
-
-    #[test]
-    fn a_status_the_browser_has_no_phrase_for_is_given_one() {
-        // The browser refuses a response whose status it cannot name.
-        let (_, params) = answer(&held("1", "http://h/api")["params"], &[rule("api", 419, "")]);
-        assert_eq!((&params["responseCode"], &params["responsePhrase"]), (&json!(419), &json!("Unknown")));
-    }
-
-    fn header<'a>(params: &'a Value, name: &str) -> Option<&'a str> {
-        params["responseHeaders"].as_array()?.iter().find(|h| h["name"] == name)?["value"].as_str()
-    }
-
-    #[test]
-    fn a_replaced_response_passes_the_pages_cross_origin_check() {
-        let rules = [rule("api/items", 200, "[]")];
-        let from_page = |method: &str, headers: Value| json!({ "requestId": "3", "request": { "url": "http://localhost:8080/api/items", "method": method, "headers": headers } });
-        // A page on another origin: the response names that origin, as the real server would.
-        let (_, params) = answer(&from_page("GET", json!({ "origin": "http://localhost:5173" })), &rules);
-        assert_eq!(header(&params, "Access-Control-Allow-Origin"), Some("http://localhost:5173"));
-        assert_eq!(header(&params, "Access-Control-Allow-Credentials"), Some("true"));
-        assert_eq!(params["body"], "W10=");
-
-        // The browser's question before such a request is answered too: the server may not exist.
-        let preflight = from_page(
-            "OPTIONS",
-            json!({
-                "Origin": "http://localhost:5173",
-                "Access-Control-Request-Method": "PUT",
-                "Access-Control-Request-Headers": "content-type,x-token",
-            }),
-        );
-        let (command, params) = answer(&preflight, &rules);
-        assert_eq!((command, &params["responseCode"]), ("Fetch.fulfillRequest", &json!(204)));
-        assert_eq!(header(&params, "Access-Control-Allow-Origin"), Some("http://localhost:5173"));
-        assert_eq!(header(&params, "Access-Control-Allow-Methods"), Some("PUT"));
-        assert_eq!(header(&params, "Access-Control-Allow-Headers"), Some("content-type,x-token"));
-        assert_eq!(params.get("body"), None);
-
-        // Same origin: nothing but the rule's own header.
-        let (_, params) = answer(&from_page("GET", json!({})), &rules);
-        assert_eq!(params["responseHeaders"], json!([{ "name": "Content-Type", "value": "application/json" }]));
-    }
-
-    /// A stand-in for js-debug's CDP proxy: what it receives, and a way to send it events.
-    pub(crate) async fn proxy() -> (String, mpsc::UnboundedReceiver<Value>, mpsc::UnboundedSender<Value>) {
-        proxy_refusing(|_| false).await
-    }
-
-    /// A proxy that answers the commands `refused` picks with an error, like the real one does
-    /// for what it or the browser does not accept.
-    pub(crate) async fn proxy_refusing(
-        refused: fn(&Value) -> bool,
-    ) -> (String, mpsc::UnboundedReceiver<Value>, mpsc::UnboundedSender<Value>) {
-        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let url = format!("ws://127.0.0.1:{}/session", listener.local_addr().unwrap().port());
-        let (received_tx, received) = mpsc::unbounded_channel();
-        let (events, mut events_rx) = mpsc::unbounded_channel::<Value>();
-        tokio::spawn(async move {
-            let (stream, _) = listener.accept().await.unwrap();
-            let (mut write, mut read) = tokio_tungstenite::accept_async(stream).await.unwrap().split();
-            loop {
-                tokio::select! {
-                    message = read.next() => {
-                        let Some(Ok(message)) = message else { break };
-                        let Ok(text) = message.to_text() else { continue };
-                        let Ok(request) = serde_json::from_str::<Value>(text) else { continue };
-                        let reply = if refused(&request) {
-                            json!({ "id": request["id"], "error": { "code": -32602, "message": "refused" } })
-                        } else {
-                            json!({ "id": request["id"], "result": {} })
-                        };
-                        let _ = write.send(Message::text(reply.to_string())).await;
-                        let _ = received_tx.send(request);
-                    }
-                    Some(event) = events_rx.recv() => {
-                        let _ = write.send(Message::text(event.to_string())).await;
-                    }
-                }
-            }
-        });
-        (url, received, events)
-    }
-
-    pub(crate) async fn next(received: &mut mpsc::UnboundedReceiver<Value>) -> (String, Value) {
-        let request = tokio::time::timeout(std::time::Duration::from_secs(5), received.recv())
-            .await
-            .expect("the proxy got a request in time")
-            .expect("the connection is open");
-        (request["method"].as_str().unwrap().to_owned(), request["params"].clone())
-    }
-
-    /// The browser's event for a request it holds.
-    fn held(request_id: &str, url: &str) -> Value {
-        json!({ "method": "Fetch.requestPaused", "params": { "requestId": request_id, "request": { "url": url } } })
-    }
-
-    type Serving = (tokio::task::JoinHandle<()>, oneshot::Receiver<Result<(), String>>);
-
-    fn serving(url: String, rules: watch::Receiver<Vec<JsResponseRule>>) -> Serving {
-        let (ready, is_ready) = oneshot::channel();
-        (tokio::spawn(serve(url, rules, ready)), is_ready)
-    }
-
-    async fn ended(task: tokio::task::JoinHandle<()>) {
-        tokio::time::timeout(std::time::Duration::from_secs(5), task).await.unwrap().unwrap();
-    }
-
-    #[tokio::test]
-    async fn held_requests_are_answered_and_interception_ends_before_the_connection() {
-        let (url, mut received, events) = proxy().await;
-        let (rules, watched) = tokio::sync::watch::channel(vec![rule("api/items", 200, "[]")]);
-        let (serving, ready) = serving(url, watched);
-        assert_eq!(ready.await.unwrap(), Ok(()));
-
-        assert_eq!(
-            next(&mut received).await,
-            ("JsDebug.subscribe".into(), json!({ "events": ["Fetch.requestPaused"] }))
-        );
-        assert_eq!(
-            next(&mut received).await,
-            (
-                "Fetch.enable".into(),
-                json!({ "patterns": [{ "urlPattern": "*api/items*", "requestStage": "Request" }] })
-            )
-        );
-
-        events.send(held("1", "http://h/api/items")).unwrap();
-        let (command, params) = next(&mut received).await;
-        assert_eq!(
-            (command.as_str(), &params["requestId"], &params["responseCode"]),
-            ("Fetch.fulfillRequest", &json!("1"), &json!(200))
-        );
-        events.send(held("2", "http://h/other")).unwrap();
-        assert_eq!(next(&mut received).await, ("Fetch.continueRequest".into(), json!({ "requestId": "2" })));
-
-        // New rules replace the browser's patterns.
-        rules.send(vec![rule("api/users", 404, "{}")]).unwrap();
-        assert_eq!(
-            next(&mut received).await,
-            (
-                "Fetch.enable".into(),
-                json!({ "patterns": [{ "urlPattern": "*api/users*", "requestStage": "Request" }] })
-            )
-        );
-
-        // No rules left: the browser stops holding requests. The connection stays for the
-        // rules that come next, and goes with the session.
-        rules.send(Vec::new()).unwrap();
-        assert_eq!(next(&mut received).await.0, "Fetch.disable");
-        rules.send(vec![rule("api/items", 200, "[]")]).unwrap();
-        assert_eq!(next(&mut received).await.0, "Fetch.enable");
-        rules.send(Vec::new()).unwrap();
-        assert_eq!(next(&mut received).await.0, "Fetch.disable");
-        drop(rules);
-        ended(serving).await;
-        // Already off: not switched off a second time.
-        assert!(received.try_recv().is_err());
-    }
-
-    #[tokio::test]
-    async fn a_session_that_goes_away_switches_interception_off() {
-        let (url, mut received, _events) = proxy().await;
-        let (rules, watched) = tokio::sync::watch::channel(vec![rule("api", 200, "[]")]);
-        let (serving, _ready) = serving(url, watched);
-        assert_eq!(next(&mut received).await.0, "JsDebug.subscribe");
-        assert_eq!(next(&mut received).await.0, "Fetch.enable");
-        drop(rules);
-        assert_eq!(next(&mut received).await.0, "Fetch.disable");
-        ended(serving).await;
-    }
-
-    #[tokio::test]
-    async fn a_response_the_browser_refuses_lets_the_request_through() {
-        let (url, mut received, events) = proxy_refusing(|request| request["method"] == "Fetch.fulfillRequest").await;
-        let (_rules, watched) = tokio::sync::watch::channel(vec![rule("api", 200, "[]")]);
-        let (_serving, _ready) = serving(url, watched);
-        assert_eq!(next(&mut received).await.0, "JsDebug.subscribe");
-        assert_eq!(next(&mut received).await.0, "Fetch.enable");
-        events.send(held("9", "http://h/api")).unwrap();
-        assert_eq!(next(&mut received).await.0, "Fetch.fulfillRequest");
-        // Unanswered, the request would hang the page.
-        assert_eq!(next(&mut received).await, ("Fetch.continueRequest".into(), json!({ "requestId": "9" })));
-    }
-
-    #[tokio::test]
-    async fn a_proxy_that_does_not_report_held_requests_is_not_asked_to_hold_any() {
-        let (url, mut received, _events) = proxy_refusing(|request| request["method"] == "JsDebug.subscribe").await;
-        let (_rules, watched) = tokio::sync::watch::channel(vec![rule("api", 200, "[]")]);
-        let (serving, ready) = serving(url, watched);
-        assert_eq!(next(&mut received).await.0, "JsDebug.subscribe");
-        assert_eq!(ready.await.unwrap(), Err("refused".to_owned()));
-        ended(serving).await;
-        assert!(received.try_recv().is_err());
-    }
-
-    #[tokio::test]
-    async fn no_connection_to_the_proxy_is_reported() {
-        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let url = format!("ws://127.0.0.1:{}/session", listener.local_addr().unwrap().port());
-        drop(listener);
-        let (_rules, watched) = tokio::sync::watch::channel(vec![rule("api", 200, "[]")]);
-        let (serving, ready) = serving(url, watched);
-        assert!(ready.await.unwrap().is_err());
-        ended(serving).await;
-    }
-}

crates/ide-dap/src/js_debug.rs

@@ -11,8 +11,6 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use specta::Type;
 use std::collections::BTreeMap;
-use std::path::PathBuf;
-use std::sync::atomic::{AtomicU32, Ordering};
 
 pub(crate) const ADAPTER: &str = "js-debug";
 
@@ -27,7 +25,7 @@ pub(crate) fn is_page(session: &Session) -> bool {
 /// Waits until the adapter answered the `launch` of `session`. js-debug sets a page's session
 /// up between `configurationDone` and that answer; a request of its own that arrives then is
 /// answered and has no effect.
-pub(crate) async fn launched(session: &Session) -> bool {
+async fn launched(session: &Session) -> bool {
     let mut launched = session.launched.subscribe();
     let answered = tokio::time::timeout(REQUEST_TIMEOUT, launched.wait_for(|answered| *answered)).await;
     matches!(answered, Ok(Ok(_)))
@@ -61,44 +59,6 @@ impl DebugManager {
         self.js_page_request(s, "setCustomBreakpoints", json!({ "ids": ids, "xhr": xhr })).await?;
         Ok(())
     }
-
-    /// Starts recording the page's CPU profile; [`Self::js_stop_profile`] ends it.
-    pub async fn js_start_profile(&self, s: DebugSessionId) -> IdeResult<()> {
-        self.js_page_request(s, "startProfile", json!({ "type": "cpu" })).await?;
-        Ok(())
-    }
-
-    /// Ends the recording and returns a new directory holding it as `page.cpuprofile`
-    /// (what `ide-profiler` reads a directory of).
-    pub async fn js_stop_profile(&self, s: DebugSessionId) -> IdeResult<PathBuf> {
-        let session = self.session(s)?;
-        // js-debug names the file it records into when the recording starts.
-        let Some(recorded) = session.js_profile.lock().take() else {
-            return Err(IdeError::invalid("no CPU profile is being recorded"));
-        };
-        self.js_page_request(s, "stopProfile", json!({})).await?;
-        static HANDED_OVER: AtomicU32 = AtomicU32::new(0);
-        let dir = std::env::temp_dir().join(format!(
-            "openidea-js-profile-{}-{}-{}",
-            std::process::id(),
-            s.0,
-            HANDED_OVER.fetch_add(1, Ordering::Relaxed)
-        ));
-        let copied = tokio::task::spawn_blocking({
-            let dir = dir.clone();
-            move || {
-                std::fs::create_dir_all(&dir)?;
-                std::fs::copy(&recorded, dir.join("page.cpuprofile"))?;
-                // The adapter's own copy is in the system's temporary directory: no use keeping two.
-                let _ = std::fs::remove_file(&recorded);
-                Ok::<_, std::io::Error>(())
-            }
-        })
-        .await
-        .map_err(|e| IdeError::internal(e.to_string()))?;
-        copied.map_err(|e| IdeError::unavailable(format!("the recorded CPU profile cannot be read: {e}")))?;
-        Ok(dir)
-    }
 }
 
 /// The browser events js-debug is asked to pass on (`enableNetworking`'s `mirrorEvents`).

crates/ide-dap/src/lib.rs

@@ -13,7 +13,6 @@ pub mod attach;
 mod cargo;
 pub mod connection;
 pub mod jdwp;
-mod js_cdp;
 mod js_debug;
 mod jvm_memory;
 pub mod kotlin;
@@ -25,7 +24,6 @@ use connection::{Connection, DapError};
 use futures::future::join_all;
 use ide_core::{DebugSessionId, IdeError, IdeResult, SharedSink};
 use ide_language::LanguageRegistry;
-pub use js_cdp::JsResponseRule;
 pub use js_debug::JsResponseBody;
 pub use jvm_memory::*;
 use parking_lot::Mutex;

crates/ide-dap/src/session.rs

@@ -94,11 +94,6 @@ pub(crate) struct Session {
     /// The `type` of the launch or attach request (js-debug's `pwa-node`, `pwa-chrome`); a child
     /// session's comes from the configuration the adapter started it with.
     pub launch_type: std::sync::OnceLock<String>,
-    /// The response rules of a page once a connection applies them (`js_cdp::serve`).
-    /// Dropped with the session, which switches the browser's interception off.
-    pub js_overrides: tokio::sync::Mutex<Option<tokio::sync::watch::Sender<Vec<crate::JsResponseRule>>>>,
-    /// The file js-debug records the page's CPU profile into, while one is being recorded.
-    pub js_profile: parking_lot::Mutex<Option<std::path::PathBuf>>,
     pub jvm_inspector: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::JvmInspector>>>,
     /// One inspector request per session at a time.
     pub inspect_lock: tokio::sync::Mutex<()>,
@@ -260,8 +255,6 @@ impl Session {
             progress: Mutex::new(HashMap::new()),
             jdwp_link: parking_lot::Mutex::new(None),
             launch_type: std::sync::OnceLock::new(),
-            js_overrides: tokio::sync::Mutex::new(None),
-            js_profile: parking_lot::Mutex::new(None),
             jvm_inspector: parking_lot::Mutex::new(None),
             inspect_lock: tokio::sync::Mutex::default(),
             ended: ide_core::CancellationToken::new(),
@@ -849,10 +842,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
                 s.emit(DebugEvent::JsNetwork { event });
             }
         }
-        // js-debug, after `startProfile`: where it records the profile.
-        "profileStarted" => {
-            *s.js_profile.lock() = str_("file").map(std::path::PathBuf::from);
-        }
         _ => tracing::trace!("dap: ignored event {event}"),
     }
 }
@@ -883,7 +872,6 @@ fn on_reverse_request(mgr: &Arc<DebugManager>, s: &Arc<Session>, seq: i64, comma
 pub(crate) struct ProgramTerminal {
     writer: ide_core::input::InputWriter,
     killer: Box<dyn portable_pty::ChildKiller + Send + Sync>,
-    #[cfg_attr(not(unix), allow(dead_code))]
     pid: Option<u32>,
     /// Set once the program has exited and been reaped.
     exited: Arc<AtomicBool>,
@@ -896,7 +884,6 @@ impl ProgramTerminal {
     }
 
     /// The program's process id while it runs.
-    #[cfg_attr(not(unix), allow(dead_code))]
     pub(crate) fn process_id(&self) -> Option<u32> {
         if self.exited.load(Ordering::Acquire) { None } else { self.pid }
     }

crates/ide-dap/src/tests.rs

@@ -1104,142 +1104,6 @@ async fn a_page_whose_requests_the_adapter_does_not_report_says_so() {
     h.wait_event(|e| matches!(e, DebugEvent::JsNetworkUnavailable)).await;
 }
 
-/// Where the fake adapter says its CDP proxy listens (`requestCDPProxy`).
-static CDP_PROXY_PORT: std::sync::atomic::AtomicU16 = std::sync::atomic::AtomicU16::new(0);
-
-fn proxy_adapter(msg: &Value) -> Option<CustomReply> {
-    let port = CDP_PROXY_PORT.load(std::sync::atomic::Ordering::Relaxed);
-    (msg["command"] == "requestCDPProxy")
-        .then(|| (json!({ "host": "127.0.0.1", "port": port, "path": "/session" }), Vec::new()))
-}
-
-#[tokio::test]
-async fn response_overrides_reach_the_page_through_the_adapters_proxy() {
-    use crate::js_cdp::tests::{next, proxy, rule};
-    let (url, mut received, _events) = proxy().await;
-    let port: u16 = url.trim_start_matches("ws://127.0.0.1:").trim_end_matches("/session").parse().unwrap();
-    CDP_PROXY_PORT.store(port, std::sync::atomic::Ordering::Relaxed);
-
-    let h = harness(Script {
-        start_debugging: true,
-        custom: Some(proxy_adapter),
-        child_launch_delay: Duration::from_millis(150),
-        ..Script::default()
-    });
-    let browser = h.start(js_config("pwa-chrome")).await.unwrap();
-    let page = child_of(&h, browser).await;
-
-    // Rules that are there as the page starts wait until its session takes requests.
-    tokio::time::sleep(Duration::from_millis(50)).await;
-    h.manager.js_set_response_overrides(page, vec![rule("api/items", 200, "[]")]).await.unwrap();
-    let dropped = h.log.lock().iter().filter(|m| m["type"] == "dropped").count();
-    assert_eq!(dropped, 0, "the proxy was asked for before the page took requests");
-    assert_eq!(next(&mut received).await.0, "JsDebug.subscribe");
-    assert_eq!(
-        next(&mut received).await,
-        ("Fetch.enable".into(), json!({ "patterns": [{ "urlPattern": "*api/items*", "requestStage": "Request" }] }))
-    );
-    // Changed rules go over the connection that is open: the proxy is asked for once.
-    h.manager.js_set_response_overrides(page, vec![rule("api/users", 200, "[]")]).await.unwrap();
-    assert_eq!(next(&mut received).await.1["patterns"][0]["urlPattern"], "*api/users*");
-    assert_eq!(requests(&h, "requestCDPProxy").len(), 1);
-
-    h.manager.js_set_response_overrides(page, Vec::new()).await.unwrap();
-    assert_eq!(next(&mut received).await.0, "Fetch.disable");
-    // A rule switched back on.
-    h.manager.js_set_response_overrides(page, vec![rule("api/items", 200, "[]")]).await.unwrap();
-    assert_eq!(next(&mut received).await.0, "Fetch.enable");
-    assert_eq!(requests(&h, "requestCDPProxy").len(), 1);
-
-    let not_a_page = h.manager.js_set_response_overrides(browser, vec![rule("api", 200, "")]).await.unwrap_err();
-    assert_eq!(not_a_page.kind, ide_core::error::ErrorKind::Unavailable);
-}
-
-#[tokio::test]
-async fn response_overrides_are_unavailable_without_the_adapters_proxy() {
-    use crate::js_cdp::tests::rule;
-    let h = harness(Script { start_debugging: true, ..Script::default() });
-    let browser = h.start(js_config("pwa-chrome")).await.unwrap();
-    let page = child_of(&h, browser).await;
-    let refused = h.manager.js_set_response_overrides(page, vec![rule("api", 200, "")]).await.unwrap_err();
-    assert_eq!(refused.kind, ide_core::error::ErrorKind::Unavailable);
-    // Nothing to switch off is not an error.
-    h.manager.js_set_response_overrides(page, Vec::new()).await.unwrap();
-}
-
-/// A port nothing listens on, which the fake adapter gives as its CDP proxy.
-static DEAD_PROXY_PORT: std::sync::atomic::AtomicU16 = std::sync::atomic::AtomicU16::new(0);
-
-fn dead_proxy_adapter(msg: &Value) -> Option<CustomReply> {
-    let port = DEAD_PROXY_PORT.load(std::sync::atomic::Ordering::Relaxed);
-    (msg["command"] == "requestCDPProxy")
-        .then(|| (json!({ "host": "127.0.0.1", "port": port, "path": "/session" }), Vec::new()))
-}
-
-#[tokio::test]
-async fn response_overrides_that_cannot_reach_the_browser_are_an_error() {
-    use crate::js_cdp::tests::rule;
-    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
-    DEAD_PROXY_PORT.store(listener.local_addr().unwrap().port(), std::sync::atomic::Ordering::Relaxed);
-    drop(listener);
-
-    let h = harness(Script { start_debugging: true, custom: Some(dead_proxy_adapter), ..Script::default() });
-    let browser = h.start(js_config("pwa-chrome")).await.unwrap();
-    let page = child_of(&h, browser).await;
-    let unreachable = h.manager.js_set_response_overrides(page, vec![rule("api", 200, "")]).await.unwrap_err();
-    assert_eq!(unreachable.kind, ide_core::error::ErrorKind::Unavailable);
-    // The next rules try again instead of going to a connection that never was.
-    let again = h.manager.js_set_response_overrides(page, vec![rule("api", 200, "")]).await.unwrap_err();
-    assert_eq!(again.kind, ide_core::error::ErrorKind::Unavailable);
-    assert_eq!(requests(&h, "requestCDPProxy").len(), 2);
-}
-
-/// The file the fake adapter says it records a CPU profile into (`profileStarted`).
-static PROFILE_FILE: parking_lot::Mutex<String> = parking_lot::Mutex::new(String::new());
-
-fn profiling_adapter(msg: &Value) -> Option<CustomReply> {
-    match msg["command"].as_str()? {
-        "startProfile" => {
-            Some((json!({}), vec![("profileStarted", json!({ "file": *PROFILE_FILE.lock(), "type": "cpu" }))]))
-        }
-        "stopProfile" => Some((json!({}), vec![("profilerStateUpdate", json!({ "label": "", "running": false }))])),
-        _ => None,
-    }
-}
-
-#[tokio::test]
-async fn a_pages_cpu_profile_is_handed_over_as_a_cpuprofile_file() {
-    let recorded = std::env::temp_dir().join(format!("openidea-dap-profile-{}", std::process::id()));
-    std::fs::write(&recorded, r#"{"nodes":[],"samples":[]}"#).unwrap();
-    *PROFILE_FILE.lock() = recorded.to_string_lossy().into_owned();
-
-    let h = harness(Script { start_debugging: true, custom: Some(profiling_adapter), ..Script::default() });
-    let browser = h.start(js_config("pwa-chrome")).await.unwrap();
-    let page = child_of(&h, browser).await;
-
-    // Nothing is being recorded yet.
-    let idle = h.manager.js_stop_profile(page).await.unwrap_err();
-    assert_eq!(idle.kind, ide_core::error::ErrorKind::InvalidInput);
-
-    h.manager.js_start_profile(page).await.unwrap();
-    assert_eq!(requests(&h, "startProfile"), [json!({ "type": "cpu" })]);
-    let dir = h.manager.js_stop_profile(page).await.unwrap();
-    assert_eq!(requests(&h, "stopProfile").len(), 1);
-    let files: Vec<_> = std::fs::read_dir(&dir).unwrap().map(|e| e.unwrap().file_name()).collect();
-    assert_eq!(files, ["page.cpuprofile"]);
-    assert_eq!(std::fs::read_to_string(dir.join("page.cpuprofile")).unwrap(), r#"{"nodes":[],"samples":[]}"#);
-    // One recording is handed over once.
-    assert_eq!(h.manager.js_stop_profile(page).await.unwrap_err().kind, ide_core::error::ErrorKind::InvalidInput);
-
-    // The adapter's file isn't there when it is asked for (the hand-over above took the first one).
-    assert!(!recorded.exists());
-    h.manager.js_start_profile(page).await.unwrap();
-    assert_eq!(h.manager.js_stop_profile(page).await.unwrap_err().kind, ide_core::error::ErrorKind::Unavailable);
-
-    assert_eq!(h.manager.js_start_profile(browser).await.unwrap_err().kind, ide_core::error::ErrorKind::Unavailable);
-    let _ = std::fs::remove_dir_all(dir);
-}
-
 #[test]
 fn a_child_session_is_named_by_the_adapter_unless_it_is_a_blank_page() {
     assert_eq!(child_name(&json!({ "name": "server.js [4120]" }), "Server"), "server.js [4120]");

crates/ide-docker/src/lib.rs

@@ -542,24 +542,6 @@ pub fn compose_config(ep: &DockerEndpoint, dir: &Path, files: &[String]) -> IdeR
     if out.success { Ok(out.stdout) } else { Err(failure(&args, &out.stderr, &out.stdout)) }
 }
 
-/// Runs the docker CLI with `args` in `dir` and returns its standard output; a non-zero
-/// exit is an error with docker's message.
-pub fn cli(
-    ep: &DockerEndpoint,
-    dir: Option<&Path>,
-    args: &[String],
-    timeout: Duration,
-    cancel: Option<&CancellationToken>,
-) -> IdeResult<String> {
-    let args: Vec<&str> = args.iter().map(String::as_str).collect();
-    let mut cmd = command(ep, &args)?;
-    if let Some(dir) = dir {
-        cmd.current_dir(dir);
-    }
-    let out = process::run(cmd, timeout, cancel)?;
-    if out.success { Ok(out.stdout) } else { Err(failure(&args, &out.stderr, &out.stdout)) }
-}
-
 #[cfg(test)]
 mod local_tests {
     use super::*;

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

@@ -382,15 +382,6 @@ pub async fn debug_js_custom_breakpoints(
     host.debugger.js_set_custom_breakpoints(session, ids, xhr).await
 }
 
-pub async fn debug_js_response_overrides(
-    host: &Host,
-    _window: &str,
-    session: DebugSessionId,
-    rules: Vec<ide_dap::JsResponseRule>,
-) -> IdeResult<()> {
-    host.debugger.js_set_response_overrides(session, rules).await
-}
-
 pub async fn debug_js_response_body(
     host: &Host,
     _window: &str,
@@ -400,18 +391,6 @@ pub async fn debug_js_response_body(
     host.debugger.js_response_body(session, request_id).await
 }
 
-pub async fn debug_js_start_profile(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<()> {
-    host.debugger.js_start_profile(session).await
-}
-
-pub async fn debug_js_stop_profile(
-    host: &Host,
-    _window: &str,
-    session: DebugSessionId,
-) -> IdeResult<ide_core::IpcPath> {
-    host.debugger.js_stop_profile(session).await.map(Into::into)
-}
-
 pub fn debug_capabilities(host: &Host, _window: &str, session: DebugSessionId) -> IdeResult<DebugCapabilities> {
     host.debugger.capabilities(session)
 }
@@ -628,23 +607,12 @@ pub(crate) fn register(d: &mut Dispatcher) {
         debug_restart_frame(&c.host, &c.window, c.arg("session")?, c.arg("frameId")?).await
     });
     d.add("debug_capabilities", |c| async move { debug_capabilities(&c.host, &c.window, c.arg("session")?) });
-    d.add("debug_js_response_overrides", |c| async move {
-        debug_js_response_overrides(&c.host, &c.window, c.arg("session")?, c.arg("rules")?).await
-    });
     d.add("debug_js_response_body", |c| async move {
         debug_js_response_body(&c.host, &c.window, c.arg("session")?, c.arg("requestId")?).await
     });
     d.add("debug_js_custom_breakpoints", |c| async move {
         debug_js_custom_breakpoints(&c.host, &c.window, c.arg("session")?, c.arg("ids")?, c.arg("xhr")?).await
     });
-    d.add(
-        "debug_js_start_profile",
-        |c| async move { debug_js_start_profile(&c.host, &c.window, c.arg("session")?).await },
-    );
-    d.add(
-        "debug_js_stop_profile",
-        |c| async move { debug_js_stop_profile(&c.host, &c.window, c.arg("session")?).await },
-    );
     d.add("debug_set_function_breakpoints", |c| async move {
         debug_set_function_breakpoints(&c.host, &c.window, c.arg("breakpoints")?).await
     });

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

@@ -21,28 +21,6 @@ pub fn close(host: &Host, window: &str, doc: DocId) -> IdeResult<()> {
     Ok(())
 }
 
-/// Opens an editable untitled buffer (a new-file tab); it reaches the disk
-/// through [`save_as`], which turns it into a regular file document. `name`
-/// re-references an already minted buffer instead of creating one.
-pub async fn open_untitled(host: &Host, window: &str, name: Option<String>) -> IdeResult<DocumentInfo> {
-    let project = host.project(window)?;
-    host.blocking(move || project.documents.open_untitled(name.as_deref())).await
-}
-
-/// Save As for an untitled buffer ([`Documents::save_as`]); LightEdit windows
-/// start watching the saved file's folder.
-pub async fn save_as(host: &Host, window: &str, doc: DocId, path: PathBuf) -> IdeResult<DocumentInfo> {
-    let project = host.project(window)?;
-    host.blocking(move || {
-        let info = project.documents.save_as(doc, &path)?;
-        if let Some(dir) = path.parent().filter(|_| project.light) {
-            project.watch_light_dir(dir);
-        }
-        Ok(info)
-    })
-    .await
-}
-
 /// Applies a CodeMirror change set; returns the new version (`outOfSync` when `base_version` is stale).
 pub fn edit(host: &Host, window: &str, doc: DocId, base_version: u32, changes: ChangeSet) -> IdeResult<u32> {
     host.project(window)?.documents.edit(doc, base_version, changes)

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

@@ -50,10 +50,7 @@ pub async fn doc_set_encoding(
     reload: bool,
 ) -> IdeResult<DocumentEncoding> {
     let project = host.project(window)?;
-    if reload
-        && !project.documents.is_untitled(doc)?
-        && let Some(uri) = project.documents.virtual_uri(doc)?
-    {
+    if reload && let Some(uri) = project.documents.virtual_uri(doc)? {
         let vd = if uri.starts_with("git-revision:") {
             crate::ops::vcs::revision_virtual_document(host, window, &uri, Some(&encoding)).await?
         } else {
@@ -162,15 +159,6 @@ pub async fn doc_highlights(host: &Host, window: &str, doc: DocId) -> IdeResult<
     .await
 }
 
-/// Python class facts the inheritance inspections read: base names as written, a method's
-/// parameters, decorator semantics and its body shape. Tree-sitter answers; no LSP.
-pub async fn doc_python_facts(host: &Host, window: &str, doc: DocId) -> IdeResult<ide_language::PythonFacts> {
-    let project = host.project(window)?;
-    let syntax = host.syntax();
-    let snap = project.documents.text_snapshot(doc)?;
-    blocking(move || Ok(syntax.python_facts(&snap.language, &snap.text))).await
-}
-
 /// Extend Selection (⌥↑): syntax ranges around `offset`, innermost first.
 /// Large documents fall back to word / line / document ranges.
 pub async fn doc_selection_ranges(host: &Host, window: &str, doc: DocId, offset: u32) -> IdeResult<Vec<Range>> {
@@ -220,7 +208,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("doc_outline", |c| async move { doc_outline(&c.host, &c.window, c.arg("doc")?).await });
     d.add("doc_folding", |c| async move { doc_folding(&c.host, &c.window, c.arg("doc")?).await });
     d.add("doc_highlights", |c| async move { doc_highlights(&c.host, &c.window, c.arg("doc")?).await });
-    d.add("doc_python_facts", |c| async move { doc_python_facts(&c.host, &c.window, c.arg("doc")?).await });
     d.add("doc_selection_ranges", |c| async move {
         doc_selection_ranges(&c.host, &c.window, c.arg("doc")?, c.arg("offset")?).await
     });

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

@@ -1472,15 +1472,6 @@ pub async fn lsp_type_hierarchy(
     host.project(window)?.lsp.type_hierarchy(doc, pos, direction).await
 }
 
-pub async fn lsp_prepare_type_hierarchy(
-    host: &Host,
-    window: &str,
-    doc: DocId,
-    pos: Pos,
-) -> IdeResult<Option<HierarchyItem>> {
-    host.project(window)?.lsp.prepare_type_hierarchy(doc, pos).await
-}
-
 pub fn lsp_servers(host: &Host, window: &str) -> IdeResult<Vec<ServerInfo>> {
     Ok(host.project(window)?.lsp.servers())
 }
@@ -1865,9 +1856,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
     d.add("lsp_type_hierarchy", |c| async move {
         lsp_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?, c.arg("direction")?).await
     });
-    d.add("lsp_prepare_type_hierarchy", |c| async move {
-        lsp_prepare_type_hierarchy(&c.host, &c.window, c.arg("doc")?, c.arg("pos")?).await
-    });
     d.add("lsp_servers", |c| async move { lsp_servers(&c.host, &c.window) });
     d.add("lsp_resend_diagnostics", |c| async move { lsp_resend_diagnostics(&c.host, &c.window) });
     d.add("lsp_restart", |c| async move { lsp_restart(&c.host, &c.window, c.arg("server")?).await });

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

@@ -239,12 +239,6 @@ pub fn set_settings(
     let toolchain = ["languages", "tools", "languageServers", "projectStructure"]
         .iter()
         .any(|k| key == *k || key.starts_with(&format!("{k}.")));
-    // A run target chosen as the Python interpreter (or changed) needs a snapshot of its libraries.
-    if ["languages", "languages.python", "languages.python.interpreter", "runTargets"].contains(&key) {
-        for project in affected() {
-            crate::ops::sdk::container_python::ensure(host, &project);
-        }
-    }
     // Code style only reaches servers as settings (e.g. jdtls' formatter profile); builds don't depend on it.
     if code_style || toolchain {
         for project in affected() {

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

@@ -508,7 +508,7 @@ pub fn list(host: &Host) -> Vec<RunInfo> {
 }
 
 mod commands;
-pub(crate) mod container;
+mod container;
 pub use commands::*;
 
 #[cfg(test)]

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

@@ -33,11 +33,23 @@ pub(super) async fn prepare(host: &Host, root: &Path, target: RunTarget, config:
     let root = root.to_path_buf();
     let data_dir = host.data_dir.clone();
     host.blocking(move || {
-        require_local(&endpoint, &target)?;
+        if !ide_docker::endpoint_is_local(&endpoint)? {
+            return Err(IdeError::invalid(format!(
+                "Run target '{}' uses a Docker daemon on another machine: the project can only be mounted from a local one",
+                target.name
+            )));
+        }
         let docker = ide_docker::docker_executable().ok_or_else(|| {
             IdeError::unavailable("docker executable not found; install Docker and make sure it is on PATH")
         })?;
-        let container_root = container_root(&endpoint, &root, &target)?;
+        let container_root = match target.container_root.trim() {
+            "" if target.kind == RunTargetKind::Compose => {
+                let json = ide_docker::compose_config(&endpoint, &root, &target.compose_files)?;
+                compose_container_root(&json, target.service.trim(), &root)?
+            }
+            "" => default_container_root(&root),
+            folder => folder.to_owned(),
+        };
         let file_env = env_files(&root, &config)?;
         let name = container_name(&config.id, &unique());
         let debugging = if debug { Some(Debugging::prepare(&data_dir)?) } else { None };
@@ -63,29 +75,6 @@ pub(super) async fn prepare(host: &Host, root: &Path, target: RunTarget, config:
     .await
 }
 
-/// The project can only be bind-mounted from a daemon on this machine.
-pub(crate) fn require_local(endpoint: &DockerEndpoint, target: &RunTarget) -> IdeResult<()> {
-    if !ide_docker::endpoint_is_local(endpoint)? {
-        return Err(IdeError::invalid(format!(
-            "Run target '{}' uses a Docker daemon on another machine: the project can only be mounted from a local one",
-            target.name
-        )));
-    }
-    Ok(())
-}
-
-/// Where the project is in the target's containers.
-pub(crate) fn container_root(endpoint: &DockerEndpoint, root: &Path, target: &RunTarget) -> IdeResult<String> {
-    Ok(match target.container_root.trim() {
-        "" if target.kind == RunTargetKind::Compose => {
-            let json = ide_docker::compose_config(endpoint, root, &target.compose_files)?;
-            compose_container_root(&json, target.service.trim(), root)?
-        }
-        "" => default_container_root(root),
-        folder => folder.to_owned(),
-    })
-}
-
 /// What a debug run mounts and publishes.
 struct Debugging {
     port: u16,
@@ -115,7 +104,7 @@ fn free_port() -> IdeResult<u16> {
 }
 
 /// The target's Docker connection (Services tool window), by id; none = the CLI's daemon.
-pub(crate) fn endpoint(data_dir: &Path, target: &RunTarget) -> IdeResult<DockerEndpoint> {
+fn endpoint(data_dir: &Path, target: &RunTarget) -> IdeResult<DockerEndpoint> {
     let id = target.docker_connection.trim();
     if id.is_empty() {
         return Ok(DockerEndpoint::Default);

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

@@ -10,9 +10,6 @@ use std::path::PathBuf;
 use std::sync::Mutex;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-pub(crate) mod container_python;
-pub use container_python::{ContainerPython, sdk_container_python, sdk_container_python_refresh};
-
 fn join_err(e: impl std::fmt::Display) -> IdeError {
     IdeError::internal(e.to_string())
 }
@@ -235,17 +232,12 @@ pub async fn sdk_project_libraries(
     let project = host.project(window)?;
     let (root, cache, settings) = (project.root.clone(), project.build_cache_dir(), project.settings.effective());
     let cancel = host.begin_project_request(window, request);
-    let container = container_python::library_group(host, &root, &settings);
     let libraries = {
         let (root, settings, cancel, on_groups) = (root.clone(), settings.clone(), cancel.clone(), on_groups.clone());
         tokio::task::spawn_blocking(move || {
-            if let Some(group) = &container {
-                let _ = on_groups.send(vec![group.clone()]);
-            }
-            let groups = ide_sdk::libraries::project_libraries_stream(&root, &settings, &[], &cancel, &|groups| {
+            ide_sdk::libraries::project_libraries_stream(&root, &settings, &[], &cancel, &|groups| {
                 let _ = on_groups.send(groups);
-            });
-            container.into_iter().chain(groups).collect::<Vec<_>>()
+            })
         })
     };
     let dependencies = {
@@ -385,8 +377,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
     );
     d.add("sdk_python_effective", |c| async move { sdk_python_effective(&c.host, &c.window, c.arg("near")?) });
     d.add("sdk_php_effective", |c| async move { sdk_php_effective(&c.host, &c.window) });
-    d.add("sdk_container_python", |c| async move { sdk_container_python(&c.host, &c.window) });
-    d.add("sdk_container_python_refresh", |c| async move { sdk_container_python_refresh(&c.host, &c.window).await });
     d.add("sdk_php_xdebug", |c| async move { sdk_php_xdebug(&c.host, &c.window, c.arg("php")?, c.arg("cwd")?).await });
     d.add(
         "sdk_php_language_level",

crates/ide-host/src/ops/sdk/container_python.rs

@@ -1,298 +0,0 @@
-//! A Docker or Compose run target's Python as the project interpreter: snapshots of the
-//! container's library folders for the language server (see `ide_sdk::container_python`).
-//!
-//! A snapshot runs the target's Python once in a new container (the image's entrypoint
-//! and the service's dependencies skipped), then copies its `sys.path` folders out of
-//! the stopped container with `docker cp`. Nothing is installed in the container.
-
-use crate::Host;
-use crate::project::Project;
-use ide_core::event::NotifyLevel;
-use ide_core::remote_settings::{RunTarget, RunTargetKind};
-use ide_core::settings::Settings;
-use ide_core::{IdeError, IdeEvent, IdeResult, IpcPath, TaskId};
-use ide_sdk::container_python::{self as snapshots, Snapshot};
-use ide_sdk::python::PythonPackage;
-use std::collections::HashSet;
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, LazyLock, Mutex};
-use std::time::Duration;
-
-/// Building or pulling the image may come first.
-const PROBE_TIMEOUT: Duration = Duration::from_secs(15 * 60);
-const COPY_TIMEOUT: Duration = Duration::from_secs(10 * 60);
-const QUICK: Duration = Duration::from_secs(30);
-
-/// The project interpreter when it is a run target's.
-#[derive(Clone, Debug, serde::Serialize, specta::Type)]
-#[serde(rename_all = "camelCase")]
-pub struct ContainerPython {
-    /// The run target's id.
-    pub target: String,
-    /// Its name; empty when no run target has the id.
-    pub name: String,
-    /// The Python version of the snapshot in use; `None`: no snapshot yet.
-    pub version: Option<String>,
-    /// The image the snapshot was copied from.
-    pub image: Option<String>,
-    /// The copied library folders on this machine.
-    pub folders: Vec<IpcPath>,
-    /// Packages of the snapshot (read-only).
-    pub packages: Vec<PythonPackage>,
-    /// A snapshot is being taken.
-    pub updating: bool,
-}
-
-/// Where snapshots are kept, and the Docker connections the targets refer to.
-#[derive(Clone)]
-struct Dirs {
-    data: PathBuf,
-    /// `<local data>/container-python/`: `<project>/<target>/<image>/` and `neutral/`.
-    cache: PathBuf,
-}
-
-impl Dirs {
-    fn of(host: &Host) -> Self {
-        Self::new(&host.data_dir, &host.local_data_dir)
-    }
-
-    fn new(data_dir: &Path, local_data_dir: &Path) -> Self {
-        Self { data: data_dir.to_path_buf(), cache: local_data_dir.join("container-python") }
-    }
-
-    fn target(&self, root: &Path, target: &str) -> PathBuf {
-        snapshots::target_dir(&self.cache.join(crate::project::project_key(root)), target)
-    }
-}
-
-/// Target folders with a snapshot being taken.
-static UPDATING: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
-
-fn updating(dir: &Path) -> bool {
-    UPDATING.lock().unwrap_or_else(|e| e.into_inner()).contains(dir)
-}
-
-/// The snapshot in use for the project's interpreter, if it is a run target's.
-fn current(dirs: &Dirs, root: &Path, settings: &Settings) -> Option<(PathBuf, Snapshot)> {
-    let target = settings.languages.python.run_target()?;
-    snapshots::current(&dirs.target(root, target))
-}
-
-/// Language server configuration: basedpyright / pyright see the container's libraries.
-pub(crate) fn configure_server(
-    cfg: &mut ide_language::LanguageServerConfig,
-    local_data_dir: &Path,
-    root: &Path,
-    settings: &Settings,
-) {
-    if settings.languages.python.run_target().is_none() {
-        return;
-    }
-    let current = current(&Dirs::new(local_data_dir, local_data_dir), root, settings);
-    snapshots::configure_server(cfg, current.as_ref().map(|(d, s)| (d.as_path(), s)));
-}
-
-/// External Libraries: the snapshot's folders, named after the run target.
-pub(crate) fn library_group(host: &Host, root: &Path, settings: &Settings) -> Option<ide_sdk::libraries::LibraryGroup> {
-    let target = settings.languages.python.run_target()?;
-    let (dir, snapshot) = current(&Dirs::of(host), root, settings)?;
-    let name = settings.run_targets.iter().find(|t| t.id == target).map_or(target, |t| t.name.as_str());
-    snapshots::library_group(name, &dir, &snapshot)
-}
-
-/// The project interpreter when it is a run target's, with its snapshot.
-pub fn sdk_container_python(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
-    host.require_trust(window)?;
-    let project = host.project(window)?;
-    Ok(describe(host, &project.root, &project.settings.effective()))
-}
-
-fn describe(host: &Host, root: &Path, settings: &Settings) -> Option<ContainerPython> {
-    let target = settings.languages.python.run_target()?;
-    let name = settings.run_targets.iter().find(|t| t.id == target).map(|t| t.name.clone()).unwrap_or_default();
-    let dir = Dirs::of(host).target(root, target);
-    let mut out = ContainerPython {
-        target: target.to_owned(),
-        name,
-        version: None,
-        image: None,
-        folders: Vec::new(),
-        packages: Vec::new(),
-        updating: updating(&dir),
-    };
-    if let Some((dir, snapshot)) = snapshots::current(&dir) {
-        out.folders = snapshots::local_folders(&dir, &snapshot).into_iter().map(Into::into).collect();
-        out.packages = snapshots::packages(&dir, &snapshot);
-        out.version = Some(snapshot.probe.version);
-        out.image = Some(snapshot.image);
-    }
-    Some(out)
-}
-
-/// Takes a new snapshot of the project interpreter's container (also of an image that
-/// has one already), then the language servers pick it up.
-pub async fn sdk_container_python_refresh(host: &Host, window: &str) -> IdeResult<Option<ContainerPython>> {
-    host.require_trust(window)?;
-    let project = host.project(window)?;
-    update(Dirs::of(host), &project, true).await?;
-    Ok(describe(host, &project.root, &project.settings.effective()))
-}
-
-/// Takes a snapshot when the project interpreter is a run target's and the current image
-/// has none yet (a new choice, a rebuilt image), in the background. Errors are notified.
-pub(crate) fn ensure(host: &Host, project: &Arc<Project>) {
-    if !project.is_trusted() || project.settings.effective().languages.python.run_target().is_none() {
-        return;
-    }
-    let (dirs, project) = (Dirs::of(host), project.clone());
-    host.runtime.spawn(async move {
-        if let Err(e) = update(dirs, &project, false).await
-            && e.kind != ide_core::error::ErrorKind::Cancelled
-        {
-            project.sink.emit(IdeEvent::Notify {
-                level: NotifyLevel::Warning,
-                title: "Cannot copy the container's Python libraries".into(),
-                body: Some(e.message),
-            });
-        }
-    });
-}
-
-async fn update(dirs: Dirs, project: &Arc<Project>, force: bool) -> IdeResult<()> {
-    let settings = project.settings.effective();
-    let Some(id) = settings.languages.python.run_target() else { return Ok(()) };
-    let target = ide_remote::service::run_target(&settings, id)?;
-    if target.kind == RunTargetKind::Ssh {
-        return Err(IdeError::invalid(format!(
-            "Run target '{}' runs over SSH: only a Docker or Compose run target can be the project interpreter",
-            target.name
-        )));
-    }
-    let dir = dirs.target(&project.root, id);
-    if !UPDATING.lock().unwrap_or_else(|e| e.into_inner()).insert(dir.clone()) {
-        return Ok(());
-    }
-    let _done = Updating(dir.clone());
-    let endpoint = crate::ops::run::container::endpoint(&dirs.data, &target)?;
-    let task = TaskId::next();
-    let title = format!("Python libraries of {}", target.name);
-    let (root, sink) = (project.root.clone(), project.sink.clone());
-    let progress = move |message: &str, done: bool| {
-        sink.emit(IdeEvent::Task {
-            id: task,
-            title: title.clone(),
-            message: Some(message.to_owned()),
-            fraction: None,
-            done,
-            cancellable: false,
-        })
-    };
-    let report = progress.clone();
-    let result = tokio::task::spawn_blocking(move || {
-        take(&endpoint, &root, &target, &dir, &dirs.cache, force, &|message| report(message, false))
-    })
-    .await
-    .map_err(|e| IdeError::internal(e.to_string()))
-    .and_then(|r| r);
-    progress(if result.is_ok() { "Done" } else { "Failed" }, true);
-    if result? {
-        project.lsp.reconfigure().await;
-    }
-    Ok(())
-}
-
-struct Updating(PathBuf);
-
-impl Drop for Updating {
-    fn drop(&mut self) {
-        UPDATING.lock().unwrap_or_else(|e| e.into_inner()).remove(&self.0);
-    }
-}
-
-/// Removes the probe container, also when copying failed.
-struct Container<'a> {
-    endpoint: &'a ide_docker::DockerEndpoint,
-    name: String,
-}
-
-impl Drop for Container<'_> {
-    fn drop(&mut self) {
-        let args = ["rm", "--force", "--volumes", &self.name].map(String::from);
-        if let Err(e) = ide_docker::cli(self.endpoint, None, &args, QUICK, None) {
-            tracing::warn!("cannot remove container {}: {}", self.name, e.message);
-        }
-    }
-}
-
-/// Takes the snapshot in `target_dir` and makes it the one in use; `false` when the image
-/// had one already and it is in use (unless `force`).
-fn take(
-    endpoint: &ide_docker::DockerEndpoint,
-    root: &Path,
-    target: &RunTarget,
-    target_dir: &Path,
-    cache: &Path,
-    force: bool,
-    progress: &dyn Fn(&str),
-) -> IdeResult<bool> {
-    crate::ops::run::container::require_local(endpoint, target)?;
-    let container_root = crate::ops::run::container::container_root(endpoint, root, target)?;
-    let name = format!("openidea-python-{}", unique());
-    let args = ide_remote::docker::python_probe_args(target, root, &name, snapshots::PROBE)?;
-    progress("Starting the container's Python");
-    let container = Container { endpoint, name };
-    let out = ide_docker::cli(endpoint, Some(root), &args, PROBE_TIMEOUT, None);
-    let probe = snapshots::parse_probe(&out?)?;
-    let inspect = ["inspect".into(), "--format".into(), "{{.Image}}".into(), container.name.clone()];
-    let image = ide_docker::cli(endpoint, None, &inspect, QUICK, None)?.trim().to_owned();
-    if image.is_empty() {
-        return Err(IdeError::internal(format!("docker inspect printed no image for {}", container.name)));
-    }
-    let dir = target_dir.join(snapshots::dir_name(&image));
-    let before = snapshots::current(target_dir).map(|(_, s)| s.image);
-    if !force && snapshots::read(&dir).is_some() {
-        snapshots::make_current(target_dir, &image)?;
-        return Ok(before.as_deref() != Some(image.as_str()));
-    }
-    let partial = target_dir.join(format!("{}.partial", snapshots::dir_name(&image)));
-    if partial.exists() {
-        std::fs::remove_dir_all(&partial)?;
-    }
-    std::fs::create_dir_all(&partial)?;
-    let mut folders = Vec::new();
-    for folder in snapshots::folders_to_copy(&probe, &container_root) {
-        progress(&format!("Copying {folder}"));
-        let local = snapshots::local_folder(&partial, &folder);
-        let Some(parent) = local.parent() else { continue };
-        std::fs::create_dir_all(parent)?;
-        // Into an existing folder: `docker cp` puts the source folder in it under its own name.
-        let args = ["cp".into(), format!("{}:{folder}", container.name), format!("{}/", parent.to_string_lossy())];
-        match ide_docker::cli(endpoint, None, &args, COPY_TIMEOUT, None) {
-            Ok(_) => folders.push(folder),
-            Err(e) => tracing::warn!("cannot copy {folder} from {}: {}", container.name, e.message),
-        }
-    }
-    drop(container);
-    progress("Preparing the language server's interpreter");
-    let snapshot = Snapshot {
-        neutral_python: snapshots::neutral_python(cache, &probe.version),
-        image: image.clone(),
-        probe,
-        folders,
-    };
-    snapshots::write(&partial, &snapshot)?;
-    if dir.exists() {
-        std::fs::remove_dir_all(&dir)?;
-    }
-    std::fs::rename(&partial, &dir)?;
-    snapshots::make_current(target_dir, &image)?;
-    Ok(true)
-}
-
-/// Distinguishes probe containers.
-fn unique() -> String {
-    use std::sync::atomic::{AtomicU32, Ordering};
-    static COUNT: AtomicU32 = AtomicU32::new(0);
-    let secs = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs());
-    format!("{:x}-{}-{}", secs & 0xff_ffff, std::process::id(), COUNT.fetch_add(1, Ordering::Relaxed))
-}

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

@@ -77,22 +77,9 @@ pub(super) fn validate_reply(reply: &ContentTabReply) -> Result<(), HostError> {
     Ok(())
 }
 
-/// Largest side of a plugin diff, in UTF-16 code units (earlier hosts allowed 1 MiB).
-pub(super) const MAX_DIFF_SIDE: usize = 8 << 20;
-
-fn diff_side(value: &str, side: &str) -> Result<(), HostError> {
-    if value.contains('\0') {
-        return Err(HostError::Invalid(format!("the {side} side of the diff contains NUL")));
-    }
-    if value.encode_utf16().count() > MAX_DIFF_SIDE {
-        return Err(HostError::Invalid(format!("diff too large: the {side} side is over {} MiB", MAX_DIFF_SIDE >> 20)));
-    }
-    Ok(())
-}
-
 pub(super) fn validate_diff(diff: &ide_plugin::ContentDiff) -> Result<(), HostError> {
-    diff_side(&diff.left, "left")?;
-    diff_side(&diff.right, "right")?;
+    body(&diff.left)?;
+    body(&diff.right)?;
     for value in [&diff.left_label, &diff.right_label].into_iter().flatten() {
         label(value, 128)?;
     }
@@ -584,25 +571,3 @@ impl PluginHost {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn diff(left: String, right: String) -> ide_plugin::ContentDiff {
-        ide_plugin::ContentDiff { left, right, left_label: None, right_label: None, title: None }
-    }
-
-    #[test]
-    fn diff_sides_up_to_the_limit_open_and_larger_ones_say_why() {
-        assert!(validate_diff(&diff("x".repeat(5 << 20), "y".repeat(MAX_DIFF_SIDE))).is_ok());
-        let err = validate_diff(&diff(String::new(), "y".repeat(MAX_DIFF_SIDE + 1))).unwrap_err();
-        assert!(
-            matches!(&err, HostError::Invalid(m) if m == "diff too large: the right side is over 8 MiB"),
-            "{err:?}"
-        );
-        assert!(
-            matches!(validate_diff(&diff("a\0".into(), String::new())), Err(HostError::Invalid(m)) if m.contains("NUL"))
-        );
-    }
-}

crates/ide-host/src/project.rs

@@ -88,9 +88,6 @@ impl Host {
         let root = dunce::canonicalize(root)?;
         let opening = self.opening(window);
         let _opening = opening.lock();
-        // Untitled buffers belong to the window, not a project: they follow it
-        // into the project's fresh document registry.
-        let carried = self.project(window).ok().map(|prev| prev.documents.untitled_buffers()).unwrap_or_default();
         // Reject a damaged manifest before replacing the currently open project.
         let is_workspace = ide_workspace::workspace::Workspace::load(&root)?.is_some();
         // The window reloaded (or asked again) for the project it already has: keep
@@ -177,7 +174,6 @@ impl Host {
                 let root = member.as_ref().unwrap_or(window_root);
                 ide_sdk::apply::server_launch_overrides(cfg, &effective);
                 ide_sdk::apply::configure_server(cfg, root, server_root, &effective);
-                crate::ops::sdk::container_python::configure_server(cfg, &data_dir, root, &effective);
                 if cfg.name == "jdtls" {
                     // A workspace member keeps its build model under its own key (Build Project).
                     let cache = match &member {
@@ -624,9 +620,6 @@ impl Host {
             }));
         }
         self.insert_project(window, project.clone());
-        for (key, text, dirty) in &carried {
-            let _ = project.documents.restore_untitled_buffer(key, text, *dirty);
-        }
         project.lsp.prewarm_java_configuration();
         if let Some(bridge) = &project.kotlin_bridge {
             bridge.start(&self.runtime);
@@ -637,7 +630,6 @@ impl Host {
         if let Some(cmd) = post_start {
             self.environment.spawn_post_start(cmd, project.root.clone(), project.sink.clone());
         }
-        crate::ops::sdk::container_python::ensure(self, &project);
         Ok(project)
     }
 
@@ -709,29 +701,12 @@ impl Host {
             return Err(IdeError::invalid(format!("{} is a folder", file.display())));
         }
         let dir = file.parent().map(Path::to_path_buf).ok_or_else(|| IdeError::invalid("no parent folder"))?;
-        let watch = dir.clone();
-        self.open_light_in(window, dir, Some(&watch))
-    }
-
-    /// LightEdit without a file (a welcome window's File › New File): rooted
-    /// at the user's home folder, watching nothing until a buffer is saved
-    /// into a real folder ([`Project::watch_light_dir`]).
-    pub fn open_light_empty(&self, window: &str) -> IdeResult<Arc<Project>> {
-        let dir = dirs::home_dir().unwrap_or_else(std::env::temp_dir);
-        self.open_light_in(window, dir, None)
-    }
-
-    fn open_light_in(&self, window: &str, dir: PathBuf, watch_dir: Option<&Path>) -> IdeResult<Arc<Project>> {
         let opening = self.opening(window);
         let _opening = opening.lock();
-        // Untitled buffers belong to the window: they follow it out of a project.
-        let carried = self.project(window).ok().map(|prev| prev.documents.untitled_buffers()).unwrap_or_default();
         if let Ok(current) = self.project(window)
             && current.light
         {
-            if let Some(dir) = watch_dir {
-                current.watch_light_dir(dir);
-            }
+            current.watch_light_dir(&dir);
             return Ok(current);
         }
         self.close_project(window);
@@ -750,16 +725,7 @@ impl Host {
         let syntax = Arc::new(SyntaxCache::new(self.syntax()));
         documents.add_observer(Arc::new(SyntaxObserver(syntax.clone())));
         documents.add_observer(Arc::new(HistoryObserver(history.clone())));
-        let watcher = match watch_dir {
-            Some(dir) => light_watcher(dir, &sink, &documents, &history)?,
-            // A quiet private folder stands in until the first save brings a
-            // real folder in.
-            None => {
-                let idle = self.local_data_dir.join("light-edit");
-                std::fs::create_dir_all(&idle)?;
-                light_watcher(&idle, &sink, &documents, &history)?
-            }
-        };
+        let watcher = light_watcher(&dir, &sink, &documents, &history)?;
         let project_key = project_key(&dir);
         let (db, http_history, agents) = self.project_services(&dir, &project_key, &settings, &sink);
         let notebooks = crate::notebook::NotebookService::new(
@@ -805,11 +771,8 @@ impl Host {
             light: true,
             root: dir,
         });
-        tracing::info!("window {window} edits {} without a project", project.root.display());
+        tracing::info!("window {window} edits {} without a project", file.display());
         self.insert_project(window, project.clone());
-        for (key, text, dirty) in &carried {
-            let _ = project.documents.restore_untitled_buffer(key, text, *dirty);
-        }
         Ok(project)
     }
 }
@@ -1493,7 +1456,7 @@ fn content_root_watcher(
 ) -> Option<Watcher> {
     let (kotlin_bridge, phpstan) = (kotlin_bridge.cloned(), phpstan.cloned());
     let (index, documents, history, lsp) = (index.clone(), documents.clone(), history.clone(), lsp.clone());
-    let (root, events) = (dir.to_path_buf(), sink.clone());
+    let root = dir.to_path_buf();
     Watcher::start(
         dir,
         excludes.to_vec(),
@@ -1515,11 +1478,6 @@ fn content_root_watcher(
             }
             documents.on_disk_changed(&[&changed[..], &ignored].concat());
             record_external_changes(&history, &changed, &batch.removed);
-            // A member outside the project folder: its repository changes (commit, checkout,
-            // fetch, pull) reach the UI only through this watcher.
-            if batch.vcs.iter().any(|p| vcs_path_changed(p)) {
-                events.emit(IdeEvent::VcsChanged { root: root.clone().into() });
-            }
         }),
     )
     .map_err(|e| tracing::warn!("content root watcher {}: {e}", dir.display()))

crates/ide-host/src/rpc.rs

@@ -218,13 +218,6 @@ impl Dispatcher {
         })
         .add("fs_read_text", |c| async move { ops::fs::read_text(&c.host, &c.window, c.arg("path")?).await })
         .add("doc_open", |c| async move { ops::doc::open(&c.host, &c.window, c.arg("path")?).await })
-        .add("doc_open_untitled", |c| async move {
-            ops::doc::open_untitled(&c.host, &c.window, c.arg::<Option<String>>("name")?).await
-        })
-        .add(
-            "doc_save_as",
-            |c| async move { ops::doc::save_as(&c.host, &c.window, c.arg("doc")?, c.arg("path")?).await },
-        )
         .add("doc_close", |c| async move {
             ops::doc::blocking(move || ops::doc::close(&c.host, &c.window, c.arg("doc")?)).await
         })

crates/ide-host/src/trust.rs

@@ -289,7 +289,6 @@ impl crate::Host {
                 }
             }
             project.lsp.reconfigure().await;
-            crate::ops::sdk::container_python::ensure(self, &project);
             project.sink.emit(ide_core::IdeEvent::ProjectTrustChanged { root: project.root.clone().into(), trusted });
         }
         Ok(())
@@ -401,7 +400,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
             | "web_unresolved_references"
             | "project_rename"
             | "light_edit_open"
-            | "light_edit_open_untitled"
             | "workspace_create"
             | "workspace_discover_projects"
             | "workspace_update"

crates/ide-host/tests/container_python_real.rs

@@ -1,174 +0,0 @@
-//! A Compose run target as the Python interpreter, against a real daemon and the real
-//! basedpyright. Ignored by default: `OPENIDEA_DOCKER_TEST_DIR` names an empty folder the
-//! daemon can bind-mount (on this machine, or at the same path in a VM such as OrbStack's),
-//! `docker` with the Compose plugin and `basedpyright-langserver` must be on `PATH`, and
-//! this machine's Python must not have Django installed.
-#![cfg(unix)]
-
-use ide_core::IdeEvent;
-use ide_host::{Host, HostConfig, ops};
-use ide_run::{OutputChunk, RunConfig};
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::sync::{Arc, Mutex};
-use std::time::{Duration, Instant};
-
-const WINDOW: &str = "main";
-type Events = Arc<Mutex<Vec<IdeEvent>>>;
-
-fn host(base: &Path, events: &Events) -> Arc<Host> {
-    Arc::new(Host::new(HostConfig {
-        config_dir: base.join("config"),
-        data_dir: base.join("data"),
-        local_data_dir: base.join("data"),
-        languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
-        syntax: Arc::default(),
-        sink_for: Box::new({
-            let events = events.clone();
-            move |_| {
-                let events = events.clone();
-                Arc::new(move |e: IdeEvent| events.lock().unwrap().push(e))
-            }
-        }),
-        owner: |w| w,
-        runtime: tokio::runtime::Handle::current(),
-        project_environment: false,
-    }))
-}
-
-/// basedpyright's latest diagnostics of `path` once `done` accepts them.
-async fn diagnostics(events: &Events, path: &Path, timeout: Duration, done: impl Fn(&[String]) -> bool) -> Vec<String> {
-    let deadline = Instant::now() + timeout;
-    loop {
-        let latest = events.lock().unwrap().iter().rev().find_map(|e| match e {
-            IdeEvent::Diagnostics { path: p, items, source } if **p == *path && source.contains("basedpyright") => {
-                Some(items.iter().map(|d| d.message.clone()).collect::<Vec<_>>())
-            }
-            _ => None,
-        });
-        if let Some(messages) = &latest
-            && done(messages)
-        {
-            return messages.clone();
-        }
-        assert!(Instant::now() < deadline, "timed out; last diagnostics: {latest:?}");
-        tokio::time::sleep(Duration::from_millis(500)).await;
-    }
-}
-
-fn unresolved(messages: &[String]) -> bool {
-    messages.iter().any(|m| m.contains("\"django") && m.contains("could not be resolved"))
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[ignore = "requires a Docker daemon, basedpyright and OPENIDEA_DOCKER_TEST_DIR"]
-async fn compose_target_is_the_python_interpreter() {
-    let root = PathBuf::from(std::env::var("OPENIDEA_DOCKER_TEST_DIR").expect("OPENIDEA_DOCKER_TEST_DIR"));
-    let root = dunce::canonicalize(root).unwrap();
-    let files = [
-        ("compose.yaml", "services:\n  web:\n    build: .\n    volumes:\n      - .:/app\n    working_dir: /app\n"),
-        (
-            "Dockerfile",
-            "FROM python:3.12-slim\nCOPY requirements.txt /tmp/requirements.txt\n\
-             RUN pip install --no-cache-dir -r /tmp/requirements.txt\n",
-        ),
-        ("requirements.txt", "Django==5.1.3\n"),
-        (
-            "app/main.py",
-            "import django\nfrom django.http import HttpResponse\n\nprint(django.get_version(), HttpResponse)\n",
-        ),
-    ];
-    for (path, text) in files {
-        std::fs::create_dir_all(root.join(path).parent().unwrap()).unwrap();
-        std::fs::write(root.join(path), text).unwrap();
-    }
-    let main = root.join("app/main.py");
-    let state = tempfile::tempdir().unwrap();
-    let events: Events = Arc::default();
-    let host = host(state.path(), &events);
-    host.trust.decide(&root, true, false).unwrap();
-    host.open_project(WINDOW, &root).unwrap();
-    let set = |key: &str, value: serde_json::Value| {
-        ops::project::set_settings(
-            &host,
-            WINDOW,
-            ide_workspace::settings::SettingsScope::Project,
-            key,
-            &value.to_string(),
-        )
-        .unwrap();
-    };
-    set("runTargets", serde_json::json!([{ "kind": "compose", "id": "web", "name": "Compose web", "service": "web" }]));
-
-    // A local interpreter: Django is only in the image.
-    ops::doc::open(&host, WINDOW, main.clone()).await.unwrap();
-    let before = diagnostics(&events, &main, Duration::from_secs(120), unresolved).await;
-    eprintln!("local interpreter: {before:?}");
-
-    // The run target as the interpreter: a snapshot is taken in the background, then the
-    // server restarts with the copied site-packages as `extraPaths`.
-    set("languages.python.interpreter", serde_json::json!("target:web"));
-    let after = diagnostics(&events, &main, Duration::from_secs(900), |m| !unresolved(m)).await;
-    eprintln!("run target interpreter: {after:?}");
-    assert!(after.iter().all(|m| !m.contains("could not be resolved")), "{after:?}");
-
-    let info = ops::sdk::sdk_container_python(&host, WINDOW).unwrap().expect("a run target interpreter");
-    eprintln!("snapshot: version {:?}, image {:?}, folders {:?}", info.version, info.image, info.folders);
-    assert_eq!(info.name, "Compose web");
-    assert!(info.version.as_deref().is_some_and(|v| v.starts_with("3.12.")), "{info:?}");
-    assert!(info.packages.iter().any(|p| p.name == "Django" && p.version == "5.1.3"), "{:?}", info.packages);
-    let site = info.folders.iter().find(|f| f.0.ends_with("site-packages")).expect("site-packages copied");
-    assert!(site.0.join("django/__init__.py").is_file());
-    assert!(site.0.starts_with(state.path().join("data/container-python")), "{site:?}");
-    let servers = ops::lsp::lsp_servers(&host, WINDOW).unwrap();
-    eprintln!("servers: {:?}", servers.iter().map(|s| (&s.name, s.status)).collect::<Vec<_>>());
-
-    // Run: a Python configuration without its own target runs in the container.
-    let out = Arc::new(Mutex::new(String::new()));
-    let sink = out.clone();
-    let config = RunConfig {
-        id: "main".into(),
-        name: "main".into(),
-        kind: "python".into(),
-        command: "python3".into(),
-        args: vec!["app/main.py".into()],
-        cwd: None,
-        env: Default::default(),
-        detected: false,
-        is_test: false,
-        debug_adapter: None,
-        allow_parallel: false,
-        extras: Default::default(),
-    };
-    ops::run::start(
-        &host,
-        WINDOW,
-        config,
-        Arc::new(move |chunk| match chunk {
-            OutputChunk::Stdout { text } | OutputChunk::Stderr { text } | OutputChunk::System { text } => {
-                sink.lock().unwrap().push_str(&text)
-            }
-        }),
-    )
-    .await
-    .unwrap();
-    for _ in 0..1200 {
-        if out.lock().unwrap().contains("Process finished") {
-            break;
-        }
-        tokio::time::sleep(Duration::from_millis(100)).await;
-    }
-    let out = out.lock().unwrap().clone();
-    eprintln!("run output: {out}");
-    assert!(out.contains("5.1.3") && out.contains("exit code 0"), "{out}");
-
-    // Refresh takes a new snapshot of the same image; nothing is left running.
-    let refreshed = ops::sdk::sdk_container_python_refresh(&host, WINDOW).await.unwrap().unwrap();
-    assert_eq!(refreshed.image, info.image);
-    let probes = Command::new("docker")
-        .args(["ps", "--all", "--quiet", "--filter", "label=openidea.python-probe=true"])
-        .output()
-        .unwrap();
-    assert_eq!(String::from_utf8_lossy(&probes.stdout).trim(), "", "probe containers are removed");
-    Command::new("docker").args(["compose", "down", "--rmi", "local"]).current_dir(&root).status().unwrap();
-}

crates/ide-host/tests/light_edit.rs

@@ -179,73 +179,3 @@ async fn light_notebooks_open_without_interpreter_detection_or_execution() {
     assert!(!bin.join("python.probed").exists());
     host.shutdown().await;
 }
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn untitled_buffers_reach_the_disk_through_save_as() {
-    let tmp = tempfile::tempdir().unwrap();
-    let tmp_root = dunce::canonicalize(tmp.path()).unwrap();
-    let dir = tmp_root.join("notes");
-    let host = host(&tmp_root.join("app"));
-
-    // A window with no file (a welcome screen's File › New File): rooted at the
-    // home folder, no watcher yet, doc commands work.
-    let empty = host.open_light_empty("main").unwrap();
-    assert!(empty.light);
-    let untitled = ops::doc::open_untitled(&host, "main", None).await.unwrap();
-    assert_eq!(untitled.path, std::path::PathBuf::from("untitled:Untitled-1"));
-    assert_eq!(untitled.language.as_str(), "plaintext");
-    let version = ops::doc::edit(&host, "main", untitled.id, untitled.version, untitled_edit("# notes\n")).unwrap();
-    assert!(ops::doc::save(&host, "main", untitled.id).await.is_ok(), "saving nowhere is a no-op");
-    assert!(host.project("main").unwrap().documents.is_dirty(untitled.id).unwrap());
-
-    // Save As: the buffer lands on the disk and turns into a file document.
-    let target = dir.join("deep/notes.md");
-    let saved = ops::doc::save_as(&host, "main", untitled.id, target.clone()).await.unwrap();
-    assert_eq!(saved.path, target);
-    assert_eq!(saved.language.as_str(), "markdown");
-    assert!(!saved.dirty);
-    // The platform's default line separator applies to new buffers.
-    assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "# notes\n");
-    ops::doc::edit(&host, "main", untitled.id, version, untitled_edit("x\n")).unwrap();
-    ops::doc::save(&host, "main", untitled.id).await.unwrap();
-    assert_eq!(std::fs::read_to_string(&target).unwrap().replace("\r\n", "\n"), "x\n# notes\n");
-
-    // The saved file's folder is followed for external changes now.
-    host.shutdown().await;
-}
-
-fn untitled_edit(insert: &str) -> ChangeSet {
-    ChangeSet { changes: vec![TextChange { from: 0, to: 0, insert: insert.into() }] }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn untitled_buffers_follow_the_window_into_a_project() {
-    let tmp = tempfile::tempdir().unwrap();
-    let tmp_root = dunce::canonicalize(tmp.path()).unwrap();
-    let host = host(&tmp_root.join("app"));
-
-    // A LightEdit window with an edited untitled buffer (and a clean one).
-    host.open_light_empty("main").unwrap();
-    let draft = ops::doc::open_untitled(&host, "main", None).await.unwrap();
-    ops::doc::edit(&host, "main", draft.id, draft.version, untitled_edit("{\"draft\": true}")).unwrap();
-    let clean = ops::doc::open_untitled(&host, "main", None).await.unwrap();
-
-    // The window switches to a project: the buffers follow, contents and dirty flags kept.
-    let project_root = tmp_root.join("proj");
-    std::fs::create_dir_all(&project_root).unwrap();
-    let project = host.open_project("main", &project_root).unwrap();
-    assert!(!project.light);
-
-    let carried =
-        ops::doc::open_untitled(&host, "main", Some(draft.path.to_string_lossy().into_owned())).await.unwrap();
-    assert_eq!(carried.path, draft.path, "same key, fresh registry: a new doc id carries the content");
-    let snap = ops::doc::snapshot(&host, "main", carried.id).await.unwrap();
-    assert_eq!(snap.text, "{\"draft\": true}");
-    assert!(host.project("main").unwrap().documents.is_dirty(carried.id).unwrap());
-    assert_eq!(snap.language.as_str(), "plaintext");
-
-    let clean_carried =
-        ops::doc::open_untitled(&host, "main", Some(clean.path.to_string_lossy().into_owned())).await.unwrap();
-    assert!(!host.project("main").unwrap().documents.is_dirty(clean_carried.id).unwrap());
-    host.shutdown().await;
-}

crates/ide-index/src/store.rs

@@ -599,28 +599,6 @@ impl Store {
         txn.commit().map_err(err)
     }
 
-    /// [`Self::apply`] for records already serialized (by the parse pool).
-    pub(crate) fn apply_raw(&self, puts: &[(String, Vec<u8>)], deletes: &[String], durable: bool) -> Result<()> {
-        self.ensure_db()?;
-        let db = self.db.read();
-        let mut txn = db.as_ref().expect("ensured").begin_write().map_err(err)?;
-        if !durable {
-            txn.set_durability(Durability::None).map_err(err)?;
-        }
-        {
-            let mut table = txn.open_table(FILES).map_err(err)?;
-            for (rel, bytes) in puts {
-                table.insert(rel.as_str(), bytes.as_slice()).map_err(err)?;
-            }
-            for rel in deletes {
-                table.remove(rel.as_str()).map_err(err)?;
-            }
-        }
-        // Any file change makes the columnar start-up snapshot stale.
-        let _ = std::fs::remove_file(&self.snapshot);
-        txn.commit().map_err(err)
-    }
-
     /// Reclaims free pages in the database file; `true` if anything was compacted.
     pub(crate) fn compact(&self) -> Result<bool> {
         self.ensure_db()?;

crates/ide-index/src/worker.rs

@@ -17,8 +17,6 @@ use std::time::{Duration, Instant, SystemTime};
 /// Files larger than this are listed but not parsed for symbols.
 pub const MAX_SYMBOL_FILE: u64 = 2 * 1024 * 1024;
 const CHUNK: usize = 512;
-/// Insert/persist batch of the initial scan's streaming pass.
-const SCAN_BATCH: usize = 2048;
 const PROGRESS_EVERY: Duration = Duration::from_millis(250);
 #[cfg(not(test))]
 const SNAPSHOT_DELAY: Duration = Duration::from_secs(2);
@@ -438,13 +436,10 @@ impl Shared {
         });
 
         let filter = self.filter();
-        let walk_started = Instant::now();
         let found = prewalked.unwrap_or_else(|| self.walk_roots(dirs));
-        let walk = walk_started.elapsed();
         if self.is_cancelled() {
             return self.end_scan(task);
         }
-        let classify_started = Instant::now();
         let seen: HashSet<&Path> = found.iter().map(|f| f.path.as_path()).collect();
         let (todo, stale): (Vec<&Found>, Vec<PathBuf>) = {
             let d = self.data.read();
@@ -457,7 +452,6 @@ impl Shared {
                 .collect();
             (todo, stale)
         };
-        let classify = classify_started.elapsed();
         if !stale.is_empty() {
             let mut d = self.data.write();
             for path in &stale {
@@ -468,76 +462,33 @@ impl Shared {
         self.persist(&[], &stale, false);
 
         let total = todo.len();
-        let mut laps = ChunkLaps::default();
-        {
-            // One streaming parallel pass: parse on the rayon pool without
-            // per-chunk joins (a straggler file at a join's tail idles every
-            // other core), while parsed files flow to this thread to be
-            // inserted and persisted in batches. `filter` moves into the
-            // parse thread; this thread keeps the outer one.
-            let filter = self.filter();
-            // Bounded: when inserting and persisting fall behind, the parse waits instead
-            // of holding the whole project's records (and their bytes) in the channel.
-            let (tx, rx) = std::sync::mpsc::sync_channel::<ParsedFile>(2 * SCAN_BATCH);
-            let cancelled = &self.cancelled;
-            let mut done = 0usize;
-            let mut last_progress = Instant::now();
-            let pass_started = Instant::now();
-            std::thread::scope(|scope| -> () {
-                scope.spawn(move || {
-                    todo.par_iter().for_each(|f| {
-                        if cancelled.load(Ordering::Relaxed) {
-                            return;
-                        }
-                        let Some(out) = self.parse_found(f, &filter, false) else { return };
-                        let _ = tx.send(out);
-                    });
-                    // `tx` drops here: the consumer's loop ends with the channel.
+        let mut done = 0usize;
+        let mut last_progress = Instant::now();
+        for chunk in todo.chunks(CHUNK) {
+            if self.is_cancelled() {
+                return self.end_scan(task);
+            }
+            self.index_files(chunk.iter().copied(), false);
+            done += chunk.len();
+            if last_progress.elapsed() >= PROGRESS_EVERY {
+                last_progress = Instant::now();
+                self.sink.emit(IdeEvent::Task {
+                    id: task,
+                    title: "Indexing".into(),
+                    message: Some(format!("{done} / {total} files")),
+                    fraction: Some(done as f32 / total.max(1) as f32),
+                    done: false,
+                    cancellable: false,
                 });
-                let mut batch: Vec<ParsedFile> = Vec::with_capacity(SCAN_BATCH);
-                for out in rx {
-                    if self.is_cancelled() {
-                        break;
-                    }
-                    batch.push(out);
-                    if batch.len() < SCAN_BATCH {
-                        continue;
-                    }
-                    done += batch.len();
-                    laps.add(self.publish(batch.drain(..)));
-                    if last_progress.elapsed() >= PROGRESS_EVERY {
-                        last_progress = Instant::now();
-                        self.sink.emit(IdeEvent::Task {
-                            id: task,
-                            title: "Indexing".into(),
-                            message: Some(format!("{done} / {total} files")),
-                            fraction: Some(done as f32 / total.max(1) as f32),
-                            done: false,
-                            cancellable: false,
-                        });
-                    }
-                }
-                if !batch.is_empty() && !self.is_cancelled() {
-                    done += batch.len();
-                    laps.add(self.publish(batch.drain(..)));
-                }
-            });
-            laps.extract = pass_started.elapsed();
+            }
         }
-        if self.is_cancelled() {
-            return self.end_scan(task);
-        }
-        let durable_started = Instant::now();
         self.persist(&[], &[], true);
-        let durable = durable_started.elapsed();
         if let Some(store) = &self.store {
             let recent: Vec<String> = self.recent.lock().iter().filter_map(|p| filter.store_key(p)).collect();
             let d = self.data.read();
-            let snapshot_started = Instant::now();
             if let Err(e) = store.save_snapshot(&d, &filter, guard) {
                 tracing::warn!("index snapshot: {e}");
             }
-            tracing::info!("index snapshot: written in {:?}", snapshot_started.elapsed());
             if let Err(e) = store.save_recent_file(&recent) {
                 tracing::warn!("index recent snapshot: {e}");
             }
@@ -555,85 +506,54 @@ impl Shared {
         self.emit_state();
         let d = self.data.read();
         tracing::info!(
-            "indexed {} files ({} parsed, {} symbols) in {:?} (walk {:?}, classify {:?}, extract {:?}, insert {:?}, persist {:?}, durable {:?})",
+            "indexed {} files ({} parsed, {} symbols) in {:?}",
             d.file_count,
             total,
             d.symbol_count,
-            started.elapsed(),
-            walk,
-            classify,
-            laps.extract,
-            laps.insert,
-            laps.persist,
-            durable
+            started.elapsed()
         );
     }
 
     /// Extracts records in parallel, then publishes them to memory and disk.
     /// `force` re-parses files whose content is unchanged (their language changed).
-    fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) -> ChunkLaps {
-        let mut laps = ChunkLaps::default();
+    fn index_files<'a>(&self, files: impl Iterator<Item = &'a Found>, force: bool) {
         let files: Vec<&Found> = files.collect();
         let filter = self.filter();
-        let started = Instant::now();
-        let extracted: Vec<ParsedFile> = files.par_iter().filter_map(|f| self.parse_found(f, &filter, force)).collect();
-        laps.extract = started.elapsed();
+        let extracted: Vec<(String, FileRecord, PathBuf)> = files
+            .par_iter()
+            .filter_map(|f| {
+                if self.is_cancelled() {
+                    return None;
+                }
+                let rel = filter.rel(&f.path)?;
+                let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
+                match self.extract(f, prev_hash) {
+                    Extracted::Unchanged => {
+                        // Same content, new mtime: keep the symbols, refresh metadata.
+                        let mut rec = self.data.read().record_of(&f.path)?;
+                        rec.mtime = f.mtime;
+                        rec.size = f.size;
+                        rec.ignored = f.ignored;
+                        Some((rel, rec, f.path.clone()))
+                    }
+                    Extracted::New(rec) => Some((rel, rec, f.path.clone())),
+                }
+            })
+            .collect();
         if extracted.is_empty() {
-            return laps;
-        }
-        laps.add(self.publish(extracted.into_iter()));
-        laps
-    }
-
-    /// Reads and parses one file (parallel-safe), serializing its record for
-    /// the cache alongside the parse. `None` when the file is outside the
-    /// scope or the scan was cancelled.
-    fn parse_found(&self, f: &Found, filter: &std::sync::Arc<PathFilter>, force: bool) -> Option<ParsedFile> {
-        if self.is_cancelled() {
-            return None;
-        }
-        let rel = filter.rel(&f.path)?;
-        let prev_hash = if force { None } else { self.data.read().get(&f.path).map(|e| e.hash) };
-        let rec = match self.extract(f, prev_hash) {
-            Extracted::Unchanged => {
-                // Same content, new mtime: keep the symbols, refresh metadata.
-                let mut rec = self.data.read().record_of(&f.path)?;
-                rec.mtime = f.mtime;
-                rec.size = f.size;
-                rec.ignored = f.ignored;
-                rec
-            }
-            Extracted::New(rec) => rec,
-        };
-        let key = filter.store_key(&f.path);
-        let bytes = postcard::to_allocvec(&rec).ok();
-        Some(ParsedFile { rel, rec, key, bytes, path: f.path.clone() })
-    }
-
-    /// Inserts a parsed batch into the in-memory index and persists the records.
-    fn publish(&self, batch: impl Iterator<Item = ParsedFile>) -> ChunkLaps {
-        let mut laps = ChunkLaps::default();
-        let started = Instant::now();
-        let mut entries: Vec<(FileEntry, Vec<StoredSymbol>)> = Vec::new();
-        let mut puts: Vec<(String, Vec<u8>)> = Vec::new();
-        for out in batch {
-            let ParsedFile { rel, rec, key, bytes, path } = out;
-            if let (Some(key), Some(bytes)) = (key, bytes) {
-                puts.push((key, bytes));
-            }
-            entries.push(FileEntry::new(path, rel, rec));
+            return;
         }
+        let puts: Vec<(String, FileRecord)> =
+            extracted.iter().filter_map(|(_, rec, path)| Some((filter.store_key(path)?, rec.clone()))).collect();
         {
+            let entries: Vec<(FileEntry, Vec<StoredSymbol>)> =
+                extracted.into_iter().map(|(rel, rec, path)| FileEntry::new(path, rel, rec)).collect();
             let mut d = self.data.write();
             for (e, symbols) in entries {
                 d.insert(e, symbols);
             }
         }
-        laps.insert = started.elapsed();
-        let started = Instant::now();
-        self.persist_raw(&puts, &[], false);
-        laps.persist = started.elapsed();
-        laps
+        self.persist(&puts, &[], false);
     }
 
     fn schedule_snapshot(&self) {
@@ -674,15 +594,6 @@ impl Shared {
         }
     }
 
-    /// [`Self::persist`] for records already serialized by the parse pool.
-    fn persist_raw(&self, puts: &[(String, Vec<u8>)], deletes: &[String], durable: bool) {
-        if let Some(store) = &self.store
-            && let Err(e) = store.apply_raw(puts, deletes, durable)
-        {
-            tracing::warn!("index cache write failed: {e}");
-        }
-    }
-
     fn extract(&self, f: &Found, prev_hash: Option<[u8; 32]>) -> Extracted {
         let mut rec = FileRecord { mtime: f.mtime, size: f.size, ignored: f.ignored, ..Default::default() };
         if f.ignored || f.size > MAX_SYMBOL_FILE {
@@ -882,33 +793,6 @@ enum Extracted {
     New(FileRecord),
 }
 
-/// Wall-time laps of one `index_files` chunk, accumulated by the scan.
-#[derive(Default)]
-struct ChunkLaps {
-    extract: Duration,
-    insert: Duration,
-    persist: Duration,
-}
-
-impl ChunkLaps {
-    fn add(&mut self, other: ChunkLaps) {
-        self.extract += other.extract;
-        self.insert += other.insert;
-        self.persist += other.persist;
-    }
-}
-
-/// One file parsed off the index thread: its record ready to publish, already
-/// serialized for the cache (in parallel with the parse).
-struct ParsedFile {
-    rel: String,
-    rec: FileRecord,
-    /// Cache key and postcard bytes; `None` when outside the persisted root.
-    key: Option<String>,
-    bytes: Option<Vec<u8>>,
-    path: PathBuf,
-}
-
 #[cfg(test)]
 mod tests {
     use crate::data::safe_rel;

crates/ide-jsonrpc/src/output.rs

@@ -80,47 +80,18 @@ pub fn trim_line_end(line: &[u8]) -> &[u8] {
     &line[..end]
 }
 
-/// The longest line kept in full; the rest of a longer one is dropped (a server that writes a
-/// progress bar with `\r` only, or never a newline, must not grow memory without bound).
-pub const MAX_LINE: usize = 8 * 1024;
-
 /// Reads `stream` to its end, calling `on_line` with each line decoded by [`decode`].
 /// Unlike `AsyncBufReadExt::lines`, a line that is not UTF-8 does not end the stream.
-/// A line longer than [`MAX_LINE`] bytes is cut there and ends with `…`.
 pub async fn read_lines<R: AsyncRead + Unpin>(stream: R, mut on_line: impl FnMut(String)) {
     let mut reader = BufReader::new(stream);
     let mut line = Vec::new();
-    let mut cut = false;
     loop {
-        let (used, complete) = match reader.fill_buf().await {
-            Ok([]) | Err(_) => break,
-            Ok(buf) => {
-                let end = buf.iter().position(|&b| b == b'\n');
-                let piece = &buf[..end.unwrap_or(buf.len())];
-                let room = MAX_LINE.saturating_sub(line.len());
-                cut |= piece.len() > room;
-                line.extend_from_slice(&piece[..piece.len().min(room)]);
-                (end.map_or(buf.len(), |i| i + 1), end.is_some())
-            }
-        };
-        reader.consume(used);
-        if complete {
-            emit(&mut line, &mut cut, &mut on_line);
+        line.clear();
+        match reader.read_until(b'\n', &mut line).await {
+            Ok(0) | Err(_) => break,
+            Ok(_) => on_line(decode(trim_line_end(&line))),
         }
     }
-    if !line.is_empty() || cut {
-        emit(&mut line, &mut cut, &mut on_line);
-    }
-}
-
-fn emit(line: &mut Vec<u8>, cut: &mut bool, on_line: &mut impl FnMut(String)) {
-    let mut text = decode(trim_line_end(line));
-    if *cut {
-        text.push('…');
-    }
-    line.clear();
-    *cut = false;
-    on_line(text);
 }
 
 #[cfg(test)]
@@ -162,19 +133,4 @@ mod tests {
         assert!(lines[1].ends_with(" broken"));
         assert_eq!(lines[2], "last");
     }
-
-    #[tokio::test]
-    async fn a_very_long_line_is_cut_and_the_next_one_is_intact() {
-        let mut input = vec![b'x'; MAX_LINE * 10 + 3];
-        input.extend_from_slice(b"\nnext\r\n");
-        // No newline at all after this one: still bounded.
-        input.extend_from_slice(&vec![b'y'; MAX_LINE * 3]);
-        let mut lines = Vec::new();
-        read_lines(&input[..], |l| lines.push(l)).await;
-        assert_eq!(lines.len(), 3);
-        assert_eq!(lines[0].chars().count(), MAX_LINE + 1);
-        assert!(lines[0].ends_with('…') && lines[0].starts_with("xxx"));
-        assert_eq!(lines[1], "next");
-        assert_eq!(lines[2].chars().count(), MAX_LINE + 1);
-    }
 }

crates/ide-language/queries/bash/highlights.scm

@@ -1,56 +0,0 @@
-; Shell scripts: drawn over the stream mode, which knows only fixed word lists.
-; The last matching pattern wins.
-
-[
-  (string)
-  (raw_string)
-  (ansi_c_string)
-  (translated_string)
-  (heredoc_body)
-  (heredoc_start)
-] @string
-
-[
-  (command_substitution)
-  (process_substitution)
-  (expansion)
-  (simple_expansion)
-] @embedded
-
-(comment) @comment
-
-[
-  "case"
-  "do"
-  "done"
-  "elif"
-  "else"
-  "esac"
-  "fi"
-  "for"
-  "function"
-  "if"
-  "in"
-  "select"
-  "then"
-  "until"
-  "while"
-  "declare"
-  "export"
-  "local"
-  "readonly"
-  "typeset"
-  "unset"
-  "unsetenv"
-] @keyword
-
-(command_name) @function.command
-(function_definition name: (word) @function.definition)
-
-(variable_name) @variable
-(special_variable_name) @variable
-
-[
-  (number)
-  (file_descriptor)
-] @number

crates/ide-language/src/lib.rs

@@ -28,7 +28,6 @@ pub use syntax::{
     VueComponentImport, VueRefAccess, VueRefElement, WebReference, WebReferenceKind, merge_visibility,
     set_external_syntax, shift_pos, shift_range,
 };
-pub use syntax::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
 
 /// Parsed form of `languages/<id>.toml`. Backend-only; the UI gets [`LanguageInfo`].
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -199,10 +198,6 @@ pub struct LanguageServerConfig {
     /// it parses a document.
     #[serde(default)]
     pub resync_on_configuration: bool,
-    /// Set by the settings hook: what the user sees as the server when another program serves
-    /// in its place (TypeScript 7's own `tsc --lsp` for vtsls).
-    #[serde(skip)]
-    pub display_name: Option<String>,
     /// Set on plugin languages: start exactly this approved program.
     #[serde(skip)]
     pub pinned: Option<ProgramPin>,

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

@@ -314,7 +314,7 @@ pub(crate) static SPECS: &[Spec] = &[
         name: "bash",
         language: tree_sitter_bash::LANGUAGE,
         outline: outline!("bash"),
-        highlights: Some(Highlights { query: highlights!("bash"), first_wins: false }),
+        highlights: None,
         fold_nodes: &["do_group", "if_statement", "case_statement", "heredoc_body"],
         fold_bodies: NONE,
         imports: NONE,

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

@@ -43,13 +43,11 @@ pub enum SyntaxHighlightKind {
     Operator,
     Punctuation,
     Parameter,
-    /// A shell command name (`pgrep`, a script's own function).
-    Command,
 }
 
 impl SyntaxHighlightKind {
     /// Every kind, in `as u32` order: the legend for [`SyntaxHighlights::data`].
-    pub const ALL: [Self; 26] = [
+    pub const ALL: [Self; 25] = [
         Self::Keyword,
         Self::String,
         Self::StringSpecial,
@@ -75,7 +73,6 @@ impl SyntaxHighlightKind {
         Self::Operator,
         Self::Punctuation,
         Self::Parameter,
-        Self::Command,
     ];
 
     /// The kebab-case name plugins use (`doc-comment`, `function-call`, …).
@@ -156,7 +153,6 @@ const CAPTURES: &[(&str, Paint)] = {
         ("function.builtin", Kind(K::Builtin)),
         ("function.macro", Kind(K::Macro)),
         ("function.definition", Kind(K::Function)),
-        ("function.command", Kind(K::Command)),
         ("function", Kind(K::FunctionCall)),
         ("method", Kind(K::FunctionCall)),
         ("constructor", Kind(K::Type)),
@@ -412,30 +408,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn shell_scripts_highlight_declarations_commands_and_function_names() {
-        use SyntaxHighlightKind as K;
-        let src = "this::check_process() {\n  local process\n  process=\"${1:?}\"\n  if [ -x \"$(command -v pgrep)\" ]; then\n    if pgrep -f -q \"${process}\"; then\n      functions::exit 1 \"'${process}' is running\"\n    fi\n  fi\n}\n# done\n";
-        let got = spans("shellscript", src);
-        for (text, expected) in [
-            ("this::check_process", K::Function),
-            ("local", K::Keyword),
-            ("if", K::Keyword),
-            ("command", K::Command),
-            ("pgrep", K::Command),
-            ("functions::exit", K::Command),
-            ("process", K::Variable),
-            ("# done", K::Comment),
-        ] {
-            assert!(
-                got.iter().any(|(word, kind)| word == text && *kind == expected),
-                "missing {text}: {expected:?} in {got:?}"
-            );
-        }
-        // An expansion inside a string is not string-coloured.
-        assert!(!got.iter().any(|(word, kind)| word.contains("${process}") && *kind == K::String), "{got:?}");
-    }
-
     #[test]
     fn non_kotlin_parameters_keep_variable_highlighting() {
         for (lang, src) in [

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

@@ -43,7 +43,7 @@ fn extract(tree: &Tree, text: &str) -> Vec<ClassBases> {
         // Selection-range start of the class: its name identifier (`class Foo`
         // -> `Foo`), matching `outline.rs` and the gutter marker candidates.
         let range = idx.range(name_node.start_byte(), name_node.end_byte());
-        let bases = class_base_names(node, text);
+        let bases = node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default();
         out.push(ClassBases { name, line: range.start.line, col: range.start.col, bases });
     });
     out
@@ -67,11 +67,6 @@ fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
     }
 }
 
-/// The bare base names a `class_definition` node writes (keyword arguments left out).
-pub(super) fn class_base_names(node: Node, text: &str) -> Vec<String> {
-    node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
-}
-
 fn base_names(args: Node, text: &str) -> Vec<String> {
     let mut out = Vec::new();
     let mut cursor = args.walk();

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

@@ -10,7 +10,6 @@ mod inheritance;
 pub(crate) mod lines;
 mod literals;
 mod outline;
-mod python_facts;
 mod rst;
 mod selection;
 mod sfc;
@@ -28,7 +27,6 @@ pub use inheritance::ClassBases;
 pub use lines::{shift_pos, shift_range};
 pub use literals::{Literal, LiteralKind, SpellingKind, SpellingRegion};
 pub use outline::merge_visibility;
-pub use python_facts::{MethodBody, PythonClassFacts, PythonFacts, PythonMethodFacts};
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::sync::OnceLock;

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

@@ -1,438 +0,0 @@
-//! Python class facts the inheritance inspections need: base names as written, parameter
-//! lists, decorator semantics and what a method body does. They come from the syntax tree in
-//! one pass, so the frontend reasons about the inheritance graph without parsing source text.
-//!
-//! Deliberately small: a fact exists here only when a check can decide it without guessing.
-
-use super::lines::LineIndex;
-use crate::{LanguageId, Syntax};
-use serde::{Deserialize, Serialize};
-use specta::Type;
-use tree_sitter::{Node, Tree};
-
-/// One Python module's classes, in source order.
-#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PythonFacts {
-    pub classes: Vec<PythonClassFacts>,
-}
-
-/// A class definition and the methods it declares.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PythonClassFacts {
-    pub name: String,
-    /// The class name identifier (selection range).
-    pub selection: crate::Range,
-    /// Base names as written, a qualified name reduced to its last segment.
-    pub bases: Vec<String>,
-    pub methods: Vec<PythonMethodFacts>,
-}
-
-/// A method definition the inspections can reason about.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase")]
-pub struct PythonMethodFacts {
-    pub name: String,
-    /// The method name identifier (selection range).
-    pub selection: crate::Range,
-    /// Parameter names in order; `None` for a form whose forwarding cannot be compared
-    /// (`*args`, `**kwargs`, keyword-only, positional-only).
-    pub params: Option<Vec<String>>,
-    /// Decorated with `abstractmethod` (`abc.abstractmethod` included).
-    pub abstract_method: bool,
-    /// Decorated with `override` from `typing` / `typing_extensions`.
-    pub override_decorated: bool,
-    pub body: MethodBody,
-}
-
-/// What a method body does, for the shapes a check can decide without guessing.
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
-#[serde(rename_all = "camelCase", tag = "kind")]
-pub enum MethodBody {
-    /// `pass`, `...`, a docstring, or nothing at all.
-    Empty,
-    /// Exactly one `super().name(args)` call, optionally `return`ed.
-    SuperCall { returns: bool, target: String, args: Vec<String> },
-    /// Anything else.
-    Other,
-}
-
-impl Syntax {
-    /// The classes of a Python `text` with the facts the inheritance checks need.
-    /// Every other language returns an empty result.
-    pub fn python_facts(&self, lang: &LanguageId, text: &str) -> PythonFacts {
-        self.analyze(lang, text, |g, tree, text| (g.spec.name == "python").then(|| extract(tree, text)))
-            .unwrap_or_default()
-    }
-}
-
-fn extract(tree: &Tree, text: &str) -> PythonFacts {
-    let idx = LineIndex::new(text);
-    let imports = ImportBindings::collect(tree, text);
-    let mut classes = Vec::new();
-    let mut cursor = tree.walk();
-    visit(&mut cursor, &mut |node| {
-        if node.kind() != "class_definition" {
-            return;
-        }
-        let Some(name_node) = node.child_by_field_name("name") else { return };
-        let name = text_of(name_node, text);
-        if name.is_empty() {
-            return;
-        }
-        classes.push(PythonClassFacts {
-            name,
-            selection: idx.range(name_node.start_byte(), name_node.end_byte()),
-            bases: super::inheritance::class_base_names(node, text),
-            methods: methods_of(node, text, &idx, &imports),
-        });
-    });
-    PythonFacts { classes }
-}
-
-/// The methods declared directly in `class`.
-fn methods_of(class: Node, text: &str, idx: &LineIndex, imports: &ImportBindings) -> Vec<PythonMethodFacts> {
-    let Some(body) = class.child_by_field_name("body") else { return Vec::new() };
-    let mut out = Vec::new();
-    let mut cursor = body.walk();
-    for member in body.named_children(&mut cursor) {
-        // A decorated method is a `decorated_definition` wrapping the `function_definition`.
-        let method = match member.kind() {
-            "function_definition" => member,
-            "decorated_definition" => match member.child_by_field_name("definition") {
-                Some(inner) if inner.kind() == "function_definition" => inner,
-                _ => continue,
-            },
-            _ => continue,
-        };
-        let Some(name_node) = method.child_by_field_name("name") else { continue };
-        let name = text_of(name_node, text);
-        if name.is_empty() {
-            continue;
-        }
-        let decorators = decorators_of(method, text);
-        out.push(PythonMethodFacts {
-            name,
-            selection: idx.range(name_node.start_byte(), name_node.end_byte()),
-            params: parameters_of(method, text),
-            abstract_method: decorators.iter().any(|d| last_segment(d) == "abstractmethod"),
-            override_decorated: decorators.iter().any(|d| imports.is_typing_override(d)),
-            body: body_of(method, text),
-        });
-    }
-    out
-}
-
-/// The parameter names of a `function_definition`, or `None` when the signature contains a
-/// form whose forwarding cannot be compared without guessing.
-fn parameters_of(function: Node, text: &str) -> Option<Vec<String>> {
-    let params = function.child_by_field_name("parameters")?;
-    let mut names = Vec::new();
-    let mut cursor = params.walk();
-    for param in params.named_children(&mut cursor) {
-        let name = match param.kind() {
-            "identifier" => text_of(param, text),
-            "typed_parameter" | "default_parameter" | "typed_default_parameter" => {
-                let named = param
-                    .child_by_field_name("name")
-                    .or_else(|| param.child_by_field_name("pattern"))
-                    .or_else(|| param.named_child(0))?;
-                if named.kind() != "identifier" {
-                    return None;
-                }
-                text_of(named, text)
-            }
-            // `*args`, `**kwargs`, `/`, `*`: the call form cannot be compared textually.
-            _ => return None,
-        };
-        if !name.is_empty() {
-            names.push(name);
-        }
-    }
-    Some(names)
-}
-
-/// A `function_definition`'s body, classified into the shapes a check can decide.
-fn body_of(function: Node, text: &str) -> MethodBody {
-    let Some(body) = function.child_by_field_name("body") else { return MethodBody::Empty };
-    // A docstring is not a statement the checks care about.
-    let statements: Vec<Node> = statements_of(body).into_iter().filter(|s| !is_string(*s)).collect();
-    if statements.is_empty() || statements.iter().all(|s| is_noop(*s)) {
-        return MethodBody::Empty;
-    }
-    let [only] = statements.as_slice() else { return MethodBody::Other };
-    let call = match only.kind() {
-        "expression_statement" => (only.named_child(0), false),
-        "return_statement" => (only.named_child(0), true),
-        _ => (None, false),
-    };
-    match call {
-        (Some(call), returns) if is_super_call(call, text) => {
-            let target = call
-                .child_by_field_name("function")
-                .and_then(|f| f.child_by_field_name("attribute"))
-                .map(|a| text_of(a, text))
-                .unwrap_or_default();
-            let args = call
-                .child_by_field_name("arguments")
-                .map(|args| {
-                    let mut cursor = args.walk();
-                    args.named_children(&mut cursor).map(|a| text_of(a, text)).collect()
-                })
-                .unwrap_or_default();
-            MethodBody::SuperCall { returns, target, args }
-        }
-        _ => MethodBody::Other,
-    }
-}
-
-/// Whether `node` is a `super().name(...)` call.
-fn is_super_call(node: Node, text: &str) -> bool {
-    if node.kind() != "call" {
-        return false;
-    }
-    let Some(function) = node.child_by_field_name("function") else { return false };
-    if function.kind() != "attribute" {
-        return false;
-    }
-    function.child_by_field_name("object").is_some_and(|object| {
-        object.kind() == "call"
-            && object
-                .child_by_field_name("function")
-                .is_some_and(|f| f.kind() == "identifier" && text_of(f, text) == "super")
-    })
-}
-
-/// Whether `statement` is `pass` or a bare `...`.
-fn is_noop(statement: Node) -> bool {
-    match statement.kind() {
-        "pass_statement" => true,
-        "expression_statement" => statement.named_child(0).is_some_and(|child| child.kind() == "ellipsis"),
-        _ => false,
-    }
-}
-
-/// A string expression statement: a docstring.
-fn is_string(statement: Node) -> bool {
-    statement.kind() == "expression_statement" && statement.named_child(0).is_some_and(|child| child.kind() == "string")
-}
-
-/// The statements of a `block`, comments excluded.
-fn statements_of(block: Node) -> Vec<Node> {
-    let mut cursor = block.walk();
-    block.named_children(&mut cursor).filter(|child| child.kind() != "comment").collect()
-}
-
-/// The decorators written on a definition, without the `@` or the call arguments.
-fn decorators_of(definition: Node, text: &str) -> Vec<String> {
-    let Some(parent) = definition.parent() else { return Vec::new() };
-    if parent.kind() != "decorated_definition" {
-        return Vec::new();
-    }
-    let mut out = Vec::new();
-    let mut cursor = parent.walk();
-    for decorator in parent.named_children(&mut cursor) {
-        if decorator.kind() != "decorator" {
-            continue;
-        }
-        let Some(inner) = decorator.named_child(0) else { continue };
-        let target =
-            if inner.kind() == "call" { inner.child_by_field_name("function").unwrap_or(inner) } else { inner };
-        let name = text_of(target, text).trim().to_owned();
-        if !name.is_empty() {
-            out.push(name);
-        }
-    }
-    out
-}
-
-/// The last segment of a dotted name (`typing.override` -> `override`).
-fn last_segment(name: &str) -> &str {
-    name.rsplit('.').next().unwrap_or(name)
-}
-
-fn text_of(node: Node, text: &str) -> String {
-    text.get(node.byte_range()).unwrap_or_default().to_owned()
-}
-
-/// The module-level `from ... import ...` bindings, so `override` can be told apart from a
-/// same-named decorator of another library.
-struct ImportBindings {
-    /// (local name, module, exported name)
-    bindings: Vec<(String, String, String)>,
-}
-
-impl ImportBindings {
-    fn collect(tree: &Tree, text: &str) -> Self {
-        let mut bindings = Vec::new();
-        let mut cursor = tree.walk();
-        visit(&mut cursor, &mut |node| {
-            if node.kind() != "import_from_statement" {
-                return;
-            }
-            let Some(module) = node.child_by_field_name("module_name") else { return };
-            let module = text_of(module, text);
-            let mut names = node.walk();
-            for name in node.children_by_field_name("name", &mut names) {
-                let (local, exported) = match name.kind() {
-                    "aliased_import" => (
-                        name.child_by_field_name("alias").map(|n| text_of(n, text)),
-                        name.child_by_field_name("name").map(|n| text_of(n, text)),
-                    ),
-                    _ => {
-                        let written = text_of(name, text);
-                        (Some(written.clone()), Some(written))
-                    }
-                };
-                if let (Some(local), Some(exported)) = (local, exported) {
-                    bindings.push((local, module.clone(), exported));
-                }
-            }
-        });
-        Self { bindings }
-    }
-
-    /// Whether `decorator` names `override` from `typing` / `typing_extensions`.
-    fn is_typing_override(&self, decorator: &str) -> bool {
-        const MODULES: [&str; 2] = ["typing", "typing_extensions"];
-        let segments: Vec<&str> = decorator.split('.').filter(|s| !s.is_empty()).collect();
-        match segments.as_slice() {
-            // `@typing.override`, or `@t.override` after `import typing as t`.
-            [prefix, "override"] => {
-                MODULES.contains(prefix)
-                    || self
-                        .bindings
-                        .iter()
-                        .find(|(local, _, _)| local == prefix)
-                        .is_some_and(|(_, module, _)| MODULES.contains(&module.as_str()))
-            }
-            // `@override`, or `@ov` after `from typing import override as ov`.
-            [local] => match self.bindings.iter().find(|(bound, _, _)| bound == local) {
-                Some((_, module, exported)) => exported == "override" && MODULES.contains(&module.as_str()),
-                // Nothing contradicts a bare `@override`: the usual `from typing import *`.
-                None => *local == "override",
-            },
-            _ => false,
-        }
-    }
-}
-
-/// Depth-first pre-order traversal of all descendants of `cursor`'s node.
-fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
-    loop {
-        f(cursor.node());
-        if cursor.goto_first_child() {
-            continue;
-        }
-        loop {
-            if cursor.goto_next_sibling() {
-                break;
-            }
-            if !cursor.goto_parent() {
-                return;
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    static SYNTAX: std::sync::OnceLock<Syntax> = std::sync::OnceLock::new();
-
-    fn facts(src: &str) -> PythonFacts {
-        SYNTAX.get_or_init(Syntax::new).python_facts(&LanguageId::new("python"), src)
-    }
-
-    fn method<'a>(facts: &'a PythonFacts, class: &str, method: &str) -> &'a PythonMethodFacts {
-        facts
-            .classes
-            .iter()
-            .find(|c| c.name == class)
-            .and_then(|c| c.methods.iter().find(|m| m.name == method))
-            .expect("method not found")
-    }
-
-    #[test]
-    fn classes_carry_bases_and_methods() {
-        let f = facts(
-            "class Base(ABC):\n    pass\n\nclass Child(Base, pkg.Mixin):\n    def run(self, x=1):\n        pass\n",
-        );
-        assert_eq!(f.classes.len(), 2);
-        assert_eq!(f.classes[0].name, "Base");
-        assert_eq!(f.classes[0].bases, ["ABC"]);
-        assert_eq!(f.classes[1].bases, ["Base", "Mixin"]);
-        assert_eq!(f.classes[1].methods.len(), 1);
-        assert_eq!(f.classes[1].selection.start.line, 3);
-        assert_eq!(f.classes[1].selection.start.col, 6);
-    }
-
-    #[test]
-    fn parameters_are_names_in_order_and_none_for_splats() {
-        let f = facts(
-            "class C:\n    def a(self, x: int, y=2):\n        pass\n\n    def b(self, *args):\n        pass\n\n    def c(self, *, x):\n        pass\n",
-        );
-        assert_eq!(
-            method(&f, "C", "a").params.as_deref(),
-            Some(["self".to_string(), "x".to_string(), "y".to_string()].as_slice())
-        );
-        assert_eq!(method(&f, "C", "b").params, None);
-        assert_eq!(method(&f, "C", "c").params, None);
-    }
-
-    #[test]
-    fn body_shapes_are_classified() {
-        let f = facts(
-            "class C:\n    def noop(self):\n        pass\n\n    def dots(self):\n        ...\n\n    def doc(self):\n        \"\"\"text\"\"\"\n\n    def forward(self, x):\n        return super().run(x)\n\n    def call(self):\n        super().run()\n\n    def other(self):\n        return 1\n",
-        );
-        assert_eq!(method(&f, "C", "noop").body, MethodBody::Empty);
-        assert_eq!(method(&f, "C", "dots").body, MethodBody::Empty);
-        assert_eq!(method(&f, "C", "doc").body, MethodBody::Empty);
-        assert_eq!(
-            method(&f, "C", "forward").body,
-            MethodBody::SuperCall { returns: true, target: "run".into(), args: vec!["x".into()] }
-        );
-        assert_eq!(
-            method(&f, "C", "call").body,
-            MethodBody::SuperCall { returns: false, target: "run".into(), args: vec![] }
-        );
-        assert_eq!(method(&f, "C", "other").body, MethodBody::Other);
-    }
-
-    #[test]
-    fn decorators_are_their_names_and_semantics() {
-        let f = facts(
-            "from abc import abstractmethod\nfrom typing import override\n\nclass C:\n    @abstractmethod\n    def a(self):\n        pass\n\n    @override\n    def b(self):\n        pass\n\n    @functools.cache\n    def c(self):\n        pass\n",
-        );
-        assert!(method(&f, "C", "a").abstract_method);
-        assert!(!method(&f, "C", "a").override_decorated);
-        assert!(method(&f, "C", "b").override_decorated);
-        assert!(!method(&f, "C", "c").override_decorated);
-    }
-
-    #[test]
-    fn override_of_another_library_is_not_typing_override() {
-        let f = facts("from mylib import override\n\nclass C:\n    @override\n    def a(self):\n        pass\n");
-        assert!(!method(&f, "C", "a").override_decorated);
-    }
-
-    #[test]
-    fn aliased_override_and_qualified_forms_are_recognised() {
-        let f = facts(
-            "from typing import override as ov\n\nclass C:\n    @ov\n    def a(self):\n        pass\n\nclass D:\n    @typing_extensions.override\n    def b(self):\n        pass\n",
-        );
-        assert!(method(&f, "C", "a").override_decorated);
-        assert!(method(&f, "D", "b").override_decorated);
-    }
-
-    #[test]
-    fn nested_classes_and_other_languages() {
-        let f = facts("class Outer:\n    class Inner:\n        def m(self):\n            pass\n");
-        let names: Vec<&str> = f.classes.iter().map(|c| c.name.as_str()).collect();
-        assert_eq!(names, ["Outer", "Inner"]);
-        let other = SYNTAX.get_or_init(Syntax::new).python_facts(&LanguageId::new("rust"), "class C {}");
-        assert_eq!(other.classes.len(), 0);
-    }
-}

crates/ide-lsp/src/handler.rs

@@ -41,44 +41,20 @@ pub struct ClientHandler {
     generation: u64,
 }
 
-/// The diagnostics in `items` (a JSON array) that deserialize. A server's malformed one is
-/// skipped with a warning, so the rest of the file's problems still show.
-pub(crate) fn lenient_diagnostics(server: &str, items: Value) -> Vec<lsp::Diagnostic> {
-    let Value::Array(items) = items else { return Vec::new() };
-    let mut skipped = 0usize;
-    let parsed: Vec<lsp::Diagnostic> = items
-        .into_iter()
-        .filter_map(|mut item| {
-            crate::virtual_doc::normalize_uris(&mut item);
-            match serde_json::from_value(item) {
-                Ok(diagnostic) => Some(diagnostic),
-                Err(_) => {
-                    skipped += 1;
-                    None
-                }
-            }
-        })
-        .collect();
-    if skipped > 0 {
-        tracing::warn!("{server}: skipped {skipped} malformed diagnostic(s)");
-    }
-    parsed
-}
-
 impl ClientHandler {
     pub fn new(mgr: Weak<LspManager>, server: Arc<Server>, generation: u64) -> Self {
         Self { mgr, server, generation }
     }
 
     fn encoding(&self) -> Encoding {
-        self.server.initialized_gen(self.generation).map(|r| r.caps.read().encoding).unwrap_or_default()
+        self.server.running_gen(self.generation).map(|r| r.caps.read().encoding).unwrap_or_default()
     }
 
     /// Cancelling task `task` asks this server instance to stop the work of progress `token`.
     fn cancel_handle(&self, task: TaskId, token: &Value) -> ide_core::task::CancelHandle {
         let (server, generation, token) = (self.server.clone(), self.generation, token.clone());
         ide_core::task::on_cancel(task, move || {
-            if let Some(run) = server.initialized_gen(generation)
+            if let Some(run) = server.running_gen(generation)
                 && let Err(e) = run.peer.notify("window/workDoneProgress/cancel", json!({ "token": token }))
             {
                 tracing::debug!("{}: cannot cancel progress: {e}", server.name);
@@ -200,7 +176,7 @@ impl ClientHandler {
             loop {
                 tokio::time::sleep(PROGRESS_SWEEP).await;
                 let Some(mgr) = weak.upgrade() else { return };
-                if !server.is_live(generation) || !server.has_progress(&token) {
+                if server.running_gen(generation).is_none() || !server.has_progress(&token) {
                     return; // the instance is gone, or the task ended normally
                 }
                 if server.progress_silent(&token, PROGRESS_STALE) {
@@ -275,24 +251,18 @@ impl ClientHandler {
 
     fn publish_diagnostics(&self, mgr: &LspManager, params: Value) {
         // Problems come only from servers used for `diagnostics`.
-        if self.server.initialized_gen(self.generation).is_some_and(|run| !run.caps.read().restriction.diagnostics()) {
+        if self.server.running_gen(self.generation).is_some_and(|run| !run.caps.read().restriction.diagnostics()) {
             return;
         }
         let mut params = params;
         crate::virtual_doc::normalize_uris(&mut params);
-        // One malformed diagnostic must not take the others of the file with it.
-        let raw = params.get_mut("diagnostics").map(Value::take);
-        if let Some(fields) = params.as_object_mut() {
-            fields.insert("diagnostics".into(), json!([]));
-        }
-        let mut params: lsp::PublishDiagnosticsParams = match serde_json::from_value(params) {
+        let params: lsp::PublishDiagnosticsParams = match serde_json::from_value(params) {
             Ok(p) => p,
             Err(e) => {
                 tracing::debug!("{}: bad publishDiagnostics: {e}", self.server.name);
                 return;
             }
         };
-        params.diagnostics = lenient_diagnostics(&self.server.name, raw.unwrap_or(Value::Null));
         let Some(path) = uri_to_path(params.uri.as_str())
             .or_else(|| crate::notebook::is_cell_uri(params.uri.as_str()).then(|| PathBuf::from(params.uri.as_str())))
         else {
@@ -510,7 +480,7 @@ impl Handler for ClientHandler {
                 crate::kotlin_lsp::record_import_state(&self.server, self.generation, &params)
             }
             "language/status" if self.server.name == "jdtls" && params["type"] == "ServiceReady" => {
-                if self.server.initialized_gen(self.generation).is_some() {
+                if self.server.running_gen(self.generation).is_some() {
                     self.server.set_java_ready();
                 }
                 mgr.java_import_ready(self.server.clone(), self.generation);

crates/ide-lsp/src/launch.rs

@@ -103,7 +103,7 @@ impl Launcher for ProcessLauncher {
             // A plugin's server: the approved program, unchanged since.
             Some(pin) => Some(pin.verify().map_err(LaunchError::Failed)?.to_path_buf()),
             None => ide_core::tool_path::find_command(&config.command, &search, root)
-                .and_then(|b| resolve_rustup_proxy(&config.command, b, root))
+                .and_then(|b| resolve_rustup_proxy(&config.command, b))
                 .and_then(|b| reject_dead_shim(b, &search, root)),
         };
         let mut env: Vec<(String, String)> = vec![("PATH".into(), search.to_string_lossy().into_owned())];
@@ -208,16 +208,34 @@ fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<Path
 /// toolchain lacks the component (common for rust-analyzer). In that case use
 /// the newest installed toolchain that ships the binary; with none, the tool is
 /// missing (an install hint, not a server that crashes on every restart).
-/// The probe runs in the project's root, where a `rust-toolchain.toml` picks the toolchain.
-fn resolve_rustup_proxy(command: &str, binary: PathBuf, root: &Path) -> Option<PathBuf> {
+fn resolve_rustup_proxy(command: &str, binary: PathBuf) -> Option<PathBuf> {
     let is_proxy = binary.parent().is_some_and(|d| d.ends_with(".cargo/bin"));
     if !is_proxy || command.contains('/') {
         return Some(binary);
     }
-    if proxy_works(&binary, root) {
+    let works = ide_core::process::prepare(&mut std::process::Command::new(&binary))
+        .arg("--version")
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .is_ok_and(|s| s.success());
+    if works {
         return Some(binary);
     }
-    let mut candidates = rustup_home().map(|h| toolchain_binaries(&h.join("toolchains"), command)).unwrap_or_default();
+    let toolchains = std::env::var_os("RUSTUP_HOME")
+        .map(PathBuf::from)
+        .or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".rustup")))
+        .map(|h| h.join("toolchains"));
+    let mut candidates: Vec<(std::time::SystemTime, PathBuf)> = toolchains
+        .and_then(|dir| std::fs::read_dir(dir).ok())
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| e.path().join("bin").join(command))
+        .filter(|p| p.is_file())
+        .filter_map(|p| Some((p.metadata().ok()?.modified().ok()?, p)))
+        .collect();
     // Prefer stable-looking toolchains, then the most recently installed.
     candidates.sort_by_key(|(mtime, p)| (!p.to_string_lossy().contains("nightly"), *mtime));
     match candidates.pop() {
@@ -232,57 +250,6 @@ fn resolve_rustup_proxy(command: &str, binary: PathBuf, root: &Path) -> Option<P
     }
 }
 
-/// Whether the proxy runs for the toolchain active in `root`. A probe that hangs or can't
-/// be waited for counts as working: the real start decides.
-fn proxy_works(binary: &Path, root: &Path) -> bool {
-    let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(binary))
-        .arg("--version")
-        .current_dir(root)
-        .stdin(std::process::Stdio::null())
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .spawn()
-    else {
-        return true;
-    };
-    let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
-    loop {
-        match child.try_wait() {
-            Ok(Some(status)) => return status.success(),
-            Ok(None) if std::time::Instant::now() < deadline => {
-                std::thread::sleep(std::time::Duration::from_millis(20))
-            }
-            _ => {
-                let _ = child.kill();
-                return true;
-            }
-        }
-    }
-}
-
-/// Where rustup keeps its toolchains: `RUSTUP_HOME`, else `.rustup` in the user's home
-/// (`HOME`, which a GUI app on Windows doesn't have, or `USERPROFILE`).
-fn rustup_home() -> Option<PathBuf> {
-    std::env::var_os("RUSTUP_HOME").map(PathBuf::from).or_else(|| {
-        let home = std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE"))?;
-        Some(PathBuf::from(home).join(".rustup"))
-    })
-}
-
-/// The `command` binary (with the platform's executable suffix) of every toolchain in
-/// `toolchains`, with its modification time.
-fn toolchain_binaries(toolchains: &Path, command: &str) -> Vec<(std::time::SystemTime, PathBuf)> {
-    let file = format!("{command}{}", std::env::consts::EXE_SUFFIX);
-    std::fs::read_dir(toolchains)
-        .into_iter()
-        .flatten()
-        .flatten()
-        .map(|e| e.path().join("bin").join(&file))
-        .filter(|p| p.is_file())
-        .filter_map(|p| Some((p.metadata().ok()?.modified().ok()?, p)))
-        .collect()
-}
-
 /// Workspace root for `file`: the outermost ancestor within `project_root`
 /// containing a root marker (so a Cargo/npm workspace gets one server, not one
 /// per member), else `project_root`. `None` when `file` is outside the project.
@@ -396,24 +363,7 @@ mod proxy_tests {
     #[test]
     fn non_proxy_binaries_are_kept() {
         let p = PathBuf::from("/usr/bin/true");
-        assert_eq!(resolve_rustup_proxy("true", p.clone(), Path::new(".")), Some(p));
-    }
-
-    /// The binary is `rust-analyzer.exe` on Windows: a lookup of the bare name found nothing there.
-    #[test]
-    fn toolchain_binaries_carry_the_platform_executable_suffix() {
-        let tmp = tempfile::tempdir().unwrap();
-        let file = format!("rust-analyzer{}", std::env::consts::EXE_SUFFIX);
-        for toolchain in ["stable-x86_64", "nightly-x86_64"] {
-            std::fs::create_dir_all(tmp.path().join(toolchain).join("bin")).unwrap();
-        }
-        std::fs::write(tmp.path().join("stable-x86_64/bin").join(&file), "").unwrap();
-        // Another tool, and a bare name without the suffix where one is required.
-        std::fs::write(tmp.path().join("nightly-x86_64/bin").join("rustfmt"), "").unwrap();
-        let found = toolchain_binaries(tmp.path(), "rust-analyzer");
-        assert_eq!(found.len(), 1);
-        assert_eq!(found[0].1, tmp.path().join("stable-x86_64/bin").join(&file));
-        assert!(toolchain_binaries(&tmp.path().join("missing"), "rust-analyzer").is_empty());
+        assert_eq!(resolve_rustup_proxy("true", p.clone()), Some(p));
     }
 
     /// Exercises the real machine setup when a broken rustup proxy is present.
@@ -422,7 +372,7 @@ mod proxy_tests {
     fn broken_rustup_proxy_falls_back_to_a_toolchain() {
         let home = PathBuf::from(std::env::var_os("HOME").unwrap());
         let proxy = home.join(".cargo/bin/rust-analyzer");
-        let resolved = resolve_rustup_proxy("rust-analyzer", proxy.clone(), Path::new(".")).unwrap();
+        let resolved = resolve_rustup_proxy("rust-analyzer", proxy.clone()).unwrap();
         eprintln!("resolved: {}", resolved.display());
         assert_ne!(resolved, proxy);
     }

crates/ide-lsp/src/lib.rs

@@ -343,10 +343,6 @@ impl<T> Outcome<T> {
 /// How often a rename the server withdrew (`ContentModified`) is asked, and the pause between.
 const RENAME_ATTEMPTS: u32 = 5;
 const RENAME_RETRY_DELAY: std::time::Duration = std::time::Duration::from_millis(300);
-/// How often a semantic tokens, inlay hints or code lens request the server withdrew
-/// (`ContentModified`) is asked again, and the pause between.
-const STALE_RETRIES: u32 = 2;
-const STALE_RETRY_DELAY: std::time::Duration = std::time::Duration::from_millis(150);
 
 /// Implementation requests of one line-marker pass in flight at once.
 const IMPLEMENTATION_CONCURRENCY: usize = 4;
@@ -658,9 +654,8 @@ impl LspManager {
     }
 
     /// The servers serving `path`: every regular one, and each `fallback` one
-    /// only while all servers listed before it have given up (missing, not
-    /// launchable, or crashed for good). One that requires a root marker serves
-    /// only files below one, and stands in for no other.
+    /// 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;
@@ -677,7 +672,7 @@ impl LspManager {
                 continue;
             }
             let server = self.server_for(sc, language, path);
-            available_before |= !sc.require_root_marker && !server.gave_up();
+            available_before |= !sc.require_root_marker && server.status() != ide_core::event::ServerStatus::Missing;
             out.push(server);
         }
         out
@@ -753,14 +748,9 @@ impl LspManager {
         if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {
             return;
         }
-        // A server dropped meanwhile (disabled in settings, shadowed by another) must not come
-        // back as a process nothing lists, serves or stops: a crash backoff can outlive it.
-        if !self.servers.lock().iter().any(|s| s.id == server.id) {
-            return;
-        }
         let workspace = is_local_jdtls(&server.config).then(|| self.jdtls_workspace_state());
         if let Some(state) = &workspace {
-            if state.transitioning {
+            if state.transitioning || !self.servers.lock().iter().any(|s| s.id == server.id) {
                 return;
             }
             let (shared, roots) = self.desired_jdtls_workspace();
@@ -871,28 +861,24 @@ impl LspManager {
             }
             Err(LaunchError::Config(message)) => {
                 tracing::warn!("{}: {message}", server.name);
-                if server.fail_start(
+                server.fail_start(
                     generation,
                     Conn::Failed,
                     &self.sink,
                     ide_core::event::ServerStatus::Misconfigured,
                     Some(message),
-                ) {
-                    self.attach_fallbacks();
-                }
+                );
                 return;
             }
             Err(LaunchError::Failed(message)) => {
                 tracing::warn!("{}: {message}", server.name);
-                if server.fail_start(
+                server.fail_start(
                     generation,
                     Conn::Failed,
                     &self.sink,
                     ide_core::event::ServerStatus::Crashed,
                     Some(message),
-                ) {
-                    self.attach_fallbacks();
-                }
+                );
                 return;
             }
         };
@@ -934,18 +920,9 @@ impl LspManager {
             }
             Err(e) => {
                 tracing::warn!("{}: initialize failed: {e}", server.name);
-                match e {
+                if matches!(e, RpcError::Closed) {
                     // The server is exiting: let it, so the crash report has its exit code and last output.
-                    RpcError::Closed => {
-                        let _ = tokio::time::timeout(Duration::from_secs(3), peer.closed()).await;
-                    }
-                    RpcError::Timeout => {
-                        server.set_start_error(
-                            generation,
-                            format!("it did not answer initialize within {} s", INITIALIZE_TIMEOUT.as_secs()),
-                        );
-                    }
-                    e => server.set_start_error(generation, format!("initialize failed ({e})")),
+                    let _ = tokio::time::timeout(Duration::from_secs(3), peer.closed()).await;
                 }
                 Self::kill_peer(&server, &peer).await;
                 // Treated like a crash so transient failures retry with backoff.
@@ -1031,15 +1008,11 @@ impl LspManager {
             self.forget(std::slice::from_ref(&server));
             return;
         }
-        match delay {
-            Some(delay) => {
-                tokio::time::sleep(delay).await;
-                if server.is_idle_gen(generation) {
-                    self.ensure_started(&server);
-                }
+        if let Some(delay) = delay {
+            tokio::time::sleep(delay).await;
+            if server.is_idle_gen(generation) {
+                self.ensure_started(&server);
             }
-            // Gave up (crashed repeatedly, or its build expired): the fallbacks it hid take over.
-            None => self.attach_fallbacks(),
         }
     }
 
@@ -1485,28 +1458,6 @@ impl LspManager {
         result
     }
 
-    /// [`Self::call`], asked again when the server withdrew the answer because the text changed
-    /// (`ContentModified`, which arrives as a cancellation as no cancel token is passed).
-    /// The client advertises `retryOnContentModified` for the methods that use it.
-    async fn call_retrying<P: Serialize + Clone, R: DeserializeOwned>(
-        &self,
-        t: &Target,
-        method: &str,
-        params: P,
-        timeout: Duration,
-    ) -> IdeResult<R> {
-        let mut attempt = 0;
-        loop {
-            match self.call(t, method, params.clone(), None, timeout).await {
-                Err(e) if e.kind == ErrorKind::Cancelled && attempt < STALE_RETRIES => {
-                    attempt += 1;
-                    tokio::time::sleep(STALE_RETRY_DELAY).await;
-                }
-                result => return result,
-            }
-        }
-    }
-
     // ---- features ----
     pub async fn completion(
         &self,
@@ -2941,10 +2892,11 @@ impl LspManager {
             async move {
                 (
                     t,
-                    self.call_retrying::<_, Option<Vec<lsp::InlayHint>>>(
+                    self.call::<_, Option<Vec<lsp::InlayHint>>>(
                         t,
                         "textDocument/inlayHint",
                         params,
+                        None,
                         DEFAULT_TIMEOUT,
                     )
                     .await,
@@ -2975,8 +2927,7 @@ impl LspManager {
             self.ready_targets(&snap.servers, |c| c.semantic_tokens_full() && c.semantic_legend.is_some()).await;
         let Some(t) = targets.first() else { return Ok(None) };
         let params = json!({ "textDocument": snap.ident() });
-        let r: Option<Value> =
-            self.call_retrying(t, "textDocument/semanticTokens/full", params, DEFAULT_TIMEOUT).await?;
+        let r: Option<Value> = self.call(t, "textDocument/semanticTokens/full", params, None, DEFAULT_TIMEOUT).await?;
         let Some(data) = r.as_ref().and_then(|v| v.get("data")).and_then(Value::as_array) else { return Ok(None) };
         let data: Vec<i64> = data.iter().map(|n| n.as_i64().unwrap_or(0)).collect();
         let (enc, legend) = {
@@ -2997,7 +2948,7 @@ impl LspManager {
             let params = json!({ "textDocument": snap.ident() });
             async move {
                 let lenses = self
-                    .call_retrying::<_, Option<Vec<lsp::CodeLens>>>(t, "textDocument/codeLens", params, DEFAULT_TIMEOUT)
+                    .call::<_, Option<Vec<lsp::CodeLens>>>(t, "textDocument/codeLens", params, None, DEFAULT_TIMEOUT)
                     .await?;
                 let lenses = lenses.unwrap_or_default();
                 if !t.caps().has_sub("codeLensProvider", "resolveProvider") {
@@ -3146,21 +3097,6 @@ impl LspManager {
         Ok(CallHierarchy { items: out, incomplete })
     }
 
-    /// The type at `pos` as the server's type hierarchy names it (with its `detail`, the
-    /// package for Java); `None` when there is no type there.
-    pub async fn prepare_type_hierarchy(&self, doc: DocId, pos: Pos) -> IdeResult<Option<HierarchyItem>> {
-        let (snap, targets) = self.doc_targets(doc, "type hierarchy", |c| c.has("typeHierarchyProvider")).await?;
-        let t = &targets[0];
-        let items: Option<Vec<serde_json::Value>> =
-            self.call(t, "textDocument/prepareTypeHierarchy", snap.pos_params(t, pos), None, DEFAULT_TIMEOUT).await?;
-        let conv = self.conv(t.enc());
-        Ok(items
-            .unwrap_or_default()
-            .iter()
-            .filter_map(convert::type_item_from_json)
-            .find_map(|i| convert::type_item(&conv, &i)))
-    }
-
     pub async fn type_hierarchy(
         &self,
         doc: DocId,
@@ -3919,41 +3855,31 @@ impl LspManager {
                 languages: s.languages(),
                 status: s.status(),
                 pid: s.running().and_then(|r| r.peer.pid()),
-                label: s.display_name(),
             })
             .collect()
     }
 
     pub async fn restart(&self, server: ide_core::ServerId) -> IdeResult<()> {
-        let s = {
-            // Only the restart itself holds the lock: a start can take minutes (a Gradle or
-            // Maven import), and `reconfigure` and `shutdown_all` wait for it.
-            let _reconfigure = self.reconfigure_lock.lock().await;
-            let s = self
-                .servers
-                .lock()
-                .iter()
-                .find(|s| s.id == server)
-                .cloned()
-                .ok_or_else(|| IdeError::not_found(format!("unknown language server {server}")))?;
-            if !s.root.is_dir() {
-                return Err(IdeError::unavailable(format!(
-                    "the workspace root of {} is gone: {}",
-                    s.name,
-                    s.root.display()
-                )));
-            }
-            self.stop_instance(&s, false).await;
-            s.reset_for_restart();
-            self.ensure_started(&s);
-            // Started again: it shadows the fallbacks that took over while it was down.
-            self.detach_shadowed_fallbacks().await;
-            s
-        };
+        let _reconfigure = self.reconfigure_lock.lock().await;
+        let s = self
+            .servers
+            .lock()
+            .iter()
+            .find(|s| s.id == server)
+            .cloned()
+            .ok_or_else(|| IdeError::not_found(format!("unknown language server {server}")))?;
+        if !s.root.is_dir() {
+            return Err(IdeError::unavailable(format!(
+                "the workspace root of {} is gone: {}",
+                s.name,
+                s.root.display()
+            )));
+        }
+        self.stop_instance(&s, false).await;
+        s.reset_for_restart();
+        self.ensure_started(&s);
         match s.wait_ready(Duration::from_secs(60)).await {
             Some(_) => Ok(()),
-            // Still importing the project: the restart worked, the server is just not ready yet.
-            None if s.is_starting() => Ok(()),
             None => {
                 Err(IdeError::unavailable(s.status_message().unwrap_or_else(|| format!("{} failed to start", s.name))))
             }

crates/ide-lsp/src/library_source.rs

@@ -136,8 +136,7 @@ fn source_entry(sources: &Path, class: &str, encoding: Option<&str>) -> Option<(
             return Some((entry.clone(), text));
         }
     }
-    // A facade renamed with `@file:JvmName("…")`, or a class declared in a file named otherwise
-    // (`UserDto` in `Models.kt`).
+    // A facade renamed with `@file:JvmName("…")`.
     let kotlin_files: Vec<String> = zip
         .file_names()
         .filter_map(|n| n.ok().map(|n| n.into_owned()))
@@ -146,7 +145,7 @@ fn source_entry(sources: &Path, class: &str, encoding: Option<&str>) -> Option<(
     let jvm_name = format!("@file:JvmName(\"{outer}\")");
     for entry in kotlin_files {
         if let Some(text) = read(&entry)
-            && (text.text.contains(&jvm_name) || declares_type(&text.text, outer))
+            && text.text.contains(&jvm_name)
         {
             return Some((entry, text));
         }
@@ -154,26 +153,6 @@ fn source_entry(sources: &Path, class: &str, encoding: Option<&str>) -> Option<(
     None
 }
 
-/// Whether `text` declares a type called `name` (`class`, `interface`, `object`, `typealias`):
-/// how a Kotlin file that is not named after its class is recognised.
-fn declares_type(text: &str, name: &str) -> bool {
-    const KINDS: [&str; 4] = ["class", "interface", "object", "typealias"];
-    text.lines().any(|line| {
-        let line = line.trim_start();
-        if line.starts_with("//") || line.starts_with("/*") || line.starts_with('*') {
-            return false;
-        }
-        let mut words =
-            line.split(|c: char| !(c.is_alphanumeric() || c == '_' || c == '$' || c == '`')).filter(|w| !w.is_empty());
-        let mut previous = words.next();
-        words.any(|word| {
-            let hit = previous.is_some_and(|p| KINDS.contains(&p)) && word.trim_matches('`') == name;
-            previous = Some(word);
-            hit
-        })
-    })
-}
-
 /// Where `name` is declared in a Kotlin or Java source `text` (the start of the
 /// name), else the start of the file.
 pub(crate) fn declaration_range(text: &str, name: &str) -> Range {
@@ -266,22 +245,6 @@ pub(crate) fn folder_class(uri: &str) -> Option<(String, String)> {
     Some((package.replace('.', "/"), name.to_owned()))
 }
 
-/// Kotlin sources larger than this are not searched for a class declared in a file named otherwise.
-const MAX_SOURCE: u64 = 1 << 20;
-
-/// The files of the project's source trees: build output and ignored files are skipped.
-fn walk_sources(root: &Path) -> impl Iterator<Item = ignore::DirEntry> {
-    ignore::WalkBuilder::new(root)
-        .filter_entry(|e| {
-            let output = matches!(e.file_name().to_str(), Some("target" | "build" | "out" | "node_modules"));
-            // A package may be named `build`: only outside source trees is it output.
-            !output || e.path().components().any(|c| c.as_os_str() == "src")
-        })
-        .build()
-        .flatten()
-        .filter(|e| e.file_type().is_some_and(|t| t.is_file()))
-}
-
 /// The project's source of `class` (`Name`, `Outer$Inner`, `FileKt`) in `package`
 /// (`/`-separated): a `.kt` / `.java` file of that name declaring the package. Build
 /// output and ignored files are skipped.
@@ -292,24 +255,19 @@ pub(crate) fn project_class_source(root: &Path, package: &str, class: &str) -> O
         names.push(format!("{file}.kt"));
     }
     let package = package.replace('/', ".");
-    let mut found: Vec<PathBuf> = walk_sources(root)
+    let mut found: Vec<PathBuf> = ignore::WalkBuilder::new(root)
+        .filter_entry(|e| {
+            let output = matches!(e.file_name().to_str(), Some("target" | "build" | "out" | "node_modules"));
+            // A package may be named `build`: only outside source trees is it output.
+            !output || e.path().components().any(|c| c.as_os_str() == "src")
+        })
+        .build()
+        .flatten()
+        .filter(|e| e.file_type().is_some_and(|t| t.is_file()))
         .filter(|e| e.file_name().to_str().is_some_and(|n| names.iter().any(|name| name == n)))
         .map(|e| e.into_path())
         .filter(|p| std::fs::read_to_string(p).is_ok_and(|text| declared_package(&text) == package))
         .collect();
-    // A class declared in a file named otherwise (`UserDto` in `Models.kt`).
-    if found.is_empty() {
-        found = walk_sources(root)
-            .filter(|e| {
-                e.path().extension().is_some_and(|x| x == "kt") && e.metadata().is_ok_and(|m| m.len() <= MAX_SOURCE)
-            })
-            .map(|e| e.into_path())
-            .filter(|p| {
-                std::fs::read_to_string(p)
-                    .is_ok_and(|text| declared_package(&text) == package && declares_type(&text, outer))
-            })
-            .collect();
-    }
     // The directory matching the package first, then by name order.
     found.sort_by_key(|p| {
         let dir = p.parent().map(|d| d.to_string_lossy().replace('\\', "/")).unwrap_or_default();
@@ -400,10 +358,6 @@ mod tests {
                 "@file:JvmName(\"BootUtils\")\npackage org.springframework.boot\nfun util() {}",
             ),
             ("org/springframework/boot/Builder.kt", "class Builder"),
-            (
-                "org/springframework/boot/Models.kt",
-                "package org.springframework.boot\n\n// class NotMe\ndata class UserDto(val id: Int)\nenum class Role { A }\ninterface Repo\nobject Registry\ntypealias Ids = List<Int>\n",
-            ),
             ("Root.java", "class Root {}"),
         ];
         jar(&m2.join("spring-boot-3.5.16.jar"), &[]);
@@ -419,11 +373,6 @@ mod tests {
                 ("org/springframework/boot/SpringApplication$Running.class", "SpringApplication.java"),
                 ("org/springframework/boot/BootUtils.class", "Renamed.kt"),
                 ("org/springframework/boot/Builder.class", "Builder.kt"),
-                // Declared in a file that is not named after them.
-                ("org/springframework/boot/UserDto.class", "Models.kt"),
-                ("org/springframework/boot/Role$A.class", "Models.kt"),
-                ("org/springframework/boot/Repo.class", "Models.kt"),
-                ("org/springframework/boot/Registry.class", "Models.kt"),
                 ("Root.class", "Root.java"),
             ] {
                 let (source_uri, text) =
@@ -436,7 +385,6 @@ mod tests {
                 );
             }
             assert!(class_source(&uri("org/springframework/boot/Missing.class"), None).is_none());
-            assert!(class_source(&uri("org/springframework/boot/NotMe.class"), None).is_none(), "only in a comment");
         }
         // No sources jar: nothing to show from here.
         let lone = tmp.path().join("lone/x-1.jar");
@@ -565,11 +513,6 @@ mod tests {
         write("src/main/kotlin/com/x/build/Tool.kt", "package com.x.build\n\nclass Tool\n");
         write("src/main/kotlin/flat/Elsewhere.kt", "");
         write("src/main/kotlin/Loose.kt", "package flat\n\nobject Loose\n");
-        write(
-            "src/main/kotlin/test001/Models.kt",
-            "package test001\n\n// class NotMe\ndata class UserDto(val id: Int)\n",
-        );
-        write("src/main/kotlin/other/Models.kt", "package other\n\ndata class UserDto(val name: String)\n");
         let source = |package: &str, class: &str| {
             project_class_source(root, package, class).map(|p| p.strip_prefix(root).unwrap().to_owned())
         };
@@ -580,10 +523,6 @@ mod tests {
         assert_eq!(source("com/x/build", "Tool"), Some(PathBuf::from("src/main/kotlin/com/x/build/Tool.kt")));
         assert_eq!(source("flat", "Loose"), Some(PathBuf::from("src/main/kotlin/Loose.kt")), "any directory");
         assert_eq!(source("test001", "Missing"), None);
-        // Declared in a file named otherwise: the one of the package, not another package's.
-        assert_eq!(source("test001", "UserDto"), Some(PathBuf::from("src/main/kotlin/test001/Models.kt")));
-        assert_eq!(source("other", "UserDto"), Some(PathBuf::from("src/main/kotlin/other/Models.kt")));
-        assert_eq!(source("test001", "NotMe"), None, "only in a comment");
         assert_eq!(declared_package("package a.b.c;\n"), "a.b.c");
         assert_eq!(declared_package("class A"), "");
     }

crates/ide-lsp/src/pull.rs

@@ -166,10 +166,13 @@ impl LspManager {
             let result_id = report.get("resultId").and_then(Value::as_str).map(str::to_owned);
             let items = match report.get("kind").and_then(Value::as_str) {
                 Some("unchanged") => None,
-                _ => Some(crate::handler::lenient_diagnostics(
-                    &t.server.name,
-                    report.get("items").cloned().unwrap_or(json!([])),
-                )),
+                _ => match serde_json::from_value(report.get("items").cloned().unwrap_or(json!([]))) {
+                    Ok(items) => Some(items),
+                    Err(e) => {
+                        tracing::debug!("{}: bad textDocument/diagnostic report: {e}", t.server.name);
+                        return;
+                    }
+                },
             };
             let shown = t.server.set_pulled(t.path.clone(), result_id, items);
             let enc = t.run.caps.read().encoding;

crates/ide-lsp/src/server.rs

@@ -112,11 +112,8 @@ pub struct Server {
     status: Mutex<(ServerStatus, Option<String>)>,
     /// Consecutive crashes of short-lived instances.
     crashes: Mutex<usize>,
-    /// When the current instance became ready: only time spent running counts as uptime,
-    /// not the time spent starting (an `initialize` that hangs for minutes is not a stable run).
+    /// When the current instance was launched.
     started: Mutex<Option<Instant>>,
-    /// Why the current instance's `initialize` failed, for the crash report.
-    start_error: Mutex<Option<(u64, String)>>,
     stderr: Mutex<VecDeque<String>>,
     pub progress: Mutex<HashMap<String, Progress>>,
     /// What the editor shows per path: the pushed and the pulled diagnostics together.
@@ -180,7 +177,6 @@ impl Server {
             status: Mutex::new((ServerStatus::Stopped, None)),
             crashes: Mutex::new(0),
             started: Mutex::new(None),
-            start_error: Mutex::new(None),
             stderr: Mutex::new(VecDeque::new()),
             progress: Mutex::new(HashMap::new()),
             diagnostics: Mutex::new(HashMap::new()),
@@ -217,11 +213,6 @@ impl Server {
         config
     }
 
-    /// The configured server's display name for the current (or last) instance.
-    pub fn display_name(&self) -> Option<String> {
-        self.effective.lock().as_ref().and_then(|c| c.display_name.clone())
-    }
-
     pub fn set_effective_config(&self, generation: u64, config: LanguageServerConfig) {
         let st = self.state.lock();
         if st.generation == generation && matches!(st.conn, Conn::Starting | Conn::Ready(_)) {
@@ -261,8 +252,7 @@ impl Server {
         st.conn = Conn::Starting;
         st.restarting = false;
         *self.start_cancel.lock() = CancellationToken::new();
-        *self.started.lock() = None;
-        *self.start_error.lock() = None;
+        *self.started.lock() = Some(Instant::now());
         // A crash report quotes only this instance's output, not its predecessors'.
         self.stderr.lock().clear();
         self.import_state.send_replace(None);
@@ -310,15 +300,9 @@ impl Server {
         }
         st.conn = Conn::Ready(run);
         *self.initializing.lock() = None;
-        *self.started.lock() = Some(Instant::now());
         true
     }
 
-    /// Records why instance `generation` failed to initialize, so its crash report says so.
-    pub fn set_start_error(&self, generation: u64, reason: String) {
-        *self.start_error.lock() = Some((generation, reason));
-    }
-
     /// Wakes requests waiting for the instance (after status and documents are in place).
     pub fn announce_ready(&self, generation: u64) {
         let st = self.state.lock();
@@ -338,13 +322,6 @@ impl Server {
         matches!(self.state.lock().conn, Conn::Starting)
     }
 
-    /// The server will not run until something changes: its binary is missing, its
-    /// configuration can't launch it, or it crashed too often (or its build expired).
-    /// Servers that crashed and are about to restart are not given up on.
-    pub fn gave_up(&self) -> bool {
-        matches!(self.state.lock().conn, Conn::Missing | Conn::Failed)
-    }
-
     /// The instance told `initialized`, ready or not.
     pub fn instance(&self) -> Option<Running> {
         self.running().or_else(|| self.initializing.lock().clone())
@@ -369,13 +346,6 @@ impl Server {
         self.running().filter(|r| r.generation == generation)
     }
 
-    /// Instance `generation` is starting or running: not stopped, crashed or replaced.
-    /// Work it reports before it is ready (a Gradle import answers `initialize` late) still counts.
-    pub fn is_live(&self, generation: u64) -> bool {
-        let st = self.state.lock();
-        st.generation == generation && matches!(st.conn, Conn::Starting | Conn::Ready(_))
-    }
-
     /// Waits through startup or a planned restart; returns the instance once ready.
     pub async fn wait_ready(&self, timeout: Duration) -> Option<Running> {
         let mut rx = self.phase.subscribe();
@@ -466,12 +436,10 @@ impl Server {
         }
         let tail = self.stderr_tail(5);
         let cfg = self.effective_config();
-        let start_error = self.start_error.lock().take().filter(|(g, _)| *g == generation).map(|(_, r)| r);
-        let mut message = match (&start_error, code, &cfg.connect) {
-            (Some(reason), _, _) => format!("{} failed to start: {reason}", self.name),
-            (None, Some(c), _) => format!("{} exited with code {c}", self.name),
-            (None, None, Some(addr)) => format!("{}: the connection to the server ({addr}) closed", self.name),
-            (None, None, None) => format!("{} terminated unexpectedly", self.name),
+        let mut message = match (code, &cfg.connect) {
+            (Some(c), _) => format!("{} exited with code {c}", self.name),
+            (None, Some(addr)) => format!("{}: the connection to the server ({addr}) closed", self.name),
+            (None, None) => format!("{} terminated unexpectedly", self.name),
         };
         if !tail.is_empty() {
             message.push_str(":\n");
@@ -504,7 +472,6 @@ impl Server {
     /// Records a crash; returns the backoff before restarting, or `None` once
     /// [`MAX_RESTARTS`] instances in a row died before running [`STABLE_UPTIME`]
     /// (a server that crashes on every start, however slowly, is not restarted forever).
-    /// An instance that never became ready has run for no time at all.
     pub fn record_crash(&self) -> Option<Duration> {
         let uptime = self.started.lock().map(|t| t.elapsed()).unwrap_or_default();
         let mut crashes = self.crashes.lock();
@@ -540,13 +507,7 @@ impl Server {
             return;
         }
         *cur = (status, message.clone());
-        st.events.push_back(IdeEvent::LanguageServer {
-            server: self.id,
-            name: self.name.clone(),
-            label: self.display_name(),
-            status,
-            message,
-        });
+        st.events.push_back(IdeEvent::LanguageServer { server: self.id, name: self.name.clone(), status, message });
     }
 
     fn queue_cleanup(&self, st: &mut State) {
@@ -1067,38 +1028,6 @@ mod tests {
         assert!(s.is_busy(), "a reporting task keeps the server busy");
     }
 
-    #[test]
-    fn only_time_spent_ready_counts_as_uptime() {
-        let sink: SharedSink = Arc::new(|_: IdeEvent| {});
-        let s = server();
-        for n in 1..=MAX_RESTARTS + 1 {
-            // Never ready: crashes after a slow start count however long the start took.
-            let generation = s.begin_start().unwrap();
-            assert!(s.started.lock().is_none());
-            s.set_start_error(generation, "it did not answer initialize within 300 s".into());
-            let delay = s.on_closed(generation, &sink, None).unwrap();
-            assert_eq!(delay.is_some(), n <= MAX_RESTARTS, "crash {n}");
-            let message = s.status_message().unwrap();
-            assert!(
-                message.starts_with(&format!("{} failed to start: it did not answer initialize", s.name)),
-                "{message}"
-            );
-            s.state.lock().conn = Conn::Idle;
-        }
-        assert!(matches!(s.state.lock().conn, Conn::Idle));
-    }
-
-    #[test]
-    fn an_instance_is_live_from_its_start_until_it_is_retired() {
-        let sink: SharedSink = Arc::new(|_: IdeEvent| {});
-        let s = server();
-        let generation = s.begin_start().unwrap();
-        assert!(s.is_live(generation), "still starting: its progress (an import) is being watched");
-        assert!(!s.is_live(generation + 1));
-        assert!(s.fail_start(generation, Conn::Failed, &sink, ServerStatus::Crashed, None));
-        assert!(!s.is_live(generation));
-    }
-
     #[test]
     fn crashes_of_short_lived_instances_exhaust_the_budget_whatever_the_spacing() {
         let s = server();

crates/ide-lsp/src/types.rs

@@ -341,10 +341,6 @@ pub struct ServerInfo {
     pub status: ServerStatus,
     /// OS process of the running instance (for memory attribution).
     pub pid: Option<u32>,
-    /// What the user sees as the server when another program serves in its place.
-    #[serde(default)]
-    #[specta(optional)]
-    pub label: Option<String>,
 }
 
 /// Read-only contents a language server provides for a non-`file:` URI

crates/ide-lsp/src/virtual_doc.rs

@@ -32,7 +32,7 @@ pub(crate) fn normalize_uris(value: &mut serde_json::Value) {
                 if matches!(key.as_str(), "data" | "arguments") {
                     continue;
                 }
-                if matches!(key.as_str(), "uri" | "targetUri" | "oldUri" | "newUri" | "target")
+                if matches!(key.as_str(), "uri" | "targetUri" | "oldUri" | "newUri")
                     && let Some(uri) = value.as_str().and_then(escaped_uri)
                 {
                     *value = uri.into();
@@ -247,22 +247,6 @@ mod tests {
         assert!(encoded.parse::<lsp_types::Uri>().is_ok());
     }
 
-    /// `DocumentLink.target` is a URI too: one unescaped link fails the whole `documentLink` response.
-    #[test]
-    fn document_link_targets_are_escaped() {
-        let range = serde_json::json!({ "start": { "line": 0, "character": 0 }, "end": { "line": 0, "character": 1 } });
-        let mut links = serde_json::json!([
-            { "range": range, "target": "file:///D:/My Game/项目/a.xsd" },
-            { "range": range, "target": "https://example.com/a b" }
-        ]);
-        assert!(serde_json::from_value::<Vec<lsp_types::DocumentLink>>(links.clone()).is_err());
-        normalize_uris(&mut links);
-        assert_eq!(links[0]["target"], "file:///D:/My%20Game/%E9%A1%B9%E7%9B%AE/a.xsd");
-        assert_eq!(links[1]["target"], "https://example.com/a b", "other schemes are not touched");
-        links[1]["target"] = "https://example.com/ab".into();
-        assert_eq!(serde_json::from_value::<Vec<lsp_types::DocumentLink>>(links).unwrap().len(), 2);
-    }
-
     /// #3089: jdtls's Introduce Variable edit for a project under a Chinese path names the file
     /// with the characters unescaped, and the resolved code action failed to deserialize.
     #[test]

crates/ide-lsp/tests/mock_server.rs

@@ -146,9 +146,6 @@ impl Handler for MockHandler {
                 if let Some(gate) = gate {
                     gate.hold();
                 }
-                if let Some(error) = s.errors.lock().get("initialize").cloned() {
-                    return Err(error);
-                }
                 Ok(json!({ "capabilities": s.caps.lock().clone(), "serverInfo": { "name": "mock" } }))
             }
             "shutdown" => Ok(Value::Null),
@@ -271,7 +268,6 @@ fn server_cfg(name: &str) -> LanguageServerConfig {
         tsserver_project: false,
         tsserver_project_extras: Default::default(),
         resync_on_configuration: false,
-        display_name: None,
         pinned: None,
     }
 }
@@ -2076,29 +2072,6 @@ async fn crash_restarts_and_reopens_documents() {
     assert_eq!(hover.contents.value, "hi");
 }
 
-/// A restart during a long start (a project import) returns when the instance is up and
-/// running, and does not hold up `reconfigure` and `shutdown_all` meanwhile.
-#[tokio::test(flavor = "multi_thread")]
-async fn restart_does_not_hold_the_reconfigure_lock_while_the_server_starts() {
-    let h = harness(&[("mock", incremental_caps())]);
-    h.open("a.mk", "x");
-    h.wait_status("mock", ServerStatus::Ready).await;
-    let s = h.launcher.state("mock");
-    let gate = Arc::new(Gate::default());
-    *s.initialize_gate.lock() = Some(gate.clone());
-    let id = h.mgr.servers()[0].id;
-    let restart = tokio::spawn({
-        let mgr = h.mgr.clone();
-        async move { mgr.restart(id).await }
-    });
-    eventually(|| gate.entered()).await;
-    let reconfigured = tokio::time::timeout(Duration::from_secs(2), h.mgr.reconfigure()).await;
-    gate.open();
-    reconfigured.expect("a restart still waiting for the server to start must not block reconfigure");
-    restart.await.unwrap().unwrap();
-    assert_eq!(h.mgr.servers()[0].status, ServerStatus::Ready);
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn gives_up_after_repeated_crashes_and_manual_restart_works() {
     let h = harness(&[("mock", incremental_caps())]);
@@ -2126,118 +2099,6 @@ async fn gives_up_after_repeated_crashes_and_manual_restart_works() {
     assert_eq!(h.mgr.servers()[0].status, ServerStatus::Ready);
 }
 
-/// One malformed diagnostic costs only itself, not the file's other problems.
-#[tokio::test(flavor = "multi_thread")]
-async fn a_malformed_diagnostic_does_not_drop_the_others() {
-    let h = harness(&[("mock", incremental_caps())]);
-    let (_, path) = h.open("a.mk", "one");
-    h.wait_status("mock", ServerStatus::Ready).await;
-    let uri = uri_of(&path);
-    let range = json!({"start":{"line":0,"character":0},"end":{"line":0,"character":1}});
-    h.launcher
-        .state("mock")
-        .peer()
-        .notify(
-            "textDocument/publishDiagnostics",
-            json!({ "uri": uri, "diagnostics": [
-                { "range": range, "message": "first" },
-                { "message": "no range" },
-                { "range": range, "message": 7 },
-                { "range": range, "message": "last" }] }),
-        )
-        .unwrap();
-    eventually(|| {
-        h.events.lock().iter().any(|e| match e {
-            IdeEvent::Diagnostics { items, .. } => {
-                items.iter().map(|d| d.message.as_str()).collect::<Vec<_>>() == ["first", "last"]
-            }
-            _ => false,
-        })
-    })
-    .await;
-}
-
-/// The `initialize` error is the crash report's reason, not "terminated unexpectedly", and
-/// a server that never gets past `initialize` gives up like any other crash loop.
-#[tokio::test(flavor = "multi_thread")]
-async fn a_failed_initialize_is_reported_with_its_reason_and_gives_up() {
-    let h = harness(&[("mock", incremental_caps())]);
-    let s = h.launcher.state("mock");
-    s.errors.lock().insert("initialize".into(), (-32603, "no workspace".into()));
-    h.open("a.mk", "x");
-    let count = |status| h.statuses("mock").iter().filter(|s| **s == status).count();
-    eventually(|| count(ServerStatus::Crashed) == 4).await;
-    let messages: Vec<String> = h
-        .events
-        .lock()
-        .iter()
-        .filter_map(|e| match e {
-            IdeEvent::LanguageServer { status: ServerStatus::Crashed, message, .. } => message.clone(),
-            _ => None,
-        })
-        .collect();
-    assert!(
-        messages[0].contains("failed to start: initialize failed (server error -32603: no workspace)"),
-        "{messages:?}"
-    );
-    assert!(messages[0].ends_with("Restarting…"));
-    assert!(messages[3].ends_with("restart it manually."), "{messages:?}");
-    tokio::time::sleep(Duration::from_millis(300)).await;
-    assert_eq!(s.launches.load(Ordering::SeqCst), 4, "initial start + 3 restarts");
-}
-
-/// The client tells servers it retries semantic tokens, inlay hints and code lens that they
-/// withdrew with `ContentModified` (`staleRequestSupport`), so it must.
-#[tokio::test(flavor = "multi_thread")]
-async fn withdrawn_editor_decoration_requests_are_asked_again() {
-    let h = harness(&[("mock", incremental_caps())]);
-    let (doc, _) = h.open("a.mk", "let x = 1");
-    h.wait_status("mock", ServerStatus::Ready).await;
-    let s = h.launcher.state("mock");
-    let range = json!({"start":{"line":0,"character":0},"end":{"line":0,"character":1}});
-    let cases = [
-        ("textDocument/semanticTokens/full", json!({ "data": [0, 0, 1, 0, 0] })),
-        ("textDocument/inlayHint", json!([{ "position": {"line":0,"character":0}, "label": "x" }])),
-        ("textDocument/codeLens", json!([{ "range": range, "command": { "title": "t", "command": "c" } }])),
-    ];
-    for (method, answer) in cases {
-        s.errors.lock().insert(method.into(), (-32801, "content modified".into()));
-        let mgr = h.mgr.clone();
-        let request = tokio::spawn(async move {
-            match method {
-                "textDocument/semanticTokens/full" => mgr.semantic_tokens(doc).await.map(|r| r.is_some()),
-                "textDocument/inlayHint" => {
-                    mgr.inlay_hints(doc, Range::new(Pos::new(0, 0), Pos::new(0, 9))).await.map(|v| v.len() == 1)
-                }
-                _ => mgr.code_lens(doc).await.map(|v| v.len() == 1),
-            }
-        });
-        eventually(|| !s.requested(method).is_empty()).await;
-        s.errors.lock().remove(method);
-        s.respond(method, answer);
-        let answered = tokio::time::timeout(Duration::from_secs(5), request).await.unwrap().unwrap();
-        assert!(answered.unwrap_or(false), "{method} was not asked again");
-        assert_eq!(s.requested(method).len(), 2, "{method}");
-    }
-}
-
-/// A server disabled in settings while its crash backoff is still sleeping stays gone: the
-/// pending restart must not bring it back as a process nothing lists or stops.
-#[tokio::test(flavor = "multi_thread")]
-async fn a_server_disabled_during_its_crash_backoff_does_not_restart() {
-    let h = harness(&[("mock", incremental_caps()), ("other", incremental_caps())]);
-    h.open("a.mk", "x");
-    h.wait_status("mock", ServerStatus::Ready).await;
-    let s = h.launcher.state("mock");
-    s.peer().kill();
-    eventually(|| h.statuses("mock").contains(&ServerStatus::Crashed)).await;
-    h.mgr.set_servers_hook(Box::new(|_, configs| configs.iter().filter(|c| c.name == "other").cloned().collect()));
-    h.mgr.reconfigure().await;
-    eventually(|| h.removed("mock")).await;
-    tokio::time::sleep(Duration::from_millis(1200)).await;
-    assert_eq!(s.launches.load(Ordering::SeqCst), 1, "no restart after the server was dropped");
-}
-
 /// The whole workspace root deleted: the server can never start again
 /// (its cwd is gone), so the crash drops the entry instead of restarting.
 #[tokio::test(flavor = "multi_thread")]
@@ -3136,49 +2997,6 @@ async fn fallback_servers_only_run_when_the_preferred_one_is_missing() {
     assert!(h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.is_ok());
 }
 
-/// A server that is installed but cannot run (crashed for good, or its configuration
-/// can't launch it) hides its fallbacks no longer than one that is missing.
-#[tokio::test(flavor = "multi_thread")]
-async fn fallback_servers_take_over_from_a_preferred_one_that_crashed_for_good() {
-    let h = harness_with_fallbacks(&[("main", incremental_caps()), ("alt", incremental_caps())], &["alt"]);
-    let (doc, path) = h.open("a.mk", "x");
-    let main = h.launcher.state("main");
-    let count = |status| h.statuses("main").iter().filter(|s| **s == status).count();
-    for n in 1..=4 {
-        eventually(|| count(ServerStatus::Ready) == n).await;
-        // Restarting after a crash is not giving up: the fallback stays away.
-        assert!(h.statuses("alt").is_empty(), "alt started after crash {}", n - 1);
-        main.peer().kill();
-        eventually(|| count(ServerStatus::Crashed) == n).await;
-    }
-    h.wait_status("alt", ServerStatus::Ready).await;
-    let uri = uri_of(&path);
-    eventually(|| h.launcher.state("alt").docs.lock().contains_key(&uri)).await;
-    assert!(h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.is_ok());
-
-    // Restarting the preferred one by hand gives the documents back to it.
-    let id = h.mgr.servers().into_iter().find(|s| s.name == "main").unwrap().id;
-    h.mgr.restart(id).await.unwrap();
-    eventually(|| h.removed("alt")).await;
-    assert_eq!(h.mgr.servers().iter().filter(|s| s.name == "alt").count(), 0);
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn fallback_servers_take_over_from_a_preferred_one_that_cannot_be_launched() {
-    let h = harness_with_fallbacks(&[("main", incremental_caps()), ("alt", incremental_caps())], &["alt"]);
-    h.mgr.set_config_hook(Box::new(|cfg, _| {
-        if cfg.name == "main" {
-            cfg.launch_error = Some("needs JDK 21".into());
-        }
-    }));
-    let (doc, path) = h.open("a.mk", "x");
-    h.wait_status("main", ServerStatus::Misconfigured).await;
-    h.wait_status("alt", ServerStatus::Ready).await;
-    let uri = uri_of(&path);
-    eventually(|| h.launcher.state("alt").docs.lock().contains_key(&uri)).await;
-    assert!(h.mgr.hover(doc, Pos::new(0, 0), Default::default()).await.is_ok());
-}
-
 #[tokio::test(flavor = "multi_thread")]
 async fn a_server_requiring_a_root_marker_serves_only_files_below_one() {
     // `framework` next to `main` (one instance for the whole project), like the

crates/ide-lsp/tests/real_servers.rs

@@ -426,7 +426,6 @@ async fn missing_binary_is_reported_with_install_hint() {
         tsserver_project: false,
         tsserver_project_extras: Default::default(),
         resync_on_configuration: false,
-        display_name: None,
         pinned: None,
     };
     let (mgr, events) = manager(dir.path(), LanguageRegistry::from_configs(vec![lang("nope", "nope", server)]));
@@ -699,7 +698,6 @@ async fn typescript_language_server_end_to_end() {
         tsserver_project: false,
         tsserver_project_extras: Default::default(),
         resync_on_configuration: false,
-        display_name: None,
         pinned: None,
     };
     let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![lang("typescript", "ts", server)]));
@@ -752,7 +750,6 @@ fn npm_server(tools: &Path, name: &str, bin: &str, init: Option<serde_json::Valu
         tsserver_project: false,
         tsserver_project_extras: Default::default(),
         resync_on_configuration: false,
-        display_name: None,
         pinned: None,
     }
 }

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

@@ -1 +1 @@
-0b77e7a414ec3b0dd1f41e5658b981f059dd842743dbe2f06e5d428f5b9570f9
+e616b87b24371581ad648f9c7072259de7732d122b5887b488f7bd480ebd69c2

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

@@ -1 +1 @@
-6f7d6527837c8e5c86c377479cceef5116decd61666b28f36dd11332e36e9934
+75eeecc467bff141bda14f1f080633348af348f7259e793be81e6548d2008669

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

@@ -1 +1 @@
-c1ac86a5b4d45b55013e6e00dcb83deda33b759ecc366c3fdf57739bdd22cbff
+4aaf7754e895f022d34dad05bd2b8018e3a61ba18771b8c95d9f070cb212530c

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

@@ -1 +1 @@
-e4d8d8f5f5849b912b2c0ebee6b91d60796c3070929d7698323e8ce4f200a38a
+e573144879a7caa0975e17b233476eb317ff54bef23fd8fa64280d3649bad700

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

@@ -1 +1 @@
-e2e2fc44ad9cae9cf26a5bf706768d3786502f23db6994dc29695deb249ed73f
+36dd40ef751a617f1ad59491312889c12481b05666e580f21f7c2552df76edbc

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

@@ -1 +1 @@
-61e1f0c43bbfddc35dcf40685169eb273777ddca13da534626e1699b47e8eac3
+724ed3bbd828e4fc1925c1b555bdaec9268633cb587806a661f8838e5a540545

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

@@ -1 +1 @@
-2ea1c1693db8638db996c9c47597f0c1635ef0a9c7dfb33685c515b7af95e6a6
+1a3685234f1b3b0957184c44c603c0eefe7e3084b88d0df32da268b29292ee92

crates/ide-plugin/tests/fixtures/ext-owner/dist/plugin.wasm.sources

@@ -1 +1 @@
-3c788f6092b229484a5d94fd0e6f4651afc88dd0ab1b22b067d84614a6a0c85e
+4283de821d69a18438f58062e4bc28b63ba5025cc5f9fa51f21ff475b677a6a5

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

@@ -1 +1 @@
-18273599cc459833d6a30185a5f0ba127cdb4e22bc054a973571e530eb3a85ca
+0f25487b8e488e5ec01fabd2951bdb03d80bc26e4e9aa508394a7f9cd09d1759

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

@@ -1 +1 @@
-c9fafba362fa0745d7ee1685efe5582d432510003c04c98100eddd557bd1e2cf
+80f9dc28e4f168dd22ccee1c53e1f6b08c446622eb10f07de29be5fc45e9fb1c

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

@@ -1 +1 @@
-4121009913709edeca8c5cb52d88dfcc2b16867bc06859768f73c17cf9c456a2
+5355cb4ef373eba3c54806eb00294fcd5fccb3cf05dae3e1c2a4ad45ab958f03

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

@@ -1 +1 @@
-b55bd202a06f5643c4f70abb6fb473fbe53af657f4e21a6d13581a23a726e085
+fc75ede42e6db7619fa28fc8999f091d39e3c1ed401356db3a3f07de54287c99

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

@@ -1 +1 @@
-11a12228df67f9b94bd52375b5dddb2d955f7e5f88d7f9ea0a430b1db128f6ca
+8793601496f1727cf912e4cdf86ec48fc340a17585098e98dee52a125cb8a16d

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

@@ -1 +1 @@
-553ce6c57052f8ff2ea2526e88762d5a0aee2489cda192fc7ab708766078ccf7
+fb2db14a645cad42941d20a25a3ff87ca6fdee635fdb40953383ff30ce16af8a

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

@@ -1 +1 @@
-7b43f8a2a06d7b2952f8d46727a4cce524fb2bdecee1035dad9c767261d276d0
+fc66b3b56a1ab1c9d547e3efe6bb4693dca908bb18be8b8ebd26f2fb41e4436c

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

@@ -1 +1 @@
-e994c69fda5eef94ae85d6dac5aec3d04fb6811c35c446c9d33236a449bd1c6c
+c76830df9dee3caba932ffaddaabce88ac7ef23b3957b3e8e570b4939dd58d9d

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

@@ -1 +1 @@
-c37f6a7ea9018ca636d0fd486a9d91cd397158615410de9b837ca9b8f9f593b7
+3a41a06d54939a9e85fcf6b0bf15b336f928a3caf66576bd2da62c5b8b177c1d

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

@@ -1 +1 @@
-1b298dfa5c1f2163d609ef0ccc3d42fafe78e69326002effe53abc4b82974749
+f30a8c0a7893519872628c001314efd567f87f4dfaf718a737ea3631b55881b0

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

@@ -1 +1 @@
-1e11a95e0909d18308d21a9a8448f8b2e427d240d5d8cd13d8ddbe6ba5009237
+cb65533984ffd8684c9e9f5ddeef92a8f387735c12310b25282ee7bbf2d73cd7

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

@@ -1 +1 @@
-d5cd77130cc97cffdbc742f04e3e1196f14160107b636806c6ef3c9b40724e84
+d11f9cb1130f3f3aaa89514bf47ec8ece9b2ca0edf1d82c11f80b262325f16be

crates/ide-plugin/tests/fixtures/semantic-tokens/dist/plugin.wasm.sources

@@ -1 +1 @@
-a0f74430b0a7d9ff48524d7aae4f8a0bd0fc60511e2a951dde9991b9bf7d15a9
+48ea4414469ebd70a89da8a5df7b7bddc4d32f5c50f1759ee3cea14558073c92

crates/ide-plugin/tests/fixtures/settings-pages/dist/plugin.wasm.sources

@@ -1 +1 @@
-65508f6e25bd0efc85820ae7d0f9037b58c778fa61e8498c5b9a5055cc38f6fc
+0c02303182be04ed3776fb532fd8b72e6057aa0fdb92b7d235000146fef4120e

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

@@ -1 +1 @@
-c86ed41d68c132f72eb8b5794f31b975492e5ad42e41b7823d1bf28ba118a262
+8162a70e848172663463119e6357984a73e54bc71a99b2845621d0733cf9333e

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

@@ -1 +1 @@
-3da1a09906d803234016b3f9c30a88b9b40bf3187fc73840ff60a2e05f504b48
+4524cab0ceac631153a945f6b76f7d40efd3c854740ae22c64580381e9532397

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

@@ -1 +1 @@
-39e7a805120ce6433750c32b1d670b3caba990f7b15aea866a29c23b01cba708
+a92f4def072ca4cc805414516ab4f046fc54bcf11394a5413a27ea151c156174