fix(turbopack): don't emit issues for deleted pages (#62012)

### What?

We now keep track of all client assets emitted for each route in
`ClientAssetMapper` and remove all issues associated with them when a
route get deleted.

Fixes #61384  
Closes PACK-2487

Author: ForsakenHarmony

packages/next-swc/crates/napi/src/next_api/endpoint.rs

@@ -3,8 +3,8 @@ use std::{ops::Deref, sync::Arc};
 use anyhow::Result;
 use napi::{bindgen_prelude::External, JsFunction};
 use next_api::{
+    paths::ServerPath,
     route::{Endpoint, WrittenEndpoint},
-    server_paths::ServerPath,
 };
 use tracing::Instrument;
 use turbo_tasks::{ReadRef, Vc};
@@ -28,10 +28,10 @@ pub struct NapiServerPath {
     pub content_hash: String,
 }
 
-impl From<&ServerPath> for NapiServerPath {
-    fn from(server_path: &ServerPath) -> Self {
+impl From<ServerPath> for NapiServerPath {
+    fn from(server_path: ServerPath) -> Self {
         Self {
-            path: server_path.path.clone(),
+            path: server_path.path,
             content_hash: format!("{:x}", server_path.content_hash),
         }
     }
@@ -42,25 +42,32 @@ impl From<&ServerPath> for NapiServerPath {
 pub struct NapiWrittenEndpoint {
     pub r#type: String,
     pub entry_path: Option<String>,
-    pub server_paths: Option<Vec<NapiServerPath>>,
+    pub client_paths: Vec<String>,
+    pub server_paths: Vec<NapiServerPath>,
     pub config: NapiEndpointConfig,
 }
 
-impl From<&WrittenEndpoint> for NapiWrittenEndpoint {
-    fn from(written_endpoint: &WrittenEndpoint) -> Self {
+impl From<WrittenEndpoint> for NapiWrittenEndpoint {
+    fn from(written_endpoint: WrittenEndpoint) -> Self {
         match written_endpoint {
             WrittenEndpoint::NodeJs {
                 server_entry_path,
                 server_paths,
+                client_paths,
             } => Self {
                 r#type: "nodejs".to_string(),
-                entry_path: Some(server_entry_path.clone()),
-                server_paths: Some(server_paths.iter().map(From::from).collect()),
+                entry_path: Some(server_entry_path),
+                client_paths,
+                server_paths: server_paths.into_iter().map(From::from).collect(),
                 ..Default::default()
             },
-            WrittenEndpoint::Edge { server_paths } => Self {
+            WrittenEndpoint::Edge {
+                server_paths,
+                client_paths,
+            } => Self {
                 r#type: "edge".to_string(),
-                server_paths: Some(server_paths.iter().map(From::from).collect()),
+                client_paths,
+                server_paths: server_paths.into_iter().map(From::from).collect(),
                 ..Default::default()
             },
         }
@@ -127,7 +134,7 @@ pub async fn endpoint_write_to_disk(
         .await
         .map_err(|e| napi::Error::from_reason(PrettyPrintError(&e).to_string()))?;
     Ok(TurbopackResult {
-        result: NapiWrittenEndpoint::from(&*written),
+        result: NapiWrittenEndpoint::from(written.clone_value()),
         issues: issues.iter().map(|i| NapiIssue::from(&**i)).collect(),
         diagnostics: diags.iter().map(|d| NapiDiagnostic::from(d)).collect(),
     })

packages/next-swc/crates/next-api/src/app.rs

@@ -63,11 +63,13 @@ use crate::{
         DynamicImportedChunks,
     },
     font::create_font_manifest,
-    middleware::{get_js_paths_from_root, get_wasm_paths_from_root, wasm_paths_to_bindings},
+    paths::{
+        all_paths_in_root, all_server_paths, get_js_paths_from_root, get_wasm_paths_from_root,
+        wasm_paths_to_bindings,
+    },
     project::Project,
     route::{AppPageRoute, Endpoint, Route, Routes, WrittenEndpoint},
     server_actions::create_server_actions_manifest,
-    server_paths::all_server_paths,
 };
 
 #[turbo_tasks::value]
@@ -1110,25 +1112,34 @@ impl Endpoint for AppEndpoint {
 
             let node_root_ref = &node_root.await?;
 
-            let node_root = this.app_project.project().node_root();
             this.app_project
                 .project()
                 .emit_all_output_assets(Vc::cell(output_assets))
                 .await?;
 
+            let node_root = this.app_project.project().node_root();
             let server_paths = all_server_paths(output_assets, node_root)
                 .await?
                 .clone_value();
 
+            let client_relative_root = this.app_project.project().client_relative_path();
+            let client_paths = all_paths_in_root(output_assets, client_relative_root)
+                .await?
+                .clone_value();
+
             let written_endpoint = match *output.await? {
                 AppEndpointOutput::NodeJs { rsc_chunk, .. } => WrittenEndpoint::NodeJs {
                     server_entry_path: node_root_ref
                         .get_path_to(&*rsc_chunk.ident().path().await?)
                         .context("Node.js chunk entry path must be inside the node root")?
                         .to_string(),
                     server_paths,
+                    client_paths,
+                },
+                AppEndpointOutput::Edge { .. } => WrittenEndpoint::Edge {
+                    server_paths,
+                    client_paths,
                 },
-                AppEndpointOutput::Edge { .. } => WrittenEndpoint::Edge { server_paths },
             };
             Ok(written_endpoint.cell())
         }

packages/next-swc/crates/next-api/src/font.rs

@@ -10,7 +10,7 @@ use turbopack_binding::{
     },
 };
 
-use crate::middleware::get_font_paths_from_root;
+use crate::paths::get_font_paths_from_root;
 
 pub(crate) async fn create_font_manifest(
     client_root: Vc<FileSystemPath>,

packages/next-swc/crates/next-api/src/instrumentation.rs

@@ -26,10 +26,11 @@ use turbopack_binding::{
 };
 
 use crate::{
-    middleware::{get_js_paths_from_root, get_wasm_paths_from_root, wasm_paths_to_bindings},
+    paths::{
+        all_server_paths, get_js_paths_from_root, get_wasm_paths_from_root, wasm_paths_to_bindings,
+    },
     project::Project,
     route::{Endpoint, WrittenEndpoint},
-    server_paths::all_server_paths,
 };
 
 #[turbo_tasks::value]
@@ -202,7 +203,11 @@ impl Endpoint for InstrumentationEndpoint {
                 .await?
                 .clone_value();
 
-            Ok(WrittenEndpoint::Edge { server_paths }.cell())
+            Ok(WrittenEndpoint::Edge {
+                server_paths,
+                client_paths: vec![],
+            }
+            .cell())
         }
         .instrument(span)
         .await

packages/next-swc/crates/next-api/src/lib.rs

@@ -8,10 +8,10 @@ mod font;
 mod instrumentation;
 mod middleware;
 mod pages;
+pub mod paths;
 pub mod project;
 pub mod route;
 mod server_actions;
-pub mod server_paths;
 mod versioned_content_map;
 
 // Declare build-time information variables generated in build.rs

packages/next-swc/crates/next-api/src/middleware.rs

@@ -3,23 +3,21 @@ use next_core::{
     all_assets_from_entries,
     middleware::get_middleware_module,
     next_edge::entry::wrap_edge_entry,
-    next_manifests::{
-        AssetBinding, EdgeFunctionDefinition, MiddlewareMatcher, MiddlewaresManifestV2,
-    },
+    next_manifests::{EdgeFunctionDefinition, MiddlewareMatcher, MiddlewaresManifestV2},
     next_server::{get_server_runtime_entries, ServerContextType},
     util::parse_config_from_source,
 };
 use tracing::Instrument;
-use turbo_tasks::{Completion, TryFlatJoinIterExt, Value, Vc};
+use turbo_tasks::{Completion, Value, Vc};
 use turbopack_binding::{
-    turbo::tasks_fs::{File, FileContent, FileSystemPath},
+    turbo::tasks_fs::{File, FileContent},
     turbopack::{
         core::{
             asset::AssetContent,
             chunk::{availability_info::AvailabilityInfo, ChunkingContextExt},
             context::AssetContext,
             module::Module,
-            output::{OutputAsset, OutputAssets},
+            output::OutputAssets,
             reference_type::{EntryReferenceSubType, ReferenceType},
             source::Source,
             virtual_output::VirtualOutputAsset,
@@ -29,9 +27,12 @@ use turbopack_binding::{
 };
 
 use crate::{
+    paths::{
+        all_paths_in_root, all_server_paths, get_js_paths_from_root, get_wasm_paths_from_root,
+        wasm_paths_to_bindings,
+    },
     project::Project,
     route::{Endpoint, WrittenEndpoint},
-    server_paths::all_server_paths,
 };
 
 #[turbo_tasks::value]
@@ -197,7 +198,17 @@ impl Endpoint for MiddlewareEndpoint {
                 .await?
                 .clone_value();
 
-            Ok(WrittenEndpoint::Edge { server_paths }.cell())
+            // Middleware could in theory have a client path (e.g. `new URL`).
+            let client_relative_root = this.project.client_relative_path();
+            let client_paths = all_paths_in_root(output_assets, client_relative_root)
+                .await?
+                .clone_value();
+
+            Ok(WrittenEndpoint::Edge {
+                server_paths,
+                client_paths,
+            }
+            .cell())
         }
         .instrument(span)
         .await
@@ -213,94 +224,3 @@ impl Endpoint for MiddlewareEndpoint {
         Completion::immutable()
     }
 }
-
-pub(crate) async fn get_paths_from_root(
-    root: &FileSystemPath,
-    output_assets: &[Vc<Box<dyn OutputAsset>>],
-    filter: impl FnOnce(&str) -> bool + Copy,
-) -> Result<Vec<String>> {
-    output_assets
-        .iter()
-        .map({
-            move |&file| async move {
-                let path = &*file.ident().path().await?;
-                let Some(relative) = root.get_path_to(path) else {
-                    return Ok(None);
-                };
-
-                Ok(if filter(relative) {
-                    Some(relative.to_string())
-                } else {
-                    None
-                })
-            }
-        })
-        .try_flat_join()
-        .await
-}
-
-pub(crate) async fn get_js_paths_from_root(
-    root: &FileSystemPath,
-    output_assets: &[Vc<Box<dyn OutputAsset>>],
-) -> Result<Vec<String>> {
-    get_paths_from_root(root, output_assets, |path| path.ends_with(".js")).await
-}
-
-pub(crate) async fn get_wasm_paths_from_root(
-    root: &FileSystemPath,
-    output_assets: &[Vc<Box<dyn OutputAsset>>],
-) -> Result<Vec<String>> {
-    get_paths_from_root(root, output_assets, |path| path.ends_with(".wasm")).await
-}
-
-pub(crate) async fn get_font_paths_from_root(
-    root: &FileSystemPath,
-    output_assets: &[Vc<Box<dyn OutputAsset>>],
-) -> Result<Vec<String>> {
-    get_paths_from_root(root, output_assets, |path| {
-        path.ends_with(".woff")
-            || path.ends_with(".woff2")
-            || path.ends_with(".eot")
-            || path.ends_with(".ttf")
-            || path.ends_with(".otf")
-    })
-    .await
-}
-
-fn get_file_stem(path: &str) -> &str {
-    let file_name = if let Some((_, file_name)) = path.rsplit_once('/') {
-        file_name
-    } else {
-        path
-    };
-
-    if let Some((stem, _)) = file_name.split_once('.') {
-        if stem.is_empty() {
-            file_name
-        } else {
-            stem
-        }
-    } else {
-        file_name
-    }
-}
-
-pub(crate) fn wasm_paths_to_bindings(paths: Vec<String>) -> Vec<AssetBinding> {
-    paths
-        .into_iter()
-        .map(|path| {
-            let stem = get_file_stem(&path);
-
-            // very simple escaping just replacing unsupported characters with `_`
-            let escaped = stem.replace(
-                |c: char| !c.is_ascii_alphanumeric() && c != '$' && c != '_',
-                "_",
-            );
-
-            AssetBinding {
-                name: format!("wasm_{}", escaped),
-                file_path: path,
-            }
-        })
-        .collect()
-}

packages/next-swc/crates/next-api/src/pages.rs

@@ -72,10 +72,12 @@ use crate::{
         DynamicImportedChunks,
     },
     font::create_font_manifest,
-    middleware::{get_js_paths_from_root, get_wasm_paths_from_root, wasm_paths_to_bindings},
+    paths::{
+        all_paths_in_root, all_server_paths, get_js_paths_from_root, get_wasm_paths_from_root,
+        wasm_paths_to_bindings,
+    },
     project::Project,
     route::{Endpoint, Route, Routes, WrittenEndpoint},
-    server_paths::all_server_paths,
 };
 
 #[turbo_tasks::value]
@@ -1171,6 +1173,11 @@ impl Endpoint for PageEndpoint {
                 .await?
                 .clone_value();
 
+            let client_relative_root = this.pages_project.project().client_relative_path();
+            let client_paths = all_paths_in_root(output_assets, client_relative_root)
+                .await?
+                .clone_value();
+
             let node_root = &node_root.await?;
             let written_endpoint = match *output.await? {
                 PageEndpointOutput::NodeJs { entry_chunk, .. } => WrittenEndpoint::NodeJs {
@@ -1179,8 +1186,12 @@ impl Endpoint for PageEndpoint {
                         .context("ssr chunk entry path must be inside the node root")?
                         .to_string(),
                     server_paths,
+                    client_paths,
+                },
+                PageEndpointOutput::Edge { .. } => WrittenEndpoint::Edge {
+                    server_paths,
+                    client_paths,
                 },
-                PageEndpointOutput::Edge { .. } => WrittenEndpoint::Edge { server_paths },
             };
 
             Ok(written_endpoint.cell())