ChunkGroup in evaluated_chunk_group

Author: mischnic

crates/next-api/src/app.rs

@@ -1652,23 +1652,27 @@ impl AppEndpoint {
                 } = *chunking_context
                     .evaluated_chunk_group(
                         server_action_manifest_loader.ident(),
-                        Vc::cell(vec![server_action_manifest_loader]),
+                        ChunkGroup::Entry(
+                            [ResolvedVc::upcast(server_action_manifest_loader)]
+                                .into_iter()
+                                .collect(),
+                        ),
                         module_graph,
                         Value::new(AvailabilityInfo::Root),
                     )
                     .await?;
 
-                let mut evaluatable_assets =
-                    this.app_project.edge_rsc_runtime_entries().owned().await?;
-                let evaluatable = ResolvedVc::try_sidecast(app_entry.rsc_entry)
-                    .context("Entry module must be evaluatable")?;
-                evaluatable_assets.push(evaluatable);
+                let edge_rsc_runtime_entries = this.app_project.edge_rsc_runtime_entries().await?;
+                let evaluatable_assets = edge_rsc_runtime_entries
+                    .iter()
+                    .map(|m| ResolvedVc::upcast(*m))
+                    .chain(std::iter::once(app_entry.rsc_entry));
 
                 assets.concatenate(
                     chunking_context
                         .evaluated_chunk_group_assets(
                             app_entry.rsc_entry.ident(),
-                            Vc::cell(evaluatable_assets.clone()),
+                            ChunkGroup::Entry(evaluatable_assets.collect()),
                             module_graph,
                             Value::new(availability_info),
                         )

crates/next-api/src/instrumentation.rs

@@ -17,13 +17,15 @@ use turbopack_core::{
     },
     context::AssetContext,
     module::Module,
-    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries},
+    module_graph::{
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
+        GraphEntries,
+    },
     output::{OutputAsset, OutputAssets},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
     virtual_output::VirtualOutputAsset,
 };
