feat(bundle): support browser field map in package.json (#34407)

Closes #30024

## Summary

Implements the object form of the npm `browser` field for `deno bundle
--platform browser`. The simple string form was already supported; the
mapped form was silently dropped.

```json
"browser": {
  "./bar.js": "./bar.browser.js",
  "crypto": false,
  "foo": "./shims/foo.js"
}
```

- relative-path keys remap the resolved file (`./bar.js` →
`./bar.browser.js`)
- bare-name keys remap an import specifier (`foo` → `./shims/foo.js`),
with `node:` prefix stripped before lookup so `import "node:crypto"`
matches a `"crypto"` key
- a value of `false` disables the module — the bundler substitutes an
empty stub

Esbuild's built-in browser-map handling is bypassed because Deno's
`on_resolve` plugin claims every resolve with filter `.*`, so we have to
apply the mapping ourselves.

## Where the logic lives

- **`libs/package_json`** — parses the object form into `browser_map:
Option<IndexMap<String, BrowserMapEntry>>` (`Replace(String) |
Disabled`). The string form keeps populating the existing `browser`
field.
- **`libs/node_resolver`** — substitution happens here, gated on the
existing `prefer_browser_field` flag (only set when bundling with
`--platform browser`). Hooks in `resolve`, `resolve_package`, and
`resolve_package_subpath_from_deno_module`. A new
`BrowserMapDisabledError` propagates `false` entries up to the caller.
- **`cli/tools/bundle/mod.rs`** — only catches `BrowserMapDisabledError`
from the resolver, returns a `\0deno-browser-disabled:<orig>` sentinel
path, and the `on_load` hook turns it into `module.exports = {}`.

## Test plan

- [x] New spec `tests/specs/bundle/browser_platform_map` covers all four
cases (relative remap, bare remap, bare disabled, transitive
within-package import) using new npm fixture
`@denotest/browser-field-map`
- [x] All 49 existing `bundle::*` spec tests still pass
- [x] `node_resolver` unit tests still pass
- [x] `--platform deno` bundles are unchanged (gate is
`prefer_browser_field`)

Author: nathanwhit

cli/tools/bundle/mod.rs

@@ -851,6 +851,10 @@ pub struct DeferredResolveError {
   error: ResolveWithGraphError,
 }
 
+/// Path prefix used to mark modules disabled via a `browser` map (`"foo": false`).
+/// `\0` keeps it from colliding with any real filesystem path.
+const BROWSER_DISABLED_PREFIX: &str = "\0deno-browser-disabled:";
+
 pub struct DenoPluginHandler {
   file_fetcher: Arc<CliFileFetcher>,
   resolver: Arc<CliResolver>,
@@ -1013,6 +1017,17 @@ impl esbuild_client::PluginHandler for DenoPluginHandler {
     let result = match result {
       Ok(r) => r,
       Err(e) => {
+        // A `browser` map entry of `false` disables the module: return a
+        // sentinel path that `on_load` recognizes and turns into an empty
+        // module, rather than surfacing the resolver error.
+        if let Some(orig) = browser_map_disabled_specifier(&e) {
+          return Ok(Some(esbuild_client::OnResolveResult {
+            path: Some(format!("{BROWSER_DISABLED_PREFIX}{orig}")),
+            namespace: Some("deno".into()),
+            plugin_name: Some("deno".to_string()),
+            ..Default::default()
+          }));
+        }
         return Ok(Some(esbuild_client::OnResolveResult {
           errors: Some(vec![esbuild_client::protocol::PartialMessage {
             id: "deno_error".into(),
@@ -1068,6 +1083,13 @@ impl esbuild_client::PluginHandler for DenoPluginHandler {
     args: esbuild_client::OnLoadArgs,
   ) -> Result<Option<esbuild_client::OnLoadResult>, AnyError> {
     log::debug!("{}: {args:?}", deno_terminal::colors::cyan("on_load"));
+    if args.path.starts_with(BROWSER_DISABLED_PREFIX) {
+      return Ok(Some(esbuild_client::OnLoadResult {
+        contents: Some(b"module.exports = {};\n".to_vec()),
+        loader: Some(esbuild_client::BuiltinLoader::Js),
+        ..Default::default()
+      }));
+    }
     if let Some(virtual_modules) = &self.virtual_modules
       && let Some(module) = virtual_modules.get(&args.path)
     {
@@ -1215,6 +1237,29 @@ impl BundleLoadError {
   }
 }
 
+/// Walk a `BundleError` looking for a `BrowserMapDisabled` error returned
+/// by `node_resolver`. Returns the original specifier so the bundle can
+/// emit an empty-module stub in place of the resolution.
+fn browser_map_disabled_specifier(error: &BundleError) -> Option<String> {
+  let BundleErrorKind::Resolver(resolve_err) = error.as_kind() else {
+    return None;
+  };
+  let deno_resolver::graph::ResolveWithGraphErrorKind::Resolve(e) =
+    resolve_err.as_kind()
+  else {
+    return None;
+  };
+  let deno_resolver::DenoResolveErrorKind::Node(node_err) = e.as_kind() else {
+    return None;
+  };
+  let node_resolver::errors::NodeResolveErrorKind::BrowserMapDisabled(disabled) =
+    node_err.as_kind()
+  else {
+    return None;
+  };
+  Some(disabled.specifier.clone())
+}
+
 fn maybe_ignorable_resolution_error(
   error: &ResolveWithGraphError,
 ) -> Option<String> {

libs/node_resolver/errors.rs

@@ -227,6 +227,9 @@ impl NodeJsErrorCoded for PackageSubpathFromDenoModuleResolveError {
       PackageSubpathFromDenoModuleResolveErrorKind::FinalizeResolution(e) => {
         e.code()
       }
+      PackageSubpathFromDenoModuleResolveErrorKind::BrowserMapDisabled(_) => {
+        NodeJsErrorCode::ERR_MODULE_NOT_FOUND
+      }
     }
   }
 }
@@ -240,6 +243,9 @@ impl PackageSubpathFromDenoModuleResolveError {
       PackageSubpathFromDenoModuleResolveErrorKind::FinalizeResolution(e) => {
         e.as_types_not_found()
       }
+      PackageSubpathFromDenoModuleResolveErrorKind::BrowserMapDisabled(_) => {
+        None
+      }
     }
   }
 
@@ -251,6 +257,9 @@ impl PackageSubpathFromDenoModuleResolveError {
       PackageSubpathFromDenoModuleResolveErrorKind::FinalizeResolution(e) => {
         e.maybe_specifier()
       }
+      PackageSubpathFromDenoModuleResolveErrorKind::BrowserMapDisabled(_) => {
+        None
+      }
     }
   }
 
@@ -264,6 +273,9 @@ impl PackageSubpathFromDenoModuleResolveError {
       PackageSubpathFromDenoModuleResolveErrorKind::FinalizeResolution(e) => {
         NodeResolveErrorKind::FinalizeResolution(e)
       }
+      PackageSubpathFromDenoModuleResolveErrorKind::BrowserMapDisabled(e) => {
+        NodeResolveErrorKind::BrowserMapDisabled(e)
+      }
     }
     .into_box()
   }
@@ -277,6 +289,9 @@ pub enum PackageSubpathFromDenoModuleResolveErrorKind {
   #[class(inherit)]
   #[error(transparent)]
   FinalizeResolution(#[from] FinalizeResolutionError),
+  #[class(inherit)]
+  #[error(transparent)]
+  BrowserMapDisabled(#[from] BrowserMapDisabledError),
 }
 
 #[derive(Debug, Boxed, JsError)]
@@ -691,6 +706,17 @@ pub struct DataUrlReferrerError {
   pub source: url::ParseError,
 }
 
+/// A module was disabled by the importer's `package.json` `browser` map
+/// (`{"name": false}`). The bundler turns this into an empty stub; other
+/// callers treat it as a resolution failure.
+#[derive(Debug, Error, JsError)]
+#[class(generic)]
+#[error("Module `{specifier}` is disabled by the `browser` field in `{}`.", pkg_json_path.display())]
+pub struct BrowserMapDisabledError {
+  pub specifier: String,
+  pub pkg_json_path: PathBuf,
+}
+
 #[derive(Debug, Boxed, JsError)]
 pub struct NodeResolveError(pub Box<NodeResolveErrorKind>);
 
@@ -714,7 +740,8 @@ impl NodeResolveError {
       NodeResolveErrorKind::FinalizeResolution(err) => err.maybe_specifier(),
       NodeResolveErrorKind::UnsupportedEsmUrlScheme(_)
       | NodeResolveErrorKind::DataUrlReferrer(_)
-      | NodeResolveErrorKind::RelativeJoin(_) => None,
+      | NodeResolveErrorKind::RelativeJoin(_)
+      | NodeResolveErrorKind::BrowserMapDisabled(_) => None,
     }
   }
 }
@@ -751,6 +778,9 @@ pub enum NodeResolveErrorKind {
   #[class(inherit)]
   #[error(transparent)]
   FinalizeResolution(#[from] FinalizeResolutionError),
+  #[class(inherit)]
+  #[error(transparent)]
+  BrowserMapDisabled(#[from] BrowserMapDisabledError),
 }
 
 impl NodeResolveErrorKind {
@@ -769,6 +799,7 @@ impl NodeResolveErrorKind {
       | NodeResolveErrorKind::RelativeJoin(_)
       | NodeResolveErrorKind::PathToUrl(_)
       | NodeResolveErrorKind::UnknownBuiltInNodeModule(_)
+      | NodeResolveErrorKind::BrowserMapDisabled(_)
       | NodeResolveErrorKind::UrlToFilePath(_) => None,
     }
   }
@@ -785,6 +816,7 @@ impl NodeResolveErrorKind {
       NodeResolveErrorKind::TypesNotFound(e) => Some(e.code()),
       NodeResolveErrorKind::UnknownBuiltInNodeModule(e) => Some(e.code()),
       NodeResolveErrorKind::FinalizeResolution(e) => Some(e.code()),
+      NodeResolveErrorKind::BrowserMapDisabled(_) => None,
     }
   }
 }