Turbopack: pass current Node.js version from JS side instead of invoking node (#80949)

mischnic · web-flow · commit c2be57cc1d7a · 2025-06-27T08:27:16.000+02:00
diff --git a/crates/napi/src/next_api/project.rs b/crates/napi/src/next_api/project.rs
@@ -156,6 +156,9 @@ pub struct NapiProjectOptions {
     /// local names for variables, functions etc., which can be useful for
     /// debugging/profiling purposes.
     pub no_mangling: bool,
+
+    /// The version of Node.js that is available/currently running.
+    pub current_node_js_version: RcStr,
 }
 
 /// [NapiProjectOptions] with all fields optional.
@@ -261,6 +264,7 @@ impl From<NapiProjectOptions> for ProjectOptions {
             preview_props: val.preview_props.into(),
             browserslist_query: val.browserslist_query,
             no_mangling: val.no_mangling,
+            current_node_js_version: val.current_node_js_version,
         }
     }
 }
diff --git a/crates/next-api/benches/hmr.rs b/crates/next-api/benches/hmr.rs
@@ -1,5 +1,4 @@
 use std::{
-    env,
     fs::{create_dir_all, write},
     mem::forget,
     path::{Path, PathBuf},
@@ -182,10 +181,7 @@ impl HmrBenchmark {
                 project_path: RcStr::from(project_path.clone()),
                 next_config: load_next_config(),
                 js_config: RcStr::from("{}"),
-                env: vec![(
-                    RcStr::from("PATH"),
-                    RcStr::from(env::var("PATH").unwrap_or_default()),
-                )],
+                env: vec![],
                 define_env: DefineEnv {
                     client: vec![],
                     edge: vec![],
@@ -205,6 +201,7 @@ impl HmrBenchmark {
                 },
                 browserslist_query: RcStr::from("last 2 versions"),
                 no_mangling: false,
+                current_node_js_version: RcStr::from("18.0.0"),
             };
 
             container.initialize(options).await?;
diff --git a/crates/next-api/src/project.rs b/crates/next-api/src/project.rs
@@ -51,6 +51,7 @@ use turbopack_core::{
     compile_time_info::CompileTimeInfo,
     context::AssetContext,
     diagnostics::DiagnosticExt,
+    environment::NodeJsVersion,
     file_source::FileSource,
     ident::Layer,
     issue::{
@@ -186,6 +187,9 @@ pub struct ProjectOptions {
     /// local names for variables, functions etc., which can be useful for
     /// debugging/profiling purposes.
     pub no_mangling: bool,
+
+    /// The version of Node.js that is available/currently running.
+    pub current_node_js_version: RcStr,
 }
 
 #[derive(
@@ -442,6 +446,7 @@ impl ProjectContainer {
         let preview_props;
         let browserslist_query;
         let no_mangling;
+        let current_node_js_version;
         {
             let options = self.options_state.get();
             let options = options
@@ -464,7 +469,8 @@ impl ProjectContainer {
             build_id = options.build_id.clone();
             preview_props = options.preview_props.clone();
             browserslist_query = options.browserslist_query.clone();
-            no_mangling = options.no_mangling
+            no_mangling = options.no_mangling;
+            current_node_js_version = options.current_node_js_version.clone();
         }
 
         let dist_dir = next_config
@@ -493,6 +499,7 @@ impl ProjectContainer {
             encryption_key,
             preview_props,
             no_mangling,
+            current_node_js_version,
         }
         .cell())
     }
@@ -570,6 +577,8 @@ pub struct Project {
     /// local names for variables, functions etc., which can be useful for
     /// debugging/profiling purposes.
     no_mangling: bool,
+
+    current_node_js_version: RcStr,
 }
 
 #[turbo_tasks::value]
@@ -737,6 +746,11 @@ impl Project {
         *self.env
     }
 
+    #[turbo_tasks::function]
+    pub(super) fn current_node_js_version(&self) -> Vc<NodeJsVersion> {
+        NodeJsVersion::Static(ResolvedVc::cell(self.current_node_js_version.clone())).cell()
+    }
+
     #[turbo_tasks::function]
     pub(super) fn next_config(&self) -> Vc<NextConfig> {
         *self.next_config
@@ -974,10 +988,10 @@ impl Project {
     pub(super) async fn server_compile_time_info(self: Vc<Self>) -> Result<Vc<CompileTimeInfo>> {
         let this = self.await?;
         Ok(get_server_compile_time_info(
-            self.env(),
-            this.define_env.nodejs(),
             // `/ROOT` corresponds to `[project]/`, so we need exactly the `path` part.
             format!("/ROOT/{}", self.project_path().await?.path).into(),
+            this.define_env.nodejs(),
+            self.current_node_js_version(),
         ))
     }
 
@@ -987,7 +1001,7 @@ impl Project {
         Ok(get_edge_compile_time_info(
             self.project_path(),
             this.define_env.edge(),
-            self.env(),
+            self.current_node_js_version(),
         ))
     }
 
diff --git a/crates/next-build-test/src/main.rs b/crates/next-build-test/src/main.rs
@@ -166,6 +166,7 @@ fn main() {
                                      Safari versions, last 1 Edge versions"
                     .into(),
                 no_mangling: false,
+                current_node_js_version: "18.0.0".into(),
             };
 
             let json = serde_json::to_string_pretty(&options).unwrap();
diff --git a/crates/next-core/src/next_edge/context.rs b/crates/next-core/src/next_edge/context.rs
@@ -1,7 +1,7 @@
 use anyhow::Result;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{FxIndexMap, OptionVcExt, ResolvedVc, Vc};
-use turbo_tasks_env::{EnvMap, ProcessEnv};
+use turbo_tasks_env::EnvMap;
 use turbo_tasks_fs::FileSystemPath;
 use turbopack::{css::chunk::CssChunkType, resolve_options_context::ResolveOptionsContext};
 use turbopack_browser::BrowserChunkingContext;
@@ -83,16 +83,11 @@ async fn next_edge_free_vars(
 pub async fn get_edge_compile_time_info(
     project_path: Vc<FileSystemPath>,
     define_env: Vc<EnvMap>,
-    process_env: Vc<Box<dyn ProcessEnv>>,
+    node_version: ResolvedVc<NodeJsVersion>,
 ) -> Result<Vc<CompileTimeInfo>> {
     CompileTimeInfo::builder(
         Environment::new(ExecutionEnvironment::EdgeWorker(
-            EdgeWorkerEnvironment {
-                node_version: NodeJsVersion::resolved_cell(NodeJsVersion::Current(
-                    process_env.to_resolved().await?,
-                )),
-            }
-            .resolved_cell(),
+            EdgeWorkerEnvironment { node_version }.resolved_cell(),
         ))
         .to_resolved()
         .await?,
diff --git a/crates/next-core/src/next_server/context.rs b/crates/next-core/src/next_server/context.rs
@@ -3,7 +3,7 @@ use std::iter::once;
 use anyhow::{Result, bail};
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{FxIndexMap, OptionVcExt, ResolvedVc, TaskInput, Vc};
-use turbo_tasks_env::{EnvMap, ProcessEnv};
+use turbo_tasks_env::EnvMap;
 use turbo_tasks_fs::FileSystemPath;
 use turbopack::{
     css::chunk::CssChunkType,
@@ -381,17 +381,15 @@ async fn next_server_free_vars(define_env: Vc<EnvMap>) -> Result<Vc<FreeVarRefer
 
 #[turbo_tasks::function]
 pub async fn get_server_compile_time_info(
-    process_env: Vc<Box<dyn ProcessEnv>>,
-    define_env: Vc<EnvMap>,
     cwd: RcStr,
+    define_env: Vc<EnvMap>,
+    node_version: ResolvedVc<NodeJsVersion>,
 ) -> Result<Vc<CompileTimeInfo>> {
     CompileTimeInfo::builder(
         Environment::new(ExecutionEnvironment::NodeJsLambda(
             NodeJsEnvironment {
                 compile_target: CompileTarget::current().to_resolved().await?,
-                node_version: NodeJsVersion::resolved_cell(NodeJsVersion::Current(
-                    process_env.to_resolved().await?,
-                )),
+                node_version,
                 cwd: ResolvedVc::cell(Some(cwd)),
             }
             .resolved_cell(),
diff --git a/packages/next/src/build/swc/generated-native.d.ts b/packages/next/src/build/swc/generated-native.d.ts
@@ -136,6 +136,8 @@ export interface NapiProjectOptions {
    * debugging/profiling purposes.
    */
   noMangling: boolean
+  /** The version of Node.js that is available/currently running. */
+  currentNodeJsVersion: RcStr
 }
 /** [NapiProjectOptions] with all fields optional. */
 export interface NapiPartialProjectOptions {
diff --git a/packages/next/src/build/swc/types.ts b/packages/next/src/build/swc/types.ts
@@ -423,6 +423,11 @@ export interface ProjectOptions {
    * debugging/profiling purposes.
    */
   noMangling: boolean
+
+  /**
+   * The version of Node.js that is available/currently running.
+   */
+  currentNodeJsVersion: string
 }
 
 export interface DefineEnv {
diff --git a/packages/next/src/build/turbopack-build/impl.ts b/packages/next/src/build/turbopack-build/impl.ts
@@ -43,6 +43,7 @@ export async function turbopackBuild(): Promise<{
   const rewrites = NextBuildContext.rewrites!
   const appDirOnly = NextBuildContext.appDirOnly!
   const noMangling = NextBuildContext.noMangling!
+  const currentNodeJsVersion = process.versions.node
 
   const startTime = process.hrtime()
   const bindings = await loadBindings(config?.experimental?.useWasmBinary)
@@ -80,6 +81,7 @@ export async function turbopackBuild(): Promise<{
       previewProps,
       browserslistQuery: supportedBrowsers.join(', '),
       noMangling,
+      currentNodeJsVersion,
     },
     {
       persistentCaching,
diff --git a/packages/next/src/server/dev/hot-reloader-turbopack.ts b/packages/next/src/server/dev/hot-reloader-turbopack.ts
@@ -210,6 +210,8 @@ export async function createHotReloaderTurbopack(
     'last 1 Chrome versions, last 1 Firefox versions, last 1 Safari versions, last 1 Edge versions',
   ]
 
+  const currentNodeJsVersion = process.versions.node
+
   const project = await bindings.turbo.createProject(
     {
       projectPath: projectPath,
@@ -243,6 +245,7 @@ export async function createHotReloaderTurbopack(
       previewProps: opts.fsChecker.prerenderManifest.preview,
       browserslistQuery: supportedBrowsers.join(', '),
       noMangling: false,
+      currentNodeJsVersion,
     },
     {
       persistentCaching: isPersistentCachingEnabled(opts.nextConfig),
diff --git a/test/development/basic/next-rs-api.test.ts b/test/development/basic/next-rs-api.test.ts
@@ -197,9 +197,7 @@ describe('next.rs api', () => {
       '.next'
     )
     project = await bindings.turbo.createProject({
-      env: {
-        PATH: process.env.PATH,
-      },
+      env: {},
       jsConfig: {
         compilerOptions: {},
       },
@@ -233,6 +231,7 @@ describe('next.rs api', () => {
       },
       browserslistQuery: 'last 2 versions',
       noMangling: false,
+      currentNodeJsVersion: '18.0.0',
     })
     projectUpdateSubscription = filterMapAsyncIterator(
       project.updateInfoSubscribe(1000),
diff --git a/turbopack/crates/turbopack-core/src/environment.rs b/turbopack/crates/turbopack-core/src/environment.rs
@@ -3,7 +3,7 @@ use std::{
     str::FromStr,
 };
 
-use anyhow::{Context, Result, anyhow};
+use anyhow::{Context, Result, anyhow, bail};
 use browserslist::Distrib;
 use swc_core::ecma::preset_env::{Version, Versions};
 use turbo_rcstr::{RcStr, rcstr};
@@ -12,7 +12,7 @@ use turbo_tasks_env::ProcessEnv;
 
 use crate::target::CompileTarget;
 
-static DEFAULT_NODEJS_VERSION: &str = "16.0.0";
+static DEFAULT_NODEJS_VERSION: &str = "18.0.0";
 
 #[turbo_tasks::value]
 #[derive(Clone, Copy, Default, Hash, TaskInput, Debug)]
@@ -283,7 +283,8 @@ impl NodeJsEnvironment {
 
         Ok(Vc::cell(Versions {
             node: Some(
-                Version::from_str(&str).map_err(|_| anyhow!("Node.js version parse error"))?,
+                Version::from_str(&str)
+                    .map_err(|_| anyhow!("Failed to parse Node.js version: '{}'", str))?,
             ),
             ..Default::default()
         }))
@@ -303,7 +304,9 @@ impl NodeJsEnvironment {
 
 #[turbo_tasks::value(shared)]
 pub enum NodeJsVersion {
+    /// Use the version of Node.js that is available from the environment (via `node --version`)
     Current(ResolvedVc<Box<dyn ProcessEnv>>),
+    /// Use the specified version of Node.js.
     Static(ResolvedVc<RcStr>),
 }
 
@@ -323,6 +326,9 @@ pub struct BrowserEnvironment {
 
 #[turbo_tasks::value(shared)]
 pub struct EdgeWorkerEnvironment {
+    // This isn't actually the Edge's worker environment, but we have to use some kind of version
+    // for transpiling ECMAScript features. No tool supports Edge Workers as a separate
+    // environment.
     pub node_version: ResolvedVc<NodeJsVersion>,
 }
 
@@ -360,12 +366,30 @@ pub async fn get_current_nodejs_version(env: Vc<Box<dyn ProcessEnv>>) -> Result<
     cmd.stdin(Stdio::piped());
     cmd.stdout(Stdio::piped());
 
-    Ok(Vc::cell(
-        String::from_utf8(cmd.output()?.stdout)?
-            .strip_prefix('v')
-            .context("Version must begin with v")?
-            .strip_suffix('\n')
-            .context("Version must end with \\n")?
-            .into(),
-    ))
+    let output = cmd.output()?;
+
+    if !output.status.success() {
+        bail!(
+            "'node --version' command failed{}{}",
+            output
+                .status
+                .code()
+                .map(|c| format!(" with exit code {c}"))
+                .unwrap_or_default(),
+            String::from_utf8(output.stderr)
+                .map(|stderr| format!(": {stderr}"))
+                .unwrap_or_default()
+        );
+    }
+
+    let version = String::from_utf8(output.stdout)
+        .context("failed to parse 'node --version' output as utf8")?;
+    if let Some(version_number) = version.strip_prefix("v") {
+        Ok(Vc::cell(version_number.trim().into()))
+    } else {
+        bail!(
+            "Expected 'node --version' to return a version starting with 'v', but received: '{}'",
+            version
+        )
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -156,6 +156,9 @@ pub struct NapiProjectOptions {`
`156`	`156`	`/// local names for variables, functions etc., which can be useful for`
`157`	`157`	`/// debugging/profiling purposes.`
`158`	`158`	`pub no_mangling: bool,`
	`159`	`+`
	`160`	`+ /// The version of Node.js that is available/currently running.`
	`161`	`+ pub current_node_js_version: RcStr,`
`159`	`162`	`}`
`160`	`163`
`161`	`164`	`/// [NapiProjectOptions] with all fields optional.`
`@@ -261,6 +264,7 @@ impl From<NapiProjectOptions> for ProjectOptions {`
`261`	`264`	`preview_props: val.preview_props.into(),`
`262`	`265`	`browserslist_query: val.browserslist_query,`
`263`	`266`	`no_mangling: val.no_mangling,`
	`267`	`+ current_node_js_version: val.current_node_js_version,`
`264`	`268`	`}`
`265`	`269`	`}`
`266`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,6 +136,8 @@ export interface NapiProjectOptions {`
`136`	`136`	`* debugging/profiling purposes.`
`137`	`137`	`*/`
`138`	`138`	`noMangling: boolean`
	`139`	`+ /** The version of Node.js that is available/currently running. */`
	`140`	`+ currentNodeJsVersion: RcStr`
`139`	`141`	`}`
`140`	`142`	`/** [NapiProjectOptions] with all fields optional. */`
`141`	`143`	`export interface NapiPartialProjectOptions {`
Original file line number	Diff line number	Diff line change
`@@ -210,6 +210,8 @@ export async function createHotReloaderTurbopack(`
`210`	`210`	`'last 1 Chrome versions, last 1 Firefox versions, last 1 Safari versions, last 1 Edge versions',`
`211`	`211`	`]`
`212`	`212`
	`213`	`+ const currentNodeJsVersion = process.versions.node`
	`214`	`+`
`213`	`215`	`const project = await bindings.turbo.createProject(`
`214`	`216`	`{`
`215`	`217`	`projectPath: projectPath,`
`@@ -243,6 +245,7 @@ export async function createHotReloaderTurbopack(`
`243`	`245`	`previewProps: opts.fsChecker.prerenderManifest.preview,`
`244`	`246`	`browserslistQuery: supportedBrowsers.join(', '),`
`245`	`247`	`noMangling: false,`
	`248`	`+ currentNodeJsVersion,`
`246`	`249`	`},`
`247`	`250`	`{`
`248`	`251`	`persistentCaching: isPersistentCachingEnabled(opts.nextConfig),`