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

package/dist/src/utils/dev-server-ready-check.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseServeFlags = parseServeFlags;
+exports.parseServeArgv = parseServeArgv;
+exports.getDevServerAddress = getDevServerAddress;
+exports.waitForWebpackDevServer = waitForWebpackDevServer;
+const internal_1 = require("@nx/devkit/internal");
+const module_1 = require("module");
+const path_1 = require("path");
+/** The flags of `webpack-cli serve` the check reads, from its parsed argv. */
+function parseServeFlags(argv) {
+    const env = {};
+    for (const value of argv.env ?? [])
+        parseEnv(value, env);
+    return {
+        port: argv.port,
+        host: argv.host,
+        configNames: argv.configName ?? [],
+        configs: argv.config ?? [],
+        merge: !!argv.merge,
+        env,
+        extends: argv.extends ?? [],
+    };
+}
+const stringConfig = [{ type: 'string' }];
+const flagConfig = [{ type: 'enum', values: [true] }];
+// webpack-cli's own options in any of its majors
+const CLI_OPTIONS = {
+    config: { alias: 'c', configs: stringConfig, multiple: true },
+    'config-name': { configs: stringConfig, multiple: true },
+    merge: { alias: 'm', configs: flagConfig },
+    'disable-interpret': { configs: flagConfig },
+    env: { configs: stringConfig, multiple: true },
+    'node-env': { configs: stringConfig },
+    'define-process-env-node-env': { configs: stringConfig },
+    'config-node-env': { configs: stringConfig },
+    analyze: { configs: flagConfig },
+    progress: { configs: [...stringConfig, ...flagConfig] },
+    json: { alias: 'j', configs: [...stringConfig, ...flagConfig] },
+    'fail-on-warnings': { configs: flagConfig },
+    extends: { alias: 'e', configs: stringConfig, multiple: true },
+};
+const CORE_ALIASES = {
+    devtool: 'd',
+    'output-path': 'o',
+    target: 't',
+    watch: 'w',
+};
+const VALUE_TYPES = {
+    boolean: 'boolean',
+    reset: 'boolean',
+    number: 'number',
+    string: 'string',
+    path: 'string',
+    RegExp: 'string',
+};
+/**
+ * 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.
+ */
+function parseServeArgv(options) {
+    const tokens = (0, internal_1.getForwardedArgs)(options);
+    // Registers only the options the args can name, since only those set a value
+    const named = new Set(tokens.flatMap((token) => {
+        if (!token.startsWith('-'))
+            return [];
+        if (!token.startsWith('--'))
+            return [...token.slice(1)];
+        const name = token.slice(2).split('=')[0];
+        return [name, name.replace(/^no-/, '')];
+    }));
+    if (named.size === 0)
+        return {};
+    const cliRequire = createWebpackCliRequire();
+    const { Command, Option } = cliRequire('commander');
+    const webpack = cliRequire('webpack');
+    const args = {
+        ...webpack.cli.getArguments(),
+        ...webpack.cli.getArguments(cliRequire('webpack-dev-server').schema),
+        ...CLI_OPTIONS,
+    };
+    const command = new Command().exitOverride();
+    for (const [name, arg] of Object.entries(args)) {
+        const alias = arg.alias ?? CORE_ALIASES[name];
+        if (named.has(name) || named.has(alias)) {
+            addCliOption(command, Option, name, { ...arg, alias });
+        }
+    }
+    // webpack-cli's program parses the args at least twice before `serve` does,
+    // and each pass drops a `--` that comes before any option it doesn't know
+    const program = new Command().option('--color').option('--no-color');
+    let serveArgs = ['serve', ...tokens];
+    for (let pass = 0; pass < 2; pass++) {
+        const { operands, unknown } = program.parseOptions(serveArgs);
+        serveArgs = [...operands, ...unknown];
+    }
+    command.parseOptions(serveArgs.slice(1));
+    return command.opts();
+}
+// Ports webpack-cli's makeOption
+function addCliOption(command, Option, name, { configs = [], multiple, alias }) {
+    const types = new Set();
+    let negatable = false;
+    for (const { type, values = [] } of configs) {
+        if (type === 'enum') {
+            for (const value of values) {
+                const valueType = VALUE_TYPES[typeof value];
+                if (value === false)
+                    negatable = true;
+                else if (valueType)
+                    types.add(valueType);
+            }
+        }
+        else if (VALUE_TYPES[type]) {
+            types.add(VALUE_TYPES[type]);
+            negatable ||= type === 'boolean';
+        }
+    }
+    if (types.size === 0 && !negatable)
+        return;
+    const takesValue = types.size > (types.has('boolean') ? 1 : 0);
+    const variadic = multiple ? '...' : '';
+    const placeholder = types.has('boolean')
+        ? ` [value${variadic}]`
+        : ` <value${variadic}>`;
+    const option = new Option(`${alias ? `-${alias}, ` : ''}--${name}${takesValue ? placeholder : ''}`);
+    if (takesValue) {
+        option.argParser((value, prev = []) => {
+            const number = Number(value);
+            if (types.has('number') && (types.size === 1 || !isNaN(number))) {
+                return multiple ? [prev, number].flat() : number;
+            }
+            return multiple && types.has('string') ? [prev, value].flat() : value;
+        });
+    }
+    command.addOption(option);
+    if (negatable)
+        command.addOption(new Option(`--no-${name}`));
+}
+// webpack-cli's `--env` parser, edge cases included
+function parseEnv(value, env) {
+    const [allKeys, val] = value.split(/[=](.+)/, 2);
+    const splitKeys = allKeys.split(/\.(?!$)/);
+    let prevRef = env;
+    for (let [index, someKey] of splitKeys.entries()) {
+        if (someKey.endsWith('=')) {
+            someKey = someKey.slice(0, -1);
+            prevRef[someKey] = undefined;
+            continue;
+        }
+        if (!prevRef[someKey] || typeof prevRef[someKey] === 'string') {
+            prevRef[someKey] = {};
+        }
+        if (index === splitKeys.length - 1) {
+            prevRef[someKey] = typeof val === 'string' ? val : true;
+        }
+        prevRef = prevRef[someKey];
+    }
+}
+/**
+ * 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.
+ */
+function getDevServerAddress(devServer, flags, basePort) {
+    if (devServer?.ipc)
+        return null;
+    const host = flags.host ?? devServer?.host;
+    return (0, internal_1.getServerAddress)(flags.port ?? devServer?.port ?? basePort ?? 8080, 
+    // `local-ip` and friends resolve to an interface address first, the way
+    // the dev server resolves them
+    typeof host === 'string' ? (0, internal_1.resolveStartupHost)(host) : undefined);
+}
+async function loadConfigExport(path) {
+    if (/\.(ts|mts|cts)$/.test(path)) {
+        const { getRootTsConfigPath } = require('@nx/js');
+        const { resolveUserDefinedWebpackConfig } = require('./webpack/resolve-user-defined-webpack-config');
+        return resolveUserDefinedWebpackConfig(path, getRootTsConfigPath());
+    }
+    const config = await (0, internal_1.loadConfigFile)(path);
+    // webpack-cli also unwraps a default export's own `default`
+    return config && typeof config === 'object' && 'default' in config
+        ? config.default
+        : config;
+}
+// webpack-cli runs from the task's cwd and loads its dependencies from its own
+// location
+function createWebpackCliRequire() {
+    return (0, module_1.createRequire)(require.resolve('webpack-cli', { paths: [process.cwd()] }));
+}
+function loadWebpackMerge() {
+    return createWebpackCliRequire()('webpack-merge').merge;
+}
+/**
+ * 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.
+ */
+async function waitForWebpackDevServer(configPath) {
+    await (0, internal_1.runReadyCheck)(async ({ options, root }) => {
+        const parsed = parseServeArgv(options);
+        const flags = parseServeFlags(parsed);
+        // Skips NxAppWebpackPlugin's option normalization, which nothing here uses
+        global.NX_GRAPH_CREATION = true;
+        const { readWebpackOptions } = require('./webpack/read-webpack-options');
+        const env = { WEBPACK_SERVE: true, ...flags.env };
+        const argv = { ...parsed, env };
+        const load = async (path) => readWebpackOptions(await loadConfigExport((0, path_1.resolve)(path)), env, argv);
+        let configs = (await Promise.all(
+        // The config's file name, in the cwd of the serve task
+        (flags.configs.length > 0
+            ? flags.configs
+            : [(0, path_1.resolve)(root, configPath)]).map(load)))
+            .flat()
+            .filter((config) => flags.configNames.length === 0 ||
+            flags.configNames.includes(config.name));
+        let webpackMerge;
+        const merge = (...configs) => (webpackMerge ??= loadWebpackMerge())(...configs);
+        const resolveExtends = async (config, extendsPaths, seen) => {
+            delete config.extends;
+            const paths = extendsPaths.map((path) => (0, path_1.resolve)(path));
+            if (paths.some((path) => seen.includes(path))) {
+                throw new Error('Recursive configuration detected.');
+            }
+            const extended = (await Promise.all(paths.map(load))).flat();
+            if (extended.length > 0)
+                config = merge(...extended, config);
+            return config.extends
+                ? resolveExtends(config, [config.extends].flat(), [...seen, ...paths])
+                : config;
+        };
+        configs = await Promise.all(configs.map((config) => flags.extends.length > 0
+            ? resolveExtends(config, flags.extends, [])
+            : config.extends
+                ? resolveExtends(config, [config.extends].flat(), [])
+                : config));
+        if (flags.merge) {
+            if (configs.length < 2) {
+                throw new Error('At least two configurations are required for merge.');
+            }
+            configs = [configs.reduce((merged, config) => merge(merged, config), {})];
+        }
+        // webpack-cli starts a dev server for every config with devServer, or for
+        // the first config when none has one
+        const withDevServer = configs.filter((config) => config.devServer);
+        const servers = withDevServer.length > 0 ? withDevServer : configs.slice(0, 1);
+        const addresses = servers
+            .filter((config) => config.devServer !== false)
+            .map((config) => getDevServerAddress(config.devServer, flags, process.env.WEBPACK_DEV_SERVER_BASE_PORT));
+        return addresses.some((address) => address === null) ? null : addresses;
+    });
+}

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

