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

package/dist/src/generators/convert-config-to-webpack-plugin/schema.json

@@ -1,13 +1,13 @@
 {
   "$schema": "https://json-schema.org/schema",
   "$id": "NxWebpackConvertConfigToWebpackPlugin",
-  "description": "Convert existing Webpack project(s) using `@nx/webpack:webpack` executor that uses `withNx` to use `NxAppWebpackPlugin`. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
+  "description": "Convert existing Webpack config(s) that use `withNx` to use `NxAppWebpackPlugin`, for projects on the `@nx/webpack:webpack` executor or the `@nx/webpack/plugin` inference plugin. Defaults to migrating all projects. Pass '--project' to migrate only one target.",
   "title": "Convert Webpack project using withNx to NxAppWebpackPlugin",
   "type": "object",
   "properties": {
     "project": {
       "type": "string",
-      "description": "The project to convert from using the `@nx/webpack:webpack` executor and `withNx` plugin to use `NxAppWebpackPlugin`.",
+      "description": "The project whose webpack config to convert from the `withNx` plugin to `NxAppWebpackPlugin`.",
       "x-priority": "important"
     },
     "skipFormat": {

package/dist/src/generators/convert-to-inferred/convert-to-inferred.js

@@ -40,7 +40,7 @@ async function convertToInferred(tree, options) {
         const convertMessage = [...logger.loggedMessages.values()]
             .flat()
             .find((v) => v.includes('@nx/webpack:convert-config-to-webpack-plugin'));
-        if (convertMessage.length > 0) {
+        if (convertMessage?.length > 0) {
             logger.flushLogs((message) => !convertMessage.includes(message));
             throw new Error(convertMessage);
         }
@@ -56,9 +56,10 @@ async function convertToInferred(tree, options) {
     if (!options.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);
     }
-    return (0, devkit_1.runTasksInSerial)(installCallback, () => {
-        migrationContext.logger.flushLogs();
-    });
+    // Flushed now rather than in the callback so remove-deprecated-executors, which
+    // skips the install callback, still prints these.
+    migrationContext.logger.flushLogs();
+    return installCallback;
 }
 function skipProjectFilterFactory(tree) {
     return function skipProjectFilter(projectConfiguration) {

package/dist/src/generators/convert-to-inferred/utils/ast.d.ts

@@ -1,3 +1,5 @@
 import * as ts from 'typescript';
 export declare function toPropertyAssignment(key: string, value: unknown): ts.PropertyAssignment;
 export declare function toExpression(value: unknown): ts.Expression;
+/** Whether a top-level `configValues` object written by convert-to-inferred has `key`. */
+export declare function hasMigratedConfigValues(sourceFile: ts.SourceFile, key: string): boolean;

package/dist/src/generators/convert-to-inferred/utils/ast.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toPropertyAssignment = toPropertyAssignment;
 exports.toExpression = toExpression;
+exports.hasMigratedConfigValues = hasMigratedConfigValues;
 const tslib_1 = require("tslib");
 const ts = tslib_1.__importStar(require("typescript"));
 function toPropertyAssignment(key, value) {
@@ -38,3 +39,15 @@ function toExpression(value) {
         return ts.factory.createObjectLiteralExpression(Object.entries(value).map(([key, value]) => toPropertyAssignment(key, value)));
     }
 }
+/** Whether a top-level `configValues` object written by convert-to-inferred has `key`. */
+function hasMigratedConfigValues(sourceFile, key) {
+    return sourceFile.statements.some((statement) => ts.isVariableStatement(statement) &&
+        statement.declarationList.declarations.some((declaration) => ts.isIdentifier(declaration.name) &&
+            declaration.name.text === 'configValues' &&
+            declaration.initializer !== undefined &&
+            ts.isObjectLiteralExpression(declaration.initializer) &&
+            declaration.initializer.properties.some((property) => ts.isPropertyAssignment(property) &&
+                (ts.isIdentifier(property.name) ||
+                    ts.isStringLiteral(property.name)) &&
+                property.name.text === key)));
+}

package/dist/src/generators/convert-to-inferred/utils/build-post-target-transformer.js

@@ -13,6 +13,13 @@ function buildPostTargetTransformerFactory(migrationContext) {
             projectName: projectDetails.projectName,
             projectRoot: projectDetails.root,
         };
+        // outputPath moves into the config, where `{options.outputPath}` can't resolve.
+        const outputPath = target.options?.outputPath;
+        if (target.outputs && typeof outputPath === 'string') {
+            target.outputs = target.outputs.map((output) => output.startsWith('{options.outputPath}')
+                ? output.replace('{options.outputPath}', `{workspaceRoot}/${outputPath}`)
+                : output.replace('{options.outputPath}', outputPath));
+        }
         const { pluginOptions, webpackConfigPath } = processOptions(target, context);
         updateWebpackConfig(tree, webpackConfigPath, pluginOptions);
         if (target.outputs) {
@@ -109,6 +116,11 @@ function updateWebpackConfig(tree, webpackConfig, pluginOptions) {
         sourceFile = (0, tsquery_1.ast)(webpackConfigText);
     };
     updateSources();
+    // A target kept on its executor is converted again on rerun, and its options
+    // are already in the config.
+    if ((0, ast_1.hasMigratedConfigValues)(sourceFile, 'build')) {
+        return;
+    }
     setOptionsInWebpackConfig(tree, webpackConfigText, sourceFile, webpackConfig, pluginOptions);
     updateSources();
     setOptionsInNxWebpackPlugin(tree, webpackConfigText, sourceFile, webpackConfig);
@@ -118,9 +130,17 @@ function updateWebpackConfig(tree, webpackConfig, pluginOptions) {
 function setOptionsInWebpackConfig(tree, text, sourceFile, webpackConfig, pluginOptions) {
     const { default: defaultOptions, ...configurationOptions } = pluginOptions;
     const optionsSelector = 'VariableStatement:has(VariableDeclaration:has(Identifier[name=options]))';
-    const optionsVariable = (0, tsquery_1.query)(sourceFile, optionsSelector)[0];
-    // This is assuming the `options` variable will be available since it's what the
-    // `convert-config-to-webpack-plugin` generates
+    let optionsVariable = (0, tsquery_1.query)(sourceFile, optionsSelector)[0];
+    if (!optionsVariable) {
+        const plugin = (0, tsquery_1.query)(sourceFile, 'NewExpression:has(Identifier[name=NxAppWebpackPlugin])')[0];
+        const argument = plugin.arguments?.[0];
+        if (argument && !ts.isObjectLiteralExpression(argument)) {
+            throw new Error('Move NxAppWebpackPlugin options into an object literal before converting this config.');
+        }
+        text = `const options = ${argument?.getText(sourceFile) ?? '{}'};\n${text}`;
+        sourceFile = (0, tsquery_1.ast)(text);
+        optionsVariable = (0, tsquery_1.query)(sourceFile, optionsSelector)[0];
+    }
     let defaultOptionsObject;
     const optionsObject = (0, tsquery_1.query)(optionsVariable, 'ObjectLiteralExpression')[0];
     if (optionsObject.properties.length === 0) {
@@ -188,8 +208,8 @@ function setOptionsInNxWebpackPlugin(tree, text, sourceFile, webpackConfig) {
 function setOptionsInLegacyNxPlugin(tree, text, sourceFile, webpackConfig) {
     const legacyNxPluginSelector = 'AwaitExpression CallExpression:has(Identifier[name=useLegacyNxPlugin])';
     const legacyNxPlugin = (0, tsquery_1.query)(sourceFile, legacyNxPluginSelector)[0];
-    // we're assuming the `useLegacyNxPlugin` function is being called since it's what the `convert-config-to-webpack-plugin` generates
-    // we've already "ensured" that the `convert-config-to-webpack-plugin` was run by checking for the `NxAppWebpackPlugin` in the project validation
+    if (!legacyNxPlugin)
+        return;
     const updatedLegacyNxPlugin = ts.factory.updateCallExpression(legacyNxPlugin, legacyNxPlugin.expression, undefined, [legacyNxPlugin.arguments[0], ts.factory.createIdentifier('buildOptions')]);
     text = `${text.slice(0, legacyNxPlugin.getStart())}${ts
         .createPrinter()

package/dist/src/generators/convert-to-inferred/utils/serve-post-target-transformer.js

@@ -16,7 +16,7 @@ function servePostTargetTransformerFactory(migrationContext) {
             projectName: projectDetails.projectName,
             projectRoot: projectDetails.root,
         };
-        const { devServerOptions, webpackConfigPath } = await processOptions(tree, target, context);
+        const { devServerOptions, webpackConfigPath } = await processOptions(target, context);
         updateWebpackConfig(tree, webpackConfigPath, devServerOptions, context);
         if (target.outputs) {
             (0, internal_1.processTargetOutputs)(target, [], inferredTarget, {
@@ -27,20 +27,14 @@ function servePostTargetTransformerFactory(migrationContext) {
         return target;
     };
 }
-async function processOptions(tree, target, context) {
-    const executorContext = {
-        cwd: process.cwd(),
-        nxJsonConfiguration: (0, devkit_1.readJson)(tree, 'nx.json'),
-        projectGraph: context.projectGraph,
-        projectName: context.projectName,
-        projectsConfigurations: Object.entries(context.projectGraph.nodes).reduce((acc, [projectName, project]) => {
-            acc.projects[projectName] = project.data;
-            return acc;
-        }, { version: 1, projects: {} }),
-        root: context.workspaceRoot,
+async function processOptions(target, context) {
+    const buildTarget = (0, devkit_1.parseTargetString)(target.options.buildTarget, context.projectGraph);
+    const buildConfiguration = context.projectGraph.nodes[buildTarget.project].data.targets[buildTarget.target];
+    // The build executor is removed in v24; do not resolve its schema.
+    const buildOptions = {
+        ...buildConfiguration.options,
+        ...buildConfiguration.configurations?.[buildTarget.configuration ?? buildConfiguration.defaultConfiguration],
     };
-    const buildTarget = (0, devkit_1.parseTargetString)(target.options.buildTarget, executorContext);
-    const buildOptions = (0, devkit_1.readTargetOptions)(buildTarget, executorContext);
     // it must exist, we validated it in the project filter
     const webpackConfigPath = buildOptions.webpackConfig;
     const defaultOptions = extractDevServerOptions(target.options, context);
@@ -183,6 +177,11 @@ function updateWebpackConfig(tree, webpackConfigPath, devServerOptions, context)
         sourceFile = (0, tsquery_1.ast)(webpackConfigText);
     };
     updateSources();
+    // A target kept on its executor is converted again on rerun, and its options
+    // are already in the config.
+    if ((0, ast_1.hasMigratedConfigValues)(sourceFile, 'serve')) {
+        return;
+    }
     setOptionsInWebpackConfig(tree, webpackConfigText, sourceFile, webpackConfigPath, devServerOptions);
     updateSources();
     setDevServerOptionsInWebpackConfig(tree, webpackConfigText, sourceFile, webpackConfigPath, context);

package/dist/src/generators/init/init.js

@@ -7,71 +7,62 @@ const devkit_1 = require("@nx/devkit");
 const plugin_1 = require("../../plugins/plugin");
 const versions_1 = require("../../utils/versions");
 function webpackInitGenerator(tree, schema) {
-    return webpackInitGeneratorInternal(tree, { addPlugin: false, ...schema });
+    return webpackInitGeneratorInternal(tree, schema);
 }
 async function webpackInitGeneratorInternal(tree, schema) {
     (0, versions_1.assertSupportedWebpackVersion)(tree);
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    schema.addPlugin ??= addPluginDefault;
-    if (schema.addPlugin) {
-        await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/webpack/plugin', plugin_1.createNodesV2, {
-            buildTargetName: [
-                'build',
-                'webpack:build',
-                'build:webpack',
-                'webpack-build',
-                'build-webpack',
-            ],
-            serveTargetName: [
-                'serve',
-                'webpack:serve',
-                'serve:webpack',
-                'webpack-serve',
-                'serve-webpack',
-            ],
-            previewTargetName: [
-                'preview',
-                'webpack:preview',
-                'preview:webpack',
-                'webpack-preview',
-                'preview-webpack',
-            ],
-            buildDepsTargetName: [
-                'build-deps',
-                'webpack:build-deps',
-                'webpack-build-deps',
-            ],
-            watchDepsTargetName: [
-                'watch-deps',
-                'webpack:watch-deps',
-                'webpack-watch-deps',
-            ],
-            serveStaticTargetName: [
-                'serve-static',
-                'webpack:serve-static',
-                'serve-static:webpack',
-                'webpack-serve-static',
-                'serve-static-webpack',
-            ],
-        }, schema.updatePackageScripts);
-    }
+    await (0, internal_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/webpack/plugin', plugin_1.createNodesV2, {
+        buildTargetName: [
+            'build',
+            'webpack:build',
+            'build:webpack',
+            'webpack-build',
+            'build-webpack',
+        ],
+        serveTargetName: [
+            'serve',
+            'webpack:serve',
+            'serve:webpack',
+            'webpack-serve',
+            'serve-webpack',
+        ],
+        previewTargetName: [
+            'preview',
+            'webpack:preview',
+            'preview:webpack',
+            'webpack-preview',
+            'preview-webpack',
+        ],
+        buildDepsTargetName: [
+            'build-deps',
+            'webpack:build-deps',
+            'webpack-build-deps',
+        ],
+        watchDepsTargetName: [
+            'watch-deps',
+            'webpack:watch-deps',
+            'webpack-watch-deps',
+        ],
+        serveStaticTargetName: [
+            'serve-static',
+            'webpack:serve-static',
+            'serve-static:webpack',
+            'webpack-serve-static',
+            'serve-static-webpack',
+        ],
+    }, schema.updatePackageScripts);
     let installTask = () => { };
     if (!schema.skipPackageJson) {
-        // webpack and webpack-dev-server are peer dependencies, so ensure they are
-        // installed (both the executor and inferred-plugin paths need them at the
-        // user's runtime).
+        // webpack and webpack-dev-server are peer dependencies needed at the
+        // user's runtime.
         const devDependencies = {
             '@nx/webpack': versions_1.nxVersion,
             '@nx/web': versions_1.nxVersion,
             webpack: versions_1.webpackVersion,
             'webpack-dev-server': versions_1.webpackDevServerVersion,
-        };
-        if (schema.addPlugin) {
             // The inferred plugin runs the `webpack-cli` binary.
-            devDependencies['webpack-cli'] = versions_1.webpackCliVersion;
-        }
+            'webpack-cli': versions_1.webpackCliVersion,
+        };
         // @nx/webpack depends on sass, which pulls in @parcel/watcher. Its install
         // script only builds from source when npm_config_build_from_source is set,
         // so skip it.

package/dist/src/generators/init/schema.d.ts

@@ -3,5 +3,4 @@ export interface Schema {
   skipPackageJson?: boolean;
   keepExistingVersions?: boolean;
   updatePackageScripts?: boolean;
-  addPlugin?: boolean;
 }

package/dist/src/migrations/update-24-0-0/finish-inferred-conversion.md

@@ -0,0 +1,11 @@
+# Replace removed @nx/webpack executors with inferred tasks
+
+Nx 24 removed `@nx/webpack:webpack`, `@nx/webpack:dev-server` (including old `@nrwl` aliases).
+
+Before changing anything, check for leftover work: a project target, a package.json target or a `targetDefaults` entry still uses a removed executor, or the advisory context reports a conversion error. If none applies, make no changes and stop. Treat each advisory-context item as pending work.
+
+1. Inspect all affected projects and workspace defaults. Repair config-loading errors first. Do not restore executor registrations or install older Nx packages.
+2. Register `@nx/webpack/plugin` with options/includes that preserve custom target names and mixed inferred/explicit projects. Replace remaining removed-executor targets, including those in package.json and filtered targetDefaults. Transfer their behavior before removing obsolete defaults. Preserve configurations, dependencies, cache inputs/outputs and environment behavior. Do not silently delete unsupported options or unrelated targets. Migrate old @nrwl aliases too.
+3. Run project graph creation with the daemon and graph cache disabled (`NX_DAEMON=false NX_CACHE_PROJECT_GRAPH=false`), using the workspace package manager. Inspect resolved project targets and verify each migrated entrypoint exists and is inferred (a thin alias to an inferred target is acceptable). Resolve graph errors before completing this migration, even if task validation was skipped. Configs must load for subsequent migrations.
+4. By default run relevant real builds/tests with task cache disabled, including alternate configurations. Honor an existing preference to skip expensive task validation; otherwise offer that option when validation is slow. Skipping expensive tasks never skips conversion or the graph check. Report each skipped task as unverified. Never weaken assertions or change application behavior to make checks pass.
+5. Report converted projects, graph validation, task results and any skipped checks. Unconverted targets or a broken graph mean the migration is incomplete. Investigate task failures and distinguish missing environment prerequisites from conversion regressions; do not claim a working workspace with unresolved regressions.

package/dist/src/migrations/update-24-0-0/inventory.d.ts

@@ -0,0 +1,10 @@
+import { type Tree } from '@nx/devkit';
+export interface HelperUsage {
+    name: string;
+    root: string;
+    configPaths: string[];
+    usesHelpers: boolean;
+    usesModuleFederation: boolean;
+    usesExecutor: boolean;
+}
+export declare function inventoryComposePlugins(tree: Tree): HelperUsage[];

package/dist/src/migrations/update-24-0-0/inventory.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inventoryComposePlugins = inventoryComposePlugins;
+const devkit_1 = require("@nx/devkit");
+const CONFIG_EXTENSIONS = ['js', 'cjs', 'mjs', 'ts', 'cts', 'mts'];
+const REMOVED_HELPERS = /\b(composePlugins|composePluginsSync|withNx|withWeb|withReact)\b/;
+// Left by an earlier conversion; the wrapped `.old` config still calls the helpers.
+const LEGACY_WRAPPER = /\buseLegacyNxPlugin\b/;
+const MODULE_FEDERATION_HELPERS = /\bwithModuleFederation(ForSSR)?\b/;
+function inventoryComposePlugins(tree) {
+    const usages = [];
+    for (const [name, project] of (0, devkit_1.getProjects)(tree)) {
+        const configs = [...collectConfigPaths(tree, project)].map((path) => ({
+            path,
+            source: tree.read(path, 'utf-8') ?? '',
+        }));
+        const configPaths = configs
+            .filter(({ source }) => REMOVED_HELPERS.test(source) || LEGACY_WRAPPER.test(source))
+            .map(({ path }) => path);
+        if (!configPaths.length)
+            continue;
+        usages.push({
+            name,
+            root: project.root,
+            configPaths: configPaths.sort(),
+            usesHelpers: configs.some(({ source }) => REMOVED_HELPERS.test(source)),
+            usesModuleFederation: configs.some(({ source }) => MODULE_FEDERATION_HELPERS.test(source)),
+            usesExecutor: Object.values(project.targets ?? {}).some((target) => ['@nx/webpack:webpack', '@nrwl/webpack:webpack'].includes(target.executor)),
+        });
+    }
+    return usages;
+}
+function collectConfigPaths(tree, project) {
+    const paths = new Set();
+    for (const target of Object.values(project.targets ?? {})) {
+        for (const options of [
+            target.options,
+            ...Object.values(target.configurations ?? {}),
+        ]) {
+            const configured = options?.webpackConfig;
+            // A package path such as `@nx/react/plugins/webpack` resolves to the stubs
+            // rather than a workspace file; the prompt gives those projects a config.
+            if (typeof configured === 'string' && tree.exists(configured)) {
+                paths.add(configured);
+            }
+        }
+    }
+    for (const extension of CONFIG_EXTENSIONS) {
+        const conventional = `${project.root}/webpack.config.${extension}`;
+        if (tree.exists(conventional)) {
+            paths.add(conventional);
+        }
+    }
+    return paths;
+}

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.d.ts

@@ -0,0 +1,10 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateComposePlugins(tree: Tree): Promise<{
+    skipAgentic: boolean;
+    nextSteps?: undefined;
+    agentContext?: undefined;
+} | {
+    skipAgentic?: undefined;
+    nextSteps: string[];
+    agentContext: string[];
+}>;

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateComposePlugins;
+const devkit_1 = require("@nx/devkit");
+const convert_config_to_webpack_plugin_1 = require("../../generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin");
+const inventory_1 = require("./inventory");
+const CONVERTER = '@nx/webpack:convert-config-to-webpack-plugin';
+async function migrateComposePlugins(tree) {
+    const usages = (0, inventory_1.inventoryComposePlugins)(tree);
+    if (!usages.length) {
+        return { skipAgentic: true };
+    }
+    const converted = [];
+    const remaining = [];
+    const moduleFederation = [];
+    for (const usage of usages) {
+        if (!usage.usesHelpers) {
+            converted.push(usage);
+            continue;
+        }
+        if (usage.usesModuleFederation) {
+            moduleFederation.push(usage);
+            continue;
+        }
+        try {
+            await (0, convert_config_to_webpack_plugin_1.convertConfigToWebpackPluginGenerator)(tree, {
+                project: usage.name,
+                skipFormat: true,
+            });
+            converted.push(usage);
+        }
+        catch (e) {
+            remaining.push({ usage, reason: e.message });
+        }
+    }
+    if (converted.length) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return {
+        nextSteps: nextSteps(converted, remaining),
+        agentContext: agentContext(converted, remaining, moduleFederation),
+    };
+}
+function nextSteps(converted, remaining) {
+    const steps = [];
+    if (converted.length) {
+        steps.push(`Inline the \`webpack.config.old.*\` files that ${CONVERTER} left behind in ${converted.length} project(s), then drop \`useLegacyNxPlugin\`.`);
+    }
+    if (remaining.length) {
+        steps.push(`Migrate ${remaining.length} project(s) off the removed webpack config helpers by hand: ${remaining
+            .map(({ usage }) => usage.name)
+            .join(', ')}.`);
+    }
+    return steps;
+}
+function agentContext(converted, remaining, moduleFederation) {
+    const context = [];
+    if (converted.length) {
+        context.push(`${CONVERTER} converted these projects. Each one now has a standard config whose \`useLegacyNxPlugin\` call still loads the renamed \`.old\` config, so the helper callbacks it holds have to move into the new config before the \`.old\` file can go:`, ...converted.map((usage) => `- ${usage.name} (${usage.root}): ${usage.configPaths.join(', ')}`));
+    }
+    if (remaining.length) {
+        context.push(`${CONVERTER} could not convert these projects, so their configs are untouched and still call the removed helpers. Rewrite each one by hand:`, ...remaining.map(({ usage, reason }) => `- ${usage.name} (${usage.root}): ${usage.configPaths.join(', ')} - ${reason}`));
+    }
+    if (moduleFederation.length) {
+        context.push(`These projects compose Module Federation helpers, so their configs are untouched. The @nx/module-federation migration handles them; do not convert them here:`, ...moduleFederation.map((usage) => `- ${usage.name} (${usage.root}): ${usage.configPaths.join(', ')}`));
+    }
+    return context;
+}

package/dist/src/migrations/update-24-0-0/migrate-compose-plugins.md

@@ -0,0 +1,98 @@
+# Migrate webpack compose helpers
+
+Nx v24 removed `composePlugins`, `composePluginsSync`, `withNx`, `withWeb`, and webpack
+`withReact`. Their exports remain as inert stubs so existing configs still load while Nx
+builds the project graph. They do not configure builds, and a config that loads is not a
+working build.
+
+`@nx/webpack:convert-config-to-webpack-plugin` already ran. The agent context lists the
+projects it converted, including configs an earlier conversion left wrapped in
+`useLegacyNxPlugin`, and, separately, the projects it could not convert with the reason
+for each. Work only on those projects and the files they import. Do not re-inventory the
+workspace, and do not run the converter again.
+
+Preserve the installed webpack version, bundler, targets, configurations, and commands.
+Nx 24 also removed the `@nx/webpack:webpack` executor. Its targets are converted to inferred
+`@nx/webpack/plugin` tasks by a separate migration, so do not add it back or keep a target on it.
+
+## Baseline
+
+This workspace is already on v24, so the old helpers no longer build here. To compare
+against the previous behavior, check out the commit before the upgrade in a separate git
+worktree, install with its lockfile, and build there. Do not downgrade this workspace. If
+you cannot build a baseline, say so in your report rather than calling the comparison a
+pass. Record build commands, output locations, assets, entry points, and any observable
+custom behavior.
+
+## Projects the converter handled
+
+Each one now has a standard config built around `NxAppWebpackPlugin`, plus a
+`useLegacyNxPlugin(require('./webpack.config.old.*'), options)` entry that still loads the
+renamed old config. The old config composes its remaining callbacks through a local
+`composeLegacyPlugins` helper the converter inlined. Two things are left:
+
+- Move what the old config still does into the new config, then delete the `.old` file and
+  drop `useLegacyNxPlugin`.
+- `useLegacyNxPlugin` runs at `beforeCompile`. That is too late to register rules, entries,
+  or plugins, so anything the old config set through those is already not applying the way
+  it used to. Check each one against the baseline instead of trusting the converted build.
+
+Also check the options the converter copied into the new config. It reads them out of the
+old `withNx` call as written, so values that depended on the executor or on environment
+variables are not represented, and workspace-relative paths may need adjusting: native
+plugin options resolve against the project and config directory, while executor options
+were workspace-relative.
+
+## Projects the converter skipped
+
+The agent context gives a reason per project. Those configs are untouched and still call
+the removed helpers, so rewrite each one.
+
+Use a standard webpack configuration with `NxAppWebpackPlugin` from
+`@nx/webpack/app-plugin`. For React apps also use `NxReactWebpackPlugin` from
+`@nx/react/webpack-plugin`. Do not add React configuration to Node or plain web apps, and
+do not change frameworks or upgrade dependencies to simplify the rewrite.
+
+Map the effective old options onto those plugins and standard webpack properties, reading
+the installed plugin types rather than assuming. Preserve precedence between target
+options, named configurations, helper options, and custom callbacks. Preserve compiler
+choice, aliases, CSS, SVG rules, assets, externals, file replacements, source maps,
+optimization, public paths, output filenames, and dev-server behavior. Set output hashing
+explicitly where the old helper defaults differ from the plugin defaults; a build that
+succeeds with renamed entry files is not output parity.
+
+A `webpackConfig` target option naming a package path rather than a local file, such as
+`@nx/react/plugins/webpack`, resolves to the stubs. Give that project its own config file.
+
+Inferred targets run the webpack CLI, which calls a function export with `(env, argv)`.
+Represent the options the executor used to supply in the config itself. Use config
+functions or separate configs where values vary by configuration.
+
+For custom composable functions, move the function into user-owned code and supply the
+options and context it needs explicitly. A local adapter exposing `apply(compiler)` can
+work, but an `apply` object belongs in `config.plugins`; exporting it as the whole config
+is invalid, and a top-level config function must return a config object or supported array.
+Preserve execution order and whether each callback mutates its input or returns a
+replacement. Await asynchronous transforms and propagate failures rather than leaving a
+pending promise.
+
+## Module Federation
+
+Projects using Nx Module Federation are out of scope here. `@nx/module-federation` ships
+its own v24 migration; follow that one. Do not remove federation, disable the project, or
+report success for it from this migration.
+
+## Verify and finish
+
+1. Rebuild the project graph without its disk cache and confirm the same projects and
+   targets are still discoverable.
+2. Run each affected build, development and production and any alternate configurations,
+   without reusing cached task outputs. Exercise Node startup where it applies, plus tests
+   and dev-server or HMR behavior.
+3. Compare emitted files against the baseline: custom assets and markers, entry points,
+   aliases, CSS and SVG handling, externals, and output paths. Compare content where hashes
+   differ. A zero exit code is not enough.
+4. Search the active configs and their imports for the removed helpers again. An already
+   migrated config needs no further change.
+5. Report the commands you ran, the output you checked, and anything still unresolved. Do
+   not delete tests, custom behavior, or targets to get a green result.

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

@@ -0,0 +1,6 @@
+import { type Tree } from '@nx/devkit';
+export default function update(tree: Tree): Promise<{
+    nextSteps?: string[];
+    agentContext?: string[];
+    skipAgentic?: boolean;
+}>;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = update;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const convert_config_to_webpack_plugin_1 = require("../../generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin");
+const inventory_1 = require("./inventory");
+function update(tree) {
+    return (0, internal_1.migrateRemovedExecutors)(tree, [
+        '@nx/webpack:webpack',
+        '@nx/webpack:dev-server',
+        '@nrwl/webpack:webpack',
+        '@nrwl/webpack:dev-server',
+    ], async (tree, options) => {
+        await convertHelperConfigs(tree);
+        const { convertToInferred } = require('../../generators/convert-to-inferred/convert-to-inferred');
+        return convertToInferred(tree, options);
+    });
+}
+// convert-to-inferred skips configs built on the removed helpers, so convert
+// those first. migrate-compose-plugins reports the `.old` configs left behind.
+async function convertHelperConfigs(tree) {
+    for (const usage of (0, inventory_1.inventoryComposePlugins)(tree)) {
+        if (!usage.usesExecutor || !usage.usesHelpers)
+            continue;
+        // Left for the Module Federation migration, like migrate-compose-plugins.
+        if (usage.usesModuleFederation)
+            continue;
+        try {
+            await (0, convert_config_to_webpack_plugin_1.convertConfigToWebpackPluginGenerator)(tree, {
+                project: usage.name,
+                skipFormat: true,
+            });
+        }
+        catch (e) {
+            devkit_1.logger.warn(`Could not convert the webpack config helpers in ${usage.name}: ${e.message}`);
+        }
+    }
+}