bundler(splitting): one edge rule for both walks; no chunk imports an unhashed entry

docs/bundler/index.mdx

@@ -617,6 +617,8 @@ With `splitting`, also fold small side-effect-free chunks into a chunk that more
 
 Code splitting gives each distinct set of importers its own chunk, then folds chunks that are always loaded together: a module that `index.tsx` imports and that a lazily `import()`ed module also imports lives in `index.js`, and the lazy chunk imports it from there, because the lazy module can only load after `index.tsx` has run. That fold never makes an entrypoint load more code, so it is always on.
 
+With `target: "browser"`, nothing folds into the chunk of an entrypoint whose name has no `[hash]` (the default `naming`). A server can add a query string to that URL (`index.js?v=123`), and an `import "./index.js"` in another chunk would then run the file a second time. The shared code goes into one hashed chunk next to the entrypoint. Entrypoints that an HTML file loads, and entrypoints with `[hash]` in `naming.entry`, still take the fold.
+
 `minChunkSize` goes further for chunks whose source files add up to fewer than this many bytes and whose modules run nothing at the top level: only declarations, `"sideEffects": false` in their `package.json`, a lazily initialized CommonJS/ESM wrapper, or an import of a CommonJS module (such as `react`) that is already initialized wherever the chunk's code ends up. Such a chunk folds into a chunk loaded by a superset of its importers. Everything it imports must already be loaded whenever that target is, or be side-effect free as well. The extra entrypoints then carry some unused definitions, capped at about 1.5% of what each entrypoint loaded to begin with. No side effect runs earlier than before and nothing lazy becomes eager. Because these rules bound what an entrypoint can end up loading, a large `minChunkSize` is reasonable.
 
 For `target: "browser"`, where every chunk is a request, 16 KiB is a good starting point.

packages/bun-types/bun.d.ts

@@ -3210,6 +3210,7 @@ declare module "bun" {
      * that absorbs a folded chunk exports the symbols other chunks import
      * from it. Requires `splitting: true`. CLI: `--min-chunk-size`. For browser
      * builds, where every chunk is a request, 16384 is a good value.
+     * Nothing folds into a `target: "browser"` entry point without `[hash]` in its name.
      *
      * @default 0 (disabled)
      */

src/bundler/LinkerContext.rs

@@ -1445,6 +1445,7 @@ pub struct LinkerOptions {
     /// See `merge_small_chunks`.
     pub(crate) min_chunk_size: u64,
     pub(crate) fold_chunks: bool,
+    pub(crate) entry_naming_has_hash: bool,
     pub(crate) module_preload: bool,
     pub(crate) source_maps: SourceMapOption,
     pub(crate) target: Target,
@@ -1493,6 +1494,7 @@ impl Default for LinkerOptions {
             css_chunking: false,
             min_chunk_size: 0,
             fold_chunks: true,
+            entry_naming_has_hash: false,
             module_preload: true,
             source_maps: SourceMapOption::None,
             target: Target::Browser,

src/bundler/bundle_v2.rs

@@ -3302,6 +3302,10 @@ pub mod bv2_impl {
                     crate::options::default_min_chunk_size(this.transpiler.options.target)
                 });
             this.linker.options.fold_chunks = this.transpiler.options.fold_chunks;
+            this.linker.options.entry_naming_has_hash = crate::options::path_template_needs(
+                &this.transpiler.options.entry_naming,
+                crate::options::PlaceholderField::Hash,
+            );
             this.linker.options.module_preload = this.transpiler.options.module_preload;
             this.linker.options.source_maps = this.transpiler.options.source_map;
             this.linker.options.tree_shaking = this.transpiler.options.tree_shaking;

src/bundler/linker_context/README.md

@@ -741,6 +741,7 @@ The renamed symbols are then used during final code generation to produce output
 - Computes, per `import()` entry point, which other entry points are guaranteed to be loaded already whenever it loads
 - Reduces each chunk key (`File.entry_bits`) to its load-condition class by dropping such redundant dynamic entries
 - Rewrites the entry bits of files to those of the class's parent chunk (the chunk keyed by the reduced set, else the largest member) before `computeChunks()` groups files
+- Leaves an entry point's own chunk alone when the entry point has exports, with `--compile`, and for a browser entry point without `[hash]` in its name (a page can load it as `entry.js?v=1`, so no chunk may import it)
 - Keeps a chunk out of the fold when it can be in the middle of being evaluated while an entry of its class loads (it, or a file that statically imports its way to it, `require()`s a split ES module): the entry's chunk reads the other members then
 - With `--min-chunk-size`, additionally folds small chunks with no top-level side effects into a chunk loaded by a superset of their entries when every dependency is already loaded wherever the target is, no static import cycle between chunks results, and every CommonJS/ESM wrapper the moved code initializes at the top level is already initialized by a chunk the target imports
 
@@ -762,7 +763,7 @@ The renamed symbols are then used during final code generation to produce output
 **Key functions**:
 
 - Walks the import graph in evaluation order (`EntryWalk`): depth first along every `import` statement, also through files that tree shaking dropped, so a file prints after the files it imports
-- One walk per entry point, in parallel. A chunk has one owner: the entry point that loads first among the chunk's entry points (`LoadOrder`). The owner's walk places the files of the chunk, so no two walks write the same list. Without code splitting, each chunk is owned by its own entry point
+- One walk per entry point, in parallel. A chunk has one owner: the entry point that loads first among the chunk's entry points (`load_rank`). `load_rank` and `EntryWalk` read the same edges (`for_each_edge`). The owner's walk places the files of the chunk, so no two walks write the same list. Without code splitting, each chunk is owned by its own entry point
 - Places the parts of a file in runs: a part prints after the files it imports and before the files that the next part imports
 - Collects the live parts of each run into part ranges
 - Records the other chunks in the order a walk from the chunk's files reaches their first file with side effects (`reached_chunks_in_order`), which orders the chunk's cross-chunk `import` statements

src/bundler/linker_context/findAllImportedPartsInJSOrder.rs

@@ -318,6 +318,79 @@
     }
 }
 
