@rstest/core 0.7.1 → 0.7.3

package/dist/0~923.js

@@ -1,10 +1,10 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
-import { posix, src_logger } from "./946.js";
-import { pathToFileURL } from "./770.js";
+import { posix, logger_logger } from "./946.js";
+import { pathToFileURL } from "./404.js";
 import { node_vm, interopModule, shouldInterop } from "./0~346.js";
-const external_node_path_ = __webpack_require__("node:path");
+const external_node_path_ = __webpack_require__("path");
 var loadEsModule_EsmMode = /*#__PURE__*/ function(EsmMode) {
     EsmMode[EsmMode["Unknown"] = 0] = "Unknown";
     EsmMode[EsmMode["Evaluated"] = 1] = "Evaluated";
@@ -27,7 +27,7 @@ const defineRstestDynamicImport = ({ distPath, testPath, assetFiles, interopDefa
                 esmMode
             });
         } catch (err) {
-            src_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
+            logger_logger.error(`load file ${joinedPath} failed:\n`, err instanceof Error ? err.message : err);
         }
         const resolvedPath = (0, external_node_path_.isAbsolute)(specifier) ? pathToFileURL(specifier) : import.meta.resolve(specifier, pathToFileURL(testPath));
         const modulePath = 'string' == typeof resolvedPath ? resolvedPath : resolvedPath.pathname;

package/dist/{155.js → 131.js}

@@ -2,8 +2,9 @@ import 'module';
 /*#__PURE__*/ import.meta.url;
 import { __webpack_require__ } from "./rslib-runtime.js";
 import { EventEmitter } from "events";
-import { createRsbuild, loadConfig, logger, mergeRsbuildConfig } from "@rsbuild/core";
-import { basename, DEFAULT_CONFIG_EXTENSIONS, TS_CONFIG_FILE, isTTY, dirname, posix, resolve as pathe_M_eThtNZ_resolve, pathe_M_eThtNZ_relative, DEFAULT_CONFIG_NAME, globalApis, formatTestPath, getAbsolutePath, filterProjects, join, formatRootStr, isDynamicPattern, glob, writeFile, castArray, src_logger, prettyTestPath, prettyTime, isDebug, isAbsolute, getTaskNameWithPrefix, formatError, normalize, TEMP_RSTEST_OUTPUT_DIR_GLOB } from "./946.js";
+import { createRsbuild, loadConfig, logger as core_logger, mergeRsbuildConfig } from "@rsbuild/core";
+import { DEFAULT_CONFIG_NAME, posix, globalApis, resolve as pathe_M_eThtNZ_resolve, pathe_M_eThtNZ_relative, filterProjects, join, glob, prettyTestPath, prettyTime, isAbsolute, TEMP_RSTEST_OUTPUT_DIR_GLOB, formatTestPath, TS_CONFIG_FILE, basename, logger_logger, dirname, isTTY, getAbsolutePath, bgColor, formatRootStr, isDynamicPattern, writeFile, castArray, isDebug, getTaskNameWithPrefix, DEFAULT_CONFIG_EXTENSIONS, formatError, normalize } from "./946.js";
+import { parse as stack_trace_parser_esm_parse } from "./672.js";
 import { decode } from "./397.js";
 function toArr(any) {
     return null == any ? [] : Array.isArray(any) ? any : [
@@ -497,16 +498,16 @@ function prepareCli() {
     initNodeEnv();
     process.env.RSTEST = 'true';
     const { npm_execpath } = process.env;
-    if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
+    if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) logger_logger.log();
 }
 function showRstest() {
-    src_logger.greet("  Rstest v0.7.1");
-    src_logger.log('');
+    logger_logger.greet("  Rstest v0.7.3");
+    logger_logger.log('');
 }
 const applyCommonOptions = (cli)=>{
     cli.option('-c, --config <config>', 'Specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'Specify the loader to load the config file, can be `jiti` or `native`', {
         default: 'jiti'
-    }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('--isolate', 'Run tests in an isolated environment').option('--include <include>', 'Match test files').option('--exclude <exclude>', 'Exclude files from test').option('-u, --update', 'Update snapshot files').option('--coverage', 'Enable code coverage collection').option('--project <name>', 'Run only projects that match the name, can be a full name or wildcards pattern').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--logHeapUsage', 'Log heap usage after each test').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('--reporter <reporter>', 'Specify the reporter to use').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--hookTimeout <value>', 'Timeout of hook in milliseconds').option('--hideSkippedTests', 'Hide skipped tests from the output').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--bail [number]', 'Stop running tests after n failures. Set to 0 to run all tests regardless of failures').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test');
+    }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('--isolate', 'Run tests in an isolated environment').option('--include <include>', 'Match test files').option('--exclude <exclude>', 'Exclude files from test').option('-u, --update', 'Update snapshot files').option('--coverage', 'Enable code coverage collection').option('--project <name>', 'Run only projects that match the name, can be a full name or wildcards pattern').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--logHeapUsage', 'Log heap usage after each test').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('--reporter <reporter>', 'Specify the reporter to use').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--hookTimeout <value>', 'Timeout of hook in milliseconds').option('--hideSkippedTests', 'Hide skipped tests from the output').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--bail [number]', 'Stop running tests after n failures. Set to 0 to run all tests regardless of failures').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test').option('--includeTaskLocation', 'Collect test and suite locations. This might increase the running time.');
 };
 const runRest = async ({ options, filters, command })=>{
     let rstest;
@@ -536,15 +537,15 @@ const runRest = async ({ options, filters, command })=>{
         await rstest.runTests();
     } catch (err) {
         for (const reporter of rstest?.context.reporters || [])reporter.onExit?.();
-        src_logger.error('Failed to run Rstest.');
-        src_logger.error(formatError(err));
+        logger_logger.error('Failed to run Rstest.');
+        logger_logger.error(formatError(err));
         process.exit(1);
     }
 };
 function setupCommands() {
     const cli = dist('rstest');
     cli.help();
-    cli.version("0.7.1");
+    cli.version("0.7.3");
     applyCommonOptions(cli);
     cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
         showRstest();
@@ -575,12 +576,13 @@ function setupCommands() {
             command: 'watch'
         });
     });