@@ -0,0 +1,29 @@
+import type { AddressInfo } from 'net';
+import type { Compiler } from 'webpack';
+export declare const READY_SIGNAL_PLUGIN: unique symbol;
+/** Whether the dev server of this config will report its readiness. */
+export declare function sendsReadySignal(config: {
+    devServer?: unknown;
+    plugins?: unknown[];
+}): boolean;
+/**
+ * Reports the dev server's address to an Nx task whose readyWhen is `signal`.
+ * `webpack-cli serve` reads `devServer` from the compiler after plugins apply,
+ * so wrapping `onListening` here reaches the server it starts.
+ */
+export declare function applyDevServerReadySignal(compiler: Compiler): void;
+/** Reports the dev server's address to an Nx task whose readyWhen is `signal`. */
+export declare class NxReadySignalPlugin {
+    readonly [READY_SIGNAL_PLUGIN] = true;
+    apply(compiler: Compiler): void;
+}
+export declare function getDevServerUrl(server: {
+    server?: {
+        address(): AddressInfo | string | null;
+    };
+    options?: {
+        server?: string | {
+            type?: string;
+        };
+    };
+}): string | undefined;

package/dist/src/utils/dev-server-ready-signal.js

@@ -0,0 +1,51 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxReadySignalPlugin = exports.READY_SIGNAL_PLUGIN = void 0;
+exports.sendsReadySignal = sendsReadySignal;
+exports.applyDevServerReadySignal = applyDevServerReadySignal;
+exports.getDevServerUrl = getDevServerUrl;
+// Set on the plugins that report readiness, so inference can find them in a
+// config it has loaded
+exports.READY_SIGNAL_PLUGIN = Symbol.for('@nx/ready-signal-plugin');
+/** Whether the dev server of this config will report its readiness. */
+function sendsReadySignal(config) {
+    return (typeof config.devServer === 'object' &&
+        !!config.devServer &&
+        !!config.plugins?.some((plugin) => plugin?.[exports.READY_SIGNAL_PLUGIN]));
+}
+/**
+ * Reports the dev server's address to an Nx task whose readyWhen is `signal`.
+ * `webpack-cli serve` reads `devServer` from the compiler after plugins apply,
+ * so wrapping `onListening` here reaches the server it starts.
+ */
+function applyDevServerReadySignal(compiler) {
+    const devServer = compiler.options.devServer;
+    if (!devServer || !process.env.NX_READY_SIGNAL_SOCKET) {
+        return;
+    }
+    const { emitReadySignal } = require('@nx/devkit');
+    const onListening = devServer.onListening;
+    devServer.onListening = (server) => {
+        onListening?.(server);
+        emitReadySignal(getDevServerUrl(server));
+    };
+}
+/** Reports the dev server's address to an Nx task whose readyWhen is `signal`. */
+class NxReadySignalPlugin {
+    constructor() {
+        this[_a] = true;
+    }
+    apply(compiler) {
+        applyDevServerReadySignal(compiler);
+    }
+}
+exports.NxReadySignalPlugin = NxReadySignalPlugin;
+_a = exports.READY_SIGNAL_PLUGIN;
+function getDevServerUrl(server) {
+    const { getListeningUrl } = require('@nx/devkit/internal');
+    const type = typeof server.options?.server === 'string'
+        ? server.options.server
+        : server.options?.server?.type;
+    return getListeningUrl(server.server?.address(), !!type && type !== 'http');
+}