+#[derive(Clone, Copy)]
+enum Edge {
+    /// `file` runs here, under the same load.
+    Import(IndexInt),
+    /// A split `require()` in a part that runs at load: the chunk of `file` runs here.
+    LoadNow(IndexInt),
+    /// An `import()`, or a split `require()` in a part that only declares.
+    LoadLater(IndexInt),
+}
+
+/// The files that a file leads to, in evaluation order, with the part that leads there. `runs`: the load evaluates the file.
+fn for_each_edge(
+    c: &LinkerContext,
+    source_index: IndexInt,
+    runs: bool,
+    mut each: impl FnMut(u32, Edge),
+) {
+    let records = c.graph.ast.items_import_records()[source_index as usize].as_slice();
+    if c.graph.ast.items_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.
+        for record in records {
+            if record.source_index.is_valid() {
+                each(0, Edge::Import(record.source_index.get()));
+            }
+        }
+        return;
+    }
+
+    let parts = c.graph.ast.items_parts()[source_index as usize].as_slice();
+    let parts_live = &c.graph.parts_live[source_index as usize];
+    for (part_index, part) in parts.iter().enumerate() {
+        let runs_here = runs && parts_live.is_set(part_index);
+        let part_index = part_index as u32;
+        for &record_id in part.import_record_indices.slice() {
+            let record: &ImportRecord = &records[record_id as usize];
+            if !record.source_index.is_valid() || !(record.kind == ImportKind::Stmt || runs_here) {
+                continue;
+            }
+            let other = record.source_index.get();
+            each(
+                part_index,
+                if !c.is_external_dynamic_import(record, source_index) {
+                    Edge::Import(other)
+                } else if record.kind == ImportKind::Require && !part_has_no_side_effects(part) {
+                    Edge::LoadNow(other)
+                } else {
+                    Edge::LoadLater(other)
+                },
+            );
+        }
+        // A file that the `import` statements did not reach: ahead of the part that uses it.
+        if runs_here && part_index != bun_ast::NAMESPACE_EXPORT_PART_INDEX {
+            for dependency in part.dependencies.iter() {
+                each(part_index, Edge::Import(dependency.source_index.get()));
+            }
+        }
+    }
+    // The namespace export part is ahead of the `import` statements and only holds getters.
+    if let Some(namespace_export) = parts.get(bun_ast::NAMESPACE_EXPORT_PART_INDEX as usize)
+        && runs
+        && parts_live.is_set(bun_ast::NAMESPACE_EXPORT_PART_INDEX as usize)
+    {
+        for dependency in namespace_export.dependencies.iter() {
+            each(
+                parts.len() as u32,
+                Edge::Import(dependency.source_index.get()),
+            );
+        }
+    }
+}
+
 #[derive(Clone, Copy)]
 enum LoadFrame {
     /// `loader`: the entry point whose load reaches the file.
@@ -336,10 +409,6 @@
     let files_len = c.graph.files.len();
     let entry_points = c.graph.entry_points.items_source_index();
     let entry_point_kinds = c.graph.files.items_entry_point_kind();
-    let css = c.graph.ast.items_css();
-    let loaders = c.parse_graph().input_files.items_loader();
-    let parts = c.graph.ast.items_parts();
-    let import_records = c.graph.ast.items_import_records();
     let entry_bits = c.graph.files.items_entry_bits();
 
     // The load of an entry point that loads the file evaluated it.
@@ -409,54 +478,16 @@
             }
 
             let mark = stack.len();
