diff --git a/src/bundler/LinkerContext.rs b/src/bundler/LinkerContext.rs
index 60649fdd6f50..6f078aef85d5 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -2416,17 +2416,15 @@ impl<'a> LinkerContext<'a> {
             } else {
                 Ref::NONE
             },
-            require_ref: match self.options.output_format {
-                Format::Cjs => None, // use unbounded global
-                _ => runtime_require_ref,
-            },
+            require_ref: runtime_require_ref,
             require_or_import_meta_for_source_callback: Some(
                 js_printer::RequireOrImportMetaCallback::init(self),
             ),
             line_offset_tables: Some(
                 &self.graph.files.items_line_offset_table()[source_index.get() as usize],
             ),
-            target: self.options.target,
+            // A `#!/usr/bin/env bun` entry point can be parsed for a target other than the bundle's.
+            target: ast.target,
 
             hmr_ref: if self.options.output_format == Format::InternalBakeDev {
                 ast.wrapper_ref
diff --git a/src/bundler/ParseTask.rs b/src/bundler/ParseTask.rs
index 4b4cf26f9ded..e33bf3ad667d 100644
--- a/src/bundler/ParseTask.rs
+++ b/src/bundler/ParseTask.rs
@@ -316,8 +316,11 @@ impl<'a> ParseTask<'a> {
     /// Re-export of `parse_worker::get_runtime_source` as an associated fn so
     /// callers can spell it `ParseTask::get_runtime_source`.
     #[inline]
-    pub(crate) fn get_runtime_source(target: options::Target) -> RuntimeSource {
-        parse_worker::get_runtime_source(target)
+    pub(crate) fn get_runtime_source(
+        target: options::Target,
+        output_format: options::Format,
+    ) -> RuntimeSource {
+        parse_worker::get_runtime_source(target, output_format)
     }
 }
 
@@ -570,7 +573,10 @@ export var __callDispose = (stack, error, hasError) => {
 pub mod parse_worker {
     use super::*;
 
-    fn get_runtime_source_comptime(target: options::Target) -> RuntimeSource {
+    fn get_runtime_source_comptime(
+        target: options::Target,
+        output_format: options::Format,
+    ) -> RuntimeSource {
         // The runtime module is the shared `runtime.js` body plus a per-target
         // `__require`/`__using` tail. Concatenating at compile time would embed
         // four copies of the 13 KB body, so each variant is assembled once on
@@ -582,11 +588,16 @@ pub mod parse_worker {
             Node,
             Other,
         }
-        let variant = match target {
-            options::Target::Bun => Variant::Bun,
-            options::Target::BunMacro => Variant::BunMacro,
-            options::Target::Node => Variant::Node,
-            _ => Variant::Other,
+        let variant = match (target, output_format) {
+            (options::Target::Bun, _) => Variant::Bun,
+            (options::Target::BunMacro, _) => Variant::BunMacro,
+            // An iife has no `import` statement: read the host's `require`.
+            (options::Target::Node, options::Format::Iife) => Variant::Other,
+            (
+                options::Target::Node,
+                options::Format::Esm | options::Format::Cjs | options::Format::InternalBakeDev,
+            ) => Variant::Node,
+            (options::Target::Browser | options::Target::ServerComponentsSsr, _) => Variant::Other,
         };
         static SOURCES: [bun_core::Once<Box<[u8]>>; 4] = [
             bun_core::Once::new(),
@@ -661,8 +672,11 @@ pub mod parse_worker {
         RuntimeSource { parse_task, source }
     }
 
-    pub(crate) fn get_runtime_source(target: options::Target) -> RuntimeSource {
-        get_runtime_source_comptime(target)
+    pub(crate) fn get_runtime_source(
+        target: options::Target,
+        output_format: options::Format,
+    ) -> RuntimeSource {
+        get_runtime_source_comptime(target, output_format)
     }
 
     // ───────────────────────────────────────────────────────────────────────────
@@ -2505,8 +2519,7 @@ pub mod parse_worker {
         opts.features.ascii_only = target.is_bun();
         opts.features.hot_module_reloading =
             output_format == options::Format::InternalBakeDev && !task.source_index.is_runtime();
-        opts.features.auto_polyfill_require =
-            output_format == options::Format::Esm && !opts.features.hot_module_reloading;
+        opts.features.auto_polyfill_require = options::should_call_runtime_require(output_format);
         opts.features.react_fast_refresh =
             topts.react_fast_refresh && loader.is_jsx() && !source.path.is_node_module();
         opts.features.react_compiler = if topts.react_compiler.is_enabled()
@@ -2625,8 +2638,8 @@ pub mod parse_worker {
         // in which we inline `true`.
         if topts.inline_entrypoint_import_meta_main || !task.is_entry_point {
             opts.import_meta_main_value = Some(task.is_entry_point && !topts.has_dev_server());
-        } else if target == options::Target::Node {
-            opts.lower_import_meta_main_for_node_js = true;
+        } else {
+            opts.lower_import_meta_main = !output_format.keeps_import_meta_main(target);
         }
 
         opts.tree_shaking = if task.source_index.is_runtime() {
diff --git a/src/bundler/bundle_v2.rs b/src/bundler/bundle_v2.rs
index 706e739ccb98..28a436f39304 100644
--- a/src/bundler/bundle_v2.rs
+++ b/src/bundler/bundle_v2.rs
@@ -3724,7 +3724,10 @@ pub mod bv2_impl {
         /// Common prelude shared by all enqueue_entry_points_* variants: add the runtime task.
         fn enqueue_entry_points_common(&mut self) -> Result<(), Error> {
             // Add the runtime
-            let rt = ParseTask::get_runtime_source(self.transpiler.options.target);
+            let rt = ParseTask::get_runtime_source(
+                self.transpiler.options.target,
+                self.transpiler.options.output_format,
+            );
             self.graph.input_files.append(crate::Graph::InputFile {
                 source: rt.source,
                 loader: Loader::Js,
diff --git a/src/bundler/linker_context/generateCodeForLazyExport.rs b/src/bundler/linker_context/generateCodeForLazyExport.rs
index f486564afea0..3b0188dfdf36 100644
--- a/src/bundler/linker_context/generateCodeForLazyExport.rs
+++ b/src/bundler/linker_context/generateCodeForLazyExport.rs
@@ -172,7 +172,7 @@ pub(crate) fn generate_code_for_lazy_export(
     // output, so the part that holds the call must import it.
     let calls_runtime_require = matches!(expr.data, ExprData::ECall(ref c)
         if matches!(c.target.data, ExprData::ERequireCallTarget))
-        && this.options.output_format != crate::options::OutputFormat::Cjs;
+        && crate::options::should_call_runtime_require(this.options.output_format);
 
     match exports_kind {
         bun_ast::ExportsKind::Cjs => {
diff --git a/src/bundler/linker_context/generateCompileResultForJSChunk.rs b/src/bundler/linker_context/generateCompileResultForJSChunk.rs
index f39841f65f5e..8e47d29091a9 100644
--- a/src/bundler/linker_context/generateCompileResultForJSChunk.rs
+++ b/src/bundler/linker_context/generateCompileResultForJSChunk.rs
@@ -7,7 +7,7 @@ use bun_threading::thread_pool as ThreadPoolLib;
 
 use crate::analyze_transpiled_module::ModuleInfo;
 use crate::linker_context_mod::LinkerContext;
-use crate::options::OutputFormat;
+use crate::options::should_call_runtime_require;
 use crate::thread_pool::Worker;
 use crate::{Chunk, CompileResult, Index, PartRange};
 
@@ -100,15 +100,11 @@ fn generate_compile_result_for_js_chunk_impl(
         .graph
         .symbols
         .follow(runtime_members.get(b"__toESM".as_slice()).unwrap().ref_);
-    let runtime_require_ref = if c.options.output_format == OutputFormat::Cjs {
-        None
-    } else {
-        Some(
-            c.graph
-                .symbols
-                .follow(runtime_members.get(b"__require".as_slice()).unwrap().ref_),
-        )
-    };
+    let runtime_require_ref = should_call_runtime_require(c.options.output_format).then(|| {
+        c.graph
+            .symbols
+            .follow(runtime_members.get(b"__require".as_slice()).unwrap().ref_)
+    });
 
     // `worker.arena` (= `BackRef` to `worker.heap`) is a disjoint field from
     // `worker.temporary_arena` / `worker.stmt_list` borrowed `&mut` above, so
diff --git a/src/bundler/linker_context/postProcessJSChunk.rs b/src/bundler/linker_context/postProcessJSChunk.rs
index 1455395e4bc6..58a3ad7a5f9d 100644
--- a/src/bundler/linker_context/postProcessJSChunk.rs
+++ b/src/bundler/linker_context/postProcessJSChunk.rs
@@ -144,15 +144,6 @@ pub(crate) fn post_process_js_chunk(
         .graph
         .symbols
         .follow(runtime_members.get(&b"__toESM"[..]).unwrap().ref_);
-    let runtime_require_ref = if c.options.output_format == options::OutputFormat::Cjs {
-        None
-    } else {
-        Some(
-            c.graph
-                .symbols
-                .follow(runtime_members.get(&b"__require"[..]).unwrap().ref_),
-        )
-    };
 
     // The chunk's module record, assembled in output order: the printer records
     // the cross-chunk prefix imports below, then the per-part-range results
@@ -200,7 +191,6 @@ pub(crate) fn post_process_js_chunk(
             indent: Default::default(),
             has_run_symbol_renamer: true,
 
-            require_ref: runtime_require_ref,
             minify_whitespace: c.options.minify_whitespace,
             minify_identifiers: c.options.minify_identifiers,
             minify_syntax: c.options.minify_syntax,
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index 73dee5b22d28..b466b9d89e57 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -1144,7 +1144,7 @@ pub(crate) fn scan_imports_and_exports(
                             // nor does a split `require()` (`import.meta.require`).
                             if kind != ImportKind::Dynamic
                                 && !is_external_dyn
-                                && should_call_runtime_require(output_format)
+                                && options::should_call_runtime_require(output_format)
                             {
                                 runtime_require_uses += 1;
                             }
@@ -1440,11 +1440,6 @@ pub(crate) fn scan_imports_and_exports(
     Ok(())
 }
 
-#[inline]
-fn should_call_runtime_require(format: options::Format) -> bool {
-    format != Format::Cjs
-}
-
 // ──────────────────────────────────────────────────────────────────────────
 // DependencyWrapper
 // ──────────────────────────────────────────────────────────────────────────
diff --git a/src/bundler/options.rs b/src/bundler/options.rs
index 457bc6993f04..fc3581db2eb6 100644
--- a/src/bundler/options.rs
+++ b/src/bundler/options.rs
@@ -321,6 +321,14 @@ impl TargetExt for Target {
 pub use bun_options_types::Format;
 pub use bun_options_types::WindowsOptions;
 
+/// Whether an unbundled `require` is the runtime's `__require`, for the parser and the linker.
+pub(crate) fn should_call_runtime_require(format: Format) -> bool {
+    match format {
+        Format::Esm | Format::Iife => true,
+        Format::Cjs | Format::InternalBakeDev => false,
+    }
+}
+
 // Re-export of `bun_ast::Loader`.
 // There is exactly ONE `Loader`; re-export so the bundler's
 // `BundleOptions.loaders` and the resolver's `Path::loader()` operate on the
diff --git a/src/bundler/transpiler.rs b/src/bundler/transpiler.rs
index 90e748d3c5c4..691434566b4e 100644
--- a/src/bundler/transpiler.rs
+++ b/src/bundler/transpiler.rs
@@ -1504,7 +1504,7 @@ impl<'a> Transpiler<'a> {
                     transform_only: self.options.transform_only,
                     import_meta_glob: None,
                     import_meta_main_value: None,
-                    lower_import_meta_main_for_node_js: false,
+                    lower_import_meta_main: false,
                     framework: None,
                     repl_mode: self.options.repl_mode,
                     lower_toml_datetimes: false,
diff --git a/src/js_parser/p.rs b/src/js_parser/p.rs
index 7af9d48c2bda..3a3346424832 100644
--- a/src/js_parser/p.rs
+++ b/src/js_parser/p.rs
@@ -6031,9 +6031,8 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     }
 
     /// This is only allowed to be called if allow_runtime is true
-    /// If --target=bun, this does nothing.
+    /// It does nothing unless the output calls the runtime's `__require`.
     pub(crate) fn record_usage_of_runtime_require(&mut self) {
-        // target bun does not have __require
         if self.options.features.auto_polyfill_require {
             debug_assert!(self.options.features.allow_runtime);
             self.ensure_require_symbol();
@@ -6084,8 +6083,11 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         //
         // The printer can handle this for us, but we need to reference
         // a handle to the `__require` function.
-        if self.options.lower_import_meta_main_for_node_js {
+        if self.options.lower_import_meta_main {
             self.record_usage_of_runtime_require();
+            if self.options.output_format == options::Format::Iife {
+                self.reserve_host_module_name();
+            }
         }
         Expr {
             loc,
@@ -6093,6 +6095,18 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
         }
     }
 
+    /// The iife lowering of `import.meta.main` prints `module`: keep bundle bindings off the name.
+    fn reserve_host_module_name(&mut self) {
+        let reserved = self.module_scope().generated.slice().iter().any(|ref_| {
+            let symbol = &self.symbols[ref_.inner_index() as usize];
+            symbol.kind == js_ast::symbol::Kind::Unbound
+                && symbol.original_name.slice() == b"module"
+        });
+        if !reserved {
+            self.declare_generated_symbol(js_ast::symbol::Kind::Unbound, b"module");
+        }
+    }
+
     pub(crate) fn keep_expr_symbol_name(&mut self, _value: Expr, _name: &[u8]) -> Expr {
         _value
     }
diff --git a/src/js_parser/parse/parse_entry.rs b/src/js_parser/parse/parse_entry.rs
index 026bfc8ba168..e30e80de5c1a 100644
--- a/src/js_parser/parse/parse_entry.rs
+++ b/src/js_parser/parse/parse_entry.rs
@@ -181,7 +181,8 @@ pub struct Options<'a> {
 
     /// Used for inlining the state of import.meta.main during visiting
     pub import_meta_main_value: Option<bool>,
-    pub lower_import_meta_main_for_node_js: bool,
+    /// The printer lowers `import.meta.main`: see `Format::keeps_import_meta_main`.
+    pub lower_import_meta_main: bool,
 
     /// When using react fast refresh or server components, the framework is
     /// able to customize what import sources are used.
@@ -231,7 +232,7 @@ impl<'a> Default for Options<'a> {
             transform_only: false,
             import_meta_glob: None,
             import_meta_main_value: None,
-            lower_import_meta_main_for_node_js: false,
+            lower_import_meta_main: false,
             framework: None,
             repl_mode: false,
             lower_toml_datetimes: false,
@@ -326,7 +327,7 @@ impl<'a> Options<'a> {
             transform_only: self.transform_only,
             import_meta_glob: self.import_meta_glob,
             import_meta_main_value: self.import_meta_main_value,
-            lower_import_meta_main_for_node_js: self.lower_import_meta_main_for_node_js,
+            lower_import_meta_main: self.lower_import_meta_main,
             framework: self.framework,
             repl_mode: self.repl_mode,
             lower_toml_datetimes: self.lower_toml_datetimes,
@@ -410,7 +411,7 @@ impl<'a> Options<'a> {
             transform_only: false,
             import_meta_glob: None,
             import_meta_main_value: None,
-            lower_import_meta_main_for_node_js: false,
+            lower_import_meta_main: false,
             framework: None,
             repl_mode: false,
             lower_toml_datetimes: loader == options::Loader::Toml,
diff --git a/src/js_printer/lib.rs b/src/js_printer/lib.rs
index 264fdd74b3c7..65b947ab8dde 100644
--- a/src/js_printer/lib.rs
+++ b/src/js_printer/lib.rs
@@ -3286,11 +3286,11 @@ pub(crate) mod __gated_printer {
                     }
                 }
                 ExprData::EImportMetaMain(data) => {
-                    if self.options.module_type == bundle_opts::Format::Esm
-                        && self.options.target != bun_ast::Target::Node
+                    if self
+                        .options
+                        .module_type
+                        .keeps_import_meta_main(self.options.target)
                     {
-                        // Node.js doesn't support import.meta.main
-                        // Most of the time, leave it in there
                         let wrap = data.inverted && level.gte(Level::Prefix);
                         if wrap {
                             self.print(b"(");
@@ -3314,26 +3314,42 @@ pub(crate) mod __gated_printer {
                             self.options.module_type != bundle_opts::Format::InternalBakeDev
                         );
 
-                        let wrap = level.gte(Level::Equals);
+                        // A `<script>` has no `module`. `??` takes no bare `&&` or `||` operand.
+                        let guard_host_module =
+                            self.options.module_type == bundle_opts::Format::Iife;
+                        let wrap = guard_host_module || level.gte(Level::Equals);
                         if wrap {
                             self.print(b"(");
                         }
                         self.print_space_before_identifier();
                         self.add_source_mapping(expr.loc);
 
+                        if guard_host_module {
+                            self.print(b"typeof module");
+                            if data.inverted {
+                                self.print_whitespacer(ws!(b" == \"undefined\" || "));
+                            } else {
+                                self.print_whitespacer(ws!(b" != \"undefined\" && "));
+                            }
+                        }
+
                         if let Some(require) = self.options.require_ref {
                             self.print_symbol(require);
                         } else {
                             self.print(b"require");
                         }
 
-                        if data.inverted {
-                            self.print_whitespacer(ws!(b".main != "));
-                        } else {
-                            self.print_whitespacer(ws!(b".main == "));
-                        }
+                        // Strict: an undefined `.main` must not equal a host `module` of null.
+                        self.print_whitespacer(match (guard_host_module, data.inverted) {
+                            (true, false) => ws!(b".main === "),
+                            (true, true) => ws!(b".main !== "),
+                            (false, false) => ws!(b".main == "),
+                            (false, true) => ws!(b".main != "),
+                        });
 
-                        if self.options.target == bun_ast::Target::Node {
+                        if guard_host_module {
+                            self.print(b"module");
+                        } else if self.options.target == bun_ast::Target::Node {
                             // "__require.module"
                             if let Some(require) = self.options.require_ref {
                                 self.print_symbol(require);
diff --git a/src/options_types/bundle_enums.rs b/src/options_types/bundle_enums.rs
index 796703191ba3..3f18e61fadb2 100644
--- a/src/options_types/bundle_enums.rs
+++ b/src/options_types/bundle_enums.rs
@@ -47,6 +47,15 @@ impl Format {
         self == Format::Esm
     }
 
+    /// Whether `import.meta.main` of an entry point parsed for `target` is printed as written.
+    pub fn keeps_import_meta_main(self, target: Target) -> bool {
+        match self {
+            Format::Esm => !target.is_node(),
+            Format::Iife => target.is_bun(), // Bun loads its `// @bun` output as an ES module.
+            Format::Cjs | Format::InternalBakeDev => false,
+        }
+    }
+
     pub const MAP: __ComptimeStringMap_FORMAT_MAP = __ComptimeStringMap_FORMAT_MAP(());
 
     // `to_js`/`from_js` live as extension-trait methods in the `*_jsc` crate.
diff --git a/test/bundler/bundler_cjs.test.ts b/test/bundler/bundler_cjs.test.ts
index 81a4caed037a..c70e209a27c1 100644
--- a/test/bundler/bundler_cjs.test.ts
+++ b/test/bundler/bundler_cjs.test.ts
@@ -609,6 +609,396 @@ describe("bundler", () => {
     },
   });
 
+  // ============================================================================
+  // The runtime's `__require` in iife output. A `require` that is not bundled
+  // prints as `__require`: a call with a non-literal argument, require.resolve,
+  // an uncalled `require`, require.main, an external package. The output has
+  // to define it, for each target. Each entry point here is an ES module.
+  // ============================================================================
+
+  const dynamicRequireFiles = {
+    "/entry.js": /* js */ `
+      import value from "./dyn.cjs";
+      console.log(value);
+    `,
+    "/dyn.cjs": /* js */ `
+      var ext = ".cjs";
+      module.exports = require("./dep-runtime" + ext).value;
+    `,
+  };
+  const dynamicRequireRuntimeFiles = {
+    "/dep-runtime.cjs": /* js */ `module.exports = { value: "required at runtime" };`,
+  };
+  const requiredAtRuntime = [
+    { runtime: "node" as const, stdout: "required at runtime" },
+    { stdout: "required at runtime" },
+  ];
+  // The scope of a `<script>`: no `require` and no `module`.
+  const scriptHostRunner = {
+    "/script.cjs": /* js */ `
+      const code = require("node:fs").readFileSync(__dirname + "/out.js", "utf8");
+      require("node:vm").runInNewContext(code, { console });
+    `,
+  };
+
+  for (const backend of ["cli", "api"] as const) {
+    // An iife has no `import` statement and no `import.meta.url`, so node gets
+    // the definition that reads the `require` of the host.
+    itBundled(`cjs/__require_iife_dynamic_require_target_node_${backend}`, {
+      backend,
+      files: dynamicRequireFiles,
+      runtimeFiles: dynamicRequireRuntimeFiles,
+      target: "node",
+      format: "iife",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toMatch(/var __require = /);
+        api.expectFile("/out.js").not.toContain("createRequire");
+        api.expectFile("/out.js").not.toContain("import.meta");
+      },
+      run: requiredAtRuntime,
+    });
+
+    // Bun loads the `// @bun` output as an ES module: import.meta.require is
+    // the `require` there.
+    itBundled(`cjs/__require_iife_dynamic_require_target_bun_${backend}`, {
+      backend,
+      files: dynamicRequireFiles,
+      runtimeFiles: dynamicRequireRuntimeFiles,
+      target: "bun",
+      format: "iife",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toContain("var __require = import.meta.require;");
+      },
+      run: {
+        stdout: "required at runtime",
+      },
+    });
+
+    itBundled(`cjs/__require_iife_dynamic_require_target_browser_${backend}`, {
+      backend,
+      files: dynamicRequireFiles,
+      runtimeFiles: dynamicRequireRuntimeFiles,
+      target: "browser",
+      format: "iife",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toMatch(/var __require = /);
+      },
+      run: requiredAtRuntime,
+    });
+  }
+
+  // In an executable the module graph loads the iife, not the `// @bun` pragma.
+  itBundled("cjs/__require_iife_dynamic_require_compile", {
+    files: dynamicRequireFiles,
+    runtimeFiles: dynamicRequireRuntimeFiles,
+    format: "iife",
+    compile: true,
+    run: {
+      stdout: "required at runtime",
+      setCwd: true,
+    },
+  });
+
+  // The renamer also runs on the part of the runtime that defines `__require`.
+  itBundled("cjs/__require_iife_dynamic_require_minified", {
+    files: dynamicRequireFiles,
+    runtimeFiles: dynamicRequireRuntimeFiles,
+    target: "browser",
+    format: "iife",
+    minifyIdentifiers: true,
+    minifySyntax: true,
+    minifyWhitespace: true,
+    run: requiredAtRuntime,
+  });
+
+  // With no `require` in the host, the call throws the error of esbuild.
+  // `new Function` runs the iife in the global scope, where the `require` of
+  // the module is not visible.
+  itBundled("cjs/__require_iife_dynamic_require_without_host_require", {
+    files: {
+      ...dynamicRequireFiles,
+      "/test.js": /* js */ `
+        import { readFileSync } from "node:fs";
+        const code = readFileSync(new URL("./out.js", import.meta.url), "utf8");
+        try {
+          new Function(code)();
+        } catch (e) {
+          console.log(e.message);
+        }
+      `,
+    },
+    runtimeFiles: dynamicRequireRuntimeFiles,
+    target: "browser",
+    format: "iife",
+    run: {
+      file: "/test.js",
+      stdout: 'Dynamic require of "./dep-runtime.cjs" is not supported',
+    },
+  });
+
+  // Each form of `require` that the parser does not bundle. For bun it is
+  // import.meta.require, which has no `main`.
+  for (const target of ["node", "browser", "bun"] as const) {
+    const stdout = `true true true true true ${target === "bun" ? "undefined" : "object"} function`;
+    itBundled(`cjs/__require_iife_require_reference_forms_target_${target}`, {
+      files: {
+        "/entry.js": /* js */ `
+          import value from "./forms.cjs";
+          console.log(value.join(" "));
+        `,
+        "/forms.cjs": /* js */ `
+          var ext = ".cjs";
+          var indirect = require;
+          module.exports = [
+            require("./dep-runtime" + ext).value === "required at runtime",
+            require("./dep-runtime" + ext, "second argument").value === "required at runtime",
+            module.require("./dep-runtime" + ext).value === "required at runtime",
+            indirect("./dep-runtime" + ext).value === "required at runtime",
+            require.resolve("./dep-runtime" + ext).endsWith("dep-runtime.cjs"),
+            typeof require.main,
+            typeof require,
+          ];
+        `,
+      },
+      runtimeFiles: dynamicRequireRuntimeFiles,
+      target,
+      format: "iife",
+      run: target === "bun" ? { stdout } : [{ runtime: "node", stdout }, { stdout }],
+    });
+  }
+
+  // A `require(expr)` in a `try` block threw a ReferenceError that the block
+  // caught. It calls the `require` of the host now, as in esm output.
+  itBundled("cjs/__require_iife_dynamic_require_in_try", {
+    files: {
+      "/entry.js": /* js */ `
+        import load from "./optional.cjs";
+        console.log(load("f" + "s") ? "loaded with the require of the host" : "not loaded");
+      `,
+      "/optional.cjs": /* js */ `
+        module.exports = function (name) {
+          try {
+            return require(name);
+          } catch {
+            return null;
+          }
+        };
+      `,
+    },
+    runtimeFiles: scriptHostRunner,
+    format: "iife",
+    run: [
+      { runtime: "node", stdout: "loaded with the require of the host" },
+      { stdout: "loaded with the require of the host" },
+      { file: "/script.cjs", runtime: "node", stdout: "not loaded" },
+      { file: "/script.cjs", stdout: "not loaded" },
+    ],
+  });
+
+  // The prelude of a browserify bundle reads an uncalled `require` when it loads.
+  itBundled("cjs/__require_iife_browserify_prelude", {
+    files: {
+      "/entry.js": /* js */ `
+        import lib from "./umd.js";
+        console.log(lib);
+      `,
+      "/umd.js": /* js */ `
+        (function (f) {
+          if (typeof exports === "object" && typeof module !== "undefined") {
+            module.exports = f();
+          } else {
+            globalThis.lib = f();
+          }
+        })(function () {
+          return (function e(t, n, r) {
+            function s(o, u) {
+              if (!n[o]) {
+                if (!t[o]) {
+                  var a = typeof require == "function" && require;
+                  if (!u && a) return a(o, !0);
+                  if (i) return i(o, !0);
+                  var f = new Error("Cannot find module '" + o + "'");
+                  throw ((f.code = "MODULE_NOT_FOUND"), f);
+                }
+                var l = (n[o] = { exports: {} });
+                t[o][0].call(l.exports, function (e) { var n = t[o][1][e]; return s(n ? n : e); }, l, l.exports, e, t, n, r);
+              }
+              return n[o].exports;
+            }
+            var i = typeof require == "function" && require;
+            for (var o = 0; o < r.length; o++) s(r[o]);
+            return s;
+          })({ 1: [function (_dereq_, module, exports) { module.exports = "loaded the browserify bundle"; }, {}] }, {}, [1])(1);
+        });
+      `,
+      "/test.js": /* js */ `
+        import { readFileSync } from "node:fs";
+        new Function("console", readFileSync(new URL("./out.js", import.meta.url), "utf8"))(console);
+      `,
+    },
+    format: "iife",
+    run: [
+      { runtime: "node", stdout: "loaded the browserify bundle" },
+      { stdout: "loaded the browserify bundle" },
+      { file: "/test.js", stdout: "loaded the browserify bundle" },
+    ],
+  });
+
+  // A `require()` of an external package imported `__require` already. For node
+  // the definition was an import of node:module, which an iife prints as
+  // `__require("node:module")`: `__require` defined through itself.
+  itBundled("cjs/__require_iife_external_require_target_node", {
+    files: {
+      "/entry.js": /* js */ `
+        import value from "./dep.cjs";
+        console.log(value);
+      `,
+      "/dep.cjs": /* js */ `
+        module.exports = require("ext").value;
+      `,
+    },
+    runtimeFiles: {
+      "/node_modules/ext/index.js": /* js */ `module.exports = { value: "external package" };`,
+    },
+    external: ["ext"],
+    target: "node",
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('__require("ext")');
+      api.expectFile("/out.js").not.toContain('__require("node:module")');
+      api.expectFile("/out.js").not.toContain("import.meta");
+    },
+    run: [{ runtime: "node", stdout: "external package" }, { stdout: "external package" }],
+  });
+
+  // An import of a node builtin is a `__require()` call in an iife for node.
+  itBundled("cjs/__require_iife_builtin_import_target_node", {
+    files: {
+      "/entry.js": /* js */ `
+        import { join } from "node:path";
+        console.log(typeof join);
+      `,
+    },
+    target: "node",
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('__require("node:path")');
+      api.expectFile("/out.js").not.toContain('__require("node:module")');
+    },
+    run: [{ runtime: "node", stdout: "function" }, { stdout: "function" }],
+  });
+
+  // With no `require` in the host, the definition reads the global `Proxy`
+  // when the bundle loads. A binding of the bundle with that name gets another
+  // name.
+  itBundled("cjs/__require_iife_target_node_user_binding_named_Proxy", {
+    files: {
+      "/entry.js": /* js */ `
+        import load from "./lazy.cjs";
+        class Proxy {
+          static own = "the class of the bundle";
+        }
+        console.log(typeof load, Proxy.own);
+      `,
+      "/lazy.cjs": /* js */ `
+        module.exports = name => require(name);
+      `,
+    },
+    runtimeFiles: scriptHostRunner,
+    target: "node",
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain("class Proxy2 {");
+    },
+    run: [
+      { runtime: "node", stdout: "function the class of the bundle" },
+      { stdout: "function the class of the bundle" },
+      { file: "/script.cjs", runtime: "node", stdout: "function the class of the bundle" },
+      { file: "/script.cjs", stdout: "function the class of the bundle" },
+    ],
+  });
+
+  // Without the definition in the output, a `__require()` call reached a
+  // binding of the bundle that has this name.
+  itBundled("cjs/__require_iife_user_binding_named___require", {
+    files: {
+      "/entry.js": /* js */ `
+        import value from "./dyn.cjs";
+        function __require() {
+          return { value: "the function of the bundle" };
+        }
+        console.log(value, __require().value);
+      `,
+      "/dyn.cjs": dynamicRequireFiles["/dyn.cjs"],
+    },
+    runtimeFiles: dynamicRequireRuntimeFiles,
+    format: "iife",
+    run: [
+      { runtime: "node", stdout: "required at runtime the function of the bundle" },
+      { stdout: "required at runtime the function of the bundle" },
+    ],
+  });
+
+  // A dependency that esbuild bundled declares its own `__require`. Its text
+  // reads `require`, which prints as the runtime's `__require`: without the
+  // definition, the helper of the dependency returned itself.
+  for (const minify of [false, true]) {
+    itBundled(`cjs/__require_iife_dependency_with_own_helper${minify ? "_minified" : ""}`, {
+      files: {
+        "/entry.js": /* js */ `
+          import { loadPath } from "./prebundled.js";
+          console.log(typeof loadPath().join);
+        `,
+        "/prebundled.js": /* js */ `
+          var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+            get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+          }) : x)(function(x) {
+            if (typeof require !== "undefined") return require.apply(this, arguments);
+            throw Error('Dynamic require of "' + x + '" is not supported');
+          });
+          export const loadPath = () => __require("node:path");
+        `,
+      },
+      format: "iife",
+      minifyIdentifiers: minify,
+      minifySyntax: minify,
+      minifyWhitespace: minify,
+      run: [{ runtime: "node", stdout: "function" }, { stdout: "function" }],
+    });
+  }
+
+  // A file whose only use of `require` folds away is an ES module, as in esm
+  // output. It was CommonJS in iife output.
+  itBundled("cjs/__require_iife_typeof_require_only_is_esm", {
+    files: {
+      "/entry.js": /* js */ `
+        console.log(typeof require);
+      `,
+    },
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").not.toContain("__commonJS");
+    },
+    run: [{ runtime: "node", stdout: "function" }, { stdout: "function" }],
+  });
+
+  // esm output for node keeps the createRequire() definition.
+  itBundled("cjs/__require_esm_dynamic_require_target_node", {
+    files: dynamicRequireFiles,
+    runtimeFiles: dynamicRequireRuntimeFiles,
+    target: "node",
+    format: "esm",
+    outfile: "/out.mjs",
+    onAfterBundle(api) {
+      api.expectFile("/out.mjs").toContain('import { createRequire } from "node:module";');
+      api.expectFile("/out.mjs").toContain("createRequire(import.meta.url)");
+    },
+    run: {
+      runtime: "node",
+      stdout: "required at runtime",
+    },
+  });
+
   // ============================================================================
   // isNodeMode follows the importer's module type: the file extension first,
   // then the nearest package.json "type". One test per importer kind.
diff --git a/test/bundler/bundler_edgecase.test.ts b/test/bundler/bundler_edgecase.test.ts
index b65ae9be6569..d40616e9ee2c 100644
--- a/test/bundler/bundler_edgecase.test.ts
+++ b/test/bundler/bundler_edgecase.test.ts
@@ -2444,6 +2444,284 @@ describe("bundler", () => {
       api.expectFile("/out.js").toMatch(/[^\.:]module/); // `.module` and `node:module` are not ok.
     },
   });
+  // The entry point has four forms of the check. `other` is not an entry
+  // point: its two fold to `false`. A bundle runs as the main module, then
+  // required from runner.cjs, which flips each value of the entry point.
+  const importMetaMainFiles = {
+    "/entry.ts": /* js */ `
+      import {other} from './other';
+      console.log(
+        capture(import.meta.main),
+        capture(require.main === module),
+        capture(!import.meta.main),
+        capture(require.main !== module),
+        ...other,
+      );
+    `,
+    "/other.ts": /* js */ `
+      globalThis['ca' + 'pture'] = x => x;
+
+      export const other = [capture(require.main === module), capture(import.meta.main)];
+    `,
+  };
+  const importMetaMainRunner = {
+    "/runner.cjs": /* js */ `require("./out.js");`,
+  };
+  const importMetaMainAsMain = "true true false false false false";
+  const importMetaMainWhenRequired = "false false true true false false";
+  const importMetaMainKept = [
+    "false",
+    "false",
+    "import.meta.main",
+    "import.meta.main",
+    "!import.meta.main",
+    "!import.meta.main",
+  ];
+  // Bun loads a file that starts with `// @bun` as an ES module, unless the
+  // pragma also says `@bun-cjs` (cjs output). An iife for bun has
+  // import.meta.main and has no `require` or `module`.
+  itBundled("edgecase/ImportMetaMainIIFETargetBun", {
+    files: importMetaMainFiles,
+    runtimeFiles: importMetaMainRunner,
+    target: "bun",
+    format: "iife",
+    capture: importMetaMainKept,
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toStartWith("// @bun\n");
+      api.expectFile("/out.js").not.toContain("require");
+      api.expectFile("/out.js").not.toContain("module");
+    },
+    run: [{ stdout: importMetaMainAsMain }, { file: "/runner.cjs", stdout: importMetaMainWhenRequired }],
+  });
+  itBundled("edgecase/ImportMetaMainCJSTargetBun", {
+    files: importMetaMainFiles,
+    runtimeFiles: importMetaMainRunner,
+    target: "bun",
+    format: "cjs",
+    capture: [
+      "false",
+      "false",
+      "require.main == module",
+      "require.main == module",
+      "!(require.main == module)",
+      "require.main != module",
+    ],
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toStartWith("// @bun @bun-cjs\n");
+    },
+    run: [{ stdout: importMetaMainAsMain }, { file: "/runner.cjs", stdout: importMetaMainWhenRequired }],
+  });
+  // A build with no target builds an entry point that starts with
+  // `#!/usr/bin/env bun` for bun: its output has the `// @bun` pragma. itBundled
+  // always gives a target, so these two build directly.
+  for (const backend of ["cli", "api"] as const) {
+    test.concurrent(`edgecase/ImportMetaMainBunHashbangNoTargetIIFE-${backend}`, async () => {
+      using dir = tempDir("import-meta-main-bun-hashbang", {
+        "entry.ts": "#!/usr/bin/env bun\n" + importMetaMainFiles["/entry.ts"],
+        "other.ts": importMetaMainFiles["/other.ts"],
+        "runner.cjs": importMetaMainRunner["/runner.cjs"],
+        "build.ts": /* js */ `
+          const { success, logs } = await Bun.build({
+            entrypoints: ["./entry.ts"],
+            format: "iife",
+            outdir: ".",
+            naming: "out.js",
+          });
+          if (!success) throw new AggregateError(logs);
+        `,
+      });
+      const spawn = async (...args: string[]) => {
+        await using proc = Bun.spawn({
+          cmd: [bunExe(), ...args],
+          cwd: String(dir),
+          env: bunEnv,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+        return { stdout, stderr, exitCode };
+      };
+      const build = await spawn(
+        ...(backend === "cli" ? ["build", "entry.ts", "--format=iife", "--outfile=out.js"] : ["build.ts"]),
+      );
+      expect({ stderr: build.stderr, exitCode: build.exitCode }).toEqual({ stderr: "", exitCode: 0 });
+      const out = await Bun.file(join(String(dir), "out.js")).text();
+      expect(out).toStartWith("#!/usr/bin/env bun\n// @bun\n");
+      expect(out).not.toContain("__require");
+      expect(await spawn("out.js")).toEqual({ stdout: importMetaMainAsMain + "\n", stderr: "", exitCode: 0 });
+      expect(await spawn("runner.cjs")).toEqual({
+        stdout: importMetaMainWhenRequired + "\n",
+        stderr: "",
+        exitCode: 0,
+      });
+    });
+  }
+  // `bun build --no-bundle --target=bun` prints for the format of the command line.
+  itBundled("edgecase/ImportMetaMainNoBundleIIFETargetBun", {
+    files: {
+      "/entry.ts": /* js */ `
+        console.log(import.meta.main, require.main === module, !import.meta.main);
+      `,
+    },
+    bundling: false,
+    target: "bun",
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toBe("console.log(import.meta.main, import.meta.main, !import.meta.main);\n");
+    },
+    run: { stdout: "true true false" },
+  });
+  // An iife for the browser or for node has no import.meta.main. The check
+  // becomes `require.main === module` with the `module` of the host. A
+  // CommonJS host has one. A `<script>` has none: the check is false there.
+  const importMetaMainIIFECapture = [
+    "false",
+    "false",
+    '(typeof module != "undefined" && __require.main === module)',
+    '(typeof module != "undefined" && __require.main === module)',
+    '!(typeof module != "undefined" && __require.main === module)',
+    '(typeof module == "undefined" || __require.main !== module)',
+  ];
+  const importMetaMainIIFERunners = {
+    ...importMetaMainRunner,
+    // The scope of a `<script>`: no `require` and no `module`.
+    "/script.cjs": /* js */ `
+      const code = require("node:fs").readFileSync(__dirname + "/out.js", "utf8");
+      require("node:vm").runInNewContext(code, { console });
+    `,
+    // A host whose `module` is not a CommonJS module.
+    "/null-module.cjs": /* js */ `
+      const code = require("node:fs").readFileSync(__dirname + "/out.js", "utf8");
+      require("node:vm").runInNewContext(code, { console, module: null });
+    `,
+  };
+  const importMetaMainIIFERuns = [
+    { stdout: importMetaMainAsMain },
+    { runtime: "node" as const, stdout: importMetaMainAsMain },
+    { file: "/runner.cjs", stdout: importMetaMainWhenRequired },
+    { file: "/runner.cjs", runtime: "node" as const, stdout: importMetaMainWhenRequired },
+    { file: "/script.cjs", stdout: importMetaMainWhenRequired },
+    { file: "/script.cjs", runtime: "node" as const, stdout: importMetaMainWhenRequired },
+    { file: "/null-module.cjs", stdout: importMetaMainWhenRequired },
+    { file: "/null-module.cjs", runtime: "node" as const, stdout: importMetaMainWhenRequired },
+    // Node loads `.mjs` as an ES module: it has no `require` and no `module`.
+    { file: "/out.mjs", runtime: "node" as const, stdout: importMetaMainWhenRequired },
+  ];
+  for (const target of ["browser", "node"] as const) {
+    itBundled(`edgecase/ImportMetaMainIIFETarget${target === "node" ? "Node" : "Browser"}`, {
+      files: importMetaMainFiles,
+      runtimeFiles: importMetaMainIIFERunners,
+      target,
+      format: "iife",
+      capture: importMetaMainIIFECapture,
+      onAfterBundle(api) {
+        api.expectFile("/out.js").toMatch(/var __require = /);
+        api.expectFile("/out.js").not.toContain("createRequire");
+        api.writeFile("/out.mjs", api.readFile("/out.js"));
+      },
+      run: importMetaMainIIFERuns,
+    });
+  }
+  itBundled("edgecase/ImportMetaMainIIFEMinified", {
+    files: importMetaMainFiles,
+    runtimeFiles: importMetaMainIIFERunners,
+    format: "iife",
+    minifyIdentifiers: true,
+    minifySyntax: true,
+    minifyWhitespace: true,
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('(typeof module!="undefined"&&');
+      api.expectFile("/out.js").toContain('(typeof module=="undefined"||');
+      api.expectFile("/out.js").toContain(".main===module)");
+      api.expectFile("/out.js").toContain(".main!==module)");
+      api.writeFile("/out.mjs", api.readFile("/out.js"));
+    },
+    run: importMetaMainIIFERuns,
+  });
+  // The check is one operand in any position: of a member access, of `**`
+  // and of `??`, which takes no `&&` or `||` operand without parentheses.
+  itBundled("edgecase/ImportMetaMainIIFEOperandPositions", {
+    files: {
+      "/entry.ts": /* js */ `
+        globalThis['ca' + 'pture'] = x => x;
+        console.log(
+          capture((require.main === module).toString()),
+          capture((require.main !== module).toString()),
+          capture(globalThis.nothing ?? import.meta.main),
+          capture(import.meta.main ?? globalThis.nothing),
+          capture((require.main !== module) ** 2),
+        );
+      `,
+    },
+    format: "iife",
+    capture: [
+      '(typeof module != "undefined" && __require.main === module).toString()',
+      '(typeof module == "undefined" || __require.main !== module).toString()',
+      'globalThis.nothing ?? (typeof module != "undefined" && __require.main === module)',
+      '(typeof module != "undefined" && __require.main === module) ?? globalThis.nothing',
+      '(typeof module == "undefined" || __require.main !== module) ** 2',
+    ],
+    run: [{ stdout: "true false true true 0" }, { runtime: "node", stdout: "true false true true 0" }],
+  });
+  // The `module` of the check is the one of the host. A binding of the bundle
+  // with that name gets another name, as in cjs output.
+  itBundled("edgecase/ImportMetaMainIIFEShadowedModuleBinding", {
+    files: {
+      "/entry.ts": /* js */ `
+        import {sibling} from './sibling';
+        const module = { name: "entry" };
+        console.log(import.meta.main, module.name, sibling);
+      `,
+      "/sibling.ts": /* js */ `
+        let module = { name: "sibling" };
+        export const sibling = module.name;
+      `,
+    },
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out.js").toContain('(typeof module != "undefined" && __require.main === module)');
+      api.expectFile("/out.js").toMatch(/var module2 = \{/);
+      api.expectFile("/out.js").toMatch(/var module3 = \{/);
+    },
+    run: [{ stdout: "true entry sibling" }, { runtime: "node", stdout: "true entry sibling" }],
+  });
+  // The same for the `module` parameter of a CommonJS wrapper. `b.js` is an
+  // entry point, so its check is not a constant in the output of `a.js`.
+  itBundled("edgecase/ImportMetaMainIIFECommonJSWrappedEntry", {
+    files: {
+      "/a.js": /* js */ `
+        import b from "./b.js";
+        console.log(b);
+      `,
+      "/b.js": /* js */ `
+        module.exports = [require.main === module, typeof module.exports].join(" ");
+      `,
+    },
+    entryPoints: ["/a.js", "/b.js"],
+    outdir: "/out",
+    format: "iife",
+    onAfterBundle(api) {
+      api.expectFile("/out/a.js").toContain("function(exports, module2)");
+      api.expectFile("/out/a.js").toContain('(typeof module != "undefined" && __require.main === module)');
+    },
+  });
+  // An entry point whose only use of `require` is this check is an ES module
+  // in iife output, as in esm output. It was CommonJS, and a CommonJS entry
+  // point does not run in iife output.
+  for (const target of ["browser", "node", "bun"] as const) {
+    itBundled(`edgecase/ImportMetaMainIIFERequireMainOnlyEntryTarget${target[0].toUpperCase()}${target.slice(1)}`, {
+      files: {
+        "/entry.js": /* js */ `
+          console.log(require.main === module);
+        `,
+      },
+      target,
+      format: "iife",
+      onAfterBundle(api) {
+        api.expectFile("/out.js").not.toContain("__commonJS");
+      },
+      run: target === "bun" ? { stdout: "true" } : [{ stdout: "true" }, { runtime: "node", stdout: "true" }],
+    });
+  }
   itBundled("edgecase/IdentifierInEnum#13081", {
     files: {
       "/entry.ts": `