refactor: use deno_graph for npm specifiers (#17858)

This changes npm specifiers to be handled by deno_graph and resolved to
an npm package name and version when the specifier is encountered. It
also slightly changes how npm specifier resolution occurs—previously it
would collect all the npm specifiers and resolve them all at once, but
now it resolves them on the fly as they are encountered in the module
graph.

https://github.com/denoland/deno_graph/pull/232

---------

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>

9 files changed, 241 insertions, 203 deletions

diff --git a/cli/tools/bench.rs b/cli/tools/bench.rs
index 447cb1fcb..cd6e91c9f 100644
--- a/cli/tools/bench.rs
+++ b/cli/tools/bench.rs
@@ -642,7 +642,7 @@ pub async fn run_benchmarks_with_watch(
           output: &mut HashSet<&'a ModuleSpecifier>,
           no_check: bool,
         ) {
-          if let Some(module) = maybe_module {
+          if let Some(module) = maybe_module.and_then(|m| m.esm()) {
             for dep in module.dependencies.values() {
               if let Some(specifier) = &dep.get_code() {
                 if !output.contains(specifier) {
@@ -671,6 +671,7 @@ pub async fn run_benchmarks_with_watch(
             }
           }
         }
+
         // This bench module and all it's dependencies
         let mut modules = HashSet::new();
         modules.insert(&specifier);
diff --git a/cli/tools/bundle.rs b/cli/tools/bundle.rs
index 6a9019cd8..d75da5ec7 100644
--- a/cli/tools/bundle.rs
+++ b/cli/tools/bundle.rs
@@ -6,6 +6,7 @@ use std::sync::Arc;
 use deno_core::error::AnyError;
 use deno_core::futures::FutureExt;
 use deno_core::resolve_url_or_path;
+use deno_graph::Module;
 use deno_runtime::colors;
 
 use crate::args::BundleFlags;
@@ -48,8 +49,12 @@ pub async fn bundle(
       let mut paths_to_watch: Vec<PathBuf> = graph
         .specifiers()
         .filter_map(|(_, r)| {
-          r.ok()
-            .and_then(|module| module.specifier.to_file_path().ok())
+          r.ok().and_then(|module| match module {
+            Module::Esm(m) => m.specifier.to_file_path().ok(),
+            Module::Json(m) => m.specifier.to_file_path().ok(),
+            // nothing to watch
+            Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
+          })
         })
         .collect();
 
diff --git a/cli/tools/check.rs b/cli/tools/check.rs
index bf5e3033f..a29c4cea8 100644
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@@ -5,8 +5,8 @@ use std::sync::Arc;
 use deno_ast::MediaType;
 use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
+use deno_graph::Module;
 use deno_graph::ModuleGraph;
-use deno_graph::ModuleKind;
 use deno_runtime::colors;
 use once_cell::sync::Lazy;
 use regex::Regex;
@@ -39,11 +39,6 @@ pub struct CheckOptions {
   /// If true, valid `.tsbuildinfo` files will be ignored and type checking
   /// will always occur.
   pub reload: bool,
-  /// If the graph has a node built-in specifier.
-  ///
-  /// Although this could be derived from the graph, this helps
-  /// speed things up.
-  pub has_node_builtin_specifier: bool,
 }
 
 /// The result of a check of a module graph.
@@ -81,8 +76,7 @@ pub fn check(
     }
   }
 
-  let root_names =
-    get_tsc_roots(&graph, options.has_node_builtin_specifier, check_js);
+  let root_names = get_tsc_roots(&graph, check_js);
   // while there might be multiple roots, we can't "merge" the build info, so we
   // try to retrieve the build info for first root, which is the most common use
   // case.
@@ -168,45 +162,53 @@ fn get_check_hash(
 
   let check_js = options.ts_config.get_check_js();
   let mut sorted_modules = graph.modules().collect::<Vec<_>>();
-  sorted_modules.sort_by_key(|m| m.specifier.as_str()); // make it deterministic
+  sorted_modules.sort_by_key(|m| m.specifier().as_str()); // make it deterministic
   let mut has_file = false;
   let mut has_file_to_type_check = false;
   for module in sorted_modules {
-    let ts_check =
-      has_ts_check(module.media_type, module.maybe_source.as_deref());
-    if ts_check {
-      has_file_to_type_check = true;
-    }
+    match module {
+      Module::Esm(module) => {
+        let ts_check = has_ts_check(module.media_type, &module.source);
+        if ts_check {
+          has_file_to_type_check = true;
+        }
 
-    match module.media_type {
-      MediaType::TypeScript
-      | MediaType::Dts
-      | MediaType::Dmts
-      | MediaType::Dcts
-      | MediaType::Mts
-      | MediaType::Cts
-      | MediaType::Tsx => {
-        has_file = true;
-        has_file_to_type_check = true;
-      }
-      MediaType::JavaScript
-      | MediaType::Mjs
-      | MediaType::Cjs
-      | MediaType::Jsx => {
-        has_file = true;
-        if !check_js && !ts_check {
-          continue;
+        match module.media_type {
+          MediaType::TypeScript
+          | MediaType::Dts
+          | MediaType::Dmts
+          | MediaType::Dcts
+          | MediaType::Mts
+          | MediaType::Cts
+          | MediaType::Tsx => {
+            has_file = true;
+            has_file_to_type_check = true;
+          }
+          MediaType::JavaScript
+          | MediaType::Mjs
+          | MediaType::Cjs
+          | MediaType::Jsx => {
+            has_file = true;
+            if !check_js && !ts_check {
+              continue;
+            }
+          }
+          MediaType::Json
+          | MediaType::TsBuildInfo
+          | MediaType::SourceMap
+          | MediaType::Wasm
+          | MediaType::Unknown => continue,
         }
+
+        hasher.write_str(module.specifier.as_str());
+        hasher.write_str(&module.source);
+      }
+      Module::Json(_)
+      | Module::External(_)
+      | Module::Node(_)
+      | Module::Npm(_) => {
+        // ignore
       }
-      MediaType::Json
-      | MediaType::TsBuildInfo
-      | MediaType::SourceMap
-      | MediaType::Wasm
-      | MediaType::Unknown => continue,
-    }
-    hasher.write_str(module.specifier.as_str());
-    if let Some(code) = &module.maybe_source {
-      hasher.write_str(code);
     }
   }
 
@@ -226,38 +228,43 @@ fn get_check_hash(
 /// otherwise they would be ignored if only imported into JavaScript.
 fn get_tsc_roots(
   graph: &ModuleGraph,
-  has_node_builtin_specifier: bool,
   check_js: bool,
 ) -> Vec<(ModuleSpecifier, MediaType)> {
   let mut result = Vec::new();
-  if has_node_builtin_specifier {
+  if graph.has_node_specifier {
     // inject a specifier that will resolve node types
     result.push((
       ModuleSpecifier::parse("asset:///node_types.d.ts").unwrap(),
       MediaType::Dts,
     ));
   }
-  result.extend(graph.modules().filter_map(|module| {
-    if module.kind == ModuleKind::External || module.maybe_source.is_none() {
-      return None;
-    }
-    match module.media_type {
+  result.extend(graph.modules().filter_map(|module| match module {
+    Module::Esm(module) => match module.media_type {
       MediaType::TypeScript
       | MediaType::Tsx
       | MediaType::Mts
       | MediaType::Cts
       | MediaType::Jsx => Some((module.specifier.clone(), module.media_type)),
-      MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs
-        if check_js
-          || has_ts_check(
-            module.media_type,
-            module.maybe_source.as_deref(),
-          ) =>
-      {
-        Some((module.specifier.clone(), module.media_type))
+      MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs => {
+        if check_js || has_ts_check(module.media_type, &module.source) {
+          Some((module.specifier.clone(), module.media_type))
+        } else {
+          None
+        }
       }
-      _ => None,
-    }
+      MediaType::Json
+      | MediaType::Dts
+      | MediaType::Dmts
+      | MediaType::Dcts
+      | MediaType::Wasm
+      | MediaType::TsBuildInfo
+      | MediaType::SourceMap
+      | MediaType::Unknown => None,
+    },
+    Module::External(_)
+    | Module::Node(_)
+    | Module::Npm(_)
+    | Module::Json(_) => None,
   }));
   result
 }
@@ -266,11 +273,7 @@ fn get_tsc_roots(
 static TS_CHECK_RE: Lazy<Regex> =
   Lazy::new(|| Regex::new(r#"(?i)^\s*@ts-check(?:\s+|$)"#).unwrap());
 
-fn has_ts_check(media_type: MediaType, maybe_file_text: Option<&str>) -> bool {
-  let file_text = match maybe_file_text {
-    Some(text) => text,
-    None => return false,
-  };
+fn has_ts_check(media_type: MediaType, file_text: &str) -> bool {
   match &media_type {
     MediaType::JavaScript
     | MediaType::Mjs
@@ -278,7 +281,18 @@ fn has_ts_check(media_type: MediaType, maybe_file_text: Option<&str>) -> bool {
     | MediaType::Jsx => get_leading_comments(file_text)
       .iter()
       .any(|text| TS_CHECK_RE.is_match(text)),
-    _ => false,
+    MediaType::TypeScript
+    | MediaType::Mts
+    | MediaType::Cts
+    | MediaType::Dts
+    | MediaType::Dcts
+    | MediaType::Dmts
+    | MediaType::Tsx
+    | MediaType::Json
+    | MediaType::Wasm
+    | MediaType::TsBuildInfo
+    | MediaType::SourceMap
+    | MediaType::Unknown => false,
   }
 }
 
@@ -374,20 +388,19 @@ mod test {
   fn has_ts_check_test() {
     assert!(has_ts_check(
       MediaType::JavaScript,
-      Some("// @ts-check\nconsole.log(5);")
+      "// @ts-check\nconsole.log(5);"
     ));
     assert!(has_ts_check(
       MediaType::JavaScript,
-      Some("// deno-lint-ignore\n// @ts-check\n")
+      "// deno-lint-ignore\n// @ts-check\n"
     ));
     assert!(!has_ts_check(
       MediaType::JavaScript,
-      Some("test;\n// @ts-check\n")
+      "test;\n// @ts-check\n"
     ));
     assert!(!has_ts_check(
       MediaType::JavaScript,
-      Some("// ts-check\nconsole.log(5);")
+      "// ts-check\nconsole.log(5);"
     ));
-    assert!(!has_ts_check(MediaType::TypeScript, None,));
   }
 }
diff --git a/cli/tools/info.rs b/cli/tools/info.rs
index 2f9b2a183..8a7f4b6b9 100644
--- a/cli/tools/info.rs
+++ b/cli/tools/info.rs
@@ -10,7 +10,8 @@ use deno_core::error::AnyError;
 use deno_core::resolve_url_or_path;
 use deno_core::serde_json;
 use deno_core::serde_json::json;
-use deno_graph::npm::NpmPackageReq;
+use deno_graph::npm::NpmPackageNv;
+use deno_graph::npm::NpmPackageNvReference;
 use deno_graph::npm::NpmPackageReqReference;
 use deno_graph::Dependency;
 use deno_graph::Module;
@@ -141,7 +142,7 @@ fn add_npm_packages_to_json(
   let modules = json.get_mut("modules").and_then(|m| m.as_array_mut());
   if let Some(modules) = modules {
     if modules.len() == 1
-      && modules[0].get("kind").and_then(|k| k.as_str()) == Some("external")
+      && modules[0].get("kind").and_then(|k| k.as_str()) == Some("npm")
     {
       // If there is only one module and it's "external", then that means
       // someone provided an npm specifier as a cli argument. In this case,
@@ -150,10 +151,10 @@ fn add_npm_packages_to_json(
       let maybe_package = module
         .get("specifier")
         .and_then(|k| k.as_str())
-        .and_then(|specifier| NpmPackageReqReference::from_str(specifier).ok())
+        .and_then(|specifier| NpmPackageNvReference::from_str(specifier).ok())
         .and_then(|package_ref| {
           snapshot
-            .resolve_package_from_deno_module(&package_ref.req)
+            .resolve_package_from_deno_module(&package_ref.nv)
             .ok()
         });
       if let Some(pkg) = maybe_package {
@@ -162,8 +163,6 @@ fn add_npm_packages_to_json(
             "npmPackage".to_string(),
             pkg.pkg_id.as_serialized().into(),
           );
-          // change the "kind" to be "npm"
-          module.insert("kind".to_string(), "npm".into());
         }
       }
     } else {
@@ -173,7 +172,10 @@ fn add_npm_packages_to_json(
       // references. So there could be listed multiple npm specifiers
       // that would resolve to a single npm package.
       for i in (0..modules.len()).rev() {
-        if modules[i].get("kind").and_then(|k| k.as_str()) == Some("external") {
+        if matches!(
+          modules[i].get("kind").and_then(|k| k.as_str()),
+          Some("npm") | Some("external")
+        ) {
           modules.remove(i);
         }
       }
@@ -189,8 +191,7 @@ fn add_npm_packages_to_json(
             let specifier = dep.get("specifier").and_then(|s| s.as_str());
             if let Some(specifier) = specifier {
               if let Ok(npm_ref) = NpmPackageReqReference::from_str(specifier) {
-                if let Ok(pkg) =
-                  snapshot.resolve_package_from_deno_module(&npm_ref.req)
+                if let Ok(pkg) = snapshot.resolve_pkg_from_pkg_req(&npm_ref.req)
                 {
                   dep.insert(
                     "npmPackage".to_string(),
@@ -303,9 +304,8 @@ fn print_tree_node<TWrite: Write>(
 #[derive(Default)]
 struct NpmInfo {
   package_sizes: HashMap<NpmPackageId, u64>,
-  resolved_reqs: HashMap<NpmPackageReq, NpmPackageId>,
+  resolved_ids: HashMap<NpmPackageNv, NpmPackageId>,
   packages: HashMap<NpmPackageId, NpmResolutionPackage>,
-  specifiers: HashMap<ModuleSpecifier, NpmPackageReq>,
 }
 
 impl NpmInfo {
@@ -315,21 +315,15 @@ impl NpmInfo {
     npm_snapshot: &'a NpmResolutionSnapshot,
   ) -> Self {
     let mut info = NpmInfo::default();
-    if !npm_resolver.has_packages() {
-      return info; // skip going over the specifiers if there's no npm packages
+    if graph.npm_packages.is_empty() {
+      return info; // skip going over the modules if there's no npm packages
     }
 
-    for (specifier, _) in graph.specifiers() {
-      if let Ok(reference) = NpmPackageReqReference::from_specifier(specifier) {
-        info
-          .specifiers
-          .insert(specifier.clone(), reference.req.clone());
-        if let Ok(package) =
-          npm_snapshot.resolve_package_from_deno_module(&reference.req)
-        {
-          info
-            .resolved_reqs
-            .insert(reference.req, package.pkg_id.clone());
+    for module in graph.modules() {
+      if let Module::Npm(module) = module {
+        let nv = &module.nv_reference.nv;
+        if let Ok(package) = npm_snapshot.resolve_package_from_deno_module(nv) {
+          info.resolved_ids.insert(nv.clone(), package.pkg_id.clone());
           if !info.packages.contains_key(&package.pkg_id) {
             info.fill_package_info(package, npm_resolver, npm_snapshot);
           }
@@ -361,15 +355,12 @@ impl NpmInfo {
     }
   }
 
-  pub fn package_from_specifier(
+  pub fn resolve_package(
     &self,
-    specifier: &ModuleSpecifier,
+    nv: &NpmPackageNv,
   ) -> Option<&NpmResolutionPackage> {
-    self
-      .specifiers
-      .get(specifier)
-      .and_then(|package_req| self.resolved_reqs.get(package_req))
-      .and_then(|id| self.packages.get(id))
+    let id = self.resolved_ids.get(nv)?;
+    self.packages.get(id)
   }
 }
 
@@ -407,7 +398,12 @@ impl<'a> GraphDisplayContext<'a> {
     let root_specifier = self.graph.resolve(&self.graph.roots[0]);
     match self.graph.try_get(&root_specifier) {
       Ok(Some(root)) => {
-        if let Some(cache_info) = root.maybe_cache_info.as_ref() {
+        let maybe_cache_info = match root {
+          Module::Esm(module) => module.maybe_cache_info.as_ref(),
+          Module::Json(module) => module.maybe_cache_info.as_ref(),
+          Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
+        };
+        if let Some(cache_info) = maybe_cache_info {
           if let Some(local) = &cache_info.local {
             writeln!(
               writer,
@@ -433,9 +429,21 @@ impl<'a> GraphDisplayContext<'a> {
             )?;
           }
         }
-        writeln!(writer, "{} {}", colors::bold("type:"), root.media_type)?;
-        let total_modules_size =
-          self.graph.modules().map(|m| m.size() as f64).sum::<f64>();
+        if let Some(module) = root.esm() {
+          writeln!(writer, "{} {}", colors::bold("type:"), module.media_type)?;
+        }
+        let total_modules_size = self
+          .graph
+          .modules()
+          .map(|m| {
+            let size = match m {
+              Module::Esm(module) => module.size(),
+              Module::Json(module) => module.size(),
+              Module::Node(_) | Module::Npm(_) | Module::External(_) => 0,
+            };
+            size as f64
+          })
+          .sum::<f64>();
         let total_npm_package_size = self
           .npm_info
           .package_sizes
@@ -443,9 +451,9 @@ impl<'a> GraphDisplayContext<'a> {
           .map(|s| *s as f64)
           .sum::<f64>();
         let total_size = total_modules_size + total_npm_package_size;
-        let dep_count = self.graph.modules().count() - 1
+        let dep_count = self.graph.modules().count() - 1 // -1 for the root module
           + self.npm_info.packages.len()
-          - self.npm_info.resolved_reqs.len();
+          - self.npm_info.resolved_ids.len();
         writeln!(
           writer,
           "{} {} unique",
@@ -507,42 +515,39 @@ impl<'a> GraphDisplayContext<'a> {
 
     use PackageOrSpecifier::*;
 
-    let package_or_specifier =
-      match self.npm_info.package_from_specifier(&module.specifier) {
+    let package_or_specifier = match module.npm() {
+      Some(npm) => match self.npm_info.resolve_package(&npm.nv_reference.nv) {
         Some(package) => Package(package.clone()),
-        None => Specifier(module.specifier.clone()),
-      };
+        None => Specifier(module.specifier().clone()), // should never happen
+      },
+      None => Specifier(module.specifier().clone()),
+    };
     let was_seen = !self.seen.insert(match &package_or_specifier {
       Package(package) => package.pkg_id.as_serialized(),
       Specifier(specifier) => specifier.to_string(),
     });
     let header_text = if was_seen {
       let specifier_str = if type_dep {
-        colors::italic_gray(&module.specifier).to_string()
+        colors::italic_gray(module.specifier()).to_string()
       } else {
-        colors::gray(&module.specifier).to_string()
+        colors::gray(module.specifier()).to_string()
       };
       format!("{} {}", specifier_str, colors::gray("*"))
     } else {
-      let specifier_str = if type_dep {
-        colors::italic(&module.specifier).to_string()
+      let header_text = if type_dep {
+        colors::italic(module.specifier()).to_string()
       } else {
-        module.specifier.to_string()
-      };
-      let header_text = match &package_or_specifier {
-        Package(package) => {
-          format!("{} - {}", specifier_str, package.pkg_id.nv.version)
-        }
-        Specifier(_) => specifier_str,
+        module.specifier().to_string()
       };
       let maybe_size = match &package_or_specifier {
         Package(package) => {
           self.npm_info.package_sizes.get(&package.pkg_id).copied()
         }
-        Specifier(_) => module
-          .maybe_source
-          .as_ref()
-          .map(|s| s.as_bytes().len() as u64),
+        Specifier(_) => match module {
+          Module::Esm(module) => Some(module.size() as u64),
+          Module::Json(module) => Some(module.size() as u64),
+          Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
+        },
       };
       format!("{} {}", header_text, maybe_size_to_text(maybe_size))
     };
@@ -550,20 +555,22 @@ impl<'a> GraphDisplayContext<'a> {
     let mut tree_node = TreeNode::from_text(header_text);
 
     if !was_seen {
-      if let Some(types_dep) = &module.maybe_types_dependency {
-        if let Some(child) =
-          self.build_resolved_info(&types_dep.dependency, true)
-        {
-          tree_node.children.push(child);
-        }
-      }
       match &package_or_specifier {
         Package(package) => {
           tree_node.children.extend(self.build_npm_deps(package));
         }
         Specifier(_) => {
-          for dep in module.dependencies.values() {
-            tree_node.children.extend(self.build_dep_info(dep));
+          if let Some(module) = module.esm() {
+            if let Some(types_dep) = &module.maybe_types_dependency {
+              if let Some(child) =
+                self.build_resolved_info(&types_dep.dependency, true)
+              {
+                tree_node.children.push(child);
+              }
+            }
+            for dep in module.dependencies.values() {
+              tree_node.children.extend(self.build_dep_info(dep));
+            }
           }
         }
       }
diff --git a/cli/tools/test.rs b/cli/tools/test.rs
index d308de8de..d0f3013b3 100644
--- a/cli/tools/test.rs
+++ b/cli/tools/test.rs
@@ -1389,7 +1389,7 @@ pub async fn run_tests_with_watch(
           output: &mut HashSet<&'a ModuleSpecifier>,
           no_check: bool,
         ) {
-          if let Some(module) = maybe_module {
+          if let Some(module) = maybe_module.and_then(|m| m.esm()) {
             for dep in module.dependencies.values() {
               if let Some(specifier) = &dep.get_code() {
                 if !output.contains(specifier) {
diff --git a/cli/tools/vendor/build.rs b/cli/tools/vendor/build.rs
index 89130f391..3bee843fd 100644
--- a/cli/tools/vendor/build.rs
+++ b/cli/tools/vendor/build.rs
@@ -10,9 +10,9 @@ use deno_core::anyhow::bail;
 use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::parking_lot::Mutex;
+use deno_graph::EsmModule;
 use deno_graph::Module;
 use deno_graph::ModuleGraph;
-use deno_graph::ModuleKind;
 use import_map::ImportMap;
 use import_map::SpecifierMap;
 
@@ -93,7 +93,7 @@ pub fn build(
   let all_modules = graph.modules().collect::<Vec<_>>();
   let remote_modules = all_modules
     .iter()
-    .filter(|m| is_remote_specifier(&m.specifier))
+    .filter(|m| is_remote_specifier(m.specifier()))
     .copied()
     .collect::<Vec<_>>();
   let mappings =
@@ -101,21 +101,16 @@ pub fn build(
 
   // write out all the files
   for module in &remote_modules {
-    let source = match &module.maybe_source {
-      Some(source) => source,
-      None => continue,
+    let source = match module {
+      Module::Esm(module) => &module.source,
+      Module::Json(module) => &module.source,
+      Module::Node(_) | Module::Npm(_) | Module::External(_) => continue,
     };
+    let specifier = module.specifier();
     let local_path = mappings
-      .proxied_path(&module.specifier)
-      .unwrap_or_else(|| mappings.local_path(&module.specifier));
-    if !matches!(module.kind, ModuleKind::Esm | ModuleKind::Asserted) {
-      log::warn!(
-        "Unsupported module kind {:?} for {}",
-        module.kind,
-        module.specifier
-      );
-      continue;
-    }
+      .proxied_path(specifier)
+      .unwrap_or_else(|| mappings.local_path(specifier));
+
     environment.create_dir_all(local_path.parent().unwrap())?;
     environment.write_file(&local_path, source)?;
   }
@@ -123,7 +118,7 @@ pub fn build(
   // write out the proxies
   for (specifier, proxied_module) in mappings.proxied_modules() {
     let proxy_path = mappings.local_path(specifier);
-    let module = graph.get(specifier).unwrap();
+    let module = graph.get(specifier).unwrap().esm().unwrap();
     let text =
       build_proxy_module_source(module, proxied_module, parsed_source_cache)?;
 
@@ -185,7 +180,7 @@ fn validate_original_import_map(
 }
 
 fn build_proxy_module_source(
-  module: &Module,
+  module: &EsmModule,
   proxied_module: &ProxiedModule,
   parsed_source_cache: &ParsedSourceCache,
 ) -> Result<String, AnyError> {
@@ -211,13 +206,11 @@ fn build_proxy_module_source(
   writeln!(text, "export * from \"{relative_specifier}\";").unwrap();
 
   // add a default export if one exists in the module
-  if let Some(parsed_source) =
-    parsed_source_cache.get_parsed_source_from_module(module)?
-  {
-    if has_default_export(&parsed_source) {
-      writeln!(text, "export {{ default }} from \"{relative_specifier}\";")
-        .unwrap();
-    }
+  let parsed_source =
+    parsed_source_cache.get_parsed_source_from_esm_module(module)?;
+  if has_default_export(&parsed_source) {
+    writeln!(text, "export {{ default }} from \"{relative_specifier}\";")
+      .unwrap();
   }
 
   Ok(text)
diff --git a/cli/tools/vendor/import_map.rs b/cli/tools/vendor/import_map.rs
index 3d2c1efd9..916eb55c5 100644
--- a/cli/tools/vendor/import_map.rs
+++ b/cli/tools/vendor/import_map.rs
@@ -4,7 +4,6 @@ use deno_ast::LineAndColumnIndex;
 use deno_ast::ModuleSpecifier;
 use deno_ast::SourceTextInfo;
 use deno_core::error::AnyError;
-use deno_graph::MediaType;
 use deno_graph::Module;
 use deno_graph::ModuleGraph;
 use deno_graph::Position;
@@ -205,21 +204,20 @@ fn visit_modules(
   parsed_source_cache: &ParsedSourceCache,
 ) -> Result<(), AnyError> {
   for module in modules {
-    if module.media_type == MediaType::Json {
+    let module = match module {
+      Module::Esm(module) => module,
       // skip visiting Json modules as they are leaves
-      continue;
-    }
-
-    let text_info =
-      match parsed_source_cache.get_parsed_source_from_module(module)? {
-        Some(source) => source.text_info().clone(),
-        None => continue,
-      };
-    let source_text = match &module.maybe_source {
-      Some(source) => source,
-      None => continue,
+      Module::Json(_)
+      | Module::Npm(_)
+      | Module::Node(_)
+      | Module::External(_) => continue,
     };
 
+    let parsed_source =
+      parsed_source_cache.get_parsed_source_from_esm_module(module)?;
+    let text_info = parsed_source.text_info().clone();
+    let source_text = &module.source;
+
     for dep in module.dependencies.values() {
       visit_resolution(
         &dep.maybe_code,
@@ -291,7 +289,7 @@ fn handle_dep_specifier(
   mappings: &Mappings,
 ) {
   let specifier = match graph.get(unresolved_specifier) {
-    Some(module) => module.specifier.clone(),
+    Some(module) => module.specifier().clone(),
     // Ignore when None. The graph was previous validated so this is a
     // dynamic import that was missing and is ignored for vendoring
     None => return,
diff --git a/cli/tools/vendor/mappings.rs b/cli/tools/vendor/mappings.rs
index 399002ea3..1ecc14edf 100644
--- a/cli/tools/vendor/mappings.rs
+++ b/cli/tools/vendor/mappings.rs
@@ -39,8 +39,9 @@ impl Mappings {
     remote_modules: &[&Module],
     output_dir: &Path,
   ) -> Result<Self, AnyError> {
-    let partitioned_specifiers =
-      partition_by_root_specifiers(remote_modules.iter().map(|m| &m.specifier));
+    let partitioned_specifiers = partition_by_root_specifiers(
+      remote_modules.iter().map(|m| m.specifier()),
+    );
     let mut mapped_paths = HashSet::new();
     let mut mappings = HashMap::new();
     let mut proxies = HashMap::new();
@@ -52,7 +53,12 @@ impl Mappings {
         &mut mapped_paths,
       );
       for specifier in specifiers {
-        let media_type = graph.get(&specifier).unwrap().media_type;
+        let module = graph.get(&specifier).unwrap();
+        let media_type = match module {
+          Module::Esm(module) => module.media_type,
+          Module::Json(_) => MediaType::Json,
+          Module::Node(_) | Module::Npm(_) | Module::External(_) => continue,
+        };
         let sub_path = sanitize_filepath(&make_url_relative(&root, &{
           let mut specifier = specifier.clone();
           specifier.set_query(None);
@@ -75,28 +81,30 @@ impl Mappings {
 
     // resolve all the "proxy" paths to use for when an x-typescript-types header is specified
     for module in remote_modules {
-      if let Some(resolved) = &module
-        .maybe_types_dependency
-        .as_ref()
-        .and_then(|d| d.dependency.ok())
-      {
-        let range = &resolved.range;
-        // hack to tell if it's an x-typescript-types header
-        let is_ts_types_header =
-          range.start == Position::zeroed() && range.end == Position::zeroed();
-        if is_ts_types_header {
-          let module_path = mappings.get(&module.specifier).unwrap();
-          let proxied_path = get_unique_path(
-            path_with_stem_suffix(module_path, ".proxied"),
-            &mut mapped_paths,
-          );
-          proxies.insert(
-            module.specifier.clone(),
-            ProxiedModule {
-              output_path: proxied_path,
-              declaration_specifier: resolved.specifier.clone(),
-            },
-          );
+      if let Some(module) = module.esm() {
+        if let Some(resolved) = &module
+          .maybe_types_dependency
+          .as_ref()
+          .and_then(|d| d.dependency.ok())
+        {
+          let range = &resolved.range;
+          // hack to tell if it's an x-typescript-types header
+          let is_ts_types_header = range.start == Position::zeroed()
+            && range.end == Position::zeroed();
+          if is_ts_types_header {
+            let module_path = mappings.get(&module.specifier).unwrap();
+            let proxied_path = get_unique_path(
+              path_with_stem_suffix(module_path, ".proxied"),
+              &mut mapped_paths,
+            );
+            proxies.insert(
+              module.specifier.clone(),
+              ProxiedModule {
+                output_path: proxied_path,
+                declaration_specifier: resolved.specifier.clone(),
+              },
+            );
+          }
         }
       }
     }
diff --git a/cli/tools/vendor/test.rs b/cli/tools/vendor/test.rs
index 874b329da..aed2a852c 100644
--- a/cli/tools/vendor/test.rs
+++ b/cli/tools/vendor/test.rs
@@ -20,6 +20,8 @@ use deno_graph::ModuleGraph;
 use import_map::ImportMap;
 
 use crate::cache::ParsedSourceCache;
+use crate::npm::NpmRegistryApi;
+use crate::npm::NpmResolution;
 use crate::resolver::CliGraphResolver;
 
 use super::build::VendorEnvironment;
@@ -260,8 +262,19 @@ async fn build_test_graph(
   mut loader: TestLoader,
   analyzer: &dyn deno_graph::ModuleAnalyzer,
 ) -> ModuleGraph {
-  let resolver = original_import_map
-    .map(|m| CliGraphResolver::new(None, Some(Arc::new(m)), None));
+  let resolver = original_import_map.map(|m| {
+    let npm_registry_api = NpmRegistryApi::new_uninitialized();
+    let npm_resolution =
+      NpmResolution::new(npm_registry_api.clone(), None, None);
+    CliGraphResolver::new(
+      None,
+      Some(Arc::new(m)),
+      false,
+      npm_registry_api,
+      npm_resolution,
+      None,
+    )
+  });
   let mut graph = ModuleGraph::default();
   graph
     .build(