gate behind has_next_support

mischnic · mischnic · commit 82e0f2c05905 · 2026-01-31T00:07:41.000+01:00
diff --git a/crates/next-api/src/project.rs b/crates/next-api/src/project.rs
@@ -1097,8 +1097,13 @@ impl Project {
     }
 
     #[turbo_tasks::function]
-    pub(super) fn client_compile_time_info(&self) -> Vc<CompileTimeInfo> {
-        get_client_compile_time_info(self.browserslist_query.clone(), self.define_env.client())
+    pub(super) async fn client_compile_time_info(self: Vc<Self>) -> Result<Vc<CompileTimeInfo>> {
+        let this = self.await?;
+        Ok(get_client_compile_time_info(
+            this.browserslist_query.clone(),
+            this.define_env.client(),
+            self.ci_has_next_support(),
+        ))
     }
 
     #[turbo_tasks::function]
@@ -1336,6 +1341,7 @@ impl Project {
             self.project_path(),
             this.define_env.nodejs(),
             self.current_node_js_version(),
+            self.ci_has_next_support(),
         ))
     }
 
@@ -1346,6 +1352,7 @@ impl Project {
             self.project_path().owned().await?,
             this.define_env.edge(),
             self.current_node_js_version(),
+            self.ci_has_next_support(),
         ))
     }
 
diff --git a/crates/next-core/src/next_client/context.rs b/crates/next-core/src/next_client/context.rs
@@ -80,9 +80,15 @@ async fn next_client_defines(define_env: Vc<OptionEnvMap>) -> Result<Vc<CompileT
 }
 
 #[turbo_tasks::function]
