@nx/rspack 23.0.0 → 23.1.0-beta.1

package/README.md

@@ -7,13 +7,12 @@
 
 <div style="text-align: center;">
 
-[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
 [![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
 [![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
-[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+[![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)
 
 </div>
 

package/dist/src/executors/rspack/lib/config.js

@@ -18,8 +18,8 @@ async function getRspackConfigs(options, context) {
     }
     // Nx composes these helpers internally to build the default config; suppress
     // their deprecation warning so it fires only for user-authored configs.
-    const config = (0, deprecation_1.suppressRspackComposeHelperWarnings)(() => (options.target === 'web'
-        ? (0, config_1.composePluginsSync)((0, with_nx_1.withNx)(options), (0, with_web_1.withWeb)(options))
+    const config = await (0, deprecation_1.suppressRspackComposeHelperWarnings)(() => (options.target === 'web'
+        ? (0, config_1.composePlugins)((0, with_nx_1.withNx)(options), (0, with_web_1.withWeb)(options))
         : (0, with_nx_1.withNx)(options))({}, { options, context }));
     if (typeof userDefinedConfig === 'function' &&
         ((0, config_1.isNxRspackComposablePlugin)(userDefinedConfig) ||

package/dist/src/executors/rspack/rspack.impl.js

@@ -5,7 +5,6 @@ const devkit_1 = require("@nx/devkit");
 const internal_1 = require("@nx/devkit/internal");
 const js_1 = require("@nx/js");
 const internal_2 = require("@nx/js/internal");
-const core_1 = require("@rspack/core");
 const path_1 = require("path");
 const create_compiler_1 = require("../../utils/create-compiler");
 const mode_utils_1 = require("../../utils/mode-utils");
@@ -26,9 +25,9 @@ async function* runExecutor(options, context) {
     }
     const compiler = await (0, create_compiler_1.createCompiler)(normalizedOptions, context);
     const iterable = (0, internal_1.createAsyncIterable)(async ({ next, done }) => {
-        const watch = (compiler instanceof core_1.Compiler
-            ? compiler.options.watch
-            : compiler.options[0].watch) ?? options.watch;
+        const watch = ((0, create_compiler_1.isMultiCompiler)(compiler)
+            ? compiler.options[0].watch
+            : compiler.options.watch) ?? options.watch;
         if (watch) {
             const watcher = compiler.watch({}, async (err, stats) => {
                 if (err) {

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

@@ -1,8 +1,8 @@
 import { ExecutorContext } from '@nx/devkit';
 import { RspackSsrDevServerOptions, TargetOptions } from './schema';
 export declare function ssrDevServerExecutor(options: RspackSsrDevServerOptions, context: ExecutorContext): AsyncGenerator<{
-    baseUrl: string;
     success: boolean;
     options: TargetOptions;
+    baseUrl: string;
 }, void, unknown>;
 export default ssrDevServerExecutor;

package/dist/src/generators/configuration/configuration.js

@@ -13,13 +13,11 @@ function projectIsRootProjectInStandaloneWorkspace(projectRoot) {
     return (0, path_1.relative)(devkit_1.workspaceRoot, projectRoot).length === 0;
 }
 function editTsConfig(tree, projectRoot, framework, relativePathToRootTsConfig) {
-    const shared = require('@nx/js');
     if (framework === 'react') {
         const json = {
             compilerOptions: {
                 jsx: 'react-jsx',
                 allowJs: false,
-                esModuleInterop: false,
                 allowSyntheticDefaultImports: true,
                 strict: true,
             },
@@ -35,7 +33,7 @@ function editTsConfig(tree, projectRoot, framework, relativePathToRootTsConfig)
         if (projectIsRootProjectInStandaloneWorkspace(projectRoot)) {
             json.compileOnSave = false;
             json.compilerOptions = {
-                ...shared.tsConfigBaseOptions,
+                ...(0, internal_1.getTsConfigBaseOptions)(tree),
                 ...json.compilerOptions,
             };
             json.exclude = ['node_modules', 'tmp'];

package/dist/src/migrations/update-23-0-0/migrate-rspack-config-to-v2.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateRspackConfigToV2(tree: Tree): Promise<void>;
+export declare function rewriteLibraryTarget(source: string): string;
+export declare function disableLazyCompilationForModuleFederation(source: string): string;
+export declare function rewriteExperimentsCss(source: string): string;

package/dist/src/migrations/update-23-0-0/migrate-rspack-config-to-v2.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateRspackConfigToV2;
+exports.rewriteLibraryTarget = rewriteLibraryTarget;
+exports.disableLazyCompilationForModuleFederation = disableLazyCompilationForModuleFederation;
+exports.rewriteExperimentsCss = rewriteExperimentsCss;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const ts = tslib_1.__importStar(require("typescript"));
+// Rewrite rspack.config.{js,ts,mjs,cjs} for @rspack/core@2:
+// - output.libraryTarget → output.library.type
+// - experiments.css: true dropped (default in v2); :false replaced with a comment
+// - module federation configs get lazyCompilation: false (rspack-cli@2 dev
+//   mode enables it by default, which breaks federated remotes)
+// See rspack.rs/guide/migration/rspack_1.x.
+async function migrateRspackConfigToV2(tree) {
+    const configFiles = [];
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (filePath.endsWith('rspack.config.ts') ||
+            filePath.endsWith('rspack.config.js') ||
+            filePath.endsWith('rspack.config.mjs') ||
+            filePath.endsWith('rspack.config.cjs')) {
+            configFiles.push(filePath);
+        }
+    });
+    for (const configFile of configFiles) {
+        const original = tree.read(configFile, 'utf-8');
+        if (!original)
+            continue;
+        let next = rewriteLibraryTarget(original);
+        next = rewriteExperimentsCss(next);
+        next = disableLazyCompilationForModuleFederation(next);
+        if (next !== original) {
+            tree.write(configFile, next);
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+function applyEdits(source, edits) {
+    if (edits.length === 0)
+        return source;
+    // Apply back-to-front so earlier edits don't shift later offsets.
+    const sorted = [...edits].sort((a, b) => b.start - a.start);
+    return sorted.reduce((acc, e) => acc.slice(0, e.start) + e.replacement + acc.slice(e.end), source);
+}
+function getPropertyName(prop) {
+    const name = prop.name;
+    if (ts.isIdentifier(name))
+        return name.text;
+    if (ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function isInsideObjectKeyed(prop, parentKey) {
+    const objLiteral = prop.parent;
+    if (!objLiteral || !ts.isObjectLiteralExpression(objLiteral))
+        return false;
+    const containingProp = objLiteral.parent;
+    if (!containingProp || !ts.isPropertyAssignment(containingProp))
+        return false;
+    return getPropertyName(containingProp) === parentKey;
+}
+function rewriteLibraryTarget(source) {
+    if (!source.includes('libraryTarget'))
+        return source;
+    const sourceFile = (0, tsquery_1.ast)(source);
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            getPropertyName(node) === 'libraryTarget' &&
+            isInsideObjectKeyed(node, 'output') &&
+            isStringLikeInitializer(node.initializer)) {
+            const valueText = node.initializer.getText(sourceFile);
+            edits.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                replacement: `library: { type: ${valueText} }`,
+            });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return applyEdits(source, edits);
+}
+function isStringLikeInitializer(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node);
+}
+// rspack-cli@2 dev mode enables lazyCompilation unless the config sets it
+// explicitly, and lazy-compiled dynamic imports break module federation
+// remotes. Insert `lazyCompilation: false` into plain-object configs that use
+// module federation. Compose-style configs (withModuleFederation) are handled
+// at runtime by withModuleFederation itself.
+function disableLazyCompilationForModuleFederation(source) {
+    if (!source.includes('NxModuleFederationPlugin') &&
+        !source.includes('ModuleFederationPlugin')) {
+        return source;
+    }
+    if (source.includes('lazyCompilation'))
+        return source;
+    const sourceFile = (0, tsquery_1.ast)(source);
+    const edits = [];
+    const insertIntoObject = (obj) => {
+        const start = obj.getStart(sourceFile) + 1;
+        edits.push({
+            start,
+            end: start,
+            replacement: '\n  // rspack-cli dev mode defaults this on; it breaks module federation.\n  lazyCompilation: false,',
+        });
+    };
+    const visit = (node) => {
+        // export default { ... }
+        if (ts.isExportAssignment(node) &&
+            ts.isObjectLiteralExpression(node.expression)) {
+            insertIntoObject(node.expression);
+            return;
+        }
+        // module.exports = { ... }
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isObjectLiteralExpression(node.right) &&
+            node.left.getText(sourceFile) === 'module.exports') {
+            insertIntoObject(node.right);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return applyEdits(source, edits);
+}
+// `experiments.css: true` is left for the companion AI-prompt migration
+// `rewrite-experiments-css-to-module-rules` to handle.
+function rewriteExperimentsCss(source) {
+    if (!/\bcss\s*:/.test(source))
+        return source;
+    const sourceFile = (0, tsquery_1.ast)(source);
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            getPropertyName(node) === 'css' &&
+            isInsideObjectKeyed(node, 'experiments') &&
+            node.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+            // Delete the property + its trailing comma and newline so the
+            // surrounding object literal stays well-formed.
+            let endOfRemoval = node.getEnd();
+            const trailingText = source.slice(endOfRemoval);
+            const trailingMatch = trailingText.match(/^\s*,?\s*\r?\n/);
+            if (trailingMatch) {
+                endOfRemoval += trailingMatch[0].length;
+            }
+            let startOfRemoval = node.getStart(sourceFile);
+            const lineStart = source.lastIndexOf('\n', startOfRemoval - 1) + 1;
+            if (source.slice(lineStart, startOfRemoval).trim() === '') {
+                startOfRemoval = lineStart;
+            }
+            edits.push({ start: startOfRemoval, end: endOfRemoval, replacement: '' });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return applyEdits(source, edits);
+}

package/dist/src/migrations/update-23-0-0/rewrite-experiments-css-to-module-rules.md

@@ -0,0 +1,96 @@
+#### Rewrite `experiments.css: true` for `@rspack/core@2`
+
+`@rspack/core@2` removed `experiments.css` and promoted CSS handling to a
+default-available feature — but it's now opt-in **per file type** via
+`module.rules`. Workspaces that set `experiments.css: true` on v1 will
+silently lose CSS processing on v2 unless `module.rules` declares a rule
+matching their CSS file extensions with a `type` of `'css'`, `'css/module'`,
+or `'css/auto'`.
+
+This change is workspace-specific (which `test:` regex, which `type:`,
+whether existing rules already cover it), so the migration ships as an
+AI-assisted instruction rather than a blind codemod.
+
+#### What needs to change
+
+For every `rspack.config.{ts,js,mjs,cjs}` in the workspace that has
+`experiments.css: true`:
+
+1. **Delete the `experiments.css: true` line.** If `experiments` becomes
+   empty after the deletion, delete the whole `experiments: { ... }`
+   property too.
+
+2. **Ensure `module.rules` has a CSS rule using `type: 'css/auto'`** (or
+   `'css'` / `'css/module'` if you have a stronger preference). The rspack
+   docs recommend `'css/auto'` because it auto-detects CSS Modules
+   (filenames matching `*.module.css`).
+   - If `module.rules` already has an entry that matches `.css` files —
+     for example via `css-loader` / `style-loader` / `MiniCssExtractPlugin`
+     — **leave it alone**. The user opted into a loader pipeline on v1 and
+     that pipeline still works on v2.
+
+   - If `module.rules` has no CSS-related rule at all, append:
+
+     ```ts
+     {
+       test: /\.css$/,
+       type: 'css/auto',
+     }
+     ```
+
+3. **Do not touch `experiments.css: false` configs.** Those are handled
+   automatically by the deterministic codemod that runs alongside this
+   prompt.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts title="apps/myapp/rspack.config.ts" {3-5}
+export default {
+  // ...
+  experiments: {
+    css: true,
+  },
+};
+```
+
+##### After
+
+```ts title="apps/myapp/rspack.config.ts" {3-7}
+export default {
+  // ...
+  module: {
+    rules: [{ test: /\.css$/, type: 'css/auto' }],
+  },
+};
+```
+
+##### Before — workspace that already uses css-loader
+
+```ts title="apps/myapp/rspack.config.ts" {3-5,7-10}
+export default {
+  // ...
+  experiments: {
+    css: true,
+  },
+  module: {
+    rules: [{ test: /\.css$/, use: ['style-loader', 'css-loader'] }],
+  },
+};
+```
+
+##### After — `experiments.css` removed, existing rule untouched
+
+```ts title="apps/myapp/rspack.config.ts"
+export default {
+  // ...
+  module: {
+    rules: [{ test: /\.css$/, use: ['style-loader', 'css-loader'] }],
+  },
+};
+```
+
+#### Reference
+
+[`@rspack/core@2` migration guide — Remove experiments.css](https://rspack.rs/guide/migration/rspack_1.x#remove-experimentscss)

package/dist/src/plugins/generate-package-json-plugin.d.ts

@@ -1,5 +1,5 @@
 import { ExecutorContext } from '@nx/devkit';
-import { type Compiler, type RspackPluginInstance } from '@rspack/core';
+import type { Compiler, RspackPluginInstance } from '@rspack/core';
 export declare class GeneratePackageJsonPlugin implements RspackPluginInstance {
     private readonly options;
     private readonly context;

package/dist/src/plugins/generate-package-json-plugin.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeneratePackageJsonPlugin = void 0;
 const devkit_1 = require("@nx/devkit");
 const js_1 = require("@nx/js");
-const core_1 = require("@rspack/core");
 const pluginName = 'GeneratePackageJsonPlugin';
 class GeneratePackageJsonPlugin {
     constructor(options, context) {
@@ -13,10 +12,11 @@ class GeneratePackageJsonPlugin {
     }
     apply(compiler) {
         compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
-            compilation.hooks.processAssets.tap({
+            compilation.hooks.processAssets.tapPromise({
                 name: pluginName,
                 stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-            }, () => {
+            }, async () => {
+                const sources = compiler.webpack.sources;
                 const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(this.context.root, this.context.projectName, this.projectGraph);
                 const importHelpers = !!(0, js_1.readTsConfig)(this.options.tsConfig).options
                     .importHelpers;
@@ -36,7 +36,7 @@ class GeneratePackageJsonPlugin {
                     helperDependencies: helperDependencies.map((dep) => dep.target),
                 });
                 packageJson.main = packageJson.main ?? this.options.outputFileName;
-                compilation.emitAsset('package.json', new core_1.sources.RawSource((0, devkit_1.serializeJson)(packageJson)));
+                compilation.emitAsset('package.json', new sources.RawSource((0, devkit_1.serializeJson)(packageJson)));
                 const packageManager = (0, devkit_1.detectPackageManager)(this.context.root);
                 if (packageManager === 'bun') {
                     compilation
@@ -44,7 +44,7 @@ class GeneratePackageJsonPlugin {
                         .warn('Bun lockfile generation is not supported. Only package.json will be generated.');
                 }
                 else {
-                    compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new core_1.sources.RawSource((0, js_1.createLockFile)(packageJson, this.projectGraph, packageManager)));
+                    compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new sources.RawSource((0, js_1.createLockFile)(packageJson, this.projectGraph, packageManager)));
                 }
             });
         });

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

@@ -35,6 +35,7 @@ class NxAppRspackPlugin {
         }
         (0, apply_base_config_1.applyBaseConfig)(this.options, compiler.options, {
             useNormalizedEntry: true,
+            compiler,
         });
         if (compiler.options.target) {
             this.options.target = compiler.options.target;
@@ -42,6 +43,7 @@ class NxAppRspackPlugin {
         if (this.options.target === 'web' || this.options.target === 'webworker') {
             (0, apply_web_config_1.applyWebConfig)(this.options, compiler.options, {
                 useNormalizedEntry: true,
+                compiler,
             });
         }
     }

package/dist/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.js

@@ -7,7 +7,8 @@ class NxReactRspackPlugin {
         this.options = options;
     }
     apply(compiler) {
-        (0, apply_react_config_1.applyReactConfig)(this.options, compiler.options);
+        (0, apply_react_config_1.applyReactConfigSync)(compiler.options);
+        (0, apply_react_config_1.applyReactHotReloadToCompiler)(compiler);
     }
 }
 exports.NxReactRspackPlugin = NxReactRspackPlugin;

package/dist/src/plugins/utils/apply-base-config.d.ts

@@ -1,5 +1,6 @@
-import { Configuration, RspackOptionsNormalized } from '@rspack/core';
+import type { Compiler, Configuration, RspackOptionsNormalized } from '@rspack/core';
 import { NormalizedNxAppRspackPluginOptions } from './models';
-export declare function applyBaseConfig(options: NormalizedNxAppRspackPluginOptions, config?: Partial<RspackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
+export declare function applyBaseConfig(options: NormalizedNxAppRspackPluginOptions, config?: Partial<RspackOptionsNormalized | Configuration>, { useNormalizedEntry, compiler, }?: {
     useNormalizedEntry?: boolean;
+    compiler?: Compiler;
 }): void;

package/dist/src/plugins/utils/apply-base-config.js

@@ -4,8 +4,8 @@ exports.applyBaseConfig = applyBaseConfig;
 const tslib_1 = require("tslib");
 const path = tslib_1.__importStar(require("path"));
 const license_webpack_plugin_1 = require("license-webpack-plugin");
-const core_1 = require("@rspack/core");
 const js_1 = require("@nx/js");
+const version_utils_1 = require("../../utils/version-utils");
 const stats_json_plugin_1 = require("./plugins/stats-json-plugin");
 const generate_package_json_plugin_1 = require("./plugins/generate-package-json-plugin");
 const hash_format_1 = require("./hash-format");
@@ -14,6 +14,7 @@ const get_terser_ecma_version_1 = require("./get-terser-ecma-version");
 const nodeExternals = require("webpack-node-externals");
 const internal_1 = require("@nx/js/internal");
 const get_non_buildable_libs_1 = require("./get-non-buildable-libs");
+const is_serve_mode_1 = require("../../utils/is-serve-mode");
 const IGNORED_RSPACK_WARNINGS = [
     /The comment file/i,
     /could not find any license/i,
@@ -26,7 +27,7 @@ const extensionAlias = {
     '.jsx': ['.tsx', '.jsx'],
 };
 const mainFields = ['module', 'main'];
-function applyBaseConfig(options, config = {}, { useNormalizedEntry, } = {}) {
+function applyBaseConfig(options, config = {}, { useNormalizedEntry, compiler, } = {}) {
     // Defaults that was applied from executor schema previously.
     options.externalDependencies ??= 'all';
     options.fileReplacements ??= [];
@@ -34,15 +35,21 @@ function applyBaseConfig(options, config = {}, { useNormalizedEntry, } = {}) {
     options.transformers ??= [];
     options.progress ??= true;
     options.outputHashing ??= 'all';
-    applyNxIndependentConfig(options, config);
+    // Lazy-require avoids loading @rspack/core (pure ESM in v2) at module
+    // parse time, so Jest can still load this file.
+    const rspackCore = compiler
+        ? compiler.rspack
+        : require('@rspack/core');
+    applyNxIndependentConfig(options, config, rspackCore);
     // Some of the options only work during actual tasks, not when reading the rspack config during CreateNodes.
     if (global.NX_GRAPH_CREATION)
         return;
-    applyNxDependentConfig(options, config, { useNormalizedEntry });
+    applyNxDependentConfig(options, config, { useNormalizedEntry }, rspackCore);
 }
-function applyNxIndependentConfig(options, config) {
+function applyNxIndependentConfig(options, config, rspackCore) {
+    const { SwcJsMinimizerRspackPlugin } = rspackCore;
     const isProd = process.env.NODE_ENV === 'production' || options.mode === 'production';
-    const isDevServer = process.env['WEBPACK_SERVE'];
+    const isDevServer = (0, is_serve_mode_1.isServeMode)();
     const hashFormat = (0, hash_format_1.getOutputHashFormat)(options.outputHashing);
     config.context = path.join(options.root, options.projectRoot);
     config.target ??= options.target;
@@ -75,30 +82,40 @@ function applyNxIndependentConfig(options, config) {
                 : undefined;
     config.devtool =
         options.sourceMap === true ? 'source-map' : options.sourceMap;
+    const existingOutputConfig = config.output;
+    const existingLibraryTarget = existingOutputConfig?.libraryTarget;
+    const existingLibraryType = typeof existingOutputConfig?.library === 'object' &&
+        'type' in existingOutputConfig?.library
+        ? existingOutputConfig?.library?.type
+        : undefined;
+    const computedLibraryType = (() => {
+        if (existingLibraryType !== undefined)
+            return undefined;
+        if (existingLibraryTarget !== undefined)
+            return existingLibraryTarget;
+        if (options.target === 'node')
+            return 'commonjs';
+        if (options.target === 'async-node')
+            return 'commonjs-module';
+        return undefined;
+    })();
+    // @rspack/core@2 removed output.libraryTarget; emit library.type instead.
+    const installedRspackMajor = (0, version_utils_1.getRspackCoreMajorVersion)(rspackCore);
+    const existingLibrary = typeof config.output?.library === 'object' ? config.output.library : {};
+    const libraryOutput = computedLibraryType === undefined
+        ? {}
+        : installedRspackMajor >= 2
+            ? {
+                library: { ...existingLibrary, type: computedLibraryType },
+                libraryTarget: undefined,
+            }
+            : { libraryTarget: computedLibraryType };
+    if (existingLibraryType !== undefined) {
+        libraryOutput.libraryTarget = undefined;
+    }
     config.output = {
         ...(config.output ?? {}),
-        libraryTarget: (() => {
-            const existingOutputConfig = config.output;
-            const existingLibraryTarget = existingOutputConfig?.libraryTarget;
-            const existingLibraryType = typeof existingOutputConfig?.library === 'object' &&
-                'type' in existingOutputConfig?.library
-                ? existingOutputConfig?.library?.type
-                : undefined;
-            // If user is using modern library.type, don't set the deprecated libraryTarget
-            if (existingLibraryType !== undefined) {
-                return undefined;
-            }
-            // If user has set libraryTarget explicitly, use it
-            if (existingLibraryTarget !== undefined) {
-                return existingLibraryTarget;
-            }
-            // Set defaults based on target when user hasn't configured anything
-            if (options.target === 'node')
-                return 'commonjs';
-            if (options.target === 'async-node')
-                return 'commonjs-module';
-            return undefined;
-        })(),
+        ...libraryOutput,
         path: config.output?.path ??
             (options.outputPath
                 ? // If path is relative, it is relative from project root (aka cwd).
@@ -120,7 +137,11 @@ function applyNxIndependentConfig(options, config) {
     config.watchOptions = {
         poll: options.poll,
     };
-    config.profile = options.statsJson;
+    // TODO(v24): drop once @rspack/core v1 is out of the support window.
+    // v2 removed top-level `profile`; Rsdoctor replaces it.
+    if (options.statsJson && installedRspackMajor < 2) {
+        config.profile = true;
+    }
     config.performance = {
         ...config.performance,
         hints: false,
@@ -138,7 +159,7 @@ function applyNxIndependentConfig(options, config) {
                     ? !!options.optimization.scripts
                     : !!options.optimization,
                 minimizer: [
-                    new core_1.SwcJsMinimizerRspackPlugin({
+                    new SwcJsMinimizerRspackPlugin({
                         extractComments: false,
                         minimizerOptions: {
                             // this needs to be false to allow toplevel variables to be used in the global scope
@@ -198,7 +219,8 @@ function applyNxIndependentConfig(options, config) {
     config.plugins ??= [];
     config.externals ??= [];
 }
-function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
+function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}, rspackCore) {
+    const { ProgressPlugin, SwcJsMinimizerRspackPlugin, CopyRspackPlugin } = rspackCore;
     const tsConfig = options.tsConfig ?? (0, js_1.getRootTsConfigPath)();
     const plugins = [];
     const isUsingTsSolution = (0, internal_1.isUsingTsSolutionSetup)();
@@ -235,8 +257,7 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
         typeCheckOptions = defaultTypeCheckOptions;
     }
     // New TS Solution already has a typecheck target but allow it to run during serve
-    const shouldTypeCheck = typeCheckOptions !== false &&
-        (!isUsingTsSolution || process.env['WEBPACK_SERVE']);
+    const shouldTypeCheck = typeCheckOptions !== false && (!isUsingTsSolution || (0, is_serve_mode_1.isServeMode)());
     if (shouldTypeCheck) {
         const { TsCheckerRspackPlugin } = require('ts-checker-rspack-plugin');
         const pluginConfig = {
@@ -292,7 +313,7 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
         }
     });
     if (options.progress) {
-        plugins.push(new core_1.ProgressPlugin({ profile: options.verbose }));
+        plugins.push(new ProgressPlugin({ profile: options.verbose }));
     }
     if (options.extractLicenses) {
         plugins.push(new license_webpack_plugin_1.LicenseWebpackPlugin({
@@ -305,7 +326,7 @@ function applyNxDependentConfig(options, config, { useNormalizedEntry } = {}) {
         }));
     }
     if (Array.isArray(options.assets) && options.assets.length > 0) {
-        plugins.push(new core_1.CopyRspackPlugin({
+        plugins.push(new CopyRspackPlugin({
             patterns: options.assets.map((asset) => {
                 return {
                     context: asset.input,

package/dist/src/plugins/utils/apply-react-config.d.ts

@@ -1,2 +1,13 @@
-import { Configuration, RspackOptionsNormalized } from '@rspack/core';
-export declare function applyReactConfig(options?: Record<string, any>, config?: Partial<RspackOptionsNormalized | Configuration>): void;
+import type { Compiler, Configuration, RspackOptionsNormalized } from '@rspack/core';
+type RspackConfigShape = Partial<RspackOptionsNormalized | Configuration>;
+/**
+ * Apply rspack/react config for the compose path (e.g. `withReact`):
+ * sync tweaks + push react-refresh into `config.plugins`. Plugins that
+ * participate in rspack's lifecycle should call
+ * `applyReactConfigSync(...)` + `applyReactHotReloadToCompiler(...)`
+ * instead.
+ */
+export declare function applyReactConfig(options?: Record<string, any>, config?: RspackConfigShape): void;
+export declare function applyReactConfigSync(config: RspackConfigShape): void;
+export declare function applyReactHotReloadToCompiler(compiler: Compiler): void;
+export {};