package/dist/src/utils/e2e-web-server-info-utils.d.ts

@@ -1,2 +1,2 @@
 import { type Tree } from '@nx/devkit';
-export declare function getWebpackE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, isPluginBeingAdded: boolean, e2ePortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;
+export declare function getWebpackE2EWebServerInfo(tree: Tree, projectName: string, configFilePath: string, e2ePortOverride?: number): Promise<import("@nx/devkit/internal").E2EWebServerDetails>;

package/dist/src/utils/e2e-web-server-info-utils.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWebpackE2EWebServerInfo = getWebpackE2EWebServerInfo;
 const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/devkit/internal");
-async function getWebpackE2EWebServerInfo(tree, projectName, configFilePath, isPluginBeingAdded, e2ePortOverride) {
+async function getWebpackE2EWebServerInfo(tree, projectName, configFilePath, e2ePortOverride) {
     const nxJson = (0, devkit_1.readNxJson)(tree);
     let e2ePort = e2ePortOverride ?? 4200;
     const servePort = (0, internal_1.readTargetDefaultsForTarget)('serve', nxJson.targetDefaults)
@@ -26,5 +26,5 @@ async function getWebpackE2EWebServerInfo(tree, projectName, configFilePath, isP
         defaultE2ECiBaseUrl: `http://localhost:${e2ePort}`,
         defaultE2EPort: e2ePort,
         e2EPortIsExplicit: e2ePortOverride != null,
-    }, isPluginBeingAdded);
+    });
 }

