@rstest/core 0.1.2 → 0.2.0

package/dist/668.js.LICENSE.txt

@@ -0,0 +1 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */

package/dist/813.js

@@ -134,7 +134,7 @@ export const __webpack_modules__ = {
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
-        __webpack_require__("fs");
+        __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("node:module");
         __webpack_require__("pathe");

package/dist/854.js

@@ -9,7 +9,6 @@ export const __webpack_modules__ = {
             r: ()=>createRsbuildServer,
             z: ()=>prepareRsbuild
         });
-        var external_node_fs_ = __webpack_require__("fs");
         var core_ = __webpack_require__("@rsbuild/core");
         var external_pathe_ = __webpack_require__("pathe");
         var utils = __webpack_require__("./src/utils/index.ts");
@@ -142,7 +141,7 @@ export const __webpack_modules__ = {
                 });
             }
         }
-        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles })=>({
+        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, configFilePath })=>({
                 name: 'rstest:entry-watch',
                 setup: (api)=>{
                     api.modifyRspackConfig(async (config)=>{
@@ -158,7 +157,8 @@ export const __webpack_modules__ = {
                             config.watchOptions ??= {};
                             config.watchOptions.ignored = (0, utils.XQ)(config.watchOptions.ignored || []);
                             if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
-                            config.watchOptions.ignored.push(utils.f1);
+                            config.watchOptions.ignored.push(utils.f1, '**/*.snap');
+                            if (configFilePath) config.watchOptions.ignored.push(configFilePath);
                         } else {
                             config.watch = false;
                             config.watchOptions ??= {};
@@ -476,6 +476,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         pluginEntryWatch({
                             globTestSourceEntries,
                             setupFiles,
+                            configFilePath: context.configFilePath,
                             isWatch: 'watch' === command
                         }),
                         pluginExternal(testEnvironment),
@@ -508,12 +509,15 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     rstest: normalizedConfig
                 }
             });
-            const outputFileSystem = (isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem) || external_node_fs_["default"];
-            const getRsbuildStats = async ()=>{
+            if (!rspackCompiler) throw new Error('rspackCompiler was not initialized');
+            const outputFileSystem = isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem;
+            if (!outputFileSystem) throw new Error(`Expect outputFileSystem to be defined, but got ${outputFileSystem}`);
+            const getRsbuildStats = async ({ fileFilters } = {})=>{
                 const stats = await devServer.environments[name].getStats();
                 const manifest = devServer.environments[name].context.manifest;
-                const { entrypoints, outputPath, assets, time: buildTime } = stats.toJson({
+                const { entrypoints, outputPath, assets, hash, time: buildTime } = stats.toJson({
                     all: false,
+                    hash: true,
                     entrypoints: true,
                     outputPath: true,
                     assets: true,
@@ -548,11 +552,14 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         testPath: setupFiles[entry],
                         files: entryFiles[entry]
                     });
-                    else if (sourceEntries[entry]) entries.push({
-                        distPath,
-                        testPath: sourceEntries[entry],
-                        files: entryFiles[entry]
-                    });
+                    else if (sourceEntries[entry]) {
+                        if (fileFilters?.length && !fileFilters.includes(sourceEntries[entry])) continue;
+                        entries.push({
+                            distPath,
+                            testPath: sourceEntries[entry],
+                            files: entryFiles[entry]
+                        });
+                    }
                 }
                 const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
                 const sourceMaps = Object.fromEntries((await Promise.all(assets.map(async (asset)=>{
@@ -579,6 +586,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     ];
                 }))).filter((asset)=>null !== asset[1]));
                 return {
+                    hash,
                     entries,
                     setupEntries,
                     buildTime: buildTime,
@@ -590,11 +598,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         ];
                     }))),
                     sourceMaps,
-                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null,
-                    close: devServer.close
+                    getSourcemap: (sourcePath)=>sourceMaps[sourcePath] || null
                 };
             };
-            return getRsbuildStats;
+            return {
+                closeServer: devServer.close,
+                getRsbuildStats
+            };
         };
     },
     "./src/pool/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -689,12 +699,41 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             }
             return parsed > 0 ? parsed : 1;
         };
