refactor(ext/node): remove dependency on deno_npm and deno_semver (#20718)

This is required from BYONM (bring your own node_modules).

Part of #18967

19 files changed, 193 insertions, 115 deletions

diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index e4ac49842..cb150e5db 100644
--- a/cli/Cargo.toml
+++ b/cli/Cargo.toml
@@ -54,9 +54,9 @@ deno_emit = "=0.28.0"
 deno_graph = "=0.55.0"
 deno_lint = { version = "=0.51.0", features = ["docs"] }
 deno_lockfile.workspace = true
-deno_npm.workspace = true
+deno_npm = "0.15.1"
 deno_runtime = { workspace = true, features = ["dont_create_runtime_snapshot", "exclude_runtime_main_js", "include_js_files_for_snapshotting"] }
-deno_semver.workspace = true
+deno_semver = "0.5.1"
 deno_task_shell = "=0.13.2"
 eszip = "=0.53.0"
 napi_sym.workspace = true
diff --git a/cli/factory.rs b/cli/factory.rs
index 28788093b..6acf248a8 100644
--- a/cli/factory.rs
+++ b/cli/factory.rs
@@ -623,10 +623,11 @@ impl CliFactory {
     &self,
   ) -> Result<CliMainWorkerFactory, AnyError> {
     let node_resolver = self.node_resolver().await?;
+    let npm_resolver = self.npm_resolver().await?;
     let fs = self.fs();
     Ok(CliMainWorkerFactory::new(
       StorageKeyResolver::from_options(&self.options),
-      self.npm_resolver().await?.clone(),
+      npm_resolver.clone(),
       node_resolver.clone(),
       self.blob_store().clone(),
       Box::new(CliModuleLoaderFactory::new(
@@ -641,6 +642,7 @@ impl CliFactory {
           self.node_code_translator().await?.clone(),
           fs.clone(),
           node_resolver.clone(),
+          npm_resolver.clone(),
         ),
       )),
       self.root_cert_store_provider().clone(),
diff --git a/cli/lsp/analysis.rs b/cli/lsp/analysis.rs
index 7a0c11212..1b11deca8 100644
--- a/cli/lsp/analysis.rs
+++ b/cli/lsp/analysis.rs
@@ -199,9 +199,8 @@ impl<'a> TsResponseImportMapper<'a> {
     }
 
     if self.npm_resolver.in_npm_package(specifier) {
-      if let Ok(Some(pkg_id)) = self
-        .npm_resolver
-        .resolve_package_id_from_specifier(specifier)
+      if let Ok(Some(pkg_id)) =
+        self.npm_resolver.resolve_pkg_id_from_specifier(specifier)
       {
         let pkg_reqs =
           self.npm_resolution.resolve_pkg_reqs_from_pkg_id(&pkg_id);
@@ -254,7 +253,7 @@ impl<'a> TsResponseImportMapper<'a> {
     let specifier_path = specifier.to_file_path().ok()?;
     let root_folder = self
       .npm_resolver
-      .resolve_package_folder_from_specifier(specifier)
+      .resolve_pkg_folder_from_specifier(specifier)
       .ok()
       .flatten()?;
     let package_json_path = root_folder.join("package.json");
diff --git a/cli/lsp/diagnostics.rs b/cli/lsp/diagnostics.rs
index 43ae35f54..183901fb0 100644
--- a/cli/lsp/diagnostics.rs
+++ b/cli/lsp/diagnostics.rs
@@ -800,8 +800,8 @@ fn generate_lint_diagnostics(
       }
 
       // ignore any npm package files
-      if let Some(node_resolver) = &snapshot.maybe_node_resolver {
-        if node_resolver.in_npm_package(document.specifier()) {
+      if let Some(npm) = &snapshot.npm {
+        if npm.node_resolver.in_npm_package(document.specifier()) {
           continue;
         }
       }
@@ -1237,10 +1237,10 @@ fn diagnose_resolution(
       } else if let Ok(pkg_ref) =
         NpmPackageReqReference::from_specifier(specifier)
       {
-        if let Some(npm_resolver) = &snapshot.maybe_npm_resolver {
+        if let Some(npm) = &snapshot.npm {
           // show diagnostics for npm package references that aren't cached
           let req = pkg_ref.into_inner().req;
-          if !npm_resolver.is_pkg_req_folder_cached(&req) {
+          if !npm.npm_resolver.is_pkg_req_folder_cached(&req) {
             diagnostics
               .push(DenoDiagnostic::NoCacheNpm(req, specifier.clone()));
           }
@@ -1250,10 +1250,10 @@ fn diagnose_resolution(
         if !deno_node::is_builtin_node_module(module_name) {
           diagnostics
             .push(DenoDiagnostic::InvalidNodeSpecifier(specifier.clone()));
-        } else if let Some(npm_resolver) = &snapshot.maybe_npm_resolver {
+        } else if let Some(npm) = &snapshot.npm {
           // check that a @types/node package exists in the resolver
           let types_node_req = PackageReq::from_str("@types/node").unwrap();
-          if !npm_resolver.is_pkg_req_folder_cached(&types_node_req) {
+          if !npm.npm_resolver.is_pkg_req_folder_cached(&types_node_req) {
             diagnostics.push(DenoDiagnostic::NoCacheNpm(
               types_node_req,
               ModuleSpecifier::parse("npm:@types/node").unwrap(),
@@ -1291,8 +1291,8 @@ fn diagnose_dependency(
   dependency_key: &str,
   dependency: &deno_graph::Dependency,
 ) {
-  if let Some(npm_resolver) = &snapshot.maybe_npm_resolver {
-    if npm_resolver.in_npm_package(referrer) {
+  if let Some(npm) = &snapshot.npm {
+    if npm.npm_resolver.in_npm_package(referrer) {
       return; // ignore, surface typescript errors instead
     }
   }
@@ -1461,8 +1461,7 @@ mod tests {
         GlobalHttpCache::new(location.to_path_buf(), RealDenoCacheEnv),
       )),
       config: Default::default(),
-      maybe_node_resolver: None,
-      maybe_npm_resolver: None,
+      npm: None,
     }
   }
 
diff --git a/cli/lsp/documents.rs b/cli/lsp/documents.rs
index 24d4e2a10..1c672f623 100644
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@@ -2,6 +2,7 @@
 
 use super::cache::calculate_fs_version;
 use super::cache::calculate_fs_version_at_path;
+use super::language_server::StateNpmSnapshot;
 use super::text::LineIndex;
 use super::tsc;
 use super::tsc::AssetDocument;
@@ -41,7 +42,6 @@ use deno_graph::Resolution;
 use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolution;
 use deno_runtime::deno_node::NodeResolutionMode;
-use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_node::PackageJson;
 use deno_runtime::permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReqReference;
@@ -1089,7 +1089,7 @@ impl Documents {
     &self,
     specifiers: Vec<String>,
     referrer_doc: &AssetOrDocument,
-    maybe_node_resolver: Option<&Arc<NodeResolver>>,
+    maybe_npm: Option<&StateNpmSnapshot>,
   ) -> Vec<Option<(ModuleSpecifier, MediaType)>> {
     let referrer = referrer_doc.specifier();
     let dependencies = match referrer_doc {
@@ -1098,11 +1098,12 @@ impl Documents {
     };
     let mut results = Vec::new();
     for specifier in specifiers {
-      if let Some(node_resolver) = maybe_node_resolver {
-        if node_resolver.in_npm_package(referrer) {
+      if let Some(npm) = maybe_npm {
+        if npm.node_resolver.in_npm_package(referrer) {
           // we're in an npm package, so use node resolution
           results.push(Some(NodeResolution::into_specifier_and_media_type(
-            node_resolver
+            npm
+              .node_resolver
               .resolve(
                 &specifier,
                 referrer,
@@ -1126,9 +1127,9 @@ impl Documents {
         dependencies.as_ref().and_then(|d| d.deps.get(&specifier))
       {
         if let Some(specifier) = dep.maybe_type.maybe_specifier() {
-          results.push(self.resolve_dependency(specifier, maybe_node_resolver));
+          results.push(self.resolve_dependency(specifier, maybe_npm));
         } else if let Some(specifier) = dep.maybe_code.maybe_specifier() {
-          results.push(self.resolve_dependency(specifier, maybe_node_resolver));
+          results.push(self.resolve_dependency(specifier, maybe_npm));
         } else {
           results.push(None);
         }
@@ -1136,12 +1137,11 @@ impl Documents {
         .resolve_imports_dependency(&specifier)
         .and_then(|r| r.maybe_specifier())
       {
-        results.push(self.resolve_dependency(specifier, maybe_node_resolver));
+        results.push(self.resolve_dependency(specifier, maybe_npm));
       } else if let Ok(npm_req_ref) =
         NpmPackageReqReference::from_str(&specifier)
       {
-        results
-          .push(node_resolve_npm_req_ref(npm_req_ref, maybe_node_resolver));
+        results.push(node_resolve_npm_req_ref(npm_req_ref, maybe_npm));
       } else {
         results.push(None);
       }
@@ -1475,7 +1475,7 @@ impl Documents {
   fn resolve_dependency(
     &self,
     specifier: &ModuleSpecifier,
-    maybe_node_resolver: Option<&Arc<NodeResolver>>,
+    maybe_npm: Option<&StateNpmSnapshot>,
   ) -> Option<(ModuleSpecifier, MediaType)> {
     if let Some(module_name) = specifier.as_str().strip_prefix("node:") {
       if deno_node::is_builtin_node_module(module_name) {
@@ -1487,7 +1487,7 @@ impl Documents {
     }
 
     if let Ok(npm_ref) = NpmPackageReqReference::from_specifier(specifier) {
-      return node_resolve_npm_req_ref(npm_ref, maybe_node_resolver);
+      return node_resolve_npm_req_ref(npm_ref, maybe_npm);
     }
     let doc = self.get(specifier)?;
     let maybe_module = doc.maybe_esm_module().and_then(|r| r.as_ref().ok());
@@ -1496,7 +1496,7 @@ impl Documents {
     if let Some(specifier) =
       maybe_types_dependency.and_then(|d| d.maybe_specifier())
     {
-      self.resolve_dependency(specifier, maybe_node_resolver)
+      self.resolve_dependency(specifier, maybe_npm)
     } else {
       let media_type = doc.media_type();
       Some((doc.specifier().clone(), media_type))
@@ -1519,18 +1519,26 @@ impl Documents {
 
 fn node_resolve_npm_req_ref(
   npm_req_ref: NpmPackageReqReference,
-  maybe_node_resolver: Option<&Arc<NodeResolver>>,
+  maybe_npm: Option<&StateNpmSnapshot>,
 ) -> Option<(ModuleSpecifier, MediaType)> {
-  maybe_node_resolver.map(|node_resolver| {
+  maybe_npm.map(|npm| {
     NodeResolution::into_specifier_and_media_type(
-      node_resolver
-        .resolve_npm_req_reference(
-          &npm_req_ref,
-          NodeResolutionMode::Types,
-          &PermissionsContainer::allow_all(),
-        )
+      npm
+        .npm_resolver
+        .resolve_pkg_folder_from_deno_module_req(npm_req_ref.req())
         .ok()
-        .flatten(),
+        .and_then(|package_folder| {
+          npm
+            .node_resolver
+            .resolve_npm_reference(
+              &package_folder,
+              npm_req_ref.sub_path(),
+              NodeResolutionMode::Types,
+              &PermissionsContainer::allow_all(),
+            )
+            .ok()
+            .flatten()
+        }),
     )
   })
 }
diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
index d9db2edbf..38d07fb52 100644
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@@ -158,6 +158,12 @@ impl LspNpmConfigHash {
 #[derive(Debug, Clone)]
 pub struct LanguageServer(Arc<tokio::sync::RwLock<Inner>>);
 
+#[derive(Debug)]
+pub struct StateNpmSnapshot {
+  pub node_resolver: Arc<NodeResolver>,
+  pub npm_resolver: Arc<CliNpmResolver>,
+}
+
 /// Snapshot of the state used by TSC.
 #[derive(Debug)]
 pub struct StateSnapshot {
@@ -166,8 +172,7 @@ pub struct StateSnapshot {
   pub config: Arc<ConfigSnapshot>,
   pub documents: Documents,
   pub maybe_import_map: Option<Arc<ImportMap>>,
-  pub maybe_node_resolver: Option<Arc<NodeResolver>>,
-  pub maybe_npm_resolver: Option<Arc<CliNpmResolver>>,
+  pub npm: Option<StateNpmSnapshot>,
 }
 
 #[derive(Debug)]
@@ -819,8 +824,10 @@ impl Inner {
       config: self.config.snapshot(),
       documents: self.documents.clone(),
       maybe_import_map: self.maybe_import_map.clone(),
-      maybe_node_resolver: Some(node_resolver),
-      maybe_npm_resolver: Some(npm_resolver),
+      npm: Some(StateNpmSnapshot {
+        node_resolver,
+        npm_resolver,
+      }),
     })
   }
 
diff --git a/cli/lsp/tsc.rs b/cli/lsp/tsc.rs
index 9a33ff5f9..cf809408b 100644
--- a/cli/lsp/tsc.rs
+++ b/cli/lsp/tsc.rs
@@ -3293,9 +3293,9 @@ fn op_is_node_file(state: &mut OpState, #[string] path: String) -> bool {
   match ModuleSpecifier::parse(&path) {
     Ok(specifier) => state
       .state_snapshot
-      .maybe_npm_resolver
+      .npm
       .as_ref()
-      .map(|r| r.in_npm_package(&specifier))
+      .map(|n| n.npm_resolver.in_npm_package(&specifier))
       .unwrap_or(false),
     Err(_) => false,
   }
@@ -3341,7 +3341,7 @@ fn op_resolve(
       let resolved = state.state_snapshot.documents.resolve(
         args.specifiers,
         &referrer_doc,
-        state.state_snapshot.maybe_node_resolver.as_ref(),
+        state.state_snapshot.npm.as_ref(),
       );
       Ok(
         resolved
@@ -3477,8 +3477,7 @@ deno_core::extension!(deno_tsc,
         config: Default::default(),
         documents: Documents::new(options.cache.clone()),
         maybe_import_map: None,
-        maybe_node_resolver: None,
-        maybe_npm_resolver: None,
+        npm: None,
       }),
       options.performance,
     ));
@@ -4304,8 +4303,7 @@ mod tests {
       cache_metadata: CacheMetadata::new(cache),
       config: Default::default(),
       maybe_import_map: None,
-      maybe_node_resolver: None,
-      maybe_npm_resolver: None,
+      npm: None,
     }
   }
 
diff --git a/cli/module_loader.rs b/cli/module_loader.rs
index 4a1e0b671..f1882d5d7 100644
--- a/cli/module_loader.rs
+++ b/cli/module_loader.rs
@@ -12,6 +12,7 @@ use crate::graph_util::ModuleGraphBuilder;
 use crate::graph_util::ModuleGraphContainer;
 use crate::node;
 use crate::node::CliNodeCodeTranslator;
+use crate::npm::CliNpmResolver;
 use crate::resolver::CliGraphResolver;
 use crate::tools::check;
 use crate::tools::check::TypeChecker;
@@ -646,6 +647,7 @@ pub struct NpmModuleLoader {
   node_code_translator: Arc<CliNodeCodeTranslator>,
   fs: Arc<dyn deno_fs::FileSystem>,
   node_resolver: Arc<NodeResolver>,
+  npm_resolver: Arc<CliNpmResolver>,
 }
 
 impl NpmModuleLoader {
@@ -654,12 +656,14 @@ impl NpmModuleLoader {
     node_code_translator: Arc<CliNodeCodeTranslator>,
     fs: Arc<dyn deno_fs::FileSystem>,
     node_resolver: Arc<NodeResolver>,
+    npm_resolver: Arc<CliNpmResolver>,
   ) -> Self {
     Self {
       cjs_resolutions,
       node_code_translator,
       fs,
       node_resolver,
+      npm_resolver,
     }
   }
 
@@ -693,9 +697,13 @@ impl NpmModuleLoader {
     nv_ref: &NpmPackageNvReference,
     permissions: &PermissionsContainer,
   ) -> Result<ModuleSpecifier, AnyError> {
+    let package_folder = self
+      .npm_resolver
+      .resolve_pkg_folder_from_deno_module(nv_ref.nv())?;
     self
       .handle_node_resolve_result(self.node_resolver.resolve_npm_reference(
-        nv_ref,
+        &package_folder,
+        nv_ref.sub_path(),
         NodeResolutionMode::Execution,
         permissions,
       ))
@@ -704,16 +712,20 @@ impl NpmModuleLoader {
 
   pub fn resolve_req_reference(
     &self,
-    reference: &NpmPackageReqReference,
+    req_ref: &NpmPackageReqReference,
     permissions: &PermissionsContainer,
   ) -> Result<ModuleSpecifier, AnyError> {
+    let package_folder = self
+      .npm_resolver
+      .resolve_pkg_folder_from_deno_module_req(req_ref.req())?;
     self
-      .handle_node_resolve_result(self.node_resolver.resolve_npm_req_reference(
-        reference,
+      .handle_node_resolve_result(self.node_resolver.resolve_npm_reference(
+        &package_folder,
+        req_ref.sub_path(),
         NodeResolutionMode::Execution,
         permissions,
       ))
-      .with_context(|| format!("Could not resolve '{reference}'."))
+      .with_context(|| format!("Could not resolve '{}'.", req_ref))
   }
 
   pub fn maybe_prepare_load(
diff --git a/cli/npm/installer.rs b/cli/npm/installer.rs
index 9e7b413b4..8f3db0531 100644
--- a/cli/npm/installer.rs
+++ b/cli/npm/installer.rs
@@ -105,7 +105,7 @@ impl PackageJsonDepsInstaller {
       let (req, info) = result?;
       let result = inner
         .npm_resolution
-        .resolve_package_req_as_pending_with_info(req, &info);
+        .resolve_pkg_req_as_pending_with_info(req, &info);
       if let Err(err) = result {
         if inner.npm_registry_api.mark_force_reload() {
           log::debug!("Failed to resolve package. Retrying. Error: {err:#}");
diff --git a/cli/npm/resolution.rs b/cli/npm/resolution.rs
index 5595a71ef..3e76d5e85 100644
--- a/cli/npm/resolution.rs
+++ b/cli/npm/resolution.rs
@@ -224,19 +224,19 @@ impl NpmResolution {
   /// Resolves a package requirement for deno graph. This should only be
   /// called by deno_graph's NpmResolver or for resolving packages in
   /// a package.json
-  pub fn resolve_package_req_as_pending(
+  pub fn resolve_pkg_req_as_pending(
     &self,
     pkg_req: &PackageReq,
   ) -> Result<PackageNv, NpmPackageVersionResolutionError> {
     // we should always have this because it should have been cached before here
     let package_info = self.api.get_cached_package_info(&pkg_req.name).unwrap();
-    self.resolve_package_req_as_pending_with_info(pkg_req, &package_info)
+    self.resolve_pkg_req_as_pending_with_info(pkg_req, &package_info)
   }
 
   /// Resolves a package requirement for deno graph. This should only be
   /// called by deno_graph's NpmResolver or for resolving packages in
   /// a package.json
-  pub fn resolve_package_req_as_pending_with_info(
+  pub fn resolve_pkg_req_as_pending_with_info(
     &self,
     pkg_req: &PackageReq,
     package_info: &NpmPackageInfo,
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index 19dd726f5..efaad93ee 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -23,7 +23,10 @@ use deno_runtime::deno_fs::FileSystem;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NpmResolver;
+use deno_semver::npm::NpmPackageNvReference;
+use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageNv;
+use deno_semver::package::PackageNvReference;
 use deno_semver::package::PackageReq;
 use global::GlobalNpmPackageResolver;
 use serde::Deserialize;
@@ -98,6 +101,19 @@ impl CliNpmResolver {
       .unwrap_or(false)
   }
 
+  pub fn resolve_pkg_nv_ref_from_pkg_req_ref(
+    &self,
+    req_ref: &NpmPackageReqReference,
+  ) -> Result<NpmPackageNvReference, PackageReqNotFoundError> {
+    let pkg_nv = self
+      .resolve_pkg_id_from_pkg_req(req_ref.req())
+      .map(|id| id.nv)?;
+    Ok(NpmPackageNvReference::new(PackageNvReference {
+      nv: pkg_nv,
+      sub_path: req_ref.sub_path().map(|s| s.to_string()),
+    }))
+  }
+
   pub fn resolve_pkg_id_from_pkg_req(
     &self,
     req: &PackageReq,
@@ -127,7 +143,7 @@ impl CliNpmResolver {
   /// Resolve the root folder of the package the provided specifier is in.
   ///
   /// This will error when the provided specifier is not in an npm package.
-  pub fn resolve_package_folder_from_specifier(
+  pub fn resolve_pkg_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
   ) -> Result<Option<PathBuf>, AnyError> {
@@ -145,8 +161,24 @@ impl CliNpmResolver {
     Ok(Some(path))
   }
 
+  pub fn resolve_pkg_folder_from_deno_module_req(
+    &self,
+    req: &PackageReq,
+  ) -> Result<PathBuf, AnyError> {
+    let pkg_id = self.resolve_pkg_id_from_pkg_req(req)?;
+    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
+  }
+
+  pub fn resolve_pkg_folder_from_deno_module(
+    &self,
+    nv: &PackageNv,
+  ) -> Result<PathBuf, AnyError> {
+    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(nv)?;
+    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
+  }
+
   /// Resolves the package nv from the provided specifier.
-  pub fn resolve_package_id_from_specifier(
+  pub fn resolve_pkg_id_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
   ) -> Result<Option<NpmPackageId>, AnyError> {
@@ -266,22 +298,7 @@ impl NpmResolver for CliNpmResolver {
     &self,
     specifier: &ModuleSpecifier,
   ) -> Result<Option<PathBuf>, AnyError> {
-    self.resolve_package_folder_from_specifier(specifier)
-  }
-
-  fn resolve_package_folder_from_deno_module(
-    &self,
-    pkg_nv: &PackageNv,
-  ) -> Result<PathBuf, AnyError> {
-    let pkg_id = self.resolution.resolve_pkg_id_from_deno_module(pkg_nv)?;
-    self.resolve_pkg_folder_from_pkg_id(&pkg_id)
-  }
-
-  fn resolve_pkg_id_from_pkg_req(
-    &self,
-    req: &PackageReq,
-  ) -> Result<NpmPackageId, PackageReqNotFoundError> {
-    self.resolution.resolve_pkg_id_from_pkg_req(req)
+    self.resolve_pkg_folder_from_specifier(specifier)
   }
 
   fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
diff --git a/cli/resolver.rs b/cli/resolver.rs
index 6fd48db82..1cbd3356e 100644
--- a/cli/resolver.rs
+++ b/cli/resolver.rs
@@ -319,9 +319,7 @@ impl NpmResolver for CliGraphResolver {
       ));
     }
 
-    let result = self
-      .npm_resolution
-      .resolve_package_req_as_pending(package_req);
+    let result = self.npm_resolution.resolve_pkg_req_as_pending(package_req);
     match result {
       Ok(nv) => NpmPackageReqResolution::Ok(nv),
       Err(err) => {
diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index 5ab39d719..e3ab448e3 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -404,6 +404,7 @@ pub async fn run(
         node_code_translator,
         fs.clone(),
         node_resolver.clone(),
+        npm_resolver.clone(),
       )),
     }),
   };
@@ -429,7 +430,7 @@ pub async fn run(
   };
   let worker_factory = CliMainWorkerFactory::new(
     StorageKeyResolver::empty(),
-    npm_resolver.clone(),
+    npm_resolver,
     node_resolver,
     Default::default(),
     Box::new(module_loader_factory),
diff --git a/cli/tests/testdata/npm/deno_run_no_bin_entrypoint.out b/cli/tests/testdata/npm/deno_run_no_bin_entrypoint.out
index b878bc70c..73bddfecf 100644
--- a/cli/tests/testdata/npm/deno_run_no_bin_entrypoint.out
+++ b/cli/tests/testdata/npm/deno_run_no_bin_entrypoint.out
@@ -1 +1 @@
-error: package '@denotest/esm-basic' did not have a bin property in its package.json
+error: '[WILDCARD]@denotest[WILDCARD]esm-basic[WILDCARD]package.json' did not have a bin property
diff --git a/cli/tests/testdata/npm/deno_run_no_bin_entrypoint_non_existent_subpath.out b/cli/tests/testdata/npm/deno_run_no_bin_entrypoint_non_existent_subpath.out
index 06d7292b0..ea5ee3d35 100644
--- a/cli/tests/testdata/npm/deno_run_no_bin_entrypoint_non_existent_subpath.out
+++ b/cli/tests/testdata/npm/deno_run_no_bin_entrypoint_non_existent_subpath.out
@@ -1,3 +1,3 @@
-error: package '@denotest/esm-basic' did not have a bin property in its package.json
+error: '[WILDCARD]@denotest[WILDCARD]esm-basic[WILDCARD]package.json' did not have a bin property
 
 Fallback failed: Cannot find module 'file:///[WILDCARD]/non-existent.js'
diff --git a/cli/tools/check.rs b/cli/tools/check.rs
index 85ce44b95..a61e3cfe1 100644
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@@ -138,7 +138,10 @@ impl TypeChecker {
       debug,
       graph: graph.clone(),
       hash_data,
-      maybe_node_resolver: Some(self.node_resolver.clone()),
+      maybe_npm: Some(tsc::RequestNpmState {
+        node_resolver: self.node_resolver.clone(),
+        npm_resolver: self.npm_resolver.clone(),
+      }),
       maybe_tsbuildinfo,
       root_names,
       check_mode: type_check_mode,
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index dcb53e4ec..6a6c23e39 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -268,7 +268,9 @@ fn resolve_npm_commands(
   let mut result = HashMap::new();
   let snapshot = npm_resolver.snapshot();
   for id in snapshot.top_level_packages() {
-    let bin_commands = node_resolver.resolve_binary_commands(&id.nv)?;
+    let package_folder = npm_resolver.resolve_pkg_folder_from_pkg_id(id)?;
+    let bin_commands =
+      node_resolver.resolve_binary_commands(&package_folder)?;
     for bin_command in bin_commands {
       result.insert(
         bin_command.to_string(),
diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs
index 04e8dec04..50b7dc9e4 100644
--- a/cli/tsc/mod.rs
+++ b/cli/tsc/mod.rs
@@ -4,6 +4,7 @@ use crate::args::TsConfig;
 use crate::args::TypeCheckMode;
 use crate::cache::FastInsecureHasher;
 use crate::node;
+use crate::npm::CliNpmResolver;
 use crate::util::checksum;
 use crate::util::path::mapped_specifier_for_tsc;
 
@@ -293,6 +294,12 @@ pub struct EmittedFile {
   pub media_type: MediaType,
 }
 
+#[derive(Debug)]
+pub struct RequestNpmState {
+  pub node_resolver: Arc<NodeResolver>,
+  pub npm_resolver: Arc<CliNpmResolver>,
+}
+
 /// A structure representing a request to be sent to the tsc runtime.
 #[derive(Debug)]
 pub struct Request {
@@ -303,7 +310,7 @@ pub struct Request {
   pub debug: bool,
   pub graph: Arc<ModuleGraph>,
   pub hash_data: u64,
-  pub maybe_node_resolver: Option<Arc<NodeResolver>>,
+  pub maybe_npm: Option<RequestNpmState>,
   pub maybe_tsbuildinfo: Option<String>,
   /// A vector of strings that represent the root/entry point modules for the
   /// program.
@@ -327,7 +334,7 @@ struct State {
   graph: Arc<ModuleGraph>,
   maybe_tsbuildinfo: Option<String>,
   maybe_response: Option<RespondArgs>,
-  maybe_node_resolver: Option<Arc<NodeResolver>>,
+  maybe_npm: Option<RequestNpmState>,
   remapped_specifiers: HashMap<String, ModuleSpecifier>,
   root_map: HashMap<String, ModuleSpecifier>,
   current_dir: PathBuf,
@@ -340,7 +347,7 @@ impl Default for State {
       graph: Arc::new(ModuleGraph::new(GraphKind::All)),
       maybe_tsbuildinfo: Default::default(),
       maybe_response: Default::default(),
-      maybe_node_resolver: Default::default(),
+      maybe_npm: Default::default(),
       remapped_specifiers: Default::default(),
       root_map: Default::default(),
       current_dir: Default::default(),
@@ -352,7 +359,7 @@ impl State {
   pub fn new(
     graph: Arc<ModuleGraph>,
     hash_data: u64,
-    maybe_node_resolver: Option<Arc<NodeResolver>>,
+    maybe_npm: Option<RequestNpmState>,
     maybe_tsbuildinfo: Option<String>,
     root_map: HashMap<String, ModuleSpecifier>,
     remapped_specifiers: HashMap<String, ModuleSpecifier>,
@@ -361,7 +368,7 @@ impl State {
     State {
       hash_data,
       graph,
-      maybe_node_resolver,
+      maybe_npm,
       maybe_tsbuildinfo,
       maybe_response: None,
       remapped_specifiers,
@@ -496,9 +503,9 @@ fn op_load(state: &mut OpState, args: Value) -> Result<Value, AnyError> {
         }
       }
     } else if state
-      .maybe_node_resolver
+      .maybe_npm
       .as_ref()
-      .map(|resolver| resolver.in_npm_package(specifier))
+      .map(|npm| npm.node_resolver.in_npm_package(specifier))
       .unwrap_or(false)
     {
       media_type = MediaType::from_specifier(specifier);
@@ -650,9 +657,13 @@ fn resolve_graph_specifier_types(
       Ok(Some((module.specifier.clone(), module.media_type)))
     }
     Some(Module::Npm(module)) => {
-      if let Some(node_resolver) = &state.maybe_node_resolver {
-        let maybe_resolution = node_resolver.resolve_npm_reference(
-          &module.nv_reference,
+      if let Some(npm) = &state.maybe_npm {
+        let package_folder = npm
+          .npm_resolver
+          .resolve_pkg_folder_from_deno_module(module.nv_reference.nv())?;
+        let maybe_resolution = npm.node_resolver.resolve_npm_reference(
+          &package_folder,
+          module.nv_reference.sub_path(),
           NodeResolutionMode::Types,
           &PermissionsContainer::allow_all(),
         )?;
@@ -665,11 +676,11 @@ fn resolve_graph_specifier_types(
     }
     Some(Module::External(module)) => {
       // we currently only use "External" for when the module is in an npm package
-      Ok(state.maybe_node_resolver.as_ref().map(|node_resolver| {
+      Ok(state.maybe_npm.as_ref().map(|npm| {
         let specifier =
           node::resolve_specifier_into_node_modules(&module.specifier);
         NodeResolution::into_specifier_and_media_type(
-          node_resolver.url_to_node_resolution(specifier).ok(),
+          npm.node_resolver.url_to_node_resolution(specifier).ok(),
         )
       }))
     }
@@ -682,10 +693,11 @@ fn resolve_non_graph_specifier_types(
   referrer: &ModuleSpecifier,
   state: &State,
 ) -> Result<Option<(ModuleSpecifier, MediaType)>, AnyError> {
-  let node_resolver = match state.maybe_node_resolver.as_ref() {
-    Some(node_resolver) => node_resolver,
+  let npm = match state.maybe_npm.as_ref() {
+    Some(npm) => npm,
     None => return Ok(None), // we only support non-graph types for npm packages
   };
+  let node_resolver = &npm.node_resolver;
   if node_resolver.in_npm_package(referrer) {
     // we're in an npm package, so use node resolution
     Ok(Some(NodeResolution::into_specifier_and_media_type(
@@ -699,13 +711,17 @@ fn resolve_non_graph_specifier_types(
         .ok()
         .flatten(),
     )))
-  } else if let Ok(npm_ref) = NpmPackageReqReference::from_str(specifier) {
+  } else if let Ok(npm_req_ref) = NpmPackageReqReference::from_str(specifier) {
     // todo(dsherret): add support for injecting this in the graph so
     // we don't need this special code here.
     // This could occur when resolving npm:@types/node when it is
     // injected and not part of the graph
-    let maybe_resolution = node_resolver.resolve_npm_req_reference(
-      &npm_ref,
+    let package_folder = npm
+      .npm_resolver
+      .resolve_pkg_folder_from_deno_module_req(npm_req_ref.req())?;
+    let maybe_resolution = node_resolver.resolve_npm_reference(
+      &package_folder,
+      npm_req_ref.sub_path(),
       NodeResolutionMode::Types,
       &PermissionsContainer::allow_all(),
     )?;
@@ -722,9 +738,9 @@ fn op_is_node_file(state: &mut OpState, #[string] path: &str) -> bool {
   let state = state.borrow::<State>();
   match ModuleSpecifier::parse(path) {
     Ok(specifier) => state
-      .maybe_node_resolver
+      .maybe_npm
       .as_ref()
-      .map(|r| r.in_npm_package(&specifier))
+      .map(|n| n.node_resolver.in_npm_package(&specifier))
       .unwrap_or(false),
     Err(_) => false,
   }
@@ -783,7 +799,7 @@ pub fn exec(request: Request) -> Result<Response, AnyError> {
       state.put(State::new(
         options.request.graph,
         options.request.hash_data,
-        options.request.maybe_node_resolver,
+        options.request.maybe_npm,
         options.request.maybe_tsbuildinfo,
         options.root_map,
         options.remapped_specifiers,
@@ -952,7 +968,7 @@ mod tests {
       debug: false,
       graph: Arc::new(graph),
       hash_data,
-      maybe_node_resolver: None,
+      maybe_npm: None,
       maybe_tsbuildinfo: None,
       root_names: vec![(specifier.clone(), MediaType::TypeScript)],
       check_mode: TypeCheckMode::All,
diff --git a/cli/worker.rs b/cli/worker.rs
index b29f22e6e..5d80ab6fd 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -39,6 +39,7 @@ use deno_runtime::worker::MainWorker;
 use deno_runtime::worker::WorkerOptions;
 use deno_runtime::BootstrapOptions;
 use deno_runtime::WorkerLogLevel;
+use deno_semver::npm::NpmPackageNvReference;
 use deno_semver::npm::NpmPackageReqReference;
 use deno_semver::package::PackageReqReference;
 
@@ -386,6 +387,9 @@ impl CliMainWorkerFactory {
         .npm_resolver
         .add_package_reqs(&[package_ref.req().clone()])
         .await?;
+      let package_ref = shared
+        .npm_resolver
+        .resolve_pkg_nv_ref_from_pkg_req_ref(&package_ref)?;
       let node_resolution =
         self.resolve_binary_entrypoint(&package_ref, &permissions)?;
       let is_main_cjs = matches!(node_resolution, NodeResolution::CommonJs(_));
@@ -511,10 +515,18 @@ impl CliMainWorkerFactory {
 
   fn resolve_binary_entrypoint(
     &self,
-    package_ref: &NpmPackageReqReference,
+    package_ref: &NpmPackageNvReference,
     permissions: &PermissionsContainer,
   ) -> Result<NodeResolution, AnyError> {
-    match self.shared.node_resolver.resolve_binary_export(package_ref) {
+    let package_folder = self
+      .shared
+      .npm_resolver
+      .resolve_pkg_folder_from_deno_module(package_ref.nv())?;
+    match self
+      .shared
+      .node_resolver
+      .resolve_binary_export(&package_folder, package_ref.sub_path())
+    {
       Ok(node_resolution) => Ok(node_resolution),
       Err(original_err) => {
         // if the binary entrypoint was not found, fallback to regular node resolution
@@ -534,7 +546,7 @@ impl CliMainWorkerFactory {
   /// resolve the binary entrypoint using regular node resolution
   fn resolve_binary_entrypoint_fallback(
     &self,
-    package_ref: &NpmPackageReqReference,
+    package_ref: &NpmPackageNvReference,
     permissions: &PermissionsContainer,
   ) -> Result<Option<NodeResolution>, AnyError> {
     // only fallback if the user specified a sub path
@@ -545,12 +557,16 @@ impl CliMainWorkerFactory {
       return Ok(None);
     }
 
-    let Some(resolution) =
-      self.shared.node_resolver.resolve_npm_req_reference(
-        package_ref,
-        NodeResolutionMode::Execution,
-        permissions,
-      )?
+    let package_folder = self
+      .shared
+      .npm_resolver
+      .resolve_pkg_folder_from_deno_module(package_ref.nv())?;
+    let Some(resolution) = self.shared.node_resolver.resolve_npm_reference(
+      &package_folder,
+      package_ref.sub_path(),
+      NodeResolutionMode::Execution,
+      permissions,
+    )?
     else {
       return Ok(None);
     };