-async fn next_client_free_vars(define_env: Vc<OptionEnvMap>) -> Result<Vc<FreeVarReferences>> {
+async fn next_client_free_vars(
+    define_env: Vc<OptionEnvMap>,
+    has_next_support: Vc<bool>,
+) -> Result<Vc<FreeVarReferences>> {
     Ok(free_var_references!(
-        ..free_var_references_with_vercel_system_env_warnings(defines(&*define_env.await?)),
+        ..free_var_references_with_vercel_system_env_warnings(
+            defines(&*define_env.await?),
+            *has_next_support.await?
+        ),
         Buffer = FreeVarReference::EcmaScriptModule {
             request: rcstr!("node:buffer"),
             lookup_path: None,
@@ -101,6 +107,7 @@ async fn next_client_free_vars(define_env: Vc<OptionEnvMap>) -> Result<Vc<FreeVa
 pub async fn get_client_compile_time_info(
     browserslist_query: RcStr,
     define_env: Vc<OptionEnvMap>,
+    has_next_support: Vc<bool>,
 ) -> Result<Vc<CompileTimeInfo>> {
     CompileTimeInfo::builder(
         Environment::new(ExecutionEnvironment::Browser(
@@ -116,7 +123,11 @@ pub async fn get_client_compile_time_info(
         .await?,
     )
     .defines(next_client_defines(define_env).to_resolved().await?)
-    .free_var_references(next_client_free_vars(define_env).to_resolved().await?)
+    .free_var_references(
+        next_client_free_vars(define_env, has_next_support)
+            .to_resolved()
+            .await?,
+    )
     .cell()
     .await
 }
diff --git a/crates/next-core/src/next_edge/context.rs b/crates/next-core/src/next_edge/context.rs
@@ -47,9 +47,13 @@ async fn next_edge_defines(define_env: Vc<OptionEnvMap>) -> Result<Vc<CompileTim
 async fn next_edge_free_vars(
     project_path: FileSystemPath,
     define_env: Vc<OptionEnvMap>,
+    has_next_support: Vc<bool>,
 ) -> Result<Vc<FreeVarReferences>> {
     Ok(free_var_references!(
-        ..free_var_references_with_vercel_system_env_warnings(defines(&*define_env.await?)),
+        ..free_var_references_with_vercel_system_env_warnings(
+            defines(&*define_env.await?),
+            *has_next_support.await?
+        ),
         Buffer = FreeVarReference::EcmaScriptModule {
             request: rcstr!("buffer"),
             lookup_path: Some(project_path),
@@ -64,6 +68,7 @@ pub async fn get_edge_compile_time_info(
     project_path: FileSystemPath,
     define_env: Vc<OptionEnvMap>,
     node_version: ResolvedVc<NodeJsVersion>,
+    has_next_support: Vc<bool>,
 ) -> Result<Vc<CompileTimeInfo>> {
     CompileTimeInfo::builder(
         Environment::new(ExecutionEnvironment::EdgeWorker(
@@ -74,7 +79,7 @@ pub async fn get_edge_compile_time_info(
     )
     .defines(next_edge_defines(define_env).to_resolved().await?)
     .free_var_references(
-        next_edge_free_vars(project_path, define_env)
+        next_edge_free_vars(project_path, define_env, has_next_support)
             .to_resolved()
             .await?,
     )
diff --git a/crates/next-core/src/next_server/context.rs b/crates/next-core/src/next_server/context.rs
@@ -355,15 +355,23 @@ async fn next_server_defines(define_env: Vc<OptionEnvMap>) -> Result<Vc<CompileT
 }
 
 #[turbo_tasks::function]
-async fn next_server_free_vars(define_env: Vc<OptionEnvMap>) -> Result<Vc<FreeVarReferences>> {
-    Ok(free_var_references_with_vercel_system_env_warnings(defines(&*define_env.await?)).cell())
+async fn next_server_free_vars(
+    define_env: Vc<OptionEnvMap>,
+    has_next_support: Vc<bool>,
+) -> Result<Vc<FreeVarReferences>> {
+    Ok(free_var_references_with_vercel_system_env_warnings(
+        defines(&*define_env.await?),
+        *has_next_support.await?,
+    )
+    .cell())
 }
 
 #[turbo_tasks::function]
 pub async fn get_server_compile_time_info(
     cwd: Vc<FileSystemPath>,
     define_env: Vc<OptionEnvMap>,
     node_version: ResolvedVc<NodeJsVersion>,
+    has_next_support: Vc<bool>,
 ) -> Result<Vc<CompileTimeInfo>> {
     CompileTimeInfo::builder(
         Environment::new(ExecutionEnvironment::NodeJsLambda(
@@ -378,7 +386,11 @@ pub async fn get_server_compile_time_info(
         .await?,
     )
     .defines(next_server_defines(define_env).to_resolved().await?)
-    .free_var_references(next_server_free_vars(define_env).to_resolved().await?)
+    .free_var_references(
+        next_server_free_vars(define_env, has_next_support)
+            .to_resolved()
+            .await?,
+    )
     .cell()
     .await
 }
diff --git a/crates/next-core/src/util.rs b/crates/next-core/src/util.rs
@@ -5,7 +5,7 @@ use bincode::{Decode, Encode};
 use next_taskless::{expand_next_js_template, expand_next_js_template_no_imports};
 use serde::{Deserialize, de::DeserializeOwned};
 use turbo_rcstr::{RcStr, rcstr};
-use turbo_tasks::{FxIndexMap, NonLocalValue, TaskInput, Vc, trace::TraceRawVcs};
+use turbo_tasks::{FxIndexMap, NonLocalValue, TaskInput, Vc, fxindexset, trace::TraceRawVcs};
 use turbo_tasks_fs::{File, FileContent, FileJsonContent, FileSystem, FileSystemPath, rope::Rope};
 use turbopack::module_options::RuleCondition;
 use turbopack_core::{
@@ -62,9 +62,10 @@ pub fn defines(define_env: &FxIndexMap<RcStr, Option<RcStr>>) -> CompileTimeDefi
     CompileTimeDefines(defines)
 }
 
-/// Emits warnings or errors when inlining frequently changing system env vars
+/// Emits warnings or errors when inlining frequently changing Vercel system env vars
 pub fn free_var_references_with_vercel_system_env_warnings(
     defines: CompileTimeDefines,
+    has_next_support: bool,
 ) -> FreeVarReferences {
     // constant:
     //      VERCEL
@@ -98,74 +99,104 @@ pub fn free_var_references_with_vercel_system_env_warnings(
     //      VERCEL_GIT_COMMIT_AUTHOR_NAME
     //      VERCEL_GIT_PREVIOUS_SHA
 
-    let should_error = std::env::var("NEXT_TURBOPACK_SYSTEM_ENV_ERROR")
-        .ok()
-        .is_some_and(|v| !v.is_empty());
+    let entries = defines
+        .0
+        .into_iter()
+        .map(|(k, value)| (k, FreeVarReference::Value(value)));
+
+    let entries = if has_next_support {
+        let should_error = std::env::var("NEXT_TURBOPACK_SYSTEM_ENV_ERROR")
+            .ok()
+            .is_some_and(|v| !v.is_empty());
+
+        fn wrap_report_next_public_usage(
+            public_env_var: &str,
+            inner: Option<Box<FreeVarReference>>,
+            should_error: bool,
+        ) -> FreeVarReference {
+            let message = match public_env_var {
+                "NEXT_DEPLOYMENT_ID" | "VERCEL_DEPLOYMENT_ID" => {
+                    rcstr!(
+                        "The deployment id is being inlined. Use process.env.NEXT_DEPLOYMENT_ID \
+                         instead to access the same value without inlining, for faster deploy \
+                         times and better browser client-side caching."
+                    )
+                }
+                _ => format!(
+                    "A system environment variable is being inlined. This variable changes on \
+                     every deployment, causing slower deploy times and worse browser client-side \
+                     caching. For server-side code, replace with process.env.{} and for browser \
+                     code, try to remove it.",
+                    public_env_var.strip_prefix("NEXT_PUBLIC_").unwrap(),
+                )
+                .into(),
+            };
+            FreeVarReference::ReportUsage {
+                message,
+                severity: if should_error {
+                    IssueSeverity::Error
+                } else {
+                    IssueSeverity::Warning
+                },
+                inner,
+            }
+        }
 
-    FreeVarReferences(
-        defines
-            .0
-            .into_iter()
+        let mut list = fxindexset!(
+            "NEXT_PUBLIC_NEXT_DEPLOYMENT_ID",
+            "NEXT_PUBLIC_VERCEL_BRANCH_URL",
+            "NEXT_PUBLIC_VERCEL_DEPLOYMENT_ID",
+            "NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_LOGIN",
+            "NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_NAME",
+            "NEXT_PUBLIC_VERCEL_GIT_COMMIT_MESSAGE",
+            "NEXT_PUBLIC_VERCEL_GIT_COMMIT_REF",
+            "NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA",
+            "NEXT_PUBLIC_VERCEL_GIT_PREVIOUS_SHA",
+            "NEXT_PUBLIC_VERCEL_GIT_PULL_REQUEST_ID",
+            "NEXT_PUBLIC_VERCEL_OIDC_TOKEN",
+            "NEXT_PUBLIC_VERCEL_URL",
+        );
+
+        let mut entries: FxIndexMap<_, _> = entries
             .map(|(k, value)| {
-                const LIST: [&str; 12] = [
-                    "NEXT_DEPLOYMENT_ID",
-                    "VERCEL_BRANCH_URL",
-                    "VERCEL_DEPLOYMENT_ID",
-                    "VERCEL_GIT_COMMIT_AUTHOR_LOGIN",
-                    "VERCEL_GIT_COMMIT_AUTHOR_NAME",
-                    "VERCEL_GIT_COMMIT_MESSAGE",
-                    "VERCEL_GIT_COMMIT_REF",
-                    "VERCEL_GIT_COMMIT_SHA",
-                    "VERCEL_GIT_PREVIOUS_SHA",
-                    "VERCEL_GIT_PULL_REQUEST_ID",
-                    "VERCEL_OIDC_TOKEN",
-                    "VERCEL_URL",
-                ];
-
                 let value = if let &[
                     DefinableNameSegment::Name(a),
                     DefinableNameSegment::Name(b),
-                    DefinableNameSegment::Name(c),
+                    DefinableNameSegment::Name(public_env_var),
                 ] = &&*k
                     && a == "process"
                     && b == "env"
-                    && let Some(env_var) = c.strip_prefix("NEXT_PUBLIC_")
-                    && LIST.binary_search(&env_var).is_ok()
+                    && list.swap_remove(&**public_env_var)
                 {
-                    let message = match &**c {
-                        "NEXT_PUBLIC_NEXT_DEPLOYMENT_ID" | "NEXT_PUBLIC_VERCEL_DEPLOYMENT_ID" => {
-                            rcstr!(
-                                "The deployment id is being inlined. Use \
-                                 process.env.NEXT_DEPLOYMENT_ID instead to access the same value \
-                                 without inlining, for faster deploy times and better browser \
-                                 client-side caching."
-                            )
-                        }
-                        _ => format!(
-                            "A system environment variable is being inlined. This variable \
-                             changes on every deployment, causing slower deploy times and worse \
-                             browser client-side caching. For server-side code, replace with \
-                             process.env.{} and for browser code, try to remove it.",
-                            env_var,
-                        )
-                        .into(),
-                    };
-                    FreeVarReference::ReportUsage {
-                        message,
-                        severity: if should_error {
-                            IssueSeverity::Error
-                        } else {
-                            IssueSeverity::Warning
-                        },
-                        inner: Some(Box::new(FreeVarReference::Value(value))),
-                    }
+                    wrap_report_next_public_usage(
+                        public_env_var,
+                        Some(Box::new(value)),
+                        should_error,
+                    )
                 } else {
-                    FreeVarReference::Value(value)
+                    value
                 };
                 (k, value)
             })
-            .collect(),
-    )
+            .collect();
+
+        // For the remaining ones, still add a warning, but without replacement
+        for public_env_var in list {
+            entries.insert(
+                vec![
+                    rcstr!("process").into(),
+                    rcstr!("env").into(),
+                    DefinableNameSegment::Name(public_env_var.into()),
+                ],
+                wrap_report_next_public_usage(public_env_var, None, should_error),
+            );
+        }
+        entries
+    } else {
+        entries.collect()
+    };
+
+    FreeVarReferences(entries)
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, TaskInput, TraceRawVcs, Encode, Decode)]
diff --git a/packages/next/src/lib/static-env.ts b/packages/next/src/lib/static-env.ts
@@ -22,52 +22,6 @@ function errorIfEnvConflicted(
  */
 export function getNextPublicEnvironmentVariables() {
   const defineEnv: [string, string | undefined][] = []
-
-  process.env.NEXT_PUBLIC_VERCEL = process.env.NEXT_PUBLIC_VERCEL || ''
-  process.env.NEXT_PUBLIC_CI = process.env.NEXT_PUBLIC_CI || ''
-  process.env.NEXT_PUBLIC_VERCEL_PROJECT_PRODUCTION_URL =
-    process.env.NEXT_PUBLIC_VERCEL_PROJECT_PRODUCTION_URL || ''
-  process.env.NEXT_PUBLIC_VERCEL_REGION =
-    process.env.NEXT_PUBLIC_VERCEL_REGION || ''
-  process.env.NEXT_PUBLIC_VERCEL_SKEW_PROTECTION_ENABLED =
-    process.env.NEXT_PUBLIC_VERCEL_SKEW_PROTECTION_ENABLED || ''
-  process.env.NEXT_PUBLIC_VERCEL_AUTOMATION_BYPASS_SECRET =
-    process.env.NEXT_PUBLIC_VERCEL_AUTOMATION_BYPASS_SECRET || ''
-  process.env.NEXT_PUBLIC_VERCEL_PROJECT_ID =
-    process.env.NEXT_PUBLIC_VERCEL_PROJECT_ID || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_PROVIDER =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_PROVIDER || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_SLUG =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_SLUG || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_OWNER =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_OWNER || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_ID =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_REPO_ID || ''
-  process.env.NEXT_PUBLIC_VERCEL_ENV = process.env.NEXT_PUBLIC_VERCEL_ENV || ''
-  process.env.NEXT_PUBLIC_VERCEL_TARGET_ENV =
-    process.env.NEXT_PUBLIC_VERCEL_TARGET_ENV || ''
-  process.env.NEXT_PUBLIC_VERCEL_BRANCH_URL =
-    process.env.NEXT_PUBLIC_VERCEL_BRANCH_URL || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_REF =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_REF || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_PULL_REQUEST_ID =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_PULL_REQUEST_ID || ''
-  process.env.NEXT_PUBLIC_VERCEL_URL = process.env.NEXT_PUBLIC_VERCEL_URL || ''
-  process.env.NEXT_PUBLIC_VERCEL_DEPLOYMENT_ID =
-    process.env.NEXT_PUBLIC_VERCEL_DEPLOYMENT_ID || ''
-  process.env.NEXT_PUBLIC_VERCEL_OIDC_TOKEN =
-    process.env.NEXT_PUBLIC_VERCEL_OIDC_TOKEN || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_MESSAGE =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_MESSAGE || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_LOGIN =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_LOGIN || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_NAME =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_COMMIT_AUTHOR_NAME || ''
-  process.env.NEXT_PUBLIC_VERCEL_GIT_PREVIOUS_SHA =
-    process.env.NEXT_PUBLIC_VERCEL_GIT_PREVIOUS_SHA || ''
-
   for (const key in process.env) {
     if (key.startsWith('NEXT_PUBLIC_')) {
       const value = process.env[key]