-    cli.command('list [...filters]', 'lists all test files that Rstest will run').option('--filesOnly', 'only list the test files').option('--json [boolean/path]', 'print tests as JSON or write to a file').action(async (filters, options)=>{
+    cli.command('list [...filters]', 'lists all test files that Rstest will run').option('--filesOnly', 'only list the test files').option('--json [boolean/path]', 'print tests as JSON or write to a file').option('--includeSuites', 'include suites in output').option('--printLocation', 'print test case location').action(async (filters, options)=>{
         try {
             const { initCli } = await Promise.resolve().then(()=>({
                     initCli: init_initCli
                 }));
             const { config, configFilePath, projects } = await initCli(options);
+            if (options.printLocation) config.includeTaskLocation = true;
             const { createRstest } = await Promise.resolve().then(()=>({
                     createRstest: core_createRstest
                 }));
@@ -591,11 +593,13 @@ function setupCommands() {
             }, 'list', filters.map(normalize));
             await rstest.listTests({
                 filesOnly: options.filesOnly,
-                json: options.json
+                json: options.json,
+                includeSuites: options.includeSuites,
+                printLocation: options.printLocation
             });
         } catch (err) {
-            src_logger.error('Failed to run Rstest list.');
-            src_logger.error(formatError(err));
+            logger_logger.error('Failed to run Rstest list.');
+            logger_logger.error(formatError(err));
             process.exit(1);
         }
     });
@@ -618,7 +622,7 @@ const resolveConfigPath = (root, customConfig)=>{
 async function config_loadConfig({ cwd = process.cwd(), path, envMode, configLoader }) {
     const configFilePath = resolveConfigPath(cwd, path);
     if (!configFilePath) {
-        src_logger.debug('no rstest config file found');
+        logger_logger.debug('no rstest config file found');
         return {
             content: {},
             filePath: configFilePath
@@ -698,6 +702,7 @@ const createDefaultConfig = ()=>({
         hideSkippedTests: false,
         logHeapUsage: false,
         bail: 0,
+        includeTaskLocation: false,
         coverage: {
             exclude: [
                 '**/node_modules/**',
@@ -909,8 +914,8 @@ async function runCLI() {
     try {
         setupCommands();
     } catch (err) {
-        src_logger.error('Failed to start Rstest CLI.');
-        src_logger.error(err);
+        logger_logger.error('Failed to start Rstest CLI.');
+        logger_logger.error(err);
     }
 }
 class SnapshotManager {
@@ -1293,94 +1298,6 @@ function G() {
 }
 const P = G();
 P?.name;
-var UNKNOWN_FUNCTION = '<unknown>';
-function stack_trace_parser_esm_parse(stackString) {
-    var lines = stackString.split('\n');
-    return lines.reduce(function(stack, line) {
-        var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);
-        if (parseResult) stack.push(parseResult);
-        return stack;
-    }, []);
-}
-var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
-var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
-function parseChrome(line) {
-    var parts = chromeRe.exec(line);
-    if (!parts) return null;
-    var isNative = parts[2] && 0 === parts[2].indexOf('native');
-    var isEval = parts[2] && 0 === parts[2].indexOf('eval');
-    var submatch = chromeEvalRe.exec(parts[2]);
-    if (isEval && null != submatch) {
-        parts[2] = submatch[1];
-        parts[3] = submatch[2];
-        parts[4] = submatch[3];
-    }
-    return {
-        file: isNative ? null : parts[2],
-        methodName: parts[1] || UNKNOWN_FUNCTION,
-        arguments: isNative ? [
-            parts[2]
-        ] : [],
-        lineNumber: parts[3] ? +parts[3] : null,
-        column: parts[4] ? +parts[4] : null
-    };
-}
-var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-function parseWinjs(line) {
-    var parts = winjsRe.exec(line);
-    if (!parts) return null;
-    return {
-        file: parts[2],
-        methodName: parts[1] || UNKNOWN_FUNCTION,
-        arguments: [],
-        lineNumber: +parts[3],
-        column: parts[4] ? +parts[4] : null
-    };
-}
-var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
-var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
-function parseGecko(line) {
-    var parts = geckoRe.exec(line);
-    if (!parts) return null;
-    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
-    var submatch = geckoEvalRe.exec(parts[3]);
-    if (isEval && null != submatch) {
-        parts[3] = submatch[1];
-        parts[4] = submatch[2];
-        parts[5] = null;
-    }
-    return {
-        file: parts[3],
-        methodName: parts[1] || UNKNOWN_FUNCTION,
-        arguments: parts[2] ? parts[2].split(',') : [],
-        lineNumber: parts[4] ? +parts[4] : null,
-        column: parts[5] ? +parts[5] : null
-    };
-}
-var javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
-function parseJSC(line) {
-    var parts = javaScriptCoreRe.exec(line);
-    if (!parts) return null;
-    return {
-        file: parts[3],
-        methodName: parts[1] || UNKNOWN_FUNCTION,
-        arguments: [],
-        lineNumber: +parts[4],
-        column: parts[5] ? +parts[5] : null
-    };
-}
-var nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-function parseNode(line) {
-    var parts = nodeRe.exec(line);
-    if (!parts) return null;
-    return {
-        file: parts[2],
-        methodName: parts[1] || UNKNOWN_FUNCTION,
-        arguments: [],
-        lineNumber: +parts[3],
-        column: parts[4] ? +parts[4] : null
-    };
-}
 const getSummaryStatusString = (tasks, name = 'tests', showTotal = true)=>{
     if (0 === tasks.length) return picocolors_default().dim(`no ${name}`);
     const passed = tasks.filter((result)=>'pass' === result.status);
@@ -1417,19 +1334,19 @@ const printSnapshotSummaryLog = (snapshots, rootDir)=>{
     }
     for (const [index, snapshot] of summary.entries()){
         const title = 0 === index ? 'Snapshots' : '';
-        src_logger.log(`${picocolors_default().gray(title.padStart(12))} ${snapshot}`);
+        logger_logger.log(`${picocolors_default().gray(title.padStart(12))} ${snapshot}`);
     }
 };
 const TestFileSummaryLabel = picocolors_default().gray('Test Files'.padStart(11));
 const TestSummaryLabel = picocolors_default().gray('Tests'.padStart(11));
 const DurationLabel = picocolors_default().gray('Duration'.padStart(11));
 const printSummaryLog = ({ results, testResults, snapshotSummary, duration, rootPath })=>{
-    src_logger.log('');
+    logger_logger.log('');
     printSnapshotSummaryLog(snapshotSummary, rootPath);
-    src_logger.log(`${TestFileSummaryLabel} ${getSummaryStatusString(results)}`);
-    src_logger.log(`${TestSummaryLabel} ${getSummaryStatusString(testResults)}`);
-    src_logger.log(`${DurationLabel} ${prettyTime(duration.totalTime)} ${picocolors_default().gray(`(build ${prettyTime(duration.buildTime)}, tests ${prettyTime(duration.testTime)})`)}`);
-    src_logger.log('');
+    logger_logger.log(`${TestFileSummaryLabel} ${getSummaryStatusString(results)}`);
+    logger_logger.log(`${TestSummaryLabel} ${getSummaryStatusString(testResults)}`);
+    logger_logger.log(`${DurationLabel} ${prettyTime(duration.totalTime)} ${picocolors_default().gray(`(build ${prettyTime(duration.buildTime)}, tests ${prettyTime(duration.testTime)})`)}`);
+    logger_logger.log('');
 };
 const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap, filterRerunTestPaths })=>{
     const failedTests = [
@@ -1437,13 +1354,13 @@ const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSource
         ...testResults.filter((i)=>'fail' === i.status && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true))
     ];
     if (0 === failedTests.length) return;
-    src_logger.log('');
-    src_logger.log(picocolors_default().bold('Summary of all failing tests:'));
-    src_logger.log('');
+    logger_logger.stderr('');
+    logger_logger.stderr(picocolors_default().bold('Summary of all failing tests:'));
+    logger_logger.stderr('');
     for (const test of failedTests){
         const relativePath = posix.relative(rootPath, test.testPath);
         const nameStr = getTaskNameWithPrefix(test);
-        src_logger.log(`${picocolors_default().bgRed(' FAIL ')} ${prettyTestPath(relativePath)} ${nameStr.length ? `${picocolors_default().dim(">")} ${nameStr}` : ''}`);
+        logger_logger.stderr(`${bgColor('bgRed', ' FAIL ')} ${prettyTestPath(relativePath)} ${nameStr.length ? `${picocolors_default().dim(">")} ${nameStr}` : ''}`);
         if (test.errors) {
             const { printError } = await Promise.resolve().then(()=>({
                     printError: error_printError
@@ -1575,11 +1492,11 @@ class StatusRenderer {
     renderer;
     startTime = void 0;
     testState;
-    constructor(rootPath, state){
+    constructor(rootPath, state, logger){
         this.rootPath = rootPath;
         this.renderer = new WindowRenderer({
             getWindow: ()=>this.getContent(),
-            logger: {
+            logger: logger ?? {
                 outputStream: process.stdout,
                 errorStream: process.stderr,
                 getColumns: ()=>'columns' in process.stdout ? process.stdout.columns : 80
@@ -1596,7 +1513,7 @@ class StatusRenderer {
         const shouldDisplayRunningTests = (runningTests)=>runningTests[0]?.startTime && now - runningTests[0].startTime > 2000;
         for (const [module, { runningTests }] of runningModules.entries()){
             const relativePath = pathe_M_eThtNZ_relative(this.rootPath, module);
-            summary.push(`${picocolors_default().bgYellow(picocolors_default().bold(' RUNS '))} ${prettyTestPath(relativePath)}`);
+            summary.push(`${bgColor('bgYellow', ' RUNS ')} ${prettyTestPath(relativePath)}`);
             if (runningTests.length && shouldDisplayRunningTests(runningTests)) {
                 let caseLog = ` ${picocolors_default().gray("➜")} ${getTaskNameWithPrefix(runningTests[0])} ${picocolors_default().magenta(prettyTime(now - runningTests[0].startTime))}`;
                 if (runningTests.length > 1) caseLog += picocolors_default().gray(` and ${runningTests.length - 1} more cases`);
@@ -1646,8 +1563,8 @@ const logCase = (result, options)=>{
     const duration = void 0 !== result.duration ? ` (${prettyTime(result.duration)})` : '';
     const retry = result.retryCount ? picocolors_default().yellow(` (retry x${result.retryCount})`) : '';
     const heap = result.heap ? ` ${picocolors_default().magenta(formatHeapUsed(result.heap))}` : '';
-    src_logger.log(`  ${icon} ${nameStr}${picocolors_default().gray(duration)}${retry}${heap}`);
-    if (result.errors) for (const error of result.errors)console.error(picocolors_default().red(`    ${error.message}`));
+    logger_logger.log(`  ${icon} ${nameStr}${picocolors_default().gray(duration)}${retry}${heap}`);
+    if (result.errors) for (const error of result.errors)logger_logger.log(picocolors_default().red(`    ${error.message}`));
 };
 const formatHeapUsed = (heap)=>`${Math.floor(heap / 1024 / 1024)} MB heap used`;
 const logFileTitle = (test, relativePath, alwaysShowTime = false)=>{
@@ -1656,7 +1573,7 @@ const logFileTitle = (test, relativePath, alwaysShowTime = false)=>{
     title += ` ${picocolors_default().gray(`(${test.results.length})`)}`;
     if (alwaysShowTime) title += ` ${formatDuration(test.duration)}`;
     if (test.heap) title += ` ${picocolors_default().magenta(formatHeapUsed(test.heap))}`;
-    src_logger.log(title);
+    logger_logger.log(title);
 };
 class DefaultReporter {
     rootPath;
@@ -1667,7 +1584,7 @@ class DefaultReporter {
         this.rootPath = rootPath;
         this.config = config;
         this.options = options;
-        if (isTTY()) this.statusRenderer = new StatusRenderer(rootPath, testState);
+        if (isTTY() || options.logger) this.statusRenderer = new StatusRenderer(rootPath, testState, options.logger);
     }
     onTestFileStart() {
         this.statusRenderer?.onTestFileStart();
@@ -1699,10 +1616,11 @@ class DefaultReporter {
             if (filePath !== testPath) titles.push(testPath);
             titles.push(`${filePath}:${frame.lineNumber}:${frame.column}`);
         } else titles.push(testPath);
-        src_logger.log('');
-        src_logger.log(`${log.name}${picocolors_default().gray(picocolors_default().dim(` | ${titles.join(picocolors_default().gray(picocolors_default().dim(' | ')))}`))}`);
-        src_logger.log(log.content);
-        src_logger.log('');
+        const logOutput = 'stdout' === log.type ? logger_logger.log : logger_logger.stderr;
+        logOutput('');
+        logOutput(`${log.name}${picocolors_default().gray(picocolors_default().dim(` | ${titles.join(picocolors_default().gray(picocolors_default().dim(' | ')))}`))}`);
+        logOutput(log.content);
+        logOutput('');
     }
     async onExit() {
         this.statusRenderer?.clear();
@@ -1734,7 +1652,7 @@ class GithubActionsReporter {
         this.rootPath = rootPath;
     }
     log(message) {
-        console.log(`${message}\n`);
+        logger_logger.log(`${message}\n`);
     }
     async onTestRunEnd({ results, testResults, getSourcemap }) {
         const failedTests = [
@@ -2115,14 +2033,14 @@ async function error_printError(error, getSourcemap, rootPath) {
             `  - Update your code to use imports from "${picocolors_default().yellow('@rstest/core')}" instead of "${picocolors_default().yellow('vitest')}".`,
             '  - Enable `globals` configuration and use global API.'
         ];
-        src_logger.log(`${picocolors_default().red(tips.join('\n'))}\n`);
+        logger_logger.stderr(`${picocolors_default().red(tips.join('\n'))}\n`);
         return;
     }
     if (error.message.includes('is not defined')) error.message = hintNotDefinedError(error.message);
-    src_logger.log(`${picocolors_default().red(picocolors_default().bold(errorName))}${picocolors_default().red(`: ${error.message}`)}\n`);
+    logger_logger.stderr(`${picocolors_default().red(picocolors_default().bold(errorName))}${picocolors_default().red(`: ${error.message}`)}\n`);
     if (error.diff) {
-        src_logger.log(error.diff);
-        src_logger.log();
+        logger_logger.stderr(error.diff);
+        logger_logger.stderr('');
     }
     if (error.stack) {
         const stackFrames = await error_parseErrorStacktrace({
@@ -2130,7 +2048,7 @@ async function error_printError(error, getSourcemap, rootPath) {
             fullStack: error.fullStack,
             getSourcemap
         });
-        if (!stackFrames.length && !(error.fullStack || isDebug()) && !error.stack.endsWith(error.message)) src_logger.log(picocolors_default().gray("No error stack found, set 'DEBUG=rstest' to show fullStack."));
+        if (!stackFrames.length && !(error.fullStack || isDebug()) && !error.stack.endsWith(error.message)) logger_logger.stderr(picocolors_default().gray("No error stack found, set 'DEBUG=rstest' to show fullStack."));
         if (stackFrames[0]) await printCodeFrame(stackFrames[0]);
         printStack(stackFrames, rootPath);
     }
@@ -2150,15 +2068,15 @@ async function printCodeFrame(frame) {
         highlightCode: true,
         linesBelow: 2
     });
-    src_logger.log(result);
-    src_logger.log('');
+    logger_logger.stderr(result);
+    logger_logger.stderr('');
 }
 function formatStack(frame, rootPath) {
     return '<unknown>' !== frame.methodName ? `at ${frame.methodName} (${formatTestPath(rootPath, frame.file)}:${frame.lineNumber}:${frame.column})` : `at ${formatTestPath(rootPath, frame.file)}:${frame.lineNumber}:${frame.column}`;
 }
 function printStack(stackFrames, rootPath) {
-    for (const frame of stackFrames)src_logger.log(picocolors_default().gray(`        ${formatStack(frame, rootPath)}`));
-    stackFrames.length && src_logger.log();
+    for (const frame of stackFrames)logger_logger.stderr(picocolors_default().gray(`        ${formatStack(frame, rootPath)}`));
+    stackFrames.length && logger_logger.stderr('');
 }
 const stackIgnores = [
     /\/@rstest\/core/,
@@ -2175,7 +2093,7 @@ const stackIgnores = [
 ];
 async function error_parseErrorStacktrace({ stack, getSourcemap, fullStack = isDebug() }) {
     const stackFrames = await Promise.all(stack_trace_parser_esm_parse(stack).filter((frame)=>fullStack ? true : frame.file && !stackIgnores.some((entry)=>frame.file?.match(entry))).map(async (frame)=>{
-        const sourcemap = await getSourcemap(frame.file);
+        const sourcemap = await getSourcemap?.(frame.file);
         if (sourcemap) {
             const traceMap = new TraceMap(sourcemap);
             const { line, column, source, name } = originalPositionFor(traceMap, {
@@ -2305,13 +2223,13 @@ class JUnitReporter {
         const xmlContent = this.generateJUnitXml(report);
         if (this.outputPath) try {
             await writeFile(this.outputPath, xmlContent, 'utf-8');
-            console.log(`JUnit XML report written to: ${this.outputPath}`);
+            logger_logger.log(`JUnit XML report written to: ${this.outputPath}`);
         } catch (error) {
-            console.error(`Failed to write JUnit XML report to ${this.outputPath}:`, error);
-            console.log('JUnit XML Report:');
-            console.log(xmlContent);
+            logger_logger.stderr(`Failed to write JUnit XML report to ${this.outputPath}:`, error);
+            logger_logger.log('JUnit XML Report:');
+            logger_logger.log(xmlContent);
         }
-        else console.log(xmlContent);
+        else logger_logger.log(xmlContent);
     }
 }
 class VerboseReporter extends DefaultReporter {
@@ -2428,7 +2346,7 @@ class Rstest {
         });
         this.reporters = reporters;
         this.snapshotManager = snapshotManager;
-        this.version = "0.7.1";
+        this.version = "0.7.3";
         this.rootPath = rootPath;
         this.originalConfig = userConfig;
         this.normalizedConfig = rstestConfig;
@@ -2523,7 +2441,7 @@ function core_createRstest({ config, projects, configFilePath }, command, fileFi
         const { listTests } = await import("./0~634.js").then((mod)=>({
                 listTests: mod.listTests
             }));
-        await listTests(context, options);
+        return listTests(context, options);
     };
     return {
         context,
@@ -2571,4 +2489,4 @@ function defineConfig(config) {
 function defineProject(config) {
     return config;
 }
-export { EventEmitter, afterAll, afterEach, assert, beforeAll, beforeEach, config_loadConfig as loadConfig, core_createRstest as createRstest, createRsbuild, defineConfig, defineProject, describe, error_printError, expect, init_initCli as initCli, it, logger, mergeRstestConfig, onTestFailed, onTestFinished, public_rstest as rstest, public_test as test, rs, runCLI, runRest };
+export { EventEmitter, afterAll, afterEach, assert, beforeAll, beforeEach, config_loadConfig as loadConfig, core_createRstest as createRstest, core_logger, createRsbuild, defineConfig, defineProject, describe, error_printError, expect, init_initCli as initCli, it, mergeRstestConfig, onTestFailed, onTestFinished, public_rstest as rstest, public_test as test, rs, runCLI, runRest };

package/dist/404.js

@@ -0,0 +1,210 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { fileURLToPath, pathToFileURL } from "node:url";
+import node_v8 from "node:v8";
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+    return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+    let $closed = false;
+    const _rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promiseInit;
+    let rpc;
+    async function _call(method, args, event, optional) {
+        if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        const req = {
+            m: method,
+            a: args,
+            t: TYPE_REQUEST
+        };
+        if (optional) req.o = true;
+        const send = async (_req)=>post(serialize(_req));
+        if (event) return void await send(req);
+        if (_promiseInit) try {
+            await _promiseInit;
+        } finally{
+            _promiseInit = void 0;
+        }
+        let { promise, resolve, reject } = createPromiseWithResolvers();
+        const id = nanoid();
+        req.i = id;
+        let timeoutId;
+        async function handler(newReq = req) {
+            if (timeout >= 0) {
+                timeoutId = dist_setTimeout(()=>{
+                    try {
+                        const handleResult = options.onTimeoutError?.call(rpc, method, args);
+                        if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                    } catch (e) {
+                        reject(e);
+                    }
+                    _rpcPromiseMap.delete(id);
+                }, timeout);
+                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+            }
+            _rpcPromiseMap.set(id, {
+                resolve,
+                reject,
+                timeoutId,
+                method
+            });
+            await send(newReq);
+            return promise;
+        }
+        try {
+            if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+            else await handler();
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        } finally{
+            dist_clearTimeout(timeoutId);
+            _rpcPromiseMap.delete(id);
+        }
+        return promise;
+    }
+    const $call = (method, ...args)=>_call(method, args, false);
+    const $callOptional = (method, ...args)=>_call(method, args, false, true);
+    const $callEvent = (method, ...args)=>_call(method, args, true);
+    const $callRaw = (options2)=>_call(options2.method, options2.args, options2.event, options2.optional);
+    const builtinMethods = {
+        $call,
+        $callOptional,
+        $callEvent,
+        $callRaw,
+        $rejectPendingCalls,
+        get $closed () {
+            return $closed;
+        },
+        get $meta () {
+            return options.meta;
+        },
+        $close,
+        $functions
+    };
+    rpc = new Proxy({}, {
+        get (_, method) {
+            if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+            if ("then" === method && !eventNames.includes("then") && !("then" in $functions)) return;
+            const sendEvent = (...args)=>_call(method, args, true);
+            if (eventNames.includes(method)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = (...args)=>_call(method, args, false);
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    });
+    function $close(customError) {
+        $closed = true;
+        _rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        _rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function $rejectPendingCalls(handler) {
+        const entries = Array.from(_rpcPromiseMap.values());
+        const handlerResults = entries.map(({ method, reject })=>{
+            if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        _rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        }
+        if (msg.t === TYPE_REQUEST) {
+            const { m: method, a: args, o: optional } = msg;
+            let result, error;
+            let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+            if (optional) fn ||= ()=>void 0;
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : $functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onError) options.onError.call(rpc, error, method, args);
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError.call(rpc, error, method, args)) return;
+                }
+                if (!error) try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+                try {
+                    await post(serialize({
+                        t: TYPE_RESPONSE,
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = _rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            _rpcPromiseMap.delete(ack);
+        }
+    }
+    _promiseInit = on(onMessage);
+    return rpc;
+}
+function createPromiseWithResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
+export { createBirpc, fileURLToPath, node_v8, pathToFileURL };