-            let records = import_records[source_index as usize].as_slice();
-            if css[source_index as usize].is_some()
-                || loaders[source_index as usize] == Loader::Html
-            {
-                for record in records {
-                    if record.source_index.is_valid() {
-                        stack.push(LoadFrame::Enter {
-                            source_index: record.source_index.get(),
-                            loader,
-                        });
-                    }
-                }
-            } else {
-                let parts_live = &c.graph.parts_live[source_index as usize];
-                for (part_index, part) in parts[source_index as usize].as_slice().iter().enumerate()
-                {
-                    let runs = evaluates && parts_live.is_set(part_index);
-                    for &record_id in part.import_record_indices.slice() {
-                        let record: &ImportRecord = &records[record_id as usize];
-                        if !record.source_index.is_valid()
-                            || !(record.kind == ImportKind::Stmt || runs)
-                        {
-                            continue;
-                        }
-                        let other = record.source_index.get();
-                        stack.push(if !c.is_external_dynamic_import(record, source_index) {
-                            LoadFrame::Enter {
-                                source_index: other,
-                                loader,
-                            }
-                        } else if record.kind == ImportKind::Require
-                            && !part_has_no_side_effects(part)
-                        {
-                            LoadFrame::Load(entry_id_of_file[other as usize])
-                        } else {
-                            LoadFrame::Later(entry_id_of_file[other as usize])
-                        });
-                    }
-                    if runs {
-                        for dependency in part.dependencies.iter() {
-                            stack.push(LoadFrame::Enter {
-                                source_index: dependency.source_index.get(),
-                                loader,
-                            });
-                        }
-                    }
-                }
-            }
+            for_each_edge(c, source_index, evaluates, |_, edge| {
+                stack.push(match edge {
+                    Edge::Import(source_index) => LoadFrame::Enter {
+                        source_index,
+                        loader,
+                    },
+                    Edge::LoadNow(other) => LoadFrame::Load(entry_id_of_file[other as usize]),
+                    Edge::LoadLater(other) => LoadFrame::Later(entry_id_of_file[other as usize]),
+                });
+            });
             stack[mark..].reverse();
         }
     }
@@ -474,7 +505,7 @@
 }
 
 /// One walk from an entry point. It lays out the chunks that the entry point owns.
 struct EntryWalk {
     entry_id: u32,
     chunks: Vec<u32>,
     /// Per owned chunk: the runs placed so far.
@@ -525,9 +556,6 @@
         let entry_bits = c.graph.files.items_entry_bits();
         let flags = c.graph.meta.items_flags();
         let css = c.graph.ast.items_css();
-        let loaders = c.parse_graph().input_files.items_loader();
-        let parts = c.graph.ast.items_parts();
-        let import_records = c.graph.ast.items_import_records();
         let loads = |source_index: IndexInt, loader: u32| {
             files_live.is_set(source_index as usize)
                 && entry_bits[source_index as usize].is_set(loader as usize)
@@ -640,59 +668,13 @@
                 });
             };
 