-        const createPool = async ({ entries, context, assetFiles, setupEntries, sourceMaps })=>{
+        const getRuntimeConfig = (context)=>{
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate } = context.normalizedConfig;
+            return {
+                testNamePattern,
+                testTimeout,
+                hookTimeout,
+                passWithNoTests,
+                retry,
+                globals,
+                clearMocks,
+                resetMocks,
+                restoreMocks,
+                unstubEnvs,
+                unstubGlobals,
+                maxConcurrency,
+                printConsoleTrace,
+                disableConsoleIntercept,
+                testEnvironment,
+                isolate
+            };
+        };
+        const filterAssetsByEntry = (entryInfo, assetFiles, setupAssets, sourceMaps, entryLength)=>{
+            const neededFiles = entryLength > 1 && entryInfo.files ? Object.fromEntries(Object.entries(assetFiles).filter(([key])=>entryInfo.files.includes(key) || setupAssets.includes(key))) : assetFiles;
+            const neededSourceMaps = entryLength > 1 ? Object.fromEntries(Object.entries(sourceMaps).filter(([key])=>neededFiles[key])) : sourceMaps;
+            return {
+                assetFiles: neededFiles,
+                sourceMaps: neededSourceMaps
+            };
+        };
+        const createPool = async ({ context, recommendWorkerCount = 1 / 0 })=>{
             const execArgv = process.execArgv.filter((execArg)=>execArg.startsWith('--perf') || execArg.startsWith('--cpu-prof') || execArg.startsWith('--heap-prof') || execArg.startsWith('--diagnostic-dir'));
             const numCpus = getNumCpus();
             const { normalizedConfig: { pool: poolOptions, isolate }, reporters } = context;
             const threadsCount = 'watch' === context.command ? Math.max(Math.floor(numCpus / 2), 1) : Math.max(numCpus - 1, 1);
-            const recommendCount = 'watch' === context.command ? threadsCount : Math.min(Object.keys(entries).length, threadsCount);
+            const recommendCount = 'watch' === context.command ? threadsCount : Math.min(recommendWorkerCount, threadsCount);
             const maxWorkers = poolOptions.maxWorkers ? parseWorkers(poolOptions.maxWorkers) : recommendCount;
             const minWorkers = poolOptions.minWorkers ? parseWorkers(poolOptions.minWorkers) : maxWorkers < recommendCount ? maxWorkers : recommendCount;
             if (maxWorkers < minWorkers) throw `Invalid pool configuration: maxWorkers(${maxWorkers}) cannot be less than minWorkers(${minWorkers}).`;
@@ -717,26 +756,6 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     ...process.env
                 }
             });
-            const { updateSnapshot } = context.snapshotManager.options;
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout } = context.normalizedConfig;
-            const runtimeConfig = {
-                testNamePattern,
-                testTimeout,
-                hookTimeout,
-                passWithNoTests,
-                retry,
-                globals,
-                clearMocks,
-                resetMocks,
-                restoreMocks,
-                unstubEnvs,
-                unstubGlobals,
-                maxConcurrency,
-                printConsoleTrace,
-                disableConsoleIntercept,
-                testEnvironment,
-                isolate
-            };
             const rpcMethods = {
                 onTestCaseResult: async (result)=>{
                     await Promise.all(reporters.map((reporter)=>reporter.onTestCaseResult?.(result)));
@@ -751,30 +770,23 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     await Promise.all(reporters.map((reporter)=>reporter.onTestFileResult?.(test)));
                 }
             };
-            const setupAssets = setupEntries.flatMap((entry)=>entry.files);
-            const entryLength = Object.keys(entries).length;
-            const filterAssetsByEntry = (entryInfo)=>{
-                const neededFiles = entryLength > 1 && entryInfo.files ? Object.fromEntries(Object.entries(assetFiles).filter(([key])=>entryInfo.files.includes(key) || setupAssets.includes(key))) : assetFiles;
-                const neededSourceMaps = entryLength > 1 ? Object.fromEntries(Object.entries(sourceMaps).filter(([key])=>neededFiles[key])) : sourceMaps;
-                return {
-                    assetFiles: neededFiles,
-                    sourceMaps: neededSourceMaps
-                };
-            };
             return {
-                runTests: async ()=>{
+                runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
+                    const entryLength = Object.keys(entries).length;
+                    const runtimeConfig = getRuntimeConfig(context);
                     const results = await Promise.all(entries.map((entryInfo)=>{
-                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                        const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.runTest({
                             options: {
                                 entryInfo,
-                                assetFiles,
+                                assetFiles: neededFiles,
                                 context: {
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.v8)(runtimeConfig)
                                 },
                                 type: 'run',
-                                sourceMaps,
+                                sourceMaps: neededSourceMaps,
                                 setupEntries,
                                 updateSnapshot
                             },
@@ -799,18 +811,22 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         testResults
                     };
                 },
-                collectTests: async ()=>Promise.all(entries.map((entryInfo)=>{
-                        const { assetFiles, sourceMaps } = filterAssetsByEntry(entryInfo);
+                collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                    const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
+                    const entryLength = Object.keys(entries).length;
+                    const runtimeConfig = getRuntimeConfig(context);
+                    return Promise.all(entries.map((entryInfo)=>{
+                        const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.collectTests({
                             options: {
                                 entryInfo,
-                                assetFiles,
+                                assetFiles: neededFiles,
                                 context: {
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.v8)(runtimeConfig)
                                 },
                                 type: 'collect',
-                                sourceMaps,
+                                sourceMaps: neededSourceMaps,
                                 setupEntries,
                                 updateSnapshot
                             },
@@ -825,7 +841,8 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 ]
                             };
                         });
-                    })),
+                    }));
+                },
                 close: ()=>pool.close()
             };
         };

