Turbopack: avoid embedding deployment ID into the turbopack runtime (#86370)

### What?

* add support for multiple options for chunk suffix
* Use FromScriptSrc chunk suffix to avoid depending on deployment id
* fix passing chunk suffix to WebWorkers initial chunks

Author: sokra

crates/next-api/src/project.rs

@@ -1144,7 +1144,6 @@ impl Project {
             client_root: self.client_relative_path().owned().await?,
             client_root_to_root_path: rcstr!("/ROOT"),
             asset_prefix: self.next_config().computed_asset_prefix(),
-            chunk_suffix_path: self.next_config().chunk_suffix_path(),
             environment: self.client_compile_time_info().environment(),
             module_id_strategy: self.module_ids(),
             export_usage: self.export_usage(),

crates/next-core/src/next_client/context.rs

@@ -14,7 +14,7 @@ use turbopack::{
     resolve_options_context::ResolveOptionsContext,
 };
 use turbopack_browser::{
-    BrowserChunkingContext, ContentHashing, CurrentChunkMethod,
+    BrowserChunkingContext, ChunkSuffix, ContentHashing, CurrentChunkMethod,
     react_refresh::assert_can_resolve_react_refresh,
 };
 use turbopack_core::{
@@ -414,7 +414,6 @@ pub struct ClientChunkingContextOptions {
     pub client_root: FileSystemPath,
     pub client_root_to_root_path: RcStr,
     pub asset_prefix: Vc<RcStr>,
-    pub chunk_suffix_path: Vc<Option<RcStr>>,
     pub environment: Vc<Environment>,
     pub module_id_strategy: Vc<Box<dyn ModuleIdStrategy>>,
     pub export_usage: Vc<OptionExportUsageInfo>,
@@ -437,7 +436,6 @@ pub async fn get_client_chunking_context(
         client_root,
         client_root_to_root_path,
         asset_prefix,
-        chunk_suffix_path,
         environment,
         module_id_strategy,
         export_usage,
@@ -452,7 +450,6 @@ pub async fn get_client_chunking_context(
 
     let next_mode = mode.await?;
     let asset_prefix = asset_prefix.owned().await?;
-    let chunk_suffix_path = chunk_suffix_path.to_resolved().await?;
     let mut builder = BrowserChunkingContext::builder(
         root_path,
         client_root.clone(),
@@ -464,7 +461,7 @@ pub async fn get_client_chunking_context(
         next_mode.runtime_type(),
     )
     .chunk_base_path(Some(asset_prefix.clone()))
-    .chunk_suffix_path(chunk_suffix_path)
+    .chunk_suffix(ChunkSuffix::FromScriptSrc.resolved_cell())
     .minify_type(if *minify.await? {
         MinifyType::Minify {
             mangle: (!*no_mangling.await?).then_some(MangleType::OptimalSize),

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -33,7 +33,7 @@ use turbopack_ecmascript::{
     chunk::EcmascriptChunk,
     manifest::{chunk_asset::ManifestAsyncModule, loader_item::ManifestLoaderChunkItem},
 };
-use turbopack_ecmascript_runtime::RuntimeType;
+use turbopack_ecmascript_runtime::{ChunkSuffix, RuntimeType};
 
 use crate::ecmascript::{
     chunk::EcmascriptBrowserChunk,
@@ -130,8 +130,8 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
-    pub fn chunk_suffix_path(mut self, chunk_suffix_path: ResolvedVc<Option<RcStr>>) -> Self {
-        self.chunking_context.chunk_suffix_path = Some(chunk_suffix_path);
+    pub fn chunk_suffix(mut self, chunk_suffix: ResolvedVc<ChunkSuffix>) -> Self {
+        self.chunking_context.chunk_suffix = Some(chunk_suffix);
         self
     }
 
@@ -253,9 +253,9 @@ pub struct BrowserChunkingContext {
     /// Base path that will be prepended to all chunk URLs when loading them.
     /// This path will not appear in chunk paths or chunk data.
     chunk_base_path: Option<RcStr>,
-    /// Suffix path that will be appended to all chunk URLs when loading them.
+    /// Suffix that will be appended to all chunk URLs when loading them.
     /// This path will not appear in chunk paths or chunk data.
-    chunk_suffix_path: Option<ResolvedVc<Option<RcStr>>>,
+    chunk_suffix: Option<ResolvedVc<ChunkSuffix>>,
     /// URL prefix that will be prepended to all static asset URLs when loading
     /// them.
     asset_base_path: Option<RcStr>,
@@ -322,7 +322,7 @@ impl BrowserChunkingContext {
                 asset_root_path,
                 asset_root_paths: Default::default(),
                 chunk_base_path: None,
-                chunk_suffix_path: None,
+                chunk_suffix: None,
                 asset_base_path: None,
                 asset_base_paths: Default::default(),
                 enable_hot_module_replacement: false,
@@ -425,11 +425,11 @@ impl BrowserChunkingContext {
 
     /// Returns the asset suffix path.
     #[turbo_tasks::function]
-    pub fn chunk_suffix_path(&self) -> Vc<Option<RcStr>> {
-        if let Some(chunk_suffix_path) = self.chunk_suffix_path {
-            *chunk_suffix_path
+    pub fn chunk_suffix(&self) -> Vc<ChunkSuffix> {
+        if let Some(chunk_suffix) = self.chunk_suffix {
+            *chunk_suffix
         } else {
-            Vc::cell(None)
+            ChunkSuffix::None.cell()
         }
     }
 

turbopack/crates/turbopack-browser/src/ecmascript/evaluate/chunk.rs

@@ -173,7 +173,7 @@ impl EcmascriptBrowserEvaluateChunk {
                 let runtime_code = turbopack_ecmascript_runtime::get_browser_runtime_code(
                     environment,
                     this.chunking_context.chunk_base_path(),
-                    this.chunking_context.chunk_suffix_path(),
+                    this.chunking_context.chunk_suffix(),
                     runtime_type,
                     output_root_to_root_path,
                     source_maps,

turbopack/crates/turbopack-browser/src/lib.rs

@@ -10,3 +10,4 @@ pub mod react_refresh;
 pub use chunking_context::{
     BrowserChunkingContext, BrowserChunkingContextBuilder, ContentHashing, CurrentChunkMethod,
 };
+pub use turbopack_ecmascript_runtime::ChunkSuffix;

turbopack/crates/turbopack-ecmascript-runtime/Cargo.toml

@@ -29,4 +29,3 @@ turbo-tasks-fs = { workspace = true }
 turbopack = { workspace = true }
 turbopack-core = { workspace = true }
 turbopack-ecmascript = { workspace = true }
-

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

@@ -13,13 +13,15 @@
 
 // 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 chunk suffix
+declare var TURBOPACK_CHUNK_SUFFIX: 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
+declare var CHUNK_SUFFIX: string
 
 interface TurbopackBrowserBaseContext<M> extends TurbopackBaseContext<M> {
   R: ResolvePathFromModule
@@ -322,8 +324,9 @@ function getWorkerBlobURL(chunks: ChunkPath[]): string {
   // It is important to reverse the array so when bootstrapping we can infer what chunk is being
   // evaluated by poping urls off of this array.  See `getPathFromScript`
   let bootstrap = `self.TURBOPACK_WORKER_LOCATION = ${JSON.stringify(location.origin)};
+self.TURBOPACK_CHUNK_SUFFIX = ${JSON.stringify(CHUNK_SUFFIX)};
 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());`
+importScripts(...self.TURBOPACK_NEXT_CHUNK_URLS.map(c => self.TURBOPACK_WORKER_LOCATION + c + self.TURBOPACK_CHUNK_SUFFIX).reverse());`
   let blob = new Blob([bootstrap], { type: 'text/javascript' })
   return URL.createObjectURL(blob)
 }
@@ -345,7 +348,7 @@ function getChunkRelativeUrl(chunkPath: ChunkPath | ChunkListPath): ChunkUrl {
   return `${CHUNK_BASE_PATH}${chunkPath
     .split('/')
     .map((p) => encodeURIComponent(p))
-    .join('/')}${CHUNK_SUFFIX_PATH}` as ChunkUrl
+    .join('/')}${CHUNK_SUFFIX}` as ChunkUrl
 }
 
 /**

turbopack/crates/turbopack-ecmascript-runtime/js/src/browser/runtime/dom/dev-backend-dom.ts

@@ -111,7 +111,7 @@ let DEV_BACKEND: DevRuntimeBackend
 
 function _eval({ code, url, map }: EcmascriptModuleEntry): ModuleFactory {
   code += `\n\n//# sourceURL=${encodeURI(
-    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX_PATH
+    location.origin + CHUNK_BASE_PATH + url + CHUNK_SUFFIX
   )}`
   if (map) {
     code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${btoa(

turbopack/crates/turbopack-ecmascript-runtime/src/browser_runtime.rs

@@ -11,14 +11,16 @@ use turbopack_core::{
 };
 use turbopack_ecmascript::utils::StringifyJs;
 
-use crate::{RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code};
+use crate::{
+    ChunkSuffix, RuntimeType, asset_context::get_runtime_asset_context, embed_js::embed_static_code,
+};
 
 /// Returns the code for the ECMAScript runtime.
 #[turbo_tasks::function]
 pub async fn get_browser_runtime_code(
     environment: ResolvedVc<Environment>,
     chunk_base_path: Vc<Option<RcStr>>,
-    chunk_suffix_path: Vc<Option<RcStr>>,
+    chunk_suffix: Vc<ChunkSuffix>,
     runtime_type: RuntimeType,
     output_root_to_root_path: RcStr,
     generate_source_map: bool,
@@ -80,10 +82,7 @@ pub async fn get_browser_runtime_code(
     let relative_root_path = output_root_to_root_path;
     let chunk_base_path = chunk_base_path.await?;
     let chunk_base_path = chunk_base_path.as_ref().map_or_else(|| "", |f| f.as_str());
-    let chunk_suffix_path = chunk_suffix_path.await?;
-    let chunk_suffix_path = chunk_suffix_path
-        .as_ref()
-        .map_or_else(|| "", |f| f.as_str());
+    let chunk_suffix = chunk_suffix.await?;
 
     writedoc!(
         code,
@@ -94,16 +93,42 @@ pub async fn get_browser_runtime_code(
             }}
 
             const CHUNK_BASE_PATH = {};
-            const CHUNK_SUFFIX_PATH = {};
             const RELATIVE_ROOT_PATH = {};
             const RUNTIME_PUBLIC_PATH = {};
         "#,
         StringifyJs(chunk_base_path),
-        StringifyJs(chunk_suffix_path),
         StringifyJs(relative_root_path.as_str()),
         StringifyJs(chunk_base_path),
     )?;
 
+    match &*chunk_suffix {
+        ChunkSuffix::None => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX = "";
+                "#
+            )?;
+        }
+        ChunkSuffix::Constant(suffix) => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX = {};
+                "#,
+                StringifyJs(suffix.as_str())
+            )?;
+        }
+        ChunkSuffix::FromScriptSrc => {
+            writedoc!(
+                code,
+                r#"
+                    const CHUNK_SUFFIX = (self.TURBOPACK_CHUNK_SUFFIX ?? document?.currentScript?.getAttribute?.('src')?.replace(/^(.*(?=\?)|^.*$)/, "")) || "";
+                "#
+            )?;
+        }
+    }
+
     code.push_code(&*shared_runtime_utils_code.await?);
     for runtime_code in runtime_base_code {
         code.push_code(

turbopack/crates/turbopack-ecmascript-runtime/src/chunk_suffix.rs

@@ -0,0 +1,12 @@
+use turbo_rcstr::RcStr;
+
+#[turbo_tasks::value(shared)]
+pub enum ChunkSuffix {
+    /// No suffix.
+    None,
+    /// A constant suffix to append to chunk URLs.
+    Constant(RcStr),
+    /// Use the query string of the `src` attribute of the current script tag as a suffix for chunk
+    /// loading.
+    FromScriptSrc,
+}