@rstest/core 0.6.9 → 0.7.1

package/dist/0~122.js

@@ -202,6 +202,7 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
                     options: {
                         entryInfo,
                         context: {
+                            outputModule: project.outputModule,
                             taskId: index + 1,
                             project: projectName,
                             rootPath: context.rootPath,
@@ -273,6 +274,7 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
                         context: {
                             taskId: index + 1,
                             project: projectName,
+                            outputModule: project.outputModule,
                             rootPath: context.rootPath,
                             projectRoot: project.rootPath,
                             runtimeConfig: serializableConfig(runtimeConfig)
@@ -302,11 +304,15 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
     };
 };
 const RUNTIME_CHUNK_NAME = 'runtime';
+const requireShim = `// Rstest ESM shims
+import __rstest_shim_module__ from 'node:module';
+const require = /*#__PURE__*/ __rstest_shim_module__.createRequire(import.meta.url);
+`;
 const pluginBasic = (context)=>({
         name: 'rstest:basic',
         setup: (api)=>{
             api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
-                const { normalizedConfig: { resolve, source, output, tools, performance, dev, testEnvironment }, rootPath } = context.projects.find((p)=>p.environmentName === name);
+                const { normalizedConfig: { resolve, source, output, tools, performance, dev, testEnvironment }, outputModule, rootPath } = context.projects.find((p)=>p.environmentName === name);
                 return mergeEnvironmentConfig(config, {
                     performance,
                     tools,
@@ -326,6 +332,10 @@ const pluginBasic = (context)=>({
                         sourceMap: {
                             js: 'source-map'
                         },
+                        module: outputModule,
+                        filename: outputModule ? {
+                            js: '[name].mjs'
+                        } : void 0,
                         distPath: {
                             root: context.projects.length > 1 ? `${TEMP_RSTEST_OUTPUT_DIR}/${name}` : TEMP_RSTEST_OUTPUT_DIR
                         }
@@ -336,7 +346,7 @@ const pluginBasic = (context)=>({
                             config.mode = isProd ? 'production' : 'development';
                             config.output ??= {};
                             config.output.iife = false;
-                            config.output.importFunctionName = '__rstest_dynamic_import__';
+                            config.output.importFunctionName = outputModule ? 'import.meta.__rstest_dynamic_import__' : '__rstest_dynamic_import__';
                             config.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
                             if (!config.devtool || !config.devtool.includes('inline')) config.devtool = 'nosources-source-map';
                             config.plugins.push(new rspack.experiments.RstestPlugin({
@@ -345,6 +355,12 @@ const pluginBasic = (context)=>({
                                 hoistMockModule: true,
                                 manualMockRoot: posix.resolve(rootPath, '__mocks__')
                             }));
+                            if (outputModule) config.plugins.push(new rspack.BannerPlugin({
+                                banner: requireShim,
+                                stage: rspack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE - 1,
+                                raw: true,
+                                include: /\.(js|mjs)$/
+                            }));
                             config.module.parser ??= {};
                             config.module.parser.javascript = {
                                 importDynamic: false,
@@ -467,20 +483,20 @@ const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context
             });
         }
     });
-const autoExternalNodeModules = ({ context, request, dependencyType, getResolve }, callback)=>{
-    if (!request) return callback();
-    if (request.startsWith('@swc/helpers/') || request.endsWith('.wasm')) return callback();
-    const doExternal = (externalPath = request)=>{
-        callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'import');
+const autoExternalNodeModules = (outputModule)=>({ context, request, dependencyType, getResolve }, callback)=>{
+        if (!request) return callback();
+        if (request.startsWith('@swc/helpers/') || request.endsWith('.wasm')) return callback();
+        const doExternal = (externalPath = request)=>{
+            callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : outputModule ? 'module-import' : 'import');
+        };
+        const resolver = getResolve?.();
+        if (!resolver) return callback();
+        resolver(context, request, (err, resolvePath)=>{
+            if (err) return callback(void 0, request, 'node-commonjs');
+            if (resolvePath && resolvePath.includes('node_modules') && !/\.(?:ts|tsx|jsx|mts|cts)$/.test(resolvePath)) return doExternal(resolvePath);
+            return callback();
+        });
     };
-    const resolver = getResolve?.();
-    if (!resolver) return callback();
-    resolver(context, request, (err, resolvePath)=>{
-        if (err) return callback();
-        if (resolvePath && resolvePath.includes('node_modules') && !/\.(?:ts|tsx|jsx|mts|cts)$/.test(resolvePath)) return doExternal(resolvePath);
-        return callback();
-    });
-};
 function autoExternalNodeBuiltin({ request, dependencyType }, callback) {
     if (!request) return void callback();
     const isNodeBuiltin = isBuiltin(request) || ADDITIONAL_NODE_BUILTINS.some((builtin)=>{
@@ -494,11 +510,11 @@ const pluginExternal = (context)=>({
         name: 'rstest:external',
         setup: (api)=>{
             api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
-                const { normalizedConfig: { testEnvironment } } = context.projects.find((p)=>p.environmentName === name);
+                const { normalizedConfig: { testEnvironment }, outputModule } = context.projects.find((p)=>p.environmentName === name);
                 return mergeEnvironmentConfig(config, {
                     output: {
                         externals: 'node' === testEnvironment ? [
-                            autoExternalNodeModules
+                            autoExternalNodeModules(outputModule)
                         ] : void 0
                     },
                     tools: {
@@ -509,7 +525,7 @@ const pluginExternal = (context)=>({
                             });
                             config.externalsPresets ??= {};
                             config.externalsPresets.node = false;
-                            config.externals.push(autoExternalNodeBuiltin);
+                            config.externals.unshift(autoExternalNodeBuiltin);
                         }
                     }
                 });
@@ -553,6 +569,10 @@ const pluginInspect = ()=>enable ? {
 const external_node_fs_ = __webpack_require__("node:fs");
 const mockRuntime_dirname = external_node_path_["default"].dirname(fileURLToPath(import.meta.url));
 class MockRuntimeRspackPlugin {
+    outputModule;
+    constructor(outputModule){
+        this.outputModule = outputModule;
+    }
     apply(compiler) {
         const { RuntimeModule } = compiler.webpack;
         class RetestImportRuntimeModule extends RuntimeModule {
@@ -570,12 +590,16 @@ class MockRuntimeRspackPlugin {
                     const finalSource = module.source.source.toString('utf-8').replace('for (var moduleId in moreModules) {', "for (var moduleId in moreModules) {\n		if (Object.keys(__webpack_require__.rstest_original_modules).includes(moduleId)) continue;");
                     module.source.source = Buffer.from(finalSource);
                 }
+                if ('module_chunk_loading' === module.name) {
+                    const finalSource = module.source.source.toString('utf-8').replace('for (moduleId in __webpack_modules__) {', "for (moduleId in __webpack_modules__) {\n		if (Object.keys(__webpack_require__.rstest_original_modules).includes(moduleId)) continue;");
+                    module.source.source = Buffer.from(finalSource);
+                }
                 if ('define_property_getters' === module.name) {
                     const finalSource = module.source.source.toString('utf-8').replace('enumerable: true, get:', 'enumerable: true, configurable: true, get:');
                     module.source.source = Buffer.from(finalSource);
                 }
                 if ('async_wasm_loading' === module.name) {
-                    const finalSource = module.source.source.toString('utf-8').replace('readFile(', 'readWasmFile(');
+                    const finalSource = module.source.source.toString('utf-8').replace('readFile(', this.outputModule ? 'import.meta.readWasmFile(' : 'readWasmFile(');
                     module.source.source = Buffer.from(finalSource);
                 }
             });
@@ -591,7 +615,7 @@ const pluginMockRuntime = {
     name: 'rstest:mock-runtime',
     setup: (api)=>{
         api.modifyRspackConfig(async (config)=>{
-            config.plugins.push(new MockRuntimeRspackPlugin());
+            config.plugins.push(new MockRuntimeRspackPlugin(Boolean(config.output.module)));
         });
     }
 };
@@ -810,7 +834,8 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
     const readFile = async (fileName)=>new Promise((resolve, reject)=>{
             outputFileSystem.readFile(fileName, (err, data)=>{
                 if (err) reject(err);
-                resolve('string' == typeof data ? data : data.toString());
+                const content = 'string' == typeof data ? data : fileName.endsWith('.wasm') ? data.toString('base64') : data.toString('utf-8');
+                resolve(content);
             });
         });
     const buildData = {};
@@ -844,7 +869,8 @@ const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildI
         const sourceEntries = await globTestSourceEntries(environmentName);
         for (const entry of Object.keys(entrypoints)){
             const e = entrypoints[entry];
-            const distPath = posix.join(outputPath, e.assets[e.assets.length - 1].name);
+            const filteredAssets = e.assets.filter((asset)=>!asset.name.endsWith('.wasm'));
+            const distPath = posix.join(outputPath, filteredAssets[filteredAssets.length - 1].name);
             if (setupFiles[environmentName][entry]) setupEntries.push({
                 distPath,
                 testPath: setupFiles[environmentName][entry],

package/dist/0~173.js

@@ -379,12 +379,17 @@ async function runTests(context) {
             afterTestsWatchRun();
         });
     } else {
+        let isTeardown = false;
         const unExpectedExit = (code)=>{
-            src_logger.log(picocolors_default().red(`Rstest exited unexpectedly with code ${code}, terminating test run.`));
-            process.exitCode = 1;
+            if (isTeardown) src_logger.log(picocolors_default().yellow(`Rstest exited unexpectedly with code ${code}, this is likely caused by test environment teardown.`));
+            else {
+                src_logger.log(picocolors_default().red(`Rstest exited unexpectedly with code ${code}, terminating test run.`));
+                process.exitCode = 1;
+            }
         };
         process.on('exit', unExpectedExit);
         await run();
+        isTeardown = true;
         await pool.close();
         await closeServer();
         process.off('exit', unExpectedExit);

package/dist/0~346.js

@@ -0,0 +1,46 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_vm from "node:vm";
+const shouldInterop = ({ interopDefault = true, modulePath, mod })=>{
+    if (!interopDefault) return false;
+    return !modulePath.endsWith('.mjs') && 'default' in mod;
+};
+const isPrimitive = (v)=>v !== Object(v);
+function interopModule(mod) {
+    if (isPrimitive(mod)) return {
+        mod: {
+            default: mod
+        },
+        defaultExport: mod
+    };
+    const defaultExport = 'default' in mod ? mod.default : mod;
+    if (!isPrimitive(defaultExport) && '__esModule' in defaultExport) return {
+        mod: defaultExport,
+        defaultExport: 'default' in defaultExport ? defaultExport.default : defaultExport
+    };
+    return {
+        mod,
+        defaultExport
+    };
+}
+const asModule = async (something, defaultExport, context, unlinked)=>{
+    const { Module, SyntheticModule } = await import("node:vm");
+    if (something instanceof Module) return something;
+    const exports = [
+        ...new Set([
+            'default',
+            ...Object.keys(something)
+        ])
+    ];
+    const m = new SyntheticModule(exports, ()=>{
+        for (const name of exports)m.setExport(name, 'default' === name ? defaultExport : something[name]);
+    }, {
+        context
+    });
+    if (unlinked) return m;
+    await m.link(()=>{});
+    if (m.instantiate) m.instantiate();
+    await m.evaluate();
+    return m;
+};
+export { asModule, interopModule, node_vm, shouldInterop };

package/dist/0~835.js

@@ -0,0 +1,143 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { posix, external_node_module_createRequire, src_logger } from "./946.js";
+import { pathToFileURL } from "./770.js";
+import { node_vm, asModule, shouldInterop, interopModule } from "./0~346.js";
+const external_node_path_ = __webpack_require__("node:path");
+const isRelativePath = (p)=>/^\.\.?\//.test(p);
+const createRequire = (filename, distPath, rstestContext, assetFiles, interopDefault)=>{
+    const _require = (()=>{
+        try {
+            return external_node_module_createRequire(filename);
+        } catch (_err) {
+            return external_node_module_createRequire(distPath);
+        }
+    })();
+    const require = (id)=>{
+        const currentDirectory = posix.dirname(distPath);
+        const joinedPath = isRelativePath(id) ? posix.join(currentDirectory, id) : id;
+        const content = assetFiles[joinedPath];
+        if (content) try {
+            return cacheableLoadModule({
+                codeContent: content,
+                testPath: joinedPath,
+                distPath: joinedPath,
+                rstestContext,
+                assetFiles,
+                interopDefault
+            });
+        } catch (err) {
+            src_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
+        }
+        const resolved = _require.resolve(id);
+        return _require(resolved);
+    };
+    require.resolve = _require.resolve;
+    require.main = _require.main;
+    return require;
+};
+const defineRstestDynamicImport = ({ testPath, interopDefault, returnModule = false })=>async (specifier, importAttributes)=>{
+        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
+        const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
+        if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
+        if (modulePath.endsWith('.json')) {
+            const importedModule = await import(modulePath, {
+                with: {
+                    type: 'json'
+                }
+            });
+            return returnModule ? asModule(importedModule.default, importedModule.default) : {
+                ...importedModule.default,
+                default: importedModule.default
+            };
+        }
+        const importedModule = await import(modulePath, importAttributes);
+        if (shouldInterop({
+            interopDefault,
+            modulePath,
+            mod: importedModule
+        })) {
+            const { mod, defaultExport } = interopModule(importedModule);
+            if (returnModule) return asModule(mod, defaultExport);
+            return new Proxy(mod, {
+                get (mod, prop) {
+                    if ('default' === prop) return defaultExport;
+                    return mod[prop] ?? defaultExport?.[prop];
+                },
+                has (mod, prop) {
+                    if ('default' === prop) return void 0 !== defaultExport;
+                    return prop in mod || defaultExport && prop in defaultExport;
+                },
+                getOwnPropertyDescriptor (mod, prop) {
+                    const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+                    if (descriptor) return descriptor;
+                    if ('default' === prop && void 0 !== defaultExport) return {
+                        value: defaultExport,
+                        enumerable: true,
+                        configurable: true
+                    };
+                }
+            });
+        }
+        return importedModule;
+    };
+const loadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles, interopDefault })=>{
+    const fileDir = posix.dirname(testPath);
+    const localModule = {
+        children: [],
+        exports: {},
+        filename: testPath,
+        id: testPath,
+        isPreloading: false,
+        loaded: false,
+        path: fileDir
+    };
+    const context = {
+        module: localModule,
+        exports: localModule.exports,
+        require: createRequire(testPath, distPath, rstestContext, assetFiles, interopDefault),
+        readWasmFile: (wasmPath, callback)=>{
+            const joinedPath = isRelativePath(wasmPath) ? posix.join(posix.dirname(distPath), wasmPath) : wasmPath;
+            const content = assetFiles[posix.normalize(joinedPath)];
+            if (content) callback(null, Buffer.from(content, 'base64'));
+            else callback(new Error(`WASM file ${joinedPath} not found in asset files.`));
+        },
+        __rstest_dynamic_import__: defineRstestDynamicImport({
+            testPath,
+            interopDefault
+        }),
+        __dirname: fileDir,
+        __filename: testPath,
+        ...rstestContext
+    };
+    const codeDefinition = `'use strict';(${Object.keys(context).join(',')})=>{`;
+    const code = `${codeDefinition}${codeContent}\n}`;
+    const fn = node_vm.runInThisContext(code, {
+        filename: distPath,
+        lineOffset: 0,
+        columnOffset: -codeDefinition.length,
+        importModuleDynamically: (specifier, _referencer, importAttributes)=>defineRstestDynamicImport({
+                testPath,
+                interopDefault,
+                returnModule: true
+            })(specifier, importAttributes)
+    });
+    fn(...Object.values(context));
+    return localModule.exports;
+};
+const moduleCache = new Map();
+const cacheableLoadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles, interopDefault })=>{
+    if (moduleCache.has(testPath)) return moduleCache.get(testPath);
+    const mod = loadModule({
+        codeContent,
+        distPath,
+        testPath,
+        rstestContext,
+        assetFiles,
+        interopDefault
+    });
+    moduleCache.set(testPath, mod);
+    return mod;
+};
+export { cacheableLoadModule, loadModule };

package/dist/0~923.js

@@ -0,0 +1,149 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { posix, src_logger } from "./946.js";
+import { pathToFileURL } from "./770.js";
+import { node_vm, interopModule, shouldInterop } from "./0~346.js";
+const external_node_path_ = __webpack_require__("node:path");
+var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
+    EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
+    EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";
+    EsmMode[EsmMode["Unlinked"] = 2] = "Unlinked";
+    return EsmMode;
+}({});
+const isRelativePath = (p)=>/^\.\.?\//.test(p);
+const defineRstestDynamicImport = ({ distPath, testPath, assetFiles, interopDefault, returnModule, esmMode })=>async (specifier, importAttributes)=>{
+        const currentDirectory = posix.dirname(distPath);
+        const joinedPath = isRelativePath(specifier) ? posix.join(currentDirectory, specifier) : specifier;
+        const content = assetFiles[joinedPath];
+        if (content) try {
+            return await loadModule({
+                codeContent: content,
+                testPath,
+                distPath: joinedPath,
+                rstestContext: {},
+                assetFiles,
+                interopDefault,
+                esmMode
+            });
+        } catch (err) {
+            src_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
+        }
+        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
+        const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
+        if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
+        if (modulePath.endsWith('.json')) {
+            const importedModule = await import(modulePath, {
+                with: {
+                    type: 'json'
+                }
+            });
+            return returnModule ? asModule(importedModule.default) : {
+                ...importedModule.default,
+                default: importedModule.default
+            };
+        }
+        const importedModule = await import(modulePath, importAttributes);
+        if (shouldInterop({
+            interopDefault,
+            modulePath,
+            mod: importedModule
+        }) && !modulePath.startsWith('node:')) {
+            const { mod, defaultExport } = interopModule(importedModule);
+            if (returnModule) return asModule(mod);
+            return new Proxy(mod, {
+                get (mod, prop) {
+                    if ('default' === prop) return defaultExport;
+                    return mod[prop] ?? defaultExport?.[prop];
+                },
+                has (mod, prop) {
+                    if ('default' === prop) return void 0 !== defaultExport;
+                    return prop in mod || defaultExport && prop in defaultExport;
+                },
+                getOwnPropertyDescriptor (mod, prop) {
+                    const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+                    if (descriptor) return descriptor;
+                    if ('default' === prop && void 0 !== defaultExport) return {
+                        value: defaultExport,
+                        enumerable: true,
+                        configurable: true
+                    };
+                }
+            });
+        }
+        return importedModule;
+    };
+const asModule = async (something, context, unlinked)=>{
+    const { Module, SyntheticModule } = await import("node:vm");
+    if (something instanceof Module) return something;
+    const exports = [
+        ...new Set([
+            'default',
+            ...Object.keys(something)
+        ])
+    ];
+    const syntheticModule = new SyntheticModule(exports, ()=>{
+        for (const name of exports)syntheticModule.setExport(name, 'default' === name ? something[name] ?? something : something[name]);
+    }, {
+        context
+    });
+    if (unlinked) return syntheticModule;
+    await syntheticModule.link(()=>{});
+    await syntheticModule.evaluate();
+    return syntheticModule;
+};
+const esmCache = new Map();
+const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interopDefault, esmMode = 0 })=>{
+    const code = codeContent;
+    let esm = esmCache.get(distPath);
+    if (!esm) {
+        esm = new node_vm.SourceTextModule(code, {
+            identifier: distPath,
+            lineOffset: 0,
+            columnOffset: 0,
+            initializeImportMeta: (meta)=>{
+                meta.url = pathToFileURL(distPath.endsWith('rstest-runtime.mjs') ? distPath : testPath).toString();
+                meta.__rstest_dynamic_import__ = defineRstestDynamicImport({
+                    assetFiles,
+                    testPath,
+                    distPath: distPath || testPath,
+                    interopDefault,
+                    returnModule: false,
+                    esmMode: 0
+                });
+                meta.readWasmFile = (wasmPath, callback)=>{
+                    const joinedPath = isRelativePath(wasmPath.pathname) ? posix.join(posix.dirname(distPath), wasmPath.pathname) : wasmPath.pathname;
+                    const content = assetFiles[posix.normalize(joinedPath)];
+                    if (content) callback(null, Buffer.from(content, 'base64'));
+                    else callback(new Error(`WASM file ${joinedPath} not found in asset files.`));
+                };
+            },
+            importModuleDynamically: (specifier, _referencer, importAttributes)=>defineRstestDynamicImport({
+                    assetFiles,
+                    testPath,
+                    distPath: distPath || testPath,
+                    interopDefault,
+                    returnModule: true,
+                    esmMode: 2
+                })(specifier, importAttributes)
+        });
+        distPath && esmCache.set(distPath, esm);
+    }
+    if (2 === esmMode) return esm;
+    if ('unlinked' === esm.status) await esm.link(async (specifier, referencingModule)=>{
+        const result = await defineRstestDynamicImport({
+            assetFiles,
+            testPath,
+            distPath: distPath || testPath,
+            interopDefault,
+            returnModule: true,
+            esmMode: 2
+        })(specifier, referencingModule);
+        const linkedModule = await asModule(result, referencingModule.context, true);
+        return linkedModule;
+    });
+    'evaluated' !== esm.status && 'evaluating' !== esm.status && await esm.evaluate();
+    const ns = esm.namespace;
+    return ns.default && ns.default instanceof Promise ? ns.default : ns;
+};
+export { asModule, loadEsModule_EsmMode, loadModule };

package/dist/155.js

@@ -500,7 +500,7 @@ function prepareCli() {
     if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
 }
 function showRstest() {
-    src_logger.greet("  Rstest v0.6.9");
+    src_logger.greet("  Rstest v0.7.1");
     src_logger.log('');
 }
 const applyCommonOptions = (cli)=>{
@@ -544,7 +544,7 @@ const runRest = async ({ options, filters, command })=>{
 function setupCommands() {
     const cli = dist('rstest');
     cli.help();
-    cli.version("0.6.9");
+    cli.version("0.7.1");
     applyCommonOptions(cli);
     cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
         showRstest();
@@ -2169,6 +2169,7 @@ const stackIgnores = [
     /node_modules\/@vitest\/snapshot/,
     /node:\w+/,
     /webpack\/runtime/,
+    /rstest runtime/,
     /webpack\\runtime/,
     '<anonymous>'
 ];
@@ -2427,7 +2428,7 @@ class Rstest {
         });
         this.reporters = reporters;
         this.snapshotManager = snapshotManager;
-        this.version = "0.6.9";
+        this.version = "0.7.1";
         this.rootPath = rootPath;
         this.originalConfig = userConfig;
         this.normalizedConfig = rstestConfig;
@@ -2447,6 +2448,7 @@ class Rstest {
                 configFilePath: project.configFilePath,
                 rootPath: config.root,
                 name: config.name,
+                outputModule: config.output?.module ?? 'true' === process.env.RSTEST_OUTPUT_MODULE,
                 environmentName: formatEnvironmentName(config.name),
                 normalizedConfig: config
             };
@@ -2455,6 +2457,7 @@ class Rstest {
                 configFilePath,
                 rootPath,
                 name: rstestConfig.name,
+                outputModule: rstestConfig.output?.module ?? 'true' === process.env.RSTEST_OUTPUT_MODULE,
                 environmentName: formatEnvironmentName(rstestConfig.name),
                 normalizedConfig: rstestConfig
             }

package/dist/362.js

@@ -1,10 +1,10 @@
 /*! For license information please see 362.js.LICENSE.txt */
 import __rslib_shim_module__ from 'module';
 const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+"use strict";
 import { __webpack_require__ } from "./rslib-runtime.js";
-import node_vm from "node:vm";
-import { basename, globalApis, posix, external_node_module_createRequire, dirname, resolve as pathe_M_eThtNZ_resolve, undoSerializableConfig, src_logger, isAbsolute, join } from "./946.js";
-import { node_v8, pathToFileURL, createBirpc } from "./770.js";
+import { basename, globalApis, dirname, external_node_module_createRequire, resolve as pathe_M_eThtNZ_resolve, undoSerializableConfig, isAbsolute, join } from "./946.js";
+import { node_v8, createBirpc } from "./770.js";
 import { createCoverageProvider } from "./734.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/@jest+diff-sequences@30.0.1/node_modules/@jest/diff-sequences/build/index.js": function(module) {
@@ -6710,184 +6710,6 @@ function checkPkgInstalled(name) {
         throw error;
     }
 }
-const shouldInterop = ({ interopDefault = true, modulePath, mod })=>{
-    if (!interopDefault) return false;
-    return !modulePath.endsWith('.mjs') && 'default' in mod;
-};
-const isPrimitive = (v)=>v !== Object(v);
-function interopModule(mod) {
-    if (isPrimitive(mod)) return {
-        mod: {
-            default: mod
-        },
-        defaultExport: mod
-    };
-    const defaultExport = 'default' in mod ? mod.default : mod;
-    if (!isPrimitive(defaultExport) && '__esModule' in defaultExport) return {
-        mod: defaultExport,
-        defaultExport: 'default' in defaultExport ? defaultExport.default : defaultExport
-    };
-    return {
-        mod,
-        defaultExport
-    };
-}
-const asModule = async (something, defaultExport, context, unlinked)=>{
-    const { Module, SyntheticModule } = await import("node:vm");
-    if (something instanceof Module) return something;
-    const exports = [
-        ...new Set([
-            'default',
-            ...Object.keys(something)
-        ])
-    ];
-    const m = new SyntheticModule(exports, ()=>{
-        for (const name of exports)m.setExport(name, 'default' === name ? defaultExport : something[name]);
-    }, {
-        context
-    });
-    if (unlinked) return m;
-    await m.link(()=>{});
-    if (m.instantiate) m.instantiate();
-    await m.evaluate();
-    return m;
-};
-const external_node_path_ = __webpack_require__("node:path");
-const isRelativePath = (p)=>/^\.\.?\//.test(p);
-const createRequire = (filename, distPath, rstestContext, assetFiles, interopDefault)=>{
-    const _require = (()=>{
-        try {
-            return external_node_module_createRequire(filename);
-        } catch (_err) {
-            return external_node_module_createRequire(distPath);
-        }
-    })();
-    const require = (id)=>{
-        const currentDirectory = posix.dirname(distPath);
-        const joinedPath = isRelativePath(id) ? posix.join(currentDirectory, id) : id;
-        const content = assetFiles[joinedPath];
-        if (content) try {
-            return cacheableLoadModule({
-                codeContent: content,
-                testPath: joinedPath,
-                distPath: joinedPath,
-                rstestContext,
-                assetFiles,
-                interopDefault
-            });
-        } catch (err) {
-            src_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
-        }
-        const resolved = _require.resolve(id);
-        return _require(resolved);
-    };
-    require.resolve = _require.resolve;
-    require.main = _require.main;
-    return require;
-};
-const defineRstestDynamicImport = ({ testPath, interopDefault, returnModule = false })=>async (specifier, importAttributes)=>{
-        const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
-        const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;
-        if (importAttributes?.with?.rstest) delete importAttributes.with.rstest;
-        if (modulePath.endsWith('.json')) {
-            const importedModule = await import(modulePath, {
-                with: {
-                    type: 'json'
-                }
-            });
-            return returnModule ? asModule(importedModule.default, importedModule.default) : {
-                ...importedModule.default,
-                default: importedModule.default
-            };
-        }
-        const importedModule = await import(modulePath, importAttributes);
-        if (shouldInterop({
-            interopDefault,
-            modulePath,
-            mod: importedModule
-        })) {
-            const { mod, defaultExport } = interopModule(importedModule);
-            if (returnModule) return asModule(mod, defaultExport);
-            return new Proxy(mod, {
-                get (mod, prop) {
-                    if ('default' === prop) return defaultExport;
-                    return mod[prop] ?? defaultExport?.[prop];
-                },
-                has (mod, prop) {
-                    if ('default' === prop) return void 0 !== defaultExport;
-                    return prop in mod || defaultExport && prop in defaultExport;
-                },
-                getOwnPropertyDescriptor (mod, prop) {
-                    const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
-                    if (descriptor) return descriptor;
-                    if ('default' === prop && void 0 !== defaultExport) return {
-                        value: defaultExport,
-                        enumerable: true,
-                        configurable: true
-                    };
-                }
-            });
-        }
-        return importedModule;
-    };
-const loadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles, interopDefault })=>{
-    const fileDir = posix.dirname(testPath);
-    const localModule = {
-        children: [],
-        exports: {},
-        filename: testPath,
-        id: testPath,
-        isPreloading: false,
-        loaded: false,
-        path: fileDir
-    };
-    const context = {
-        module: localModule,
-        exports: localModule.exports,
-        require: createRequire(testPath, distPath, rstestContext, assetFiles, interopDefault),
-        readWasmFile: (wasmPath, callback)=>{
-            const joinedPath = isRelativePath(wasmPath) ? posix.join(posix.dirname(distPath), wasmPath) : wasmPath;
-            const content = assetFiles[posix.normalize(joinedPath)];
-            if (content) callback(null, Buffer.from(content, 'utf-8'));
-            else callback(new Error(`WASM file ${joinedPath} not found in asset files.`));
-        },
-        __rstest_dynamic_import__: defineRstestDynamicImport({
-            testPath,
-            interopDefault
-        }),
-        __dirname: fileDir,
-        __filename: testPath,
-        ...rstestContext
-    };
-    const codeDefinition = `'use strict';(${Object.keys(context).join(',')})=>{`;
-    const code = `${codeDefinition}${codeContent}\n}`;
-    const fn = node_vm.runInThisContext(code, {
-        filename: distPath,
-        lineOffset: 0,
-        columnOffset: -codeDefinition.length,
-        importModuleDynamically: (specifier, _referencer, importAttributes)=>defineRstestDynamicImport({
-                testPath,
-                interopDefault,
-                returnModule: true
-            })(specifier, importAttributes)
-    });
-    fn(...Object.values(context));
-    return localModule.exports;
-};
-const moduleCache = new Map();
-const cacheableLoadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles, interopDefault })=>{
-    if (moduleCache.has(testPath)) return moduleCache.get(testPath);
-    const mod = loadModule({
-        codeContent,
-        distPath,
-        testPath,
-        rstestContext,
-        assetFiles,
-        interopDefault
-    });
-    moduleCache.set(testPath, mod);
-    return mod;
-};
 const processSend = process.send.bind(process);
 const processOn = process.on.bind(process);
 const processOff = process.off.bind(process);
@@ -6992,6 +6814,8 @@ const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.
 var picocolors_default = /*#__PURE__*/ __webpack_require__.n(picocolors);
 let sourceMaps = {};
 (0, source_map_support.install)({
+    environment: 'node',
+    handleUncaughtExceptions: false,
     retrieveSourceMap: (source)=>{
         if (sourceMaps[source]) return {
             url: source,
@@ -7115,12 +6939,20 @@ const preparePool = async ({ entryInfo: { distPath, testPath }, updateSnapshot,
         }
     };
 };
-const loadFiles = async ({ setupEntries, assetFiles, rstestContext, distPath, testPath, interopDefault, isolate })=>{
+const loadFiles = async ({ setupEntries, assetFiles, rstestContext, distPath, testPath, interopDefault, isolate, outputModule })=>{
+    const { loadModule } = outputModule ? await import("./0~923.js").then((mod)=>({
+            EsmMode: mod.loadEsModule_EsmMode,
+            asModule: mod.asModule,
+            loadModule: mod.loadModule
+        })) : await import("./0~835.js").then((mod)=>({
+            cacheableLoadModule: mod.cacheableLoadModule,
+            loadModule: mod.loadModule
+        }));
     if (!isolate) await loadModule({
         codeContent: `if (global && typeof global.__rstest_clean_core_cache__ === 'function') {
   global.__rstest_clean_core_cache__();
   }`,
-        distPath,
+        distPath: '',
         testPath,
         rstestContext,
         assetFiles,
@@ -7180,7 +7012,8 @@ const runInPool = async (options)=>{
             assetFiles,
             setupEntries,
             interopDefault,
-            isolate
+            isolate,
+            outputModule: options.context.outputModule
         });
         const tests = await runner.collectTests();
         return {
@@ -7224,7 +7057,8 @@ const runInPool = async (options)=>{
             assetFiles,
             setupEntries,
             interopDefault,
-            isolate
+            isolate,
+            outputModule: options.context.outputModule
         });
         const results = await runner.runTests(testPath, {
             onTestCaseStart: async (test)=>{

package/dist/index.d.ts

@@ -2042,6 +2042,8 @@ declare type ProjectContext = {
     environmentName: string;
     /** The root path of current project. */
     rootPath: string;
+    /** Whether to output es module. */
+    outputModule: boolean;
     configFilePath?: string;
     normalizedConfig: NormalizedProjectConfig;
 };
@@ -2363,7 +2365,7 @@ export declare interface RstestConfig {
     source?: Pick<NonNullable<RsbuildConfig['source']>, 'define' | 'tsconfigPath' | 'decorators' | 'include' | 'exclude'>;
     performance?: Pick<NonNullable<RsbuildConfig['performance']>, 'bundleAnalyze'>;
     dev?: Pick<NonNullable<RsbuildConfig['dev']>, 'writeToDisk'>;
-    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules' | 'externals' | 'cleanDistPath'>;
+    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules' | 'externals' | 'cleanDistPath' | 'module'>;
     resolve?: RsbuildConfig['resolve'];
     tools?: Pick<NonNullable<RsbuildConfig['tools']>, 'rspack' | 'swc' | 'bundlerChain'>;
 }

package/dist/worker.d.ts

@@ -1688,6 +1688,8 @@ declare type ProjectContext = {
     environmentName: string;
     /** The root path of current project. */
     rootPath: string;
+    /** Whether to output es module. */
+    outputModule: boolean;
     configFilePath?: string;
     normalizedConfig: NormalizedProjectConfig;
 };
@@ -1996,7 +1998,7 @@ declare interface RstestConfig {
     source?: Pick<NonNullable<RsbuildConfig['source']>, 'define' | 'tsconfigPath' | 'decorators' | 'include' | 'exclude'>;
     performance?: Pick<NonNullable<RsbuildConfig['performance']>, 'bundleAnalyze'>;
     dev?: Pick<NonNullable<RsbuildConfig['dev']>, 'writeToDisk'>;
-    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules' | 'externals' | 'cleanDistPath'>;
+    output?: Pick<NonNullable<RsbuildConfig['output']>, 'cssModules' | 'externals' | 'cleanDistPath' | 'module'>;
     resolve?: RsbuildConfig['resolve'];
     tools?: Pick<NonNullable<RsbuildConfig['tools']>, 'rspack' | 'swc' | 'bundlerChain'>;
 }
@@ -2553,6 +2555,7 @@ declare type WorkerContext = {
     project: string;
     runtimeConfig: RuntimeConfig;
     taskId: number;
+    outputModule: boolean;
 };
 
 declare type XInput = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/core",
-  "version": "0.6.9",
+  "version": "0.7.1",
   "description": "The Rsbuild-based test tool.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -47,7 +47,7 @@
   ],
   "dependencies": {
     "@types/chai": "^5.2.3",
-    "@rsbuild/core": "1.6.0-beta.1",
+    "@rsbuild/core": "1.6.12-canary-20251204065915",
     "tinypool": "^1.1.1"
   },
   "devDependencies": {