From 1517649704f3f26dda8142c10e2855b944c81b7a Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 8 Sep 2026 07:48:30 +0000
Subject: [PATCH 1/5] bundler: run CommonJS and lazily-initialized scripts of
 an HTML entry point

A <script src> that the bundler classifies as CommonJS (top-level this in
a UMD header, module.exports behind a typeof guard) or wraps as a lazy ES
module was emitted as var require_x = __commonJS(...) / var init_x =
__esm(...) with no call, so its body never ran. The HTML AST kept every
import record in one statement-less part, so the linker had no import
statement to turn into the wrapper call.

Give each import record of an HTML file its own part and print the
wrapper call (require_x(), init_x(), await init_x()) for that part, at
the tag's position in the merged module. Stop registering a __toESM use
for HTML importers, and keep the blank line between files when an empty
part range sits between them.
---
 src/bundler/LinkerContext.rs                  |  73 +++++++++-
 src/bundler/ParseTask.rs                      |  35 ++---
 .../generateCodeForFileInChunkJS.rs           |  11 +-
 .../linker_context/postProcessJSChunk.rs      |   7 +-
 .../linker_context/scanImportsAndExports.rs   |   4 +
 test/bundler/bundler_html.test.ts             | 129 ++++++++++++++++++
 test/bundler/html-import-manifest.test.ts     |  18 +--
 test/bundler/standalone.test.ts               |  36 +++++
 test/js/bun/http/bun-serve-html.test.ts       |   2 +-
 9 files changed, 280 insertions(+), 35 deletions(-)

