refactor: move ByonmNpmResolver to deno_resolver (#25937)

Some more slow progress on moving all the resolution code into
deno_resolver.

13 files changed, 95 insertions, 404 deletions

diff --git a/cli/factory.rs b/cli/factory.rs
index ffe7f8d2f..2cef87599 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -32,12 +32,13 @@ use crate::module_loader::ModuleLoadPreparer;
 use crate::node::CliCjsCodeAnalyzer;
 use crate::node::CliNodeCodeTranslator;
 use crate::npm::create_cli_npm_resolver;
+use crate::npm::CliByonmNpmResolverCreateOptions;
 use crate::npm::CliNpmResolver;
-use crate::npm::CliNpmResolverByonmCreateOptions;
 use crate::npm::CliNpmResolverCreateOptions;
 use crate::npm::CliNpmResolverManagedCreateOptions;
 use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::resolver::CjsResolutionStore;
+use crate::resolver::CliDenoResolverFs;
 use crate::resolver::CliGraphResolver;
 use crate::resolver::CliGraphResolverOptions;
 use crate::resolver::CliNodeResolver;
@@ -361,8 +362,8 @@ impl CliFactory {
         let cli_options = self.cli_options()?;
         // For `deno install` we want to force the managed resolver so it can set up `node_modules/` directory.
         create_cli_npm_resolver(if cli_options.use_byonm() && !matches!(cli_options.sub_command(), DenoSubcommand::Install(_) | DenoSubcommand::Add(_) | DenoSubcommand::Remove(_)) {
-          CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
-            fs: fs.clone(),
+          CliNpmResolverCreateOptions::Byonm(CliByonmNpmResolverCreateOptions {
+            fs: CliDenoResolverFs(fs.clone()),
             root_node_modules_dir: Some(match cli_options.node_modules_dir_path() {
               Some(node_modules_path) => node_modules_path.to_path_buf(),
               // path needs to be canonicalized for node resolution
diff --git a/cli/lsp/resolver.rs b/cli/lsp/resolver.rs
index f98b23a3f..a5dfd25a6 100644
--- a/cli/lsp/resolver.rs
+++ b/cli/lsp/resolver.rs
@@ -42,13 +42,14 @@ use crate::lsp::config::Config;
 use crate::lsp::config::ConfigData;
 use crate::lsp::logging::lsp_warn;
 use crate::npm::create_cli_npm_resolver_for_lsp;
+use crate::npm::CliByonmNpmResolverCreateOptions;
 use crate::npm::CliNpmResolver;
-use crate::npm::CliNpmResolverByonmCreateOptions;
 use crate::npm::CliNpmResolverCreateOptions;
 use crate::npm::CliNpmResolverManagedCreateOptions;
 use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::npm::ManagedCliNpmResolver;
 use crate::resolver::CjsResolutionStore;
+use crate::resolver::CliDenoResolverFs;
 use crate::resolver::CliGraphResolver;
 use crate::resolver::CliGraphResolverOptions;
 use crate::resolver::CliNodeResolver;
@@ -439,8 +440,8 @@ async fn create_npm_resolver(
 ) -> Option<Arc<dyn CliNpmResolver>> {
   let enable_byonm = config_data.map(|d| d.byonm).unwrap_or(false);
   let options = if enable_byonm {
-    CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
-      fs: Arc::new(deno_fs::RealFs),
+    CliNpmResolverCreateOptions::Byonm(CliByonmNpmResolverCreateOptions {
+      fs: CliDenoResolverFs(Arc::new(deno_fs::RealFs)),
       root_node_modules_dir: config_data.and_then(|config_data| {
         config_data.node_modules_dir.clone().or_else(|| {
           url_to_file_path(&config_data.scope)
diff --git a/cli/npm/byonm.rs b/cli/npm/byonm.rs
index 83c406765..ceef68135 100644
--- a/cli/npm/byonm.rs
+++ b/cli/npm/byonm.rs
@@ -1,276 +1,36 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-use std::borrow::Cow;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use deno_ast::ModuleSpecifier;
-use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
-use deno_package_json::PackageJsonDepValue;
-use deno_path_util::url_to_file_path;
-use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::DenoPkgJsonFsAdapter;
+use deno_core::url::Url;
+use deno_resolver::npm::ByonmNpmResolver;
+use deno_resolver::npm::ByonmNpmResolverCreateOptions;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeRequireResolver;
-use deno_runtime::deno_node::PackageJson;
 use deno_runtime::ops::process::NpmProcessStateProvider;
 use deno_semver::package::PackageReq;
-use deno_semver::Version;
-use node_resolver::errors::PackageFolderResolveError;
-use node_resolver::errors::PackageFolderResolveIoError;
-use node_resolver::errors::PackageJsonLoadError;
-use node_resolver::errors::PackageNotFoundError;
-use node_resolver::load_pkg_json;
 use node_resolver::NpmResolver;
 
 use crate::args::NpmProcessState;
 use crate::args::NpmProcessStateKind;
-use crate::util::fs::canonicalize_path_maybe_not_exists_with_fs;
+use crate::resolver::CliDenoResolverFs;
 
-use super::managed::normalize_pkg_name_for_node_modules_deno_folder;
 use super::CliNpmResolver;
 use super::InnerCliNpmResolverRef;
 
-pub struct CliNpmResolverByonmCreateOptions {
-  pub fs: Arc<dyn FileSystem>,
-  // todo(dsherret): investigate removing this
-  pub root_node_modules_dir: Option<PathBuf>,
-}
-
-pub fn create_byonm_npm_resolver(
-  options: CliNpmResolverByonmCreateOptions,
-) -> Arc<dyn CliNpmResolver> {
-  Arc::new(ByonmCliNpmResolver {
-    fs: options.fs,
-    root_node_modules_dir: options.root_node_modules_dir,
-  })
-}
+pub type CliByonmNpmResolverCreateOptions =
+  ByonmNpmResolverCreateOptions<CliDenoResolverFs>;
+pub type CliByonmNpmResolver = ByonmNpmResolver<CliDenoResolverFs>;
 
+// todo(dsherret): the services hanging off `CliNpmResolver` doesn't seem ideal. We should probably decouple.
 #[derive(Debug)]
-pub struct ByonmCliNpmResolver {
-  fs: Arc<dyn FileSystem>,
-  root_node_modules_dir: Option<PathBuf>,
-}
-
-impl ByonmCliNpmResolver {
-  fn load_pkg_json(
-    &self,
-    path: &Path,
-  ) -> Result<Option<Arc<PackageJson>>, PackageJsonLoadError> {
-    load_pkg_json(&DenoPkgJsonFsAdapter(self.fs.as_ref()), path)
-  }
-
-  /// Finds the ancestor package.json that contains the specified dependency.
-  pub fn find_ancestor_package_json_with_dep(
-    &self,
-    dep_name: &str,
-    referrer: &ModuleSpecifier,
-  ) -> Option<Arc<PackageJson>> {
-    let referrer_path = referrer.to_file_path().ok()?;
-    let mut current_folder = referrer_path.parent()?;
-    loop {
-      let pkg_json_path = current_folder.join("package.json");
-      if let Ok(Some(pkg_json)) = self.load_pkg_json(&pkg_json_path) {
-        if let Some(deps) = &pkg_json.dependencies {
-          if deps.contains_key(dep_name) {
-            return Some(pkg_json);
-          }
-        }
-        if let Some(deps) = &pkg_json.dev_dependencies {
-          if deps.contains_key(dep_name) {
-            return Some(pkg_json);
-          }
-        }
-      }
-
-      if let Some(parent) = current_folder.parent() {
-        current_folder = parent;
-      } else {
-        return None;
-      }
-    }
-  }
-
-  fn resolve_pkg_json_and_alias_for_req(
-    &self,
-    req: &PackageReq,
-    referrer: &ModuleSpecifier,
-  ) -> Result<Option<(Arc<PackageJson>, String)>, AnyError> {
-    fn resolve_alias_from_pkg_json(
-      req: &PackageReq,
-      pkg_json: &PackageJson,
-    ) -> Option<String> {
-      let deps = pkg_json.resolve_local_package_json_deps();
-      for (key, value) in deps {
-        if let Ok(value) = value {
-          match value {
-            PackageJsonDepValue::Req(dep_req) => {
-              if dep_req.name == req.name
-                && dep_req.version_req.intersects(&req.version_req)
-              {
-                return Some(key);
-              }
-            }
-            PackageJsonDepValue::Workspace(_workspace) => {
-              if key == req.name && req.version_req.tag() == Some("workspace") {
-                return Some(key);
-              }
-            }
-          }
-        }
-      }
-      None
-    }
-
-    // attempt to resolve the npm specifier from the referrer's package.json,
-    if let Ok(file_path) = url_to_file_path(referrer) {
-      let mut current_path = file_path.as_path();
-      while let Some(dir_path) = current_path.parent() {
-        let package_json_path = dir_path.join("package.json");
-        if let Some(pkg_json) = self.load_pkg_json(&package_json_path)? {
-          if let Some(alias) =
-            resolve_alias_from_pkg_json(req, pkg_json.as_ref())
-          {
-            return Ok(Some((pkg_json, alias)));
-          }
-        }
-        current_path = dir_path;
-      }
-    }
-
-    // otherwise, fall fallback to the project's package.json
-    if let Some(root_node_modules_dir) = &self.root_node_modules_dir {
-      let root_pkg_json_path =
-        root_node_modules_dir.parent().unwrap().join("package.json");
-      if let Some(pkg_json) = self.load_pkg_json(&root_pkg_json_path)? {
-        if let Some(alias) = resolve_alias_from_pkg_json(req, pkg_json.as_ref())
-        {
-          return Ok(Some((pkg_json, alias)));
-        }
-      }
-    }
-
-    Ok(None)
-  }
-
-  fn resolve_folder_in_root_node_modules(
-    &self,
-    req: &PackageReq,
-  ) -> Option<PathBuf> {
-    // now check if node_modules/.deno/ matches this constraint
-    let root_node_modules_dir = self.root_node_modules_dir.as_ref()?;
-    let node_modules_deno_dir = root_node_modules_dir.join(".deno");
-    let Ok(entries) = self.fs.read_dir_sync(&node_modules_deno_dir) else {
-      return None;
-    };
-    let search_prefix = format!(
-      "{}@",
-      normalize_pkg_name_for_node_modules_deno_folder(&req.name)
-    );
-    let mut best_version = None;
-
-    // example entries:
-    // - @denotest+add@1.0.0
-    // - @denotest+add@1.0.0_1
-    for entry in entries {
-      if !entry.is_directory {
-        continue;
-      }
-      let Some(version_and_copy_idx) = entry.name.strip_prefix(&search_prefix)
-      else {
-        continue;
-      };
-      let version = version_and_copy_idx
-        .rsplit_once('_')
-        .map(|(v, _)| v)
-        .unwrap_or(version_and_copy_idx);
-      let Ok(version) = Version::parse_from_npm(version) else {
-        continue;
-      };
-      if req.version_req.matches(&version) {
-        if let Some((best_version_version, _)) = &best_version {
-          if version > *best_version_version {
-            best_version = Some((version, entry.name));
-          }
-        } else {
-          best_version = Some((version, entry.name));
-        }
-      }
-    }
-
-    best_version.map(|(_version, entry_name)| {
-      join_package_name(
-        &node_modules_deno_dir.join(entry_name).join("node_modules"),
-        &req.name,
-      )
-    })
-  }
-}
-
-impl NpmResolver for ByonmCliNpmResolver {
-  fn resolve_package_folder_from_package(
-    &self,
-    name: &str,
-    referrer: &ModuleSpecifier,
-  ) -> Result<PathBuf, PackageFolderResolveError> {
-    fn inner(
-      fs: &dyn FileSystem,
-      name: &str,
-      referrer: &ModuleSpecifier,
-    ) -> Result<PathBuf, PackageFolderResolveError> {
-      let maybe_referrer_file = url_to_file_path(referrer).ok();
-      let maybe_start_folder =
-        maybe_referrer_file.as_ref().and_then(|f| f.parent());
-      if let Some(start_folder) = maybe_start_folder {
-        for current_folder in start_folder.ancestors() {
-          let node_modules_folder = if current_folder.ends_with("node_modules")
-          {
-            Cow::Borrowed(current_folder)
-          } else {
-            Cow::Owned(current_folder.join("node_modules"))
-          };
+struct CliByonmWrapper(Arc<CliByonmNpmResolver>);
 
-          let sub_dir = join_package_name(&node_modules_folder, name);
-          if fs.is_dir_sync(&sub_dir) {
-            return Ok(sub_dir);
-          }
-        }
-      }
-
-      Err(
-        PackageNotFoundError {
-          package_name: name.to_string(),
-          referrer: referrer.clone(),
-          referrer_extra: None,
-        }
-        .into(),
-      )
-    }
-
-    let path = inner(&*self.fs, name, referrer)?;
-    self.fs.realpath_sync(&path).map_err(|err| {
-      PackageFolderResolveIoError {
-        package_name: name.to_string(),
-        referrer: referrer.clone(),
-        source: err.into_io_error(),
-      }
-      .into()
-    })
-  }
-
-  fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
-    specifier.scheme() == "file"
-      && specifier
-        .path()
-        .to_ascii_lowercase()
-        .contains("/node_modules/")
-  }
-}
-
-impl NodeRequireResolver for ByonmCliNpmResolver {
+impl NodeRequireResolver for CliByonmWrapper {
   fn ensure_read_permission(
     &self,
     permissions: &mut dyn NodePermissions,
@@ -286,110 +46,54 @@ impl NodeRequireResolver for ByonmCliNpmResolver {
   }
 }
 
-impl NpmProcessStateProvider for ByonmCliNpmResolver {
+impl NpmProcessStateProvider for CliByonmWrapper {
   fn get_npm_process_state(&self) -> String {
     serde_json::to_string(&NpmProcessState {
       kind: NpmProcessStateKind::Byonm,
       local_node_modules_path: self
-        .root_node_modules_dir
-        .as_ref()
+        .0
+        .root_node_modules_dir()
         .map(|p| p.to_string_lossy().to_string()),
     })
     .unwrap()
   }
 }
 
-impl CliNpmResolver for ByonmCliNpmResolver {
+impl CliNpmResolver for CliByonmNpmResolver {
   fn into_npm_resolver(self: Arc<Self>) -> Arc<dyn NpmResolver> {
     self
   }
 
   fn into_require_resolver(self: Arc<Self>) -> Arc<dyn NodeRequireResolver> {
-    self
+    Arc::new(CliByonmWrapper(self))
   }
 
   fn into_process_state_provider(
     self: Arc<Self>,
   ) -> Arc<dyn NpmProcessStateProvider> {
-    self
+    Arc::new(CliByonmWrapper(self))
   }
 
   fn clone_snapshotted(&self) -> Arc<dyn CliNpmResolver> {
-    Arc::new(Self {
-      fs: self.fs.clone(),
-      root_node_modules_dir: self.root_node_modules_dir.clone(),
-    })
+    Arc::new(self.clone())
   }
 
   fn as_inner(&self) -> InnerCliNpmResolverRef {
     InnerCliNpmResolverRef::Byonm(self)
   }
 
-  fn root_node_modules_path(&self) -> Option<&PathBuf> {
-    self.root_node_modules_dir.as_ref()
+  fn root_node_modules_path(&self) -> Option<&Path> {
+    self.root_node_modules_dir()
   }
 
   fn resolve_pkg_folder_from_deno_module_req(
     &self,
     req: &PackageReq,
-    referrer: &ModuleSpecifier,
+    referrer: &Url,
   ) -> Result<PathBuf, AnyError> {
-    fn node_resolve_dir(
-      fs: &dyn FileSystem,
-      alias: &str,
-      start_dir: &Path,
-    ) -> Result<Option<PathBuf>, AnyError> {
-      for ancestor in start_dir.ancestors() {
-        let node_modules_folder = ancestor.join("node_modules");
-        let sub_dir = join_package_name(&node_modules_folder, alias);
-        if fs.is_dir_sync(&sub_dir) {
-          return Ok(Some(canonicalize_path_maybe_not_exists_with_fs(
-            &sub_dir, fs,
-          )?));
-        }
-      }
-      Ok(None)
-    }
-
-    // now attempt to resolve if it's found in any package.json
-    let maybe_pkg_json_and_alias =
-      self.resolve_pkg_json_and_alias_for_req(req, referrer)?;
-    match maybe_pkg_json_and_alias {
-      Some((pkg_json, alias)) => {
-        // now try node resolution
-        if let Some(resolved) =
-          node_resolve_dir(self.fs.as_ref(), &alias, pkg_json.dir_path())?
-        {
-          return Ok(resolved);
-        }
-
-        bail!(
-          concat!(
-            "Could not find \"{}\" in a node_modules folder. ",
-            "Deno expects the node_modules/ directory to be up to date. ",
-            "Did you forget to run `deno install`?"
-          ),
-          alias,
-        );
-      }
-      None => {
-        // now check if node_modules/.deno/ matches this constraint
-        if let Some(folder) = self.resolve_folder_in_root_node_modules(req) {
-          return Ok(folder);
-        }
-
-        bail!(
-          concat!(
-            "Could not find a matching package for 'npm:{}' in the node_modules ",
-            "directory. Ensure you have all your JSR and npm dependencies listed ",
-            "in your deno.json or package.json, then run `deno install`. Alternatively, ",
-            r#"turn on auto-install by specifying `"nodeModulesDir": "auto"` in your "#,
-            "deno.json file."
-          ),
-          req,
-        );
-      }
-    }
+    ByonmNpmResolver::resolve_pkg_folder_from_deno_module_req(
+      self, req, referrer,
+    )
   }
 
   fn check_state_hash(&self) -> Option<u64> {
@@ -398,12 +102,3 @@ impl CliNpmResolver for ByonmCliNpmResolver {
     None
   }
 }
-
-fn join_package_name(path: &Path, package_name: &str) -> PathBuf {
-  let mut path = path.to_path_buf();
-  // ensure backslashes are used on windows
-  for part in package_name.split('/') {
-    path = path.join(part);
-  }
-  path
-}
diff --git a/cli/npm/managed/mod.rs b/cli/npm/managed/mod.rs
index e3ac5e1af..62af3e4aa 100644
--- a/cli/npm/managed/mod.rs
+++ b/cli/npm/managed/mod.rs
@@ -47,7 +47,6 @@ use self::cache::NpmCache;
 use self::registry::CliNpmRegistryApi;
 use self::resolution::NpmResolution;
 use self::resolvers::create_npm_fs_resolver;
-pub use self::resolvers::normalize_pkg_name_for_node_modules_deno_folder;
 use self::resolvers::NpmPackageFsResolver;
 
 use super::CliNpmResolver;
@@ -575,7 +574,7 @@ impl NpmProcessStateProvider for ManagedCliNpmResolver {
   fn get_npm_process_state(&self) -> String {
     npm_process_state(
       self.resolution.serialized_valid_snapshot(),
-      self.fs_resolver.node_modules_path().map(|p| p.as_path()),
+      self.fs_resolver.node_modules_path(),
     )
   }
 }
@@ -632,7 +631,7 @@ impl CliNpmResolver for ManagedCliNpmResolver {
     InnerCliNpmResolverRef::Managed(self)
   }
 
-  fn root_node_modules_path(&self) -> Option<&PathBuf> {
+  fn root_node_modules_path(&self) -> Option<&Path> {
     self.fs_resolver.node_modules_path()
   }
 
diff --git a/cli/npm/managed/resolvers/common.rs b/cli/npm/managed/resolvers/common.rs
index 620daf4b3..8df4debc5 100644
--- a/cli/npm/managed/resolvers/common.rs
+++ b/cli/npm/managed/resolvers/common.rs
@@ -33,7 +33,7 @@ pub trait NpmPackageFsResolver: Send + Sync {
   fn root_dir_url(&self) -> &Url;
 
   /// The local node_modules folder if it is applicable to the implementation.
-  fn node_modules_path(&self) -> Option<&PathBuf>;
+  fn node_modules_path(&self) -> Option<&Path>;
 
   fn maybe_package_folder(&self, package_id: &NpmPackageId) -> Option<PathBuf>;
 
diff --git a/cli/npm/managed/resolvers/global.rs b/cli/npm/managed/resolvers/global.rs
index 187e6b277..ca5722c86 100644
--- a/cli/npm/managed/resolvers/global.rs
+++ b/cli/npm/managed/resolvers/global.rs
@@ -73,7 +73,7 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
     self.cache.root_dir_url()
   }
 
-  fn node_modules_path(&self) -> Option<&PathBuf> {
+  fn node_modules_path(&self) -> Option<&Path> {
     None
   }
 
diff --git a/cli/npm/managed/resolvers/local.rs b/cli/npm/managed/resolvers/local.rs
index 297fcab23..59ba27d05 100644
--- a/cli/npm/managed/resolvers/local.rs
+++ b/cli/npm/managed/resolvers/local.rs
@@ -20,7 +20,6 @@ use crate::colors;
 use async_trait::async_trait;
 use deno_ast::ModuleSpecifier;
 use deno_cache_dir::npm::mixed_case_package_name_decode;
-use deno_cache_dir::npm::mixed_case_package_name_encode;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures::stream::FuturesUnordered;
@@ -32,6 +31,7 @@ use deno_npm::NpmPackageCacheFolderId;
 use deno_npm::NpmPackageId;
 use deno_npm::NpmResolutionPackage;
 use deno_npm::NpmSystemInfo;
+use deno_resolver::npm::normalize_pkg_name_for_node_modules_deno_folder;
 use deno_runtime::deno_fs;
 use deno_runtime::deno_node::NodePermissions;
 use deno_semver::package::PackageNv;
@@ -159,8 +159,8 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
     &self.root_node_modules_url
   }
 
-  fn node_modules_path(&self) -> Option<&PathBuf> {
-    Some(&self.root_node_modules_path)
+  fn node_modules_path(&self) -> Option<&Path> {
+    Some(self.root_node_modules_path.as_ref())
   }
 
   fn maybe_package_folder(&self, id: &NpmPackageId) -> Option<PathBuf> {
@@ -920,20 +920,6 @@ impl SetupCache {
   }
 }
 
-/// Normalizes a package name for use at `node_modules/.deno/<pkg-name>@<version>[_<copy_index>]`
-pub fn normalize_pkg_name_for_node_modules_deno_folder(name: &str) -> Cow<str> {
-  let name = if name.to_lowercase() == name {
-    Cow::Borrowed(name)
-  } else {
-    Cow::Owned(format!("_{}", mixed_case_package_name_encode(name)))
-  };
-  if name.starts_with('@') {
-    name.replace('/', "+").into()
-  } else {
-    name
-  }
-}
-
 fn get_package_folder_id_folder_name(
   folder_id: &NpmPackageCacheFolderId,
 ) -> String {
diff --git a/cli/npm/managed/resolvers/mod.rs b/cli/npm/managed/resolvers/mod.rs
index 234a6e4db..36d795ee7 100644
--- a/cli/npm/managed/resolvers/mod.rs
+++ b/cli/npm/managed/resolvers/mod.rs
@@ -15,7 +15,6 @@ use crate::args::NpmInstallDepsProvider;
 use crate::util::progress_bar::ProgressBar;
 
 pub use self::common::NpmPackageFsResolver;
-pub use self::local::normalize_pkg_name_for_node_modules_deno_folder;
 
 use self::global::GlobalNpmPackageResolver;
 use self::local::LocalNpmPackageResolver;
diff --git a/cli/npm/mod.rs b/cli/npm/mod.rs
index 2c9ee20bc..1e3c752ae 100644
--- a/cli/npm/mod.rs
+++ b/cli/npm/mod.rs
@@ -4,6 +4,7 @@ mod byonm;
 mod common;
 mod managed;
 
+use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
@@ -12,6 +13,7 @@ use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
 use deno_core::serde_json;
 use deno_npm::registry::NpmPackageInfo;
+use deno_resolver::npm::ByonmNpmResolver;
 use deno_runtime::deno_node::NodeRequireResolver;
 use deno_runtime::ops::process::NpmProcessStateProvider;
 use deno_semver::package::PackageNv;
@@ -21,15 +23,15 @@ use node_resolver::NpmResolver;
 use crate::args::npm_registry_url;
 use crate::file_fetcher::FileFetcher;
 
-pub use self::byonm::ByonmCliNpmResolver;
-pub use self::byonm::CliNpmResolverByonmCreateOptions;
+pub use self::byonm::CliByonmNpmResolver;
+pub use self::byonm::CliByonmNpmResolverCreateOptions;
 pub use self::managed::CliNpmResolverManagedCreateOptions;
 pub use self::managed::CliNpmResolverManagedSnapshotOption;
 pub use self::managed::ManagedCliNpmResolver;
 
 pub enum CliNpmResolverCreateOptions {
   Managed(CliNpmResolverManagedCreateOptions),
-  Byonm(CliNpmResolverByonmCreateOptions),
+  Byonm(CliByonmNpmResolverCreateOptions),
 }
 
 pub async fn create_cli_npm_resolver_for_lsp(
@@ -40,7 +42,7 @@ pub async fn create_cli_npm_resolver_for_lsp(
     Managed(options) => {
       managed::create_managed_npm_resolver_for_lsp(options).await
     }
-    Byonm(options) => byonm::create_byonm_npm_resolver(options),
+    Byonm(options) => Arc::new(ByonmNpmResolver::new(options)),
   }
 }
 
@@ -50,14 +52,14 @@ pub async fn create_cli_npm_resolver(
   use CliNpmResolverCreateOptions::*;
   match options {
     Managed(options) => managed::create_managed_npm_resolver(options).await,
-    Byonm(options) => Ok(byonm::create_byonm_npm_resolver(options)),
+    Byonm(options) => Ok(Arc::new(ByonmNpmResolver::new(options))),
   }
 }
 
 pub enum InnerCliNpmResolverRef<'a> {
   Managed(&'a ManagedCliNpmResolver),
   #[allow(dead_code)]
-  Byonm(&'a ByonmCliNpmResolver),
+  Byonm(&'a CliByonmNpmResolver),
 }
 
 pub trait CliNpmResolver: NpmResolver {
@@ -78,14 +80,14 @@ pub trait CliNpmResolver: NpmResolver {
     }
   }
 
-  fn as_byonm(&self) -> Option<&ByonmCliNpmResolver> {
+  fn as_byonm(&self) -> Option<&CliByonmNpmResolver> {
     match self.as_inner() {
       InnerCliNpmResolverRef::Managed(_) => None,
       InnerCliNpmResolverRef::Byonm(inner) => Some(inner),
     }
   }
 
-  fn root_node_modules_path(&self) -> Option<&PathBuf>;
+  fn root_node_modules_path(&self) -> Option<&Path>;
 
   fn resolve_pkg_folder_from_deno_module_req(
     &self,
diff --git a/cli/resolver.rs b/cli/resolver.rs
index 211f8aba1..7804261b8 100644
--- a/cli/resolver.rs
+++ b/cli/resolver.rs
@@ -61,6 +61,46 @@ pub struct ModuleCodeStringSource {
   pub media_type: MediaType,
 }
 
+#[derive(Debug, Clone)]
+pub struct CliDenoResolverFs(pub Arc<dyn FileSystem>);
+
+impl deno_resolver::fs::DenoResolverFs for CliDenoResolverFs {
+  fn read_to_string_lossy(&self, path: &Path) -> std::io::Result<String> {
+    self
+      .0
+      .read_text_file_lossy_sync(path, None)
+      .map_err(|e| e.into_io_error())
+  }
+
+  fn realpath_sync(&self, path: &Path) -> std::io::Result<PathBuf> {
+    self.0.realpath_sync(path).map_err(|e| e.into_io_error())
+  }
+
+  fn is_dir_sync(&self, path: &Path) -> bool {
+    self.0.is_dir_sync(path)
+  }
+
+  fn read_dir_sync(
+    &self,
+    dir_path: &Path,
+  ) -> std::io::Result<Vec<deno_resolver::fs::DirEntry>> {
+    self
+      .0
+      .read_dir_sync(dir_path)
+      .map(|entries| {
+        entries
+          .into_iter()
+          .map(|e| deno_resolver::fs::DirEntry {
+            name: e.name,
+            is_file: e.is_file,
+            is_directory: e.is_directory,
+          })
+          .collect::<Vec<_>>()
+      })
+      .map_err(|err| err.into_io_error())
+  }
+}
+
 #[derive(Debug)]
 pub struct CliNodeResolver {
   cjs_resolutions: Arc<CjsResolutionStore>,
diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index 56f76ffb9..258de0dad 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -60,11 +60,12 @@ use crate::cache::RealDenoCacheEnv;
 use crate::http_util::HttpClientProvider;
 use crate::node::CliCjsCodeAnalyzer;
 use crate::npm::create_cli_npm_resolver;
-use crate::npm::CliNpmResolverByonmCreateOptions;
+use crate::npm::CliByonmNpmResolverCreateOptions;
 use crate::npm::CliNpmResolverCreateOptions;
 use crate::npm::CliNpmResolverManagedCreateOptions;
 use crate::npm::CliNpmResolverManagedSnapshotOption;
 use crate::resolver::CjsResolutionStore;
+use crate::resolver::CliDenoResolverFs;
 use crate::resolver::CliNodeResolver;
 use crate::resolver::NpmModuleLoader;
 use crate::util::progress_bar::ProgressBar;
@@ -530,8 +531,8 @@ pub async fn run(
       let fs = Arc::new(DenoCompileFileSystem::new(vfs))
         as Arc<dyn deno_fs::FileSystem>;
       let npm_resolver = create_cli_npm_resolver(
-        CliNpmResolverCreateOptions::Byonm(CliNpmResolverByonmCreateOptions {
-          fs: fs.clone(),
+        CliNpmResolverCreateOptions::Byonm(CliByonmNpmResolverCreateOptions {
+          fs: CliDenoResolverFs(fs.clone()),
           root_node_modules_dir,
         }),
       )
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index a5a5027d0..464b65d98 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -190,9 +190,7 @@ async fn run_task(opts: RunTaskOptions<'_>) -> Result<i32, AnyError> {
     custom_commands,
     init_cwd: opts.cli_options.initial_cwd(),
     argv: cli_options.argv(),
-    root_node_modules_dir: npm_resolver
-      .root_node_modules_path()
-      .map(|p| p.as_path()),
+    root_node_modules_dir: npm_resolver.root_node_modules_path(),
   })
   .await
 }
diff --git a/cli/util/fs.rs b/cli/util/fs.rs
index 9734d417e..a021ec19c 100644
--- a/cli/util/fs.rs
+++ b/cli/util/fs.rs
@@ -20,7 +20,6 @@ use deno_core::error::AnyError;
 use deno_core::unsync::spawn_blocking;
 use deno_core::ModuleSpecifier;
 use deno_runtime::deno_fs::FileSystem;
-use deno_runtime::deno_node::PathClean;
 
 use crate::util::path::get_atomic_file_path;
 use crate::util::progress_bar::ProgressBar;
@@ -290,48 +289,18 @@ pub fn canonicalize_path(path: &Path) -> Result<PathBuf, Error> {
 pub fn canonicalize_path_maybe_not_exists(
   path: &Path,
 ) -> Result<PathBuf, Error> {
-  canonicalize_path_maybe_not_exists_with_custom_fn(path, canonicalize_path)
+  deno_path_util::canonicalize_path_maybe_not_exists(path, &canonicalize_path)
 }
 
 pub fn canonicalize_path_maybe_not_exists_with_fs(
   path: &Path,
   fs: &dyn FileSystem,
 ) -> Result<PathBuf, Error> {
-  canonicalize_path_maybe_not_exists_with_custom_fn(path, |path| {
+  deno_path_util::canonicalize_path_maybe_not_exists(path, &|path| {
     fs.realpath_sync(path).map_err(|err| err.into_io_error())
   })
 }
 
-fn canonicalize_path_maybe_not_exists_with_custom_fn(
-  path: &Path,
-  canonicalize: impl Fn(&Path) -> Result<PathBuf, Error>,
-) -> Result<PathBuf, Error> {
-  let path = path.to_path_buf().clean();
-  let mut path = path.as_path();
-  let mut names_stack = Vec::new();
-  loop {
-    match canonicalize(path) {
-      Ok(mut canonicalized_path) => {
-        for name in names_stack.into_iter().rev() {
-          canonicalized_path = canonicalized_path.join(name);
-        }
-        return Ok(canonicalized_path);
-      }
-      Err(err) if err.kind() == ErrorKind::NotFound => {
-        names_stack.push(match path.file_name() {
-          Some(name) => name.to_owned(),
-          None => return Err(err),
-        });
-        path = match path.parent() {
-          Some(parent) => parent,
-          None => return Err(err),
-        };
-      }
-      Err(err) => return Err(err),
-    }
-  }
-}
-
 /// Collects module specifiers that satisfy the given predicate as a file path, by recursively walking `include`.
 /// Specifiers that start with http and https are left intact.
 /// Note: This ignores all .git and node_modules folders.