-use turbopack_ecmascript::chunk::EcmascriptChunkPlaceable;
 
 use crate::{
     nft_json::NftJsonAsset,
@@ -98,12 +100,11 @@ impl InstrumentationEndpoint {
     #[turbo_tasks::function]
     async fn edge_files(self: Vc<Self>) -> Result<Vc<OutputAssets>> {
         let this = self.await?;
-
         let module = self.core_modules().await?.edge_entry_module;
 
         let module_graph = this.project.module_graph(*module);
 
-        let mut evaluatable_assets = get_server_runtime_entries(
+        let evaluatable_assets = get_server_runtime_entries(
             Value::new(ServerContextType::Instrumentation {
                 app_dir: this.app_dir,
                 ecmascript_client_reference_transition_name: this
@@ -112,24 +113,16 @@ impl InstrumentationEndpoint {
             this.project.next_mode(),
         )
         .resolve_entries(*this.asset_context)
-        .owned()
-        .await?;
-
-        let Some(module) = ResolvedVc::try_downcast::<Box<dyn EcmascriptChunkPlaceable>>(module)
-        else {
-            bail!("Entry module must be evaluatable");
-        };
-
-        let Some(evaluatable) = ResolvedVc::try_sidecast(module) else {
-            bail!("Entry module must be evaluatable");
-        };
-        evaluatable_assets.push(evaluatable);
+        .await?
+        .iter()
+        .map(|m| ResolvedVc::upcast(*m))
+        .chain(std::iter::once(module))
+        .collect();
 
         let edge_chunking_context = this.project.edge_chunking_context(false);
-
-        let edge_files = edge_chunking_context.evaluated_chunk_group_assets(
+        let edge_files: Vc<OutputAssets> = edge_chunking_context.evaluated_chunk_group_assets(
             module.ident(),
-            Vc::cell(evaluatable_assets),
+            ChunkGroup::Entry(evaluatable_assets),
             module_graph,
             Value::new(AvailabilityInfo::Root),
         );

crates/next-api/src/middleware.rs

@@ -1,6 +1,6 @@
 use std::future::IntoFuture;
 
-use anyhow::{bail, Context, Result};
+use anyhow::{bail, Result};
 use next_core::{
     all_assets_from_entries,
     middleware::get_middleware_module,
@@ -17,17 +17,19 @@ use turbopack_core::{
     asset::AssetContent,
     chunk::{
         availability_info::AvailabilityInfo, ChunkingContext, ChunkingContextExt,
-        EntryChunkGroupResult, EvaluatableAsset,
+        EntryChunkGroupResult,
     },
     context::AssetContext,
     module::Module,
-    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries},
+    module_graph::{
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
+        GraphEntries,
+    },
     output::{OutputAsset, OutputAssets},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
     virtual_output::VirtualOutputAsset,
 };
-use turbopack_ecmascript::chunk::EcmascriptChunkPlaceable;
 
 use crate::{
     nft_json::NftJsonAsset,
@@ -103,7 +105,9 @@ impl MiddlewareEndpoint {
     #[turbo_tasks::function]
     async fn edge_files(self: Vc<Self>) -> Result<Vc<OutputAssets>> {
         let this = self.await?;
-        let module = self.entry_module();
+        let module = self.entry_module().to_resolved().await?;
+
+        let module_graph = this.project.module_graph(*module);
 
         let evaluatable_assets = get_server_runtime_entries(
             Value::new(ServerContextType::Middleware {
@@ -113,28 +117,17 @@ impl MiddlewareEndpoint {
             }),
             this.project.next_mode(),
         )
-        .resolve_entries(*this.asset_context);
-
-        let mut evaluatable_assets = evaluatable_assets.owned().await?;
-
-        let Some(module) =
-            Vc::try_resolve_downcast::<Box<dyn EcmascriptChunkPlaceable>>(module).await?
-        else {
-            bail!("Entry module must be evaluatable");
-        };
-        let evaluatable = Vc::try_resolve_sidecast::<Box<dyn EvaluatableAsset>>(module)
-            .await?
-            .context("Entry module must be evaluatable")?;
-        evaluatable_assets.push(evaluatable.to_resolved().await?);
-
-        let evaluatable_assets = Vc::cell(evaluatable_assets);
-        let module_graph = this.project.module_graph_for_entries(evaluatable_assets);
+        .resolve_entries(*this.asset_context)
+        .await?
+        .iter()
+        .map(|m| ResolvedVc::upcast(*m))
+        .chain(std::iter::once(module))
+        .collect();
 
         let edge_chunking_context = this.project.edge_chunking_context(false);
-
         let edge_files = edge_chunking_context.evaluated_chunk_group_assets(
             module.ident(),
-            evaluatable_assets,
+            ChunkGroup::Entry(evaluatable_assets),
             module_graph,
             Value::new(AvailabilityInfo::Root),
         );

crates/next-api/src/pages.rs

@@ -52,7 +52,10 @@ use turbopack_core::{
     file_source::FileSource,
     ident::AssetIdent,
     module::Module,
-    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries, ModuleGraph},
+    module_graph::{
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
+        GraphEntries, ModuleGraph,
+    },
     output::{OptionOutputAsset, OutputAsset, OutputAssets},
     reference_type::{EcmaScriptModulesReferenceSubType, EntryReferenceSubType, ReferenceType},
     resolve::{origin::PlainResolveOrigin, parse::Request, pattern::Pattern},
@@ -782,10 +785,15 @@ impl PageEndpoint {
 
             let module_graph = self.client_module_graph();
 
-            let evaluatable_assets = self.client_evaluatable_assets();
+            let evaluatable_assets = self
+                .client_evaluatable_assets()
+                .await?
+                .iter()
+                .map(|m| ResolvedVc::upcast(*m))
+                .collect();
             let client_chunk_group = client_chunking_context.evaluated_chunk_group(
                 AssetIdent::from_path(*this.page.await?.base_path),
-                evaluatable_assets,
+                ChunkGroup::Entry(evaluatable_assets),
                 module_graph,
                 Value::new(AvailabilityInfo::Root),
             );
@@ -961,13 +969,16 @@ impl PageEndpoint {
                 .context("could not process page loader entry module")?;
             let is_edge = matches!(runtime, NextRuntime::Edge);
             if is_edge {
-                let mut evaluatable_assets = edge_runtime_entries.owned().await?;
-                evaluatable_assets.push(ssr_module_evaluatable);
+                let edge_runtime_entries = edge_runtime_entries.await?;
+                let evaluatable_assets = edge_runtime_entries
+                    .iter()
+                    .map(|m| ResolvedVc::upcast(*m))
+                    .chain(std::iter::once(ResolvedVc::upcast(ssr_module_evaluatable)));
 
                 let edge_files = edge_chunking_context
                     .evaluated_chunk_group_assets(
                         ssr_module.ident(),
-                        Vc::cell(evaluatable_assets),
+                        ChunkGroup::Entry(evaluatable_assets.collect()),
                         module_graph,
                         Value::new(AvailabilityInfo::Root),
                     )

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

@@ -1,11 +1,12 @@
 use anyhow::Result;
-use turbo_tasks::{Value, Vc};
+use tracing::Instrument;
+use turbo_tasks::{ResolvedVc, Value, Vc};
 use turbopack_core::{
     chunk::{
         availability_info::AvailabilityInfo, ChunkGroupResult, ChunkingContext, EvaluatableAssets,
     },
     ident::AssetIdent,
-    module_graph::ModuleGraph,
+    module_graph::{chunk_group_info::ChunkGroup, ModuleGraph},
     output::OutputAssets,
 };
 
@@ -24,13 +25,26 @@ pub async fn get_app_client_shared_chunk_group(
         .cell());
     }
 
-    let _span = tracing::trace_span!("app client shared").entered();
-    let app_client_shared_chunk_grou = client_chunking_context.evaluated_chunk_group(
-        ident,
-        app_client_runtime_entries,
-        module_graph,
-        Value::new(AvailabilityInfo::Root),
-    );
+    let span = tracing::trace_span!("app client shared");
+    let app_client_shared_chunk_grou = async {
+        client_chunking_context
+            .evaluated_chunk_group(
+                ident,
+                ChunkGroup::Entry(
+                    app_client_runtime_entries
+                        .await?
+                        .iter()
+                        .map(|v| ResolvedVc::upcast(*v))
+                        .collect(),
+                ),
+                module_graph,
+                Value::new(AvailabilityInfo::Root),
+            )
+            .resolve()
+            .await
+    }
+    .instrument(span)
+    .await?;
 
     Ok(app_client_shared_chunk_grou)
 }

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

@@ -10,8 +10,8 @@ use turbopack_core::{
         chunk_group::{make_chunk_group, MakeChunkGroupResult},
         module_id_strategies::{DevModuleIdStrategy, ModuleIdStrategy},
         Chunk, ChunkGroupResult, ChunkItem, ChunkableModule, ChunkingConfig, ChunkingConfigs,
-        ChunkingContext, EntryChunkGroupResult, EvaluatableAssets, MinifyType, ModuleId,
-        SourceMapsType,
+        ChunkingContext, EntryChunkGroupResult, EvaluatableAsset, EvaluatableAssets, MinifyType,
+        ModuleId, SourceMapsType,
     },
     environment::Environment,
     ident::AssetIdent,
@@ -483,7 +483,7 @@ impl ChunkingContext for BrowserChunkingContext {
     async fn evaluated_chunk_group(
         self: ResolvedVc<Self>,
         ident: Vc<AssetIdent>,
-        evaluatable_assets: Vc<EvaluatableAssets>,
+        chunk_group: ChunkGroup,
         module_graph: Vc<ModuleGraph>,
         availability_info: Value<AvailabilityInfo>,
     ) -> Result<Vc<ChunkGroupResult>> {
@@ -495,11 +495,7 @@ impl ChunkingContext for BrowserChunkingContext {
             let this = self.await?;
             let availability_info = availability_info.into_value();
 
-            let evaluatable_assets_ref = evaluatable_assets.await?;
-
-            let entries = evaluatable_assets_ref
-                .iter()
-                .map(|&evaluatable| ResolvedVc::upcast(evaluatable));
+            let entries = chunk_group.entries();
 
             let MakeChunkGroupResult {
                 chunks,
@@ -520,11 +516,21 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let other_assets = Vc::cell(assets.clone());
 
+            let entries = Vc::cell(
+                chunk_group
+                    .entries()
+                    .map(|m| {
+                        ResolvedVc::try_downcast::<Box<dyn EvaluatableAsset>>(m)
+                            .context("evaluated_chunk_group entries must be evaluatable assets")
+                    })
+                    .collect::<Result<Vec<_>>>()?,
+            );
+
             if this.enable_hot_module_replacement {
                 assets.push(
                     self.generate_chunk_list_register_chunk(
                         ident,
-                        evaluatable_assets,
+                        entries,
                         other_assets,
                         Value::new(EcmascriptDevChunkListSource::Entry),
                     )
@@ -534,7 +540,7 @@ impl ChunkingContext for BrowserChunkingContext {
             }
 
             assets.push(
-                self.generate_evaluate_chunk(ident, other_assets, evaluatable_assets, module_graph)
+                self.generate_evaluate_chunk(ident, other_assets, entries, module_graph)
                     .to_resolved()
                     .await?,
             );

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

@@ -29,7 +29,10 @@ use turbopack_core::{
     ident::AssetIdent,
     issue::{handle_issues, IssueReporter, IssueSeverity},
     module::Module,
-    module_graph::{chunk_group_info::ChunkGroupEntry, ModuleGraph},
+    module_graph::{
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
+        ModuleGraph,
+    },
     output::{OutputAsset, OutputAssets},
     reference::all_assets_from_entries,
     reference_type::{EntryReferenceSubType, ReferenceType},
@@ -396,7 +399,9 @@ async fn build_internal(
                                             )
                                             .with_extension("entry.js".into()),
                                     ),
-                                    EvaluatableAssets::one(*ResolvedVc::upcast(ecmascript)),
+                                    ChunkGroup::Entry(
+                                        [ResolvedVc::upcast(ecmascript)].into_iter().collect(),
+                                    ),
                                     module_graph,
                                     Value::new(AvailabilityInfo::Root),
                                 )