@rstest/core 0.9.2 → 0.9.3

package/LICENSE.md

@@ -1183,7 +1183,7 @@ Licensed under MIT license in the repository at https://github.com/facebook/reac
 
 ### readdirp
 
-Licensed under MIT license in the repository at git://github.com/paulmillr/readdirp.git.
+Licensed under MIT license in the repository at https://github.com/paulmillr/readdirp.git.
 
 > MIT License
 >

package/dist/0~8843.js

@@ -9,7 +9,7 @@ import node_path from "node:path";
 import { isBuiltin } from "node:module";
 import node_inspector from "node:inspector";
 import node_fs from "node:fs";
-import { basename, bgColor, isDeno, dirname, castArray, resolve as pathe_M_eThtNZ_resolve, isDebug, color, getForceColorEnv, ADDITIONAL_NODE_BUILTINS, needFlagExperimentalDetectModule, join } from "./6830.js";
+import { basename, bgColor, isDeno, dirname, castArray, resolve as pathe_M_eThtNZ_resolve, isDebug, color as logger_color, getForceColorEnv, ADDITIONAL_NODE_BUILTINS, needFlagExperimentalDetectModule, join } from "./6830.js";
 import { parseWorkerMetaMessage, createBirpc } from "./1983.js";
 import { TEMP_RSTEST_OUTPUT_DIR, TEMP_RSTEST_OUTPUT_DIR_GLOB } from "./4411.js";
 import { posix } from "./7011.js";
@@ -454,8 +454,8 @@ const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
                         const runningModule = context.stateManager.runningModules.get(entryInfo.testPath);
                         if (runningModule?.runningTests.length) {
                             const getCaseName = (test)=>`"${test.name}"${test.parentNames?.length ? ` (Under suite: ${test.parentNames?.join(' > ')})` : ''}`;
-                            if (runningModule?.runningTests.length === 1) err.message += `\n\n${color.white(`Maybe relevant test case: ${getCaseName(runningModule.runningTests[0])} which is running when the error occurs.`)}`;
-                            else err.message += `\n\n${color.white(`The below test cases may be relevant, as they were running when the error occurred:\n  - ${runningModule.runningTests.map((t)=>getCaseName(t)).join('\n  - ')}`)}`;
+                            if (runningModule?.runningTests.length === 1) err.message += `\n\n${logger_color.white(`Maybe relevant test case: ${getCaseName(runningModule.runningTests[0])} which is running when the error occurs.`)}`;
+                            else err.message += `\n\n${logger_color.white(`The below test cases may be relevant, as they were running when the error occurred:\n  - ${runningModule.runningTests.map((t)=>getCaseName(t)).join('\n  - ')}`)}`;
                         }
                         return {
                             testId: '0',
@@ -598,8 +598,8 @@ async function runGlobalTeardown() {
         await teardown();
     } catch (error) {
         console.error(bgColor('bgRed', 'Error during global teardown'));
-        if (error instanceof Error) error.stack ? console.error(color.red(error.stack)) : console.error(color.red(error.message));
-        else console.error(color.red(String(error)));
+        if (error instanceof Error) error.stack ? console.error(logger_color.red(error.stack)) : console.error(logger_color.red(error.message));
+        else console.error(logger_color.red(String(error)));
         process.exitCode = 1;
     }
 }

package/dist/0~browserLoader.js

