refactor(ext/node): allow injecting `NodeFs` from CLI (#18829)

This allows providing a `NodeFs` as part of the `WorkerOptions`.

13 files changed, 74 insertions, 59 deletions

diff --git a/cli/build.rs b/cli/build.rs
index 9be441bcc..7a3252e20 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -2,6 +2,7 @@
 
 use std::env;
 use std::path::PathBuf;
+use std::sync::Arc;
 
 use deno_core::snapshot_util::*;
 use deno_core::Extension;
@@ -361,7 +362,10 @@ fn create_cli_snapshot(snapshot_path: PathBuf) {
     deno_http::deno_http::init_ops(),
     deno_io::deno_io::init_ops(Default::default()),
     deno_fs::deno_fs::init_ops::<_, PermissionsContainer>(false, StdFs),
-    deno_node::deno_node::init_ops::<deno_runtime::RuntimeNodeEnv>(None),
+    deno_node::deno_node::init_ops::<deno_runtime::RuntimeNodeEnv>(
+      None,
+      Some(Arc::new(deno_node::RealFs)),
+    ),
     cli::init_ops_and_esm(), // NOTE: This needs to be init_ops_and_esm!
   ];
 
diff --git a/cli/lsp/documents.rs b/cli/lsp/documents.rs
index fd40bb95f..31aa3ae8e 100644
--- a/cli/lsp/documents.rs
+++ b/cli/lsp/documents.rs
@@ -17,7 +17,6 @@ use crate::file_fetcher::get_source_from_bytes;
 use crate::file_fetcher::map_content_type;
 use crate::file_fetcher::SUPPORTED_SCHEMES;
 use crate::lsp::logging::lsp_warn;
-use crate::node::CliNodeResolver;
 use crate::npm::CliNpmRegistryApi;
 use crate::npm::NpmResolution;
 use crate::npm::PackageJsonDepsInstaller;
@@ -39,8 +38,8 @@ 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::deno_node::RealFs;
 use deno_runtime::permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReq;
 use deno_semver::npm::NpmPackageReqReference;
@@ -1057,7 +1056,7 @@ impl Documents {
     &self,
     specifiers: Vec<String>,
     referrer_doc: &AssetOrDocument,
-    maybe_node_resolver: Option<&Arc<CliNodeResolver>>,
+    maybe_node_resolver: Option<&Arc<NodeResolver>>,
   ) -> Vec<Option<(ModuleSpecifier, MediaType)>> {
     let referrer = referrer_doc.specifier();
     let dependencies = match referrer_doc {
@@ -1071,7 +1070,7 @@ impl Documents {
           // we're in an npm package, so use node resolution
           results.push(Some(NodeResolution::into_specifier_and_media_type(
             node_resolver
-              .resolve::<RealFs>(
+              .resolve(
                 &specifier,
                 referrer,
                 NodeResolutionMode::Types,
@@ -1419,7 +1418,7 @@ impl Documents {
   fn resolve_dependency(
     &self,
     specifier: &ModuleSpecifier,
-    maybe_node_resolver: Option<&Arc<CliNodeResolver>>,
+    maybe_node_resolver: Option<&Arc<NodeResolver>>,
   ) -> Option<(ModuleSpecifier, MediaType)> {
     if let Ok(npm_ref) = NpmPackageReqReference::from_specifier(specifier) {
       return node_resolve_npm_req_ref(npm_ref, maybe_node_resolver);
@@ -1454,12 +1453,12 @@ impl Documents {
 
 fn node_resolve_npm_req_ref(
   npm_req_ref: NpmPackageReqReference,
-  maybe_node_resolver: Option<&Arc<CliNodeResolver>>,
+  maybe_node_resolver: Option<&Arc<NodeResolver>>,
 ) -> Option<(ModuleSpecifier, MediaType)> {
   maybe_node_resolver.map(|node_resolver| {
     NodeResolution::into_specifier_and_media_type(
       node_resolver
-        .resolve_npm_req_reference::<RealFs>(
+        .resolve_npm_req_reference(
           &npm_req_ref,
           NodeResolutionMode::Types,
           &mut PermissionsContainer::allow_all(),
diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs
index f1b9cb434..e7968a665 100644
--- a/cli/lsp/language_server.rs
+++ b/cli/lsp/language_server.rs
@@ -9,6 +9,7 @@ use deno_core::serde_json;
 use deno_core::serde_json::json;
 use deno_core::serde_json::Value;
 use deno_core::ModuleSpecifier;
+use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_node::PackageJson;
 use deno_runtime::deno_web::BlobStore;
@@ -79,7 +80,6 @@ use crate::file_fetcher::FileFetcher;
 use crate::graph_util;
 use crate::http_util::HttpClient;
 use crate::lsp::urls::LspUrlKind;
-use crate::node::CliNodeResolver;
 use crate::npm::create_npm_fs_resolver;
 use crate::npm::CliNpmRegistryApi;
 use crate::npm::CliNpmResolver;
@@ -103,7 +103,7 @@ pub struct StateSnapshot {
   pub cache_metadata: cache::CacheMetadata,
   pub documents: Documents,
   pub maybe_import_map: Option<Arc<ImportMap>>,
-  pub maybe_node_resolver: Option<Arc<CliNodeResolver>>,
+  pub maybe_node_resolver: Option<Arc<NodeResolver>>,
   pub maybe_npm_resolver: Option<Arc<CliNpmResolver>>,
 }
 
@@ -449,6 +449,7 @@ fn create_lsp_structs(
   let resolution =
     Arc::new(NpmResolution::from_serialized(api.clone(), None, None));
   let fs_resolver = create_npm_fs_resolver(
+    Arc::new(deno_node::RealFs),
     npm_cache.clone(),
     &progress_bar,
     registry_url.clone(),
@@ -700,9 +701,11 @@ impl Inner {
       self.npm_resolution.snapshot(),
       None,
     ));
+    let node_fs = Arc::new(deno_node::RealFs);
     let npm_resolver = Arc::new(CliNpmResolver::new(
       npm_resolution.clone(),
       create_npm_fs_resolver(
+        node_fs.clone(),
         self.npm_cache.clone(),
         &ProgressBar::new(ProgressBarStyle::TextOnly),
         self.npm_api.base_url().clone(),
@@ -711,7 +714,8 @@ impl Inner {
       ),
       None,
     ));
-    let node_resolver = Arc::new(NodeResolver::new(npm_resolver.clone()));
+    let node_resolver =
+      Arc::new(NodeResolver::new(node_fs, npm_resolver.clone()));
     Arc::new(StateSnapshot {
       assets: self.assets.snapshot(),
       cache_metadata: self.cache_metadata.clone(),
diff --git a/cli/module_loader.rs b/cli/module_loader.rs
index c4ef0ed7e..5a7743ef2 100644
--- a/cli/module_loader.rs
+++ b/cli/module_loader.rs
@@ -12,7 +12,6 @@ use crate::graph_util::ModuleGraphBuilder;
 use crate::graph_util::ModuleGraphContainer;
 use crate::node;
 use crate::node::CliNodeCodeTranslator;
-use crate::node::CliNodeResolver;
 use crate::proc_state::CjsResolutionStore;
 use crate::proc_state::FileWatcherReporter;
 use crate::proc_state::ProcState;
@@ -51,7 +50,7 @@ use deno_lockfile::Lockfile;
 use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolution;
 use deno_runtime::deno_node::NodeResolutionMode;
-use deno_runtime::deno_node::RealFs;
+use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReqReference;
 use std::borrow::Cow;
@@ -244,7 +243,7 @@ pub struct CliModuleLoader {
   graph_container: Arc<ModuleGraphContainer>,
   module_load_preparer: Arc<ModuleLoadPreparer>,
   node_code_translator: Arc<CliNodeCodeTranslator>,
-  node_resolver: Arc<CliNodeResolver>,
+  node_resolver: Arc<NodeResolver>,
   parsed_source_cache: Arc<ParsedSourceCache>,
   resolver: Arc<CliGraphResolver>,
 }
@@ -387,7 +386,7 @@ impl CliModuleLoader {
           self.root_permissions.clone()
         };
         // translate cjs to esm if it's cjs and inject node globals
-        self.node_code_translator.translate_cjs_to_esm::<RealFs>(
+        self.node_code_translator.translate_cjs_to_esm(
           specifier,
           &code,
           &mut permissions,
@@ -466,7 +465,7 @@ impl ModuleLoader for CliModuleLoader {
       if self.node_resolver.in_npm_package(referrer) {
         // we're in an npm package, so use node resolution
         return self
-          .handle_node_resolve_result(self.node_resolver.resolve::<RealFs>(
+          .handle_node_resolve_result(self.node_resolver.resolve(
             specifier,
             referrer,
             NodeResolutionMode::Execution,
@@ -492,7 +491,7 @@ impl ModuleLoader for CliModuleLoader {
           return match graph.get(specifier) {
             Some(Module::Npm(module)) => self
               .handle_node_resolve_result(
-                self.node_resolver.resolve_npm_reference::<RealFs>(
+                self.node_resolver.resolve_npm_reference(
                   &module.nv_reference,
                   NodeResolutionMode::Execution,
                   &mut permissions,
@@ -554,7 +553,7 @@ impl ModuleLoader for CliModuleLoader {
         {
           return self
             .handle_node_resolve_result(
-              self.node_resolver.resolve_npm_req_reference::<RealFs>(
+              self.node_resolver.resolve_npm_req_reference(
                 &reference,
                 NodeResolutionMode::Execution,
                 &mut permissions,
diff --git a/cli/node.rs b/cli/node.rs
index 3ec9500e8..8b54d0d42 100644
--- a/cli/node.rs
+++ b/cli/node.rs
@@ -1,7 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
 use std::collections::HashSet;
-use std::sync::Arc;
 
 use deno_ast::swc::common::SyntaxContext;
 use deno_ast::view::Node;
@@ -15,15 +14,11 @@ use deno_core::error::AnyError;
 use deno_runtime::deno_node::analyze::CjsAnalysis as ExtNodeCjsAnalysis;
 use deno_runtime::deno_node::analyze::CjsEsmCodeAnalyzer;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
-use deno_runtime::deno_node::NodeResolver;
 
 use crate::cache::NodeAnalysisCache;
-use crate::npm::CliNpmResolver;
 use crate::util::fs::canonicalize_path_maybe_not_exists;
 
-pub type CliNodeCodeTranslator =
-  NodeCodeTranslator<CliCjsEsmCodeAnalyzer, Arc<CliNpmResolver>>;
-pub type CliNodeResolver = NodeResolver<Arc<CliNpmResolver>>;
+pub type CliNodeCodeTranslator = NodeCodeTranslator<CliCjsEsmCodeAnalyzer>;
 
 /// Resolves a specifier that is pointing into a node_modules folder.
 ///
diff --git a/cli/npm/resolvers/local.rs b/cli/npm/resolvers/local.rs
index a44afc935..e2919f6ee 100644
--- a/cli/npm/resolvers/local.rs
+++ b/cli/npm/resolvers/local.rs
@@ -23,6 +23,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
 use deno_npm::NpmPackageCacheFolderId;
 use deno_npm::NpmPackageId;
 use deno_runtime::deno_core::futures;
+use deno_runtime::deno_node::NodeFs;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::PackageJson;
@@ -43,6 +44,7 @@ use super::common::NpmPackageFsResolver;
 /// and resolves packages from it.
 #[derive(Debug)]
 pub struct LocalNpmPackageResolver {
+  fs: Arc<dyn NodeFs>,
   cache: Arc<NpmCache>,
   progress_bar: ProgressBar,
   resolution: Arc<NpmResolution>,
@@ -53,6 +55,7 @@ pub struct LocalNpmPackageResolver {
 
 impl LocalNpmPackageResolver {
   pub fn new(
+    fs: Arc<dyn NodeFs>,
     cache: Arc<NpmCache>,
     progress_bar: ProgressBar,
     registry_url: Url,
@@ -60,6 +63,7 @@ impl LocalNpmPackageResolver {
     resolution: Arc<NpmResolution>,
   ) -> Self {
     Self {
+      fs,
       cache,
       progress_bar,
       resolution,
@@ -149,9 +153,10 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
       if sub_dir.is_dir() {
         // if doing types resolution, only resolve the package if it specifies a types property
         if mode.is_types() && !name.starts_with("@types/") {
-          let package_json = PackageJson::load_skip_read_permission::<
-            deno_runtime::deno_node::RealFs,
-          >(sub_dir.join("package.json"))?;
+          let package_json = PackageJson::load_skip_read_permission(
+            &*self.fs,
+            sub_dir.join("package.json"),
+          )?;
           if package_json.types.is_some() {
             return Ok(sub_dir);
           }
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index 8b871beaf..fa83cdf59 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -18,6 +18,7 @@ use deno_npm::resolution::NpmResolutionSnapshot;
 use deno_npm::resolution::PackageReqNotFoundError;
 use deno_npm::resolution::SerializedNpmResolutionSnapshot;
 use deno_npm::NpmPackageId;
+use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodePermissions;
 use deno_runtime::deno_node::NodeResolutionMode;
 use deno_runtime::deno_node::NpmResolver;
@@ -269,6 +270,7 @@ impl NpmResolver for CliNpmResolver {
 }
 
 pub fn create_npm_fs_resolver(
+  fs: Arc<dyn deno_node::NodeFs>,
   cache: Arc<NpmCache>,
   progress_bar: &ProgressBar,
   registry_url: Url,
@@ -277,6 +279,7 @@ pub fn create_npm_fs_resolver(
 ) -> Arc<dyn NpmPackageFsResolver> {
   match maybe_node_modules_path {
     Some(node_modules_folder) => Arc::new(LocalNpmPackageResolver::new(
+      fs,
       cache,
       progress_bar.clone(),
       registry_url,
diff --git a/cli/proc_state.rs b/cli/proc_state.rs
index 6b7e9b1f2..b6529d3a0 100644
--- a/cli/proc_state.rs
+++ b/cli/proc_state.rs
@@ -19,7 +19,6 @@ use crate::http_util::HttpClient;
 use crate::module_loader::ModuleLoadPreparer;
 use crate::node::CliCjsEsmCodeAnalyzer;
 use crate::node::CliNodeCodeTranslator;
-use crate::node::CliNodeResolver;
 use crate::npm::create_npm_fs_resolver;
 use crate::npm::CliNpmRegistryApi;
 use crate::npm::CliNpmResolver;
@@ -38,6 +37,7 @@ use deno_core::ModuleSpecifier;
 use deno_core::SharedArrayBufferStore;
 
 use deno_runtime::deno_broadcast_channel::InMemoryBroadcastChannel;
+use deno_runtime::deno_node;
 use deno_runtime::deno_node::analyze::NodeCodeTranslator;
 use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::deno_tls::rustls::RootCertStore;
@@ -79,7 +79,8 @@ pub struct Inner {
   pub module_graph_builder: Arc<ModuleGraphBuilder>,
   pub module_load_preparer: Arc<ModuleLoadPreparer>,
   pub node_code_translator: Arc<CliNodeCodeTranslator>,
-  pub node_resolver: Arc<CliNodeResolver>,
+  pub node_fs: Arc<dyn deno_node::NodeFs>,
+  pub node_resolver: Arc<NodeResolver>,
   pub npm_api: Arc<CliNpmRegistryApi>,
   pub npm_cache: Arc<NpmCache>,
   pub npm_resolver: Arc<CliNpmResolver>,
@@ -150,6 +151,7 @@ impl ProcState {
       module_graph_builder: self.module_graph_builder.clone(),
       module_load_preparer: self.module_load_preparer.clone(),
       node_code_translator: self.node_code_translator.clone(),
+      node_fs: self.node_fs.clone(),
       node_resolver: self.node_resolver.clone(),
       npm_api: self.npm_api.clone(),
       npm_cache: self.npm_cache.clone(),
@@ -245,7 +247,9 @@ impl ProcState {
       npm_snapshot,
       lockfile.as_ref().cloned(),
     ));
+    let node_fs = Arc::new(deno_node::RealFs);
     let npm_fs_resolver = create_npm_fs_resolver(
+      node_fs.clone(),
       npm_cache,
       &progress_bar,
       npm_registry_url,
@@ -308,11 +312,14 @@ impl ProcState {
     let node_analysis_cache =
       NodeAnalysisCache::new(caches.node_analysis_db(&dir));
     let cjs_esm_analyzer = CliCjsEsmCodeAnalyzer::new(node_analysis_cache);
+    let node_resolver =
+      Arc::new(NodeResolver::new(node_fs.clone(), npm_resolver.clone()));
     let node_code_translator = Arc::new(NodeCodeTranslator::new(
       cjs_esm_analyzer,
+      node_fs.clone(),
+      node_resolver.clone(),
       npm_resolver.clone(),
     ));
-    let node_resolver = Arc::new(NodeResolver::new(npm_resolver.clone()));
     let type_checker = Arc::new(TypeChecker::new(
       dir.clone(),
       caches.clone(),
@@ -365,6 +372,7 @@ impl ProcState {
       maybe_file_watcher_reporter,
       module_graph_builder,
       node_code_translator,
+      node_fs,
       node_resolver,
       npm_api,
       npm_cache,
diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index a2872e9b9..669ad1d81 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -190,6 +190,7 @@ fn create_web_worker_callback(
       root_cert_store: Some(ps.root_cert_store.clone()),
       seed: ps.options.seed(),
       module_loader,
+      node_fs: Some(ps.node_fs.clone()),
       npm_resolver: None, // not currently supported
       create_web_worker_cb,
       preload_module_cb: web_worker_cb.clone(),
@@ -285,6 +286,7 @@ pub async fn run(
     should_break_on_first_statement: false,
     should_wait_for_inspector_session: false,
     module_loader,
+    node_fs: Some(ps.node_fs.clone()),
     npm_resolver: None, // not currently supported
     get_error_class_fn: Some(&get_error_class_name),
     cache_storage_dir: None,
diff --git a/cli/tools/check.rs b/cli/tools/check.rs
index 36bc25d6a..4fb6800fa 100644
--- a/cli/tools/check.rs
+++ b/cli/tools/check.rs
@@ -9,6 +9,7 @@ use deno_core::error::AnyError;
 use deno_graph::Module;
 use deno_graph::ModuleGraph;
 use deno_runtime::colors;
+use deno_runtime::deno_node::NodeResolver;
 use once_cell::sync::Lazy;
 use regex::Regex;
 
@@ -21,7 +22,6 @@ use crate::cache::Caches;
 use crate::cache::DenoDir;
 use crate::cache::FastInsecureHasher;
 use crate::cache::TypeCheckCache;
-use crate::node::CliNodeResolver;
 use crate::npm::CliNpmResolver;
 use crate::tsc;
 use crate::version;
@@ -42,7 +42,7 @@ pub struct TypeChecker {
   deno_dir: DenoDir,
   caches: Arc<Caches>,
   cli_options: Arc<CliOptions>,
-  node_resolver: Arc<CliNodeResolver>,
+  node_resolver: Arc<NodeResolver>,
   npm_resolver: Arc<CliNpmResolver>,
 }
 
@@ -51,7 +51,7 @@ impl TypeChecker {
     deno_dir: DenoDir,
     caches: Arc<Caches>,
     cli_options: Arc<CliOptions>,
-    node_resolver: Arc<CliNodeResolver>,
+    node_resolver: Arc<NodeResolver>,
     npm_resolver: Arc<CliNpmResolver>,
   ) -> Self {
     Self {
diff --git a/cli/tools/task.rs b/cli/tools/task.rs
index 898cdd8d9..5d34d39c7 100644
--- a/cli/tools/task.rs
+++ b/cli/tools/task.rs
@@ -4,7 +4,6 @@ use crate::args::CliOptions;
 use crate::args::Flags;
 use crate::args::TaskFlags;
 use crate::colors;
-use crate::node::CliNodeResolver;
 use crate::npm::CliNpmResolver;
 use crate::proc_state::ProcState;
 use crate::util::fs::canonicalize_path;
@@ -13,7 +12,7 @@ use deno_core::anyhow::Context;
 use deno_core::error::AnyError;
 use deno_core::futures;
 use deno_core::futures::future::LocalBoxFuture;
-use deno_runtime::deno_node::RealFs;
+use deno_runtime::deno_node::NodeResolver;
 use deno_semver::npm::NpmPackageNv;
 use deno_task_shell::ExecuteResult;
 use deno_task_shell::ShellCommand;
@@ -236,13 +235,12 @@ impl ShellCommand for NpmPackageBinCommand {
 
 fn resolve_npm_commands(
   npm_resolver: &CliNpmResolver,
-  node_resolver: &CliNodeResolver,
+  node_resolver: &NodeResolver,
 ) -> Result<HashMap<String, Rc<dyn ShellCommand>>, AnyError> {
   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::<RealFs>(&id.nv)?;
+    let bin_commands = node_resolver.resolve_binary_commands(&id.nv)?;
     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 0d956b661..aa589a1ca 100644
--- a/cli/tsc/mod.rs
+++ b/cli/tsc/mod.rs
@@ -4,7 +4,6 @@ use crate::args::TsConfig;
 use crate::args::TypeCheckMode;
 use crate::cache::FastInsecureHasher;
 use crate::node;
-use crate::node::CliNodeResolver;
 use crate::util::checksum;
 use crate::util::path::mapped_specifier_for_tsc;
 
@@ -35,7 +34,7 @@ use deno_graph::ResolutionResolved;
 use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolution;
 use deno_runtime::deno_node::NodeResolutionMode;
-use deno_runtime::deno_node::RealFs;
+use deno_runtime::deno_node::NodeResolver;
 use deno_runtime::permissions::PermissionsContainer;
 use deno_semver::npm::NpmPackageReqReference;
 use lsp_types::Url;
@@ -307,7 +306,7 @@ pub struct Request {
   pub debug: bool,
   pub graph: Arc<ModuleGraph>,
   pub hash_data: u64,
-  pub maybe_node_resolver: Option<Arc<CliNodeResolver>>,
+  pub maybe_node_resolver: Option<Arc<NodeResolver>>,
   pub maybe_tsbuildinfo: Option<String>,
   /// A vector of strings that represent the root/entry point modules for the
   /// program.
@@ -331,7 +330,7 @@ struct State {
   graph: Arc<ModuleGraph>,
   maybe_tsbuildinfo: Option<String>,
   maybe_response: Option<RespondArgs>,
-  maybe_node_resolver: Option<Arc<CliNodeResolver>>,
+  maybe_node_resolver: Option<Arc<NodeResolver>>,
   remapped_specifiers: HashMap<String, ModuleSpecifier>,
   root_map: HashMap<String, ModuleSpecifier>,
   current_dir: PathBuf,
@@ -341,7 +340,7 @@ impl State {
   pub fn new(
     graph: Arc<ModuleGraph>,
     hash_data: u64,
-    maybe_node_resolver: Option<Arc<CliNodeResolver>>,
+    maybe_node_resolver: Option<Arc<NodeResolver>>,
     maybe_tsbuildinfo: Option<String>,
     root_map: HashMap<String, ModuleSpecifier>,
     remapped_specifiers: HashMap<String, ModuleSpecifier>,
@@ -637,7 +636,7 @@ fn resolve_graph_specifier_types(
     }
     Some(Module::Npm(module)) => {
       if let Some(node_resolver) = &state.maybe_node_resolver {
-        let maybe_resolution = node_resolver.resolve_npm_reference::<RealFs>(
+        let maybe_resolution = node_resolver.resolve_npm_reference(
           &module.nv_reference,
           NodeResolutionMode::Types,
           &mut PermissionsContainer::allow_all(),
@@ -655,9 +654,7 @@ fn resolve_graph_specifier_types(
         let specifier =
           node::resolve_specifier_into_node_modules(&module.specifier);
         NodeResolution::into_specifier_and_media_type(
-          node_resolver
-            .url_to_node_resolution::<RealFs>(specifier)
-            .ok(),
+          node_resolver.url_to_node_resolution(specifier).ok(),
         )
       }))
     }
@@ -678,7 +675,7 @@ fn resolve_non_graph_specifier_types(
     // we're in an npm package, so use node resolution
     Ok(Some(NodeResolution::into_specifier_and_media_type(
       node_resolver
-        .resolve::<RealFs>(
+        .resolve(
           specifier,
           referrer,
           NodeResolutionMode::Types,
@@ -692,7 +689,7 @@ fn resolve_non_graph_specifier_types(
     // 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::<RealFs>(
+    let maybe_resolution = node_resolver.resolve_npm_req_reference(
       &npm_ref,
       NodeResolutionMode::Types,
       &mut PermissionsContainer::allow_all(),
diff --git a/cli/worker.rs b/cli/worker.rs
index c73e4edbe..e565789ed 100644
--- a/cli/worker.rs
+++ b/cli/worker.rs
@@ -1,7 +1,6 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
 use std::path::PathBuf;
-use std::rc::Rc;
 use std::sync::Arc;
 
 use deno_ast::ModuleSpecifier;
@@ -14,7 +13,6 @@ use deno_core::ModuleId;
 use deno_runtime::colors;
 use deno_runtime::deno_node;
 use deno_runtime::deno_node::NodeResolution;
-use deno_runtime::deno_node::RealFs;
 use deno_runtime::fmt_errors::format_js_error;
 use deno_runtime::ops::worker_host::CreateWebWorkerCb;
 use deno_runtime::ops::worker_host::WorkerEventCb;
@@ -259,15 +257,13 @@ pub async fn create_custom_worker(
     ps.npm_resolver
       .add_package_reqs(vec![package_ref.req.clone()])
       .await?;
-    let node_resolution = ps
-      .node_resolver
-      .resolve_binary_export::<RealFs>(&package_ref)?;
+    let node_resolution =
+      ps.node_resolver.resolve_binary_export(&package_ref)?;
     let is_main_cjs = matches!(node_resolution, NodeResolution::CommonJs(_));
     (node_resolution.into_url(), is_main_cjs)
   } else if ps.options.is_npm_main() {
-    let node_resolution = ps
-      .node_resolver
-      .url_to_node_resolution::<RealFs>(main_module)?;
+    let node_resolution =
+      ps.node_resolver.url_to_node_resolution(main_module)?;
     let is_main_cjs = matches!(node_resolution, NodeResolution::CommonJs(_));
     (node_resolution.into_url(), is_main_cjs)
   } else {
@@ -345,7 +341,8 @@ pub async fn create_custom_worker(
     should_break_on_first_statement: ps.options.inspect_brk().is_some(),
     should_wait_for_inspector_session: ps.options.inspect_wait().is_some(),
     module_loader,
-    npm_resolver: Some(Rc::new(ps.npm_resolver.clone())),
+    node_fs: Some(ps.node_fs.clone()),
+    npm_resolver: Some(ps.npm_resolver.clone()),
     get_error_class_fn: Some(&errors::get_error_class_name),
     cache_storage_dir,
     origin_storage_dir,
@@ -468,7 +465,8 @@ fn create_web_worker_callback(
       format_js_error_fn: Some(Arc::new(format_js_error)),
       source_map_getter: Some(Box::new(module_loader.clone())),
       module_loader,
-      npm_resolver: Some(Rc::new(ps.npm_resolver.clone())),
+      node_fs: Some(ps.node_fs.clone()),
+      npm_resolver: Some(ps.npm_resolver.clone()),
       worker_type: args.worker_type,
       maybe_inspector_server,
       get_error_class_fn: Some(&errors::get_error_class_name),
@@ -492,6 +490,8 @@ fn create_web_worker_callback(
 
 #[cfg(test)]
 mod tests {
+  use std::rc::Rc;
+
   use super::*;
   use deno_core::resolve_path;
   use deno_core::FsModuleLoader;
@@ -520,6 +520,7 @@ mod tests {
       should_break_on_first_statement: false,
       should_wait_for_inspector_session: false,
       module_loader: Rc::new(FsModuleLoader),
+      node_fs: Some(Arc::new(deno_node::RealFs)),
       npm_resolver: None,
       get_error_class_fn: None,
       cache_storage_dir: None,