@nx/webpack 23.0.0-beta.23 → 23.0.0-beta.25

package/{app-plugin.d.ts → dist/app-plugin.d.ts}

@@ -1,3 +1,2 @@
 export { NxAppWebpackPlugin } from './src/plugins/nx-webpack-plugin/nx-app-webpack-plugin';
 export type { NxAppWebpackPluginOptions } from './src/plugins/nx-webpack-plugin/nx-app-webpack-plugin-options';
-//# sourceMappingURL=app-plugin.d.ts.map

package/{index.d.ts → dist/index.d.ts}

@@ -19,4 +19,3 @@ export * from './src/utils/get-css-module-local-ident';
 export * from './src/utils/with-nx';
 export * from './src/utils/with-web';
 export * from './src/utils/e2e-web-server-info-utils';
-//# sourceMappingURL=index.d.ts.map

package/dist/internal.d.ts

@@ -0,0 +1,8 @@
+export { findUp, findAllNodeModules, deleteOutputDir } from './src/utils/fs';
+export { ensureDependencies } from './src/utils/ensure-dependencies';
+export type { EnsureDependenciesOptions } from './src/utils/ensure-dependencies';
+export { resolveUserDefinedWebpackConfig } from './src/utils/webpack/resolve-user-defined-webpack-config';
+export { suppressWebpackComposeHelperWarnings } from './src/utils/deprecation';
+export { WebpackNxBuildCoordinationPlugin } from './src/plugins/webpack-nx-build-coordination-plugin';
+export type { WebSsrDevServerOptions } from './src/executors/ssr-dev-server/schema';
+export { default as ssrDevServerExecutor } from './src/executors/ssr-dev-server/ssr-dev-server.impl';

package/dist/internal.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssrDevServerExecutor = exports.WebpackNxBuildCoordinationPlugin = exports.suppressWebpackComposeHelperWarnings = exports.resolveUserDefinedWebpackConfig = exports.ensureDependencies = exports.deleteOutputDir = exports.findAllNodeModules = exports.findUp = void 0;
+const tslib_1 = require("tslib");
+// Curated internal API surface for other first-party Nx plugins (e.g. @nx/react,
+// @nx/angular, @nx/web, @nx/node, @nx/next, @nx/react-native). Prefer this over
+// deep `@nx/webpack/src/*` imports — those are not part of the public API.
+//
+// Only truly-internal symbols belong here. Anything exported from @nx/webpack's
+// public entry (composePluginsSync, withNx, withWeb, normalizeOptions,
+// normalizePluginPath, devServerExecutor, NormalizedWebpackExecutorOptions, …)
+// must be imported from '@nx/webpack', not from here.
+var fs_1 = require("./src/utils/fs");
+Object.defineProperty(exports, "findUp", { enumerable: true, get: function () { return fs_1.findUp; } });
+Object.defineProperty(exports, "findAllNodeModules", { enumerable: true, get: function () { return fs_1.findAllNodeModules; } });
+Object.defineProperty(exports, "deleteOutputDir", { enumerable: true, get: function () { return fs_1.deleteOutputDir; } });
+var ensure_dependencies_1 = require("./src/utils/ensure-dependencies");
+Object.defineProperty(exports, "ensureDependencies", { enumerable: true, get: function () { return ensure_dependencies_1.ensureDependencies; } });
+var resolve_user_defined_webpack_config_1 = require("./src/utils/webpack/resolve-user-defined-webpack-config");
+Object.defineProperty(exports, "resolveUserDefinedWebpackConfig", { enumerable: true, get: function () { return resolve_user_defined_webpack_config_1.resolveUserDefinedWebpackConfig; } });
+var deprecation_1 = require("./src/utils/deprecation");
+Object.defineProperty(exports, "suppressWebpackComposeHelperWarnings", { enumerable: true, get: function () { return deprecation_1.suppressWebpackComposeHelperWarnings; } });
+var webpack_nx_build_coordination_plugin_1 = require("./src/plugins/webpack-nx-build-coordination-plugin");
+Object.defineProperty(exports, "WebpackNxBuildCoordinationPlugin", { enumerable: true, get: function () { return webpack_nx_build_coordination_plugin_1.WebpackNxBuildCoordinationPlugin; } });
+var ssr_dev_server_impl_1 = require("./src/executors/ssr-dev-server/ssr-dev-server.impl");
+Object.defineProperty(exports, "ssrDevServerExecutor", { enumerable: true, get: function () { return tslib_1.__importDefault(ssr_dev_server_impl_1).default; } });

