feat(nextjs): Use not: foreign condition in turbopack loaders (#19502)

Just came across
https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#advanced-webpack-loader-conditions
when researching for another issue.

We can match the turbopack loaders more strictly to only run on user
code. Potentially reduces build times.

Closes #19504 (added automatically)

Author: chargome

packages/nextjs/src/config/turbopack/generateValueInjectionRules.ts

@@ -2,7 +2,7 @@ import * as path from 'path';
 import type { VercelCronsConfig } from '../../common/types';
 import type { RouteManifest } from '../manifest/types';
 import type { JSONValue, TurbopackMatcherWithRule } from '../types';
-import { getPackageModules } from '../util';
+import { getPackageModules, supportsTurbopackRuleCondition } from '../util';
 
 /**
  * Generate the value injection rules for client and server in turbopack config.
@@ -50,11 +50,16 @@ export function generateValueInjectionRules({
     serverValues = { ...serverValues, ...isomorphicValues };
   }
 
+  const hasConditionSupport = nextJsVersion ? supportsTurbopackRuleCondition(nextJsVersion) : false;
+
   // Client value injection
   if (Object.keys(clientValues).length > 0) {
     rules.push({
       matcher: '**/instrumentation-client.*',
       rule: {
+        // Only run on user code, not node_modules or Next.js internals
+        // condition field is only supported in Next.js 16+
+        ...(hasConditionSupport ? { condition: { not: 'foreign' } } : {}),
         loaders: [
           {
             loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),
@@ -72,6 +77,9 @@ export function generateValueInjectionRules({
     rules.push({
       matcher: '**/instrumentation.*',
       rule: {
+        // Only run on user code, not node_modules or Next.js internals
+        // condition field is only supported in Next.js 16+
+        ...(hasConditionSupport ? { condition: { not: 'foreign' } } : {}),
         loaders: [
           {
             loader: path.resolve(__dirname, '..', 'loaders', 'valueInjectionLoader.js'),

packages/nextjs/src/config/types.ts

@@ -849,6 +849,17 @@ type TurbopackRuleCondition = {
   path: string | RegExp;
 };
 
+// Condition used to filter when a loader rule applies.
+// Supports built-in string conditions ('foreign', 'browser', 'development', 'production', 'node', 'edge-light')
+// and boolean operators matching the Turbopack advanced condition syntax.
+type TurbopackRuleConditionFilter =
+  | string
+  | { not: TurbopackRuleConditionFilter }
+  | { all: TurbopackRuleConditionFilter[] }
+  | { any: TurbopackRuleConditionFilter[] }
+  | { path: string | RegExp }
+  | { content: RegExp };
+
 export type TurbopackRuleConfigItemOrShortcut = TurbopackLoaderItem[] | TurbopackRuleConfigItem;
 
 export type TurbopackMatcherWithRule = {
@@ -859,6 +870,7 @@ export type TurbopackMatcherWithRule = {
 type TurbopackRuleConfigItemOptions = {
   loaders: TurbopackLoaderItem[];
   as?: string;
+  condition?: TurbopackRuleConditionFilter;
 };
 
 type TurbopackRuleConfigItem =

packages/nextjs/src/config/util.ts

@@ -67,6 +67,27 @@ export function supportsProductionCompileHook(version: string): boolean {
   return false;
 }
 
+/**
+ * Checks if the current Next.js version supports the `condition` field in Turbopack rules.
+ * This field was introduced in Next.js 16.
+ *
+ * @param version - version string to check.
+ * @returns true if Next.js version is 16 or higher
+ */
+export function supportsTurbopackRuleCondition(version: string): boolean {
+  if (!version) {
+    return false;
+  }
+
+  const { major } = parseSemver(version);
+
+  if (major === undefined) {
+    return false;
+  }
+
+  return major >= 16;
+}
+
 /**
  * Checks if the current Next.js version supports native debug ids for turbopack.
  * This feature was first introduced in Next.js v15.6.0-canary.36 and marked stable in Next.js v16

packages/nextjs/test/config/turbopack/constructTurbopackConfig.test.ts

@@ -874,6 +874,68 @@ describe('constructTurbopackConfig', () => {
   });
 });
 
+describe('condition field version gating', () => {
+  it('should include condition field for Next.js 16+', () => {
+    const userNextConfig: NextConfigObject = {};
+
+    const result = constructTurbopackConfig({
+      userNextConfig,
+      nextJsVersion: '16.0.0',
+    });
+
+    const serverRule = result.rules!['**/instrumentation.*'] as { condition?: unknown; loaders: unknown[] };
+    expect(serverRule.condition).toEqual({ not: 'foreign' });
+  });
+
+  it('should include condition field for Next.js 17+', () => {
+    const userNextConfig: NextConfigObject = {};
+
+    const result = constructTurbopackConfig({
+      userNextConfig,
+      routeManifest: { dynamicRoutes: [], staticRoutes: [], isrRoutes: [] },
+      nextJsVersion: '17.0.0',
+    });
+
+    const clientRule = result.rules!['**/instrumentation-client.*'] as { condition?: unknown; loaders: unknown[] };
+    const serverRule = result.rules!['**/instrumentation.*'] as { condition?: unknown; loaders: unknown[] };
+    expect(clientRule.condition).toEqual({ not: 'foreign' });
+    expect(serverRule.condition).toEqual({ not: 'foreign' });
+  });
+
+  it('should not include condition field for Next.js 15.x', () => {
+    const userNextConfig: NextConfigObject = {};
+
+    const result = constructTurbopackConfig({
+      userNextConfig,
+      nextJsVersion: '15.4.1',
+    });
+
+    const serverRule = result.rules!['**/instrumentation.*'] as { condition?: unknown; loaders: unknown[] };
+    expect(serverRule).not.toHaveProperty('condition');
+  });
+
+  it('should not include condition field for Next.js 14.x', () => {
+    const userNextConfig: NextConfigObject = {};
+
+    const result = constructTurbopackConfig({
+      userNextConfig,
+      nextJsVersion: '14.2.0',
+    });
+
+    const serverRule = result.rules!['**/instrumentation.*'] as { condition?: unknown; loaders: unknown[] };
+    expect(serverRule).not.toHaveProperty('condition');
+  });
+
+  it('should not include condition field when nextJsVersion is undefined', () => {
+    const userNextConfig: NextConfigObject = {};
+
+    const result = constructTurbopackConfig({ userNextConfig });
+
+    const serverRule = result.rules!['**/instrumentation.*'] as { condition?: unknown; loaders: unknown[] };
+    expect(serverRule).not.toHaveProperty('condition');
+  });
+});
+
 describe('safelyAddTurbopackRule', () => {
   const mockRule = {
     loaders: [

packages/nextjs/test/config/util.test.ts

@@ -334,4 +334,39 @@ describe('util', () => {
       expect(util.detectActiveBundler()).toBe('webpack');
     });
   });
+
+  describe('supportsTurbopackRuleCondition', () => {
+    describe('supported versions (returns true)', () => {
+      it.each([
+        ['16.0.0', 'Next.js 16.0.0'],
+        ['16.1.0', 'Next.js 16.1.0'],
+        ['17.0.0', 'Next.js 17.0.0'],
+        ['20.0.0', 'Next.js 20.0.0'],
+      ])('returns true for %s (%s)', version => {
+        expect(util.supportsTurbopackRuleCondition(version)).toBe(true);
+      });
+    });
+
+    describe('unsupported versions (returns false)', () => {
+      it.each([
+        ['15.9.9', 'Next.js 15.9.9'],
+        ['15.4.1', 'Next.js 15.4.1 (min Turbopack version)'],
+        ['15.0.0', 'Next.js 15.0.0'],
+        ['14.2.0', 'Next.js 14.2.0'],
+        ['13.0.0', 'Next.js 13.0.0'],
+      ])('returns false for %s (%s)', version => {
+        expect(util.supportsTurbopackRuleCondition(version)).toBe(false);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('returns false for empty string', () => {
+        expect(util.supportsTurbopackRuleCondition('')).toBe(false);
+      });
+
+      it('returns false for invalid version string', () => {
+        expect(util.supportsTurbopackRuleCondition('invalid')).toBe(false);
+      });
+    });
+  });
 });