Turbopack: remove referenced_assets field

crates/next-api/src/app.rs

@@ -1815,7 +1815,7 @@ impl AppEndpoint {
                             .await?;
                     }
 
-                    let current_referenced_assets = current_chunk_group.referenced_assets();
+                    let current_references = current_chunk_group.references();
                     let chunk_group = current_chunk_group.await?;
                     let current_availability_info = chunk_group.availability_info;
                     let current_chunks = chunk_group.assets;
@@ -1832,13 +1832,12 @@ impl AppEndpoint {
                                         evaluatable_assets,
                                         module_graph,
                                         *current_chunks,
-                                        current_referenced_assets,
+                                        current_references,
                                         current_availability_info,
                                     )
                                     .to_resolved()
                                     .await?,
                             ]),
-                            referenced_assets: ResolvedVc::cell(vec![]),
                             references: ResolvedVc::cell(vec![]),
                         }
                         .cell(),

crates/next-api/src/instrumentation.rs

@@ -19,7 +19,7 @@ use turbopack_core::{
         GraphEntries,
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
     },
-    output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
+    output::{OutputAsset, OutputAssets, OutputAssetsReferences, OutputAssetsWithReferenced},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
     virtual_output::VirtualOutputAsset,
@@ -133,7 +133,7 @@ impl InstrumentationEndpoint {
                 Vc::cell(vec![module]),
                 module_graph,
                 OutputAssets::empty(),
-                OutputAssets::empty(),
+                OutputAssetsReferences::empty(),
                 AvailabilityInfo::Root,
             )
             .await?;

crates/next-api/src/middleware.rs

@@ -24,7 +24,7 @@ use turbopack_core::{
         GraphEntries,
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
     },
-    output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
+    output::{OutputAsset, OutputAssets, OutputAssetsReferences, OutputAssetsWithReferenced},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
     virtual_output::VirtualOutputAsset,
@@ -146,7 +146,7 @@ impl MiddlewareEndpoint {
                 Vc::cell(vec![module]),
                 module_graph,
                 OutputAssets::empty(),
-                OutputAssets::empty(),
+                OutputAssetsReferences::empty(),
                 AvailabilityInfo::Root,
             )
             .await?;

crates/next-api/src/pages.rs

@@ -56,7 +56,7 @@ use turbopack_core::{
         GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
     },
-    output::{OptionOutputAsset, OutputAsset, OutputAssets},
+    output::{OptionOutputAsset, OutputAsset, OutputAssets, OutputAssetsReferences},
     reference::all_assets_from_entries,
     reference_type::{EcmaScriptModulesReferenceSubType, EntryReferenceSubType, ReferenceType},
     resolve::{origin::PlainResolveOrigin, parse::Request, pattern::Pattern},
