Merge 4d04499 into 6939aef

crates/next-core/js/src/entry/app-renderer.tsx

@@ -37,7 +37,7 @@ import { headersFromEntries } from "@vercel/turbopack-next/internal/headers";
 import { parse, ParsedUrlQuery } from "node:querystring";
 
 globalThis.__next_require__ = (data) => {
-  const [, , ssr_id] = JSON.parse(data);
+  const [, , , ssr_id] = JSON.parse(data);
   return __turbopack_require__(ssr_id);
 };
 globalThis.__next_chunk_load__ = () => Promise.resolve();

crates/next-core/js/src/entry/app/hydrate.tsx

@@ -19,7 +19,8 @@ window.next = {
 };
 
 globalThis.__next_require__ = (data) => {
-  const [client_id] = JSON.parse(data);
+  const [client_id, chunks, chunkListPath] = JSON.parse(data);
+  __turbopack_register_chunk_list__(chunkListPath, chunks);
   return __turbopack_require__(client_id);
 };
 globalThis.__next_chunk_load__ = __turbopack_load__;

crates/next-core/js/src/entry/app/index.d.ts

@@ -5,3 +5,4 @@ export = Anything;
 
 export const __turbopack_module_id__: string | number;
 export const chunks: string[];
+export const chunkListPath: string;

crates/next-core/js/src/entry/app/server-to-client-ssr.tsx

@@ -5,6 +5,8 @@ import { createProxy } from "next/dist/build/webpack/loaders/next-flight-loader/
 import { __turbopack_module_id__ as id } from "CLIENT_MODULE";
 
 // @ts-expect-error CLIENT_CHUNKS is provided by rust
-import client_id, { chunks } from "CLIENT_CHUNKS";
+import client_id, { chunks, chunkListPath } from "CLIENT_CHUNKS";
 
-export default createProxy(JSON.stringify([client_id, chunks, id]));
+export default createProxy(
+  JSON.stringify([client_id, chunks, chunkListPath, id])
+);

crates/next-core/js/src/entry/app/server-to-client.tsx

@@ -1,6 +1,6 @@
 import { createProxy } from "next/dist/build/webpack/loaders/next-flight-loader/module-proxy";
 
 // @ts-expect-error CLIENT_CHUNKS is provided by rust
-import client_id, { chunks } from "CLIENT_CHUNKS";
+import client_id, { chunks, chunkListPath } from "CLIENT_CHUNKS";
 
-export default createProxy(JSON.stringify([client_id, chunks]));
+export default createProxy(JSON.stringify([client_id, chunks, chunkListPath]));

crates/next-core/js/src/entry/fallback.tsx