diff --git a/src/bundler/LinkerContext.rs b/src/bundler/LinkerContext.rs
index 5d8576f64d36..5da6c14f203a 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -934,13 +934,15 @@ impl<'a> LinkerContext<'a> {
                 Vec::with_capacity(parts_col.len());
             for (i, parts) in parts_col.iter().enumerate() {
                 let mut bits = bun_collections::AutoBitSet::init_empty(parts.len())?;
-                // The HTML loader's `ParseTask` builds its synthetic part 1 already
-                // live (so the JS-chunk visitor follows every embedded import record).
                 // `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);
+                // walks its parts. The HTML loader's `ParseTask` builds one
+                // statement-less part per import record (so the JS-chunk visitor
+                // follows every embedded `<script src>` in document order), and all
+                // of them are live.
+                if loaders.get(i).is_some_and(|l| *l == Loader::Html) {
+                    for part_index in 1..parts.len() {
+                        bits.set(part_index);
+                    }
                 }
                 parts_live.push(bits);
             }
@@ -2313,6 +2315,65 @@ impl<'a> LinkerContext<'a> {
         Ok(true)
     }
 
+    /// The HTML loader gives each `<script src>` its own statement-less part
+    /// that holds only the import record. A script that resolved to a wrapped
+    /// module runs nothing until its wrapper is called, so print that call where
+    /// the tag was, like `should_remove_import_export_stmt` does for a bare
+    /// `import "./script"`: `require_foo()`, `init_foo()`, or `await init_foo()`.
+    /// Nothing observes the namespace, so the result is not passed to `__toESM`.
+    pub(crate) fn append_html_script_wrapper_calls(
+        &self,
+        stmts: &mut StmtList,
+        part: &Part,
+        ast: &JSAst<'_>,
+    ) -> Result<(), AllocError> {
+        for &import_record_index in part.import_record_indices.slice() {
+            let record = &ast.import_records[import_record_index as usize];
+            if record.kind != ImportKind::Stmt
+                || !record.source_index.is_valid()
+                || record.flags.contains(bun_ast::ImportRecordFlags::IS_UNUSED)
+            {
+                continue;
+            }
+            let other_source_index = record.source_index.get() as usize;
+            let other_flags = self.graph.meta.items_flags()[other_source_index];
+            match other_flags.wrap {
+                WrapKind::None => continue,
+                WrapKind::Cjs => {}
+                WrapKind::Esm => {
+                    if !self.graph.files_live.is_set(other_source_index) {
+                        continue;
+                    }
+                }
+            }
+            let wrapper_ref = self.graph.ast.items_wrapper_ref()[other_source_index];
+            if wrapper_ref.is_empty() {
+                continue;
+            }
+
+            let mut call = Expr::init(
+                E::Call {
+                    target: Expr::init_identifier(wrapper_ref, Loc::EMPTY),
+                    ..Default::default()
+                },
+                Loc::EMPTY,
+            );
+            if other_flags.wrap == WrapKind::Esm && other_flags.is_async_or_has_async_dependency {
+                call = Expr::init(E::Await { value: call }, Loc::EMPTY);
+            }
+            stmts
+                .inside_wrapper_prefix
+                .append_non_dependency(Stmt::alloc(
+                    S::SExpr {
+                        value: call,
+                        ..Default::default()
+                    },
+                    Loc::EMPTY,
+                ))?;
+        }
+        Ok(())
+    }
+
     pub(crate) fn print_code_for_file_in_chunk_js(
         &mut self,
         r: renamer::Renamer,
diff --git a/src/bundler/ParseTask.rs b/src/bundler/ParseTask.rs
index bf59458d4fd6..50604fa50084 100644
--- a/src/bundler/ParseTask.rs
+++ b/src/bundler/ParseTask.rs
@@ -1231,23 +1231,24 @@ pub mod parse_worker {
                 // gave up on figuring out how to fix it so that
                 // this feature could ship.
                 ast.has_lazy_export = false;
-                // Liveness for this synthetic part is seeded in
-                // `tree_shaking_and_code_splitting` (the per-part bitset
-                // does not exist at parse time).
-                ast.parts.as_mut_slice()[1] = Part {
-                    stmts: ast::StoreSlice::EMPTY,
-                    import_record_indices: {
-                        // Generate a single part that depends on all the import records.
-                        // This is to ensure that we generate a JavaScript bundle containing all the user's code.
-                        let mut import_record_indices = ast::PartImportRecordIndices::init_capacity(
-                            import_records_len as usize,
-                        );
-                        import_record_indices
-                            .extend(0..u32::try_from(import_records_len).expect("int cast"));
-                        import_record_indices
-                    },
-                    ..Default::default()
-                };
+                // One statement-less part per import record, in document order.
+                // The linker prints a part after the files it imports, so a
+                // `<script src>` that resolves to a wrapped module gets its
+                // `require_foo()` / `init_foo()` call at the tag's position
+                // (see `append_html_script_wrapper_calls`). Liveness for these
+                // parts is seeded in `tree_shaking_and_code_splitting` (the
+                // per-part bitset does not exist at parse time).
+                ast.parts.truncate(1);
+                ast.parts.reserve(import_records_len);
+                for import_record_index in 0..u32::try_from(import_records_len).expect("int cast") {
+                    let mut import_record_indices = ast::PartImportRecordIndices::init_capacity(1);
+                    import_record_indices.push(import_record_index);
+                    ast.parts.push(Part {
+                        stmts: ast::StoreSlice::EMPTY,
+                        import_record_indices,
+                        ..Default::default()
+                    });
+                }
 
                 // Try to avoid generating unnecessary ESM <> CJS wrapper code.
                 if output_format == js_parser::options::Format::Esm
diff --git a/src/bundler/linker_context/generateCodeForFileInChunkJS.rs b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
index f7ba8e07ca3c..4359bc1bad6e 100644
--- a/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
+++ b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
@@ -10,7 +10,7 @@ use bun_js_printer::{self as js_printer, PrintResult, PrintResultSuccess};
 use crate::analyze_transpiled_module::ModuleInfo;
 use crate::generic_path_with_pretty_initialized;
 use crate::linker_context_mod::{StmtList, StmtListWhich};
-use crate::options::Format as OutputFormat;
+use crate::options::{Format as OutputFormat, Loader};
 use crate::{Chunk, Index, LinkerContext, Part, PartRange, WrapKind};
 
 use bun_ast::StoreRef;
@@ -237,6 +237,8 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 
     let namespace_export_part_index = bun_ast::NAMESPACE_EXPORT_PART_INDEX;
 
+    let is_html = c.parse_graph().input_files.items_loader()[source_index] == Loader::Html;
+
     stmts.reset();
 
     let part_index_for_lazy_default_export: u32 = 'brk: {
@@ -354,6 +356,13 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
             continue;
         }
 
+        if is_html {
+            if let Err(err) = c.append_html_script_wrapper_calls(stmts, part, &ast) {
+                return PrintResult::Err(err.into());
+            }
+            continue;
+        }
+
         let mut single_stmts_list: [Stmt; 1] = [Stmt::empty()];
         let mut part_stmts: &[Stmt] = part.stmts.slice();
 
diff --git a/src/bundler/linker_context/postProcessJSChunk.rs b/src/bundler/linker_context/postProcessJSChunk.rs
index 2e7da0c1c7fb..fe6f27f85bc2 100644
--- a/src/bundler/linker_context/postProcessJSChunk.rs
+++ b/src/bundler/linker_context/postProcessJSChunk.rs
@@ -680,7 +680,12 @@ pub(crate) fn post_process_js_chunk(
         }
 
         // TODO: metafile
-        newline_before_comment = !compile_result.code().is_empty();
+
+        // Put a newline before the next file path comment. An empty result (a
+        // part range that printed nothing) must not take it away again.
+        if !compile_result.code().is_empty() {
+            newline_before_comment = true;
+        }
     }
     // An entry chunk whose code all lives in shared chunks has no compile results of its own.
     if !preload_registration.is_empty() {
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index aa807c0dbc0d..480ffc41df56 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -732,6 +732,9 @@ 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];
+            // An HTML file's `<script src>` records print as bare wrapper calls
+            // (`append_html_script_wrapper_calls`); nothing reads the namespace.
+            let is_html = col_ref!(loaders)[id] == Loader::Html;
 
             let exports_ref = col_ref!(exports_refs)[id];
             let module_ref = col_ref!(module_refs)[id];
@@ -1212,6 +1215,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..ebd236a057ea 100644
--- a/test/bundler/bundler_html.test.ts
+++ b/test/bundler/bundler_html.test.ts
@@ -249,6 +249,135 @@ 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" },
+  });
+
+  // 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.
+  itBundled("html/script-src-lazy-esm", {
+    outdir: "out/",
+    files: {
+      "/index.html": `
+<!DOCTYPE html>
+<html>
+  <body>
+    <script src="./sync.js"></script>
+    <script src="./tla.js"></script>
+    <script src="./main.js"></script>
+  </body>
+</html>`,
+      "/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 { sync } = await import("./sync.js");
+const { tla } = await import("./tla.js");
+console.log("lazy " + 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 sync tla" },
+  });
+
+  // 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/html-import-manifest.test.ts b/test/bundler/html-import-manifest.test.ts
index 11b5454c9bf3..d8d4eadeb03a 100644
--- a/test/bundler/html-import-manifest.test.ts
+++ b/test/bundler/html-import-manifest.test.ts
@@ -141,11 +141,11 @@ console.log(favicon);
             "files": [
               {
                 "input": "client.html",
-                "path": "./client-qjznw47b.js",
+                "path": "./client-c9kjeh05.js",
                 "loader": "js",
                 "isEntry": true,
                 "headers": {
-                  "etag": "l5IfNVyE54s",
+                  "etag": "7GmzUg4RQCU",
                   "content-type": "text/javascript;charset=utf-8"
                 }
               },
@@ -155,7 +155,7 @@ console.log(favicon);
                 "loader": "html",
                 "isEntry": true,
                 "headers": {
-                  "etag": "xh1kdn7wbmI",
+                  "etag": "L1NGVitZslc",
                   "content-type": "text/html;charset=utf-8"
                 }
               },
@@ -325,17 +325,17 @@ console.log("About manifest:", aboutHtml);
               {
                 "headers": {
                   "content-type": "text/javascript;charset=utf-8",
-                  "etag": "Dl7kT6q7eY4",
+                  "etag": "Vr91Jdsy4Zc",
                 },
                 "input": "home.html",
                 "isEntry": true,
                 "loader": "js",
-                "path": "./home-ey4favse.js",
+                "path": "./home-pzn5vj1q.js",
               },
               {
                 "headers": {
                   "content-type": "text/html;charset=utf-8",
-                  "etag": "IhvRaM9jGDU",
+                  "etag": "bO9UOC8tMwQ",
                 },
                 "input": "home.html",
                 "isEntry": true,
@@ -360,17 +360,17 @@ console.log("About manifest:", aboutHtml);
               {
                 "headers": {
                   "content-type": "text/javascript;charset=utf-8",
-                  "etag": "RCRrF1EbBvo",
+                  "etag": "xjiS27vgDE0",
                 },
                 "input": "about.html",
                 "isEntry": true,
                 "loader": "js",
-                "path": "./about-44bqhv6t.js",
+                "path": "./about-6rjvv0cd.js",
               },
               {
                 "headers": {
                   "content-type": "text/html;charset=utf-8",
-                  "etag": "2OGqRD6vx54",
+                  "etag": "yq0KRVKuKEY",
                 },
                 "input": "about.html",
                 "isEntry": true,
diff --git a/test/bundler/standalone.test.ts b/test/bundler/standalone.test.ts
index 20cbc916e2af..5369f5fad531 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>`,
diff --git a/test/js/bun/http/bun-serve-html.test.ts b/test/js/bun/http/bun-serve-html.test.ts
index 45ab33d47126..5a7e85be8edb 100644
--- a/test/js/bun/http/bun-serve-html.test.ts
+++ b/test/js/bun/http/bun-serve-html.test.ts
@@ -224,7 +224,7 @@ console.log("How...dashing?");
   "content-length": "316",
   "content-type": "text/javascript;charset=utf-8",
   "date": "<date>",
-  "etag": ""f862dbeedf9b72bc"",
+  "etag": ""c2050d7cfe555369"",
   "sourcemap": "/chunk-HASH.js.map",
 }
 `);

From 02c77083a492aeacd34b73c3a155f35802e4e503 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Tue, 8 Sep 2026 19:46:28 +0000
Subject: [PATCH 2/5] test: cover a CommonJS <script src> between two plain
 scripts

The chunk prints wrapped files ahead of flat code, so this is the case
where the wrapper call must come from the tag's own part to keep
document order. Adapted from the html/commonjs-script-runs-in-place
case in #41999.
---
 test/bundler/bundler_html.test.ts | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/test/bundler/bundler_html.test.ts b/test/bundler/bundler_html.test.ts
index ebd236a057ea..49e3093d0951 100644
--- a/test/bundler/bundler_html.test.ts
+++ b/test/bundler/bundler_html.test.ts
@@ -310,6 +310,41 @@ console.log("requires " + dep);`,
     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 come from the
+  // tag's own part to keep document order, not from next to the wrapper.
+  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>
+  </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");`,
+    },
+    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" },
+  });
+
   // 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.

