@nx/webpack 24.0.0-pr.37405.acdaf31 → 24.0.0-rc.0

package/dist/src/migrations/update-24-0-0/remove-deprecated-executors.md

@@ -0,0 +1,92 @@
+#### Convert `@nx/webpack` build and dev-server targets to inferred tasks
+
+Nx 24 removes the `@nx/webpack:webpack` and `@nx/webpack:dev-server` executors and their `@nrwl` aliases. The migration registers `@nx/webpack/plugin` in `nx.json` and converts the targets that use those executors to inferred tasks. It moves the executor options into `webpack.config.*`. A target with nothing left to override is removed from project configuration. When several projects share the same remaining options, those options move to a `targetDefaults` entry scoped to the plugin. `targetDefaults` entries keyed by a removed executor are removed once no target uses that executor.
+
+The migration lists the targets the converter cannot convert safely. In agentic runs, an AI prompt finishes them and validates the project graph.
+
+The `@nx/webpack:ssr-dev-server` executor stays.
+
+#### Sample code changes
+
+The example shows the `build` target. Its options move into `webpack.config.*`, so only the configuration names stay on the target.
+
+##### Before
+
+```json title="apps/app1/project.json"
+{
+  "name": "app1",
+  "targets": {
+    "build": {
+      "executor": "@nx/webpack:webpack",
+      "options": {
+        "webpackConfig": "apps/app1/webpack.config.js",
+        "outputPath": "dist/apps/app1",
+        "index": "apps/app1/src/index.html",
+        "main": "apps/app1/src/main.tsx",
+        "tsConfig": "apps/app1/tsconfig.app.json",
+        "assets": ["apps/app1/src/favicon.ico", "apps/app1/src/assets"],
+        "styles": ["apps/app1/src/styles.scss"],
+        "scripts": [],
+        "compiler": "babel",
+        "baseHref": "/"
+      },
+      "configurations": {
+        "development": {
+          "extractLicenses": false,
+          "optimization": false,
+          "sourceMap": true,
+          "vendorChunk": true
+        },
+        "production": {
+          "fileReplacements": [
+            {
+              "replace": "apps/app1/src/environments/environment.ts",
+              "with": "apps/app1/src/environments/environment.prod.ts"
+            }
+          ],
+          "optimization": true,
+          "outputHashing": "all",
+          "sourceMap": false,
+          "namedChunks": false,
+          "extractLicenses": true,
+          "vendorChunk": false
+        }
+      },
+      "defaultConfiguration": "production"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="apps/app1/project.json"
+{
+  "name": "app1",
+  "targets": {
+    "build": {
+      "configurations": {
+        "development": {},
+        "production": {}
+      },
+      "defaultConfiguration": "production"
+    }
+  }
+}
+```
+
+```json title="nx.json"
+{
+  "plugins": [
+    {
+      "plugin": "@nx/webpack/plugin",
+      "options": {
+        "buildTargetName": "build",
+        "previewTargetName": "preview",
+        "serveStaticTargetName": "serve-static",
+        "serveTargetName": "serve"
+      }
+    }
+  ]
+}
+```

package/dist/src/plugins/nx-webpack-plugin/lib/normalize-options.d.ts

@@ -1,4 +1,10 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { type Target } from '@nx/devkit';
 import { AssetGlobPattern, FileReplacement, NormalizedNxAppWebpackPluginOptions, NxAppWebpackPluginOptions } from '../nx-app-webpack-plugin-options';
+export declare const webpackExecutorContext: AsyncLocalStorage<{
+    options: Partial<NxAppWebpackPluginOptions>;
+    target: Target;
+}>;
 export declare function normalizeOptions(options: NxAppWebpackPluginOptions): NormalizedNxAppWebpackPluginOptions;
 export declare function normalizeAssets(assets: any[], root: string, sourceRoot: string, projectRoot: string, resolveRelativePathsToProjectRoot?: boolean): AssetGlobPattern[];
 export declare function normalizeFileReplacements(root: string, fileReplacements: FileReplacement[]): FileReplacement[];

