@rstest/core 0.8.2 → 0.8.4

package/dist/0~130.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { AssertionError, strict } from "node:assert";
 import { Console } from "node:console";

package/dist/0~1472.js

@@ -1,11 +1,10 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { createRequire } from "./4881.js";
 import { pathToFileURL } from "./6198.js";
 import "./1157.js";
 import { logger as logger_logger, color } from "./3160.js";
 async function loadBrowserModule(options = {}) {
-    const coreVersion = "0.8.2";
+    const coreVersion = "0.8.4";
     const { projectRoots = [] } = options;
     let browserModule;
     let browserVersion;

package/dist/0~1981.js

@@ -1,3 +1,2 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 export { Readable, Writable } from "node:stream";

package/dist/0~2173.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { resolveShardedEntries, getTestEntries } from "./1157.js";
 import { createCoverageProvider } from "./5734.js";
 import { prepareRsbuild, createPool, createRsbuildServer, runGlobalTeardown, runGlobalSetup } from "./0~89.js";
@@ -148,9 +147,10 @@ async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFaile
 }
 async function runBrowserModeTests(context, browserProjects, options) {
     const projectRoots = browserProjects.map((p)=>p.rootPath);
-    const { runBrowserTests } = await loadBrowserModule({
+    const { validateBrowserConfig, runBrowserTests } = await loadBrowserModule({
         projectRoots
     });
+    validateBrowserConfig(context);
     return runBrowserTests(context, options);
 }
 async function runTests(context) {
@@ -166,7 +166,7 @@ async function runTests(context) {
         const browserResult = await runBrowserModeTests(context, browserProjects, {
             skipOnTestRunEnd: false
         });
-        if (coverage.enabled && browserResult?.results) {
+        if (coverage.enabled && browserResult?.results.length && !browserResult.unhandledErrors?.length) {
             const coverageProvider = await createCoverageProvider(coverage, context.rootPath);
             if (coverageProvider) {
                 const { generateCoverage } = await import("./0~4403.js").then((mod)=>({
@@ -214,6 +214,7 @@ async function runTests(context) {
             skipOnTestRunEnd: shouldUnifyReporter,
             shardedEntries: shard ? browserEntries : void 0
         });
+        browserResultPromise.catch(()=>{});
     }
     if (!hasNodeTestsToRun) {
         if (browserResultPromise) await browserResultPromise;
@@ -339,6 +340,7 @@ async function runTests(context) {
         const errors = returns.flatMap((r)=>r.errors || []);
         if (shouldUnifyReporter && browserResult?.results) results.push(...browserResult.results);
         if (shouldUnifyReporter && browserResult?.testResults) testResults.push(...browserResult.testResults);
+        if (shouldUnifyReporter && browserResult?.unhandledErrors) errors.push(...browserResult.unhandledErrors);
         context.updateReporterResultState(results, testResults, currentDeletedEntries);
         const nodeHasFailure = results.some((r)=>'fail' === r.status) || errors.length;
         const browserHasFailure = shouldUnifyReporter && browserResult?.hasFailure;

package/dist/0~2255.js

@@ -1,8 +1,7 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./3160.js";
-const external_node_fs_ = __webpack_require__("fs");
+const external_node_fs_ = __webpack_require__("node:fs");
 const pluginCoverageCore = (coverageOptions)=>({
         name: 'rstest:coverage-core',
         setup: (api)=>{

package/dist/0~3062.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 const LIVING_KEYS = [
     'DOMException',
     'EventTarget',

package/dist/0~3346.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 const shouldInterop = ({ interopDefault = true, modulePath, mod })=>{
     if (!interopDefault) return false;
     return !modulePath.endsWith('.mjs') && 'default' in mod;

package/dist/0~3919.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./3160.js";
 __webpack_require__.add({

package/dist/0~4403.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { isDynamicPattern, glob } from "./1157.js";
 import { normalize, logger as logger_logger } from "./3160.js";
 const getIncludedFiles = async (coverage, rootPath, fs)=>{

package/dist/0~4809.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { checkPkgInstalled } from "./1294.js";
 import { installGlobal, addDefaultErrorHandler } from "./0~3062.js";
 const environment = {

package/dist/0~5835.js

@@ -1,16 +1,11 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { logger as logger_logger } from "./3160.js";
 import { createRequire as external_node_module_createRequire } from "./4881.js";
 import { pathToFileURL } from "./6198.js";
 import { node_vm, asModule, shouldInterop, interopModule } from "./0~3346.js";
 import { posix } from "./7011.js";
-const external_node_path_ = __webpack_require__("path");
-let latestAssetFiles = {};
-const updateLatestAssetFiles = (assetFiles)=>{
-    latestAssetFiles = assetFiles;
-};
+const external_node_path_ = __webpack_require__("node:path");
 const isRelativePath = (p)=>/^\.\.?\//.test(p);
 const createRequire = (filename, distPath, rstestContext, assetFiles, interopDefault)=>{
     const _require = (()=>{
@@ -23,7 +18,7 @@ const createRequire = (filename, distPath, rstestContext, assetFiles, interopDef
     const require = (id)=>{
         const currentDirectory = posix.dirname(distPath);
         const joinedPath = isRelativePath(id) ? posix.join(currentDirectory, id) : id;
-        const content = assetFiles[joinedPath] || latestAssetFiles[joinedPath];
+        const content = assetFiles[joinedPath];
         if (content) try {
             return cacheableLoadModule({
                 codeContent: content,
@@ -105,7 +100,7 @@ const loadModule = ({ codeContent, distPath, testPath, rstestContext, assetFiles
         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)] || latestAssetFiles[posix.normalize(joinedPath)];
+            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.`));
         },
@@ -146,4 +141,5 @@ const cacheableLoadModule = ({ codeContent, distPath, testPath, rstestContext, a
     moduleCache.set(testPath, mod);
     return mod;
 };
-export { cacheableLoadModule, loadModule, updateLatestAssetFiles };
+const clearModuleCache = ()=>moduleCache.clear();
+export { cacheableLoadModule, clearModuleCache, loadModule };

package/dist/0~62.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { checkPkgInstalled } from "./1294.js";
 import { installGlobal, addDefaultErrorHandler } from "./0~3062.js";
 const environment = {

package/dist/0~6588.js

@@ -1,7 +1,6 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { logger as logger_logger, color, isTTY, ansiEnabled } from "./3160.js";
+import { color, logger as logger_logger, isTTY } from "./3160.js";
 import { runRest } from "./9131.js";
 import "./1157.js";
 const GLOB_REGEX = /[*?{}[\]()!@+|]/;
@@ -28,13 +27,14 @@ async function createChokidar(pathOrGlobs, root, options) {
     }
     return chokidar.watch(Array.from(watchFiles), options);
 }
-const external_node_path_ = __webpack_require__("path");
+const external_node_path_ = __webpack_require__("node:path");
+const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
 let cleaners = [];
 const onBeforeRestart = (cleaner)=>{
     cleaners.push(cleaner);
 };
 const clearConsole = ()=>{
-    if (isTTY() && !process.env.DEBUG && ansiEnabled) process.stdout.write('\x1B[H\x1B[2J');
+    if (isTTY() && !process.env.DEBUG && picocolors.isColorSupported) process.stdout.write('\x1B[H\x1B[2J');
 };
 const beforeRestart = async ({ filePath, root, clear = true })=>{
     if (clear) clearConsole();

package/dist/0~6907.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { encode } from "./4397.js";
 class BitSet {
     constructor(arg){

package/dist/0~6923.js

@@ -1,11 +1,10 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { logger as logger_logger } from "./3160.js";
 import { pathToFileURL } from "./6198.js";
 import { node_vm, interopModule, shouldInterop } from "./0~3346.js";
 import { posix } from "./7011.js";
-const external_node_path_ = __webpack_require__("path");
+const external_node_path_ = __webpack_require__("node:path");
 var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
     EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";
@@ -13,14 +12,10 @@ var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     return EsmMode;
 }({});
 const isRelativePath = (p)=>/^\.\.?\//.test(p);
-let latestAssetFiles = {};
-const updateLatestAssetFiles = (assetFiles)=>{
-    latestAssetFiles = assetFiles;
-};
 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] || latestAssetFiles[joinedPath];
+        const content = assetFiles[joinedPath];
         if (content) try {
             return await loadModule({
                 codeContent: content,
@@ -118,7 +113,7 @@ const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interop
                 });
                 meta.readWasmFile = (wasmPath, callback)=>{
                     const joinedPath = isRelativePath(wasmPath.pathname) ? posix.join(posix.dirname(distPath), wasmPath.pathname) : wasmPath.pathname;
-                    const content = assetFiles[posix.normalize(joinedPath)] || latestAssetFiles[posix.normalize(joinedPath)];
+                    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.`));
                 };
@@ -151,4 +146,5 @@ const loadModule = async ({ codeContent, distPath, testPath, assetFiles, interop
     const ns = esm.namespace;
     return ns.default && ns.default instanceof Promise ? ns.default : ns;
 };
-export { asModule, loadEsModule_EsmMode, loadModule, updateLatestAssetFiles };
+const clearModuleCache = ()=>esmCache.clear();
+export { asModule, clearModuleCache, loadEsModule_EsmMode, loadModule };

package/dist/0~7583.js

@@ -1,13 +1,12 @@
 /*! For license information please see 0~7583.js.LICENSE.txt */
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "fs/promises";
 import "./3160.js";
 import { readdir as promises_readdir, lstat as promises_lstat, promises_stat as promises_promises_stat, realpath as external_node_fs_promises_realpath } from "./1157.js";
 import { Readable } from "./0~1981.js";
 import { EventEmitter } from "./9131.js";
-const external_node_path_ = __webpack_require__("path");
+const external_node_path_ = __webpack_require__("node:path");
 const EntryTypes = {
     FILE_TYPE: 'files',
     DIR_TYPE: 'directories',
@@ -221,7 +220,7 @@ function readdirp(root, options = {}) {
     options.root = root;
     return new ReaddirpStream(options);
 }
-const external_node_fs_ = __webpack_require__("fs");
+const external_node_fs_ = __webpack_require__("node:fs");
 const external_node_os_ = __webpack_require__("node:os");
 const STR_DATA = 'data';
 const STR_END = 'end';

package/dist/0~7882.js

@@ -1,12 +1,11 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { color } from "./3160.js";
+import { determineAgent, color } from "./3160.js";
 import { detect, resolveCommand } from "./9131.js";
 import { Ie, Me, ye, M, dist_Y, Se, ve, pD, xe } from "./0~9348.js";
-import { determineAgent } from "./1157.js";
-const external_node_fs_ = __webpack_require__("fs");
-const external_node_path_ = __webpack_require__("path");
+import "./1157.js";
+const external_node_fs_ = __webpack_require__("node:fs");
+const external_node_path_ = __webpack_require__("node:path");
 function getUniqueBaseName(dir, baseName, ext) {
     const fullPath = external_node_path_["default"].join(dir, `${baseName}${ext}`);
     if (!external_node_fs_["default"].existsSync(fullPath)) return baseName;
@@ -373,7 +372,7 @@ async function createInteractive(cwd, projectInfo, isAgent) {
     }
     const provider = providerSelection;
     const preview = computeFilePreview(cwd, projectInfo);
-    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.8.2");
+    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.8.4");
     const depsList = Object.entries(deps).map(([name, version])=>`${name}@${version}`).join(', ');
     const previewLines = [
         `${color.cyan('+')} Create ${preview.configFile}`,
@@ -451,7 +450,7 @@ async function generateFiles(cwd, projectInfo, provider) {
     updatePackageJsonScripts(cwd, {
         'test:browser': 'rstest --config=rstest.browser.config.ts'
     });
-    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.8.2");
+    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.8.4");
     updatePackageJsonDevDeps(cwd, deps);
     return createdFiles;
 }

package/dist/0~8426.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./1157.js";
 import { relative, color } from "./3160.js";

package/dist/0~89.js

@@ -1,12 +1,11 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import node_events from "node:events";
 import { Tinypool } from "tinypool";
 import node_inspector from "node:inspector";
 import { basename, needFlagExperimentalDetectModule, isDeno, dirname, castArray, resolve as pathe_M_eThtNZ_resolve, serializableConfig, node_process, isDebug, color, getForceColorEnv, ADDITIONAL_NODE_BUILTINS, bgColor, join } from "./3160.js";
 import { fileURLToPath } from "./6198.js";
-import { node_v8, createBirpc } from "./3216.js";
+import { node_v8, parseWorkerMetaMessage, createBirpc } from "./9869.js";
 import { TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB } from "./1157.js";
 import { posix } from "./7011.js";
 import { isBuiltin } from "./4881.js";
@@ -22,9 +21,184 @@ function memory_isMemorySufficient(options) {
     const isMemorySufficient = memoryUsageRatio < memoryThreshold && heapUsed < maxHeapSize;
     return isMemorySufficient;
 }
+const MAX_CAPTURED_STDERR_BYTES = 131072;
+const STDERR_SETTLE_MAX_WAIT = 200;
+const WORKER_EXIT_ERROR = 'Worker exited unexpectedly';
+const MAX_STDERR_MESSAGE_BYTES = 65536;
+const createDeferred = ()=>{
+    let resolvePromise = ()=>void 0;
+    const deferred = {
+        settled: false,
+        resolve (value) {
+            if (deferred.settled) return;
+            deferred.settled = true;
+            resolvePromise(value);
+        },
+        promise: new Promise((resolve)=>{
+            resolvePromise = resolve;
+        })
+    };
+    return deferred;
+};
+const withTimeout = (promise, timeout)=>new Promise((resolve)=>{
+        let finished = false;
+        const timer = setTimeout(()=>{
+            if (finished) return;
+            finished = true;
+            resolve(void 0);
+        }, timeout);
+        timer.unref();
+        promise.then((value)=>{
+            if (finished) return;
+            finished = true;
+            clearTimeout(timer);
+            resolve(value);
+        }, ()=>{
+            if (finished) return;
+            finished = true;
+            clearTimeout(timer);
+            resolve(void 0);
+        });
+    });
+const formatCapturedStderr = (text)=>{
+    const bytes = Buffer.byteLength(text);
+    if (bytes <= MAX_STDERR_MESSAGE_BYTES) return text;
+    const half = Math.floor(MAX_STDERR_MESSAGE_BYTES / 2);
+    const head = text.slice(0, half);
+    const tail = text.slice(-half);
+    const hiddenBytes = bytes - Buffer.byteLength(head) - Buffer.byteLength(tail);
+    return `${head}\n\n... [truncated ${hiddenBytes} bytes of stderr] ...\n\n${tail}`;
+};
+const getChildProcessByPid = (pool, pid)=>{
+    for (const worker of pool.threads){
+        const childProcess = worker.process;
+        if (childProcess?.pid === pid) return childProcess;
+    }
+};
+const createWorkerStderrCapture = (pool)=>{
+    const workerStates = new Map();
+    const taskBindings = new Map();
+    const taskBindingWaiters = new Map();
+    const workerCloseWaiters = new Map();
+    const trackedWorkers = new Map();
+    const getWorkerState = (pid)=>{
+        let state = workerStates.get(pid);
+        if (!state) {
+            state = {
+                bytes: 0,
+                chunks: [],
+                seq: 0
+            };
+            workerStates.set(pid, state);
+        }
+        return state;
+    };
+    const appendStderr = (pid, text)=>{
+        if (!text) return;
+        const state = getWorkerState(pid);
+        const bytes = Buffer.byteLength(text);
+        state.seq += 1;
+        state.bytes += bytes;
+        state.chunks.push({
+            bytes,
+            seq: state.seq,
+            text
+        });
+        while(state.bytes > MAX_CAPTURED_STDERR_BYTES && state.chunks.length > 0){
+            const dropped = state.chunks.shift();
+            if (dropped) state.bytes -= dropped.bytes;
+        }
+    };
+    const attachWorker = (pid)=>{
+        if (trackedWorkers.has(pid)) return;
+        const childProcess = getChildProcessByPid(pool, pid);
+        const stderr = childProcess?.stderr;
+        if (!childProcess || !stderr) return;
+        const closeWaiter = createDeferred();
+        workerCloseWaiters.set(pid, closeWaiter);
+        const onData = (chunk)=>{
+            const text = 'string' == typeof chunk ? chunk : chunk.toString();
+            appendStderr(pid, text);
+        };
+        stderr.on('data', onData);
+        trackedWorkers.set(pid, {
+            onData,
+            stream: stderr
+        });
+        const detachTrackedWorker = ()=>{
+            const tracked = trackedWorkers.get(pid);
+            if (!tracked) return;
+            tracked.stream.off('data', tracked.onData);
+            trackedWorkers.delete(pid);
+        };
+        childProcess.once('close', ()=>{
+            detachTrackedWorker();
+            closeWaiter.resolve(void 0);
+        });
+    };
+    const bindTaskToPid = (taskId, pid)=>{
+        attachWorker(pid);
+        const binding = {
+            pid,
+            startSeq: getWorkerState(pid).seq
+        };
+        taskBindings.set(taskId, binding);
+        taskBindingWaiters.get(taskId)?.resolve(binding);
+    };
+    const waitForTaskBinding = async (taskId)=>{
+        const binding = taskBindings.get(taskId);
+        if (binding) return binding;
+        const waiter = taskBindingWaiters.get(taskId);
+        if (!waiter) return;
+        return withTimeout(waiter.promise, STDERR_SETTLE_MAX_WAIT);
+    };
+    const waitForWorkerClose = async (pid)=>{
+        attachWorker(pid);
+        const waiter = workerCloseWaiters.get(pid);
+        if (!waiter) return;
+        await withTimeout(waiter.promise, STDERR_SETTLE_MAX_WAIT);
+    };
+    const getTaskStderr = (taskId)=>{
+        const binding = taskBindings.get(taskId);
+        if (!binding) return '';
+        const state = workerStates.get(binding.pid);
+        if (!state || 0 === state.chunks.length) return '';
+        return state.chunks.filter((chunk)=>chunk.seq > binding.startSeq).map((chunk)=>chunk.text).join('').trim();
+    };
+    const enhanceWorkerExitError = async (taskId, err)=>{
+        if (!(err instanceof Error) || !err.message.includes(WORKER_EXIT_ERROR)) return;
+        const binding = taskBindings.get(taskId) ?? await waitForTaskBinding(taskId);
+        if (!binding) return;
+        await waitForWorkerClose(binding.pid);
+        const stderr = formatCapturedStderr(getTaskStderr(taskId));
+        if (stderr.length > 0) err.message += `\n\nMaybe related stderr:\n${stderr}`;
+    };
+    const createTask = (taskId)=>{
+        if (!taskBindingWaiters.has(taskId)) taskBindingWaiters.set(taskId, createDeferred());
+    };
+    const clearTask = (taskId)=>{
+        taskBindings.delete(taskId);
+        taskBindingWaiters.delete(taskId);
+    };
+    const cleanup = ()=>{
+        for (const { onData, stream } of trackedWorkers.values())stream.off('data', onData);
+        trackedWorkers.clear();
+        workerStates.clear();
+        taskBindings.clear();
+        taskBindingWaiters.clear();
+        workerCloseWaiters.clear();
+    };
+    return {
+        createTask,
+        bindTaskToPid,
+        clearTask,
+        enhanceWorkerExitError,
+        cleanup
+    };
+};
 const forks_filename = fileURLToPath(import.meta.url);
 const forks_dirname = dirname(forks_filename);
-function createChannel(rpcMethods) {
+function createChannel(rpcMethods, onWorkerMeta) {
     const emitter = new node_events();
     const cleanup = ()=>emitter.removeAllListeners();
     const events = {
@@ -36,6 +210,8 @@ function createChannel(rpcMethods) {
             emitter.on(events.message, callback);
         },
         postMessage: (message)=>{
+            const workerMeta = parseWorkerMetaMessage(message);
+            if (workerMeta) return void onWorkerMeta?.(workerMeta);
             emitter.emit(events.response, message);
         }
     };
@@ -67,29 +243,50 @@ const createForksPool = (poolOptions)=>{
         isolateWorkers: isolate
     };
     const pool = new Tinypool(options);
+    const stderrCapture = createWorkerStderrCapture(pool);
+    let nextTaskId = 0;
     return {
         name: 'forks',
         runTest: async ({ options, rpcMethods })=>{
-            const { channel, cleanup } = createChannel(rpcMethods);
+            const taskId = ++nextTaskId;
+            stderrCapture.createTask(taskId);
+            const { channel, cleanup } = createChannel(rpcMethods, ({ pid })=>{
+                stderrCapture.bindTaskToPid(taskId, pid);
+            });
             try {
                 return await pool.run(options, {
                     channel
                 });
+            } catch (err) {
+                await stderrCapture.enhanceWorkerExitError(taskId, err);
+                throw err;
             } finally{
                 cleanup();
+                stderrCapture.clearTask(taskId);
             }
         },
         collectTests: async ({ options, rpcMethods })=>{
-            const { channel, cleanup } = createChannel(rpcMethods);
+            const taskId = ++nextTaskId;
+            stderrCapture.createTask(taskId);
+            const { channel, cleanup } = createChannel(rpcMethods, ({ pid })=>{
+                stderrCapture.bindTaskToPid(taskId, pid);
+            });
             try {
                 return await pool.run(options, {
                     channel
                 });
+            } catch (err) {
+                await stderrCapture.enhanceWorkerExitError(taskId, err);
+                throw err;
             } finally{
                 cleanup();
+                stderrCapture.clearTask(taskId);
             }
         },
-        close: ()=>pool.destroy()
+        close: async ()=>{
+            stderrCapture.cleanup();
+            await pool.destroy();
+        }
     };
 };
 const external_node_os_ = __webpack_require__("node:os");
@@ -182,8 +379,8 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
         ],
         env: {
             NODE_ENV: 'test',
-            ...process.env,
-            ...getForceColorEnv()
+            ...getForceColorEnv(),
+            ...process.env
         }
     });
     const rpcMethods = {
@@ -353,8 +550,8 @@ async function createSetupPool() {
         isolateWorkers: false,
         env: {
             NODE_ENV: 'test',
-            ...process.env,
-            ...getForceColorEnv()
+            ...getForceColorEnv(),
+            ...process.env
         }
     };
     const pool = new Tinypool(options);
@@ -400,7 +597,7 @@ async function runGlobalTeardown() {
         process.exitCode = 1;
     }
 }
-const external_node_path_ = __webpack_require__("path");
+const external_node_path_ = __webpack_require__("node:path");
 const RUNTIME_CHUNK_NAME = 'runtime';
 const requireShim = `// Rstest ESM shims
 import __rstest_shim_module__ from 'node:module';
@@ -680,7 +877,7 @@ const pluginInspect = (options)=>{
         }
     } : null;
 };
-const external_node_fs_ = __webpack_require__("fs");
+const external_node_fs_ = __webpack_require__("node:fs");
 const mockRuntime_dirname = external_node_path_["default"].dirname(fileURLToPath(import.meta.url));
 class MockRuntimeRspackPlugin {
     outputModule;
@@ -701,11 +898,11 @@ class MockRuntimeRspackPlugin {
         compiler.hooks.compilation.tap('RstestMockPlugin', (compilation)=>{
             compilation.hooks.runtimeModule.tap('RstestMockChunkLoadingRuntimePlugin', (module)=>{
                 if ('require_chunk_loading' === module.name) {
-                    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;");
+                    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) || Object.keys(__webpack_require__.rstest_original_module_factories).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;");
+                    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) || Object.keys(__webpack_require__.rstest_original_module_factories).includes(moduleId)) continue;");
                     module.source.source = Buffer.from(finalSource);
                 }
                 if ('define_property_getters' === module.name) {

package/dist/0~9348.js

@@ -1,5 +1,4 @@
-import 'module';
-/*#__PURE__*/ import.meta.url;
+import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import node_readline, { clearLine, createInterface, emitKeypressEvents, moveCursor } from "node:readline";
 import { stdout, node_process, stdin } from "./3160.js";