js_parser: do not bind module or exports in a file whose module type is ESM

docs/runtime/module-resolution.mdx

@@ -343,7 +343,7 @@ Bun also supports [Node.js-style subpath imports](https://nodejs.org/api/package
 
 <Accordion title="Low-level details of CommonJS interop in Bun">
 
-Bun's JavaScript runtime has native support for CommonJS. When Bun's JavaScript transpiler detects usages of `module.exports`, it treats the file as CommonJS. The module loader then wraps the transpiled module in a function shaped like this:
+Bun's JavaScript runtime has native support for CommonJS. A `.cjs` or `.cts` file, or a `.js` or `.ts` file under a package.json with `"type": "commonjs"`, is CommonJS. A `.mjs` or `.mts` file, or a `.js` or `.ts` file under `"type": "module"`, is an ES module, and `module` and `exports` are not defined there, as in Node.js. For any other file, Bun's JavaScript transpiler reads the contents: when it detects usages of `module.exports`, it treats the file as CommonJS. The module loader then wraps the transpiled module in a function shaped like this:
 
 ```js
 (function (module, exports, require) {

src/ast/expr.rs

@@ -2629,7 +2629,9 @@ impl EqlKindT for StrictEql {
 /// blanket-impl'd for every `P<...>` instantiation below.
 pub trait EqlParser {
     fn arena(&self) -> &Bump;
-    fn module_ref(&self) -> Ref;
+    /// Whether `r#ref` is the CommonJS `module` binding, or the unbound global
+    /// `module` in a file that does not declare that binding.
+    fn is_module_ref(&self, r#ref: Ref) -> bool;
 }
 // `impl EqlParser for P<...>` lives in `bun_js_parser` (next to `P`).
 
@@ -2760,7 +2762,7 @@ impl Data {
                 // always re-ordered to the right side.
                 if matches!(right, Data::ERequireMain) {
                     if let Some(id) = left.as_e_identifier() {
-                        if id.ref_.eql(p.module_ref()) {
+                        if p.is_module_ref(id.ref_) {
                             return Equality::RequireMainAndModule;
                         }
                     }

src/bundler/transpiler.rs

@@ -2864,7 +2864,7 @@ impl<'a> Transpiler<'a> {
                     remove_cjs_module_wrapper: false,
                     dont_bundle_twice: false,
                     allow_commonjs: false,
-                    module_type: options::ModuleType::Unknown,
+                    module_type: resolve_result.module_type,
                     runtime_transpiler_cache: None,
                     keep_json_and_toml_as_one_statement: false,
                     allow_bytecode_cache: false,

src/js_parser/lib.rs

@@ -249,8 +249,15 @@ impl<'a, const IS_TS: bool, const SCAN: bool> bun_ast::expr::EqlParser
         self.arena
     }
     #[inline]
-    fn module_ref(&self) -> Ref {
-        self.module_ref
+    fn is_module_ref(&self, r#ref: Ref) -> bool {
+        if r#ref.eql(self.module_ref) {
+            return true;
+        }
+        if !r#ref.is_symbol() {
+            return false;
+        }
+        let symbol = &self.symbols[r#ref.inner_index() as usize];
+        symbol.kind == bun_ast::symbol::Kind::Unbound && symbol.original_name.slice() == b"module"
     }
 }
 

src/js_parser/p.rs

@@ -3344,10 +3344,22 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             .generated
             .ensure_unused_capacity(generated_symbols_count as usize * 3);
 
-        self.exports_ref =
-            self.declare_common_js_symbol(js_ast::symbol::Kind::Hoisted, b"exports")?;
-        self.module_ref =
-            self.declare_common_js_symbol(js_ast::symbol::Kind::Hoisted, b"module")?;
+        if self.is_file_considered_to_have_esm_exports {
+            // An ES module has no `exports` or `module` binding: a source
+            // reference to either name is an unbound global, as in Node. The
+            // symbols still back generated code (the ESM namespace object,
+            // `export =`, the HMR wrapper), so they live on `generated` only.
+            self.exports_ref = self.new_symbol(js_ast::symbol::Kind::Hoisted, b"exports");
+            self.module_ref = self.new_symbol(js_ast::symbol::Kind::Hoisted, b"module");
+            let (exports_ref, module_ref) = (self.exports_ref, self.module_ref);
+            VecExt::append(&mut self.module_scope_mut().generated, exports_ref);
+            VecExt::append(&mut self.module_scope_mut().generated, module_ref);
+        } else {
+            self.exports_ref =
+                self.declare_common_js_symbol(js_ast::symbol::Kind::Hoisted, b"exports")?;
+            self.module_ref =
+                self.declare_common_js_symbol(js_ast::symbol::Kind::Hoisted, b"module")?;
+        }
 
         self.require_ref =
             self.declare_common_js_symbol(js_ast::symbol::Kind::Unbound, b"require")?;
@@ -5976,7 +5988,9 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
             if self.options.repl_mode {
                 return None;
             }
-            if self.has_es_module_syntax && self.commonjs_named_exports.count() == 0 {
+            if (self.has_es_module_syntax || self.is_file_considered_to_have_esm_exports)
+                && self.commonjs_named_exports.count() == 0
+            {
                 // In an ES6 module, "this" is supposed to be undefined. Instead of
                 // doing this at runtime using "fn.call(undefined)", we do it at
                 // compile time using expression substitution here.
@@ -6031,6 +6045,18 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
+    /// `require.main === module` becomes `import.meta.main`, so the `module`
+    /// operand (the CommonJS binding, or the unbound global in an ES module)
+    /// is no longer used.
+    pub(crate) fn ignore_usage_of_require_main_module(
+        &mut self,
+        module_operand: &js_ast::ExprData,
+    ) {
+        if let js_ast::ExprData::EIdentifier(id) = module_operand {
+            self.ignore_usage(id.ref_);
+        }
+    }
+
     pub(crate) fn ignore_usage_of_runtime_require(&mut self) {
         if self.options.features.auto_polyfill_require {
             debug_assert!(!self.runtime_imports.__require.is_empty());

src/js_parser/parse/parse_entry.rs

@@ -316,6 +316,14 @@ impl<'a> Options<'a> {
             hasher.update(b"udfcf=0");
         }
 
+        // The hint decides the output of the same source (`exports`/`module`
+        // bindings, strict mode).
+        hasher.update(match self.module_type {
+            options::ModuleType::Unknown => b"mt=?",
+            options::ModuleType::Cjs => b"mt=c",
+            options::ModuleType::Esm => b"mt=e",
+        });
+
         self.features.hash_for_runtime_transpiler(hasher);
     }
 
@@ -1539,17 +1547,14 @@ impl<'a> Parser<'a> {
                         }
                         // This is a workaround for packages which have broken ESM checks
                         // If they never actually assign to exports.foo, only check for it
-                        // and the package specifies type "module"
                         // and the package uses ESM syntax
                         // We should just say
                         // You're ESM and lying about it.
-                        if p.options.module_type == options::ModuleType::Esm
-                            || p.has_es_module_syntax
-                        {
-                            if needs_decl_count == export_names_len {
-                                force_esm = true;
-                                break 'break_optimize;
-                            }
+                        // (A file whose module type is already ESM never binds
+                        // `exports`, so it never reaches this block.)
+                        if p.has_es_module_syntax && needs_decl_count == export_names_len {
+                            force_esm = true;
+                            break 'break_optimize;
                         }
 
                         if needs_decl_count > 0 || p.has_top_level_function_merged_with_var {

src/js_parser/visit/visit_binary.rs

@@ -255,7 +255,7 @@ impl BinaryExpressionVisitor {
                 match data_eql::<false, TYPESCRIPT, SCAN_ONLY>(&e_.left.data, &e_.right.data, p) {
                     Equality::RequireMainAndModule => {
                         p.ignore_usage_of_runtime_require();
-                        p.ignore_usage(p.module_ref);
+                        p.ignore_usage_of_require_main_module(&e_.left.data);
                         return p.value_for_import_meta_main(false, v.loc);
                     }
                     Equality::Equal => return p.new_expr(E::Boolean { value: true }, v.loc),
@@ -284,7 +284,7 @@ impl BinaryExpressionVisitor {
             Op::Code::BinStrictEq => {
                 match data_eql::<true, TYPESCRIPT, SCAN_ONLY>(&e_.left.data, &e_.right.data, p) {
                     Equality::RequireMainAndModule => {
-                        p.ignore_usage(p.module_ref);
+                        p.ignore_usage_of_require_main_module(&e_.left.data);
                         p.ignore_usage_of_runtime_require();
                         return p.value_for_import_meta_main(false, v.loc);
                     }
@@ -307,7 +307,7 @@ impl BinaryExpressionVisitor {
             Op::Code::BinLooseNe => {
                 match data_eql::<false, TYPESCRIPT, SCAN_ONLY>(&e_.left.data, &e_.right.data, p) {
                     Equality::RequireMainAndModule => {
-                        p.ignore_usage(p.module_ref);
+                        p.ignore_usage_of_require_main_module(&e_.left.data);
                         p.ignore_usage_of_runtime_require();
                         return p.value_for_import_meta_main(true, v.loc);
                     }
@@ -334,7 +334,7 @@ impl BinaryExpressionVisitor {
             Op::Code::BinStrictNe => {
                 match data_eql::<true, TYPESCRIPT, SCAN_ONLY>(&e_.left.data, &e_.right.data, p) {
                     Equality::RequireMainAndModule => {
-                        p.ignore_usage(p.module_ref);
+                        p.ignore_usage_of_require_main_module(&e_.left.data);
                         p.ignore_usage_of_runtime_require();
                         return p.value_for_import_meta_main(true, v.loc);
                     }

src/jsc/RuntimeTranspilerCache.rs

@@ -65,7 +65,10 @@ bun_core::declare_scope!(cache, visible);
 /// the cache-HIT path reinstates #33904 for them.
 /// Version 34: An import that a plugin `onResolve` answers is printed as it is written.
 /// Version 35: Long hexadecimal, octal and binary literals are rounded to the nearest double.
-const EXPECTED_VERSION: u32 = 35;
+/// Version 36: The module type hint (extension, package.json "type") is part of the
+/// features hash, and `.jsx`/`.tsx` loaded by a static import no longer take the hint
+/// from package.json.
+const EXPECTED_VERSION: u32 = 36;
 
 /// Source files smaller than this are not written to / read from the on-disk
 /// transpiler cache. Originally 50 KiB, which excluded almost every file in a

src/jsc/RuntimeTranspilerStore.rs

@@ -322,6 +322,7 @@ impl RuntimeTranspilerStore {
         path: &Fs::Path<'_>,
         referrer: String,
         loader: Loader,
+        module_type: ModuleType,
         package_json: Option<&PackageJSON>,
         module_loader: JSValue,
     ) -> *mut c_void {
@@ -365,6 +366,7 @@ impl RuntimeTranspilerStore {
                 ticket: None,
                 log: bun_ast::Log::init(),
                 loader,
+                module_type,
                 promise: StrongOptional::create(JSValue::from_cell(promise), global_object),
                 module_loader: if module_loader.is_empty() {
                     StrongOptional::empty()
@@ -416,6 +418,9 @@ pub struct TranspilerJob {
     pub(crate) non_threadsafe_input_specifier: bun_core::String,
     pub(crate) non_threadsafe_referrer: bun_core::String,
     pub(crate) loader: Loader,
+    /// The ESM-or-CommonJS hint from the extension or package.json `"type"`,
+    /// decided by the caller with the same rule as the synchronous loader.
+    pub(crate) module_type: ModuleType,
     pub(crate) promise: StrongOptional,
     /// The `JSModuleLoader` that is fetching, when it is not the global object's (a
     /// `Bun.ModuleGraph`'s): handed back with the result. Empty otherwise.
@@ -805,11 +810,7 @@ impl TranspilerJob {
                 && strings::eql_long(vm_main, path.text, false)
         });
 
-        let module_type: ModuleType = match this_tag {
-            ResolvedSourceTag::PackageJsonTypeCommonjs => ModuleType::Cjs,
-            ResolvedSourceTag::PackageJsonTypeModule => ModuleType::Esm,
-            _ => ModuleType::Unknown,
-        };
+        let module_type = self.module_type;
 
         let mut parse_options = ParseOptions {
             arena: &arena,

src/resolver/resolver.rs

@@ -1552,7 +1552,10 @@ impl<'a> Resolver<'a> {
                                 primary: Fs::Path::init_with_namespace(import_path, b"node"),
                                 secondary: None,
                             },
-                            module_type: options::ModuleType::Esm,
+                            // Embedded code has no extension or package.json.
+                            // Its contents decide: the react-refresh fallback
+                            // is a CommonJS bundle.
+                            module_type: options::ModuleType::Unknown,
                             primary_side_effects_data: SideEffects::NoSideEffectsPureData,
                             flags: ResultFlags::default(),
                             ..Default::default()