package/dist/src/plugins/nx-webpack-plugin/lib/normalize-options.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.webpackExecutorContext = void 0;
 exports.normalizeOptions = normalizeOptions;
 exports.normalizeAssets = normalizeAssets;
 exports.normalizeFileReplacements = normalizeFileReplacements;
+const node_async_hooks_1 = require("node:async_hooks");
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/js/internal");
 const fs_1 = require("fs");
 const path_1 = require("path");
+exports.webpackExecutorContext = new node_async_hooks_1.AsyncLocalStorage();
 function normalizeOptions(options) {
     const combinedPluginAndMaybeExecutorOptions = {};
     const isProd = process.env.NODE_ENV === 'production';
     // Since this is invoked by the executor, the graph has already been created and cached.
     const projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    const taskDetailsFromBuildTarget = process.env.NX_BUILD_TARGET
-        ? (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph)
-        : undefined;
+    const executorContext = exports.webpackExecutorContext.getStore();
+    const taskDetailsFromBuildTarget = executorContext?.target ??
+        (process.env.NX_BUILD_TARGET
+            ? (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph)
+            : undefined);
     const projectName = taskDetailsFromBuildTarget
         ? taskDetailsFromBuildTarget.project
         : process.env.NX_TASK_TARGET_PROJECT;
@@ -29,26 +34,15 @@ function normalizeOptions(options) {
     normalizeRelativePaths(projectNode.data.root, options);
     // Merge options from `@nx/webpack:webpack` into plugin options.
     // Options from `@nx/webpack:webpack` take precedence.
-    const originalTargetOptions = targetConfig.options;
-    if (configurationName) {
-        Object.assign(originalTargetOptions, targetConfig.configurations?.[configurationName]);
-    }
-    // This could be called from dev-server which means we need to read `buildTarget` to get actual build options.
-    // Otherwise, the options are passed from the `@nx/webpack:webpack` executor.
-    if (originalTargetOptions.buildTarget) {
-        const buildTargetOptions = targetConfig.options;
-        if (configurationName) {
-            Object.assign(buildTargetOptions, targetConfig.configurations?.[configurationName]);
-        }
-        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
-        // executor options take precedence (especially for overriding with CLI args)
-        buildTargetOptions);
-    }
-    else {
-        Object.assign(combinedPluginAndMaybeExecutorOptions, options, 
-        // executor options take precedence (especially for overriding with CLI args)
-        originalTargetOptions);
-    }
+    const targetOptions = {
+        ...targetConfig.options,
+        ...(configurationName
+            ? targetConfig.configurations?.[configurationName]
+            : undefined),
+    };
+    Object.assign(combinedPluginAndMaybeExecutorOptions, options, targetOptions);
+    const executorOptions = executorContext?.options;
+    Object.assign(combinedPluginAndMaybeExecutorOptions, Object.fromEntries(Object.entries(executorOptions ?? {}).filter(([key, value]) => value !== undefined && !isExecutorSchemaDefault(key, value))));
     const sourceRoot = (0, internal_1.getProjectSourceRoot)(projectNode.data);
     if (!combinedPluginAndMaybeExecutorOptions.main) {
         throw new Error(`Missing "main" option for the entry file. Set this option in your Nx webpack plugin.`);
@@ -56,7 +50,7 @@ function normalizeOptions(options) {
     return {
         ...combinedPluginAndMaybeExecutorOptions,
         assets: combinedPluginAndMaybeExecutorOptions.assets
-            ? normalizeAssets(combinedPluginAndMaybeExecutorOptions.assets, devkit_1.workspaceRoot, sourceRoot, projectNode.data.root)
+            ? normalizeAssets(combinedPluginAndMaybeExecutorOptions.assets, devkit_1.workspaceRoot, sourceRoot, projectNode.data.root, executorOptions?.assets === undefined)
             : [],
         baseHref: combinedPluginAndMaybeExecutorOptions.baseHref ?? '/',
         buildLibsFromSource: combinedPluginAndMaybeExecutorOptions.buildLibsFromSource ?? true,
@@ -163,6 +157,17 @@ function normalizeRelativePaths(projectRoot, options) {
         }
     }
 }
+// Executor-style callers pass options with the removed @nx/webpack:webpack
+// schema defaults applied. Those defaults must not override the plugin's own
+// options; target options still apply above.
+const executorSchemaDefaults = {
+    outputFileName: 'main.js',
+    standardWebpackConfigFunction: false,
+    buildLibsFromSource: true,
+};
+function isExecutorSchemaDefault(key, value) {
+    return key in executorSchemaDefaults && executorSchemaDefaults[key] === value;
+}
 function isRelativePath(val) {
     return (typeof val === 'string' &&
         (val.startsWith('./') ||

package/dist/src/plugins/nx-webpack-plugin/nx-app-webpack-plugin.d.ts

@@ -1,5 +1,6 @@
 import type { Compiler } from 'webpack';
 import { NxAppWebpackPluginOptions } from './nx-app-webpack-plugin-options';
+import { READY_SIGNAL_PLUGIN } from '../../utils/dev-server-ready-signal';
 /**
  * This plugin provides features to build Node and Web applications.
  * - TS support (including tsconfig paths)
@@ -12,6 +13,7 @@ import { NxAppWebpackPluginOptions } from './nx-app-webpack-plugin-options';
  */
 export declare class NxAppWebpackPlugin {
     private readonly options;
+    readonly [READY_SIGNAL_PLUGIN] = true;
     constructor(options?: NxAppWebpackPluginOptions);
     apply(compiler: Compiler): void;
 }

package/dist/src/plugins/nx-webpack-plugin/nx-app-webpack-plugin.js

@@ -1,7 +1,9 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NxAppWebpackPlugin = void 0;
 const normalize_options_1 = require("./lib/normalize-options");
+const dev_server_ready_signal_1 = require("../../utils/dev-server-ready-signal");
 /**
  * This plugin provides features to build Node and Web applications.
  * - TS support (including tsconfig paths)
@@ -14,6 +16,7 @@ const normalize_options_1 = require("./lib/normalize-options");
  */
 class NxAppWebpackPlugin {
     constructor(options = {}) {
+        this[_a] = true;
         // If we're building inferred targets, skip normalizing build options.
         if (!global.NX_GRAPH_CREATION) {
             this.options = (0, normalize_options_1.normalizeOptions)(options);
@@ -23,19 +26,32 @@ class NxAppWebpackPlugin {
         // Lazy-required so a generator can load this without the webpack bundler.
         const { applyBaseConfig } = require('./lib/apply-base-config');
         const { applyWebConfig } = require('./lib/apply-web-config');
+        const { applyDevServerReadySignal } = require('../../utils/dev-server-ready-signal');
+        applyDevServerReadySignal(compiler);
         // Defaults to 'web' if not specified to match Webpack's default.
         const target = this.options.target ?? compiler.options.target ?? 'web';
         this.options.outputPath ??= compiler.options.output?.path;
         if (typeof target === 'string') {
             this.options.target = target;
         }
+        // Cypress supplies its own `main` entry and index.html, and license
+        // extraction fails with ENOENT for buildable libraries under component
+        // testing.
+        if (process.env.NX_CYPRESS_COMPONENT_TEST === 'true') {
+            this.options.main = undefined;
+            this.options.generateIndexHtml = false;
+            this.options.extractLicenses = false;
+        }
         applyBaseConfig(this.options, compiler.options, {
             useNormalizedEntry: true,
         });
+        compiler.context = compiler.options.context;
         if (compiler.options.target) {
             this.options.target = compiler.options.target;
         }
-        if (this.options.target === 'web' || this.options.target === 'webworker') {
+        if (this.options.target === 'web' ||
+            this.options.target === 'webworker' ||
+            this.options.ssr) {
             applyWebConfig(this.options, compiler.options, {
                 useNormalizedEntry: true,
             });
@@ -43,3 +59,4 @@ class NxAppWebpackPlugin {
     }
 }
 exports.NxAppWebpackPlugin = NxAppWebpackPlugin;
+_a = dev_server_ready_signal_1.READY_SIGNAL_PLUGIN;

package/dist/src/plugins/plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesV2 = exports.createNodes = void 0;
 const internal_1 = require("@nx/devkit/internal");
+const dev_server_ready_signal_1 = require("../utils/dev-server-ready-signal");
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
@@ -121,6 +122,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             },
         },
     };
+    const devServerReadyWhen = getDevServerReadyWhen(configFilePath, webpackOptions);
     targets[options.serveTargetName] = {
         continuous: true,
         inputs: [...buildInputs],
@@ -129,6 +131,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             cwd: projectRoot,
             env: { NODE_ENV: 'development' },
         },
+        readyWhen: devServerReadyWhen,
         metadata: {
             technologies: ['webpack'],
             description: 'Starts Webpack dev server',
@@ -150,6 +153,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             cwd: projectRoot,
             env: { NODE_ENV: 'production' },
         },
+        readyWhen: devServerReadyWhen,
         metadata: {
             technologies: ['webpack'],
             description: 'Starts Webpack dev server in production mode',
@@ -172,6 +176,7 @@ async function createWebpackTargets(configFilePath, projectRoot, options, contex
             buildTarget: options.buildTargetName,
             spa: true,
         },
+        readyWhen: { signal: true },
     };
     // for `convert-to-inferred` we need to leave the port undefined or the options will not match
     if (webpackConfig.devServer?.port && webpackConfig.devServer?.port !== 4200) {
@@ -255,3 +260,16 @@ function normalizeOptions(options) {
         watchDepsTargetName: 'watch-deps',
     };
 }
+// A dev server whose config loads NxAppWebpackPlugin or NxReadySignalPlugin reports
+// when it listens. Otherwise the check reads the config when the task runs,
+// with the task's env and options, and waits for the dev server's port.
+function getDevServerReadyWhen(configFilePath, configs) {
+    // webpack-cli starts a dev server for each config with devServer. Only the
+    // first one to listen would signal, so several get the check that waits
+    // for each of them.
+    const withDevServer = configs.filter((config) => config.devServer);
+    const signals = withDevServer.length === 1 && (0, dev_server_ready_signal_1.sendsReadySignal)(withDevServer[0]);
+    return signals
+        ? { signal: true }
+        : (0, internal_1.getReadyCheckReadyWhen)('@nx/webpack/ready-check', (0, path_1.basename)(configFilePath));
+}

package/dist/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.js

@@ -59,6 +59,9 @@ async function useLegacyNxPlugin(fn, executorOptions) {
         apply(compiler) {
             compiler.hooks.beforeCompile.tapPromise('NxLegacyAsyncPlugin', () => {
                 return new Promise((resolve) => {
+                    // Legacy functions are typed to take `Configuration` but mutate the
+                    // normalized options in place. From webpack 5.111 the two types
+                    // conflict (`output.copy`), and the public signature can't widen.
                     fn(compiler.options, ctx).then((updated) => {
                         // Merge options back shallowly since it's a fully functional configuration.
                         // Most likely, the user modified the config in place, but this guarantees that updates are applied if users did something like:

package/dist/src/utils/config.d.ts

@@ -1,6 +1,6 @@
-import { ExecutorContext } from '@nx/devkit';
+import type { ExecutorContext } from '@nx/devkit';
 import type { Configuration } from 'webpack';
-import { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
+import type { NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
 export declare const nxWebpackComposablePlugin = "nxWebpackComposablePlugin";
 export declare function isNxWebpackComposablePlugin(a: unknown): a is AsyncNxComposableWebpackPlugin;
 export interface NxWebpackExecutionContext {
@@ -15,20 +15,16 @@ export interface AsyncNxComposableWebpackPlugin {
     (config: Configuration, ctx: NxWebpackExecutionContext): Configuration | Promise<Configuration>;
 }
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function composePlugins(...plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Promise<Configuration>) & {
+export declare function composePlugins(..._plugins: (NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin | Promise<NxComposableWebpackPlugin | AsyncNxComposableWebpackPlugin>)[]): ((config?: Configuration, ctx?: NxWebpackExecutionContext) => Promise<Configuration>) & {
     nxWebpackComposablePlugin: boolean;
 };
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function composePluginsSync(...plugins: NxComposableWebpackPlugin[]): ((config: Configuration, ctx: NxWebpackExecutionContext) => Configuration) & {
+export declare function composePluginsSync(..._plugins: NxComposableWebpackPlugin[]): ((config?: Configuration, ctx?: NxWebpackExecutionContext) => Configuration) & {
     nxWebpackComposablePlugin: boolean;
 };

package/dist/src/utils/config.js

@@ -4,84 +4,31 @@ exports.nxWebpackComposablePlugin = void 0;
 exports.isNxWebpackComposablePlugin = isNxWebpackComposablePlugin;
 exports.composePlugins = composePlugins;
 exports.composePluginsSync = composePluginsSync;
-const devkit_1 = require("@nx/devkit");
-const internal_1 = require("@nx/js/internal");
 const deprecation_1 = require("./deprecation");
-const internal_2 = require("@nx/devkit/internal");
 exports.nxWebpackComposablePlugin = 'nxWebpackComposablePlugin';
 function isNxWebpackComposablePlugin(a) {
     return a?.[exports.nxWebpackComposablePlugin] === true;
 }
+// TODO(v25): remove the inert config-helper stubs in this file.
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function composePlugins(...plugins) {
+function composePlugins(..._plugins) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return Object.assign(async function combined(config, ctx) {
-        // Webpack may be calling us as a standard config function.
-        // Build up Nx context from environment variables.
-        // This is to enable `@nx/webpack/plugin` to work with existing projects.
-        if (ctx['env']) {
-            ensureNxWebpackExecutionContext(ctx);
-            // Build this from scratch since what webpack passes us is the env, not config,
-            // and `withNX()` creates a new config object anyway.
-            config = {};
-        }
-        for (const plugin of plugins) {
-            const fn = await plugin;
-            config = await fn(config, ctx);
-        }
-        return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
+    return Object.assign(async (config = {}, ctx) => {
+        // Only the legacy Nx executor passes a config; CLIs pass (env, argv).
+        return ctx?.context && typeof ctx.context === 'object' ? config : {};
+    }, { [exports.nxWebpackComposablePlugin]: true });
 }
 /**
- * @deprecated Will be removed in Nx v24. Use `NxAppWebpackPlugin` from
- * `@nx/webpack/app-plugin` in a standard webpack config and run
- * `nx g @nx/webpack:convert-to-inferred`. See
- * https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function composePluginsSync(...plugins) {
+function composePluginsSync(..._plugins) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return Object.assign(function combined(config, ctx) {
-        for (const plugin of plugins) {
-            config = plugin(config, ctx);
-        }
-        return config;
-    }, {
-        [exports.nxWebpackComposablePlugin]: true,
-    });
-}
-function ensureNxWebpackExecutionContext(ctx) {
-    const projectName = process.env.NX_TASK_TARGET_PROJECT;
-    const targetName = process.env.NX_TASK_TARGET_TARGET;
-    const configurationName = process.env.NX_TASK_TARGET_CONFIGURATION;
-    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
-    const projectNode = projectGraph.nodes[projectName];
-    ctx.options ??= {
-        root: devkit_1.workspaceRoot,
-        projectRoot: projectNode.data.root,
-        sourceRoot: (0, internal_1.getProjectSourceRoot)(projectNode.data),
-        // These aren't actually needed since NxWebpackPlugin and withNx both support them being undefined.
-        assets: undefined,
-        outputPath: undefined,
-        tsConfig: undefined,
-        outputFileName: undefined,
-        useTsconfigPaths: undefined,
-    };
-    ctx.context ??= {
-        projectName,
-        targetName,
-        configurationName,
-        projectsConfigurations: (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
-        nxJsonConfiguration: (0, internal_2.readNxJsonFromDisk)(devkit_1.workspaceRoot),
-        cwd: process.cwd(),
-        root: devkit_1.workspaceRoot,
-        isVerbose: process.env['NX_VERBOSE_LOGGING'] === 'true',
-        projectGraph,
-    };
+    return Object.assign((config = {}, ctx) => {
+        // Only the legacy Nx executor passes a config; CLIs pass (env, argv).
+        return ctx?.context && typeof ctx.context === 'object' ? config : {};
+    }, { [exports.nxWebpackComposablePlugin]: true });
 }

package/dist/src/utils/deprecation.d.ts

@@ -1,8 +1,5 @@
-export declare const WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/webpack:webpack` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare const WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/webpack:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
-export declare function warnWebpackExecutorDeprecation(): void;
-export declare function warnWebpackDevServerExecutorDeprecation(): void;
-export declare function warnWebpackExecutorGenerating(): void;
-export declare const WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = "The `composePlugins`, `withNx`, and `withWeb` config helpers from `@nx/webpack` are deprecated and will be removed in Nx v24. They produce an Nx-specific config function that only runs under the `@nx/webpack:webpack` executor. Migrate to a standard webpack config that uses `NxAppWebpackPlugin` (from `@nx/webpack/app-plugin`) under the inferred `@nx/webpack/plugin` by running `nx g @nx/webpack:convert-to-inferred`. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.";
+export declare const WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = "The compose config helpers from `@nx/webpack` were removed in Nx v24. The remaining exports are inert compatibility stubs and do not configure builds. Migrate to a standard webpack config using `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`. Follow the config-helper migration instructions generated by `nx migrate`. Executor conversion is a separate migration.";
 export declare function suppressWebpackComposeHelperWarnings<T>(fn: () => T): T;
 export declare function warnWebpackComposeHelpersDeprecation(): void;
+export declare const WEBPACK_SSR_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = "The `@nx/webpack:ssr-dev-server` executor is deprecated and will be removed in Nx v25. Run the server from source with the `@nx/js/tsx` plugin, with the browser build in watch mode as a continuous dependency. See https://nx.dev/docs/kb/replace-ssr-dev-server.";
+export declare function warnWebpackSsrDevServerExecutorDeprecation(): void;

package/dist/src/utils/deprecation.js

@@ -1,35 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = void 0;
-exports.warnWebpackExecutorDeprecation = warnWebpackExecutorDeprecation;
-exports.warnWebpackDevServerExecutorDeprecation = warnWebpackDevServerExecutorDeprecation;
-exports.warnWebpackExecutorGenerating = warnWebpackExecutorGenerating;
+exports.WEBPACK_SSR_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = void 0;
 exports.suppressWebpackComposeHelperWarnings = suppressWebpackComposeHelperWarnings;
 exports.warnWebpackComposeHelpersDeprecation = warnWebpackComposeHelpersDeprecation;
+exports.warnWebpackSsrDevServerExecutorDeprecation = warnWebpackSsrDevServerExecutorDeprecation;
 const devkit_1 = require("@nx/devkit");
-// TODO(v24): Remove the @nx/webpack:webpack and @nx/webpack:dev-server
-// executors. The inferred plugin (@nx/webpack/plugin) and the
-// convert-to-inferred generator stay supported.
-exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/webpack:webpack` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/webpack:dev-server` executor is deprecated and will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` to migrate to the `@nx/webpack/plugin` inferred targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
-function warnWebpackExecutorDeprecation() {
-    devkit_1.logger.warn(exports.WEBPACK_EXECUTOR_DEPRECATION_MESSAGE);
-}
-function warnWebpackDevServerExecutorDeprecation() {
-    devkit_1.logger.warn(exports.WEBPACK_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
-}
-// Fired when the @nx/webpack:configuration generator is about to generate
-// targets that use the deprecated executors — i.e. when @nx/webpack/plugin
-// isn't registered in nx.json. Surfaces the deprecation at generation time
-// rather than only when the user later runs the generated targets.
-function warnWebpackExecutorGenerating() {
-    devkit_1.logger.warn('Generating targets that use the deprecated `@nx/webpack:webpack` and `@nx/webpack:dev-server` executors. These executors will be removed in Nx v24. Run `nx g @nx/webpack:convert-to-inferred` next to migrate these targets to the `@nx/webpack/plugin` inferred plugin and prevent future generators from emitting executor targets. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.');
-}
-// TODO(v24): Remove the composePlugins/withNx/withWeb config helpers. They emit
-// an Nx-specific config function that only runs under the @nx/webpack:webpack
-// executor; the inferred @nx/webpack/plugin works with standard webpack configs
-// built around NxAppWebpackPlugin instead.
-exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = 'The `composePlugins`, `withNx`, and `withWeb` config helpers from `@nx/webpack` are deprecated and will be removed in Nx v24. They produce an Nx-specific config function that only runs under the `@nx/webpack:webpack` executor. Migrate to a standard webpack config that uses `NxAppWebpackPlugin` (from `@nx/webpack/app-plugin`) under the inferred `@nx/webpack/plugin` by running `nx g @nx/webpack:convert-to-inferred`. See https://nx.dev/docs/guides/tasks--caching/convert-to-inferred for details.';
+// Helper behavior was removed in v24; exports remain only as inert stubs.
+// Keep their exports loadable so old configs do not block graph creation.
+exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE = 'The compose config helpers from `@nx/webpack` were removed in Nx v24. The remaining exports are inert compatibility stubs and do not configure builds. Migrate to a standard webpack config using `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`. Follow the config-helper migration instructions generated by `nx migrate`. Executor conversion is a separate migration.';
 let composeHelpersWarned = false;
 let suppressDepth = 0;
 // Nx-internal entry points compose these helpers themselves (e.g. the rspack
@@ -53,3 +31,8 @@ function warnWebpackComposeHelpersDeprecation() {
     composeHelpersWarned = true;
     devkit_1.logger.warn(exports.WEBPACK_COMPOSE_HELPERS_DEPRECATION_MESSAGE);
 }
+// TODO(v25): remove with the deprecated ssr-dev-server executor
+exports.WEBPACK_SSR_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE = 'The `@nx/webpack:ssr-dev-server` executor is deprecated and will be removed in Nx v25. Run the server from source with the `@nx/js/tsx` plugin, with the browser build in watch mode as a continuous dependency. See https://nx.dev/docs/kb/replace-ssr-dev-server.';
+function warnWebpackSsrDevServerExecutorDeprecation() {
+    devkit_1.logger.warn(exports.WEBPACK_SSR_DEV_SERVER_EXECUTOR_DEPRECATION_MESSAGE);
+}

package/dist/src/utils/dev-server-ready-check.d.ts

@@ -0,0 +1,36 @@
+import { type ServerAddress } from '@nx/devkit/internal';
+export interface ServeFlags {
+    port?: number | string;
+    host?: string;
+    configNames: string[];
+    configs: string[];
+    merge: boolean;
+    env: Record<string, unknown>;
+    extends: string[];
+}
+/** The flags of `webpack-cli serve` the check reads, from its parsed argv. */
+export declare function parseServeFlags(argv: Record<string, any>): ServeFlags;
+/**
+ * The options `webpack-cli serve` parses from the task's options, as
+ * run-commands forwards them. webpack-cli passes them to a function config as
+ * `argv`, with `env` parsed from the `--env` values. Parses the args with
+ * webpack-cli's commander and types each value by its argument in webpack-cli,
+ * webpack or webpack-dev-server.
+ */
+export declare function parseServeArgv(options: Record<string, unknown>): Record<string, any>;
+/**
+ * Where a dev server listens, or null when it picks its port or listens on a
+ * socket. Returns null for those, since nothing can be probed ahead of them.
+ */
+export declare function getDevServerAddress(devServer: {
+    port?: unknown;
+    host?: unknown;
+    ipc?: unknown;
+} | undefined, flags: ServeFlags, basePort: string | undefined): ServerAddress | null;
+/**
+ * The readyWhen of the inferred serve targets when the config doesn't load the
+ * signal plugin. Runs in the env and with the options of the serve task, reads
+ * the config the way `webpack-cli serve` does, and waits for each dev server it
+ * starts.
+ */
+export declare function waitForWebpackDevServer(configPath: string): Promise<void>;