resolver: read package.json exports for a package found through NODE_PATH

docs/runtime/module-resolution.mdx

@@ -268,6 +268,8 @@ NODE_PATH=./packages:./lib bun run src/index.js  # Unix/macOS
 NODE_PATH="./packages;./lib" bun run src/index.js  # Windows
 ```
 
+Bun reads the `exports` field of a package that it finds through `NODE_PATH`.
+
 ### Custom conditions
 
 The `--conditions` flag specifies the conditions to use when resolving packages from `package.json` `"exports"`.

src/resolver/resolver.rs

@@ -3064,6 +3064,22 @@ impl<'a> Resolver<'a> {
         if !node_path.is_empty() {
             let delim = if cfg!(windows) { b';' } else { b':' };
             for path in node_path.split(|&b| b == delim).filter(|s| !s.is_empty()) {
+                // A subpath that did not fit the buffer is empty.
+                if let Some(esm) = esm_.as_ref()
+                    && !esm.subpath.is_empty()
+                    && let Some(status) = self.load_node_path_package_exports(
+                        path,
+                        import_path,
+                        esm.subpath,
+                        kind,
+                        out,
+                    )
+                {
+                    if let Some(d) = self.debug_logs.as_mut() {
+                        d.decrease_indent();
+                    }
+                    return status;
+                }
                 let Some(abs_path) = self
                     .fs_ref()
                     .abs_buf_checked(&[path, import_path], bufs!(node_modules_check))
@@ -3845,6 +3861,95 @@ impl<'a> Resolver<'a> {
         unreachable!("TODO: implement enqueueDependencyToResolve for non-root packages")
     }
 
+    /// The file that "exports" of a package in `node_path`, a `NODE_PATH` entry, has for `subpath`, which is `import_path` without the name of the package. `None` without one: the caller goes on to `load_as_file_or_directory`.
+    #[cold]
+    #[inline(never)]
+    fn load_node_path_package_exports(
+        &mut self,
+        node_path: &[u8],
+        import_path: &[u8],
+        subpath: &[u8],
+        kind: ast::ImportKind,
+        out: &mut MatchResult,
+    ) -> Option<MatchStatus> {
+        use crate::package_json::EntryData;
+
+        // As in Node, the folder has the whole text in front of the subpath as its name: `npkg@1.2.3`, not `npkg`.
+        let name = import_path.get(..(import_path.len() + 1).checked_sub(subpath.len())?)?;
+        let abs_package_path = self
+            .fs_ref()
+            .abs_buf_checked(&[node_path, name], bufs!(esm_absolute_package_path))?;
+        // `dir_info_cached` opens a file of this name on every call, because it does not remember ENOTDIR.
+        let is_listed_file = bun_paths::dirname(abs_package_path)
+            .and_then(|parent| self.dir_info_cached(parent).ok().flatten())
+            .and_then(|parent| {
+                parent.get_entry(self.generation, bun_paths::basename(abs_package_path))
+            })
+            .is_some_and(|found| {
+                found.entry().kind(self.rfs_ref(), self.store_fd) != Fs::file_system::EntryKind::Dir
+            });
+        if is_listed_file {
+            return None;
+        }
+        let package = self.dir_info_cached(abs_package_path).ok().flatten()?;
+        let package_json = package.package_json()?;
+        // Node loads "main" when "exports" is `false` or a number.
+        let exports_map = package_json.exports.as_ref().filter(|exports| {
+            matches!(
+                exports.root.data,
+                EntryData::String(_) | EntryData::Array(_) | EntryData::Map(_)
+            )
+        })?;
+        if let Some(debug) = self.debug_logs.as_mut() {
+            debug.add_note_fmt(format_args!(
+                "Reading \"exports\" of the package in the NODE_PATH directory \"{}\"",
+                bstr::BStr::new(abs_package_path)
+            ));
+        }
+
+        let prev_extension_order = self.extension_order;
+        // A `NODE_PATH` entry need not be in node_modules.
+        self.extension_order = self
+            .opts
+            .extension_order
+            .kind(kind, package.is_inside_node_modules());
+        // The node_modules lookup also reads `pkg/key.js` as the key "./key".
+        let without_js = (bun_paths::extension(subpath) == b".js" && subpath.len() > 3)
+            .then(|| &subpath[..subpath.len() - 3]);
+        let mut is_found = false;
+        for key in core::iter::once(subpath).chain(without_js) {
+            let esm_resolution = ESModule {
+                conditions: match kind {
+                    ast::ImportKind::Require | ast::ImportKind::RequireResolve => {
+                        &self.opts.conditions.require
+                    }
+                    ast::ImportKind::At | ast::ImportKind::AtConditional => {
+                        &self.opts.conditions.style
+                    }
+                    _ => &self.opts.conditions.import,
+                },
+                debug_logs: self.debug_logs.as_mut(),
+                stack_check: StackCheck::init(),
+            }
+            .resolve(b"/", key, &exports_map.root);
+            is_found = self
+                .handle_esm_resolution(
+                    esm_resolution,
+                    abs_package_path,
+                    kind,
+                    package_json,
+                    subpath,
+                    out,
+                )
+                .is_success();
+            if is_found {
+                break;
+            }
+        }
+        self.extension_order = prev_extension_order;
+        is_found.then_some(MatchStatus::Success)
+    }
+
     fn handle_esm_resolution(
         &mut self,
         mut esm_resolution: crate::package_json::Resolution,

src/sema/resolve/code/computed.rs

@@ -222,6 +222,13 @@ impl<'a, 'h> CandidateSearch<'a, 'h> {
         }
         for node_path in &resolver.code_options().node_paths {
             self.walk_below(node_path, b"", SpecifierForm::Path)?;
+            // The folder has the written name: in a `NODE_PATH` entry a version is a part of it.
+            let manifest = Some(join_unrooted(node_path, name))
+                .filter(|package_directory| resolver.is_dir(package_directory))
+                .and_then(|package_directory| resolver.code_manifest(&package_directory));
+            if let Some(exports) = manifest.and_then(|manifest| manifest.exports.as_ref()) {
+                self.try_exact_exported_keys(exports, name)?;
+            }
         }
         Ok(())
     }
@@ -262,6 +269,29 @@ impl<'a, 'h> CandidateSearch<'a, 'h> {
         }
         for node_path in &resolver.code_options().node_paths {
             self.walk_below(node_path, b"", SpecifierForm::Path)?;
+            // After the walk: it ends the search in a folder where more packages start with the prefix than the limit allows, and then no manifest is read.
+            for name in self.list_installed_names(node_path) {
+                let manifest = resolver.code_manifest(&join_unrooted(node_path, &name));
+                if let Some(exports) = manifest.and_then(|manifest| manifest.exports.as_ref()) {
+                    self.try_exact_exported_keys(exports, &name)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Tries the keys of "exports" of a package in a `NODE_PATH` entry that name one subpath each. A key with a star or a key of a folder lists no folder here: of its files, only those that the walk lists are found.
+    fn try_exact_exported_keys(
+        &mut self,
+        exports: &ExportsEntry<'h>,
+        name: &[u8],
+    ) -> Result<(), ComputedUnknown> {
+        let ExportsEntry::Map(map) = *exports else {
+            return Ok(());
+        };
+        let subpath_keys = map.entries.iter().filter(|it| it.0.starts_with(b"./"));
+        for &(key, _) in subpath_keys.filter(|it| !strings::contains_char(it.0, b'*')) {
+            self.try_exported_specifier(&[name, &key[1..]].concat())?;
         }
         Ok(())
     }

src/sema/resolve/code/computed/tests.rs

@@ -500,3 +500,107 @@ fn packages_in_node_path_are_listed() {
         ""
     );
 }
+
+fn node_path_candidates(host: &MemoryHost, limit: u32, prefix: &str, suffix: &str) -> String {
+    let options = CodeOptions {
+        node_paths: vec![b"/global".to_vec()],
+        max_computed_candidates: limit,
+        ..CodeOptions::bun_run(b"/p")
+    };
+    let pattern = ComputedPattern {
+        importer: "/p/main.ts",
+        prefix,
+        suffix,
+        kind: Import,
+    };
+    resolve_computed_with(host, &options, pattern)
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn exact_exported_subpaths_of_packages_in_node_path_are_listed() {
+    let host = MemoryHost::new(&[
+        ("/p/main.ts", ""),
+        (
+            "/global/pkg/package.json",
+            r#"{ "exports": { ".": "./lib/root.js", "./alias": "./lib/target.js" } }"#,
+        ),
+        ("/global/pkg/lib/root.js", ""),
+        ("/global/pkg/lib/target.js", ""),
+        ("/global/pkg/plain.js", ""),
+    ])
+    .node_path("/global");
+    let candidates = |prefix, suffix| node_path_candidates(&host, 1024, prefix, suffix);
+    assert_eq!(candidates("pkg/al", ""), "/global/pkg/lib/target.js");
+    assert_eq!(candidates("pk", "/alias"), "/global/pkg/lib/target.js");
+    assert_eq!(candidates("pk", "g"), "/global/pkg/lib/root.js");
+    assert_eq!(candidates("pkg/pl", ""), "/global/pkg/plain.js");
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn exports_of_package_in_node_path_list_no_folder() {
+    let host = MemoryHost::new(&[
+        ("/p/main.ts", ""),
+        (
+            "/global/pkg/package.json",
+            r#"{ "exports": { "./*": "./*", "./icons/": "./icons/" } }"#,
+        ),
+        ("/global/pkg/a.js", ""),
+        ("/global/pkg/b.js", ""),
+        ("/global/pkg/c.js", ""),
+        ("/global/pkg/icons/x.js", ""),
+        ("/global/pkg/icons/y.js", ""),
+    ])
+    .node_path("/global");
+    // The walk lists the two files of `icons`. The package has more files than the limit.
+    assert_eq!(
+        node_path_candidates(&host, 2, "pkg/icons/", ""),
+        "/global/pkg/icons/x.js, /global/pkg/icons/y.js"
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn package_in_node_modules_and_in_node_path_counts_once() {
+    let host = MemoryHost::new(&[
+        ("/p/main.ts", ""),
+        (
+            "/p/node_modules/pkg/package.json",
+            r#"{ "exports": { "./icons/*": "./dist/icons/*" } }"#,
+        ),
+        ("/p/node_modules/pkg/dist/icons/x.js", ""),
+        ("/p/node_modules/pkg/dist/icons/y.js", ""),
+    ])
+    .link("/global/pkg", "/p/node_modules/pkg")
+    .node_path("/global");
+    assert_eq!(
+        node_path_candidates(&host, 2, "pkg/icons/", ""),
+        "/p/node_modules/pkg/dist/icons/x.js, /p/node_modules/pkg/dist/icons/y.js"
+    );
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn walk_over_node_path_ends_search_before_manifests_are_read() {
+    let manifest = r#"{ "exports": { "./alias": "./target.js" } }"#;
+    let host = MemoryHost::new(&[
+        ("/p/main.ts", ""),
+        ("/global/pka/package.json", manifest),
+        ("/global/pka/target.js", ""),
+        ("/global/pkb/package.json", manifest),
+        ("/global/pkb/target.js", ""),
+        ("/global/pkc/package.json", manifest),
+        ("/global/pkc/target.js", ""),
+    ])
+    .node_path("/global");
+    assert_eq!(
+        node_path_candidates(&host, 2, "pk", "/alias"),
+        "All(TooManyCandidates)"
+    );
+    assert_eq!(host.reads("/global/pka/package.json"), 0);
+    assert_eq!(
+        node_path_candidates(&host, 8, "pk", "/alias"),
+        "/global/pka/target.js, /global/pkb/target.js, /global/pkc/target.js"
+    );
+}

src/sema/resolve/code/memory_host.rs

@@ -239,19 +239,24 @@ impl CodeHost for MemoryHost {
             };
         }
         let in_node_paths = || {
-            let files = self.node_paths.iter().map(|directory| {
+            for directory in &self.node_paths {
+                let exported = super::search::find_exported_in_node_path(self, search, directory);
+                if exported.is_some() {
+                    return exported;
+                }
                 let specifier = &join(directory, search.specifier);
-                find_file_plainly(
+                let found = find_file_plainly(
                     self,
                     &FileSearch {
                         specifier,
                         ..*search
                     },
-                )
-            });
-            files
-                .into_iter()
-                .find(|it| matches!(it, FoundCode::File { .. }))
+                );
+                if matches!(found, FoundCode::File { .. }) {
+                    return Some(found);
+                }
+            }
+            None
         };
         let found = self.find_through_imports(search);
         let found = found.unwrap_or_else(|| find_file_plainly(self, search));

src/sema/resolve/code/search.rs

@@ -347,6 +347,39 @@ impl CodeOptions {
     }
 }
 
+/// What `bun run` finds by the "exports" of the package that the specifier names in `node_path`, a `NODE_PATH` entry. `None` where it goes on to the file or the folder of that name.
+#[cfg(test)]
+pub(super) fn find_exported_in_node_path<H: Host + ?Sized>(
+    host: &H,
+    search: &FileSearch<'_>,
+    node_path: &[u8],
+) -> Option<FoundCode> {
+    // The folder has the written name: in a `NODE_PATH` entry a version is a part of it.
+    installed_name(search.specifier)?;
+    let name = written_package_name(search.specifier)?;
+    let subpath = [b".".as_slice(), &search.specifier[name.len()..]].concat();
+    if subpath.len() > SUBPATH_CAPACITY {
+        return None;
+    }
+    let plain = PlainSearch {
+        host,
+        parse_manifest: H::parse_package_json,
+        orders: &BUN_RUN.extension_orders,
+        kind: search.kind,
+        prefers_module_field: search.prefers_module_field,
+        holds: &|condition| BUN_RUN.matches_condition(condition, search.kind),
+        arena: OnceCell::new(),
+    };
+    let directory = join_unrooted(node_path, name);
+    let manifest = plain.read_manifest(&directory)?;
+    let exports = plain.read_exports(&manifest)?;
+    if matches!(exports, ExportsEntry::Invalid) {
+        return None;
+    }
+    let found = plain.find_in_exports(&directory, &exports, &subpath);
+    matches!(found, FoundCode::File { .. }).then_some(found)
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 enum KeyKind {
     Exact,