package/{plugin.d.ts → dist/plugin.d.ts}

@@ -1,2 +1 @@
 export { createNodes, createNodesV2, type WebpackPluginOptions, } from './src/plugins/plugin';
-//# sourceMappingURL=plugin.d.ts.map

package/{src → dist/src}/executors/dev-server/dev-server.impl.d.ts

@@ -5,4 +5,3 @@ export declare function devServerExecutor(serveOptions: WebDevServerOptions, con
     success: boolean;
 }, any, any>;
 export default devServerExecutor;
-//# sourceMappingURL=dev-server.impl.d.ts.map

package/{src → dist/src}/executors/dev-server/dev-server.impl.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.devServerExecutor = devServerExecutor;
-const tslib_1 = require("tslib");
 const internal_1 = require("@nx/devkit/internal");
-const webpack_1 = tslib_1.__importDefault(require("webpack"));
 const devkit_1 = require("@nx/devkit");
 const operators_1 = require("rxjs/operators");
-const webpack_dev_server_1 = tslib_1.__importDefault(require("webpack-dev-server"));
 const get_dev_server_config_1 = require("./lib/get-dev-server-config");
 const internal_2 = require("@nx/js/internal");
 const run_webpack_1 = require("../../utils/run-webpack");
@@ -63,7 +60,10 @@ async function* devServerExecutor(serveOptions, context) {
             config.devServer ??= devServer;
         }
     }
