Revert "[turbopack] Add bundling support for worker_threads" (vercel#88725)

Reverts vercel#87746

because of this build error:
```
> Build error occurred
Error: Turbopack build failed with 1 errors:
./node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/index.js
non-evaluatable module
Worker thread module must be evaluatable
```

Author: sokra

.rustfmt.toml

@@ -1,4 +1,3 @@
-edition = "2024"
 max_width = 100
 
 comment_width = 100

crates/next-api/src/middleware.rs

@@ -14,7 +14,10 @@ use turbo_tasks::{Completion, ResolvedVc, Vc};
 use turbo_tasks_fs::{self, File, FileContent, FileSystemPath};
 use turbopack_core::{
     asset::AssetContent,
-    chunk::{ChunkingContextExt, EntryChunkGroupResult, availability_info::AvailabilityInfo},
+    chunk::{
+        ChunkingContext, ChunkingContextExt, EntryChunkGroupResult,
+        availability_info::AvailabilityInfo,
+    },
     context::AssetContext,
     module::Module,
     module_graph::{
@@ -135,7 +138,7 @@ impl MiddlewareEndpoint {
         };
 
         let EntryChunkGroupResult { asset: chunk, .. } = *chunking_context
-            .root_entry_chunk_group(
+            .entry_chunk_group(
                 this.project
                     .node_root()
                     .await?
@@ -144,6 +147,7 @@ impl MiddlewareEndpoint {
                 module_graph,
                 OutputAssets::empty(),
                 OutputAssets::empty(),
+                AvailabilityInfo::root(),
             )
             .await?;
         Ok(*chunk)

crates/next-api/src/nft_json.rs

@@ -76,27 +76,30 @@ impl OutputAsset for NftJsonAsset {
     }
 }
 
+#[turbo_tasks::value(transparent)]
+pub struct OutputSpecifier(Option<RcStr>);
+
 fn get_output_specifier(
-    chunk_path: &FileSystemPath,
+    path_ref: &FileSystemPath,
     ident_folder: &FileSystemPath,
     ident_folder_in_project_fs: &FileSystemPath,
     output_root: &FileSystemPath,
     project_root: &FileSystemPath,
-) -> Option<RcStr> {
+) -> Result<RcStr> {
     // include assets in the outputs such as referenced chunks
-    if chunk_path.is_inside_ref(output_root) {
-        return Some(ident_folder.get_relative_path_to(chunk_path).unwrap());
+    if path_ref.is_inside_ref(output_root) {
+        return Ok(ident_folder.get_relative_path_to(path_ref).unwrap());
     }
 
     // include assets in the project root such as images and traced references (externals)
-    if chunk_path.is_inside_ref(project_root) {
-        return Some(
-            ident_folder_in_project_fs
-                .get_relative_path_to(chunk_path)
-                .unwrap(),
-        );
+    if path_ref.is_inside_ref(project_root) {
+        return Ok(ident_folder_in_project_fs
+            .get_relative_path_to(path_ref)
+            .unwrap());
     }
-    None
+
+    // This should effectively be unreachable
+    bail!("NftJsonAsset: cannot handle filepath {path_ref}");
 }
 
 /// Apply outputFileTracingIncludes patterns to find additional files
@@ -282,21 +285,13 @@ impl Asset for NftJsonAsset {
                     }
                 }
 
-                let Some(specifier) = get_output_specifier(
+                let specifier = get_output_specifier(
                     &referenced_chunk_path,
                     &ident_folder,
                     &ident_folder_in_project_fs,
                     &output_root_ref,
                     &project_root_ref,
-                ) else {
-                    // This should effectively be unreachable
-                    bail!(
-                        "NftJsonAsset: cannot handle filepath '{chunk_path}' for \
-                         {referenced_chunk:?} it is not under the output_root: \
-                         '{output_root_ref}' or the project_root: '{project_root_ref}'",
-                        chunk_path = referenced_chunk_path.value_to_string().await?
-                    );
-                };
+                )?;
 
                 result.insert(specifier);
             }

test/e2e/app-dir/node-worker-threads/app/api/simple-worker-test/route.ts

@@ -354,7 +354,10 @@ impl BrowserChunkingContext {
         }
     }
 }
+
+#[turbo_tasks::value_impl]
 impl BrowserChunkingContext {
+    #[turbo_tasks::function]
     fn generate_evaluate_chunk(
         self: Vc<Self>,
         ident: Vc<AssetIdent>,
@@ -371,6 +374,8 @@ impl BrowserChunkingContext {
             module_graph,
         ))
     }
+
+    #[turbo_tasks::function]
     fn generate_chunk_list_register_chunk(
         self: Vc<Self>,
         ident: Vc<AssetIdent>,
@@ -386,30 +391,26 @@ impl BrowserChunkingContext {
             source,
         ))
     }
+
+    #[turbo_tasks::function]
     async fn generate_chunk(
         self: Vc<Self>,
         chunk: ResolvedVc<Box<dyn Chunk>>,
-    ) -> Result<ResolvedVc<Box<dyn OutputAsset>>> {
+    ) -> Result<Vc<Box<dyn OutputAsset>>> {
         Ok(
             if let Some(ecmascript_chunk) = ResolvedVc::try_downcast_type::<EcmascriptChunk>(chunk)
             {
-                ResolvedVc::upcast(
-                    EcmascriptBrowserChunk::new(self, *ecmascript_chunk)
-                        .to_resolved()
-                        .await?,
-                )
+                Vc::upcast(EcmascriptBrowserChunk::new(self, *ecmascript_chunk))
             } else if let Some(output_asset) =
                 ResolvedVc::try_sidecast::<Box<dyn OutputAsset>>(chunk)
             {
-                output_asset
+                *output_asset
             } else {
                 bail!("Unable to generate output asset for chunk");
             },
         )
     }
-}
-#[turbo_tasks::value_impl]
-impl BrowserChunkingContext {
+
     #[turbo_tasks::function]
     pub fn current_chunk_method(&self) -> Vc<CurrentChunkMethod> {
         self.current_chunk_method.cell()
@@ -698,7 +699,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk).to_resolved())
                 .try_join()
                 .await?;
 