From 4fb8cf5cdd89171090ee637788422d3cafa2d42e Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Wed, 14 Oct 2026 00:38:06 +0000
Subject: [PATCH 3/5] bundler: call a wrapped <script src> from the linker,
 where its tag is

The chunk walk on main no longer prints a file part by part for an HTML
file, so the wrapper calls printed after every later script.

The HTML AST is back to one part for all import records. Once wrap kinds
are final, call_wrapped_html_scripts gives that part a require_x() /
init_x() / await init_x() statement for each <script src> whose file is
wrapped, and ends the part at each call that another record follows. The
walk reports every record of an HTML file under its part, so a call
prints between the scripts around its tag.

HTMLScanner marks script[src] records with HTML_SCRIPT_SRC, so a
<link as=worker> file gets no call.

A page with no wrapped script keeps its part layout, so its chunk keeps
the same bytes and the same content hash: the hash snapshots are back to
the values on main.
---
 src/ast/import_record.rs                      |   4 +
 src/bundler/HTMLScanner.rs                    |  28 +++-
 src/bundler/LinkerContext.rs                  | 132 +++++++++++-------
 src/bundler/ParseTask.rs                      |  35 +++--
 .../findAllImportedPartsInJSOrder.rs          |  20 ++-
 .../generateCodeForFileInChunkJS.rs           |  11 +-
 .../generateCompileResultForHtmlChunk.rs      |   1 +
 .../linker_context/postProcessJSChunk.rs      |   7 +-
 .../linker_context/scanImportsAndExports.rs   |   6 +-
 test/bundler/bundler_html.test.ts             |  39 +++++-
 test/bundler/html-import-manifest.test.ts     |  18 +--
 test/js/bun/http/bun-serve-html.test.ts       |   2 +-
 12 files changed, 199 insertions(+), 104 deletions(-)

