Remove RuntimeEntries this is a complicated and expensive way to pass around an empty vec

Author: lukesandberg

crates/next-api/src/app.rs

@@ -12,8 +12,8 @@ use next_core::{
         get_app_page_entry, get_app_route_entry, metadata::route::get_app_metadata_route_entry,
     },
     next_client::{
-        ClientContextType, RuntimeEntries, get_client_module_options_context,
-        get_client_resolve_options_context, get_client_runtime_entries,
+        ClientContextType, get_client_module_options_context, get_client_resolve_options_context,
+        get_client_runtime_entries,
     },
     next_client_reference::{
         ClientReferenceGraphResult, NextCssClientReferenceTransition,
@@ -29,7 +29,6 @@ use next_core::{
     },
     next_server::{
         ServerContextType, get_server_module_options_context, get_server_resolve_options_context,
-        get_server_runtime_entries,
     },
     next_server_utility::{NEXT_SERVER_UTILITY_MERGE_TAG, NextServerUtilityTransition},
     parse_segment_config_from_source,
@@ -778,26 +777,6 @@ impl AppProject {
         ))
     }
 
-    #[turbo_tasks::function]
-    async fn runtime_entries(self: Vc<Self>) -> Result<Vc<RuntimeEntries>> {
-        Ok(get_server_runtime_entries(
-            self.rsc_ty().owned().await?,
-            self.project().next_mode(),
-        ))
-    }
-
-    #[turbo_tasks::function]
-    fn rsc_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        self.runtime_entries()
-            .resolve_entries(Vc::upcast(self.rsc_module_context()))
-    }
-
-    #[turbo_tasks::function]
-    fn edge_rsc_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        self.runtime_entries()
-            .resolve_entries(Vc::upcast(self.edge_rsc_module_context()))
-    }
-
     #[turbo_tasks::function]
     fn client_env(self: Vc<Self>) -> Vc<Box<dyn ProcessEnv>> {
         Vc::upcast(CustomProcessEnv::new(
@@ -1780,17 +1759,11 @@ impl AppEndpoint {
                     )
                     .await?;
 
-                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(),
-                            ChunkGroup::Entry(evaluatable_assets.collect()),
+                            ChunkGroup::Entry(vec![app_entry.rsc_entry]),
                             module_graph,
                             availability_info,
                         )
@@ -1799,13 +1772,11 @@ impl AppEndpoint {
                 )
             }
             NextRuntime::NodeJs => {
-                let mut evaluatable_assets = this.app_project.rsc_runtime_entries().owned().await?;
-
                 let Some(rsc_entry) = ResolvedVc::try_downcast(app_entry.rsc_entry) else {
                     bail!("rsc_entry must be evaluatable");
                 };
 
-                evaluatable_assets.push(rsc_entry);
+                let evaluatable_assets = Vc::cell(vec![rsc_entry]);
 
                 async {
                     let mut current_chunks = OutputAssets::empty();
@@ -1909,7 +1880,7 @@ impl AppEndpoint {
                                     "app{original_name}.js",
                                     original_name = app_entry.original_name
                                 ))?,
-                                Vc::cell(evaluatable_assets),
+                                evaluatable_assets,
                                 module_graph,
                                 current_chunks,
                                 current_availability_info,

crates/next-api/src/instrumentation.rs

@@ -3,7 +3,6 @@ use next_core::{
     all_assets_from_entries,
     next_edge::entry::wrap_edge_entry,
     next_manifests::{InstrumentationDefinition, MiddlewaresManifestV2},
-    next_server::{ServerContextType, get_server_runtime_entries},
 };
 use tracing::Instrument;
 use turbo_rcstr::{RcStr, rcstr};
@@ -104,26 +103,10 @@ impl InstrumentationEndpoint {
 
         let module_graph = this.project.module_graph(*module);
 
-        let evaluatable_assets = get_server_runtime_entries(
-            ServerContextType::Instrumentation {
-                app_dir: this.app_dir.clone(),
-                ecmascript_client_reference_transition_name: this
-                    .ecmascript_client_reference_transition_name
-                    .clone(),
-            },
-            this.project.next_mode(),
-        )
-        .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: Vc<OutputAssets> = edge_chunking_context.evaluated_chunk_group_assets(
             module.ident(),
-            ChunkGroup::Entry(evaluatable_assets),
+            ChunkGroup::Entry(vec![module]),
             module_graph,
             AvailabilityInfo::Root,
         );
@@ -150,17 +133,7 @@ impl InstrumentationEndpoint {
                     .node_root()
                     .await?
                     .join("server/instrumentation.js")?,
-                get_server_runtime_entries(
-                    ServerContextType::Instrumentation {
-                        app_dir: this.app_dir.clone(),
-                        ecmascript_client_reference_transition_name: this
-                            .ecmascript_client_reference_transition_name
-                            .clone(),
-                    },
-                    this.project.next_mode(),
-                )
-                .resolve_entries(*this.asset_context)
-                .with_entry(*module),
+                Vc::cell(vec![module]),
                 module_graph,
                 OutputAssets::empty(),
                 AvailabilityInfo::Root,

crates/next-api/src/middleware.rs

@@ -6,7 +6,6 @@ use next_core::{
     middleware::get_middleware_module,
     next_edge::entry::wrap_edge_entry,
     next_manifests::{EdgeFunctionDefinition, MiddlewareMatcher, MiddlewaresManifestV2, Regions},
-    next_server::{ServerContextType, get_server_runtime_entries},
     parse_segment_config_from_source,
     segment_config::ParseSegmentMode,
     util::{MiddlewareMatcherKind, NextRuntime},
@@ -111,26 +110,10 @@ impl MiddlewareEndpoint {
 
         let module_graph = this.project.module_graph(*module);
 
-        let evaluatable_assets = get_server_runtime_entries(
-            ServerContextType::Middleware {
-                app_dir: this.app_dir.clone(),
-                ecmascript_client_reference_transition_name: this
-                    .ecmascript_client_reference_transition_name
-                    .clone(),
-            },
-            this.project.next_mode(),
-        )
-        .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(),
-            ChunkGroup::Entry(evaluatable_assets),
+            ChunkGroup::Entry(vec![module]),
             module_graph,
             AvailabilityInfo::Root,
         );
@@ -156,17 +139,7 @@ impl MiddlewareEndpoint {
                     .node_root()
                     .await?
                     .join("server/middleware.js")?,
-                get_server_runtime_entries(
-                    ServerContextType::Middleware {
-                        app_dir: this.app_dir.clone(),
-                        ecmascript_client_reference_transition_name: this
-                            .ecmascript_client_reference_transition_name
-                            .clone(),
-                    },
-                    this.project.next_mode(),
-                )
-                .resolve_entries(*this.asset_context)
-                .with_entry(*module),
+                Vc::cell(vec![module]),
                 module_graph,
                 OutputAssets::empty(),
                 AvailabilityInfo::Root,

crates/next-api/src/pages.rs

@@ -6,8 +6,8 @@ use next_core::{
     hmr_entry::HmrEntryModule,
     mode::NextMode,
     next_client::{
-        ClientContextType, RuntimeEntries, get_client_module_options_context,
-        get_client_resolve_options_context, get_client_runtime_entries,
+        ClientContextType, get_client_module_options_context, get_client_resolve_options_context,
+        get_client_runtime_entries,
     },
     next_dynamic::NextDynamicTransition,
     next_edge::route_regex::get_named_middleware_regex,
@@ -18,7 +18,6 @@ use next_core::{
     next_pages::create_page_ssr_entry_module,
     next_server::{
         ServerContextType, get_server_module_options_context, get_server_resolve_options_context,
-        get_server_runtime_entries,
     },
     pages_structure::{
         PagesDirectoryStructure, PagesStructure, PagesStructureItem, find_pages_structure,
@@ -599,50 +598,6 @@ impl PagesProject {
         Ok(client_runtime_entries.resolve_entries(Vc::upcast(self.client_module_context())))
     }
 
-    #[turbo_tasks::function]
-    async fn runtime_entries(self: Vc<Self>) -> Result<Vc<RuntimeEntries>> {
-        Ok(get_server_runtime_entries(
-            ServerContextType::Pages {
-                pages_dir: self.pages_dir().owned().await?,
-            },
-            self.project().next_mode(),
-        ))
-    }
-
-    #[turbo_tasks::function]
-    async fn data_runtime_entries(self: Vc<Self>) -> Result<Vc<RuntimeEntries>> {
-        Ok(get_server_runtime_entries(
-            ServerContextType::PagesData {
-                pages_dir: self.pages_dir().owned().await?,
-            },
-            self.project().next_mode(),
-        ))
-    }
-
-    #[turbo_tasks::function]
-    fn ssr_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        let ssr_runtime_entries = self.runtime_entries();
-        ssr_runtime_entries.resolve_entries(Vc::upcast(self.ssr_module_context()))
-    }
-
-    #[turbo_tasks::function]
-    fn ssr_data_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        let ssr_data_runtime_entries = self.data_runtime_entries();
-        ssr_data_runtime_entries.resolve_entries(Vc::upcast(self.ssr_module_context()))
-    }
-
-    #[turbo_tasks::function]
-    fn edge_ssr_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        let ssr_runtime_entries = self.runtime_entries();
-        ssr_runtime_entries.resolve_entries(Vc::upcast(self.edge_ssr_module_context()))
-    }
-
-    #[turbo_tasks::function]
-    fn edge_ssr_data_runtime_entries(self: Vc<Self>) -> Vc<EvaluatableAssets> {
-        let ssr_data_runtime_entries = self.data_runtime_entries();
-        ssr_data_runtime_entries.resolve_entries(Vc::upcast(self.edge_ssr_module_context()))
-    }
-
     #[turbo_tasks::function]
     pub async fn client_main_module(self: Vc<Self>) -> Result<Vc<Box<dyn Module>>> {
         let client_module_context = Vc::upcast(self.client_module_context());
@@ -1008,8 +963,6 @@ impl PageEndpoint {
         node_path: FileSystemPath,
         node_chunking_context: Vc<NodeJsChunkingContext>,
         edge_chunking_context: Vc<Box<dyn ChunkingContext>>,
-        runtime_entries: Vc<EvaluatableAssets>,
-        edge_runtime_entries: Vc<EvaluatableAssets>,
     ) -> Result<Vc<SsrChunk>> {
         async move {
             let this = self.await?;
@@ -1126,15 +1079,9 @@ impl PageEndpoint {
                 .context("could not process page loader entry module")?;
             let is_edge = matches!(runtime, NextRuntime::Edge);
             if is_edge {
-                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(),
-                    ChunkGroup::Entry(evaluatable_assets.collect()),
+                    ChunkGroup::Entry(vec![ResolvedVc::upcast(ssr_module_evaluatable)]),
                     ssr_module_graph,
                     current_availability_info,
                 );
@@ -1155,7 +1102,7 @@ impl PageEndpoint {
                 let ssr_entry_chunk = node_chunking_context
                     .entry_chunk_group_asset(
                         ssr_entry_chunk_path,
-                        runtime_entries.with_entry(*ssr_module_evaluatable),
+                        EvaluatableAssets::empty().with_entry(*ssr_module_evaluatable),
                         ssr_module_graph,
                         current_chunks,
                         current_availability_info,
@@ -1224,8 +1171,6 @@ impl PageEndpoint {
                 .join("server")?,
             project.server_chunking_context(true),
             project.edge_chunking_context(true),
-            this.pages_project.ssr_runtime_entries(),
-            this.pages_project.edge_ssr_runtime_entries(),
         ))
     }
 
@@ -1242,8 +1187,6 @@ impl PageEndpoint {
                 .join("server/data")?,
             this.pages_project.project().server_chunking_context(true),
             this.pages_project.project().edge_chunking_context(true),
-            this.pages_project.ssr_data_runtime_entries(),
-            this.pages_project.edge_ssr_data_runtime_entries(),
         ))
     }
 
@@ -1260,8 +1203,6 @@ impl PageEndpoint {
                 .join("server")?,
             this.pages_project.project().server_chunking_context(false),
             this.pages_project.project().edge_chunking_context(false),
-            this.pages_project.ssr_runtime_entries(),
-            this.pages_project.edge_ssr_runtime_entries(),
         ))
     }
 

crates/next-core/src/next_server/context.rs

@@ -46,7 +46,6 @@ use crate::{
     app_structure::CollectedRootParams,
     mode::NextMode,
     next_build::get_postcss_package_mapping,
-    next_client::RuntimeEntries,
     next_config::NextConfig,
     next_font::local::NextFontLocalResolvePlugin,
     next_import_map::{get_next_edge_and_server_fallback_import_map, get_next_server_import_map},
@@ -1009,15 +1008,6 @@ pub async fn get_server_module_options_context(
     Ok(module_options_context)
 }
 
-#[turbo_tasks::function]
-pub fn get_server_runtime_entries(
-    _ty: ServerContextType,
-    _mode: Vc<NextMode>,
-) -> Vc<RuntimeEntries> {
-    let runtime_entries = vec![];
-    Vc::cell(runtime_entries)
-}
-
 #[derive(Clone, Debug, PartialEq, Eq, Hash, TaskInput, TraceRawVcs, Serialize, Deserialize)]
 pub struct ServerChunkingContextOptions {
     pub mode: Vc<NextMode>,