diff --git a/src/ast/import_record.rs b/src/ast/import_record.rs
index aa4160ec68c4..0a77a0d7ec4e 100644
--- a/src/ast/import_record.rs
+++ b/src/ast/import_record.rs
@@ -107,6 +107,9 @@ bitflags::bitflags! {
         /// `IS_UNUSED` for its own reasons (an unused TypeScript import, a macro
         /// import), and those records must never be resolved.
         const IS_BARREL_DEFERRED = 1 << 18;
+
+        /// The `src` of a `<script>` element in an HTML file: the page runs that file at the tag.
+        const HTML_SCRIPT_SRC = 1 << 19;
     }
 }
 
diff --git a/src/bundler/HTMLScanner.rs b/src/bundler/HTMLScanner.rs
index 41a76ebc2858..8be6705c8406 100644
--- a/src/bundler/HTMLScanner.rs
+++ b/src/bundler/HTMLScanner.rs
@@ -68,7 +68,12 @@ impl<'a> HTMLScanner<'a> {
 }
 
 impl<'a> HTMLScanner<'a> {
-    fn create_import_record(&mut self, input_path: &[u8], kind: ImportKind) -> Result<(), Error> {
+    fn create_import_record(
+        &mut self,
+        input_path: &[u8],
+        kind: ImportKind,
+        flags: ImportRecordFlags,
+    ) -> Result<(), Error> {
         // In HTML, sometimes people do /src/index.js
         // In that case, we don't want to use the absolute filesystem path, we want to use the path relative to the project root
         let path_to_use: &[u8] = if input_path.len() > 1 && input_path[0] == b'/' {
@@ -115,7 +120,7 @@ impl<'a> HTMLScanner<'a> {
             loader: None,
             source_index: AstIndex::default(),
             original_path: b"",
-            flags: ImportRecordFlags::default(),
+            flags,
         };
 
         self.import_records.push(record);
@@ -140,9 +145,10 @@ impl<'a> HTMLScanner<'a> {
         path: &[u8],
         url_attribute: &[u8],
         kind: ImportKind,
+        flags: ImportRecordFlags,
     ) {
         let _ = url_attribute;
-        let _ = self.create_import_record(path, kind);
+        let _ = self.create_import_record(path, kind, flags);
     }
 
     pub(crate) fn scan(&mut self, input: &[u8]) -> Result<(), Error> {
@@ -171,6 +177,7 @@ pub(crate) trait HTMLProcessorHandler {
         path: &[u8],
         url_attribute: &[u8],
         kind: ImportKind,
+        flags: ImportRecordFlags,
     );
     fn on_write_html(&mut self, bytes: &[u8]);
     fn on_html_parse_error(&mut self, message: &[u8]);
@@ -196,8 +203,9 @@ impl<'a> HTMLProcessorHandler for HTMLScanner<'a> {
         path: &[u8],
         url_attribute: &[u8],
         kind: ImportKind,
+        flags: ImportRecordFlags,
     ) {
-        HTMLScanner::on_tag(self, element, path, url_attribute, kind)
+        HTMLScanner::on_tag(self, element, path, url_attribute, kind, flags)
     }
     fn on_write_html(&mut self, bytes: &[u8]) {
         HTMLScanner::on_write_html(self, bytes)
@@ -217,6 +225,8 @@ struct TagHandler {
     pub(crate) url_attribute: &'static str,
     /// The kind of import to create
     pub(crate) kind: ImportKind,
+    /// The flags of the import record to create
+    pub(crate) flags: ImportRecordFlags,
 }
 
 impl TagHandler {
@@ -225,13 +235,20 @@ impl TagHandler {
             selector,
             url_attribute,
             kind,
+            flags: ImportRecordFlags::empty(),
         }
     }
+
+    const fn with_flags(mut self, flags: ImportRecordFlags) -> Self {
+        self.flags = flags;
+        self
+    }
 }
 
 const TAG_HANDLERS: [TagHandler; 16] = [
     // Module scripts with src
-    TagHandler::new("script[src]", "src", ImportKind::Stmt),
+    TagHandler::new("script[src]", "src", ImportKind::Stmt)
+        .with_flags(ImportRecordFlags::HTML_SCRIPT_SRC),
     // CSS Stylesheets
     TagHandler::new("link[rel='stylesheet'][href]", "href", ImportKind::At),
     // CSS Assets
@@ -339,6 +356,7 @@ impl<T: HTMLProcessorHandler, const VISIT_DOCUMENT_TAGS: bool>
                                     value.as_bytes(),
                                     tag_info.url_attribute.as_bytes(),
                                     tag_info.kind,
+                                    tag_info.flags,
                                 );
                             }
                         }
diff --git a/src/bundler/LinkerContext.rs b/src/bundler/LinkerContext.rs
index bbf0c81e36df..ea0111cfc43c 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -995,8 +995,13 @@ impl<'a> LinkerContext<'a> {
                 // `mark_file_live_for_tree_shaking` short-circuits for HTML and never
                 // walks its parts, so seed the bit here to preserve the old
                 // `Part::is_live = true` initializer.
-                if loaders.get(i).is_some_and(|l| *l == Loader::Html) && parts.len() > 1 {
-                    bits.set(1);
+                if loaders.get(i).is_some_and(|l| *l == Loader::Html) {
+                    // `call_wrapped_html_scripts` can split part 1: every piece holds import records.
+                    for (part_index, part) in parts.iter().enumerate().skip(1) {
+                        if part_index == 1 || !part.import_record_indices.is_empty() {
+                            bits.set(part_index);
+                        }
+                    }
                 }
                 parts_live.push(bits);
             }
@@ -2366,6 +2371,83 @@ impl<'a> LinkerContext<'a> {
         Ok(true)
     }
 
+    /// Makes an HTML file call `require_foo()` / `init_foo()` for each wrapped `<script src>`, where the tag is.
+    pub(crate) fn call_wrapped_html_scripts(
+        &mut self,
+        source_index: u32,
+    ) -> Result<(), AllocError> {
+        // SAFETY: `LinkerContext::arena()` returns a stable `&Arena` valid for the link pass;
+        // detach it so the statements do not borrow `self` across `add_part_to_file` below.
+        let arena: &Bump = unsafe { bun_ptr::detach_lifetime_ref::<Bump>(self.arena()) };
+        let flags = self.graph.meta.items_flags();
+        let wrapper_refs = self.graph.ast.items_wrapper_ref();
+        let records = &self.graph.ast.items_import_records()[source_index as usize];
+        let Some(part) = self.graph.ast.items_parts()[source_index as usize]
+            .as_slice()
+            .get(1)
+        else {
+            return Ok(());
+        };
+        let indices = part.import_record_indices.slice();
+
+        // Where each part ends in `indices`, and the call that it makes there.
+        let mut ends: Vec<(usize, bun_ast::StoreSlice<Stmt>)> = Vec::new();
+        for (i, &record_index) in indices.iter().enumerate() {
+            let record = &records[record_index as usize];
+            if !record
+                .flags
+                .contains(bun_ast::ImportRecordFlags::HTML_SCRIPT_SRC)
+                || !record.source_index.is_valid()
+            {
+                continue;
+            }
+            let other = record.source_index.get() as usize;
+            let wrapper_ref = wrapper_refs[other];
+            if flags[other].wrap == WrapKind::None || !wrapper_ref.is_valid() {
+                continue;
+            }
+            // Nothing reads the namespace, so the call is bare: no `__toESM`.
+            let mut call = Expr::allocate(
+                arena,
+                E::Call {
+                    target: Expr::init_identifier(wrapper_ref, Loc::EMPTY),
+                    ..Default::default()
+                },
+                Loc::EMPTY,
+            );
+            if flags[other].wrap == WrapKind::Esm && flags[other].is_async_or_has_async_dependency {
+                call = Expr::allocate(arena, E::Await { value: call }, Loc::EMPTY);
+            }
+            // A part prints after every file that it imports: end it at the call, ahead of the later records.
+            let stmts = arena.alloc_slice_copy(&[Stmt::allocate_expr(arena, call)]);
+            ends.push((i + 1, bun_ast::StoreSlice::new_mut(stmts)));
+        }
+        let Some(&(first_end, first_stmts)) = ends.first() else {
+            return Ok(());
+        };
+        if ends.last().is_some_and(|&(end, _)| end < indices.len()) {
+            ends.push((indices.len(), bun_ast::StoreSlice::EMPTY));
+        }
+
+        let mut begin = first_end;
+        let mut new_parts: Vec<Part> = Vec::with_capacity(ends.len() - 1);
+        for &(end, stmts) in &ends[1..] {
+            new_parts.push(Part {
+                stmts,
+                import_record_indices: bun_alloc::AstAlloc::vec_from_slice(&indices[begin..end]),
+                ..Default::default()
+            });
+            begin = end;
+        }
+        let part = &mut self.graph.ast.items_parts_mut()[source_index as usize].as_mut_slice()[1];
+        part.stmts = first_stmts;
+        part.import_record_indices.truncate(first_end);
+        for part in new_parts {
+            self.graph.add_part_to_file(source_index, part)?;
+        }
+        Ok(())
+    }
+
     pub(crate) fn print_code_for_file_in_chunk_js(
         &mut self,
         r: renamer::Renamer,
diff --git a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
index ef2459b11239..1028cb48d105 100644
--- a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
+++ b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
@@ -622,10 +622,8 @@ fn for_each_edge(
 ) {
     let records = c.graph.ast.items_import_records()[source_index as usize].as_slice();
     let css = c.graph.ast.items_css();
-    if css[source_index as usize].is_some()
-        || c.parse_graph().input_files.items_loader()[source_index as usize] == Loader::Html
-    {
-        // A CSS or HTML file has no parts; every record counts.
+    if css[source_index as usize].is_some() {
+        // A CSS file has no parts; every record counts.
         for record in records {
             if record.source_index.is_valid() {
                 each(0, Edge::Import(record.source_index.get()));
@@ -635,6 +633,19 @@ fn for_each_edge(
     }
 
     let parts = c.graph.ast.items_parts()[source_index as usize].as_slice();
+    if c.parse_graph().input_files.items_loader()[source_index as usize] == Loader::Html {
+        // Every record counts, under its part: `call_wrapped_html_scripts` ends a part at each call.
+        for (part_index, part) in parts.iter().enumerate() {
+            for &record_id in part.import_record_indices.slice() {
+                let record: &ImportRecord = &records[record_id as usize];
+                if record.source_index.is_valid() {
+                    each(part_index as u32, Edge::Import(record.source_index.get()));
+                }
+            }
+        }
+        return;
+    }
+
     let parts_live = &c.graph.parts_live[source_index as usize];
     // The namespace export part (index 0) counts last: what it names goes after what the `import` statements import.
     const _: () = assert!(bun_ast::NAMESPACE_EXPORT_PART_INDEX == 0);
diff --git a/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs b/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
index ed2061583b4f..347f8fb57462 100644
--- a/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
+++ b/src/bundler/linker_context/generateCompileResultForHtmlChunk.rs
@@ -119,6 +119,7 @@ impl<'a> HTMLProcessorHandler for HTMLLoader<'a> {
         _path: &[u8],
         url_attribute: &[u8],
         _kind: ImportKind,
+        _flags: ImportRecordFlags,
     ) {
         if self.current_import_record_index as usize >= self.import_records.len() {
             bun_core::Output::panic(format_args!(
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index 4611b2fe6f8d..4bbfee94e564 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -754,6 +754,12 @@ pub(crate) fn scan_imports_and_exports(
             let wrap = flag.wrap;
             let export_kind = col_ref!(exports_kind)[id];
             let source: &Source = &col_ref!(input_files)[id];
+            // A page calls the wrappers of its scripts bare (`call_wrapped_html_scripts`): no `__toESM`.
+            let is_html = col_ref!(loaders)[id] == Loader::Html;
+            // The dev server format loads a script through its module record, not a wrapper.
+            if is_html && output_format != Format::InternalBakeDev {
+                this.call_wrapped_html_scripts(source_index)?;
+            }
 
             let exports_ref = col_ref!(exports_refs)[id];
             let module_ref = col_ref!(module_refs)[id];
@@ -1234,6 +1240,7 @@ pub(crate) fn scan_imports_and_exports(
                         // A same-chunk `import()` of a lifted CommonJS module needs it
                         // too, so that `default` is `module.exports` (the namespace).
                         if kind != ImportKind::Require
+                            && !is_html
                             && (other_export_kind == ExportsKind::Cjs
                                 || (kind == ImportKind::Dynamic
                                     && other_flags.wrap == WrapKind::Esm
diff --git a/test/bundler/bundler_html.test.ts b/test/bundler/bundler_html.test.ts
index cc36c530ad25..cd0a95ab63bb 100644
--- a/test/bundler/bundler_html.test.ts
+++ b/test/bundler/bundler_html.test.ts
@@ -249,6 +249,255 @@ export const padZero = (num) => String(num).padStart(2, '0');`,
     },
   });
 
+  // A `<script src>` that bun classifies as CommonJS (a `.cjs` file, a file
+  // that calls `require()`, top-level `this` in a UMD header, `module.exports`
+  // behind a `typeof module` guard) is wrapped in `__commonJS`. The page must
+  // still run it, in document order.
+  itBundled("html/script-src-commonjs", {
+    outdir: "out/",
+    files: {
+      "/index.html": `
+<!DOCTYPE html>
+<html>
+  <body>
+    <script src="./umd.js"></script>
+    <script src="./guarded.js"></script>
+    <script src="./ext.cjs"></script>
+    <script src="./requires.js"></script>
+    <script src="./plain.js"></script>
+  </body>
+</html>`,
+      "/umd.js": `
+(function (root, factory) {
+  root.LIB = factory();
+})(this, function () {
+  return { v: 1 };
+});
+console.log("umd");`,
+      "/guarded.js": `
+console.log("guarded");
+if (typeof module === "object") module.exports = { guarded: true };`,
+      "/ext.cjs": `console.log("cjs extension");`,
+      "/requires.js": `
+const dep = require("./dep.js");
+console.log("requires " + dep);`,
+      "/dep.js": `module.exports = 7;`,
+      "/plain.js": `console.log("plain");`,
+    },
+    entryPoints: ["/index.html"],
+    onAfterBundle(api) {
+      const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+      api.writeFile("out/run.mjs", `import "./${js}";`);
+    },
+    run: { file: "out/run.mjs", stdout: "umd\nguarded\ncjs extension\nrequires 7\nplain" },
+  });
+
+  // Every `.js` file of a `"type": "commonjs"` package (the `npm init` default)
+  // is classified as CommonJS, so even a plain `console.log` script is wrapped.
+  itBundled("html/script-src-type-commonjs-package", {
+    outdir: "out/",
+    files: {
+      "/package.json": `{ "name": "app", "version": "1.0.0", "type": "commonjs" }`,
+      "/index.html": `<!DOCTYPE html><html><body><script src="./first.js"></script><script src="./second.js"></script></body></html>`,
+      "/first.js": `console.log("first");`,
+      "/second.js": `console.log("second");`,
+    },
+    entryPoints: ["/index.html"],
+    onAfterBundle(api) {
+      const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+      api.writeFile("out/run.mjs", `import "./${js}";`);
+    },
+    run: { file: "out/run.mjs", stdout: "first\nsecond" },
+  });
+
+  // The chunk prints wrapped files ahead of the flat ones, so the call for a
+  // CommonJS script that sits between two plain scripts must print between
+  // them to keep document order, not next to the wrapper. The call for the
+  // last script of the page prints after every other script.
+  itBundled("html/script-src-commonjs-between-plain-scripts", {
+    outdir: "out/",
+    files: {
+      "/index.html": `
+<!DOCTYPE html>
+<html>
+  <body>
+    <script src="./first.js"></script>
+    <script src="./umd-badge.js"></script>
+    <script src="./last.js"></script>
+    <script src="./tail.cjs"></script>
+  </body>
+</html>`,
+      "/first.js": `console.log("first");`,
+      "/umd-badge.js": `
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) module.exports = factory();
+  else root.Badge = factory();
+})(globalThis, function () {
+  console.log("umd badge");
+  return {};
+});`,
+      "/last.js": `console.log("last");`,
+      "/tail.cjs": `console.log("tail");`,
+    },
+    entryPoints: ["/index.html"],
+    onAfterBundle(api) {
+      const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+      api.expectFile("out/" + js).not.toContain("__toESM");
+      api.writeFile("out/run.mjs", `import "./${js}";`);
+    },
+    run: { file: "out/run.mjs", stdout: "first\numd badge\nlast\ntail" },
+  });
+
+  // A `<link as="worker">` only refers to its file: the page calls the wrapper
+  // of a CommonJS `<script src>`, and not the wrapper of a CommonJS worker.
+  itBundled("html/script-src-commonjs-with-worker-link", {
+    outdir: "out/",
+    files: {
+      "/index.html": `
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="modulepreload" as="worker" href="./worker.js">
+  </head>
+  <body>
+    <script src="./lib.cjs"></script>
+    <script src="./app.js"></script>
+  </body>
+</html>`,
+      "/worker.js": `
+console.log("worker");
+module.exports = {};`,
+      "/lib.cjs": `console.log("lib");`,
+      "/app.js": `console.log("app");`,
+    },
+    entryPoints: ["/index.html"],
+    onAfterBundle(api) {
+      const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+      api.writeFile("out/run.mjs", `import "./${js}";`);
+    },
+    run: { file: "out/run.mjs", stdout: "lib\napp" },
+  });
+
+  // Same, when the script resolved to a lazily-initialized ES module (here
+  // because another script also `import()`s it): the page calls `init_foo()`,
+  // with `await` when the module uses top-level await. A module with no side
+  // effects (pure.js) has no `init_foo` to call.
+  itBundled("html/script-src-lazy-esm", {
+    outdir: "out/",
+    files: {
+      "/index.html": `
+<!DOCTYPE html>
+<html>
+  <body>
+    <script src="./pure.js"></script>
+    <script src="./sync.js"></script>
+    <script src="./tla.js"></script>
+    <script src="./main.js"></script>
+  </body>
+</html>`,
+      "/pure.js": `export const pure = "pure";`,
+      "/sync.js": `
+export const sync = "sync";
+console.log(sync);`,
+      "/tla.js": `
+export const tla = await Promise.resolve("tla");
+console.log(tla);`,
+      "/main.js": `
+console.log("main");
+const { pure } = await import("./pure.js");
+const { sync } = await import("./sync.js");
+const { tla } = await import("./tla.js");
+console.log("lazy " + pure + " " + sync + " " + tla);`,
+    },
+    entryPoints: ["/index.html"],
+    onAfterBundle(api) {
+      const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+      api.expectFile("out/" + js).toMatch(/init_sync\(\);\s*await init_tla\(\);/);
+      api.writeFile("out/run.mjs", `import "./${js}";`);
+    },
+    run: { file: "out/run.mjs", stdout: "sync\ntla\nmain\nlazy pure sync tla" },
+  });
+
+  // The call is a statement of the page, so each output format, the minifier
+  // and the source map path keep it between the scripts around its tag.
+  for (const [name, options] of [
+    ["iife", { format: "iife" }],
+    ["cjs", { format: "cjs" }],
+    ["minify", { minifyIdentifiers: true, minifySyntax: true, minifyWhitespace: true }],
+    ["sourcemap", { sourceMap: "external" }],
+  ] as const) {
+    itBundled(`html/script-src-commonjs-${name}`, {
+      outdir: "out/",
+      ...options,
+      files: {
+        "/index.html": `<!DOCTYPE html><html><body><script src="./first.js"></script><script src="./lib.cjs"></script><script src="./last.js"></script></body></html>`,
+        "/first.js": `console.log("first");`,
+        "/lib.cjs": `console.log("lib");`,
+        "/last.js": `console.log("last");`,
+      },
+      entryPoints: ["/index.html"],
+      onAfterBundle(api) {
+        const js = api.readFile("out/index.html").match(/src="\.\/([^"]+\.js)"/)![1];
+        if (name === "sourcemap") {
+          const sources: string[] = JSON.parse(api.readFile(`out/${js}.map`)).sources;
+          expect(sources.map(source => source.split("/").pop())).toEqual(["lib.cjs", "first.js", "last.js"]);
+        }
+        api.writeFile("out/run.mjs", `import "./${js}";`);
+      },
+      run: { file: "out/run.mjs", stdout: "first\nlib\nlast" },
+    });
+  }
+
+  // A page that a script loads with `import()` is a lazily-initialized module
+  // itself: its scripts run, in document order, when that module does.
+  itBundled("html/script-src-commonjs-in-imported-page", {
+    outdir: "out/",
+    target: "browser",
+    files: {
+      "/entry.js": `
+console.log("entry");
+await import("./page.html");
+console.log("loaded");`,
+      "/page.html": `<!DOCTYPE html><html><body><script src="./lib.cjs"></script><script src="./plain.js"></script></body></html>`,
+      "/lib.cjs": `console.log("lib");`,
+      "/plain.js": `console.log("plain");`,
+    },
+    entryPoints: ["/entry.js"],
+    run: { file: "out/entry.js", stdout: "entry\nlib\nplain\nloaded" },
+  });
+
+  // With code splitting the CommonJS script shared by two pages moves to its
+  // own chunk. Each page imports `require_lib` from it and still calls it. The
+  // page itself never reads the namespace, so it does not import `__toESM`
+  // (two.js does, for its own `import * as`).
+  itBundled("html/script-src-commonjs-splitting", {
+    outdir: "out/",
+    splitting: true,
+    files: {
+      "/one.html": `<!DOCTYPE html><html><body><script src="./lib.js"></script><script src="./one.js"></script></body></html>`,
+      "/two.html": `<!DOCTYPE html><html><body><script src="./lib.js"></script><script src="./two.js"></script></body></html>`,
+      "/lib.js": `
+console.log("lib");
+module.exports = { lib: true };`,
+      "/one.js": `console.log("one");`,
+      "/two.js": `
+import * as ns from "./lib.js";
+console.log("two", ns.default.lib);`,
+    },
+    entryPoints: ["/one.html", "/two.html"],
+    onAfterBundle(api) {
+      for (const page of ["one", "two"]) {
+        const js = api.readFile(`out/${page}.html`).match(/src="\.\/([^"]+\.js)"/)![1];
+        if (page === "one") api.expectFile("out/" + js).not.toContain("__toESM");
+        api.writeFile(`out/run-${page}.mjs`, `import "./${js}";`);
+      }
+    },
+    run: [
+      { file: "out/run-one.mjs", stdout: "lib\none" },
+      { file: "out/run-two.mjs", stdout: "lib\ntwo true" },
+    ],
+  });
+
   // Test CSS imports
   itBundled("html/css-imports", {
     outdir: "out/",
diff --git a/test/bundler/standalone.test.ts b/test/bundler/standalone.test.ts
index 2f6769ac9859..90e5bd19ab36 100644
--- a/test/bundler/standalone.test.ts
+++ b/test/bundler/standalone.test.ts
@@ -74,6 +74,42 @@ console.log(data);`,
     expect(html).toContain("await");
   });
 
+  // A script that bun classifies as CommonJS (UMD header with top-level `this`,
+  // or a guarded `module.exports`) is wrapped in `__commonJS`. The inlined
+  // module must still run it, in document order.
+  test("runs CommonJS scripts in document order", async () => {
+    using dir = tempDir("compile-browser-cjs-script", {
+      "index.html": `<!DOCTYPE html><html><body><script src="./umd.js"></script><script src="./guarded.js"></script><script src="./plain.js"></script></body></html>`,
+      "umd.js": `(function (root, factory) { root.LIB = factory(); })(this, function () { return { v: 1 }; });
+console.log("umd");`,
+      "guarded.js": `console.log("guarded");
+if (typeof module === "object") module.exports = { guarded: true };`,
+      "plain.js": `console.log("plain");`,
+    });
+
+    const result = await Bun.build({
+      entrypoints: [`${dir}/index.html`],
+      compile: true,
+      target: "browser",
+    });
+
+    expect(result.success).toBe(true);
+    const html = await result.outputs[0].text();
+    const script = html.match(/<script type="module">([\s\S]*)<\/script>/)![1];
+    await Bun.write(`${dir}/inlined.mjs`, script);
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), `${dir}/inlined.mjs`],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stdout).toBe("umd\nguarded\nplain\n");
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+  });
+
   test("escapes </script> in inlined JS", async () => {
     using dir = tempDir("compile-browser-escape-script", {
       "index.html": `<!DOCTYPE html><html><body><script src="./app.js"></script></body></html>`,