diff --git a/src/ast/import_record.rs b/src/ast/import_record.rs
index aa4160ec68c4..ceb54e23255a 100644
--- a/src/ast/import_record.rs
+++ b/src/ast/import_record.rs
@@ -107,6 +107,10 @@ 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 of an HTML file: the page runs
+        /// the file where the element is. A `<link>` only refers to its file.
+        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 6ae28e082308..8f29927ad4ae 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -990,14 +990,17 @@ impl<'a> LinkerContext<'a> {
                 Vec::with_capacity(parts_col.len());
             for (i, parts) in parts_col.iter().enumerate() {
                 let mut bits = bun_collections::AutoBitSet::init_empty(parts.len())?;
+                // The HTML loader's `ParseTask` builds its synthetic part 1 already
+                // live (so the JS-chunk visitor follows every embedded import record).
                 // `mark_file_live_for_tree_shaking` short-circuits for HTML and never
-                // walks its parts. The HTML loader's `ParseTask` builds one
-                // statement-less part per import record (so the JS-chunk visitor
-                // follows every embedded `<script src>` in document order), and all
-                // of them are live.
+                // walks its parts, so seed the bit here to preserve the old
+                // `Part::is_live = true` initializer. `call_wrapped_html_scripts` can
+                // have made several parts of it: each one holds import records.
                 if loaders.get(i).is_some_and(|l| *l == Loader::Html) {
-                    for part_index in 1..parts.len() {
-                        bits.set(part_index);
+                    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);
@@ -2368,61 +2371,96 @@ impl<'a> LinkerContext<'a> {
         Ok(true)
     }
 
-    /// The HTML loader gives each `<script src>` its own statement-less part
-    /// that holds only the import record. A script that resolved to a wrapped
-    /// module runs nothing until its wrapper is called, so print that call where
-    /// the tag was, like `should_remove_import_export_stmt` does for a bare
-    /// `import "./script"`: `require_foo()`, `init_foo()`, or `await init_foo()`.
-    /// Nothing observes the namespace, so the result is not passed to `__toESM`.
-    pub(crate) fn append_html_script_wrapper_calls(
-        &self,
-        stmts: &mut StmtList,
-        part: &Part,
-        ast: &JSAst<'_>,
+    /// A page runs a `<script src>` where the tag is. The HTML loader puts every
+    /// import record of the page in part 1, which has no statement, so a script
+    /// that the linker wrapped would not run: nothing calls `require_foo` or
+    /// `init_foo`. Gives the part those calls. A part prints after all the files
+    /// that it imports, so it ends at each call that another record follows, and
+    /// the records after the call go to a new part.
+    pub(crate) fn call_wrapped_html_scripts(
+        &mut self,
+        source_index: u32,
     ) -> Result<(), AllocError> {
-        for &import_record_index in part.import_record_indices.slice() {
-            let record = &ast.import_records[import_record_index as usize];
-            if record.kind != ImportKind::Stmt
+        // 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();
+        // A wrapped file prints whole, inside its wrapper.
+        let splits = flags[source_index as usize].wrap == WrapKind::None;
+
+        let to_stmts = |calls: &[Stmt]| {
+            if calls.is_empty() {
+                bun_ast::StoreSlice::EMPTY
+            } else {
+                bun_ast::StoreSlice::new_mut(arena.alloc_slice_copy(calls))
+            }
+        };
+        // Per part: where its records end in `indices`, and its statements.
+        let mut groups: Vec<(usize, bun_ast::StoreSlice<Stmt>)> = Vec::new();
+        let mut calls: Vec<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()
-                || record.flags.contains(bun_ast::ImportRecordFlags::IS_UNUSED)
             {
                 continue;
             }
-            let other_source_index = record.source_index.get() as usize;
-            let other_flags = self.graph.meta.items_flags()[other_source_index];
-            match other_flags.wrap {
-                WrapKind::None => continue,
-                WrapKind::Cjs => {}
-                WrapKind::Esm => {
-                    if !self.graph.files_live.is_set(other_source_index) {
-                        continue;
-                    }
-                }
-            }
-            let wrapper_ref = self.graph.ast.items_wrapper_ref()[other_source_index];
-            if wrapper_ref.is_empty() {
+            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;
             }
-
-            let mut call = Expr::init(
+            // 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 other_flags.wrap == WrapKind::Esm && other_flags.is_async_or_has_async_dependency {
-                call = Expr::init(E::Await { value: call }, 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);
             }
-            stmts
-                .inside_wrapper_prefix
-                .append_non_dependency(Stmt::alloc(
-                    S::SExpr {
-                        value: call,
-                        ..Default::default()
-                    },
-                    Loc::EMPTY,
-                ))?;
+            calls.push(Stmt::allocate_expr(arena, call));
+            if splits && i + 1 < indices.len() {
+                groups.push((i + 1, to_stmts(&calls)));
+                calls.clear();
+            }
+        }
+        if groups.is_empty() && calls.is_empty() {
+            return Ok(());
+        }
+        groups.push((indices.len(), to_stmts(&calls)));
+
+        let mut groups = groups.into_iter();
+        let (first_end, first_stmts) = groups.next().expect("infallible: pushed above");
+        let mut begin = first_end;
+        let mut new_parts: Vec<Part> = Vec::with_capacity(groups.len());
+        for (end, stmts) in groups {
+            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(())
     }
diff --git a/src/bundler/ParseTask.rs b/src/bundler/ParseTask.rs
index 71076c27bce1..44d4bb95add6 100644
--- a/src/bundler/ParseTask.rs
+++ b/src/bundler/ParseTask.rs
@@ -1243,24 +1243,23 @@ pub mod parse_worker {
                 // gave up on figuring out how to fix it so that
                 // this feature could ship.
                 ast.has_lazy_export = false;
-                // One statement-less part per import record, in document order.
-                // The linker prints a part after the files it imports, so a
-                // `<script src>` that resolves to a wrapped module gets its
-                // `require_foo()` / `init_foo()` call at the tag's position
-                // (see `append_html_script_wrapper_calls`). Liveness for these
-                // parts is seeded in `tree_shaking_and_code_splitting` (the
-                // per-part bitset does not exist at parse time).
-                ast.parts.truncate(1);
-                ast.parts.reserve(import_records_len);
-                for import_record_index in 0..u32::try_from(import_records_len).expect("int cast") {
-                    let mut import_record_indices = ast::PartImportRecordIndices::init_capacity(1);
-                    import_record_indices.push(import_record_index);
-                    ast.parts.push(Part {
-                        stmts: ast::StoreSlice::EMPTY,
-                        import_record_indices,
-                        ..Default::default()
-                    });
-                }
+                // Liveness for this synthetic part is seeded in
+                // `tree_shaking_and_code_splitting` (the per-part bitset
+                // does not exist at parse time).
+                ast.parts.as_mut_slice()[1] = Part {
+                    stmts: ast::StoreSlice::EMPTY,
+                    import_record_indices: {
+                        // Generate a single part that depends on all the import records.
+                        // This is to ensure that we generate a JavaScript bundle containing all the user's code.
+                        let mut import_record_indices = ast::PartImportRecordIndices::init_capacity(
+                            import_records_len as usize,
+                        );
+                        import_record_indices
+                            .extend(0..u32::try_from(import_records_len).expect("int cast"));
+                        import_record_indices
+                    },
+                    ..Default::default()
+                };
 
                 // Try to avoid generating unnecessary ESM <> CJS wrapper code.
                 if output_format == js_parser::options::Format::Esm
diff --git a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
index ef2459b11239..1e98ec7b1353 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,20 @@ 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 of an HTML file counts. A part ends at each wrapper call that the page
+        // makes (`call_wrapped_html_scripts`): the files of the later records go after that 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/generateCodeForFileInChunkJS.rs b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
index 4359bc1bad6e..f7ba8e07ca3c 100644
--- a/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
+++ b/src/bundler/linker_context/generateCodeForFileInChunkJS.rs
@@ -10,7 +10,7 @@ use bun_js_printer::{self as js_printer, PrintResult, PrintResultSuccess};
 use crate::analyze_transpiled_module::ModuleInfo;
 use crate::generic_path_with_pretty_initialized;
 use crate::linker_context_mod::{StmtList, StmtListWhich};
-use crate::options::{Format as OutputFormat, Loader};
+use crate::options::Format as OutputFormat;
 use crate::{Chunk, Index, LinkerContext, Part, PartRange, WrapKind};
 
 use bun_ast::StoreRef;
@@ -237,8 +237,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
 
     let namespace_export_part_index = bun_ast::NAMESPACE_EXPORT_PART_INDEX;
 
-    let is_html = c.parse_graph().input_files.items_loader()[source_index] == Loader::Html;
-
     stmts.reset();
 
     let part_index_for_lazy_default_export: u32 = 'brk: {
@@ -356,13 +354,6 @@ pub fn generate_code_for_file_in_chunk_js<'r, 'src>(
             continue;
         }
 
-        if is_html {
-            if let Err(err) = c.append_html_script_wrapper_calls(stmts, part, &ast) {
-                return PrintResult::Err(err.into());
-            }
-            continue;
-        }
-
         let mut single_stmts_list: [Stmt; 1] = [Stmt::empty()];
         let mut part_stmts: &[Stmt] = part.stmts.slice();
 
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/postProcessJSChunk.rs b/src/bundler/linker_context/postProcessJSChunk.rs
index fe6f27f85bc2..2e7da0c1c7fb 100644
--- a/src/bundler/linker_context/postProcessJSChunk.rs
+++ b/src/bundler/linker_context/postProcessJSChunk.rs
@@ -680,12 +680,7 @@ pub(crate) fn post_process_js_chunk(
         }
 
         // TODO: metafile
-
-        // Put a newline before the next file path comment. An empty result (a
-        // part range that printed nothing) must not take it away again.
-        if !compile_result.code().is_empty() {
-            newline_before_comment = true;
-        }
+        newline_before_comment = !compile_result.code().is_empty();
     }
     // An entry chunk whose code all lives in shared chunks has no compile results of its own.
     if !preload_registration.is_empty() {
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index f364cf66fffd..82945c73e895 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -755,8 +755,12 @@ pub(crate) fn scan_imports_and_exports(
             let export_kind = col_ref!(exports_kind)[id];
             let source: &Source = &col_ref!(input_files)[id];
             // An HTML file's `<script src>` records print as bare wrapper calls
-            // (`append_html_script_wrapper_calls`); nothing reads the namespace.
+            // (`call_wrapped_html_scripts`); nothing reads the namespace.
             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];
diff --git a/test/bundler/bundler_html.test.ts b/test/bundler/bundler_html.test.ts
index 49e3093d0951..e840daa17364 100644
--- a/test/bundler/bundler_html.test.ts
+++ b/test/bundler/bundler_html.test.ts
@@ -311,8 +311,9 @@ console.log("requires " + dep);`,
   });
 
   // The chunk prints wrapped files ahead of the flat ones, so the call for a
-  // CommonJS script that sits between two plain scripts must come from the
-  // tag's own part to keep document order, not from next to the wrapper.
+  // 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: {
@@ -323,6 +324,7 @@ console.log("requires " + dep);`,
     <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");`,
@@ -335,6 +337,7 @@ console.log("requires " + dep);`,
   return {};
 });`,
       "/last.js": `console.log("last");`,
+      "/tail.cjs": `console.log("tail");`,
     },
     entryPoints: ["/index.html"],
     onAfterBundle(api) {
@@ -342,7 +345,37 @@ console.log("requires " + dep);`,
       api.expectFile("out/" + js).not.toContain("__toESM");
       api.writeFile("out/run.mjs", `import "./${js}";`);
     },
-    run: { file: "out/run.mjs", stdout: "first\numd badge\nlast" },
+    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
diff --git a/test/bundler/html-import-manifest.test.ts b/test/bundler/html-import-manifest.test.ts
index 5ce08a6ca37e..2698ff6936ef 100644
--- a/test/bundler/html-import-manifest.test.ts
+++ b/test/bundler/html-import-manifest.test.ts
@@ -141,11 +141,11 @@ console.log(favicon);
             "files": [
               {
                 "input": "client.html",
-                "path": "./client-c9kjeh05.js",
+                "path": "./client-qjznw47b.js",
                 "loader": "js",
                 "isEntry": true,
                 "headers": {
-                  "etag": "7GmzUg4RQCU",
+                  "etag": "l5IfNVyE54s",
                   "content-type": "text/javascript;charset=utf-8"
                 }
               },
@@ -155,7 +155,7 @@ console.log(favicon);
                 "loader": "html",
                 "isEntry": true,
                 "headers": {
-                  "etag": "L1NGVitZslc",
+                  "etag": "xh1kdn7wbmI",
                   "content-type": "text/html;charset=utf-8"
                 }
               },
@@ -325,17 +325,17 @@ console.log("About manifest:", aboutHtml);
               {
                 "headers": {
                   "content-type": "text/javascript;charset=utf-8",
-                  "etag": "Vr91Jdsy4Zc",
+                  "etag": "Dl7kT6q7eY4",
                 },
                 "input": "home.html",
                 "isEntry": true,
                 "loader": "js",
-                "path": "./home-pzn5vj1q.js",
+                "path": "./home-ey4favse.js",
               },
               {
                 "headers": {
                   "content-type": "text/html;charset=utf-8",
-                  "etag": "bO9UOC8tMwQ",
+                  "etag": "IhvRaM9jGDU",
                 },
                 "input": "home.html",
                 "isEntry": true,
@@ -360,17 +360,17 @@ console.log("About manifest:", aboutHtml);
               {
                 "headers": {
                   "content-type": "text/javascript;charset=utf-8",
-                  "etag": "xjiS27vgDE0",
+                  "etag": "RCRrF1EbBvo",
                 },
                 "input": "about.html",
                 "isEntry": true,
                 "loader": "js",
-                "path": "./about-6rjvv0cd.js",
+                "path": "./about-44bqhv6t.js",
               },
               {
                 "headers": {
                   "content-type": "text/html;charset=utf-8",
-                  "etag": "yq0KRVKuKEY",
+                  "etag": "2OGqRD6vx54",
                 },
                 "input": "about.html",
                 "isEntry": true,
diff --git a/test/js/bun/http/bun-serve-html.test.ts b/test/js/bun/http/bun-serve-html.test.ts
index c5b3ff58bb59..32cbe93c1061 100644
--- a/test/js/bun/http/bun-serve-html.test.ts
+++ b/test/js/bun/http/bun-serve-html.test.ts
@@ -224,7 +224,7 @@ console.log("How...dashing?");
   "content-length": "316",
   "content-type": "text/javascript;charset=utf-8",
   "date": "<date>",
-  "etag": ""c2050d7cfe555369"",
+  "etag": ""f862dbeedf9b72bc"",
   "sourcemap": "/chunk-HASH.js.map",
 }
 `);

From 187526cb1a91f1eeaf46bbb02dc8a0d78c10c85d Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Wed, 14 Oct 2026 05:12:02 +0000
Subject: [PATCH 4/5] bundler: keep the comments of the HTML script wrapper
 calls to one line each

---
 src/ast/import_record.rs                             |  3 +--
 src/bundler/LinkerContext.rs                         | 12 ++++--------
 .../linker_context/findAllImportedPartsInJSOrder.rs  |  3 +--
 src/bundler/linker_context/scanImportsAndExports.rs  |  3 +--
 4 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/src/ast/import_record.rs b/src/ast/import_record.rs
index ceb54e23255a..0a77a0d7ec4e 100644
--- a/src/ast/import_record.rs
+++ b/src/ast/import_record.rs
@@ -108,8 +108,7 @@ bitflags::bitflags! {
         /// import), and those records must never be resolved.
         const IS_BARREL_DEFERRED = 1 << 18;
 
-        /// The `src` of a `<script>` element of an HTML file: the page runs
-        /// the file where the element is. A `<link>` only refers to its file.
+        /// 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/LinkerContext.rs b/src/bundler/LinkerContext.rs
index 8f29927ad4ae..ffd3c35910a3 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -994,9 +994,9 @@ impl<'a> LinkerContext<'a> {
                 // live (so the JS-chunk visitor follows every embedded import record).
                 // `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. `call_wrapped_html_scripts` can
-                // have made several parts of it: each one holds import records.
+                // `Part::is_live = true` initializer.
                 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);
@@ -2371,12 +2371,7 @@ impl<'a> LinkerContext<'a> {
         Ok(true)
     }
 
-    /// A page runs a `<script src>` where the tag is. The HTML loader puts every
-    /// import record of the page in part 1, which has no statement, so a script
-    /// that the linker wrapped would not run: nothing calls `require_foo` or
-    /// `init_foo`. Gives the part those calls. A part prints after all the files
-    /// that it imports, so it ends at each call that another record follows, and
-    /// the records after the call go to a new part.
+    /// 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,
@@ -2434,6 +2429,7 @@ impl<'a> LinkerContext<'a> {
                 call = Expr::allocate(arena, E::Await { value: call }, Loc::EMPTY);
             }
             calls.push(Stmt::allocate_expr(arena, call));
+            // A part prints after every file that it imports: end it here, ahead of the later records.
             if splits && i + 1 < indices.len() {
                 groups.push((i + 1, to_stmts(&calls)));
                 calls.clear();
diff --git a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
index 1e98ec7b1353..1028cb48d105 100644
--- a/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
+++ b/src/bundler/linker_context/findAllImportedPartsInJSOrder.rs
@@ -634,8 +634,7 @@ 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 of an HTML file counts. A part ends at each wrapper call that the page
-        // makes (`call_wrapped_html_scripts`): the files of the later records go after that call.
+        // 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];
diff --git a/src/bundler/linker_context/scanImportsAndExports.rs b/src/bundler/linker_context/scanImportsAndExports.rs
index 82945c73e895..4bbfee94e564 100644
--- a/src/bundler/linker_context/scanImportsAndExports.rs
+++ b/src/bundler/linker_context/scanImportsAndExports.rs
@@ -754,8 +754,7 @@ 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];
-            // An HTML file's `<script src>` records print as bare wrapper calls
-            // (`call_wrapped_html_scripts`); nothing reads the namespace.
+            // 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 {

From 01ec601602160680b2b229008abd175c2929e089 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Wed, 14 Oct 2026 06:51:47 +0000
Subject: [PATCH 5/5] bundler: end the HTML part at every wrapper call; test
 formats, minify, source maps and an import()ed page

call_wrapped_html_scripts no longer treats a wrapped HTML file as a
special case: each call ends its part, and a wrapped file prints its
parts in order inside its wrapper anyway.

New cases run the built chunk for --format=iife, --format=cjs, the
minifier and an external source map, for a lazily-initialized module
that has no wrapper to call, and for a page that a script loads with
import().
---
 src/bundler/LinkerContext.rs      | 35 ++++++-------------
 test/bundler/bundler_html.test.ts | 58 +++++++++++++++++++++++++++++--
 2 files changed, 66 insertions(+), 27 deletions(-)

diff --git a/src/bundler/LinkerContext.rs b/src/bundler/LinkerContext.rs
index ffd3c35910a3..ea0111cfc43c 100644
--- a/src/bundler/LinkerContext.rs
+++ b/src/bundler/LinkerContext.rs
@@ -2389,19 +2389,9 @@ impl<'a> LinkerContext<'a> {
             return Ok(());
         };
         let indices = part.import_record_indices.slice();
-        // A wrapped file prints whole, inside its wrapper.
-        let splits = flags[source_index as usize].wrap == WrapKind::None;
 
-        let to_stmts = |calls: &[Stmt]| {
-            if calls.is_empty() {
-                bun_ast::StoreSlice::EMPTY
-            } else {
-                bun_ast::StoreSlice::new_mut(arena.alloc_slice_copy(calls))
-            }
-        };
-        // Per part: where its records end in `indices`, and its statements.
-        let mut groups: Vec<(usize, bun_ast::StoreSlice<Stmt>)> = Vec::new();
-        let mut calls: Vec<Stmt> = Vec::new();
+        // 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
@@ -2428,23 +2418,20 @@ impl<'a> LinkerContext<'a> {
             if flags[other].wrap == WrapKind::Esm && flags[other].is_async_or_has_async_dependency {
                 call = Expr::allocate(arena, E::Await { value: call }, Loc::EMPTY);
             }
-            calls.push(Stmt::allocate_expr(arena, call));
-            // A part prints after every file that it imports: end it here, ahead of the later records.
-            if splits && i + 1 < indices.len() {
-                groups.push((i + 1, to_stmts(&calls)));
-                calls.clear();
-            }
+            // 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)));
         }
-        if groups.is_empty() && calls.is_empty() {
+        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));
         }
-        groups.push((indices.len(), to_stmts(&calls)));
 
-        let mut groups = groups.into_iter();
-        let (first_end, first_stmts) = groups.next().expect("infallible: pushed above");
         let mut begin = first_end;
-        let mut new_parts: Vec<Part> = Vec::with_capacity(groups.len());
-        for (end, stmts) in groups {
+        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]),
diff --git a/test/bundler/bundler_html.test.ts b/test/bundler/bundler_html.test.ts
index e840daa17364..cd0a95ab63bb 100644
--- a/test/bundler/bundler_html.test.ts
+++ b/test/bundler/bundler_html.test.ts
@@ -380,7 +380,8 @@ module.exports = {};`,
 
   // 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.
+  // 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: {
@@ -388,11 +389,13 @@ module.exports = {};`,
 <!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);`,
@@ -401,9 +404,10 @@ 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 " + sync + " " + tla);`,
+console.log("lazy " + pure + " " + sync + " " + tla);`,
     },
     entryPoints: ["/index.html"],
     onAfterBundle(api) {
@@ -411,7 +415,55 @@ console.log("lazy " + sync + " " + tla);`,
       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 sync tla" },
+    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