-            let records = import_records[source_index as usize].as_slice();
-            if css[source_index as usize].is_some()
-                || loaders[source_index as usize] == Loader::Html
-            {
-                // A CSS or HTML file has no parts; every record counts.
-                for record in records {
-                    if record.source_index.is_valid() {
-                        import(0, record.source_index.get(), loader);
-                    }
+            for_each_edge(c, source_index, runs, |part_index, edge| match edge {
+                Edge::Import(other) => import(part_index, other, loader),
+                Edge::LoadNow(other) => {
+                    import(part_index, other, plan.entry_id_of_file[other as usize])
                 }
-            } else {
-                let parts_live = &c.graph.parts_live[source_index as usize];
-                for (part_index, part) in parts[source_index as usize].as_slice().iter().enumerate()
-                {
-                    let runs_here = runs && parts_live.is_set(part_index);
-                    let part_index = part_index as u32;
-                    for &record_id in part.import_record_indices.slice() {
-                        let record: &ImportRecord = &records[record_id as usize];
-                        if !record.source_index.is_valid()
-                            || !(record.kind == ImportKind::Stmt || runs_here)
-                        {
-                            continue;
-                        }
-                        let other = record.source_index.get();
-                        if !c.is_external_dynamic_import(record, source_index) {
-                            import(part_index, other, loader);
-                        } else if record.kind == ImportKind::Require
-                            && !part_has_no_side_effects(part)
-                        {
-                            // A split `require()` in a part that runs at load runs its chunk here.
-                            import(part_index, other, plan.entry_id_of_file[other as usize]);
-                        }
-                    }
-                    // A file that the `import` statements did not reach: ahead of the part that uses it.
-                    if runs_here && part_index != bun_ast::NAMESPACE_EXPORT_PART_INDEX {
-                        for dependency in part.dependencies.iter() {
-                            import(part_index, dependency.source_index.get(), loader);
-                        }
-                    }
-                }
-                // The namespace export part is ahead of the `import` statements and only holds getters.
-                let file_parts = parts[source_index as usize].as_slice();
-                if let Some(namespace_export) =
-                    file_parts.get(bun_ast::NAMESPACE_EXPORT_PART_INDEX as usize)
-                    && runs
-                    && parts_live.is_set(bun_ast::NAMESPACE_EXPORT_PART_INDEX as usize)
-                {
-                    let after_all_parts = file_parts.len() as u32;
-                    for dependency in namespace_export.dependencies.iter() {
-                        import(after_all_parts, dependency.source_index.get(), loader);
-                    }
-                }
-            }
+                Edge::LoadLater(_) => {}
+            });
             if let Some(slot) = slot {
                 stack.push(WalkFrame::Place {
                     run: PartRun {

src/bundler/linker_context/mergeSmallChunks.rs

@@ -4,7 +4,7 @@ use bun_ast::{ImportKind, ImportRecordFlags};
 use bun_collections::{ArrayHashMap, AutoBitSet, MapEntry};
 
 use crate::linker_context_mod::debug;
-use crate::options::Target;
+use crate::options::{Loader, Target};
 use crate::{EntryPoint, Index, LinkerContext, WrapKind};
 
 bun_core::define_scoped_log!(debug_merge, MergeChunks, hidden);
@@ -993,9 +993,17 @@ pub(crate) fn merge_small_chunks(
     // "exports-only"`). Chunks loaded together with it still fold into each
     // other. `--compile` leaves the chunks of user entry points alone too.
     let export_aliases = this.graph.meta.items_sorted_and_filtered_export_aliases();
+    let loaders = this.parse_graph().input_files.items_loader();
+    // A page can load such a file as `entry.js?v=1`; an `import "./entry.js"` in a chunk would then run it a second time.
+    let host_names_url = |source_index: usize| {
+        this.options.target == Target::Browser
+            && !this.options.entry_naming_has_hash
+            && loaders[source_index] != Loader::Html
+    };
     let pin_entry_chunk = |entry_id: usize| {
         let source_index = entry_source_indices[entry_id] as usize;
-        (this.options.compile_mode.is_executable() && !is_dynamic_entry(entry_id))
+        (!is_dynamic_entry(entry_id)
+            && (this.options.compile_mode.is_executable() || host_names_url(source_index)))
             || flags[source_index].wrap == WrapKind::Cjs
             || flags[source_index].needs_synthetic_default_export
             || !export_aliases[source_index].is_empty()

src/bundler/options.rs

@@ -2120,7 +2120,7 @@ pub enum PlaceholderField {
 
 // Shared body for PathTemplate::needs / PathTemplateConst::needs (D064).
 #[inline]
-fn path_template_needs(data: &[u8], field: PlaceholderField) -> bool {
+pub(crate) fn path_template_needs(data: &[u8], field: PlaceholderField) -> bool {
     let needle: &[u8] = match field {
         PlaceholderField::Dir => b"[dir]",
         PlaceholderField::Name => b"[name]",