@@ -18,7 +18,7 @@ subscribeToUpdate(
     },
   },
   (update) => {
-    if (update.type === "restart") {
+    if (update.type === "restart" || update.type === "notFound") {
       location.reload();
     }
   }

crates/next-core/js/src/entry/next-hydrate.tsx

@@ -97,7 +97,7 @@ function subscribeToPageManifest({ assetPrefix }: { assetPrefix: string }) {
       path: "_next/static/development/_devPagesManifest.json",
     },
     (update) => {
-      if (["restart", "partial"].includes(update.type)) {
+      if (["restart", "notFound", "partial"].includes(update.type)) {
         return;
       }
 

crates/next-core/js/types/globals.d.ts

@@ -1,6 +1,10 @@
 declare global {
   function __turbopack_require__(name: any): any;
   function __turbopack_load__(path: string): any;
+  function __turbopack_register_chunk_list__(
+    chunkListPath: string,
+    chunksPaths: string[]
+  ): any;
   function __webpack_require__(name: any): any;
   var __webpack_public_path__: string | undefined;
   var __DEV_MIDDLEWARE_MATCHERS: any[];

crates/next-core/src/fallback.rs

@@ -90,5 +90,6 @@ pub async fn get_fallback_page(
     Ok(DevHtmlAssetVc::new(
         dev_server_root.join("fallback.html"),
         vec![ChunkGroupVc::from_chunk(chunk)],
+        vec![],
     ))
 }

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

@@ -95,6 +95,7 @@ impl Transition for NextClientTransition {
             asset: asset.into(),
             chunking_context: self.client_chunking_context,
             base_path: self.server_root.join("_next"),
+            server_root: self.server_root,
             runtime_entries: Some(runtime_entries),
         };
 

crates/next-core/src/next_client_chunks/with_chunks.rs

@@ -1,4 +1,5 @@
-use anyhow::Result;
+use anyhow::{bail, Result};
+use indoc::formatdoc;
 use serde_json::Value;
 use turbo_tasks::{primitives::StringVc, TryJoinIterExt, ValueToString, ValueToStringVc};
 use turbo_tasks_fs::FileSystemPathVc;
@@ -13,14 +14,15 @@ use turbopack::ecmascript::{
 use turbopack_core::{
     asset::{Asset, AssetContentVc, AssetVc},
     chunk::{
-        Chunk, ChunkGroupVc, ChunkItem, ChunkItemVc, ChunkVc, ChunkableAsset,
-        ChunkableAssetReference, ChunkableAssetReferenceVc, ChunkableAssetVc, ChunkingContextVc,
-        ChunkingType, ChunkingTypeOptionVc,
+        Chunk, ChunkGroupVc, ChunkItem, ChunkItemVc, ChunkListReferenceVc, ChunkVc, ChunkableAsset,
+        ChunkableAssetReference, ChunkableAssetReferenceVc, ChunkableAssetVc, ChunkingContext,
+        ChunkingContextVc, ChunkingType, ChunkingTypeOptionVc,
     },
     ident::AssetIdentVc,
     reference::{AssetReference, AssetReferenceVc, AssetReferencesVc},
     resolve::{ResolveResult, ResolveResultVc},
 };
+use turbopack_ecmascript::utils::stringify_js_pretty;
 
 use super::in_chunking_context_asset::InChunkingContextAsset;
 
@@ -95,6 +97,25 @@ struct WithChunksChunkItem {
     chunk_item: EcmascriptChunkItemVc,
 }
 
+#[turbo_tasks::value_impl]
+impl WithChunksChunkItemVc {
+    #[turbo_tasks::function]
+    async fn chunk_list_path(self) -> Result<FileSystemPathVc> {
+        let this = self.await?;
+        Ok(this.inner_context.chunk_list_path(this.inner.ident()))
+    }
+
+    #[turbo_tasks::function]
+    async fn chunk_group(self) -> Result<ChunkGroupVc> {
+        let this = self.await?;
+        let inner = this.inner.await?;
+        Ok(ChunkGroupVc::from_asset(
+            inner.asset.into(),
+            this.inner_context,
+        ))
+    }
+}
+
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkItem for WithChunksChunkItem {
     #[turbo_tasks::function]
@@ -103,29 +124,40 @@ impl EcmascriptChunkItem for WithChunksChunkItem {
     }
 
     #[turbo_tasks::function]
-    async fn content(&self) -> Result<EcmascriptChunkItemContentVc> {
-        let inner = self.inner.await?;
-        let group = ChunkGroupVc::from_asset(inner.asset.into(), self.inner_context);
+    async fn content(self_vc: WithChunksChunkItemVc) -> Result<EcmascriptChunkItemContentVc> {
+        let this = self_vc.await?;
+        let inner = this.inner.await?;
+        let group = self_vc.chunk_group();
         let chunks = group.chunks().await?;
         let server_root = inner.server_root.await?;
         let mut client_chunks = Vec::new();
+
+        let chunk_list_path = self_vc.chunk_list_path().await?;
+        let chunk_list_path = if let Some(path) = server_root.get_path_to(&chunk_list_path) {
+            path
+        } else {
+            bail!("could not get path to chunk list");
+        };
+
         for chunk_path in chunks.iter().map(|c| c.path()).try_join().await? {
             if let Some(path) = server_root.get_path_to(&chunk_path) {
                 client_chunks.push(Value::String(path.to_string()));
             }
         }
-        let module_id = stringify_js(&*inner.asset.as_chunk_item(self.inner_context).id().await?);
+        let module_id = stringify_js(&*inner.asset.as_chunk_item(this.inner_context).id().await?);
         Ok(EcmascriptChunkItemContent {
-            inner_code: format!(
-                "__turbopack_esm__({{
-  default: () => {},
-  chunks: () => chunks
-}});
-const chunks = {};
-",
+            inner_code: formatdoc! {
+                r#"
+                __turbopack_esm__({{
+                    default: () => {},
+                    chunks: () => {},
+                    chunkListPath: () => {},
+                }});
+                "#,
                 module_id,
-                Value::Array(client_chunks)
-            )
+                stringify_js_pretty(&client_chunks),
+                stringify_js(&chunk_list_path),
+            }
             .into(),
             ..Default::default()
         }
@@ -141,18 +173,27 @@ impl ChunkItem for WithChunksChunkItem {
     }
 
     #[turbo_tasks::function]
-    async fn references(&self) -> Result<AssetReferencesVc> {
-        let inner = self.inner.await?;
-        Ok(AssetReferencesVc::cell(vec![WithChunksAssetReference {
-            asset: InChunkingContextAsset {
-                asset: inner.asset,
-                chunking_context: self.inner_context,
+    async fn references(self_vc: WithChunksChunkItemVc) -> Result<AssetReferencesVc> {
+        let this = self_vc.await?;
+        let inner = this.inner.await?;
+        Ok(AssetReferencesVc::cell(vec![
+            WithChunksAssetReference {
+                asset: InChunkingContextAsset {
+                    asset: inner.asset,
+                    chunking_context: this.inner_context,
+                }
+                .cell()
+                .into(),
             }
             .cell()
             .into(),
-        }
-        .cell()
-        .into()]))
+            ChunkListReferenceVc::new(
+                inner.server_root,
+                self_vc.chunk_group(),
+                self_vc.chunk_list_path(),
+            )
+            .into(),
+        ]))
     }
 }
 

crates/next-core/src/next_client_component/with_client_chunks.rs

@@ -21,6 +21,7 @@ use turbopack_core::{
     reference::{AssetReference, AssetReferenceVc, AssetReferencesVc},
     resolve::{ResolveResult, ResolveResultVc},
 };
+use turbopack_ecmascript::utils::stringify_js_pretty;
 
 use crate::next_client_chunks::in_chunking_context_asset::InChunkingContextAsset;
 
@@ -132,15 +133,17 @@ impl EcmascriptChunkItem for WithClientChunksChunkItem {
         let module_id = stringify_js(&*inner.asset.as_chunk_item(self.context).id().await?);
         Ok(EcmascriptChunkItemContent {
             inner_code: formatdoc!(
+                // We store the chunks in a binding, otherwise a new array would be created every
+                // time the export binding is read.
                 r#"
                     __turbopack_esm__({{
                         default: () => __turbopack_import__({}),
-                        chunks: () => chunks
+                        chunks: () => chunks,
                     }});
                     const chunks = {};
                 "#,
                 module_id,
-                stringify_js(&client_chunks)
+                stringify_js_pretty(&client_chunks),
             )
             .into(),
             ..Default::default()
@@ -157,13 +160,14 @@ impl ChunkItem for WithClientChunksChunkItem {
     }
 
     #[turbo_tasks::function]
-    async fn references(&self) -> Result<AssetReferencesVc> {
-        let inner = self.inner.await?;
+    async fn references(self_vc: WithClientChunksChunkItemVc) -> Result<AssetReferencesVc> {
+        let this = self_vc.await?;
+        let inner = this.inner.await?;
         Ok(AssetReferencesVc::cell(vec![
             WithClientChunksAssetReference {
                 asset: InChunkingContextAsset {
                     asset: inner.asset,
-                    chunking_context: self.context,
+                    chunking_context: this.context,
                 }
                 .cell()
                 .into(),

crates/next-core/src/next_edge/transition.rs

@@ -111,6 +111,7 @@ impl Transition for NextEdgeTransition {
             asset: new_asset.into(),
             chunking_context: self.edge_chunking_context,
             base_path: self.output_path,
+            server_root: self.output_path,
             runtime_entries: None,
         };
 

crates/next-core/src/page_loader.rs

@@ -2,7 +2,7 @@ use std::io::Write;
 
 use anyhow::{bail, Result};
 use indexmap::indexmap;
-use turbo_tasks::{primitives::StringVc, Value};
+use turbo_tasks::{primitives::StringVc, TryJoinIterExt, Value};
 use turbo_tasks_fs::{rope::RopeBuilder, File, FileContent, FileSystemPathVc};
 use turbopack_core::{
     asset::{Asset, AssetContentVc, AssetVc},
@@ -116,17 +116,28 @@ impl Asset for PageLoaderAsset {
         let this = &*self_vc.await?;
 
         let chunks = self_vc.get_page_chunks().await?;
-
-        let mut data = Vec::with_capacity(chunks.len());
-        for chunk in chunks.iter() {
-            let path = chunk.path().await?;
-            data.push(serde_json::Value::String(path.path.clone()));
-        }
+        let server_root = this.server_root.await?;
+
+        let chunk_paths: Vec<_> = chunks
+            .iter()
+            .map(|chunk| {
+                let server_root = server_root.clone();
+                async move {
+                    Ok(server_root
+                        .get_path_to(&*chunk.path().await?)
+                        .map(|path| path.to_string()))
+                }
+            })
+            .try_join()
+            .await?
+            .into_iter()
+            .flatten()
+            .collect();
 
         let content = format!(
             "__turbopack_load_page_chunks__({}, {})\n",
             stringify_js(&this.pathname.await?),
-            serde_json::Value::Array(data)
+            stringify_js(&chunk_paths)
         );
 
         Ok(AssetContentVc::from(File::from(content)))

crates/next-core/src/web_entry_source.rs

@@ -1,10 +1,13 @@
 use anyhow::{anyhow, Result};
-use turbo_tasks::{TryJoinIterExt, Value};
+use turbo_tasks::{primitives::StringVc, TryJoinIterExt, Value};
 use turbo_tasks_env::ProcessEnvVc;
 use turbo_tasks_fs::FileSystemPathVc;
 use turbopack::ecmascript::EcmascriptModuleAssetVc;
 use turbopack_core::{
-    chunk::{ChunkGroupVc, ChunkableAsset, ChunkableAssetVc},
+    asset::Asset,
+    chunk::{
+        ChunkGroupVc, ChunkListReferenceVc, ChunkableAsset, ChunkableAssetVc, ChunkingContext,
+    },
     reference_type::{EntryReferenceSubType, ReferenceType},
     resolve::{origin::PlainResolveOriginVc, parse::RequestVc},
 };
@@ -66,18 +69,30 @@ pub async fn create_web_entry_source(
         })
         .try_join()
         .await?;
-    let chunks: Vec<_> = entries
+
+    let chunk_groups_with_references: Vec<_> = entries
         .into_iter()
         .flatten()
         .enumerate()
         .map(|(i, module)| async move {
             if let Some(ecmascript) = EcmascriptModuleAssetVc::resolve_from(module).await? {
-                Ok(ecmascript
-                    .as_evaluated_chunk(chunking_context, (i == 0).then_some(runtime_entries)))
+                let chunk = ecmascript
+                    .as_evaluated_chunk(chunking_context, (i == 0).then_some(runtime_entries));
+                let chunk_group = ChunkGroupVc::from_chunk(chunk);
+                let additional_references = vec![ChunkListReferenceVc::new(
+                    server_root,
+                    chunk_group,
+                    chunking_context.chunk_list_path(ecmascript.ident()),
+                )
+                .into()];
+                Ok((chunk_group, additional_references))
             } else if let Some(chunkable) = ChunkableAssetVc::resolve_from(module).await? {
                 // TODO this is missing runtime code, so it's probably broken and we should also
                 // add an ecmascript chunk with the runtime code
-                Ok(chunkable.as_chunk(chunking_context))
+                Ok((
+                    ChunkGroupVc::from_chunk(chunkable.as_chunk(chunking_context)),
+                    vec![],
+                ))
             } else {
                 // TODO convert into a serve-able asset
                 Err(anyhow!(
@@ -89,9 +104,14 @@ pub async fn create_web_entry_source(
         .try_join()
         .await?;
 
+    let (chunk_groups, additional_references): (Vec<_>, Vec<_>) =
+        chunk_groups_with_references.into_iter().unzip();
+    let additional_references = additional_references.into_iter().flatten().collect();
+
     let entry_asset = DevHtmlAssetVc::new(
         server_root.join("index.html"),
-        chunks.into_iter().map(ChunkGroupVc::from_chunk).collect(),
+        chunk_groups,
+        additional_references,
     )
     .into();