Turbopack: use document.currentScript instead of chunk path literal (#77773)

### What?

Instead of embedding the chunk filename into the chunk itself (which is a probably for content hashing), use `document.currentScript` to grab the chunk path.

Author: sokra

Diff for: crates/next-core/src/next_client/context.rs

@@ -13,7 +13,9 @@ use turbopack::{
     },
     resolve_options_context::ResolveOptionsContext,
 };
-use turbopack_browser::{react_refresh::assert_can_resolve_react_refresh, BrowserChunkingContext};
+use turbopack_browser::{
+    react_refresh::assert_can_resolve_react_refresh, BrowserChunkingContext, CurrentChunkMethod,
+};
 use turbopack_core::{
     chunk::{
         module_id_strategies::ModuleIdStrategy, ChunkingConfig, ChunkingContext, MinifyType,
@@ -462,6 +464,7 @@ pub async fn get_client_chunking_context(
         SourceMapsType::None
     })
     .asset_base_path(asset_prefix)
+    .current_chunk_method(CurrentChunkMethod::DocumentCurrentScript)
     .module_id_strategy(module_id_strategy);
 
     if next_mode.is_development() {

Diff for: turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -32,6 +32,16 @@ use crate::ecmascript::{
     list::asset::{EcmascriptDevChunkList, EcmascriptDevChunkListSource},
 };
 
+#[turbo_tasks::value]
+#[derive(Debug, Clone, Copy, Hash)]
+pub enum CurrentChunkMethod {
+    StringLiteral,
+    DocumentCurrentScript,
+}
+
+pub const CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR: &str =
+    "typeof document === \"object\" ? document.currentScript : undefined";
+
 pub struct BrowserChunkingContextBuilder {
     chunking_context: BrowserChunkingContext,
 }
@@ -92,6 +102,11 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn current_chunk_method(mut self, method: CurrentChunkMethod) -> Self {
+        self.chunking_context.current_chunk_method = method;
+        self
+    }
+
     pub fn module_id_strategy(
         mut self,
         module_id_strategy: ResolvedVc<Box<dyn ModuleIdStrategy>>,
@@ -160,6 +175,8 @@ pub struct BrowserChunkingContext {
     minify_type: MinifyType,
     /// Whether to generate source maps
     source_maps_type: SourceMapsType,
+    /// Method to use when figuring out the current chunk src
+    current_chunk_method: CurrentChunkMethod,
     /// Whether to use manifest chunks for lazy compilation
     manifest_chunks: bool,
     /// The module id strategy to use
@@ -198,6 +215,7 @@ impl BrowserChunkingContext {
                 runtime_type,
                 minify_type: MinifyType::NoMinify,
                 source_maps_type: SourceMapsType::Full,
+                current_chunk_method: CurrentChunkMethod::StringLiteral,
                 manifest_chunks: false,
                 module_id_strategy: ResolvedVc::upcast(DevModuleIdStrategy::new_resolved()),
                 chunking_configs: Default::default(),
@@ -297,6 +315,11 @@ impl BrowserChunkingContext {
             },
         )
     }
+
+    #[turbo_tasks::function]
+    pub fn current_chunk_method(&self) -> Vc<CurrentChunkMethod> {
+        self.current_chunk_method.cell()
+    }
 }
 
 #[turbo_tasks::value_impl]

Diff for: turbopack/crates/turbopack-browser/src/ecmascript/content.rs

@@ -1,6 +1,7 @@
 use std::io::Write;
 
 use anyhow::{bail, Result};
+use either::Either;
 use indoc::writedoc;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{ResolvedVc, Vc};
@@ -19,7 +20,10 @@ use super::{
     chunk::EcmascriptBrowserChunk, content_entry::EcmascriptBrowserChunkContentEntries,
     merged::merger::EcmascriptBrowserChunkContentMerger, version::EcmascriptBrowserChunkVersion,
 };
-use crate::BrowserChunkingContext;
+use crate::{
+    chunking_context::{CurrentChunkMethod, CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR},
+    BrowserChunkingContext,
+};
 
 #[turbo_tasks::value(serialization = "none")]
 pub struct EcmascriptBrowserChunkContent {
@@ -67,21 +71,31 @@ impl EcmascriptBrowserChunkContent {
     #[turbo_tasks::function]
     async fn code(self: Vc<Self>) -> Result<Vc<Code>> {
         let this = self.await?;
-        let output_root = this.chunking_context.output_root().await?;
         let source_maps = *this
             .chunking_context
             .reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
             .await?;
-        let chunk_path_vc = this.chunk.path();
-        let chunk_path = chunk_path_vc.await?;
-        let chunk_server_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
-            path
-        } else {
-            bail!(
-                "chunk path {} is not in output root {}",
-                chunk_path.to_string(),
-                output_root.to_string()
-            );
+        // Lifetime hack to pull out the var into this scope
+        let chunk_path;
+        let script_or_path = match *this.chunking_context.current_chunk_method().await? {
+            CurrentChunkMethod::StringLiteral => {
+                let output_root = this.chunking_context.output_root().await?;
+                let chunk_path_vc = this.chunk.path();
+                chunk_path = chunk_path_vc.await?;
+                let chunk_server_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
+                    path
+                } else {
+                    bail!(
+                        "chunk path {} is not in output root {}",
+                        chunk_path.to_string(),
+                        output_root.to_string()
+                    );
+                };
+                Either::Left(StringifyJs(chunk_server_path))
+            }
+            CurrentChunkMethod::DocumentCurrentScript => {
+                Either::Right(CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR)
+            }
         };
         let mut code = CodeBuilder::new(source_maps);
 
@@ -95,9 +109,8 @@ impl EcmascriptBrowserChunkContent {
         writedoc!(
             code,
             r#"
-                (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([{chunk_path}, {{
-            "#,
-            chunk_path = StringifyJs(chunk_server_path)
+                (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([{script_or_path}, {{
+            "#
         )?;
 
         let content = this.content.await?;
@@ -115,7 +128,7 @@ impl EcmascriptBrowserChunkContent {
         let mut code = code.build();
 
         if let MinifyType::Minify { mangle } = this.chunking_context.await?.minify_type() {
-            code = minify(&*chunk_path_vc.await?, &code, source_maps, mangle)?;
+            code = minify(&code, source_maps, mangle)?;
         }
 
         Ok(code.cell())

Diff for: turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs

@@ -1,6 +1,7 @@
 use std::io::Write;
 
 use anyhow::{bail, Result};
+use either::Either;
 use indoc::writedoc;
 use serde::Serialize;
 use turbo_rcstr::RcStr;
@@ -26,7 +27,10 @@ use turbopack_ecmascript::{
 };
 use turbopack_ecmascript_runtime::RuntimeType;
 
-use crate::BrowserChunkingContext;
+use crate::{
+    chunking_context::{CurrentChunkMethod, CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR},
+    BrowserChunkingContext,
+};
 
 /// An Ecmascript chunk that:
 /// * Contains the Turbopack browser runtime code; and
@@ -74,22 +78,32 @@ impl EcmascriptBrowserEvaluateChunk {
         let chunking_context = this.chunking_context.await?;
         let environment = this.chunking_context.environment();
 
-        let output_root = this.chunking_context.output_root().await?;
         let output_root_to_root_path = this.chunking_context.output_root_to_root_path();
         let source_maps = *this
             .chunking_context
             .reference_chunk_source_maps(Vc::upcast(self))
             .await?;
-        let chunk_path_vc = self.path();
-        let chunk_path = chunk_path_vc.await?;
-        let chunk_public_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
-            path
-        } else {
-            bail!(
-                "chunk path {} is not in output root {}",
-                chunk_path.to_string(),
-                output_root.to_string()
-            );
+        // Lifetime hack to pull out the var into this scope
+        let chunk_path;
+        let script_or_path = match *this.chunking_context.current_chunk_method().await? {
+            CurrentChunkMethod::StringLiteral => {
+                let output_root = this.chunking_context.output_root().await?;
+                let chunk_path_vc = self.path();
+                chunk_path = chunk_path_vc.await?;
+                let chunk_server_path = if let Some(path) = output_root.get_path_to(&chunk_path) {
+                    path
+                } else {
+                    bail!(
+                        "chunk path {} is not in output root {}",
+                        chunk_path.to_string(),
+                        output_root.to_string()
+                    );
+                };
+                Either::Left(StringifyJs(chunk_server_path))
+            }
+            CurrentChunkMethod::DocumentCurrentScript => {
+                Either::Right(CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR)
+            }
         };
 
         let other_chunks_data = self.chunks_data().await?;
@@ -139,12 +153,11 @@ impl EcmascriptBrowserEvaluateChunk {
             code,
             r#"
                 (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([
-                    {},
+                    {script_or_path},
                     {{}},
                     {}
                 ]);
             "#,
-            StringifyJs(&chunk_public_path),
             StringifyJs(&params),
         )?;
 
@@ -181,7 +194,7 @@ impl EcmascriptBrowserEvaluateChunk {
         let mut code = code.build();
 
         if let MinifyType::Minify { mangle } = this.chunking_context.await?.minify_type() {
-            code = minify(&*chunk_path_vc.await?, &code, source_maps, mangle)?;
+            code = minify(&code, source_maps, mangle)?;
         }
 
         Ok(code.cell())

Diff for: turbopack/crates/turbopack-browser/src/ecmascript/list/content.rs

@@ -1,9 +1,13 @@
 use std::io::Write;
 
 use anyhow::{Context, Result};
+use either::Either;
 use indoc::writedoc;
-use serde::Serialize;
-use turbo_tasks::{FxIndexMap, IntoTraitRef, ResolvedVc, TryJoinIterExt, Vc};
+use serde::{Deserialize, Serialize};
+use turbo_rcstr::RcStr;
+use turbo_tasks::{
+    trace::TraceRawVcs, FxIndexMap, IntoTraitRef, NonLocalValue, ResolvedVc, TryJoinIterExt, Vc,
+};
 use turbo_tasks_fs::File;
 use turbopack_core::{
     asset::{Asset, AssetContent},
@@ -21,11 +25,20 @@ use super::{
     update::update_chunk_list,
     version::EcmascriptDevChunkListVersion,
 };
+use crate::chunking_context::{
+    CurrentChunkMethod, CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR,
+};
+
+#[derive(Clone, Debug, Serialize, Deserialize, TraceRawVcs, PartialEq, Eq, NonLocalValue)]
+enum CurrentChunkMethodWithData {
+    StringLiteral(RcStr),
+    DocumentCurrentScript,
+}
 
 /// Contents of an [`EcmascriptDevChunkList`].
 #[turbo_tasks::value]
 pub(super) struct EcmascriptDevChunkListContent {
-    chunk_list_path: String,
+    current_chunk_method: CurrentChunkMethodWithData,
     pub(super) chunks_contents: FxIndexMap<String, ResolvedVc<Box<dyn VersionedContent>>>,
     source: EcmascriptDevChunkListSource,
 }
@@ -37,25 +50,35 @@ impl EcmascriptDevChunkListContent {
     pub async fn new(chunk_list: Vc<EcmascriptDevChunkList>) -> Result<Vc<Self>> {
         let chunk_list_ref = chunk_list.await?;
         let output_root = chunk_list_ref.chunking_context.output_root().await?;
+        let current_chunk_method = match *chunk_list_ref
+            .chunking_context
+            .current_chunk_method()
+            .await?
+        {
+            CurrentChunkMethod::StringLiteral => {
+                let path = output_root
+                    .get_path_to(&*chunk_list.path().await?)
+                    .context("chunk list path not in output root")?
+                    .into();
+                CurrentChunkMethodWithData::StringLiteral(path)
+            }
+            CurrentChunkMethod::DocumentCurrentScript => {
+                CurrentChunkMethodWithData::DocumentCurrentScript
+            }
+        };
         Ok(EcmascriptDevChunkListContent {
-            chunk_list_path: output_root
-                .get_path_to(&*chunk_list.path().await?)
-                .context("chunk list path not in output root")?
-                .to_string(),
+            current_chunk_method,
             chunks_contents: chunk_list_ref
                 .chunks
                 .await?
                 .iter()
-                .map(|chunk| {
-                    let output_root = output_root.clone();
-                    async move {
-                        Ok((
-                            output_root
-                                .get_path_to(&*chunk.path().await?)
-                                .map(|path| path.to_string()),
-                            chunk.versioned_content().to_resolved().await?,
-                        ))
-                    }
+                .map(async |chunk| {
+                    Ok((
+                        output_root
+                            .get_path_to(&*chunk.path().await?)
+                            .map(|path| path.to_string()),
+                        chunk.versioned_content().to_resolved().await?,
+                    ))
                 })
                 .try_join()
                 .await?
@@ -111,10 +134,17 @@ impl EcmascriptDevChunkListContent {
     pub(super) async fn code(self: Vc<Self>) -> Result<Vc<Code>> {
         let this = self.await?;
 
-        let params = EcmascriptDevChunkListParams {
-            path: &this.chunk_list_path,
-            chunks: this.chunks_contents.keys().map(|s| s.as_str()).collect(),
-            source: this.source,
+        let chunks = this
+            .chunks_contents
+            .keys()
+            .map(|s| s.as_str())
+            .collect::<Vec<_>>();
+
+        let script_or_path = match &this.current_chunk_method {
+            CurrentChunkMethodWithData::StringLiteral(path) => Either::Left(StringifyJs(path)),
+            CurrentChunkMethodWithData::DocumentCurrentScript => {
+                Either::Right(CURRENT_CHUNK_METHOD_DOCUMENT_CURRENT_SCRIPT_EXPR)
+            }
         };
 
         let mut code = CodeBuilder::default();
@@ -125,14 +155,14 @@ impl EcmascriptDevChunkListContent {
         writedoc!(
             code,
             r#"
-                (globalThis.TURBOPACK = globalThis.TURBOPACK || []).push([
-                    {},
-                    {{}},
-                ]);
-                (globalThis.TURBOPACK_CHUNK_LISTS = globalThis.TURBOPACK_CHUNK_LISTS || []).push({:#});
+                (globalThis.TURBOPACK_CHUNK_LISTS = globalThis.TURBOPACK_CHUNK_LISTS || []).push({{
+                    script: {script_or_path},
+                    chunks: {:#},
+                    source: {:#}
+                }});
             "#,
-            StringifyJs(&this.chunk_list_path),
-            StringifyJs(&params),
+            StringifyJs(&chunks),
+            StringifyJs(&this.source),
         )?;
 
         Ok(Code::cell(code.build()))
@@ -159,14 +189,3 @@ impl VersionedContent for EcmascriptDevChunkListContent {
         update_chunk_list(self, from_version)
     }
 }
-
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-struct EcmascriptDevChunkListParams<'a> {
-    /// Path to the chunk list to register.
-    path: &'a str,
-    /// All chunks that belong to the chunk list.
-    chunks: Vec<&'a str>,
-    /// Where this chunk list is from.
-    source: EcmascriptDevChunkListSource,
-}

Diff for: turbopack/crates/turbopack-browser/src/lib.rs

@@ -7,7 +7,9 @@ pub(crate) mod chunking_context;
 pub mod ecmascript;
 pub mod react_refresh;
 
-pub use chunking_context::{BrowserChunkingContext, BrowserChunkingContextBuilder};
+pub use chunking_context::{
+    BrowserChunkingContext, BrowserChunkingContextBuilder, CurrentChunkMethod,
+};
 
 pub fn register() {
     turbo_tasks::register();

Diff for: turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/dev-base.ts

@@ -20,10 +20,6 @@ const devModuleCache: ModuleCache<HotModule> = Object.create(null);
 type RefreshRuntimeGlobals =
   import("@next/react-refresh-utils/dist/runtime").RefreshRuntimeGlobals;
 
-// Workers are loaded via blob object urls and aren't relative to the main context, this gets
-// prefixed to chunk urls in the worker.
-// declare var TURBOPACK_WORKER_LOCATION: string;
-// declare var CHUNK_BASE_PATH: string;
 declare var $RefreshHelpers$: RefreshRuntimeGlobals["$RefreshHelpers$"];
 declare var $RefreshReg$: RefreshRuntimeGlobals["$RefreshReg$"];
 declare var $RefreshSig$: RefreshRuntimeGlobals["$RefreshSig$"];
@@ -1080,11 +1076,13 @@ function disposeChunk(chunkPath: ChunkPath): boolean {
  * Subscribes to chunk list updates from the update server and applies them.
  */
 function registerChunkList(
-  chunkUpdateProvider: ChunkUpdateProvider,
   chunkList: ChunkList
 ) {
-  const chunkListPath = chunkList.path;
-  chunkUpdateProvider.push([
+  const chunkListScript = chunkList.script;
+  const chunkListPath = getPathFromScript(chunkListScript);
+  // The "chunk" is also registered to finish the loading in the backend
+  BACKEND.registerChunk(chunkListPath as string as ChunkPath);
+  globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!.push([
     chunkListPath,
     handleApply.bind(null, chunkListPath),
   ]);
@@ -1108,16 +1106,3 @@ function registerChunkList(
 }
 
 globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS ??= [];
-
-const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS;
-if (Array.isArray(chunkListsToRegister)) {
-  for (const chunkList of chunkListsToRegister) {
-    registerChunkList(globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS, chunkList);
-  }
-}
-
-globalThis.TURBOPACK_CHUNK_LISTS = {
-  push: (chunkList) => {
-    registerChunkList(globalThis.TURBOPACK_CHUNK_UPDATE_LISTENERS!, chunkList);
-  },
-} satisfies ChunkListProvider;

Diff for: turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/base/runtime-base.ts

@@ -11,9 +11,17 @@
 /// <reference path="../base/globals.d.ts" />
 /// <reference path="../../../shared/runtime-utils.ts" />
 
+// Used in WebWorkers to tell the runtime about the chunk base path
 declare var TURBOPACK_WORKER_LOCATION: string;
+// Used in WebWorkers to tell the runtime about the current chunk url since it can't be detected via document.currentScript
+// Note it's stored in reversed order to use push and pop
+declare var TURBOPACK_NEXT_CHUNK_URLS: ChunkUrl[] | undefined;
+
+// Injected by rust code
 declare var CHUNK_BASE_PATH: string;
 declare var CHUNK_SUFFIX_PATH: string;
+
+// Provided by build or dev base
 declare function instantiateModule(id: ModuleId, source: SourceInfo): Module;
 
 type RuntimeParams = {
@@ -22,13 +30,13 @@ type RuntimeParams = {
 };
 
 type ChunkRegistration = [
-  chunkPath: ChunkPath,
+  chunkPath: ChunkScript,
   chunkModules: ModuleFactories,
   params: RuntimeParams | undefined
 ];
 
 type ChunkList = {
-  path: ChunkListPath;
+  script: ChunkListScript;
   chunks: ChunkData[];
   source: "entry" | "dynamic";
 };
@@ -245,7 +253,9 @@ function resolveAbsolutePath(modulePath?: string): string {
 }
 
 function getWorkerBlobURL(chunks: ChunkPath[]): string {
-  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};importScripts(${chunks.map(c => (`self.TURBOPACK_WORKER_LOCATION + ${JSON.stringify(getChunkRelativeUrl(c))}`)).join(", ")});`;
+  let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
+self.TURBOPACK_NEXT_CHUNK_URLS = ${JSON.stringify(chunks.reverse().map(getChunkRelativeUrl), null, 2)};
+importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c).reverse());`;
   let blob = new Blob([bootstrap], { type: "text/javascript" });
   return URL.createObjectURL(blob);
 }
@@ -304,6 +314,23 @@ function getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {
     .join("/")}${CHUNK_SUFFIX_PATH}` as ChunkUrl;
 }
 
+/**
+ * Return the ChunkPath from a ChunkScript.
+ */
+function getPathFromScript(chunkScript: ChunkPath | ChunkScript): ChunkPath;
+function getPathFromScript(chunkScript: ChunkListPath | ChunkListScript): ChunkListPath;
+function getPathFromScript(chunkScript: ChunkPath | ChunkListPath | ChunkScript | ChunkListScript): ChunkPath | ChunkListPath {
+  if (typeof chunkScript === "string") {
+    return chunkScript as ChunkPath | ChunkListPath;
+  }
+  const chunkUrl = typeof TURBOPACK_NEXT_CHUNK_URLS !== "undefined"
+    ? TURBOPACK_NEXT_CHUNK_URLS.pop()!
+    : chunkScript.getAttribute("src")!;
+  const src = decodeURIComponent(chunkUrl.replace(/[?#].*$/, ""));
+  const path = src.startsWith(CHUNK_BASE_PATH) ? src.slice(CHUNK_BASE_PATH.length) : src;
+  return path as ChunkPath | ChunkListPath;
+}
+
 /**
  * Marks a chunk list as a runtime chunk list. There can be more than one
  * runtime chunk list. For instance, integration tests can have multiple chunk
@@ -314,10 +341,11 @@ function markChunkListAsRuntime(chunkListPath: ChunkListPath) {
 }
 
 function registerChunk([
-  chunkPath,
+  chunkScript,
   chunkModules,
   runtimeParams,
 ]: ChunkRegistration) {
+  const chunkPath = getPathFromScript(chunkScript);
   for (const [moduleId, moduleFactory] of Object.entries(chunkModules)) {
     if (!moduleFactories[moduleId]) {
       moduleFactories[moduleId] = moduleFactory;

Diff for: turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/runtime-backend-dom.ts

@@ -151,6 +151,7 @@ const chunkResolvers: Map<ChunkUrl, ChunkResolver> = new Map();
       if (isCss(chunkUrl)) {
         // ignore
       } else if (isJs(chunkUrl)) {
+        self.TURBOPACK_NEXT_CHUNK_URLS!.push(chunkUrl);
         importScripts(TURBOPACK_WORKER_LOCATION + chunkUrl);
       } else {
         throw new Error(`can't infer type of chunk from URL ${chunkUrl} in worker`);

Diff for: turbopack/crates/turbopack-ecmascript-runtime/js/src/shared/runtime-types.d.ts

@@ -7,8 +7,11 @@
  * specific to the runtime context.
  */
 
+type CurrentScript = { getAttribute: (name: string) => string | null };
 type ChunkListPath = string & { readonly brand: unique symbol };
+type ChunkListScript = CurrentScript & { readonly brand: unique symbol };
 type ChunkPath = string & { readonly brand: unique symbol };
+type ChunkScript = CurrentScript & { readonly brand: unique symbol };
 type ChunkUrl = string & { readonly brand: unique symbol };
 type ModuleId = string;
 

Diff for: turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs

@@ -149,14 +149,29 @@ pub async fn get_browser_runtime_code(
         );
     }
 
-    // Registering chunks depends on the BACKEND variable, which is set by the
+    // Registering chunks and chunk lists depends on the BACKEND variable, which is set by the
     // specific runtime code, hence it must be appended after it.
     writedoc!(
         code,
         r#"
             const chunksToRegister = globalThis.TURBOPACK;
             globalThis.TURBOPACK = {{ push: registerChunk }};
             chunksToRegister.forEach(registerChunk);
+        "#
+    )?;
+    if matches!(*runtime_type, RuntimeType::Development) {
+        writedoc!(
+            code,
+            r#"
+            const chunkListsToRegister = globalThis.TURBOPACK_CHUNK_LISTS || [];
+            chunkListsToRegister.forEach(registerChunkList);
+            globalThis.TURBOPACK_CHUNK_LISTS = {{ push: registerChunkList }};
+        "#
+        )?;
+    }
+    writedoc!(
+        code,
+        r#"
             }})();
         "#
     )?;

Diff for: turbopack/crates/turbopack-ecmascript/src/minify.rs

@@ -23,21 +23,20 @@ use swc_core::{
     },
 };
 use tracing::{instrument, Level};
-use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::code_builder::{Code, CodeBuilder};
 
 use crate::parse::generate_js_source_map;
 
 #[instrument(level = Level::INFO, skip_all)]
-pub fn minify(path: &FileSystemPath, code: &Code, source_maps: bool, mangle: bool) -> Result<Code> {
+pub fn minify(code: &Code, source_maps: bool, mangle: bool) -> Result<Code> {
     let source_maps = source_maps
         .then(|| code.generate_source_map_ref())
         .transpose()?;
 
     let cm = Arc::new(SwcSourceMap::new(FilePathMapping::empty()));
     let (src, mut src_map_buf) = {
         let fm = cm.new_source_file(
-            FileName::Custom(path.path.to_string()).into(),
+            FileName::Anon.into(),
             code.source_code().to_str()?.into_owned(),
         );
 

Diff for: turbopack/crates/turbopack-nodejs/src/ecmascript/node/content.rs

@@ -52,7 +52,6 @@ impl EcmascriptBuildNodeChunkContent {
             .chunking_context
             .reference_chunk_source_maps(*ResolvedVc::upcast(this.chunk))
             .await?;
-        let chunk_path_vc = this.chunk.path();
 
         let mut code = CodeBuilder::default();
 
@@ -79,7 +78,7 @@ impl EcmascriptBuildNodeChunkContent {
         let mut code = code.build();
 
         if let MinifyType::Minify { mangle } = this.chunking_context.await?.minify_type() {
-            code = minify(&*chunk_path_vc.await?, &code, source_maps, mangle)?;
+            code = minify(&code, source_maps, mangle)?;
         }
 
         Ok(code.cell())