Merge branch 'vercel:canary' into canary

Author: akabarki76

crates/next-api/benches/hmr.rs

@@ -1,5 +1,3 @@
-extern crate turbo_tasks_malloc;
-
 use std::{
     env,
     fs::{create_dir_all, write},

crates/next-api/src/app.rs

@@ -1670,9 +1670,11 @@ impl AppEndpoint {
                     .await?
                     .is_production()
                 {
+                    let page_name = app_entry.pathname.clone();
                     server_assets.insert(ResolvedVc::upcast(
                         NftJsonAsset::new(
                             project,
+                            Some(page_name),
                             *rsc_chunk,
                             client_reference_manifest
                                 .iter()

crates/next-api/src/instrumentation.rs

@@ -216,7 +216,7 @@ impl InstrumentationEndpoint {
             let mut output_assets = vec![chunk];
             if this.project.next_mode().await?.is_production() {
                 output_assets.push(ResolvedVc::upcast(
-                    NftJsonAsset::new(*this.project, *chunk, vec![])
+                    NftJsonAsset::new(*this.project, None, *chunk, vec![])
                         .to_resolved()
                         .await?,
                 ));

crates/next-api/src/middleware.rs

@@ -248,7 +248,7 @@ impl MiddlewareEndpoint {
             let mut output_assets = vec![chunk];
             if this.project.next_mode().await?.is_production() {
                 output_assets.push(ResolvedVc::upcast(
-                    NftJsonAsset::new(*this.project, *chunk, vec![])
+                    NftJsonAsset::new(*this.project, None, *chunk, vec![])
                         .to_resolved()
                         .await?,
                 ));

crates/next-api/src/nft_json.rs

@@ -1,10 +1,10 @@
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, VecDeque};
 
 use anyhow::{Result, bail};
 use serde_json::json;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{ResolvedVc, Vc};
-use turbo_tasks_fs::{File, FileSystem, FileSystemPath};
+use turbo_tasks_fs::{DirectoryEntry, File, FileSystem, FileSystemPath, glob::Glob};
 use turbopack_core::{
     asset::{Asset, AssetContent},
     output::OutputAsset,
@@ -30,20 +30,23 @@ pub struct NftJsonAsset {
     /// An example of this is the two-phase approach used by the `ClientReferenceManifest` in
     /// next.js.
     additional_assets: Vec<ResolvedVc<Box<dyn OutputAsset>>>,
+    page_name: Option<RcStr>,
 }
 
 #[turbo_tasks::value_impl]
 impl NftJsonAsset {
     #[turbo_tasks::function]
     pub fn new(
         project: ResolvedVc<Project>,
+        page_name: Option<RcStr>,
         chunk: ResolvedVc<Box<dyn OutputAsset>>,
         additional_assets: Vec<ResolvedVc<Box<dyn OutputAsset>>>,
     ) -> Vc<Self> {
         NftJsonAsset {
             chunk,
             project,
             additional_assets,
+            page_name,
         }
         .cell()
     }
@@ -95,6 +98,41 @@ fn get_output_specifier(
     bail!("NftJsonAsset: cannot handle filepath {}", path_ref);
 }
 
+/// Apply outputFileTracingIncludes patterns to find additional files
+async fn apply_includes(
+    project_root_path: Vc<FileSystemPath>,
+    glob: Vc<Glob>,
+    ident_folder: &FileSystemPath,
+) -> Result<BTreeSet<RcStr>> {
+    // Read files matching the glob pattern from the project root
+    let glob_result = project_root_path.read_glob(glob).await?;
+
+    // Walk the full glob_result using an explicit stack to avoid async recursion overheads.
+    let mut result = BTreeSet::new();
+    let mut stack = VecDeque::new();
+    stack.push_back(glob_result);
+    while let Some(glob_result) = stack.pop_back() {
+        // Process direct results (files and directories at this level)
+        for entry in glob_result.results.values() {
+            let DirectoryEntry::File(file_path) = entry else {
+                continue;
+            };
+
+            let file_path_ref = file_path.await?;
+            // Convert to relative path from ident_folder to the file
+            if let Some(relative_path) = ident_folder.get_relative_path_to(&file_path_ref) {
+                result.insert(relative_path);
+            }
+        }
+
+        for nested_result in glob_result.inner.values() {
+            let nested_result_ref = nested_result.await?;
+            stack.push_back(nested_result_ref);
+        }
+    }
+    Ok(result)
+}
+
 #[turbo_tasks::value_impl]
 impl Asset for NftJsonAsset {
     #[turbo_tasks::function]
@@ -104,15 +142,20 @@ impl Asset for NftJsonAsset {
 
         let output_root_ref = this.project.output_fs().root().await?;
         let project_root_ref = this.project.project_fs().root().await?;
+        let next_config = this.project.next_config();
+
+        // Parse outputFileTracingIncludes and outputFileTracingExcludes from config
+        let output_file_tracing_includes = &*next_config.output_file_tracing_includes().await?;
+        let output_file_tracing_excludes = &*next_config.output_file_tracing_excludes().await?;
+
         let client_root = this.project.client_fs().root();
         let client_root_ref = client_root.await?;
+        let project_root_path = this.project.project_root_path(); // Example: [project]
 
         // Example: [output]/apps/my-website/.next/server/app -- without the `.nft.json`
         let ident_folder = self.path().parent().await?;
         // Example: [project]/apps/my-website/.next/server/app -- without the `.nft.json`
-        let ident_folder_in_project_fs = this
-            .project
-            .project_root_path() // Example: [project]
+        let ident_folder_in_project_fs = project_root_path
             .join(ident_folder.path.clone()) // apps/my-website/.next/server/app
             .await?;
 
@@ -123,6 +166,51 @@ impl Asset for NftJsonAsset {
             .copied()
             .chain(std::iter::once(chunk))
             .collect();
+
+        let exclude_glob = if let Some(route) = &this.page_name {
+            let project_path = this.project.project_path().await?;
+
+            if let Some(excludes_config) = output_file_tracing_excludes {
+                let mut combined_excludes = BTreeSet::new();
+
+                if let Some(excludes_obj) = excludes_config.as_object() {
+                    for (glob_pattern, exclude_patterns) in excludes_obj {
+                        // Check if the route matches the glob pattern
+                        let glob = Glob::new(RcStr::from(glob_pattern.clone())).await?;
+                        if glob.matches(route)
+                            && let Some(patterns) = exclude_patterns.as_array()
+                        {
+                            for pattern in patterns {
+                                if let Some(pattern_str) = pattern.as_str() {
+                                    combined_excludes.insert(pattern_str);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                let glob = Glob::new(
+                    format!(
+                        "{project_path}/{{{}}}",
+                        combined_excludes
+                            .iter()
+                            .copied()
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                    .into(),
+                )
+                .await?;
+
+                Some(glob)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        // Collect base assets first
         for referenced_chunk in all_assets_from_entries(Vc::cell(entries)).await? {
             if chunk.eq(referenced_chunk) {
                 continue;
@@ -133,6 +221,12 @@ impl Asset for NftJsonAsset {
                 continue;
             }
 
+            if let Some(ref exclude_glob) = exclude_glob
+                && exclude_glob.matches(referenced_chunk_path.path.as_str())
+            {
+                continue;
+            }
+
             let Some(specifier) = get_output_specifier(
                 &referenced_chunk_path,
                 &ident_folder,
@@ -147,6 +241,50 @@ impl Asset for NftJsonAsset {
             result.insert(specifier);
         }
 
+        // Apply outputFileTracingIncludes and outputFileTracingExcludes
+        // Extract route from chunk path for pattern matching
+        if let Some(route) = &this.page_name {
+            let project_path = this.project.project_path();
+            let mut combined_includes = BTreeSet::new();
+
+            // Process includes
+            if let Some(includes_config) = output_file_tracing_includes
+                && let Some(includes_obj) = includes_config.as_object()
+            {
+                for (glob_pattern, include_patterns) in includes_obj {
+                    // Check if the route matches the glob pattern
+                    let glob = Glob::new(glob_pattern.as_str().into()).await?;
+                    if glob.matches(route)
+                        && let Some(patterns) = include_patterns.as_array()
+                    {
+                        for pattern in patterns {
+                            if let Some(pattern_str) = pattern.as_str() {
+                                combined_includes.insert(pattern_str);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Apply includes - find additional files that match the include patterns
+            if !combined_includes.is_empty() {
+                let glob = Glob::new(
+                    format!(
+                        "{{{}}}",
+                        combined_includes
+                            .iter()
+                            .copied()
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                    .into(),
+                );
+                let additional_files =
+                    apply_includes(project_path, glob, &ident_folder_in_project_fs).await?;
+                result.extend(additional_files);
+            }
+        }
+
         let json = json!({
           "version": 1,
           "files": result

crates/next-api/src/pages.rs

@@ -1135,6 +1135,7 @@ impl PageEndpoint {
                     ResolvedVc::cell(Some(ResolvedVc::upcast(
                         NftJsonAsset::new(
                             project,
+                            Some(this.original_name.clone()),
                             *ssr_entry_chunk,
                             loadable_manifest_output
                                 .await?

crates/next-core/src/next_config.rs

@@ -98,6 +98,10 @@ pub struct NextConfig {
     pub output: Option<OutputType>,
     pub turbopack: Option<TurbopackConfig>,
     production_browser_source_maps: bool,
+    output_file_tracing_includes: Option<serde_json::Value>,
+    output_file_tracing_excludes: Option<serde_json::Value>,
+    // TODO: This option is not respected, it uses Turbopack's root instead.
+    output_file_tracing_root: Option<RcStr>,
 
     /// Enables the bundling of node_modules packages (externals) for pages
     /// server-side bundles.
@@ -763,9 +767,6 @@ pub struct ExperimentalConfig {
     /// Automatically apply the "modularize_imports" optimization to imports of
     /// the specified packages.
     optimize_package_imports: Option<Vec<RcStr>>,
-    output_file_tracing_ignores: Option<Vec<RcStr>>,
-    output_file_tracing_includes: Option<serde_json::Value>,
-    output_file_tracing_root: Option<RcStr>,
     /// Using this feature will enable the `react@experimental` for the `app`
     /// directory.
     ppr: Option<ExperimentalPartialPrerendering>,
@@ -1112,6 +1113,9 @@ pub struct OptionSubResourceIntegrity(Option<SubResourceIntegrity>);
 #[turbo_tasks::value(transparent)]
 pub struct OptionServerActions(Option<ServerActions>);
 
+#[turbo_tasks::value(transparent)]
+pub struct OptionJsonValue(pub Option<serde_json::Value>);
+
 #[turbo_tasks::value_impl]
 impl NextConfig {
     #[turbo_tasks::function]
@@ -1627,6 +1631,16 @@ impl NextConfig {
                 .map(|path| path.to_owned().into()),
         ))
     }
+
+    #[turbo_tasks::function]
+    pub fn output_file_tracing_includes(&self) -> Vc<OptionJsonValue> {
+        Vc::cell(self.output_file_tracing_includes.clone())
+    }
+
+    #[turbo_tasks::function]
+    pub fn output_file_tracing_excludes(&self) -> Vc<OptionJsonValue> {
+        Vc::cell(self.output_file_tracing_excludes.clone())
+    }
 }
 
 /// A subset of ts/jsconfig that next.js implicitly

test/integration/build-trace-extra-entries-turbo/test/index.test.js

@@ -56,9 +56,13 @@ describe('build trace with extra entries', () => {
           ...imageTrace.files,
         ]
 
-        expect(tracedFiles.some((file) => file.endsWith('hello.json'))).toBe(
-          true
-        )
+        // Skip hello.json check for Turbopack as it doesn't support webpack entry modifications
+        if (!process.env.TURBOPACK_BUILD) {
+          expect(tracedFiles.some((file) => file.endsWith('hello.json'))).toBe(
+            true
+          )
+        }
+
         expect(
           tracedFiles.some((file) => file.includes('some-cms/index.js'))
         ).toBe(true)

test/integration/build-trace-extra-entries/test/index.test.js

@@ -49,9 +49,12 @@ describe('build trace with extra entries', () => {
           appDirRoute1Trace.files.some((file) => file.includes('exclude-me'))
         ).toBe(false)
 
-        expect(appTrace.files.some((file) => file.endsWith('hello.json'))).toBe(
-          true
-        )
+        // Skip hello.json check for Turbopack as it doesn't support webpack entry modifications
+        if (!process.env.TURBOPACK_BUILD) {
+          expect(
+            appTrace.files.some((file) => file.endsWith('hello.json'))
+          ).toBe(true)
+        }
 
         expect(
           indexTrace.files.filter(
@@ -63,9 +66,12 @@ describe('build trace with extra entries', () => {
           ).length
         )
 
-        expect(
-          appTrace.files.some((file) => file.endsWith('lib/get-data.js'))
-        ).toBe(true)
+        // Skip lib/get-data.js check for Turbopack as it doesn't support webpack entry modifications
+        if (!process.env.TURBOPACK_BUILD) {
+          expect(
+            appTrace.files.some((file) => file.endsWith('lib/get-data.js'))
+          ).toBe(true)
+        }
         expect(
           indexTrace.files.some((file) => file.endsWith('hello.json'))
         ).toBeFalsy()

test/turbopack-build-tests-manifest.json

@@ -9756,19 +9756,19 @@
     "runtimeError": false
   },
   "test/integration/build-trace-extra-entries-turbo/test/index.test.js": {
-    "passed": [],
-    "failed": [
+    "passed": [
       "build trace with extra entries production mode should build and trace correctly"
     ],
+    "failed": [],
     "pending": [],
     "flakey": [],
     "runtimeError": false
   },
   "test/integration/build-trace-extra-entries/test/index.test.js": {
-    "passed": [],
-    "failed": [
+    "passed": [
       "build trace with extra entries production mode should build and trace correctly"
     ],
+    "failed": [],
     "pending": [],
     "flakey": [],
     "runtimeError": false