@@ -1047,7 +1047,7 @@ impl PageEndpoint {
 
                 Ok(SsrChunk::Edge {
                     assets: chunk_assets.primary_assets().to_resolved().await?,
-                    referenced_assets: chunk_assets.referenced_assets().to_resolved().await?,
+                    references: chunk_assets.references().to_resolved().await?,
                     dynamic_import_entries,
                     regions: regions.clone(),
                 }
@@ -1065,7 +1065,7 @@ impl PageEndpoint {
                         EvaluatableAssets::empty().with_entry(*ssr_module_evaluatable),
                         ssr_module_graph,
                         current_chunk_group.primary_assets(),
-                        current_chunk_group.referenced_assets(),
+                        current_chunk_group.references(),
                         current_chunk_group.await?.availability_info,
                     )
                     .to_resolved()
@@ -1408,7 +1408,7 @@ impl PageEndpoint {
             }
             SsrChunk::Edge {
                 assets,
-                referenced_assets,
+                references,
                 dynamic_import_entries,
                 ref regions,
             } => {
@@ -1428,10 +1428,12 @@ impl PageEndpoint {
                         fxindexset![]
                     };
 
-                    let all_assets = assets.concatenate(*referenced_assets);
+                    let referenced_assets = references.all_assets();
+
+                    let all_assets = assets.concatenate(referenced_assets);
                     let assets_ref = assets.await?;
 
-                    server_assets.extend(referenced_assets.await?.iter().copied());
+                    server_assets.extend(referenced_assets.await?.into_iter().copied());
 
                     // TODO(sokra): accessing the 1st asset is a bit hacky, we should find a better
                     // way to get the main entry asset
@@ -1771,7 +1773,7 @@ pub enum SsrChunk {
     },
     Edge {
         assets: ResolvedVc<OutputAssets>,
-        referenced_assets: ResolvedVc<OutputAssets>,
+        references: ResolvedVc<OutputAssetsReferences>,
         dynamic_import_entries: ResolvedVc<DynamicImportedChunks>,
         regions: Option<Vec<RcStr>>,
     },

crates/next-core/src/next_app/app_client_references_chunks.rs

@@ -160,7 +160,6 @@ pub async fn get_app_client_references_chunks(
 
             let mut current_client_chunk_group = ChunkGroupResult {
                 assets: ResolvedVc::cell(vec![]),
-                referenced_assets: ResolvedVc::cell(vec![]),
                 references: ResolvedVc::cell(vec![]),
                 availability_info: client_availability_info,
             }

crates/next-core/src/next_manifests/client_reference_manifest.rs

@@ -14,7 +14,9 @@ use turbopack_core::{
     asset::{Asset, AssetContent},
     chunk::{ChunkingContext, ModuleChunkItemIdExt, ModuleId as TurbopackModuleId},
     module_graph::async_module_info::AsyncModulesInfo,
-    output::{OutputAsset, OutputAssets, OutputAssetsReference, OutputAssetsWithReferenced},
+    output::{
+        OutputAsset, OutputAssetsReference, OutputAssetsReferences, OutputAssetsWithReferenced,
+    },
 };
 use turbopack_ecmascript::utils::StringifyJs;
 
@@ -109,9 +111,13 @@ pub struct ClientReferenceManifest {
 impl OutputAssetsReference for ClientReferenceManifest {
     #[turbo_tasks::function]
     async fn references(self: Vc<Self>) -> Result<Vc<OutputAssetsWithReferenced>> {
-        Ok(OutputAssetsWithReferenced::from_assets(
-            *build_manifest(self).await?.references,
-        ))
+        Ok(OutputAssetsWithReferenced {
+            assets: ResolvedVc::cell(vec![]),
+            references: ResolvedVc::cell(vec![ResolvedVc::upcast(
+                build_manifest(self).await?.references,
+            )]),
+        }
+        .cell())
     }
 }
 
@@ -140,7 +146,7 @@ impl Asset for ClientReferenceManifest {
 #[turbo_tasks::value(shared)]
 struct ClientReferenceManifestResult {
     content: ResolvedVc<AssetContent>,
-    references: ResolvedVc<OutputAssets>,
+    references: ResolvedVc<OutputAssetsReferences>,
 }
 
 #[turbo_tasks::function]
@@ -166,7 +172,7 @@ async fn build_manifest(
     );
     async move {
         let mut entry_manifest: SerializedClientReferenceManifest = Default::default();
-        let mut references = FxIndexSet::default();
+        let mut references = Vec::new();
         let chunk_suffix_path = next_config.chunk_suffix_path().owned().await?;
         let prefix_path = next_config.computed_asset_prefix().owned().await?;
         let suffix_path = chunk_suffix_path.unwrap_or_default();
@@ -259,14 +265,17 @@ async fn build_manifest(
             let (client_chunks_paths, client_is_async) = if let Some(client_assets) =
                 client_component_client_chunks.get(&app_client_reference_ty)
             {
-                let client_chunks = client_assets.primary_assets().await?;
-                let client_referenced_assets = client_assets.referenced_assets().await?;
-                references.extend(client_chunks.iter());
-                references.extend(client_referenced_assets.iter());
-
-                let client_chunks_paths =
-                    cached_chunk_paths(&mut client_chunk_path_cache, client_chunks.iter().copied())
-                        .await?;
+                let client_chunks = client_assets.primary_assets().to_resolved().await?;
+                references.push(ResolvedVc::upcast(client_chunks));
+                references.push(ResolvedVc::upcast(
+                    client_assets.references().to_resolved().await?,
+                ));
+
+                let client_chunks_paths = cached_chunk_paths(
+                    &mut client_chunk_path_cache,
+                    client_chunks.await?.into_iter().copied(),
+                )
+                .await?;
 
                 let chunk_paths = client_chunks_paths
                     .filter_map(|(_, chunk_path)| {
@@ -312,14 +321,16 @@ async fn build_manifest(
                 } else if let Some(ssr_assets) =
                     client_component_ssr_chunks.get(&app_client_reference_ty)
                 {
-                    let ssr_chunks = ssr_assets.primary_assets().await?;
-                    let ssr_referenced_assets = ssr_assets.referenced_assets().await?;
-                    references.extend(ssr_chunks.iter());
-                    references.extend(ssr_referenced_assets.iter());
-
-                    let ssr_chunks_paths =
-                        cached_chunk_paths(&mut ssr_chunk_path_cache, ssr_chunks.iter().copied())
-                            .await?;
+                    let ssr_chunks = ssr_assets.primary_assets().to_resolved().await?;
+                    let ssr_referenced_assets = ssr_assets.references().to_resolved().await?;
+                    references.push(ResolvedVc::upcast(ssr_chunks));
+                    references.push(ResolvedVc::upcast(ssr_referenced_assets));
+
+                    let ssr_chunks_paths = cached_chunk_paths(
+                        &mut ssr_chunk_path_cache,
+                        ssr_chunks.await?.into_iter().copied(),
+                    )
+                    .await?;
                     let chunk_paths = ssr_chunks_paths
                         .filter_map(|(_, chunk_path)| {
                             node_root_ref

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

@@ -26,7 +26,7 @@ use turbopack_core::{
         chunk_group_info::ChunkGroup,
         export_usage::{ExportUsageInfo, ModuleExportUsage},
     },
-    output::{OutputAsset, OutputAssets},
+    output::{OutputAsset, OutputAssets, OutputAssetsReferences},
 };
 use turbopack_ecmascript::{
     async_chunk::module::AsyncLoaderModule,
@@ -662,7 +662,7 @@ impl ChunkingContext for BrowserChunkingContext {
             let MakeChunkGroupResult {
                 chunks,
                 referenced_output_assets,
-                references,
+                mut references,
                 availability_info,
             } = make_chunk_group(
                 entries,
@@ -678,6 +678,10 @@ impl ChunkingContext for BrowserChunkingContext {
                 .try_join()
                 .await?;
 
+            let referenced_output_assets: ResolvedVc<OutputAssets> =
+                ResolvedVc::cell(referenced_output_assets);
+            references.push(ResolvedVc::upcast(referenced_output_assets));
+
             if this.enable_hot_module_replacement {
                 let mut ident = ident;
                 match input_availability_info {
@@ -705,7 +709,6 @@ impl ChunkingContext for BrowserChunkingContext {
 
             Ok(ChunkGroupResult {
                 assets: ResolvedVc::cell(assets),
-                referenced_assets: ResolvedVc::cell(referenced_output_assets),
                 references: ResolvedVc::cell(references),
                 availability_info,
             }
@@ -734,7 +737,7 @@ impl ChunkingContext for BrowserChunkingContext {
             let MakeChunkGroupResult {
                 chunks,
                 referenced_output_assets,
-                references,
+                mut references,
                 availability_info,
             } = make_chunk_group(
                 entries,
@@ -750,6 +753,10 @@ impl ChunkingContext for BrowserChunkingContext {
                 .try_join()
                 .await?;
 
+            let referenced_output_assets: ResolvedVc<OutputAssets> =
+                ResolvedVc::cell(referenced_output_assets);
+            references.push(ResolvedVc::upcast(referenced_output_assets));
+
             let other_assets = Vc::cell(assets.clone());
 
             let entries = Vc::cell(
@@ -794,7 +801,6 @@ impl ChunkingContext for BrowserChunkingContext {
 
             Ok(ChunkGroupResult {
                 assets: ResolvedVc::cell(assets),
-                referenced_assets: ResolvedVc::cell(referenced_output_assets),
                 references: ResolvedVc::cell(references),
                 availability_info,
             }
@@ -811,7 +817,7 @@ impl ChunkingContext for BrowserChunkingContext {
         _evaluatable_assets: Vc<EvaluatableAssets>,
         _module_graph: Vc<ModuleGraph>,
         _extra_chunks: Vc<OutputAssets>,
-        _extra_referenced_assets: Vc<OutputAssets>,
+        _extra_references: Vc<OutputAssetsReferences>,
         _availability_info: AvailabilityInfo,
     ) -> Result<Vc<EntryChunkGroupResult>> {
         bail!("Browser chunking context does not support entry chunk groups")

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

@@ -117,7 +117,6 @@ impl OutputAssetsReference for EcmascriptBrowserChunk {
 
         Ok(OutputAssetsWithReferenced {
             assets: ResolvedVc::cell(assets),
-            referenced_assets: chunk_references.referenced_assets,
             references: chunk_references.references,
         }
         .cell())

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -36,7 +36,7 @@ use turbopack_core::{
         chunk_group_info::{ChunkGroup, ChunkGroupEntry},
         export_usage::compute_export_usage_info,
     },
-    output::{OutputAsset, OutputAssets, OutputAssetsWithReferenced},
+    output::{OutputAsset, OutputAssets, OutputAssetsReferences, OutputAssetsWithReferenced},
     reference_type::{EntryReferenceSubType, ReferenceType},
     resolve::{
         origin::{PlainResolveOrigin, ResolveOriginExt},
@@ -463,13 +463,12 @@ async fn build_internal(
                                             EvaluatableAssets::one(*ecmascript),
                                             module_graph,
                                             OutputAssets::empty(),
-                                            OutputAssets::empty(),
+                                            OutputAssetsReferences::empty(),
                                             AvailabilityInfo::Root,
                                         )
                                         .await?
                                         .asset,
                                 ]),
-                                referenced_assets: ResolvedVc::cell(vec![]),
                                 references: ResolvedVc::cell(vec![]),
                             }
                             .cell(),

turbopack/crates/turbopack-core/src/chunk/chunk_group.rs

@@ -26,8 +26,7 @@ use crate::{
         module_batches::{BatchingConfig, ModuleBatchesGraphEdge},
     },
     output::{
-        OutputAsset, OutputAssets, OutputAssetsReference, OutputAssetsReferences,
-        OutputAssetsWithReferenced,
+        OutputAsset, OutputAssetsReference, OutputAssetsReferences, OutputAssetsWithReferenced,
     },
     reference::ModuleReference,
     traced_asset::TracedAsset,
@@ -174,7 +173,6 @@ pub async fn references_to_output_assets(
         .collect::<Vec<_>>();
     Ok(OutputAssetsWithReferenced {
         assets: ResolvedVc::cell(output_assets),
-        referenced_assets: OutputAssets::empty_resolved(),
         references: OutputAssetsReferences::empty_resolved(),
     }
     .cell())