@@ -766,7 +767,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets: Vec<ResolvedVc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk).to_resolved())
                 .try_join()
                 .await?;
 

test/e2e/app-dir/node-worker-threads/app/api/worker-test/route.ts

@@ -139,7 +139,7 @@ use crate::{
         exports_info::{ExportsInfoBinding, ExportsInfoRef},
         ident::IdentReplacement,
         member::MemberReplacement,
-        node::PackageJsonReference,
+        node::{FilePathModuleReference, PackageJsonReference},
         raw::{DirAssetReference, FileSourceReference},
         require_context::{RequireContextAssetReference, RequireContextMap},
         type_issue::SpecifiedModuleTypeIssue,
@@ -1935,7 +1935,7 @@ where
 
                     if *compile_time_info.environment().rendering().await? == Rendering::Client {
                         analysis.add_reference_code_gen(
-                            WorkerAssetReference::new_web_worker(
+                            WorkerAssetReference::new(
                                 origin,
                                 Request::parse(pat).to_resolved().await?,
                                 issue_source(source, span),
@@ -1950,7 +1950,8 @@ where
                 // Ignore (e.g. dynamic parameter or string literal), just as Webpack does
                 return Ok(());
             }
-            WellKnownFunctionKind::NodeWorkerConstructor => {
+            WellKnownFunctionKind::NodeWorkerConstructor if analysis.analyze_mode.is_tracing() => {
+                // Only for tracing, not for bundling (yet?)
                 let args = linked_args().await?;
                 if !args.is_empty() {
                     let pat = js_value_to_pattern(&args[0]);
@@ -1967,20 +1968,17 @@ where
                             return Ok(());
                         }
                     }
-
-                    analysis.add_reference_code_gen(
-                        WorkerAssetReference::new_node_worker_thread(
-                            origin,
-                            // WorkerThreads resolve filepaths relative to the process root
+                    analysis.add_reference(
+                        FilePathModuleReference::new(
+                            origin.asset_context(),
                             get_traced_project_dir().await?,
-                            Pattern::new(pat).to_resolved().await?,
+                            Pattern::new(pat),
                             collect_affecting_sources,
                             get_issue_source(),
-                            in_try,
-                        ),
-                        ast_path.to_vec().into(),
+                        )
+                        .to_resolved()
+                        .await?,
                     );
-
                     return Ok(());
                 }
                 let (args, hints) = explain_args(args);