package/dist/867.js

@@ -1757,7 +1757,7 @@ export const __webpack_modules__ = {
         var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
-        __webpack_require__("fs");
+        __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("node:module");
         __webpack_require__("pathe");

package/dist/920.js

@@ -0,0 +1,321 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+export const __webpack_ids__ = [
+    "920"
+];
+export const __webpack_modules__ = {
+    "./src/core/runTests.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            runTests: ()=>runTests
+        });
+        var src_pool = __webpack_require__("./src/pool/index.ts");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        const isCliShortcutsEnabled = ()=>(0, utils._l)('stdin');
+        async function setupCliShortcuts({ closeServer, runAll, updateSnapshot, runFailedTests, runWithTestNamePattern, runWithFileFilters }) {
+            const { createInterface, emitKeypressEvents } = await import("node:readline");
+            const rl = createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            emitKeypressEvents(process.stdin);
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            let isPrompting = false;
+            const clearCurrentInputLine = ()=>{
+                try {
+                    process.stdout.write('\r\x1b[2K');
+                } catch  {}
+            };
+            const promptInput = async (promptText, onComplete)=>{
+                if (isPrompting) return;
+                isPrompting = true;
+                let buffer = '';
+                const render = ()=>{
+                    process.stdout.write(`\r\x1b[2K${promptText}${buffer}`);
+                };
+                render();
+                const onPromptKey = async (str, key)=>{
+                    if (!isPrompting) return;
+                    if (key.ctrl && 'c' === key.name) process.exit(0);
+                    if ('return' === key.name || 'enter' === key.name) {
+                        process.stdin.off('keypress', onPromptKey);
+                        process.stdout.write('\n');
+                        const value = '' === buffer.trim() ? void 0 : buffer.trim();
+                        isPrompting = false;
+                        await onComplete(value);
+                        return;
+                    }
+                    if ('escape' === key.name) {
+                        clearCurrentInputLine();
+                        process.stdin.off('keypress', onPromptKey);
+                        isPrompting = false;
+                        return;
+                    }
+                    if ('backspace' === key.name) {
+                        buffer = buffer.slice(0, -1);
+                        render();
+                        return;
+                    }
+                    if ('string' == typeof str && 1 === str.length) {
+                        buffer += str;
+                        render();
+                    }
+                };
+                process.stdin.on('keypress', onPromptKey);
+            };
+            const shortcuts = [
+                {
+                    key: 'f',
+                    description: `${utils.$_.bold('f')}  ${utils.$_.dim('rerun failed tests')}`,
+                    action: async ()=>{
+                        await runFailedTests();
+                    }
+                },
+                {
+                    key: 'a',
+                    description: `${utils.$_.bold('a')}  ${utils.$_.dim('rerun all tests')}`,
+                    action: async ()=>{
+                        await runAll();
+                    }
+                },
+                {
+                    key: 'u',
+                    description: `${utils.$_.bold('u')}  ${utils.$_.dim('update snapshot')}`,
+                    action: async ()=>{
+                        await updateSnapshot();
+                    }
+                },
+                {
+                    key: 't',
+                    description: `${utils.$_.bold('t')}  ${utils.$_.dim('filter by a test name regex pattern')}`,
+                    action: async ()=>{
+                        clearCurrentInputLine();
+                        await promptInput('Enter test name pattern (empty to clear): ', async (pattern)=>{
+                            await runWithTestNamePattern(pattern);
+                        });
+                    }
+                },
+                {
+                    key: 'p',
+                    description: `${utils.$_.bold('p')}  ${utils.$_.dim('filter by a filename regex pattern')}`,
+                    action: async ()=>{
+                        clearCurrentInputLine();
+                        await promptInput('Enter file name pattern (empty to clear): ', async (input)=>{
+                            const filters = input ? input.split(/\s+/).filter(Boolean) : void 0;
+                            await runWithFileFilters(filters);
+                        });
+                    }
+                },
+                {
+                    key: 'c',
+                    description: `${utils.$_.bold('c')}  ${utils.$_.dim('clear console')}`,
+                    action: ()=>{
+                        console.clear();
+                    }
+                },
+                {
+                    key: 'q',
+                    description: `${utils.$_.bold('q')}  ${utils.$_.dim('quit process')}`,
+                    action: async ()=>{
+                        try {
+                            await closeServer();
+                        } finally{
+                            process.exit(0);
+                        }
+                    }
+                }
+            ];
+            const handleKeypress = (str, key)=>{
+                if (isPrompting) return;
+                if (key.ctrl && 'c' === key.name) process.exit(0);
+                for (const shortcut of shortcuts)if (str === shortcut.key) {
+                    clearCurrentInputLine();
+                    shortcut.action();
+                    return;
+                }
+                if ('h' === str) {
+                    clearCurrentInputLine();
+                    let message = `\n  ${utils.$_.bold(utils.$_.blue('Shortcuts:'))}\n`;
+                    for (const shortcut of shortcuts)message += `  ${shortcut.description}\n`;
+                    utils.kg.log(message);
+                }
+            };
+            process.stdin.on('keypress', handleKeypress);
+            return ()=>{
+                try {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                } catch  {}
+                process.stdin.off('keypress', handleKeypress);
+                rl.close();
+            };
+        }
+        var rsbuild = __webpack_require__("./src/core/rsbuild.ts");
+        async function runTests(context) {
+            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath, reporters, snapshotManager, command } = context;
+            const entriesCache = new Map();
+            const globTestSourceEntries = async ()=>{
+                const entries = await (0, utils.GL)({
+                    include,
+                    exclude,
+                    includeSource,
+                    root,
+                    fileFilters: context.fileFilters || []
+                });
+                entriesCache.set(name, {
+                    entries,
+                    fileFilters: context.fileFilters
+                });
+                if (!Object.keys(entries).length) {
+                    utils.kg.log(utils.$_.red('No test files found.'));
+                    utils.kg.log('');
+                    if (context.fileFilters?.length) utils.kg.log(utils.$_.gray('filter: '), context.fileFilters.join(utils.$_.gray(', ')));
+                    utils.kg.log(utils.$_.gray('include:'), include.join(utils.$_.gray(', ')));
+                    utils.kg.log(utils.$_.gray('exclude:'), exclude.join(utils.$_.gray(', ')));
+                    utils.kg.log('');
+                }
+                return entries;
+            };
+            const setupFiles = (0, utils.aA)(setups, rootPath);
+            const rsbuildInstance = await (0, rsbuild.z)(context, globTestSourceEntries, setupFiles);
+            const { getRsbuildStats, closeServer } = await (0, rsbuild.r)({
+                name,
+                normalizedConfig: context.normalizedConfig,
+                globTestSourceEntries: 'watch' === command ? globTestSourceEntries : async ()=>{
+                    if (entriesCache.has(name)) return entriesCache.get(name).entries;
+                    return globTestSourceEntries();
+                },
+                setupFiles,
+                rsbuildInstance,
+                rootPath
+            });
+            const recommendWorkerCount = 'watch' === command ? 1 / 0 : Array.from(entriesCache.values()).reduce((acc, entries)=>acc + Object.keys(entries).length, 0);
+            const pool = await (0, src_pool.K)({
+                context,
+                recommendWorkerCount
+            });
+            let testFileResult = [];
+            let buildHash;
+            const run = async ({ fileFilters } = {})=>{
+                const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap, buildTime, hash } = await getRsbuildStats({
+                    fileFilters
+                });
+                const testStart = Date.now();
+                const { results, testResults } = await pool.runTests({
+                    context,
+                    entries,
+                    sourceMaps,
+                    setupEntries,
+                    assetFiles,
+                    updateSnapshot: snapshotManager.options.updateSnapshot
+                });
+                const actualBuildTime = buildHash === hash ? 0 : buildTime;
+                const testTime = Date.now() - testStart;
+                const duration = {
+                    totalTime: testTime + actualBuildTime,
+                    buildTime: actualBuildTime,
+                    testTime
+                };
+                buildHash = hash;
+                testFileResult = results;
+                if (results.some((r)=>'fail' === r.status)) process.exitCode = 1;
+                for (const reporter of reporters)await reporter.onTestRunEnd?.({
+                    results,
+                    testResults,
+                    snapshotSummary: snapshotManager.summary,
+                    duration,
+                    getSourcemap
+                });
+            };
+            if ('watch' === command) {
+                const enableCliShortcuts = isCliShortcutsEnabled();
+                const afterTestsWatchRun = ()=>{
+                    utils.kg.log(utils.$_.green('  Waiting for file changes...'));
+                    if (enableCliShortcuts) if (snapshotManager.summary.unmatched) utils.kg.log(`  ${utils.$_.dim('press')} ${utils.$_.yellow(utils.$_.bold('u'))} ${utils.$_.dim('to update snapshot')}${utils.$_.dim(', press')} ${utils.$_.bold('h')} ${utils.$_.dim('to show help')}\n`);
+                    else utils.kg.log(`  ${utils.$_.dim('press')} ${utils.$_.bold('h')} ${utils.$_.dim('to show help')}${utils.$_.dim(', press')} ${utils.$_.bold('q')} ${utils.$_.dim('to quit')}\n`);
+                };
+                const clearLogs = ()=>{
+                    console.clear();
+                };
+                const { onBeforeRestart } = await __webpack_require__.e("25").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
+                onBeforeRestart(async ()=>{
+                    await pool.close();
+                    await closeServer();
+                });
+                rsbuildInstance.onDevCompileDone(async ({ isFirstCompile })=>{
+                    if (!isFirstCompile) clearLogs();
+                    snapshotManager.clear();
+                    await run();
+                    if (isFirstCompile && enableCliShortcuts) {
+                        const closeCliShortcuts = await setupCliShortcuts({
+                            closeServer: async ()=>{
+                                await pool.close();
+                                await closeServer();
+                            },
+                            runAll: async ()=>{
+                                clearLogs();
+                                snapshotManager.clear();
+                                context.normalizedConfig.testNamePattern = void 0;
+                                context.fileFilters = void 0;
+                                await run();
+                                afterTestsWatchRun();
+                            },
+                            runWithTestNamePattern: async (pattern)=>{
+                                clearLogs();
+                                context.normalizedConfig.testNamePattern = pattern;
+                                if (pattern) utils.kg.log(`\n${utils.$_.dim('Applied testNamePattern:')} ${utils.$_.bold(pattern)}\n`);
+                                else utils.kg.log(`\n${utils.$_.dim('Cleared testNamePattern filter')}\n`);
+                                snapshotManager.clear();
+                                await run();
+                                afterTestsWatchRun();
+                            },
+                            runWithFileFilters: async (filters)=>{
+                                clearLogs();
+                                if (filters && filters.length > 0) utils.kg.log(`\n${utils.$_.dim('Applied file filters:')} ${utils.$_.bold(filters.join(', '))}\n`);
+                                else utils.kg.log(`\n${utils.$_.dim('Cleared file filters')}\n`);
+                                snapshotManager.clear();
+                                context.fileFilters = filters;
+                                const entries = await globTestSourceEntries();
+                                if (!Object.keys(entries).length) return;
+                                await run({
+                                    fileFilters: Object.values(entries)
+                                });
+                                afterTestsWatchRun();
+                            },
+                            runFailedTests: async ()=>{
+                                const failedTests = testFileResult.filter((result)=>'fail' === result.status).map((r)=>r.testPath);
+                                if (!failedTests.length) return void utils.kg.log(utils.$_.yellow('\nNo failed tests were found that needed to be rerun.'));
+                                clearLogs();
+                                snapshotManager.clear();
+                                await run({
+                                    fileFilters: failedTests
+                                });
+                                afterTestsWatchRun();
+                            },
+                            updateSnapshot: async ()=>{
+                                if (!snapshotManager.summary.unmatched) return void utils.kg.log(utils.$_.yellow('\nNo snapshots were found that needed to be updated.'));
+                                const failedTests = testFileResult.filter((result)=>result.snapshotResult?.unmatched).map((r)=>r.testPath);
+                                clearLogs();
+                                const originalUpdateSnapshot = snapshotManager.options.updateSnapshot;
+                                snapshotManager.clear();
+                                snapshotManager.options.updateSnapshot = 'all';
+                                await run({
+                                    fileFilters: failedTests
+                                });
+                                afterTestsWatchRun();
+                                snapshotManager.options.updateSnapshot = originalUpdateSnapshot;
+                            }
+                        });
+                        onBeforeRestart(closeCliShortcuts);
+                    }
+                    afterTestsWatchRun();
+                });
+            } else {
+                await run();
+                await pool.close();
+                await closeServer();
+            }
+        }
+    }
+};