-    return yield* (0, internal_1.eachValueFrom)((0, run_webpack_1.runWebpackDevServer)(config, webpack_1.default, webpack_dev_server_1.default).pipe((0, operators_1.tap)(({ stats }) => {
+    // Lazy-loaded: optional peers absent during project-graph discovery.
+    const webpack = require('webpack');
+    const WebpackDevServer = require('webpack-dev-server');
+    return yield* (0, internal_1.eachValueFrom)((0, run_webpack_1.runWebpackDevServer)(config, webpack, WebpackDevServer).pipe((0, operators_1.tap)(({ stats }) => {
         console.info(stats.toString(config.stats));
     }), (0, operators_1.map)(({ baseUrl, stats }) => {
         return {

package/{src → dist/src}/executors/dev-server/lib/get-dev-server-config.d.ts

@@ -2,4 +2,3 @@ import type { Configuration as WebpackDevServerConfiguration } from 'webpack-dev
 import { WebDevServerOptions } from '../schema';
 import { NormalizedWebpackExecutorOptions } from '../../webpack/schema';
 export declare function getDevServerOptions(root: string, serveOptions: WebDevServerOptions, buildOptions: NormalizedWebpackExecutorOptions): WebpackDevServerConfiguration;
-//# sourceMappingURL=get-dev-server-config.d.ts.map

package/{src → dist/src}/executors/dev-server/lib/serve-path.d.ts

@@ -1,4 +1,3 @@
 import type { NormalizedWebpackExecutorOptions } from '../../webpack/schema';
 export declare function buildServePath(browserOptions: NormalizedWebpackExecutorOptions): string;
 export declare function _findDefaultServePath(baseHref?: string, deployUrl?: string): string | null;
-//# sourceMappingURL=serve-path.d.ts.map

package/{src → dist/src}/executors/ssr-dev-server/lib/wait-until-server-is-listening.d.ts

@@ -1,2 +1 @@
 export declare function waitUntilServerIsListening(port: number): Promise<void>;
-//# sourceMappingURL=wait-until-server-is-listening.d.ts.map

package/{src → dist/src}/executors/ssr-dev-server/ssr-dev-server.impl.d.ts

@@ -6,4 +6,3 @@ export declare function ssrDevServerExecutor(options: WebSsrDevServerOptions, co
     options: TargetOptions;
 }, void, unknown>;
 export default ssrDevServerExecutor;
-//# sourceMappingURL=ssr-dev-server.impl.d.ts.map

package/{src → dist/src}/executors/webpack/lib/normalize-options.d.ts

@@ -1,4 +1,3 @@
 import type { NormalizedWebpackExecutorOptions, WebpackExecutorOptions } from '../schema';
 export declare function normalizeOptions(options: WebpackExecutorOptions, root: string, projectRoot: string, sourceRoot: string): NormalizedWebpackExecutorOptions;
 export declare function normalizePluginPath(pluginPath: void | string, root: string): string;
-//# sourceMappingURL=normalize-options.d.ts.map

package/{src → dist/src}/executors/webpack/lib/run-webpack.d.ts

@@ -1,4 +1,3 @@
-import webpack from 'webpack';
+import type webpack from 'webpack';
 import { Observable } from 'rxjs';
 export declare function runWebpack(config: webpack.Configuration): Observable<webpack.Stats>;
-//# sourceMappingURL=run-webpack.d.ts.map

package/{src → dist/src}/executors/webpack/lib/run-webpack.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runWebpack = runWebpack;
-const tslib_1 = require("tslib");
-const webpack_1 = tslib_1.__importDefault(require("webpack"));
 const rxjs_1 = require("rxjs");
 // TODO(jack): move to dev-server executor
 function runWebpack(config) {
+    // Lazy-loaded: `webpack` is an optional peer, absent during project-graph discovery.
+    const webpackImpl = require('webpack');
     return new rxjs_1.Observable((subscriber) => {
         // Passing `watch` option here will result in a warning due to missing callback.
         // We manually call `.watch` or `.run` later so this option isn't needed here.
         const { watch, ...normalizedConfig } = config;
-        const webpackCompiler = (0, webpack_1.default)(normalizedConfig);
+        const webpackCompiler = webpackImpl(normalizedConfig);
         const callback = (err, stats) => {
             if (err) {
                 subscriber.error(err);

package/{src → dist/src}/executors/webpack/webpack.impl.d.ts

@@ -11,4 +11,3 @@ export type WebpackExecutorEvent = {
 };
 export declare function webpackExecutor(_options: WebpackExecutorOptions, context: ExecutorContext): AsyncGenerator<WebpackExecutorEvent, WebpackExecutorEvent, undefined>;
 export default webpackExecutor;
-//# sourceMappingURL=webpack.impl.d.ts.map

package/{src → dist/src}/generators/configuration/configuration.d.ts

@@ -3,4 +3,3 @@ import { ConfigurationGeneratorSchema } from './schema';
 export declare function configurationGenerator(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
 export declare function configurationGeneratorInternal(tree: Tree, options: ConfigurationGeneratorSchema): Promise<GeneratorCallback>;
 export default configurationGenerator;
-//# sourceMappingURL=configuration.d.ts.map

package/{src → dist/src}/generators/configuration/configuration.js

@@ -9,10 +9,12 @@ const has_plugin_1 = require("../../utils/has-plugin");
 const deprecation_1 = require("../../utils/deprecation");
 const internal_2 = require("@nx/js/internal");
 const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
+const versions_1 = require("../../utils/versions");
 function configurationGenerator(tree, options) {
     return configurationGeneratorInternal(tree, { addPlugin: false, ...options });
 }
 async function configurationGeneratorInternal(tree, options) {
+    (0, versions_1.assertSupportedWebpackVersion)(tree);
     const tasks = [];
     const nxJson = (0, devkit_1.readNxJson)(tree);
     const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin.d.ts

@@ -5,4 +5,3 @@ interface Schema {
 }
 export declare function convertConfigToWebpackPluginGenerator(tree: Tree, options: Schema): Promise<void>;
 export default convertConfigToWebpackPluginGenerator;
-//# sourceMappingURL=convert-config-to-webpack-plugin.d.ts.map

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/convert-config-to-webpack-plugin.js

@@ -7,6 +7,7 @@ const extract_webpack_options_1 = require("./lib/extract-webpack-options");
 const normalize_path_options_1 = require("./lib/normalize-path-options");
 const path_1 = require("path");
 const validate_project_1 = require("./lib/validate-project");
+const versions_1 = require("../../utils/versions");
 // Make text JSON compatible
 const preprocessText = (text) => {
     return text
@@ -16,6 +17,7 @@ const preprocessText = (text) => {
         .replace(/(\r\n|\n|\r|\t)/gm, ''); // Remove newlines and tabs
 };
 async function convertConfigToWebpackPluginGenerator(tree, options) {
+    (0, versions_1.assertSupportedWebpackVersion)(tree);
     let migrated = 0;
     const projects = (0, devkit_1.getProjects)(tree);
     (0, internal_1.forEachExecutorOptions)(tree, '@nx/webpack:webpack', (currentTargetOptions, projectName, targetName, configurationName) => {

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/lib/extract-webpack-options.d.ts

@@ -4,4 +4,3 @@ export declare function extractWebpackOptions(tree: Tree, webpackConfigPath: str
     withNxConfig: "" | ts.Node;
     withReactConfig: "" | ts.Node;
 };
-//# sourceMappingURL=extract-webpack-options.d.ts.map

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/lib/normalize-path-options.d.ts

@@ -1,3 +1,2 @@
 import { WebpackExecutorOptions } from '../../../executors/webpack/schema';
 export declare function normalizePathOptions(projectRoot: string, options: Partial<WebpackExecutorOptions>): Partial<WebpackExecutorOptions>;
-//# sourceMappingURL=normalize-path-options.d.ts.map

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/lib/utils.d.ts

@@ -1,2 +1 @@
 export declare function toProjectRelativePath(path: string, projectRoot: string): string;
-//# sourceMappingURL=utils.d.ts.map

package/{src → dist/src}/generators/convert-config-to-webpack-plugin/lib/validate-project.d.ts

@@ -7,4 +7,3 @@ import { ProjectConfiguration, Tree } from '@nx/devkit';
  * @returns A string if there is an error, otherwise undefined
  */
 export declare function validateProject(tree: Tree, project: ProjectConfiguration): string;
-//# sourceMappingURL=validate-project.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.d.ts

@@ -10,4 +10,3 @@ export declare function createCollectingLogger(): typeof devkitLogger & {
     flushLogs: (filter?: (message: string) => boolean) => void;
 };
 export {};
-//# sourceMappingURL=convert-to-inferred.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/convert-to-inferred.js

@@ -10,6 +10,7 @@ const versions_1 = require("../../utils/versions");
 const utils_1 = require("./utils");
 const devkit_exports_1 = require("nx/src/devkit-exports");
 async function convertToInferred(tree, options) {
+    (0, versions_1.assertSupportedWebpackVersion)(tree);
     const projectGraph = await (0, devkit_1.createProjectGraphAsync)();
     const migrationContext = {
         logger: new internal_1.AggregatedLog(),

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

@@ -1,4 +1,3 @@
 import * as ts from 'typescript';
 export declare function toPropertyAssignment(key: string, value: unknown): ts.PropertyAssignment;
 export declare function toExpression(value: unknown): ts.Expression;
-//# sourceMappingURL=ast.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/utils/build-post-target-transformer.d.ts

@@ -4,4 +4,3 @@ export declare function buildPostTargetTransformerFactory(migrationContext: Migr
     projectName: string;
     root: string;
 }, inferredTarget: TargetConfiguration) => TargetConfiguration;
-//# sourceMappingURL=build-post-target-transformer.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/utils/index.d.ts

@@ -1,4 +1,3 @@
 export * from './build-post-target-transformer';
 export * from './serve-post-target-transformer';
 export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/utils/serve-post-target-transformer.d.ts

@@ -4,4 +4,3 @@ export declare function servePostTargetTransformerFactory(migrationContext: Migr
     projectName: string;
     root: string;
 }, inferredTarget: TargetConfiguration) => Promise<TargetConfiguration>;
-//# sourceMappingURL=serve-post-target-transformer.d.ts.map

package/{src → dist/src}/generators/convert-to-inferred/utils/types.d.ts

@@ -9,4 +9,3 @@ export type TransformerContext = MigrationContext & {
     projectName: string;
     projectRoot: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/{src → dist/src}/generators/init/init.d.ts

@@ -3,4 +3,3 @@ import { Schema } from './schema';
 export declare function webpackInitGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
 export declare function webpackInitGeneratorInternal(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
 export default webpackInitGenerator;
-//# sourceMappingURL=init.d.ts.map

package/{src → dist/src}/generators/init/init.js

@@ -10,6 +10,7 @@ function webpackInitGenerator(tree, schema) {
     return webpackInitGeneratorInternal(tree, { addPlugin: false, ...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;
@@ -58,14 +59,20 @@ async function webpackInitGeneratorInternal(tree, schema) {
     }
     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).
         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;
         }
-        installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
+        installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions ?? true);
     }
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);

package/{src → dist/src}/generators/init/schema.json

@@ -20,7 +20,7 @@
       "type": "boolean",
       "x-priority": "internal",
       "description": "Keep existing dependencies versions",
-      "default": false
+      "default": true
     },
     "updatePackageScripts": {
       "type": "boolean",

package/{src → dist/src}/migrations/update-21-0-0/remove-isolated-config.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=remove-isolated-config.d.ts.map

package/{src → dist/src}/migrations/update-22-0-0/remove-deprecated-options.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export default function (tree: Tree): Promise<void>;
-//# sourceMappingURL=remove-deprecated-options.d.ts.map

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateCreateNodesV2ToCreateNodes;
+exports.rewriteCreateNodesV2Imports = rewriteCreateNodesV2Imports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEPRECATED_NAME = 'createNodesV2';
+const CANONICAL_NAME = 'createNodes';
+// Module specifiers from which `@nx/webpack` publicly exposes `createNodesV2`.
+// A named import or re-export of `createNodesV2` from one of these is rewritten
+// to the canonical `createNodes` export.
+const TARGET_SPECIFIERS = new Set(['@nx/webpack/plugin']);
+let ts;
+async function migrateCreateNodesV2ToCreateNodes(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEPRECATED_NAME)) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Imports(original, TARGET_SPECIFIERS);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Renamed \`${DEPRECATED_NAME}\` imports to \`${CANONICAL_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Imports(source, specifiers) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isTargetSpecifier(node, specifiers) {
+    return ts.isStringLiteral(node) && specifiers.has(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    // Only `import { ... }` carries renameable named bindings. `import x`,
+    // `import * as ns`, and side-effect imports reference the module wholesale
+    // and keep working through the `createNodesV2` runtime alias, so we leave
+    // them be. A mixed `import def, { createNodesV2 }` still has its named
+    // bindings rewritten below — the default binding is untouched.
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+}
+function collectExportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!stmt.moduleSpecifier ||
+        !isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    // `export { ... } from '...'` can be rewritten; `export * from '...'` has no
+    // named bindings to rename.
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any
+ * `createNodesV2` specifier to `createNodes`. If renaming would collide with a
+ * `createNodes` that is already present (e.g. `{ createNodes, createNodesV2 }`),
+ * the duplicate is dropped. Returns without recording a change when the binding
+ * list contains no `createNodesV2`.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasDeprecated = elements.some((el) => (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    if (!hasDeprecated) {
+        return;
+    }
+    const seen = new Set();
+    const rendered = [];
+    for (const el of elements) {
+        const text = renderSpecifier(el);
+        if (!seen.has(text)) {
+            seen.add(text);
+            rendered.push(text);
+        }
+    }
+    const start = namedBindings.getStart(sourceFile);
+    changes.push({
+        type: devkit_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => name === DEPRECATED_NAME ? CANONICAL_NAME : name;
+    // `{ name }` — no alias, so the local binding follows the rename.
+    if (!el.propertyName) {
+        return `${typePrefix}${rename(el.name.text)}`;
+    }
+    // `{ propertyName as name }` — only the imported (left) side is renamed; the
+    // local alias is preserved. A now-redundant alias such as
+    // `createNodesV2 as createNodes` collapses to `createNodes`.
+    const canonicalImported = rename(el.propertyName.text);
+    const localName = el.name.text;
+    return canonicalImported === localName
+        ? `${typePrefix}${localName}`
+        : `${typePrefix}${canonicalImported} as ${localName}`;
+}

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md

@@ -0,0 +1,25 @@
+#### Rename `createNodesV2` imports to `createNodes`
+
+`@nx/webpack` renamed its primary inferred-plugin export from `createNodesV2` to `createNodes`. The `createNodesV2` name is preserved as a deprecated alias for now, but new code should use `createNodes`.
+
+This migration scans every `.ts`, `.tsx`, `.cts`, and `.mts` file in your workspace and rewrites named imports and re-exports of `createNodesV2` from `@nx/webpack/plugin` to `createNodes`.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+import { createNodesV2 } from '@nx/webpack/plugin';
+```
+
+##### After
+
+```ts
+import { createNodes } from '@nx/webpack/plugin';
+```
+
+Aliases are preserved (`createNodesV2 as cn` becomes `createNodes as cn`), and if a file already imports both names (`{ createNodes, createNodesV2 }`) the redundant binding is dropped.
+
+#### What is not rewritten
+
+Only static `import`/`export` named bindings from `@nx/webpack/plugin` are rewritten. Namespace imports, dynamic `import(...)`, `require(...)` destructuring, and property access such as `plugin.createNodesV2` are left untouched — they keep working through the `createNodesV2` runtime alias. Update those by hand if you want to drop the deprecated name everywhere.

package/{src → dist/src}/migrations/update-23-0-0/remove-nx-tsconfig-paths-webpack-plugin-import.d.ts

@@ -1,3 +1,2 @@
 import { Tree } from '@nx/devkit';
 export default function removeNxTsconfigPathsWebpackPluginImport(tree: Tree): Promise<void>;
-//# sourceMappingURL=remove-nx-tsconfig-paths-webpack-plugin-import.d.ts.map

package/dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export default function rewriteInternalSubpathImports(tree: Tree): Promise<void>;
+export declare function rewriteSubpathImports(source: string): string;