feat: override node bundled npm by specified version of npm

build.rs

@@ -187,8 +187,19 @@ fn codegen_registry() {
                     .collect::<Vec<_>>()
             })
             .unwrap_or_default();
+        let overrides = info
+            .get("overrides")
+            .map(|overrides| {
+                overrides
+                    .as_array()
+                    .unwrap()
+                    .iter()
+                    .map(|f| f.as_str().unwrap().to_string())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
         let rt = format!(
-            r#"RegistryTool{{short: "{short}", description: {description}, backends: &[{backends}], aliases: &[{aliases}], test: &{test}, os: &[{os}], depends: &[{depends}], idiomatic_files: &[{idiomatic_files}]}}"#,
+            r#"RegistryTool{{short: "{short}", description: {description}, backends: &[{backends}], aliases: &[{aliases}], test: &{test}, os: &[{os}], depends: &[{depends}], idiomatic_files: &[{idiomatic_files}], overrides: &[{overrides}]}}"#,
             description = description
                 .map(|d| format!("Some({})", raw_string_literal(&d)))
                 .unwrap_or("None".to_string()),
@@ -220,6 +231,11 @@ fn codegen_registry() {
                 .map(|f| format!("\"{f}\""))
                 .collect::<Vec<_>>()
                 .join(", "),
+            overrides = overrides
+                .iter()
+                .map(|f| format!("\"{f}\""))
+                .collect::<Vec<_>>()
+                .join(", "),
         );
         lines.push(format!(r#"    ("{short}", {rt}),"#));
         for alias in aliases {

e2e/registry/test_overrides

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+# Test 1: node defined before npm
+cat >mise.toml <<EOF
+[tools]
+node = "25.2.1"
+npm = "11.7.0"
+EOF
+
+mise install
+assert_contains "mise x -- npm --version" "11.7.0"
+
+# Test 2: npm defined before node
+cat >mise.toml <<EOF
+[tools]
+npm = "11.7.0"
+node = "25.2.1"
+EOF
+
+mise install
+assert_contains "mise x -- npm --version" "11.7.0"

registry.toml

@@ -3288,6 +3288,7 @@ description = "Find outdated or deprecated Helm charts running in your cluster"
 [tools.npm]
 backends = ["npm:npm"]
 description = "the package manager for JavaScript"
+overrides = ["node"]
 test = ["npm --version", "{{version}}"]
 
 [tools.nsc]

schema/mise-registry.json

@@ -125,6 +125,13 @@
             "type": "string"
           },
           "description": "Files that indicate this tool should be used in a project"
+        },
+        "overrides": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "List of tool IDs that this tool overrides. When a tool overrides another, its installation directory is placed earlier in PATH so its binaries take precedence over the overridden tools' binaries."
         }
       },
       "required": ["backends"],

src/registry.rs

@@ -24,6 +24,7 @@ pub struct RegistryTool {
     pub backends: &'static [RegistryBackend],
     #[allow(unused)]
     pub aliases: &'static [&'static str],
+    pub overrides: &'static [&'static str],
     pub test: &'static Option<(&'static str, &'static str)>,
     pub os: &'static [&'static str],
     pub depends: &'static [&'static str],

src/toolset/toolset_paths.rs

@@ -7,8 +7,10 @@ use std::sync::LazyLock as Lazy;
 
 use crate::config::Config;
 use crate::config::env_directive::EnvResults;
+use crate::registry::REGISTRY;
 use crate::toolset::Toolset;
 use crate::uv;
+use itertools::Itertools;
 
 // Cache Toolset::list_paths results across identical toolsets within a process.
 // Keyed by project_root plus sorted list of backend@version pairs currently installed.
@@ -21,21 +23,40 @@ impl Toolset {
         if let Some(root) = &config.project_root {
             key_parts.push(root.to_string_lossy().to_string());
         }
-        let mut installed: Vec<String> = self
-            .list_current_installed_versions(config)
-            .into_iter()
+        let mut installed = self.list_current_installed_versions(config);
+
+        let installed_strs: Vec<String> = installed
+            .iter()
             .map(|(p, tv)| format!("{}@{}", p.id(), tv.version))
+            .sorted()
             .collect();
-        installed.sort();
-        key_parts.extend(installed);
+        key_parts.extend(installed_strs);
+
         let cache_key = key_parts.join("|");
         if let Some(entry) = LIST_PATHS_CACHE.get(&cache_key) {
             trace!("toolset.list_paths hit cache");
             return entry.clone();
         }
 
+        installed.sort_by(|(a, _), (b, _)| {
+            let id_a = a.id();
+            let id_b = b.id();
+
+            if let Some(tool_a) = REGISTRY.get(id_a)
+                && tool_a.overrides.contains(&id_b)
+            {
+                return std::cmp::Ordering::Less;
+            }
+            if let Some(tool_b) = REGISTRY.get(id_b)
+                && tool_b.overrides.contains(&id_a)
+            {
+                return std::cmp::Ordering::Greater;
+            }
+            std::cmp::Ordering::Equal
+        });
+
         let mut paths: Vec<PathBuf> = Vec::new();
-        for (p, tv) in self.list_current_installed_versions(config).into_iter() {
+        for (p, tv) in installed {
             let start = std::time::Instant::now();
             let new_paths = p.list_bin_paths(config, &tv).await.unwrap_or_else(|e| {
                 warn!("Error listing bin paths for {tv}: {e:#}");