package/dist/src/utils/webpack/read-webpack-options.d.ts

@@ -8,4 +8,4 @@ import type { Configuration } from 'webpack';
  *
  * @param webpackConfig
  */
-export declare function readWebpackOptions(webpackConfig: unknown): Promise<Configuration[]>;
+export declare function readWebpackOptions(webpackConfig: unknown, env?: Record<string, unknown>, argv?: Record<string, unknown>): Promise<Configuration[]>;

package/dist/src/utils/webpack/read-webpack-options.js

@@ -13,7 +13,9 @@ const internal_1 = require("@nx/devkit/internal");
  *
  * @param webpackConfig
  */
-async function readWebpackOptions(webpackConfig) {
+async function readWebpackOptions(webpackConfig, 
+// A function config gets the production build's env unless told otherwise
+env = { production: true }, argv = {}) {
     const configs = [];
     const resolveConfig = async (config) => {
         if ((0, config_1.isNxWebpackComposablePlugin)(config)) {
@@ -39,9 +41,7 @@ async function readWebpackOptions(webpackConfig) {
             });
         }
         else if (typeof config === 'function') {
-            const resolved = await config({
-                production: true, // we want the production build options
-            }, {});
+            const resolved = await config(env, argv);
             // If the resolved configuration is an array, resolve each configuration
             return Array.isArray(resolved)
                 ? (await Promise.all(resolved.map(resolveConfig))).flat()

package/dist/src/utils/with-nx.d.ts

@@ -1,12 +1,8 @@
-import { NxComposableWebpackPlugin } from './config';
-import { NxAppWebpackPluginOptions } from '../plugins/nx-webpack-plugin/nx-app-webpack-plugin-options';
+import type { NxComposableWebpackPlugin } from './config';
+import type { NxAppWebpackPluginOptions } from '../plugins/nx-webpack-plugin/nx-app-webpack-plugin-options';
 export type WithNxOptions = Partial<NxAppWebpackPluginOptions>;
 /**
- * @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.
- * @param {WithNxOptions} pluginOptions
- * @returns {NxWebpackPlugin}
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function withNx(pluginOptions?: WithNxOptions): NxComposableWebpackPlugin;
+export declare function withNx(_options?: WithNxOptions): NxComposableWebpackPlugin;

package/dist/src/utils/with-nx.js

@@ -1,40 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withNx = withNx;
-const normalize_options_1 = require("../plugins/nx-webpack-plugin/lib/normalize-options");
 const deprecation_1 = require("./deprecation");
-const processed = new Set();
+// 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.
- * @param {WithNxOptions} pluginOptions
- * @returns {NxWebpackPlugin}
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function withNx(pluginOptions = {}) {
+function withNx(_options = {}) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return function configure(config, { options, context }) {
-        if (processed.has(config))
-            return config;
-        // Lazy-required so importing this module does not load the webpack bundler.
-        const { applyBaseConfig } = require('../plugins/nx-webpack-plugin/lib/apply-base-config');
-        applyBaseConfig({
-            ...options,
-            ...pluginOptions,
-            target: options.target ?? 'web',
-            assets: options.assets
-                ? options.assets
-                : pluginOptions.assets
-                    ? (0, normalize_options_1.normalizeAssets)(pluginOptions.assets, options.root, options.sourceRoot, options.projectRoot)
-                    : [],
-            root: context.root,
-            projectName: context.projectName,
-            targetName: context.targetName,
-            configurationName: context.configurationName,
-            projectGraph: context.projectGraph,
-        }, config);
-        processed.add(config);
-        return config;
-    };
+    return (config) => config;
 }

package/dist/src/utils/with-web.d.ts

@@ -1,5 +1,5 @@
-import { NxComposableWebpackPlugin } from './config';
-import { ExtraEntryPointClass, NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
+import type { NxComposableWebpackPlugin } from './config';
+import type { ExtraEntryPointClass, NormalizedWebpackExecutorOptions } from '../executors/webpack/schema';
 export interface WithWebOptions {
     baseHref?: string;
     crossOrigin?: 'none' | 'anonymous' | 'use-credentials';
@@ -20,11 +20,7 @@ export interface WithWebOptions {
 }
 export type MergedOptions = Omit<NormalizedWebpackExecutorOptions, keyof WithWebOptions> & WithWebOptions;
 /**
- * @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.
- * @param {WithWebOptions} pluginOptions
- * @returns {NxWebpackPlugin}
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function withWeb(pluginOptions?: WithWebOptions): NxComposableWebpackPlugin;
+export declare function withWeb(_options?: WithWebOptions): NxComposableWebpackPlugin;

package/dist/src/utils/with-web.js

@@ -2,31 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withWeb = withWeb;
 const deprecation_1 = require("./deprecation");
-const processed = new Set();
+// 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.
- * @param {WithWebOptions} pluginOptions
- * @returns {NxWebpackPlugin}
+ * @deprecated Use `NxAppWebpackPlugin` from `@nx/webpack/app-plugin`.
+ * This inert stub will be removed in Nx v25.
  */
-function withWeb(pluginOptions = {}) {
+function withWeb(_options = {}) {
     (0, deprecation_1.warnWebpackComposeHelpersDeprecation)();
-    return function configure(config, { options, context }) {
-        if (processed.has(config))
-            return config;
-        // Lazy-required so importing this module does not load the webpack bundler.
-        const { applyWebConfig } = require('../plugins/nx-webpack-plugin/lib/apply-web-config');
-        applyWebConfig({
-            ...options,
-            ...pluginOptions,
-            projectName: context.projectName,
-            targetName: context.targetName,
-            configurationName: context.configurationName,
-            projectGraph: context.projectGraph,
-        }, config);
-        processed.add(config);
-        return config;
-    };
+    return (config) => config;
 }

package/executors.json

@@ -1,15 +1,5 @@
 {
   "executors": {
-    "webpack": {
-      "implementation": "./dist/src/executors/webpack/webpack.impl",
-      "schema": "./dist/src/executors/webpack/schema.json",
-      "description": "Run webpack build."
-    },
-    "dev-server": {
-      "implementation": "./dist/src/executors/dev-server/dev-server.impl",
-      "schema": "./dist/src/executors/dev-server/schema.json",
-      "description": "Serve a web application."
-    },
     "ssr-dev-server": {
       "implementation": "./dist/src/executors/ssr-dev-server/ssr-dev-server.impl",
       "schema": "./dist/src/executors/ssr-dev-server/schema.json",

package/migrations.json

@@ -30,6 +30,19 @@
       "description": "Rename imports of `createNodesV2` from `@nx/webpack/plugin` to the canonical `createNodes` export.",
       "implementation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes",
       "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
+    },
+    "remove-deprecated-executors": {
+      "version": "24.0.0-beta.3",
+      "description": "Converts targets using the removed `@nx/webpack` executors to inferred tasks; an AI prompt finishes the targets the converter cannot convert safely and validates the project graph.",
+      "implementation": "./dist/src/migrations/update-24-0-0/remove-deprecated-executors",
+      "prompt": "./dist/src/migrations/update-24-0-0/finish-inferred-conversion.md",
+      "documentation": "./dist/src/migrations/update-24-0-0/remove-deprecated-executors.md"
+    },
+    "update-24-0-0-migrate-compose-plugins": {
+      "version": "24.0.0-beta.3",
+      "description": "Converts webpack configs that use the removed `composePlugins`, `withNx`, `withWeb` and `withReact` helpers with `@nx/webpack:convert-config-to-webpack-plugin`, then hands an AI prompt the projects it could not convert and the `.old` configs it left behind.",
+      "implementation": "./dist/src/migrations/update-24-0-0/migrate-compose-plugins",
+      "prompt": "./dist/src/migrations/update-24-0-0/migrate-compose-plugins.md"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/webpack",
-  "version": "24.0.0-pr.37405.acdaf31",
+  "version": "24.0.0-rc.0",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -38,6 +38,12 @@
       ],
       "internal": [
         "dist/internal.d.ts"
+      ],
+      "ready-check": [
+        "dist/ready-check.d.ts"
+      ],
+      "ready-signal": [
+        "dist/ready-signal.d.ts"
       ]
     }
   },
@@ -74,6 +80,16 @@
       "types": "./dist/plugin.d.ts",
       "default": "./dist/plugin.js"
     },
+    "./ready-check": {
+      "@nx/nx-source": "./ready-check.ts",
+      "types": "./dist/ready-check.d.ts",
+      "default": "./dist/ready-check.js"
+    },
+    "./ready-signal": {
+      "@nx/nx-source": "./ready-signal.ts",
+      "types": "./dist/ready-signal.d.ts",
+      "default": "./dist/ready-signal.js"
+    },
     "./tsconfig-paths-plugin": {
       "@nx/nx-source": "./tsconfig-paths-plugin.ts",
       "types": "./dist/tsconfig-paths-plugin.d.ts",
@@ -118,8 +134,8 @@
     "tslib": "^2.3.0",
     "webpack-node-externals": "^3.0.0",
     "webpack-subresource-integrity": "^5.1.0",
-    "@nx/devkit": "24.0.0-pr.37405.acdaf31",
-    "@nx/js": "24.0.0-pr.37405.acdaf31"
+    "@nx/devkit": "24.0.0-rc.0",
+    "@nx/js": "24.0.0-rc.0"
   },
   "peerDependencies": {
     "webpack": "^5.0.0",
@@ -138,7 +154,7 @@
     }
   },
   "devDependencies": {
-    "nx": "24.0.0-pr.37405.acdaf31"
+    "nx": "24.0.0-rc.0"
   },
   "publishConfig": {
     "access": "public"

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

@@ -1,3 +0,0 @@
-import type webpack from 'webpack';
-import { Observable } from 'rxjs';
-export declare function runWebpack(config: webpack.Configuration): Observable<webpack.Stats>;

package/dist/src/executors/webpack/lib/run-webpack.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runWebpack = runWebpack;
-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 = webpackImpl(normalizedConfig);
-        const callback = (err, stats) => {
-            if (err) {
-                subscriber.error(err);
-            }
-            subscriber.next(stats);
-        };
-        if (config.watch) {
-            const watchOptions = config.watchOptions || {};
-            const watching = webpackCompiler.watch(watchOptions, callback);
-            return () => watching.close(() => subscriber.complete());
-        }
-        else {
-            webpackCompiler.run((err, stats) => {
-                callback(err, stats);
-                webpackCompiler.close((closeErr) => {
-                    if (closeErr)
-                        subscriber.error(closeErr);
-                    subscriber.complete();
-                });
-            });
-        }
-    });
-}