4 files changed, 68 insertions, 56 deletions

diff --git a/cli/npm/resolvers/common.rs b/cli/npm/resolvers/common.rs
index e8acc5c3a..a705052df 100644
--- a/cli/npm/resolvers/common.rs
+++ b/cli/npm/resolvers/common.rs
@@ -46,12 +46,12 @@ pub trait NpmPackageFsResolver: Send + Sync {
   fn resolve_package_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError>;
+  ) -> Result<Option<PathBuf>, AnyError>;
 
   fn resolve_package_cache_folder_id_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<NpmPackageCacheFolderId, AnyError>;
+  ) -> Result<Option<NpmPackageCacheFolderId>, AnyError>;
 
   async fn cache_packages(&self) -> Result<(), AnyError>;
 
diff --git a/cli/npm/resolvers/global.rs b/cli/npm/resolvers/global.rs
index d1962ff04..1181403b2 100644
--- a/cli/npm/resolvers/global.rs
+++ b/cli/npm/resolvers/global.rs
@@ -8,6 +8,7 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use deno_ast::ModuleSpecifier;
+use deno_core::anyhow::bail;
 use deno_core::error::AnyError;
 use deno_core::url::Url;
 use deno_npm::resolution::PackageNotFoundFromReferrerError;
@@ -97,9 +98,11 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
     referrer: &ModuleSpecifier,
     mode: NodeResolutionMode,
   ) -> Result<PathBuf, AnyError> {
-    let referrer_pkg_id = self
+    let Some(referrer_pkg_id) = self
       .cache
-      .resolve_package_folder_id_from_specifier(referrer, &self.registry_url)?;
+      .resolve_package_folder_id_from_specifier(referrer, &self.registry_url) else {
+        bail!("could not find npm package for '{}'", referrer);
+      };
     let pkg = if mode.is_types() && !name.starts_with("@types/") {
       // attempt to resolve the types package first, then fallback to the regular package
       match self.resolve_types_package(name, &referrer_pkg_id) {
@@ -119,25 +122,30 @@ impl NpmPackageFsResolver for GlobalNpmPackageResolver {
   fn resolve_package_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError> {
-    let pkg_folder_id = self.cache.resolve_package_folder_id_from_specifier(
+  ) -> Result<Option<PathBuf>, AnyError> {
+    let Some(pkg_folder_id) = self.cache.resolve_package_folder_id_from_specifier(
       specifier,
       &self.registry_url,
-    )?;
-    Ok(
+    ) else {
+      return Ok(None);
+    };
+    Ok(Some(
       self
         .cache
         .package_folder_for_id(&pkg_folder_id, &self.registry_url),
-    )
+    ))
   }
 
   fn resolve_package_cache_folder_id_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<NpmPackageCacheFolderId, AnyError> {
-    self
-      .cache
-      .resolve_package_folder_id_from_specifier(specifier, &self.registry_url)
+  ) -> Result<Option<NpmPackageCacheFolderId>, AnyError> {
+    Ok(
+      self.cache.resolve_package_folder_id_from_specifier(
+        specifier,
+        &self.registry_url,
+      ),
+    )
   }
 
   async fn cache_packages(&self) -> Result<(), AnyError> {
diff --git a/cli/npm/resolvers/local.rs b/cli/npm/resolvers/local.rs
index 42cd0cc9e..4f8d7b709 100644
--- a/cli/npm/resolvers/local.rs
+++ b/cli/npm/resolvers/local.rs
@@ -109,31 +109,27 @@ impl LocalNpmPackageResolver {
   fn resolve_folder_for_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError> {
-    match self.maybe_resolve_folder_for_specifier(specifier) {
-      // Canonicalize the path so it's not pointing to the symlinked directory
-      // in `node_modules` directory of the referrer.
-      Some(path) => canonicalize_path_maybe_not_exists_with_fs(&path, |path| {
-        self
-          .fs
-          .realpath_sync(path)
-          .map_err(|err| err.into_io_error())
-      })
-      .map_err(|err| err.into()),
-      None => bail!("could not find npm package for '{}'", specifier),
-    }
-  }
-
-  fn maybe_resolve_folder_for_specifier(
-    &self,
-    specifier: &ModuleSpecifier,
-  ) -> Option<PathBuf> {
-    let relative_url = self.root_node_modules_url.make_relative(specifier)?;
+  ) -> Result<Option<PathBuf>, AnyError> {
+    let Some(relative_url) = self.root_node_modules_url.make_relative(specifier) else {
+      return Ok(None);
+    };
     if relative_url.starts_with("../") {
-      return None;
+      return Ok(None);
     }
     // it's within the directory, so use it
-    specifier.to_file_path().ok()
+    let Some(path) = specifier.to_file_path().ok() else {
+      return Ok(None);
+    };
+    // Canonicalize the path so it's not pointing to the symlinked directory
+    // in `node_modules` directory of the referrer.
+    canonicalize_path_maybe_not_exists_with_fs(&path, |path| {
+      self
+        .fs
+        .realpath_sync(path)
+        .map_err(|err| err.into_io_error())
+    })
+    .map(Some)
+    .map_err(|err| err.into())
   }
 }
 
@@ -172,7 +168,9 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
     referrer: &ModuleSpecifier,
     mode: NodeResolutionMode,
   ) -> Result<PathBuf, AnyError> {
-    let local_path = self.resolve_folder_for_specifier(referrer)?;
+    let Some(local_path) = self.resolve_folder_for_specifier(referrer)? else {
+      bail!("could not find npm package for '{}'", referrer);
+    };
     let package_root_path = self.resolve_package_root(&local_path);
     let mut current_folder = package_root_path.as_path();
     loop {
@@ -220,22 +218,23 @@ impl NpmPackageFsResolver for LocalNpmPackageResolver {
   fn resolve_package_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError> {
-    let local_path = self.resolve_folder_for_specifier(specifier)?;
+  ) -> Result<Option<PathBuf>, AnyError> {
+    let Some(local_path) = self.resolve_folder_for_specifier(specifier)? else {
+      return Ok(None);
+    };
     let package_root_path = self.resolve_package_root(&local_path);
-    Ok(package_root_path)
+    Ok(Some(package_root_path))
   }
 
   fn resolve_package_cache_folder_id_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<NpmPackageCacheFolderId, AnyError> {
-    let folder_path = self.resolve_package_folder_from_specifier(specifier)?;
+  ) -> Result<Option<NpmPackageCacheFolderId>, AnyError> {
+    let Some(folder_path) = self.resolve_package_folder_from_specifier(specifier)? else {
+      return Ok(None);
+    };
     let folder_name = folder_path.parent().unwrap().to_string_lossy();
-    match get_package_folder_id_from_folder_name(&folder_name) {
-      Some(package_folder_id) => Ok(package_folder_id),
-      None => bail!("could not resolve package from specifier '{}'", specifier),
-    }
+    Ok(get_package_folder_id_from_folder_name(&folder_name))
   }
 
   async fn cache_packages(&self) -> Result<(), AnyError> {
diff --git a/cli/npm/resolvers/mod.rs b/cli/npm/resolvers/mod.rs
index 39fcba3fc..d46b6da6e 100644
--- a/cli/npm/resolvers/mod.rs
+++ b/cli/npm/resolvers/mod.rs
@@ -131,31 +131,35 @@ impl CliNpmResolver {
   pub fn resolve_package_folder_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<PathBuf, AnyError> {
-    let path = self
+  ) -> Result<Option<PathBuf>, AnyError> {
+    let Some(path) = self
       .fs_resolver
-      .resolve_package_folder_from_specifier(specifier)?;
+      .resolve_package_folder_from_specifier(specifier)? else {
+        return Ok(None);
+      };
     log::debug!(
       "Resolved package folder of {} to {}",
       specifier,
       path.display()
     );
-    Ok(path)
+    Ok(Some(path))
   }
 
   /// Resolves the package nv from the provided specifier.
   pub fn resolve_package_id_from_specifier(
     &self,
     specifier: &ModuleSpecifier,
-  ) -> Result<NpmPackageId, AnyError> {
-    let cache_folder_id = self
+  ) -> Result<Option<NpmPackageId>, AnyError> {
+    let Some(cache_folder_id) = self
       .fs_resolver
-      .resolve_package_cache_folder_id_from_specifier(specifier)?;
-    Ok(
+      .resolve_package_cache_folder_id_from_specifier(specifier)? else {
+return Ok(None);
+      };
+    Ok(Some(
       self
         .resolution
         .resolve_pkg_id_from_pkg_cache_folder_id(&cache_folder_id)?,
-    )
+    ))
   }
 
   /// Attempts to get the package size in bytes.
@@ -268,7 +272,7 @@ impl NpmResolver for CliNpmResolver {
   fn resolve_package_folder_from_path(
     &self,
     path: &Path,
-  ) -> Result<PathBuf, AnyError> {
+  ) -> Result<Option<PathBuf>, AnyError> {
     let specifier = path_to_specifier(path)?;
     self.resolve_package_folder_from_specifier(&specifier)
   }
@@ -291,7 +295,8 @@ impl NpmResolver for CliNpmResolver {
   fn in_npm_package(&self, specifier: &ModuleSpecifier) -> bool {
     self
       .resolve_package_folder_from_specifier(specifier)
-      .is_ok()
+      .map(|p| p.is_some())
+      .unwrap_or(false)
   }
 
   fn ensure_read_permission(