@@ -2,9 +2,9 @@ import "node:module";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import "./4411.js";
-import { logger as logger_logger, color } from "./6830.js";
+import { logger as logger_logger, color as logger_color } from "./6830.js";
 async function loadBrowserModule(options = {}) {
-    const coreVersion = "0.9.2";
+    const coreVersion = "0.9.3";
     const { projectRoots = [] } = options;
     let browserModule;
     let browserVersion;
@@ -24,9 +24,9 @@ async function loadBrowserModule(options = {}) {
         const browserPkg = userRequire(browserPkgPath);
         browserVersion = browserPkg.version;
         if (browserVersion !== coreVersion) {
-            logger_logger.error(`\n${color.red('Error:')} Version mismatch between ${color.cyan('@rstest/core')} and ${color.cyan('@rstest/browser')}.\n`);
-            logger_logger.error(`  @rstest/core version:    ${color.yellow(coreVersion)}\n  @rstest/browser version: ${color.yellow(browserVersion)}\n`);
-            logger_logger.error(`Please ensure both packages have the same version:\n\n  ${color.cyan(`npm install @rstest/browser@${coreVersion}`)}\n`);
+            logger_logger.error(`\n${logger_color.red('Error:')} Version mismatch between ${logger_color.cyan('@rstest/core')} and ${logger_color.cyan('@rstest/browser')}.\n`);
+            logger_logger.error(`  @rstest/core version:    ${logger_color.yellow(coreVersion)}\n  @rstest/browser version: ${logger_color.yellow(browserVersion)}\n`);
+            logger_logger.error(`Please ensure both packages have the same version:\n\n  ${logger_color.cyan(`npm install @rstest/browser@${coreVersion}`)}\n`);
             process.exit(1);
         }
         return browserModule;
@@ -35,9 +35,9 @@ async function loadBrowserModule(options = {}) {
         if ('ERR_MODULE_NOT_FOUND' === err.code || 'MODULE_NOT_FOUND' === err.code) continue;
         throw error;
     }
-    logger_logger.error(`\n${color.red('Error:')} Browser mode requires ${color.cyan('@rstest/browser')} to be installed.\n`);
-    logger_logger.error(`Please install it with:\n\n  ${color.cyan(`npm install @rstest/browser@${coreVersion}`)}\n`);
-    logger_logger.error(`Or if using pnpm:\n\n  ${color.cyan(`pnpm add @rstest/browser@${coreVersion}`)}\n`);
+    logger_logger.error(`\n${logger_color.red('Error:')} Browser mode requires ${logger_color.cyan('@rstest/browser')} to be installed.\n`);
+    logger_logger.error(`Please install it with:\n\n  ${logger_color.cyan(`npm install @rstest/browser@${coreVersion}`)}\n`);
+    logger_logger.error(`Or if using pnpm:\n\n  ${logger_color.cyan(`pnpm add @rstest/browser@${coreVersion}`)}\n`);
     process.exit(1);
 }
 export { loadBrowserModule };

package/dist/0~browser~1.js

@@ -4,7 +4,7 @@ import node_fs from "node:fs";
 import { detect, resolveCommand } from "./3145.js";
 import { confirm as Rt, intro as dist_Wt, log as R, note as dist_Vt, outro as Gt, cancel as Nt, isCancel as Ct, spinner as be, select as Jt } from "./0~dist.js";
 import "./4411.js";
-import { determineAgent, color } from "./6830.js";
+import { determineAgent, color as logger_color } from "./6830.js";
 function getUniqueBaseName(dir, baseName, ext) {
     const fullPath = node_path.join(dir, `${baseName}${ext}`);
     if (!node_fs.existsSync(fullPath)) return baseName;
@@ -323,14 +323,14 @@ async function createNonInteractive(cwd, projectInfo) {
     const { agent, testDir, framework, reactVersion } = projectInfo;
     const provider = 'playwright';
     console.log();
-    console.log(color.cyan('◆'), color.bold('rstest init browser --yes'));
+    console.log(logger_color.cyan('◆'), logger_color.bold('rstest init browser --yes'));
     console.log();
     console.log('  Detecting project...');
-    if ('react' === framework && reactVersion) console.log(color.green('  ✓'), `Found React ${reactVersion}`);
-    else if ('react' === framework) console.log(color.green('  ✓'), 'Found React');
-    else console.log(color.yellow('  ⚠'), 'Framework not detected, generating vanilla DOM example');
-    console.log(color.green('  ✓'), 'Using playwright as browser provider');
-    console.log(color.green('  ✓'), `Test directory: ${testDir}/`);
+    if ('react' === framework && reactVersion) console.log(logger_color.green('  ✓'), `Found React ${reactVersion}`);
+    else if ('react' === framework) console.log(logger_color.green('  ✓'), 'Found React');
+    else console.log(logger_color.yellow('  ⚠'), 'Framework not detected, generating vanilla DOM example');
+    console.log(logger_color.green('  ✓'), 'Using playwright as browser provider');
+    console.log(logger_color.green('  ✓'), `Test directory: ${testDir}/`);
     console.log();
     const createdFiles = await generateFiles(cwd, projectInfo, provider);
     console.log('  Created files:');
@@ -342,20 +342,20 @@ async function createNonInteractive(cwd, projectInfo) {
     console.log(`    ${getPlaywrightInstallCommand(agent, provider)}`);
     console.log(`    ${getRunCommand(agent)}`);
     console.log();
-    console.log(color.green('└'), 'Done!');
+    console.log(logger_color.green('└'), 'Done!');
 }
 async function createInteractive(cwd, projectInfo, isAgent) {
     const { agent, language, testDir, framework, reactVersion } = projectInfo;
     const effectiveFramework = 'react' === framework ? 'react' : 'vanilla';
-    dist_Wt(color.bgCyan(color.black(' rstest init browser ')));
+    dist_Wt(logger_color.bgCyan(logger_color.black(' rstest init browser ')));
     const detectionLines = [];
-    if ('react' === framework && reactVersion) detectionLines.push(`${color.green('✓')} Found React ${reactVersion}`);
-    else if ('react' === framework) detectionLines.push(`${color.green('✓')} Found React`);
-    else detectionLines.push(`${color.yellow('⚠')} Framework not detected, will generate vanilla DOM example`);
-    detectionLines.push(`${color.green('✓')} Found ${'ts' === language ? 'TypeScript' : 'JavaScript'}`);
-    detectionLines.push(`${color.green('✓')} Test directory: ${testDir}/`);
+    if ('react' === framework && reactVersion) detectionLines.push(`${logger_color.green('✓')} Found React ${reactVersion}`);
+    else if ('react' === framework) detectionLines.push(`${logger_color.green('✓')} Found React`);
+    else detectionLines.push(`${logger_color.yellow('⚠')} Framework not detected, will generate vanilla DOM example`);
+    detectionLines.push(`${logger_color.green('✓')} Found ${'ts' === language ? 'TypeScript' : 'JavaScript'}`);
+    detectionLines.push(`${logger_color.green('✓')} Test directory: ${testDir}/`);
     dist_Vt(detectionLines.join('\n'), 'Detecting project...');
-    if (isAgent) R.info(`AI Agent detected. For non-interactive mode, run:\n  ${color.cyan('npx rstest init browser --yes')}`);
+    if (isAgent) R.info(`AI Agent detected. For non-interactive mode, run:\n  ${logger_color.cyan('npx rstest init browser --yes')}`);
     const providerSelection = await Jt({
         message: 'Choose a browser provider (so far, only Playwright)',
         options: [
@@ -372,15 +372,15 @@ async function createInteractive(cwd, projectInfo, isAgent) {
     }
     const provider = providerSelection;
     const preview = computeFilePreview(cwd, projectInfo);
-    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.9.2");
+    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.9.3");
     const depsList = Object.entries(deps).map(([name, version])=>`${name}@${version}`).join(', ');
     const previewLines = [
-        `${color.cyan('+')} Create ${preview.configFile}`,
-        `${color.cyan('+')} Create ${preview.componentFile}`,
-        `${color.cyan('+')} Create ${preview.testFile}`,
-        `${color.yellow('~')} Modify package.json`,
+        `${logger_color.cyan('+')} Create ${preview.configFile}`,
+        `${logger_color.cyan('+')} Create ${preview.componentFile}`,
+        `${logger_color.cyan('+')} Create ${preview.testFile}`,
+        `${logger_color.yellow('~')} Modify package.json`,
         '   - Add "test:browser" script',
-        `   - Add devDependencies: ${color.dim(depsList)}`
+        `   - Add devDependencies: ${logger_color.dim(depsList)}`
     ];
     dist_Vt(previewLines.join('\n'), 'Changes to be made');
     const confirmed = await Rt({
@@ -395,21 +395,21 @@ async function createInteractive(cwd, projectInfo, isAgent) {
     s.start('Creating files...');
     const createdFiles = await generateFiles(cwd, projectInfo, provider);
     s.stop('Created files');
-    const fileLines = createdFiles.map((f)=>`${color.green('✓')} Created ${f}`);
-    fileLines.push(`${color.green('✓')} Updated package.json`);
+    const fileLines = createdFiles.map((f)=>`${logger_color.green('✓')} Created ${f}`);
+    fileLines.push(`${logger_color.green('✓')} Updated package.json`);
     dist_Vt(fileLines.join('\n'), 'Files');
     const nextStepsLines = [
-        `${color.bold('1.')} Install dependencies:`,
-        `   ${color.cyan(getInstallCommand(agent))}`,
+        `${logger_color.bold('1.')} Install dependencies:`,
+        `   ${logger_color.cyan(getInstallCommand(agent))}`,
         '',
-        `${color.bold('2.')} Install Playwright browsers:`,
-        `   ${color.cyan(getPlaywrightInstallCommand(agent, provider))}`,
+        `${logger_color.bold('2.')} Install Playwright browsers:`,
+        `   ${logger_color.cyan(getPlaywrightInstallCommand(agent, provider))}`,
         '',
-        `${color.bold('3.')} Run your tests:`,
-        `   ${color.cyan(getRunCommand(agent))}`
+        `${logger_color.bold('3.')} Run your tests:`,
+        `   ${logger_color.cyan(getRunCommand(agent))}`
     ];
     dist_Vt(nextStepsLines.join('\n'), 'Next steps');
-    Gt(color.green('Done! Happy testing with Rstest!'));
+    Gt(logger_color.green('Done! Happy testing with Rstest!'));
 }
 async function generateFiles(cwd, projectInfo, provider) {
     const { language, testDir, framework } = projectInfo;
@@ -450,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.9.2");
+    const deps = getDependenciesWithVersions(effectiveFramework, provider, "0.9.3");
     updatePackageJsonDevDeps(cwd, deps);
     return createdFiles;
 }

package/dist/0~checkThresholds.js

@@ -1,7 +1,7 @@
 import "node:module";
 import { __webpack_require__ } from "./rslib-runtime.js";
 import "./4411.js";
-import { relative, color } from "./6830.js";
+import { relative, color as logger_color } from "./6830.js";
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
 var picomatch_default = /*#__PURE__*/ __webpack_require__.n(picomatch);
 const THRESHOLD_KEYS = [
@@ -34,7 +34,7 @@ function checkThresholds({ coverageMap, thresholds, coverageProvider, rootPath }
         const matcher = picomatch_default()(key);
         const matchedFiles = allFiles.filter((file)=>matcher(relative(rootPath, file)));
         if (!matchedFiles.length) {
-            failedThresholds.push(`${color.red('Error')}: coverage data for "${key}" was not found`);
+            failedThresholds.push(`${logger_color.red('Error')}: coverage data for "${key}" was not found`);
             continue;
         }
         for (const file of matchedFiles){
@@ -52,10 +52,10 @@ function checkThresholds({ coverageMap, thresholds, coverageProvider, rootPath }
         if (void 0 !== expected) {
             if (expected < 0) {
                 const uncovered = actual.total - actual.covered;
-                if (uncovered > -expected) errorMsg += `uncovered ${name} ${color.red(`${uncovered}`)} exceeds maximum ${'global' === type ? 'global' : `"${type}"`} threshold allowed ${color.yellow(`${-expected}`)}`;
-            } else if (actual.pct < expected) errorMsg += `coverage for ${name} ${color.red(`${actual.pct}%`)} does not meet ${'global' === type ? 'global' : `"${type}"`} threshold ${color.yellow(`${expected}%`)}`;
+                if (uncovered > -expected) errorMsg += `uncovered ${name} ${logger_color.red(`${uncovered}`)} exceeds maximum ${'global' === type ? 'global' : `"${type}"`} threshold allowed ${logger_color.yellow(`${-expected}`)}`;
+            } else if (actual.pct < expected) errorMsg += `coverage for ${name} ${logger_color.red(`${actual.pct}%`)} does not meet ${'global' === type ? 'global' : `"${type}"`} threshold ${logger_color.yellow(`${expected}%`)}`;
         }
-        if (errorMsg) failedThresholds.push(`${color.red('Error')}: ${file ? `${relative(rootPath, file)} ` : ''}${errorMsg}`);
+        if (errorMsg) failedThresholds.push(`${logger_color.red('Error')}: ${file ? `${relative(rootPath, file)} ` : ''}${errorMsg}`);
     };
     thresholdGroup.forEach(({ name, coverageMap, ...thresholds })=>{
         const summaries = thresholds.perFile ? coverageMap.files().map((file)=>({

package/dist/{0~esm.js → 0~chokidar.js}

@@ -1,10 +1,9 @@
-/*! LICENSE: 0~esm.js.LICENSE.txt */
+/*! LICENSE: 0~chokidar.js.LICENSE.txt */
 import "node:module";
+import { EventEmitter } from "node:events";
 import { stat as external_node_fs_stat, unwatchFile, watch, watchFile } from "node:fs";
-import { lstat as promises_lstat, open as promises_open, readdir, realpath as external_fs_promises_realpath, stat as promises_stat } from "fs/promises";
-import { EventEmitter } from "events";
+import { lstat, open as promises_open, readdir, realpath as promises_realpath, stat as promises_stat } from "node:fs/promises";
 import { basename as external_node_path_basename, dirname as external_node_path_dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve as external_node_path_resolve, sep } from "node:path";
-import { lstat, readdir as promises_readdir, realpath as promises_realpath, stat as external_node_fs_promises_stat } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { type as external_node_os_type } from "node:os";
 const EntryTypes = {
@@ -65,6 +64,20 @@ const normalizeFilter = (filter)=>{
     return emptyFn;
 };
 class ReaddirpStream extends Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
     constructor(options = {}){
         super({
             objectMode: true,
@@ -78,12 +91,12 @@ class ReaddirpStream extends Readable {
         const { root, type } = opts;
         this._fileFilter = normalizeFilter(opts.fileFilter);
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
-        const statMethod = opts.lstat ? lstat : external_node_fs_promises_stat;
+        const statMethod = opts.lstat ? lstat : promises_stat;
         if (wantBigintFsStats) this._stat = (path)=>statMethod(path, {
                 bigint: true
             });
         else this._stat = statMethod;
-        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._maxDepth = null != opts.depth && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
         this._wantsDir = type ? DIR_TYPES.has(type) : false;
         this._wantsFile = type ? FILE_TYPES.has(type) : false;
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
@@ -147,7 +160,7 @@ class ReaddirpStream extends Readable {
     async _exploreDir(path, depth) {
         let files;
         try {
-            files = await promises_readdir(path, this._rdOptions);
+            files = await readdir(path, this._rdOptions);
         } catch (error) {
             this._onError(error);
         }
@@ -244,7 +257,7 @@ const EVENTS = {
 const EV = EVENTS;
 const THROTTLE_MODE_WATCH = 'watch';
 const statMethods = {
-    lstat: promises_lstat,
+    lstat: lstat,
     stat: promises_stat
 };
 const KEY_LISTENERS = 'listeners';
@@ -655,6 +668,8 @@ const setFsWatchFileListener = (path, fullPath, options, handlers)=>{
     };
 };
 class NodeFsHandler {
+    fsw;
+    _boundHandleError;
     constructor(fsW){
         this.fsw = fsW;
         this._boundHandleError = (error)=>fsW._handleError(error);
@@ -732,7 +747,7 @@ class NodeFsHandler {
             this.fsw._incrReadyCount();
             let linkPath;
             try {
-                linkPath = await external_fs_promises_realpath(path);
+                linkPath = await promises_realpath(path);
             } catch (e) {
                 this.fsw._emitReady();
                 return true;
@@ -756,7 +771,8 @@ class NodeFsHandler {
     }
     _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
         directory = join(directory, '');
-        throttler = this.fsw._throttle('readdir', directory, 1000);
+        const throttleKey = target ? `${directory}:${target}` : directory;
+        throttler = this.fsw._throttle('readdir', throttleKey, 1000);
         if (!throttler) return;
         const previous = this.fsw._getWatchedDir(wh.path);
         const current = new Set();
@@ -844,13 +860,13 @@ class NodeFsHandler {
             let closer;
             if (stats.isDirectory()) {
                 const absPath = external_node_path_resolve(path);
-                const targetPath = follow ? await external_fs_promises_realpath(path) : path;
+                const targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed) return;
                 closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
                 if (this.fsw.closed) return;
                 if (absPath !== targetPath && void 0 !== targetPath) this.fsw._symlinkPaths.set(absPath, targetPath);
             } else if (stats.isSymbolicLink()) {
-                const targetPath = follow ? await external_fs_promises_realpath(path) : path;
+                const targetPath = follow ? await promises_realpath(path) : path;
                 if (this.fsw.closed) return;
                 const parent = external_node_path_dirname(wh.watchPath);
                 this.fsw._getWatchedDir(parent).add(wh.watchPath);
@@ -876,7 +892,7 @@ const ONE_DOT = '.';
 const TWO_DOTS = '..';
 const STRING_TYPE = 'string';
 const BACK_SLASH_RE = /\\/g;
-const esm_DOUBLE_SLASH_RE = /\/\//;
+const DOUBLE_SLASH_RE = /\/\//g;
 const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 const REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -906,8 +922,7 @@ function normalizePath(path) {
     path = path.replace(/\\/g, '/');
     let prepend = false;
     if (path.startsWith('//')) prepend = true;
-    const DOUBLE_SLASH_RE = /\/\//;
-    while(path.match(DOUBLE_SLASH_RE))path = path.replace(DOUBLE_SLASH_RE, '/');
+    path = path.replace(DOUBLE_SLASH_RE, '/');
     if (prepend) path = '/' + path;
     return path;
 }
@@ -935,7 +950,7 @@ const toUnix = (string)=>{
     let str = string.replace(BACK_SLASH_RE, SLASH);
     let prepend = false;
     if (str.startsWith(SLASH_SLASH)) prepend = true;
-    while(str.match(esm_DOUBLE_SLASH_RE))str = str.replace(esm_DOUBLE_SLASH_RE, SLASH);
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
     if (prepend) str = SLASH + str;
     return str;
 };
@@ -950,6 +965,9 @@ const getAbsolutePath = (path, cwd)=>{
 };
 const EMPTY_SET = Object.freeze(new Set());
 class DirEntry {
+    path;
+    _removeWatcher;
+    items;
     constructor(dir, removeWatcher){
         this.path = dir;
         this._removeWatcher = removeWatcher;
@@ -995,6 +1013,13 @@ class DirEntry {
 const STAT_METHOD_F = 'stat';
 const STAT_METHOD_L = 'lstat';
 class WatchHelper {
+    fsw;
+    path;
+    watchPath;
+    fullWatchPath;
+    dirParts;
+    followSymlinks;
+    statMethod;
     constructor(path, follow, fsw){
         this.fsw = fsw;
         const watchPath = path;
@@ -1022,6 +1047,24 @@ class WatchHelper {
     }
 }
 class FSWatcher extends EventEmitter {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
     constructor(_opts = {}){
         super();
         this.closed = false;
@@ -1413,9 +1456,9 @@ class FSWatcher extends EventEmitter {
         return stream;
     }
 }
-function esm_watch(paths, options = {}) {
+function chokidar_watch(paths, options = {}) {
     const watcher = new FSWatcher(options);
     watcher.add(paths);
     return watcher;
 }
-export { esm_watch as watch };
+export { chokidar_watch as watch };

package/dist/0~console.js

@@ -2,7 +2,7 @@ import "node:module";
 import { AssertionError, strict } from "node:assert";
 import { Console } from "node:console";
 import { format, formatWithOptions, inspect } from "node:util";
-import { prettyTime, color } from "./6830.js";
+import { prettyTime, color as logger_color } from "./6830.js";
 const RealDate = Date;
 function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
     const getConsoleTrace = ()=>{
@@ -21,13 +21,13 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
         getPrettyName(type) {
             switch(type){
                 case 'error':
-                    return color.red(type);
+                    return logger_color.red(type);
                 case 'warn':
-                    return color.yellow(type);
+                    return logger_color.yellow(type);
                 case 'info':
-                    return color.cyan(type);
+                    return logger_color.cyan(type);
                 default:
-                    return color.gray(type);
+                    return logger_color.gray(type);
             }
         }
         _log(name, message, type = 'stdout') {
@@ -69,11 +69,11 @@ function createCustomConsole({ rpc, testPath, printConsoleTrace }) {
         }
         group(title, ...args) {
             this._groupDepth++;
-            if (null != title || args.length > 0) this._log('group', color.bold(format(title, ...args)));
+            if (null != title || args.length > 0) this._log('group', logger_color.bold(format(title, ...args)));
         }
         groupCollapsed(title, ...args) {
             this._groupDepth++;
-            if (null != title || args.length > 0) this._log('groupCollapsed', color.bold(format(title, ...args)));
+            if (null != title || args.length > 0) this._log('groupCollapsed', logger_color.bold(format(title, ...args)));
         }
         groupEnd() {
             if (this._groupDepth > 0) this._groupDepth--;

package/dist/0~generate.js

@@ -22,6 +22,10 @@ async function generateCoverage(context, results, coverageProvider) {
     try {
         const finalCoverageMap = coverageProvider.createCoverageMap();
         for (const result of results)if (result.coverage) finalCoverageMap.merge(result.coverage);
+        if (!coverage.allowExternal) finalCoverageMap.filter((filePath)=>{
+            const normalizedFile = normalize(filePath);
+            return normalizedFile.startsWith(normalize(rootPath));
+        });
         if (coverage.include?.length) {
             const coveredFiles = finalCoverageMap.files().map(normalize);
             let isTimeout = false;

package/dist/0~listTests.js

@@ -3,7 +3,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative } from "node:path";
 import { prepareRsbuild, createPool, createRsbuildServer, runGlobalTeardown, runGlobalSetup } from "./0~8843.js";
 import { getTestEntries, resolveShardedEntries, prettyTestPath, ROOT_SUITE_NAME } from "./4411.js";
-import { logger as logger_logger, getTaskNameWithPrefix, color, bgColor } from "./6830.js";
+import { logger as logger_logger, getTaskNameWithPrefix, color as logger_color, bgColor } from "./6830.js";
 const collectNodeTests = async ({ context, nodeProjects, globTestSourceEntries })=>{
     const { getSetupFiles } = await import("./255.js");
     if (0 === nodeProjects.length) return {
@@ -262,7 +262,7 @@ async function listTests(context, { filesOnly, json, printLocation, includeSuite
     } else for (const test of tests){
         let shortPath = relative(rootPath, test.file);
         if (test.location && printLocation) shortPath = `${shortPath}:${test.location.line}:${test.location.column}`;
-        logger_logger.log(test.name ? `${color.dim(`${shortPath} > `)}${test.name}` : prettyTestPath(shortPath));
+        logger_logger.log(test.name ? `${logger_color.dim(`${shortPath} > `)}${test.name}` : prettyTestPath(shortPath));
     }
     await close();
     return list;

package/dist/0~mergeReports.js

@@ -0,0 +1,127 @@
+import "node:module";
+import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
+import { createCoverageProvider } from "./7704.js";
+import "./4411.js";
+import { prettyTime, logger as logger_logger, relative, color as logger_color, join } from "./6830.js";
+const DEFAULT_BLOB_DIR = '.rstest-reports';
+function loadBlobFiles(blobDir) {
+    if (!existsSync(blobDir)) throw new Error(`Blob reports directory not found: ${logger_color.cyan(blobDir)}\nRun tests with --reporter=blob first to generate shard reports.`);
+    const files = readdirSync(blobDir).filter((f)=>/^blob(-\d+-\d+)?\.json$/.test(f)).sort();
+    if (0 === files.length) throw new Error(`No blob report files found in: ${logger_color.cyan(blobDir)}\nRun tests with --reporter=blob first to generate shard reports.`);
+    return files.map((file)=>{
+        const content = readFileSync(join(blobDir, file), 'utf-8');
+        return JSON.parse(content);
+    });
+}
+function mergeSnapshots(summaries) {
+    const merged = {
+        added: 0,
+        didUpdate: false,
+        failure: false,
+        filesAdded: 0,
+        filesRemoved: 0,
+        filesRemovedList: [],
+        filesUnmatched: 0,
+        filesUpdated: 0,
+        matched: 0,
+        total: 0,
+        unchecked: 0,
+        uncheckedKeysByFile: [],
+        unmatched: 0,
+        updated: 0
+    };
+    for (const s of summaries){
+        merged.added += s.added;
+        merged.filesAdded += s.filesAdded;
+        merged.filesRemoved += s.filesRemoved;
+        merged.filesRemovedList.push(...s.filesRemovedList);
+        merged.filesUnmatched += s.filesUnmatched;
+        merged.filesUpdated += s.filesUpdated;
+        merged.matched += s.matched;
+        merged.total += s.total;
+        merged.unchecked += s.unchecked;
+        merged.uncheckedKeysByFile.push(...s.uncheckedKeysByFile);
+        merged.unmatched += s.unmatched;
+        merged.updated += s.updated;
+        if (s.didUpdate) merged.didUpdate = true;
+        if (s.failure) merged.failure = true;
+    }
+    return merged;
+}
+function mergeDurations(durations) {
+    let totalTime = 0;
+    let buildTime = 0;
+    let testTime = 0;
+    for (const d of durations){
+        totalTime += d.totalTime;
+        buildTime += d.buildTime;
+        testTime += d.testTime;
+    }
+    return {
+        totalTime,
+        buildTime,
+        testTime
+    };
+}
+async function mergeReports(context, options) {
+    const { path, cleanup } = options || {};
+    const blobDir = path ? join(context.rootPath, path) : join(context.rootPath, DEFAULT_BLOB_DIR);
+    const blobs = loadBlobFiles(blobDir);
+    const relativeBlobDir = relative(context.rootPath, blobDir) || '.';
+    logger_logger.log(`\nMerging ${logger_color.bold(String(blobs.length))} blob ${1 === blobs.length ? 'report' : 'reports'} from ${logger_color.cyan(relativeBlobDir)}\n`);
+    const allResults = [];
+    const allTestResults = [];
+    const allDurations = [];
+    const shardDurations = [];
+    const allSnapshotSummaries = [];
+    const allUnhandledErrors = [];
+    for (const blob of blobs){
+        allResults.push(...blob.results);
+        allTestResults.push(...blob.testResults);
+        allDurations.push(blob.duration);
+        allSnapshotSummaries.push(blob.snapshotSummary);
+        const shardLabel = blob.shard ? `Shard ${blob.shard.index}/${blob.shard.count}` : 'Shard';
+        shardDurations.push({
+            label: shardLabel,
+            duration: blob.duration
+        });
+        if (blob.unhandledErrors) for (const e of blob.unhandledErrors){
+            const error = new Error(e.message);
+            error.name = e.name || 'Error';
+            error.stack = e.stack;
+            allUnhandledErrors.push(error);
+        }
+        if (blob.consoleLogs) for (const log of blob.consoleLogs)for (const reporter of context.reporters)reporter.onUserConsoleLog?.(log);
+    }
+    const mergedDuration = mergeDurations(allDurations);
+    const mergedSnapshotSummary = mergeSnapshots(allSnapshotSummaries);
+    const hasFailure = allResults.some((r)=>'fail' === r.status) || allUnhandledErrors.length > 0;
+    if (hasFailure) process.exitCode = 1;
+    for (const reporter of context.reporters)await reporter.onTestRunStart?.();
+    for (const { label, duration } of shardDurations)logger_logger.log(logger_color.gray(`  ${label}: ${prettyTime(duration.totalTime)} (build ${prettyTime(duration.buildTime)}, tests ${prettyTime(duration.testTime)})`));
+    if (shardDurations.length > 0) logger_logger.log('');
+    for (const result of allResults)for (const reporter of context.reporters)reporter.onTestFileResult?.(result);
+    for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
+        results: allResults,
+        testResults: allTestResults,
+        duration: mergedDuration,
+        snapshotSummary: mergedSnapshotSummary,
+        unhandledErrors: allUnhandledErrors.length ? allUnhandledErrors : void 0,
+        getSourcemap: async ()=>null
+    });
+    const { coverage } = context.normalizedConfig;
+    if (coverage.enabled && (!hasFailure || coverage.reportOnFailure)) {
+        const coverageProvider = await createCoverageProvider(coverage, context.rootPath);
+        if (coverageProvider) {
+            const { generateCoverage } = await import("./0~generate.js");
+            await generateCoverage(context, allResults, coverageProvider);
+        }
+    }
+    if (cleanup && existsSync(blobDir)) {
+        rmSync(blobDir, {
+            recursive: true
+        });
+        logger_logger.log(logger_color.gray(`Cleaned up blob reports directory: ${relativeBlobDir}\n`));
+    }
+}
+export { mergeReports };