@rspack/test-tools 2.0.8 → 2.1.0-beta.0

package/dist/case/cache.js

@@ -111,9 +111,10 @@ const creators = new Map();
 function matchStatsSnapshot(env, source, updateIndex, stats) {
     const content = (0, placeholder_js_namespaceObject.normalizePlaceholder)(stats.toString({
         all: false,
-        logging: 'info',
+        logging: false,
+        loggingDebug: /^rspack\.persistentCache$/,
         colors: false
-    })).trim();
+    }).replace(/[0-9]+(\.[0-9]+)? ms/g, 'xx ms')).trim();
     if (!content.includes('rspack.persistentCache')) return;
     env.expect(content).toMatchFileSnapshotSync(external_node_path_default().resolve(source, '__snapshots__', `stats-${updateIndex}.txt`));
 }

package/dist/case/common.js

@@ -222,10 +222,10 @@ function findMultiCompilerBundle(context, name, multiFindBundle) {
 }
 function configMultiCompiler(context, name, configFiles, defaultOptions, overrideOptions) {
     const multiCompilerOptions = [];
-    const caseOptions = Array.isArray(configFiles) ? (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getSource(i)), context, {}, (configs)=>configs.flatMap((c)=>{
+    const caseOptions = Array.isArray(configFiles) ? (0, index_js_namespaceObject.readConfigFile)(configFiles.map((i)=>context.getCompileSource(i)), context, {}, (configs)=>configs.flatMap((c)=>{
             if ('function' == typeof c) {
                 const options = {
-                    testPath: context.getDist(),
+                    testPath: context.getCompileDist(),
                     env: void 0
                 };
                 return c(options.env, options);

package/dist/case/config.d.ts

@@ -1,8 +1,8 @@
 import type { RspackOptions } from '@rspack/core';
 import type { ITestContext, ITestProcessor, TTestConfig } from '../type';
 export type TConfigCaseConfig = Omit<TTestConfig, 'validate'>;
-export declare function createConfigProcessor(name: string): ITestProcessor;
-export declare function createConfigCase(name: string, src: string, dist: string): void;
+export declare function createConfigProcessor(name: string, rspackOptions?: RspackOptions): ITestProcessor;
+export declare function createConfigCase(name: string, src: string, dist: string, rspackOptions?: RspackOptions): void;
 export declare function defaultOptions(index: number, context: ITestContext): RspackOptions;
 export declare function enableEsmLibraryPlugin(options: RspackOptions): boolean;
 export declare function overrideOptions(index: number, context: ITestContext, options: RspackOptions): void;

package/dist/case/config.js

@@ -51,15 +51,21 @@ var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_
 const parseResource_js_namespaceObject = require("../helper/legacy/parseResource.js");
 const creator_js_namespaceObject = require("../test/creator.js");
 const external_common_js_namespaceObject = require("./common.js");
+const external_runtime_mode_js_namespaceObject = require("./runtime-mode.js");
 const external_runner_js_namespaceObject = require("./runner.js");
-function createConfigProcessor(name) {
+function createConfigProcessor(name, rspackOptions) {
     return {
         config: (context)=>{
+            if (context.getTestConfig().isolateSource) external_fs_extra_default().copySync(context.getSource(), context.getCompileSource());
             (0, external_common_js_namespaceObject.configMultiCompiler)(context, name, [
                 'rspack.config.cjs',
                 'rspack.config.js',
                 'webpack.config.js'
-            ], defaultOptions, overrideOptions);
+            ], defaultOptions, (index, context, options)=>{
+                overrideOptions(index, context, options);
+                mergeRspackOptions(options, rspackOptions);
+                (0, external_runtime_mode_js_namespaceObject.applyRuntimeModeTestDefines)(options);
+            });
         },
         compiler: async (context)=>{
             await (0, external_common_js_namespaceObject.compiler)(context, name);
@@ -98,18 +104,23 @@ const creator = new creator_js_namespaceObject.BasicCaseCreator({
     },
     concurrent: true
 });
-function createConfigCase(name, src, dist) {
-    creator.create(name, src, dist);
+function createConfigCase(name, src, dist, rspackOptions) {
+    creator.create(name, src, dist, void 0, {
+        rspackOptions,
+        steps: ({ name, rspackOptions })=>[
+                createConfigProcessor(name, rspackOptions)
+            ]
+    });
 }
 function defaultOptions(index, context) {
     return {
-        context: context.getSource(),
+        context: context.getCompileSource(),
         mode: 'production',
         target: 'async-node',
         devtool: false,
         cache: false,
         output: {
-            path: context.getDist(),
+            path: context.getCompileDist(),
             bundlerInfo: {
                 force: false
             }
@@ -142,6 +153,15 @@ function overrideOptions(index, context, options) {
         level: 'error'
     };
 }
+function mergeRspackOptions(options, override) {
+    if (!override) return;
+    const { experiments, ...rest } = override;
+    Object.assign(options, rest);
+    if (experiments) options.experiments = {
+        ...options.experiments,
+        ...experiments
+    };
+}
 function findBundle(index, context, options) {
     const testConfig = context.getTestConfig();
     if ('function' == typeof testConfig.findBundle) return testConfig.findBundle(index, options);

package/dist/case/hot.d.ts

@@ -2,8 +2,8 @@ import { type RspackOptions } from '@rspack/core';
 import { HotUpdatePlugin } from '../helper/hot-update/plugin';
 import type { ITestContext, ITestEnv, ITestProcessor, ITestRunner } from '../type';
 type TTarget = RspackOptions['target'];
-export declare function createHotProcessor(name: string, src: string, temp: string, target: TTarget, incremental?: boolean): THotProcessor;
-export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: RspackOptions['target']): void;
+export declare function createHotProcessor(name: string, src: string, temp: string, target: TTarget, incremental?: boolean, rspackOptions?: RspackOptions): THotProcessor;
+export declare function createHotCase(name: string, src: string, dist: string, temp: string, target: RspackOptions['target'], rspackOptions?: RspackOptions): void;
 type THotProcessor = ITestProcessor & {
     updatePlugin: HotUpdatePlugin;
 };

package/dist/case/hot.js

@@ -52,9 +52,10 @@ const external_plugin_index_js_namespaceObject = require("../plugin/index.js");
 const external_runner_index_js_namespaceObject = require("../runner/index.js");
 const creator_js_namespaceObject = require("../test/creator.js");
 const external_common_js_namespaceObject = require("./common.js");
+const external_runtime_mode_js_namespaceObject = require("./runtime-mode.js");
 const external_runner_js_namespaceObject = require("./runner.js");
 const creators = new Map();
-function createHotProcessor(name, src, temp, target, incremental = false) {
+function createHotProcessor(name, src, temp, target, incremental = false, rspackOptions) {
     const updatePlugin = new plugin_js_namespaceObject.HotUpdatePlugin(src, temp);
     const processor = {
         before: async (context)=>{
@@ -70,6 +71,8 @@ function createHotProcessor(name, src, temp, target, incremental = false) {
             ], options);
             overrideOptions(context, options, target, updatePlugin);
             if (incremental) options.incremental ??= 'advance-silent';
+            mergeRspackOptions(options, rspackOptions);
+            (0, external_runtime_mode_js_namespaceObject.applyRuntimeModeTestDefines)(options);
             compiler.setOptions(options);
         },
         compiler: async (context)=>{
@@ -102,8 +105,8 @@ function getCreator(target) {
         clean: true,
         describe: true,
         target,
-        steps: ({ name, target, src, dist, temp })=>[
-                createHotProcessor(name, src, temp || external_node_path_default().resolve(dist, 'temp'), target)
+        steps: ({ name, target, src, dist, temp, rspackOptions })=>[
+                createHotProcessor(name, src, temp || external_node_path_default().resolve(dist, 'temp'), target, false, rspackOptions)
             ],
         runner: {
             key: (context, name, file)=>name,
@@ -113,9 +116,20 @@ function getCreator(target) {
     }));
     return creators.get(target);
 }
-function createHotCase(name, src, dist, temp, target) {
+function createHotCase(name, src, dist, temp, target, rspackOptions) {
     const creator = getCreator(target);
-    creator.create(name, src, dist, temp);
+    creator.create(name, src, dist, temp, {
+        rspackOptions
+    });
+}
+function mergeRspackOptions(options, override) {
+    if (!override) return;
+    const { experiments, ...rest } = override;
+    Object.assign(options, rest);
+    if (experiments) options.experiments = {
+        ...options.experiments,
+        ...experiments
+    };
 }
 function defaultOptions(context, target) {
     const options = {

package/dist/case/runner.js

@@ -71,8 +71,8 @@ function createRunner(context, name, file, env) {
         stats: cachedStats(context, name),
         name,
         testConfig: context.getTestConfig(),
-        source: context.getSource(),
-        dist: context.getDist(),
+        source: context.getCompileSource(),
+        dist: context.getCompileDist(),
         compilerOptions
     };
     const isWeb = isWebTarget(compilerOptions);
@@ -129,8 +129,8 @@ function createMultiCompilerRunner(context, name, file, env) {
         },
         name,
         testConfig: context.getTestConfig(),
-        source: context.getSource(),
-        dist: context.getDist(),
+        source: context.getCompileSource(),
+        dist: context.getCompileDist(),
         compilerOptions,
         logs,
         errors

package/dist/case/runtime-mode.d.ts

@@ -0,0 +1,2 @@
+import { type RspackOptions } from '@rspack/core';
+export declare function applyRuntimeModeTestDefines(options: RspackOptions): void;

package/dist/case/runtime-mode.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyRuntimeModeTestDefines: ()=>applyRuntimeModeTestDefines
+});
+const core_namespaceObject = require("@rspack/core");
+var core_default = /*#__PURE__*/ __webpack_require__.n(core_namespaceObject);
+const runtimeModeDefine = {
+    'globalThis.__RSPACK_TEST_RUNTIME_MODE_RSPACK': JSON.stringify(true)
+};
+function applyRuntimeModeTestDefines(options) {
+    if (options.experiments?.runtimeMode !== 'rspack') return;
+    options.plugins ??= [];
+    options.plugins.push(new (core_default()).DefinePlugin(runtimeModeDefine));
+}
+exports.applyRuntimeModeTestDefines = __webpack_exports__.applyRuntimeModeTestDefines;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRuntimeModeTestDefines"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/compiler.js

@@ -187,7 +187,8 @@ var __webpack_exports__ = {};
             const watchOptions = {
                 poll: 300,
                 ignored: [],
-                aggregateTimeout: timeout
+                aggregateTimeout: timeout,
+                ...this.compilerInstance.options.watchOptions
             };
             if (__DEBUG__) context.setValue(debug_js_namespaceObject.DEBUG_SCOPES.BuildMethod, {
                 method: 'watch',

package/dist/helper/expect/to-match-file-snapshot.js

@@ -51,6 +51,37 @@ const external_jest_diff_namespaceObject = require("jest-diff");
 const external_serializers_js_namespaceObject = require("../serializers.js");
 const external_snapshot_serializers_js_namespaceObject = require("./snapshot-serializers.js");
 const isEqual = (a, b)=>Buffer.isBuffer(a) ? a.equals(b) : a === b;
+function readSnapshot(filename, content) {
+    const output = external_node_fs_default().readFileSync(filename, Buffer.isBuffer(content) ? null : 'utf8');
+    return Buffer.isBuffer(output) ? output : output.replace(/\r\n/g, '\n');
+}
+function toPosixPath(filename) {
+    return filename.split(external_node_path_default().sep).join('/');
+}
+function getRuntimeModeSnapshotFilename(filename) {
+    if (!globalThis.__RSPACK_TEST_RUNTIME_MODE_RSPACK) return;
+    const normalized = toPosixPath(filename);
+    if (normalized.includes('/runtimeModeSnapshot/')) return;
+    for (const marker of [
+        '/__snapshot__/',
+        '/__snapshots__/'
+    ]){
+        const markerIndex = normalized.indexOf(marker);
+        if (markerIndex >= 0) return external_node_path_default().normalize(`${normalized.slice(0, markerIndex + marker.length)}runtimeModeSnapshot/${normalized.slice(markerIndex + marker.length)}`);
+    }
+}
+function cleanupRuntimeModeSnapshot(filename) {
+    external_node_fs_default().unlinkSync(filename);
+    let current = external_node_path_default().dirname(filename);
+    while('runtimeModeSnapshot' !== external_node_path_default().basename(current)){
+        try {
+            external_node_fs_default().rmdirSync(current);
+        } catch  {
+            break;
+        }
+        current = external_node_path_default().dirname(current);
+    }
+}
 function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
     const content = Buffer.isBuffer(rawContent) ? rawContent : (0, external_snapshot_serializers_js_namespaceObject.serializeSnapshot)(rawContent, 2, {
         plugins: [
@@ -62,15 +93,17 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
     const filename = void 0 === filepath ? external_node_path_default().join(external_node_path_default().dirname(this.testPath), '__file_snapshots__', `${external_filenamify_default()(this.currentTestName, {
         replacement: '-'
     }).replace(/\s/g, '-')}-${this.assertionCalls}`) : filepath;
-    if ('none' === snapshotState._updateSnapshot && !external_node_fs_default().existsSync(filename)) {
+    const runtimeModeSnapshotFilename = getRuntimeModeSnapshotFilename(filename);
+    const matchedFilename = runtimeModeSnapshotFilename && external_node_fs_default().existsSync(runtimeModeSnapshotFilename) ? runtimeModeSnapshotFilename : filename;
+    if ('none' === snapshotState._updateSnapshot && !external_node_fs_default().existsSync(matchedFilename)) {
         snapshotState.unmatched++;
         return {
             pass: isNot,
-            message: ()=>`New output file ${external_chalk_default().blue(external_node_path_default().basename(filename))} was ${external_chalk_default().bold.red('not written')}.\n\nThe update flag must be explicitly passed to write a new snapshot.\n\nThis is likely because this test is run in a ${external_chalk_default().blue('continuous integration (CI) environment')} in which snapshots are not written by default.\n\n`
+            message: ()=>`New output file ${external_chalk_default().blue(external_node_path_default().basename(matchedFilename))} was ${external_chalk_default().bold.red('not written')}.\n\nThe update flag must be explicitly passed to write a new snapshot.\n\nThis is likely because this test is run in a ${external_chalk_default().blue('continuous integration (CI) environment')} in which snapshots are not written by default.\n\n`
         };
     }
-    if (external_node_fs_default().existsSync(filename)) {
-        const output = external_node_fs_default().readFileSync(filename, Buffer.isBuffer(content) ? null : 'utf8').replace(/\r\n/g, '\n');
+    if (external_node_fs_default().existsSync(matchedFilename)) {
+        const output = readSnapshot(matchedFilename, content);
         if (isNot) {
             if (!isEqual(content, output)) return {
                 pass: false,
@@ -79,7 +112,7 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
             snapshotState.unmatched++;
             return {
                 pass: true,
-                message: ()=>`Expected received content ${external_chalk_default().red('to not match')} the file ${external_chalk_default().blue(external_node_path_default().basename(filename))}.`
+                message: ()=>`Expected received content ${external_chalk_default().red('to not match')} the file ${external_chalk_default().blue(external_node_path_default().basename(matchedFilename))}.`
             };
         }
         if (isEqual(content, output)) return {
@@ -87,10 +120,19 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
             message: ()=>''
         };
         if ('all' === snapshotState._updateSnapshot) {
-            external_node_fs_default().mkdirSync(external_node_path_default().dirname(filename), {
+            if (runtimeModeSnapshotFilename && matchedFilename === runtimeModeSnapshotFilename && external_node_fs_default().existsSync(filename) && isEqual(content, readSnapshot(filename, content))) {
+                cleanupRuntimeModeSnapshot(runtimeModeSnapshotFilename);
+                snapshotState.updated++;
+                return {
+                    pass: true,
+                    message: ()=>''
+                };
+            }
+            const updatedFilename = runtimeModeSnapshotFilename && external_node_fs_default().existsSync(filename) ? runtimeModeSnapshotFilename : matchedFilename;
+            external_node_fs_default().mkdirSync(external_node_path_default().dirname(updatedFilename), {
                 recursive: true
             });
-            external_node_fs_default().writeFileSync(filename, content);
+            external_node_fs_default().writeFileSync(updatedFilename, content);
             snapshotState.updated++;
             return {
                 pass: true,
@@ -105,14 +147,19 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
         }, options.diff || {}))}`;
         return {
             pass: false,
-            message: ()=>`Received content ${external_chalk_default().red("doesn't match")} the file ${external_chalk_default().blue(external_node_path_default().basename(filename))}.${difference}`
+            message: ()=>`Received content ${external_chalk_default().red("doesn't match")} the file ${external_chalk_default().blue(external_node_path_default().basename(matchedFilename))}.${difference}`
         };
     }
     if (!isNot && ('new' === snapshotState._updateSnapshot || 'all' === snapshotState._updateSnapshot)) {
-        external_node_fs_default().mkdirSync(external_node_path_default().dirname(filename), {
+        if (runtimeModeSnapshotFilename && external_node_fs_default().existsSync(filename) && isEqual(content, readSnapshot(filename, content))) return {
+            pass: true,
+            message: ()=>''
+        };
+        const newFilename = runtimeModeSnapshotFilename || filename;
+        external_node_fs_default().mkdirSync(external_node_path_default().dirname(newFilename), {
             recursive: true
         });
-        external_node_fs_default().writeFileSync(filename, content);
+        external_node_fs_default().writeFileSync(newFilename, content);
         snapshotState.added++;
         return {
             pass: true,
@@ -122,7 +169,7 @@ function toMatchFileSnapshotSync(rawContent, filepath, options = {}) {
     snapshotState.unmatched++;
     return {
         pass: true,
-        message: ()=>`The output file ${external_chalk_default().blue(external_node_path_default().basename(filename))} ${external_chalk_default().bold.red("doesn't exist")}.`
+        message: ()=>`The output file ${external_chalk_default().blue(external_node_path_default().basename(matchedFilename))} ${external_chalk_default().bold.red("doesn't exist")}.`
     };
 }
 exports.toMatchFileSnapshotSync = __webpack_exports__.toMatchFileSnapshotSync;

package/dist/helper/hot-update/plugin.js

@@ -151,7 +151,7 @@ class HotUpdatePlugin {
                 set.add(compiler.rspack.RuntimeGlobals.moduleCache);
             });
             compilation.hooks.runtimeModule.tap(PLUGIN_NAME, (module, _set)=>{
-                if ('DefinePropertyGettersRuntimeModule' === module.constructor.name) module.source.source = Buffer.from(`
+                if ('DefinePropertyGettersRuntimeModule' === module.constructor.name && compiler.options.experiments?.runtimeMode !== 'rspack') module.source.source = Buffer.from(`
 ${RuntimeGlobals.definePropertyGetters} = function (exports, getters, values) {
   var define = function (defs, kind) {
     for(var key in defs) {

package/dist/runner/node/index.d.ts

@@ -22,9 +22,11 @@ export declare class NodeRunner implements ITestRunner {
     protected globalContext: IGlobalContext | null;
     protected baseModuleScope: IModuleScope | null;
     protected requirers: Map<string, TRunnerRequirer>;
+    protected runQueue: Promise<void> | undefined;
     constructor(_options: INodeRunnerOptions);
     protected log(message: string): void;
     run(file: string): Promise<unknown>;
+    protected runFile(file: string): Promise<unknown>;
     getRequire(): TRunnerRequirer;
     getGlobal(name: string): unknown;
     protected createGlobalContext(): IGlobalContext;

package/dist/runner/node/index.js

@@ -91,6 +91,7 @@ var __webpack_exports__ = {};
         globalContext = null;
         baseModuleScope = null;
         requirers = new Map();
+        runQueue;
         constructor(_options){
             this._options = _options;
         }
@@ -98,6 +99,11 @@ var __webpack_exports__ = {};
             this._options.logs?.push(`[NodeRunner] ${message}`);
         }
         run(file) {
+            const run = this.runQueue ? this.runQueue.then(()=>this.runFile(file)) : this.runFile(file);
+            this.runQueue = run.then(()=>void 0, ()=>void 0);
+            return run;
+        }
+        runFile(file) {
             if (!this.globalContext) this.globalContext = this.createGlobalContext();
             this.baseModuleScope = this.createBaseModuleScope();
             if ('function' == typeof this._options.testConfig.moduleScope) this._options.testConfig.moduleScope(this.baseModuleScope, this._options.stats, this._options.compilerOptions);

package/dist/test/context.d.ts

@@ -9,6 +9,8 @@ export declare class TestContext implements ITestContext {
     constructor(config: TTestContextOptions);
     getSource(sub?: string): string;
     getDist(sub?: string): string;
+    getCompileSource(sub?: string): string;
+    getCompileDist(sub?: string): string;
     getTemp(sub?: string): string | null;
     getCompiler(): ITestCompilerManager;
     getRunner(file: string, env: ITestEnv): ITestRunner;

package/dist/test/context.js

@@ -60,6 +60,14 @@ class TestContext {
         if (sub) return external_node_path_default().resolve(this.config.dist, sub);
         return this.config.dist;
     }
+    getCompileSource(sub) {
+        if (this.config.testConfig?.isolateSource) return this.getDist(sub ? external_node_path_default().join('src', sub) : 'src');
+        return this.getSource(sub);
+    }
+    getCompileDist(sub) {
+        if (this.config.testConfig?.isolateSource) return this.getDist(sub ? external_node_path_default().join('dist', sub) : 'dist');
+        return this.getDist(sub);
+    }
     getTemp(sub) {
         if (!this.config.temp) return null;
         if (sub) return external_node_path_default().resolve(this.config.temp, sub);

package/dist/type.d.ts

@@ -3,6 +3,8 @@ import type { Compiler, MultiStats, RspackOptions, Stats, StatsCompilation } fro
 export interface ITestContext {
     getSource(sub?: string): string;
     getDist(sub?: string): string;
+    getCompileSource(sub?: string): string;
+    getCompileDist(sub?: string): string;
     getTemp(sub?: string): string | null;
     getCompiler(): ITestCompilerManager;
     closeCompiler(): Promise<void>;
@@ -122,6 +124,7 @@ export type TTestConfig = {
     location?: string;
     validate?: (stats: Stats | MultiStats, stderr?: string) => void;
     noTests?: boolean;
+    isolateSource?: boolean;
     writeStatsOuptut?: boolean;
     writeStatsJson?: boolean;
     beforeExecute?: (options: RspackOptions) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/test-tools",
-  "version": "2.0.8",
+  "version": "2.1.0-beta.0",
   "description": "Test tools for rspack",
   "homepage": "https://rspack.rs",
   "bugs": "https://github.com/web-infra-dev/rspack/issues",
@@ -45,24 +45,24 @@
     "javascript-stringify": "^2.1.0",
     "jest-diff": "^30.4.1",
     "jsdom": "^26.1.0",
-    "memfs": "4.57.6",
+    "memfs": "4.57.7",
     "path-serializer": "0.6.0",
     "pretty-format": "30.4.1",
     "rimraf": "^5.0.10",
-    "rspack-merge": "0.1.1",
+    "rspack-merge": "1.0.1",
     "source-map": "^0.7.6",
-    "terser-webpack-plugin": "^5.5.0",
+    "terser-webpack-plugin": "^5.6.1",
     "wast-loader": "^1.14.1",
     "webpack-sources": "3.3.4"
   },
   "devDependencies": {
-    "@rslib/core": "^0.22.0",
+    "@rslib/core": "^0.22.1",
     "@types/babel__generator": "7.27.0",
     "@types/babel__traverse": "7.28.0",
     "@types/fs-extra": "11.0.4",
     "@types/jsdom": "^21.1.7",
     "typescript": "^6.0.3",
-    "@rspack/core": "2.0.8"
+    "@rspack/core": "2.1.0-beta.0"
   },
   "peerDependencies": {
     "@rspack/core": ">=1.0.0"