@rstest/core 0.5.1 → 0.5.2

package/dist/index.js

@@ -7,10 +7,11 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/
 import * as __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__ from "node:module";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
-import * as __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__ from "node:tty";
 import * as __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__ from "node:process";
+import * as __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__ from "node:tty";
 import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
 import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
+import * as __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__ from "node:util";
 var __webpack_modules__ = {
     "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js": function(module) {
         let p = process || {}, argv = p.argv || [], env = p.env || {};
@@ -1484,6 +1485,99 @@ var __webpack_modules__ = {
             return last;
         };
     },
+    "../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            q: ()=>parse
+        });
+        var UNKNOWN_FUNCTION = '<unknown>';
+        function 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
+            };
+        }
+    },
     "./src/cli/commands.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             a: ()=>runRest,
@@ -1987,12 +2081,9 @@ ${section.body}` : section.body).join("\n\n"));
         const runRest = async ({ options, filters, command })=>{
             let rstest;
             try {
-                const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
+                const { initCli } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
                 const { config, configFilePath, projects } = await initCli(options);
-                const { createRstest } = await Promise.all([
-                    __webpack_require__.e("908"),
-                    __webpack_require__.e("876")
-                ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+                const { createRstest } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                 rstest = createRstest({
                     config,
                     configFilePath,
@@ -2017,7 +2108,7 @@ ${section.body}` : section.body).join("\n\n"));
         function setupCommands() {
             const cli = dist('rstest');
             cli.help();
-            cli.version("0.5.1");
+            cli.version("0.5.2");
             applyCommonOptions(cli);
             cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
                 (0, prepare.N)();
@@ -2050,12 +2141,9 @@ ${section.body}` : section.body).join("\n\n"));
             });
             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)=>{
                 try {
-                    const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
+                    const { initCli } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
                     const { config, configFilePath, projects } = await initCli(options);
-                    const { createRstest } = await Promise.all([
-                        __webpack_require__.e("908"),
-                        __webpack_require__.e("876")
-                    ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+                    const { createRstest } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                     const rstest = createRstest({
                         config,
                         configFilePath,
@@ -2074,6 +2162,175 @@ ${section.body}` : section.body).join("\n\n"));
             cli.parse();
         }
     },
+    "./src/cli/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            G: ()=>runCLI,
+            X: ()=>_init__WEBPACK_IMPORTED_MODULE_3__.initCli
+        });
+        var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/utils/logger.ts");
+        var _commands__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/cli/commands.ts");
+        var _prepare__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/cli/prepare.ts");
+        var _init__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/cli/init.ts");
+        async function runCLI() {
+            (0, _prepare__WEBPACK_IMPORTED_MODULE_2__.k)();
+            try {
+                (0, _commands__WEBPACK_IMPORTED_MODULE_1__.Q)();
+            } catch (err) {
+                _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.error('Failed to start Rstest CLI.');
+                _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.error(err);
+            }
+        }
+    },
+    "./src/cli/init.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            initCli: ()=>initCli
+        });
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+        var dist = __webpack_require__("../../node_modules/.pnpm/tinyglobby@0.2.15/node_modules/tinyglobby/dist/index.mjs");
+        var src_config = __webpack_require__("./src/config.ts");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        async function resolveConfig(options) {
+            const { content: config, filePath: configFilePath } = await (0, src_config.Z9)({
+                cwd: options.root,
+                path: options.config,
+                configLoader: options.configLoader
+            });
+            const keys = [
+                'root',
+                'globals',
+                'isolate',
+                'passWithNoTests',
+                'update',
+                'testNamePattern',
+                'testTimeout',
+                'hookTimeout',
+                'clearMocks',
+                'resetMocks',
+                'restoreMocks',
+                'unstubEnvs',
+                'unstubGlobals',
+                'retry',
+                'slowTestThreshold',
+                'maxConcurrency',
+                'printConsoleTrace',
+                'disableConsoleIntercept',
+                'testEnvironment'
+            ];
+            for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
+            if (options.reporter) config.reporters = (0, utils.bg)(options.reporter);
+            if (void 0 !== options.coverage) {
+                config.coverage ??= {};
+                config.coverage.enabled = options.coverage;
+            }
+            if (options.exclude) config.exclude = (0, utils.bg)(options.exclude);
+            if (options.include) config.include = (0, utils.bg)(options.include);
+            return {
+                config,
+                configFilePath: configFilePath ?? void 0
+            };
+        }
+        async function resolveProjects({ config, root, options }) {
+            if (!config.projects) return [];
+            const getDefaultProjectName = (dir)=>{
+                const pkgJsonPath = (0, pathe_M_eThtNZ.r)(dir, 'package.json');
+                const name = (0, external_node_fs_.existsSync)(pkgJsonPath) ? JSON.parse((0, external_node_fs_.readFileSync)(pkgJsonPath, 'utf-8')).name : '';
+                if ('string' != typeof name || !name) return (0, pathe_M_eThtNZ.c)(dir);
+                return name;
+            };
+            const globProjects = async (patterns)=>{
+                const globOptions = {
+                    absolute: true,
+                    dot: true,
+                    onlyFiles: false,
+                    cwd: root,
+                    expandDirectories: false,
+                    ignore: [
+                        '**/node_modules/**',
+                        '**/.DS_Store'
+                    ]
+                };
+                return (0, dist.glob)(patterns, globOptions);
+            };
+            const { projectPaths, projectPatterns, projectConfigs } = (config.projects || []).reduce((total, p)=>{
+                if ('object' == typeof p) {
+                    const projectRoot = p.root ? (0, utils.tS)(p.root, root) : root;
+                    total.projectConfigs.push({
+                        config: {
+                            root: projectRoot,
+                            name: p.name ? p.name : getDefaultProjectName(projectRoot),
+                            ...p
+                        },
+                        configFilePath: void 0
+                    });
+                    return total;
+                }
+                const projectStr = (0, utils.tS)(p, root);
+                if ((0, dist.ey)(projectStr)) total.projectPatterns.push(projectStr);
+                else {
+                    const absolutePath = (0, utils.FI)(root, projectStr);
+                    if (!(0, external_node_fs_.existsSync)(absolutePath)) throw `Can't resolve project "${p}", please make sure "${p}" is a existing file or a directory.`;
+                    total.projectPaths.push(absolutePath);
+                }
+                return total;
+            }, {
+                projectPaths: [],
+                projectPatterns: [],
+                projectConfigs: []
+            });
+            projectPaths.push(...await globProjects(projectPatterns));
+            const projects = await Promise.all(projectPaths.map(async (project)=>{
+                const isDirectory = (0, external_node_fs_.statSync)(project).isDirectory();
+                const { config, configFilePath } = await resolveConfig({
+                    ...options,
+                    config: isDirectory ? void 0 : project,
+                    root: isDirectory ? project : (0, pathe_M_eThtNZ.d)(project)
+                });
+                config.name ??= getDefaultProjectName(project);
+                if (config.projects?.length && config.root !== root) utils.vF.warn(`Projects cannot have nested projects, the "projects" field in project "${config.name}" will be ignored.`);
+                return {
+                    config,
+                    configFilePath
+                };
+            })).then((projects)=>(0, utils.zz)(projects.concat(projectConfigs), options));
+            if (!projects.length) {
+                let errorMsg = `No projects found, please make sure you have at least one valid project.
+${utils.yW.gray('projects:')} ${JSON.stringify(config.projects, null, 2)}`;
+                if (options.project) errorMsg += `\n${utils.yW.gray('projectName filter:')} ${JSON.stringify(options.project, null, 2)}`;
+                throw errorMsg;
+            }
+            const names = new Set();
+            projects.forEach((project)=>{
+                if (names.has(project.config.name)) {
+                    const conflictProjects = projects.filter((p)=>p.config.name === project.config.name);
+                    throw `Project name "${project.config.name}" is already used. Please ensure all projects have unique names.
+Conflicting projects:
+${conflictProjects.map((p)=>`- ${p.configFilePath || p.config.root}`).join('\n')}
+        `;
+                }
+                names.add(project.config.name);
+            });
+            return projects;
+        }
+        async function initCli(options) {
+            const cwd = process.cwd();
+            const root = options.root ? (0, utils.FI)(cwd, options.root) : cwd;
+            const { config, configFilePath } = await resolveConfig({
+                ...options,
+                root
+            });
+            const projects = await resolveProjects({
+                config,
+                root,
+                options
+            });
+            return {
+                config,
+                configFilePath,
+                projects
+            };
+        }
+    },
     "./src/cli/prepare.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             N: ()=>showRstest,
@@ -2090,7 +2347,7 @@ ${section.body}` : section.body).join("\n\n"));
             if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
         }
         function showRstest() {
-            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.greet("  Rstest v0.5.1");
+            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.greet("  Rstest v0.5.2");
             _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.log('');
         }
     },
@@ -2194,6 +2451,7 @@ ${section.body}` : section.body).join("\n\n"));
                 printConsoleTrace: false,
                 disableConsoleIntercept: false,
                 snapshotFormat: {},
+                env: {},
                 coverage: {
                     exclude: [
                         '**/node_modules/**',
@@ -2242,6 +2500,1051 @@ ${section.body}` : section.body).join("\n\n"));
             };
         };
     },
+    "./src/core/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            createRstest: ()=>createRstest
+        });
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
+        class SnapshotManager {
+            summary;
+            extension = ".snap";
+            constructor(options){
+                this.options = options;
+                this.clear();
+            }
+            clear() {
+                this.summary = emptySummary(this.options);
+            }
+            add(result) {
+                addSnapshotResult(this.summary, result);
+            }
+            resolvePath(testPath, context) {
+                const resolver = this.options.resolveSnapshotPath || (()=>(0, pathe_M_eThtNZ.j)((0, pathe_M_eThtNZ.j)((0, pathe_M_eThtNZ.d)(testPath), "__snapshots__"), `${(0, pathe_M_eThtNZ.c)(testPath)}${this.extension}`));
+                const path = resolver(testPath, this.extension, context);
+                return path;
+            }
+            resolveRawPath(testPath, rawPath) {
+                return (0, pathe_M_eThtNZ.i)(rawPath) ? rawPath : (0, pathe_M_eThtNZ.r)((0, pathe_M_eThtNZ.d)(testPath), rawPath);
+            }
+        }
+        function emptySummary(options) {
+            const summary = {
+                added: 0,
+                failure: false,
+                filesAdded: 0,
+                filesRemoved: 0,
+                filesRemovedList: [],
+                filesUnmatched: 0,
+                filesUpdated: 0,
+                matched: 0,
+                total: 0,
+                unchecked: 0,
+                uncheckedKeysByFile: [],
+                unmatched: 0,
+                updated: 0,
+                didUpdate: "all" === options.updateSnapshot
+            };
+            return summary;
+        }
+        function addSnapshotResult(summary, result) {
+            if (result.added) summary.filesAdded++;
+            if (result.fileDeleted) summary.filesRemoved++;
+            if (result.unmatched) summary.filesUnmatched++;
+            if (result.updated) summary.filesUpdated++;
+            summary.added += result.added;
+            summary.matched += result.matched;
+            summary.unchecked += result.unchecked;
+            if (result.uncheckedKeys && result.uncheckedKeys.length > 0) summary.uncheckedKeysByFile.push({
+                filePath: result.filepath,
+                keys: result.uncheckedKeys
+            });
+            summary.unmatched += result.unmatched;
+            summary.updated += result.updated;
+            summary.total += result.added + result.matched + result.unmatched + result.updated;
+        }
+        const dist_r = Object.create(null), dist_i = (e)=>globalThis.process?.env || {
+                MODE: "production",
+                DEV: false,
+                PROD: true,
+                BASE_URL: "/",
+                ASSET_PREFIX: "auto"
+            }, o = new Proxy(dist_r, {
+            get (e, s) {
+                return dist_i()[s] ?? dist_r[s];
+            },
+            has (e, s) {
+                const E = dist_i();
+                return s in E || s in dist_r;
+            },
+            set (e, s, E) {
+                const B = dist_i(!0);
+                return B[s] = E, !0;
+            },
+            deleteProperty (e, s) {
+                if (!s) return !1;
+                const E = dist_i(!0);
+                return delete E[s], !0;
+            },
+            ownKeys () {
+                const e = dist_i(!0);
+                return Object.keys(e);
+            }
+        }), t = typeof process < "u" && process.env && process.env.NODE_ENV || "", f = [
+            [
+                "APPVEYOR"
+            ],
+            [
+                "AWS_AMPLIFY",
+                "AWS_APP_ID",
+                {
+                    ci: !0
+                }
+            ],
+            [
+                "AZURE_PIPELINES",
+                "SYSTEM_TEAMFOUNDATIONCOLLECTIONURI"
+            ],
+            [
+                "AZURE_STATIC",
+                "INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN"
+            ],
+            [
+                "APPCIRCLE",
+                "AC_APPCIRCLE"
+            ],
+            [
+                "BAMBOO",
+                "bamboo_planKey"
+            ],
+            [
+                "BITBUCKET",
+                "BITBUCKET_COMMIT"
+            ],
+            [
+                "BITRISE",
+                "BITRISE_IO"
+            ],
+            [
+                "BUDDY",
+                "BUDDY_WORKSPACE_ID"
+            ],
+            [
+                "BUILDKITE"
+            ],
+            [
+                "CIRCLE",
+                "CIRCLECI"
+            ],
+            [
+                "CIRRUS",
+                "CIRRUS_CI"
+            ],
+            [
+                "CLOUDFLARE_PAGES",
+                "CF_PAGES",
+                {
+                    ci: !0
+                }
+            ],
+            [
+                "CLOUDFLARE_WORKERS",
+                "WORKERS_CI",
+                {
+                    ci: !0
+                }
+            ],
+            [
+                "CODEBUILD",
+                "CODEBUILD_BUILD_ARN"
+            ],
+            [
+                "CODEFRESH",
+                "CF_BUILD_ID"
+            ],
+            [
+                "DRONE"
+            ],
+            [
+                "DRONE",
+                "DRONE_BUILD_EVENT"
+            ],
+            [
+                "DSARI"
+            ],
+            [
+                "GITHUB_ACTIONS"
+            ],
+            [
+                "GITLAB",
+                "GITLAB_CI"
+            ],
+            [
+                "GITLAB",
+                "CI_MERGE_REQUEST_ID"
+            ],
+            [
+                "GOCD",
+                "GO_PIPELINE_LABEL"
+            ],
+            [
+                "LAYERCI"
+            ],
+            [
+                "HUDSON",
+                "HUDSON_URL"
+            ],
+            [
+                "JENKINS",
+                "JENKINS_URL"
+            ],
+            [
+                "MAGNUM"
+            ],
+            [
+                "NETLIFY"
+            ],
+            [
+                "NETLIFY",
+                "NETLIFY_LOCAL",
+                {
+                    ci: !1
+                }
+            ],
+            [
+                "NEVERCODE"
+            ],
+            [
+                "RENDER"
+            ],
+            [
+                "SAIL",
+                "SAILCI"
+            ],
+            [
+                "SEMAPHORE"
+            ],
+            [
+                "SCREWDRIVER"
+            ],
+            [
+                "SHIPPABLE"
+            ],
+            [
+                "SOLANO",
+                "TDDIUM"
+            ],
+            [
+                "STRIDER"
+            ],
+            [
+                "TEAMCITY",
+                "TEAMCITY_VERSION"
+            ],
+            [
+                "TRAVIS"
+            ],
+            [
+                "VERCEL",
+                "NOW_BUILDER"
+            ],
+            [
+                "VERCEL",
+                "VERCEL",
+                {
+                    ci: !1
+                }
+            ],
+            [
+                "VERCEL",
+                "VERCEL_ENV",
+                {
+                    ci: !1
+                }
+            ],
+            [
+                "APPCENTER",
+                "APPCENTER_BUILD_ID"
+            ],
+            [
+                "CODESANDBOX",
+                "CODESANDBOX_SSE",
+                {
+                    ci: !1
+                }
+            ],
+            [
+                "CODESANDBOX",
+                "CODESANDBOX_HOST",
+                {
+                    ci: !1
+                }
+            ],
+            [
+                "STACKBLITZ"
+            ],
+            [
+                "STORMKIT"
+            ],
+            [
+                "CLEAVR"
+            ],
+            [
+                "ZEABUR"
+            ],
+            [
+                "CODESPHERE",
+                "CODESPHERE_APP_ID",
+                {
+                    ci: !0
+                }
+            ],
+            [
+                "RAILWAY",
+                "RAILWAY_PROJECT_ID"
+            ],
+            [
+                "RAILWAY",
+                "RAILWAY_SERVICE_ID"
+            ],
+            [
+                "DENO-DEPLOY",
+                "DENO_DEPLOYMENT_ID"
+            ],
+            [
+                "FIREBASE_APP_HOSTING",
+                "FIREBASE_APP_HOSTING",
+                {
+                    ci: !0
+                }
+            ]
+        ];
+        function b() {
+            if (globalThis.process?.env) for (const e of f){
+                const s = e[1] || e[0];
+                if (globalThis.process?.env[s]) return {
+                    name: e[0].toLowerCase(),
+                    ...e[2]
+                };
+            }
+            return globalThis.process?.env?.SHELL === "/bin/jsh" && globalThis.process?.versions?.webcontainer ? {
+                name: "stackblitz",
+                ci: !1
+            } : {
+                name: "",
+                ci: !1
+            };
+        }
+        const l = b();
+        l.name;
+        function n(e) {
+            return e ? "false" !== e : !1;
+        }
+        const I = globalThis.process?.platform || "", T = n(o.CI) || !1 !== l.ci, R = n(globalThis.process?.stdout && globalThis.process?.stdout.isTTY), A = (n(o.DEBUG), "test" === t || n(o.TEST), n(o.MINIMAL), /^win/i.test(I)), C = (/^linux/i.test(I), /^darwin/i.test(I), !n(o.NO_COLOR) && (n(o.FORCE_COLOR) || (R || A) && o.TERM), (globalThis.process?.versions?.node || "").replace(/^v/, "") || null), W = (Number(C?.split(".")[0]), globalThis.process || Object.create(null)), dist_ = {
+            versions: {}
+        }, O = (new Proxy(W, {
+            get (e, s) {
+                if ("env" === s) return o;
+                if (s in e) return e[s];
+                if (s in dist_) return dist_[s];
+            }
+        }), globalThis.process?.release?.name === "node"), c = !!globalThis.Bun || !!globalThis.process?.versions?.bun, D = !!globalThis.Deno, L = !!globalThis.fastly, S = !!globalThis.Netlify, u = !!globalThis.EdgeRuntime, N = globalThis.navigator?.userAgent === "Cloudflare-Workers", F = [
+            [
+                S,
+                "netlify"
+            ],
+            [
+                u,
+                "edge-light"
+            ],
+            [
+                N,
+                "workerd"
+            ],
+            [
+                L,
+                "fastly"
+            ],
+            [
+                D,
+                "deno"
+            ],
+            [
+                c,
+                "bun"
+            ],
+            [
+                O,
+                "node"
+            ]
+        ];
+        function G() {
+            const e = F.find((s)=>s[0]);
+            if (e) return {
+                name: e[1]
+            };
+        }
+        const P = G();
+        P?.name;
+        var src_config = __webpack_require__("./src/config.ts");
+        var stack_trace_parser_esm = __webpack_require__("../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        const DEFAULT_RENDER_INTERVAL_MS = 1000;
+        const ESC = '\x1B[';
+        const CLEAR_LINE = `${ESC}K`;
+        const MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`;
+        const SYNC_START = `${ESC}?2026h`;
+        const SYNC_END = `${ESC}?2026l`;
+        class WindowRenderer {
+            options;
+            streams;
+            buffer = [];
+            renderInterval = void 0;
+            renderScheduled = false;
+            windowHeight = 0;
+            finished = false;
+            cleanups = [];
+            constructor(options){
+                this.options = {
+                    interval: DEFAULT_RENDER_INTERVAL_MS,
+                    ...options
+                };
+                this.streams = {
+                    output: options.logger.outputStream.write.bind(options.logger.outputStream),
+                    error: options.logger.errorStream.write.bind(options.logger.errorStream)
+                };
+                this.cleanups.push(this.interceptStream(process.stdout, 'output'), this.interceptStream(process.stderr, 'error'));
+                this.start();
+            }
+            start() {
+                this.finished = false;
+                this.renderInterval = setInterval(()=>this.schedule(), this.options.interval).unref();
+            }
+            stop() {
+                this.cleanups.splice(0).map((fn)=>fn());
+                clearInterval(this.renderInterval);
+            }
+            finish() {
+                this.finished = true;
+                this.flushBuffer();
+                clearInterval(this.renderInterval);
+            }
+            schedule() {
+                if (!this.renderScheduled) {
+                    this.renderScheduled = true;
+                    this.flushBuffer();
+                    setTimeout(()=>{
+                        this.renderScheduled = false;
+                    }, 100).unref();
+                }
+            }
+            flushBuffer() {
+                if (0 === this.buffer.length) return this.render();
+                let current;
+                for (const next of this.buffer.splice(0)){
+                    if (!current) {
+                        current = next;
+                        continue;
+                    }
+                    if (current.type !== next.type) {
+                        this.render(current.message, current.type);
+                        current = next;
+                        continue;
+                    }
+                    current.message += next.message;
+                }
+                if (current) this.render(current?.message, current?.type);
+            }
+            render(message, type = 'output') {
+                if (this.finished) {
+                    this.clearWindow();
+                    return this.write(message || '', type);
+                }
+                const windowContent = this.options.getWindow();
+                const rowCount = getRenderedRowCount(windowContent, this.options.logger.getColumns());
+                let padding = this.windowHeight - rowCount;
+                if (padding > 0 && message) padding -= getRenderedRowCount([
+                    message
+                ], this.options.logger.getColumns());
+                this.write(SYNC_START);
+                this.clearWindow();
+                if (message) this.write(message, type);
+                if (padding > 0) this.write('\n'.repeat(padding));
+                this.write(windowContent.join('\n'));
+                this.write(SYNC_END);
+                this.windowHeight = rowCount + Math.max(0, padding);
+            }
+            clearWindow() {
+                if (0 === this.windowHeight) return;
+                this.write(CLEAR_LINE);
+                for(let i = 1; i < this.windowHeight; i++)this.write(`${MOVE_CURSOR_ONE_ROW_UP}${CLEAR_LINE}`);
+                this.windowHeight = 0;
+            }
+            interceptStream(stream, type) {
+                const original = stream.write.bind(stream);
+                stream.write = (chunk, _, callback)=>{
+                    if (chunk) if (this.finished) this.write(chunk.toString(), type);
+                    else this.buffer.push({
+                        type,
+                        message: chunk.toString()
+                    });
+                    callback?.();
+                };
+                return function restore() {
+                    stream.write = original;
+                };
+            }
+            write(message, type = 'output') {
+                this.streams[type](message);
+            }
+        }
+        function getRenderedRowCount(rows, columns) {
+            let count = 0;
+            for (const row of rows){
+                const text = (0, __WEBPACK_EXTERNAL_MODULE_node_util_1b29d436__.stripVTControlCharacters)(row);
+                count += Math.max(1, Math.ceil(text.length / columns));
+            }
+            return count;
+        }
+        class StatusRenderer {
+            rootPath;
+            renderer;
+            runningModules = new Set();
+            constructor(rootPath){
+                this.rootPath = rootPath;
+                this.renderer = new WindowRenderer({
+                    getWindow: ()=>this.getContent(),
+                    logger: {
+                        outputStream: process.stdout,
+                        errorStream: process.stderr,
+                        getColumns: ()=>'columns' in process.stdout ? process.stdout.columns : 80
+                    }
+                });
+            }
+            getContent() {
+                const summary = [];
+                for (const module of this.runningModules){
+                    const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, module);
+                    summary.push(`${utils.yW.bgYellow(utils.yW.bold(' RUNS '))} ${(0, utils.EQ)(relativePath)}`);
+                }
+                summary.push('');
+                return summary;
+            }
+            addRunningModule(testPath) {
+                this.runningModules.add(testPath);
+                this.renderer?.schedule();
+            }
+            removeRunningModule(testPath) {
+                this.runningModules.delete(testPath);
+                this.renderer?.schedule();
+            }
+            clear() {
+                this.runningModules.clear();
+                this.renderer?.finish();
+            }
+        }
+        var dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
+        const getSummaryStatusString = (tasks, name = 'tests', showTotal = true)=>{
+            if (0 === tasks.length) return utils.yW.dim(`no ${name}`);
+            const passed = tasks.filter((result)=>'pass' === result.status);
+            const failed = tasks.filter((result)=>'fail' === result.status);
+            const skipped = tasks.filter((result)=>'skip' === result.status);
+            const todo = tasks.filter((result)=>'todo' === result.status);
+            const status = [
+                failed.length ? utils.yW.bold(utils.yW.red(`${failed.length} failed`)) : null,
+                passed.length ? utils.yW.bold(utils.yW.green(`${passed.length} passed`)) : null,
+                skipped.length ? utils.yW.yellow(`${skipped.length} skipped`) : null,
+                todo.length ? utils.yW.gray(`${todo.length} todo`) : null
+            ].filter(Boolean);
+            return status.join(utils.yW.dim(' | ')) + (showTotal && status.length > 1 ? utils.yW.gray(` (${tasks.length})`) : '');
+        };
+        const printSnapshotSummaryLog = (snapshots, rootDir)=>{
+            const summary = [];
+            if (snapshots.added) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.added} written`)));
+            if (snapshots.unmatched) summary.push(utils.yW.bold(utils.yW.red(`${snapshots.unmatched} failed`)));
+            if (snapshots.updated) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.updated} updated `)));
+            if (snapshots.filesRemoved) if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.filesRemoved} files removed `)));
+            else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.filesRemoved} files obsolete `)));
+            const POINTER = '➜';
+            if (snapshots.filesRemovedList?.length) {
+                const [head, ...tail] = snapshots.filesRemovedList;
+                summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, head)}`);
+                for (const key of tail)summary.push(`  ${(0, utils.XJ)(rootDir, key)}`);
+            }
+            if (snapshots.unchecked) {
+                if (snapshots.didUpdate) summary.push(utils.yW.bold(utils.yW.green(`${snapshots.unchecked} removed`)));
+                else summary.push(utils.yW.bold(utils.yW.yellow(`${snapshots.unchecked} obsolete`)));
+                for (const uncheckedFile of snapshots.uncheckedKeysByFile){
+                    summary.push(`${utils.yW.gray(POINTER)} ${(0, utils.XJ)(rootDir, uncheckedFile.filePath)}`);
+                    for (const key of uncheckedFile.keys)summary.push(`  ${key}`);
+                }
+            }
+            for (const [index, snapshot] of summary.entries()){
+                const title = 0 === index ? 'Snapshots' : '';
+                utils.vF.log(`${utils.yW.gray(title.padStart(12))} ${snapshot}`);
+            }
+        };
+        const printSummaryLog = ({ results, testResults, snapshotSummary, duration, rootPath })=>{
+            utils.vF.log('');
+            printSnapshotSummaryLog(snapshotSummary, rootPath);
+            utils.vF.log(`${utils.yW.gray('Test Files'.padStart(11))} ${getSummaryStatusString(results)}`);
+            utils.vF.log(`${utils.yW.gray('Tests'.padStart(11))} ${getSummaryStatusString(testResults)}`);
+            utils.vF.log(`${utils.yW.gray('Duration'.padStart(11))} ${(0, utils.kV)(duration.totalTime)} ${utils.yW.gray(`(build ${(0, utils.kV)(duration.buildTime)}, tests ${(0, utils.kV)(duration.testTime)})`)}`);
+            utils.vF.log('');
+        };
+        const printSummaryErrorLogs = async ({ testResults, results, rootPath, getSourcemap, filterRerunTestPaths })=>{
+            const failedTests = [
+                ...results.filter((i)=>'fail' === i.status && i.errors?.length && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true)),
+                ...testResults.filter((i)=>'fail' === i.status && (filterRerunTestPaths ? filterRerunTestPaths.includes(i.testPath) : true))
+            ];
+            if (0 === failedTests.length) return;
+            utils.vF.log('');
+            utils.vF.log(utils.yW.bold('Summary of all failing tests:'));
+            utils.vF.log('');
+            for (const test of failedTests){
+                const relativePath = dist.Ay.relative(rootPath, test.testPath);
+                const nameStr = (0, utils.fN)(test);
+                utils.vF.log(`${utils.yW.bgRed(' FAIL ')} ${(0, utils.EQ)(relativePath)} ${nameStr.length ? `${utils.yW.dim(utils.vO)} ${nameStr}` : ''}`);
+                if (test.errors) {
+                    const { printError } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
+                    for (const error of test.errors)await printError(error, getSourcemap, rootPath);
+                }
+            }
+        };
+        const statusStr = {
+            fail: '✗',
+            pass: '✓',
+            todo: '-',
+            skip: '-'
+        };
+        const statusColorfulStr = {
+            fail: utils.yW.red(statusStr.fail),
+            pass: utils.yW.green(statusStr.pass),
+            todo: utils.yW.gray(statusStr.todo),
+            skip: utils.yW.gray(statusStr.skip)
+        };
+        const logCase = (result, slowTestThreshold)=>{
+            const isSlowCase = (result.duration || 0) > slowTestThreshold;
+            const icon = isSlowCase && 'pass' === result.status ? utils.yW.yellow(statusStr[result.status]) : statusColorfulStr[result.status];
+            const nameStr = (0, utils.fN)(result);
+            const duration = void 0 !== result.duration ? ` (${(0, utils.kV)(result.duration)})` : '';
+            const retry = result.retryCount ? utils.yW.yellow(` (retry x${result.retryCount})`) : '';
+            utils.vF.log(`  ${icon} ${nameStr}${utils.yW.gray(duration)}${retry}`);
+            if (result.errors) for (const error of result.errors)console.error(utils.yW.red(`    ${error.message}`));
+        };
+        const logFileTitle = (test, relativePath, slowTestThreshold, alwaysShowTime = false)=>{
+            let title = ` ${utils.yW.bold(statusColorfulStr[test.status])} ${(0, utils.EQ)(relativePath)}`;
+            const formatDuration = (duration)=>utils.yW[duration > slowTestThreshold ? 'yellow' : 'green']((0, utils.kV)(duration));
+            title += ` ${utils.yW.gray(`(${test.results.length})`)}`;
+            const isTooSlow = test.duration && test.duration > slowTestThreshold;
+            if (alwaysShowTime || isTooSlow) title += ` ${formatDuration(test.duration)}`;
+            utils.vF.log(title);
+        };
+        class DefaultReporter {
+            rootPath;
+            config;
+            options = {};
+            statusRenderer;
+            constructor({ rootPath, options, config }){
+                this.rootPath = rootPath;
+                this.config = config;
+                this.options = options;
+                if (!T) this.statusRenderer = new StatusRenderer(rootPath);
+            }
+            onTestFileStart(test) {
+                this.statusRenderer?.addRunningModule(test.testPath);
+            }
+            onTestFileResult(test) {
+                this.statusRenderer?.removeRunningModule(test.testPath);
+                const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath);
+                const { slowTestThreshold } = this.config;
+                logFileTitle(test, relativePath, slowTestThreshold);
+                const isTooSlow = test.duration && test.duration > slowTestThreshold;
+                const hasRetryCase = test.results.some((result)=>(result.retryCount || 0) > 0);
+                if ('fail' !== test.status && !isTooSlow && !hasRetryCase) return;
+                const showAllCases = isTooSlow && !test.results.some((result)=>(result.duration || 0) > slowTestThreshold);
+                for (const result of test.results){
+                    const isSlowCase = (result.duration || 0) > slowTestThreshold;
+                    const retried = (result.retryCount || 0) > 0;
+                    if (showAllCases || 'fail' === result.status || isSlowCase || retried) logCase(result, slowTestThreshold);
+                }
+            }
+            onTestCaseResult(_result) {}
+            onUserConsoleLog(log) {
+                const shouldLog = this.config.onConsoleLog?.(log.content) ?? true;
+                if (!shouldLog) return;
+                const titles = [
+                    log.name
+                ];
+                const testPath = (0, pathe_M_eThtNZ.b)(this.rootPath, log.testPath);
+                if (log.trace) {
+                    const [frame] = (0, stack_trace_parser_esm.q)(log.trace);
+                    const filePath = (0, pathe_M_eThtNZ.b)(this.rootPath, frame.file || '');
+                    if (filePath !== testPath) titles.push((0, utils.EQ)(testPath));
+                    titles.push((0, utils.EQ)(filePath) + utils.yW.gray(`:${frame.lineNumber}:${frame.column}`));
+                } else titles.push((0, utils.EQ)(testPath));
+                utils.vF.log(titles.join(utils.yW.gray(' | ')));
+                utils.vF.log(log.content);
+                utils.vF.log('');
+            }
+            async onExit() {
+                this.statusRenderer?.clear();
+            }
+            async onTestRunEnd({ results, testResults, duration, getSourcemap, snapshotSummary, filterRerunTestPaths }) {
+                this.statusRenderer?.clear();
+                if (false === this.options.summary) return;
+                await printSummaryErrorLogs({
+                    testResults,
+                    results,
+                    rootPath: this.rootPath,
+                    getSourcemap,
+                    filterRerunTestPaths
+                });
+                printSummaryLog({
+                    results,
+                    testResults,
+                    duration,
+                    rootPath: this.rootPath,
+                    snapshotSummary
+                });
+            }
+        }
+        class GithubActionsReporter {
+            onWritePath;
+            rootPath;
+            constructor({ options, rootPath }){
+                this.onWritePath = options.onWritePath;
+                this.rootPath = rootPath;
+            }
+            log(message) {
+                console.log(`${message}\n`);
+            }
+            async onTestRunEnd({ results, testResults, getSourcemap }) {
+                const failedTests = [
+                    ...results.filter((i)=>'fail' === i.status && i.errors?.length),
+                    ...testResults.filter((i)=>'fail' === i.status)
+                ];
+                if (0 === failedTests.length) return;
+                const { parseErrorStacktrace } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
+                const logs = [];
+                for (const test of failedTests){
+                    const { testPath } = test;
+                    const nameStr = (0, utils.fN)(test);
+                    const shortPath = (0, pathe_M_eThtNZ.b)(this.rootPath, testPath);
+                    const title = `${shortPath} ${utils.vO} ${nameStr}`;
+                    for (const error of test.errors || []){
+                        let file = testPath;
+                        let line = 1;
+                        let column = 1;
+                        const message = `${error.message}${error.diff ? `\n${error.diff}` : ''}`;
+                        const type = 'error';
+                        if (error.stack) {
+                            const stackFrames = await parseErrorStacktrace({
+                                stack: error.stack,
+                                fullStack: error.fullStack,
+                                getSourcemap
+                            });
+                            if (stackFrames[0]) {
+                                file = stackFrames[0].file || test.testPath;
+                                line = stackFrames[0].lineNumber || 1;
+                                column = stackFrames[0].column || 1;
+                            }
+                        }
+                        logs.push(`::${type} file=${this.onWritePath?.(file) || file},line=${line},col=${column},title=${escapeData(title)}::${escapeData(message)}`);
+                    }
+                }
+                this.log('::group::error for github actions');
+                for (const log of logs)this.log(log);
+                this.log('::endgroup::');
+            }
+        }
+        function escapeData(s) {
+            return s.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A').replace(/:/g, '%3A').replace(/,/g, '%2C');
+        }
+        var promises_ = __webpack_require__("node:fs/promises");
+        function ansiRegex({ onlyFirst = false } = {}) {
+            const ST = '(?:\\u0007|\\u001B\\u005C|\\u009C)';
+            const pattern = [
+                `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
+                '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
+            ].join('|');
+            return new RegExp(pattern, onlyFirst ? void 0 : 'g');
+        }
+        const regex = ansiRegex();
+        function stripAnsi(string) {
+            if ('string' != typeof string) throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+            return string.replace(regex, '');
+        }
+        var utils_error = __webpack_require__("./src/utils/error.ts");
+        class JUnitReporter {
+            rootPath;
+            outputPath;
+            constructor({ rootPath, options: { outputPath } = {} }){
+                this.rootPath = rootPath;
+                this.outputPath = outputPath;
+            }
+            sanitizeXml(text) {
+                let result = '';
+                for (const ch of stripAnsi(text)){
+                    const cp = ch.codePointAt(0);
+                    const valid = 0x09 === cp || 0x0a === cp || 0x0d === cp || cp >= 0x20 && cp <= 0xd7ff || cp >= 0xe000 && cp <= 0xfffd || cp >= 0x10000 && cp <= 0x10ffff;
+                    if (valid) result += ch;
+                }
+                return result;
+            }
+            escapeXml(text) {
+                const sanitized = this.sanitizeXml(text);
+                return sanitized.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+            }
+            async createJUnitTestCase(test, getSourcemap) {
+                const testCase = {
+                    name: (0, utils.fN)(test),
+                    classname: (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath),
+                    time: (test.duration || 0) / 1000,
+                    status: test.status
+                };
+                if (test.errors && test.errors.length > 0) testCase.errors = await Promise.all(test.errors.map(async (error)=>{
+                    let details = `${error.message}${error.diff ? `\n${error.diff}` : ''}`;
+                    const stackFrames = error.stack ? await (0, utils_error.parseErrorStacktrace)({
+                        stack: error.stack,
+                        fullStack: error.fullStack,
+                        getSourcemap
+                    }) : [];
+                    if (stackFrames[0]) details += `\n${(0, utils_error.C)(stackFrames[0], this.rootPath)}`;
+                    return {
+                        message: this.escapeXml(error.message),
+                        type: error.name || 'Error',
+                        details: this.escapeXml(details)
+                    };
+                }));
+                return testCase;
+            }
+            async createJUnitTestSuite(fileResult, getSourcemap) {
+                const testCases = await Promise.all(fileResult.results.map(async (test)=>this.createJUnitTestCase(test, getSourcemap)));
+                const failures = testCases.filter((test)=>'fail' === test.status).length;
+                const errors = 0;
+                const skipped = testCases.filter((test)=>'skip' === test.status || 'todo' === test.status).length;
+                const totalTime = testCases.reduce((sum, test)=>sum + test.time, 0);
+                return {
+                    name: (0, pathe_M_eThtNZ.b)(this.rootPath, fileResult.testPath),
+                    tests: testCases.length,
+                    failures,
+                    errors,
+                    skipped,
+                    time: totalTime,
+                    timestamp: new Date().toISOString(),
+                    testcases: testCases
+                };
+            }
+            generateJUnitXml(report) {
+                const xmlDeclaration = '<?xml version="1.0" encoding="UTF-8"?>';
+                const testsuitesXml = `
+<testsuites name="${this.escapeXml(report.testsuites.name)}" tests="${report.testsuites.tests}" failures="${report.testsuites.failures}" errors="${report.testsuites.errors}" skipped="${report.testsuites.skipped}" time="${report.testsuites.time}" timestamp="${this.escapeXml(report.testsuites.timestamp)}">`;
+                const testsuiteXmls = report.testsuites.testsuite.map((suite)=>{
+                    const testsuiteStart = `
+  <testsuite name="${this.escapeXml(suite.name)}" tests="${suite.tests}" failures="${suite.failures}" errors="${suite.errors}" skipped="${suite.skipped}" time="${suite.time}" timestamp="${this.escapeXml(suite.timestamp)}">`;
+                    const testcaseXmls = suite.testcases.map((testcase)=>{
+                        let testcaseXml = `
+    <testcase name="${this.escapeXml(testcase.name)}" classname="${this.escapeXml(testcase.classname)}" time="${testcase.time}">`;
+                        if ('skip' === testcase.status || 'todo' === testcase.status) testcaseXml += `
+      <skipped/>`;
+                        else if ('fail' === testcase.status && testcase.errors) testcase.errors.forEach((error)=>{
+                            testcaseXml += `
+      <failure message="${error.message}" type="${error.type}">${error.details || ''}</failure>`;
+                        });
+                        testcaseXml += `
+    </testcase>`;
+                        return testcaseXml;
+                    }).join('');
+                    const testsuiteEnd = `
+  </testsuite>`;
+                    return testsuiteStart + testcaseXmls + testsuiteEnd;
+                }).join('');
+                const testsuitesEnd = `
+</testsuites>`;
+                return xmlDeclaration + testsuitesXml + testsuiteXmls + testsuitesEnd;
+            }
+            async onTestRunEnd({ results, testResults, duration, getSourcemap }) {
+                const testSuites = await Promise.all(results.map(async (fileResult)=>this.createJUnitTestSuite(fileResult, getSourcemap)));
+                const totalTests = testResults.length;
+                const totalFailures = testResults.filter((test)=>'fail' === test.status).length;
+                const totalErrors = 0;
+                const totalSkipped = testResults.filter((test)=>'skip' === test.status || 'todo' === test.status).length;
+                const totalTime = duration.testTime / 1000;
+                const report = {
+                    testsuites: {
+                        name: 'rstest tests',
+                        tests: totalTests,
+                        failures: totalFailures,
+                        errors: totalErrors,
+                        skipped: totalSkipped,
+                        time: totalTime,
+                        timestamp: new Date().toISOString(),
+                        testsuite: testSuites
+                    }
+                };
+                const xmlContent = this.generateJUnitXml(report);
+                if (this.outputPath) try {
+                    await (0, promises_.writeFile)(this.outputPath, xmlContent, 'utf-8');
+                    console.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);
+                }
+                else console.log(xmlContent);
+            }
+        }
+        class VerboseReporter extends DefaultReporter {
+            onTestFileResult(test) {
+                this.statusRenderer?.removeRunningModule(test.testPath);
+                const relativePath = (0, pathe_M_eThtNZ.b)(this.rootPath, test.testPath);
+                const { slowTestThreshold } = this.config;
+                logFileTitle(test, relativePath, slowTestThreshold, true);
+                for (const result of test.results)logCase(result, slowTestThreshold);
+            }
+        }
+        function formatEnvironmentName(name) {
+            return name.replace(/[^a-zA-Z0-9\-_$]/g, '_');
+        }
+        class Rstest {
+            cwd;
+            command;
+            fileFilters;
+            configFilePath;
+            reporters;
+            snapshotManager;
+            version;
+            rootPath;
+            originalConfig;
+            normalizedConfig;
+            idMap = new Map();
+            reporterResults = {
+                results: [],
+                testResults: []
+            };
+            projects = [];
+            constructor({ cwd = process.cwd(), command, fileFilters, configFilePath, projects }, userConfig){
+                this.cwd = cwd;
+                this.command = command;
+                this.fileFilters = fileFilters;
+                this.configFilePath = configFilePath;
+                const rootPath = userConfig.root ? (0, utils.FI)(cwd, userConfig.root) : cwd;
+                const rstestConfig = (0, src_config.wX)({
+                    ...userConfig,
+                    root: rootPath
+                });
+                const reporters = 'list' !== command ? createReporters(rstestConfig.reporters, {
+                    rootPath,
+                    config: rstestConfig
+                }) : [];
+                const snapshotManager = new SnapshotManager({
+                    updateSnapshot: rstestConfig.update ? 'all' : T ? 'none' : 'new'
+                });
+                this.reporters = reporters;
+                this.snapshotManager = snapshotManager;
+                this.version = "0.5.2";
+                this.rootPath = rootPath;
+                this.originalConfig = userConfig;
+                this.normalizedConfig = rstestConfig;
+                this.projects = projects.length ? projects.map((project)=>{
+                    const config = (0, src_config.wX)(project.config);
+                    config.isolate = rstestConfig.isolate;
+                    config.source ??= {};
+                    config.coverage = rstestConfig.coverage;
+                    if (!config.source.tsconfigPath) {
+                        const tsconfigPath = (0, pathe_M_eThtNZ.j)(config.root, utils.WB);
+                        if ((0, external_node_fs_.existsSync)(tsconfigPath)) config.source.tsconfigPath = tsconfigPath;
+                    }
+                    return {
+                        configFilePath: project.configFilePath,
+                        rootPath: config.root,
+                        name: config.name,
+                        environmentName: formatEnvironmentName(config.name),
+                        normalizedConfig: config
+                    };
+                }) : [
+                    {
+                        configFilePath,
+                        rootPath,
+                        name: rstestConfig.name,
+                        environmentName: formatEnvironmentName(rstestConfig.name),
+                        normalizedConfig: rstestConfig
+                    }
+                ];
+            }
+            updateReporterResultState(results, testResults, deletedEntries = []) {
+                results.forEach((item)=>{
+                    const existingIndex = this.reporterResults.results.findIndex((r)=>r.testPath === item.testPath);
+                    if (-1 !== existingIndex) this.reporterResults.results[existingIndex] = item;
+                    else this.reporterResults.results.push(item);
+                });
+                const testPathsToUpdate = new Set(testResults.map((r)=>r.testPath));
+                this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!testPathsToUpdate.has(r.testPath));
+                this.reporterResults.testResults.push(...testResults);
+                if (deletedEntries.length > 0) {
+                    const deletedPathsSet = new Set(deletedEntries);
+                    this.reporterResults.results = this.reporterResults.results.filter((r)=>!deletedPathsSet.has(r.testPath));
+                    this.reporterResults.testResults = this.reporterResults.testResults.filter((r)=>!deletedPathsSet.has(r.testPath));
+                }
+            }
+        }
+        const reportersMap = {
+            default: DefaultReporter,
+            verbose: VerboseReporter,
+            'github-actions': GithubActionsReporter,
+            junit: JUnitReporter
+        };
+        function createReporters(reporters, initOptions = {}) {
+            const result = (0, utils.bg)(reporters).map((reporter)=>{
+                if ('string' == typeof reporter || Array.isArray(reporter)) {
+                    const [name, options = {}] = 'string' == typeof reporter ? [
+                        reporter,
+                        {}
+                    ] : reporter;
+                    if (name in reportersMap) {
+                        const Reporter = reportersMap[name];
+                        return new Reporter({
+                            ...initOptions,
+                            options
+                        });
+                    }
+                    throw new Error(`Reporter ${reporter} not found. Please install it or use a built-in reporter.`);
+                }
+                return reporter;
+            });
+            return result;
+        }
+        __webpack_require__("./src/cli/index.ts");
+        function createRstest({ config, projects, configFilePath }, command, fileFilters) {
+            const context = new Rstest({
+                cwd: process.cwd(),
+                command,
+                fileFilters,
+                configFilePath,
+                projects
+            }, config);
+            const runTests = async ()=>{
+                const { runTests } = await Promise.all([
+                    __webpack_require__.e("816"),
+                    __webpack_require__.e("33")
+                ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/runTests.ts"));
+                await runTests(context);
+            };
+            const listTests = async (options)=>{
+                const { listTests } = await Promise.all([
+                    __webpack_require__.e("816"),
+                    __webpack_require__.e("971")
+                ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/listTests.ts"));
+                await listTests(context, options);
+            };
+            return {
+                context,
+                runTests,
+                listTests
+            };
+        }
+    },
     "./src/utils/constants.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             EJ: ()=>TEMP_RSTEST_OUTPUT_DIR_GLOB,
@@ -2249,9 +3552,11 @@ ${section.body}` : section.body).join("\n\n"));
             WB: ()=>TS_CONFIG_FILE,
             kv: ()=>DEFAULT_CONFIG_EXTENSIONS,
             t: ()=>DEFAULT_CONFIG_NAME,
+            vO: ()=>TEST_DELIMITER,
             zZ: ()=>TEMP_RSTEST_OUTPUT_DIR
         });
         const DEFAULT_CONFIG_NAME = 'rstest.config';
+        const TEST_DELIMITER = '>';
         const TEMP_RSTEST_OUTPUT_DIR = 'dist/.rstest-temp';
         const TEMP_RSTEST_OUTPUT_DIR_GLOB = '**/dist/.rstest-temp';
         const DEFAULT_CONFIG_EXTENSIONS = [
@@ -2279,6 +3584,517 @@ ${section.body}` : section.body).join("\n\n"));
         ];
         const TS_CONFIG_FILE = 'tsconfig.json';
     },
+    "./src/utils/error.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            printError: ()=>printError,
+            C: ()=>formatStack,
+            parseErrorStacktrace: ()=>parseErrorStacktrace
+        });
+        var external_node_fs_ = __webpack_require__("node:fs");
+        var comma = ",".charCodeAt(0);
+        var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        var intToChar = new Uint8Array(64);
+        var charToInt = new Uint8Array(128);
+        for(let i = 0; i < chars.length; i++){
+            const c = chars.charCodeAt(i);
+            intToChar[i] = c;
+            charToInt[c] = i;
+        }
+        function decodeInteger(reader, relative) {
+            let value = 0;
+            let shift = 0;
+            let integer = 0;
+            do {
+                const c = reader.next();
+                integer = charToInt[c];
+                value |= (31 & integer) << shift;
+                shift += 5;
+            }while (32 & integer);
+            const shouldNegate = 1 & value;
+            value >>>= 1;
+            if (shouldNegate) value = -2147483648 | -value;
+            return relative + value;
+        }
+        function hasMoreVlq(reader, max) {
+            if (reader.pos >= max) return false;
+            return reader.peek() !== comma;
+        }
+        typeof TextDecoder;
+        var StringReader = class {
+            constructor(buffer){
+                this.pos = 0;
+                this.buffer = buffer;
+            }
+            next() {
+                return this.buffer.charCodeAt(this.pos++);
+            }
+            peek() {
+                return this.buffer.charCodeAt(this.pos);
+            }
+            indexOf(char) {
+                const { buffer, pos } = this;
+                const idx = buffer.indexOf(char, pos);
+                return -1 === idx ? buffer.length : idx;
+            }
+        };
+        function decode(mappings) {
+            const { length } = mappings;
+            const reader = new StringReader(mappings);
+            const decoded = [];
+            let genColumn = 0;
+            let sourcesIndex = 0;
+            let sourceLine = 0;
+            let sourceColumn = 0;
+            let namesIndex = 0;
+            do {
+                const semi = reader.indexOf(";");
+                const line = [];
+                let sorted = true;
+                let lastCol = 0;
+                genColumn = 0;
+                while(reader.pos < semi){
+                    let seg;
+                    genColumn = decodeInteger(reader, genColumn);
+                    if (genColumn < lastCol) sorted = false;
+                    lastCol = genColumn;
+                    if (hasMoreVlq(reader, semi)) {
+                        sourcesIndex = decodeInteger(reader, sourcesIndex);
+                        sourceLine = decodeInteger(reader, sourceLine);
+                        sourceColumn = decodeInteger(reader, sourceColumn);
+                        if (hasMoreVlq(reader, semi)) {
+                            namesIndex = decodeInteger(reader, namesIndex);
+                            seg = [
+                                genColumn,
+                                sourcesIndex,
+                                sourceLine,
+                                sourceColumn,
+                                namesIndex
+                            ];
+                        } else seg = [
+                            genColumn,
+                            sourcesIndex,
+                            sourceLine,
+                            sourceColumn
+                        ];
+                    } else seg = [
+                        genColumn
+                    ];
+                    line.push(seg);
+                    reader.pos++;
+                }
+                if (!sorted) sort(line);
+                decoded.push(line);
+                reader.pos = semi + 1;
+            }while (reader.pos <= length);
+            return decoded;
+        }
+        function sort(line) {
+            line.sort(sortComparator);
+        }
+        function sortComparator(a, b) {
+            return a[0] - b[0];
+        }
+        const schemeRegex = /^[\w+.-]+:\/\//;
+        const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+        const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+        function isAbsoluteUrl(input) {
+            return schemeRegex.test(input);
+        }
+        function isSchemeRelativeUrl(input) {
+            return input.startsWith('//');
+        }
+        function isAbsolutePath(input) {
+            return input.startsWith('/');
+        }
+        function isFileUrl(input) {
+            return input.startsWith('file:');
+        }
+        function isRelative(input) {
+            return /^[.?#]/.test(input);
+        }
+        function parseAbsoluteUrl(input) {
+            const match = urlRegex.exec(input);
+            return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+        }
+        function parseFileUrl(input) {
+            const match = fileRegex.exec(input);
+            const path = match[2];
+            return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+        }
+        function makeUrl(scheme, user, host, port, path, query, hash) {
+            return {
+                scheme,
+                user,
+                host,
+                port,
+                path,
+                query,
+                hash,
+                type: 7
+            };
+        }
+        function parseUrl(input) {
+            if (isSchemeRelativeUrl(input)) {
+                const url = parseAbsoluteUrl('http:' + input);
+                url.scheme = '';
+                url.type = 6;
+                return url;
+            }
+            if (isAbsolutePath(input)) {
+                const url = parseAbsoluteUrl('http://foo.com' + input);
+                url.scheme = '';
+                url.host = '';
+                url.type = 5;
+                return url;
+            }
+            if (isFileUrl(input)) return parseFileUrl(input);
+            if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+            const url = parseAbsoluteUrl('http://foo.com/' + input);
+            url.scheme = '';
+            url.host = '';
+            url.type = input ? input.startsWith('?') ? 3 : input.startsWith('#') ? 2 : 4 : 1;
+            return url;
+        }
+        function stripPathFilename(path) {
+            if (path.endsWith('/..')) return path;
+            const index = path.lastIndexOf('/');
+            return path.slice(0, index + 1);
+        }
+        function mergePaths(url, base) {
+            normalizePath(base, base.type);
+            if ('/' === url.path) url.path = base.path;
+            else url.path = stripPathFilename(base.path) + url.path;
+        }
+        function normalizePath(url, type) {
+            const rel = type <= 4;
+            const pieces = url.path.split('/');
+            let pointer = 1;
+            let positive = 0;
+            let addTrailingSlash = false;
+            for(let i = 1; i < pieces.length; i++){
+                const piece = pieces[i];
+                if (!piece) {
+                    addTrailingSlash = true;
+                    continue;
+                }
+                addTrailingSlash = false;
+                if ('.' !== piece) {
+                    if ('..' === piece) {
+                        if (positive) {
+                            addTrailingSlash = true;
+                            positive--;
+                            pointer--;
+                        } else if (rel) pieces[pointer++] = piece;
+                        continue;
+                    }
+                    pieces[pointer++] = piece;
+                    positive++;
+                }
+            }
+            let path = '';
+            for(let i = 1; i < pointer; i++)path += '/' + pieces[i];
+            if (!path || addTrailingSlash && !path.endsWith('/..')) path += '/';
+            url.path = path;
+        }
+        function resolve_uri_resolve(input, base) {
+            if (!input && !base) return '';
+            const url = parseUrl(input);
+            let inputType = url.type;
+            if (base && 7 !== inputType) {
+                const baseUrl = parseUrl(base);
+                const baseType = baseUrl.type;
+                switch(inputType){
+                    case 1:
+                        url.hash = baseUrl.hash;
+                    case 2:
+                        url.query = baseUrl.query;
+                    case 3:
+                    case 4:
+                        mergePaths(url, baseUrl);
+                    case 5:
+                        url.user = baseUrl.user;
+                        url.host = baseUrl.host;
+                        url.port = baseUrl.port;
+                    case 6:
+                        url.scheme = baseUrl.scheme;
+                }
+                if (baseType > inputType) inputType = baseType;
+            }
+            normalizePath(url, inputType);
+            const queryHash = url.query + url.hash;
+            switch(inputType){
+                case 2:
+                case 3:
+                    return queryHash;
+                case 4:
+                    {
+                        const path = url.path.slice(1);
+                        if (!path) return queryHash || '.';
+                        if (isRelative(base || input) && !isRelative(path)) return './' + path + queryHash;
+                        return path + queryHash;
+                    }
+                case 5:
+                    return url.path + queryHash;
+                default:
+                    return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+            }
+        }
+        function stripFilename(path) {
+            if (!path) return "";
+            const index = path.lastIndexOf("/");
+            return path.slice(0, index + 1);
+        }
+        function resolver(mapUrl, sourceRoot) {
+            const from = stripFilename(mapUrl);
+            const prefix = sourceRoot ? sourceRoot + "/" : "";
+            return (source)=>resolve_uri_resolve(prefix + (source || ""), from);
+        }
+        var COLUMN = 0;
+        var SOURCES_INDEX = 1;
+        var SOURCE_LINE = 2;
+        var SOURCE_COLUMN = 3;
+        var NAMES_INDEX = 4;
+        function maybeSort(mappings, owned) {
+            const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+            if (unsortedIndex === mappings.length) return mappings;
+            if (!owned) mappings = mappings.slice();
+            for(let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1))mappings[i] = sortSegments(mappings[i], owned);
+            return mappings;
+        }
+        function nextUnsortedSegmentLine(mappings, start) {
+            for(let i = start; i < mappings.length; i++)if (!isSorted(mappings[i])) return i;
+            return mappings.length;
+        }
+        function isSorted(line) {
+            for(let j = 1; j < line.length; j++)if (line[j][COLUMN] < line[j - 1][COLUMN]) return false;
+            return true;
+        }
+        function sortSegments(line, owned) {
+            if (!owned) line = line.slice();
+            return line.sort(trace_mapping_sortComparator);
+        }
+        function trace_mapping_sortComparator(a, b) {
+            return a[COLUMN] - b[COLUMN];
+        }
+        var found = false;
+        function binarySearch(haystack, needle, low, high) {
+            while(low <= high){
+                const mid = low + (high - low >> 1);
+                const cmp = haystack[mid][COLUMN] - needle;
+                if (0 === cmp) {
+                    found = true;
+                    return mid;
+                }
+                if (cmp < 0) low = mid + 1;
+                else high = mid - 1;
+            }
+            found = false;
+            return low - 1;
+        }
+        function upperBound(haystack, needle, index) {
+            for(let i = index + 1; i < haystack.length && haystack[i][COLUMN] === needle; index = i++);
+            return index;
+        }
+        function lowerBound(haystack, needle, index) {
+            for(let i = index - 1; i >= 0 && haystack[i][COLUMN] === needle; index = i--);
+            return index;
+        }
+        function memoizedState() {
+            return {
+                lastKey: -1,
+                lastNeedle: -1,
+                lastIndex: -1
+            };
+        }
+        function memoizedBinarySearch(haystack, needle, state, key) {
+            const { lastKey, lastNeedle, lastIndex } = state;
+            let low = 0;
+            let high = haystack.length - 1;
+            if (key === lastKey) {
+                if (needle === lastNeedle) {
+                    found = -1 !== lastIndex && haystack[lastIndex][COLUMN] === needle;
+                    return lastIndex;
+                }
+                if (needle >= lastNeedle) low = -1 === lastIndex ? 0 : lastIndex;
+                else high = lastIndex;
+            }
+            state.lastKey = key;
+            state.lastNeedle = needle;
+            return state.lastIndex = binarySearch(haystack, needle, low, high);
+        }
+        function parse(map) {
+            return "string" == typeof map ? JSON.parse(map) : map;
+        }
+        var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+        var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+        var LEAST_UPPER_BOUND = -1;
+        var GREATEST_LOWER_BOUND = 1;
+        var TraceMap = class {
+            constructor(map, mapUrl){
+                const isString = "string" == typeof map;
+                if (!isString && map._decodedMemo) return map;
+                const parsed = parse(map);
+                const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+                this.version = version;
+                this.file = file;
+                this.names = names || [];
+                this.sourceRoot = sourceRoot;
+                this.sources = sources;
+                this.sourcesContent = sourcesContent;
+                this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+                const resolve = resolver(mapUrl, sourceRoot);
+                this.resolvedSources = sources.map(resolve);
+                const { mappings } = parsed;
+                if ("string" == typeof mappings) {
+                    this._encoded = mappings;
+                    this._decoded = void 0;
+                } else if (Array.isArray(mappings)) {
+                    this._encoded = void 0;
+                    this._decoded = maybeSort(mappings, isString);
+                } else if (parsed.sections) throw new Error("TraceMap passed sectioned source map, please use FlattenMap export instead");
+                else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+                this._decodedMemo = memoizedState();
+                this._bySources = void 0;
+                this._bySourceMemos = void 0;
+            }
+        };
+        function cast(map) {
+            return map;
+        }
+        function decodedMappings(map) {
+            var _a;
+            return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+        }
+        function originalPositionFor(map, needle) {
+            let { line, column, bias } = needle;
+            line--;
+            if (line < 0) throw new Error(LINE_GTR_ZERO);
+            if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+            const decoded = decodedMappings(map);
+            if (line >= decoded.length) return OMapping(null, null, null, null);
+            const segments = decoded[line];
+            const index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
+            if (-1 === index) return OMapping(null, null, null, null);
+            const segment = segments[index];
+            if (1 === segment.length) return OMapping(null, null, null, null);
+            const { names, resolvedSources } = map;
+            return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], 5 === segment.length ? names[segment[NAMES_INDEX]] : null);
+        }
+        function OMapping(source, line, column, name) {
+            return {
+                source,
+                line,
+                column,
+                name
+            };
+        }
+        function traceSegmentInternal(segments, memo, line, column, bias) {
+            let index = memoizedBinarySearch(segments, column, memo, line);
+            if (found) index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+            else if (bias === LEAST_UPPER_BOUND) index++;
+            if (-1 === index || index === segments.length) return -1;
+            return index;
+        }
+        var stack_trace_parser_esm = __webpack_require__("../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js");
+        var utils = __webpack_require__("./src/utils/index.ts");
+        async function printError(error, getSourcemap, rootPath) {
+            const errorName = error.name || 'Unknown Error';
+            if (error.message.includes('Vitest failed to access its internal state')) {
+                const tips = [
+                    'Error: not support import `vitest` in Rstest test environment.\n',
+                    'Solution:',
+                    `  - Update your code to use imports from "${utils.yW.yellow('@rstest/core')}" instead of "${utils.yW.yellow('vitest')}".`,
+                    '  - Enable `globals` configuration and use global API.'
+                ];
+                utils.vF.log(`${utils.yW.red(tips.join('\n'))}\n`);
+                return;
+            }
+            if (error.message.includes('is not defined')) {
+                const [, varName] = error.message.match(/(.*) is not defined/) || [];
+                if (varName) {
+                    if (utils.TE.includes(varName)) error.message = error.message.replace(`${varName} is not defined`, `${varName} is not defined. Did you forget to enable "globals" configuration?`);
+                    else if ([
+                        'jest',
+                        'vitest'
+                    ].includes(varName)) error.message = error.message.replace(`${varName} is not defined`, `${varName} is not defined. Did you mean rstest?`);
+                }
+            }
+            utils.vF.log(`${utils.yW.red(utils.yW.bold(errorName))}${utils.yW.red(`: ${error.message}`)}\n`);
+            if (error.diff) {
+                utils.vF.log(error.diff);
+                utils.vF.log();
+            }
+            if (error.stack) {
+                const stackFrames = await parseErrorStacktrace({
+                    stack: error.stack,
+                    fullStack: error.fullStack,
+                    getSourcemap
+                });
+                if (!stackFrames.length && error.stack.length) utils.vF.log(utils.yW.gray("No error stack found, set 'DEBUG=rstest' to show fullStack."));
+                if (stackFrames[0]) await printCodeFrame(stackFrames[0]);
+                printStack(stackFrames, rootPath);
+            }
+        }
+        async function printCodeFrame(frame) {
+            const filePath = frame.file?.startsWith('file') ? new URL(frame.file) : frame.file;
+            if (!filePath) return;
+            const source = external_node_fs_["default"].existsSync(filePath) ? external_node_fs_["default"].readFileSync(filePath, 'utf-8') : void 0;
+            if (!source) return;
+            const { codeFrameColumns } = await __webpack_require__.e("171").then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/@babel+code-frame@7.27.1/node_modules/@babel/code-frame/lib/index.js"));
+            const result = codeFrameColumns(source, {
+                start: {
+                    line: frame.lineNumber,
+                    column: frame.column
+                }
+            }, {
+                highlightCode: true,
+                linesBelow: 2
+            });
+            utils.vF.log(result);
+            utils.vF.log('');
+        }
+        function formatStack(frame, rootPath) {
+            return '<unknown>' !== frame.methodName ? `at ${frame.methodName} (${(0, utils.XJ)(rootPath, frame.file)}:${frame.lineNumber}:${frame.column})` : `at ${(0, utils.XJ)(rootPath, frame.file)}:${frame.lineNumber}:${frame.column}`;
+        }
+        function printStack(stackFrames, rootPath) {
+            for (const frame of stackFrames)utils.vF.log(utils.yW.gray(`        ${formatStack(frame, rootPath)}`));
+            stackFrames.length && utils.vF.log();
+        }
+        const stackIgnores = [
+            /\/@rstest\/core/,
+            /rstest\/packages\/core\/dist/,
+            /node_modules\/tinypool/,
+            /node_modules\/chai/,
+            /node_modules\/@vitest\/expect/,
+            /node_modules\/@vitest\/snapshot/,
+            /node:\w+/,
+            /webpack\/runtime/,
+            /webpack\\runtime/,
+            '<anonymous>'
+        ];
+        async function parseErrorStacktrace({ stack, getSourcemap, fullStack = (0, utils._o)() }) {
+            const stackFrames = await Promise.all((0, stack_trace_parser_esm.q)(stack).filter((frame)=>fullStack ? true : frame.file && !stackIgnores.some((entry)=>frame.file?.match(entry))).map(async (frame)=>{
+                const sourcemap = await getSourcemap(frame.file);
+                if (sourcemap) {
+                    const traceMap = new TraceMap(sourcemap);
+                    const { line, column, source, name } = originalPositionFor(traceMap, {
+                        line: frame.lineNumber,
+                        column: frame.column
+                    });
+                    if (!source) return null;
+                    return {
+                        ...frame,
+                        file: source,
+                        lineNumber: line,
+                        name,
+                        column
+                    };
+                }
+                return frame;
+            })).then((frames)=>frames.filter((frame)=>null !== frame));
+            return stackFrames;
+        }
+    },
     "./src/utils/helper.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             C3: ()=>needFlagExperimentalDetectModule,
@@ -2297,7 +4113,7 @@ ${section.body}` : section.body).join("\n\n"));
         var pathe__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
         var picocolors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
         var picocolors__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(picocolors__WEBPACK_IMPORTED_MODULE_1__);
-        __webpack_require__("./src/utils/constants.ts");
+        var _constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/utils/constants.ts");
         const formatRootStr = (rootStr, root)=>rootStr.replace('<rootDir>', root);
         function getAbsolutePath(base, filepath) {
             return (0, pathe__WEBPACK_IMPORTED_MODULE_2__.i)(filepath) ? filepath : (0, pathe__WEBPACK_IMPORTED_MODULE_2__.j)(base, filepath);
@@ -2345,7 +4161,7 @@ ${section.body}` : section.body).join("\n\n"));
             return time;
         };
         const getTaskNames = (test)=>(test.parentNames || []).concat(test.name).filter(Boolean);
-        const getTaskNameWithPrefix = (test, delimiter = ">")=>getTaskNames(test).join(` ${delimiter} `);
+        const getTaskNameWithPrefix = (test, delimiter = _constants__WEBPACK_IMPORTED_MODULE_0__.vO)=>getTaskNames(test).join(` ${delimiter} `);
         const REGEXP_FLAG_PREFIX = 'RSTEST_REGEXP:';
         const wrapRegex = (value)=>`${REGEXP_FLAG_PREFIX}${value.toString()}`;
         const serializableConfig = (normalizedConfig)=>{
@@ -2391,7 +4207,7 @@ ${section.body}` : section.body).join("\n\n"));
             fN: ()=>helper.fN,
             vF: ()=>logger.vF,
             Ok: ()=>helper.Ok,
-            vO: ()=>">",
+            vO: ()=>constants.vO,
             tG: ()=>getTestEntries,
             FI: ()=>helper.FI,
             Uq: ()=>helper.Uq,
@@ -2528,15 +4344,16 @@ ${section.body}` : section.body).join("\n\n"));
             mT: ()=>clearScreen,
             vF: ()=>src_logger
         });
+        var external_node_process_ = __webpack_require__("node:process");
         var external_node_os_ = __webpack_require__("node:os");
         var external_node_tty_ = __webpack_require__("node:tty");
-        function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__["default"].argv) {
+        function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : external_node_process_["default"].argv) {
             const prefix = flag.startsWith('-') ? '' : 1 === flag.length ? '-' : '--';
             const position = argv.indexOf(prefix + flag);
             const terminatorPosition = argv.indexOf('--');
             return -1 !== position && (-1 === terminatorPosition || position < terminatorPosition);
         }
-        const { env } = __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__["default"];
+        const { env } = external_node_process_["default"];
         let flagForceColor;
         if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) flagForceColor = 0;
         else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) flagForceColor = 1;
@@ -2576,7 +4393,7 @@ ${section.body}` : section.body).join("\n\n"));
             if (haveStream && !streamIsTTY && void 0 === forceColor) return 0;
             const min = forceColor || 0;
             if ('dumb' === env.TERM) return min;
-            if ('win32' === __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__["default"].platform) {
+            if ('win32' === external_node_process_["default"].platform) {
                 const osRelease = external_node_os_["default"].release().split('.');
                 if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
                 return 1;
@@ -2826,6 +4643,9 @@ ${section.body}` : section.body).join("\n\n"));
     "node:path": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
     },
+    "node:process": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_process_786449bf__;
+    },
     "node:tty": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_node_tty_c64aab7e__;
     },
@@ -4161,19 +5981,9 @@ __webpack_require__.m = __webpack_modules__;
         }
     };
 })();
-var logger = __webpack_require__("./src/utils/logger.ts");
-var commands = __webpack_require__("./src/cli/commands.ts");
-var prepare = __webpack_require__("./src/cli/prepare.ts");
-async function runCLI() {
-    (0, prepare.k)();
-    try {
-        (0, commands.Q)();
-    } catch (err) {
-        logger.vF.error('Failed to start Rstest CLI.');
-        logger.vF.error(err);
-    }
-}
+var cli = __webpack_require__("./src/cli/index.ts");
 var src_config = __webpack_require__("./src/config.ts");
+var core = __webpack_require__("./src/core/index.ts");
 const check = (name)=>{
     if (!globalThis.RSTEST_API?.[name]) throw new Error(`Rstest API '${name}' is not registered yet, please make sure you are running in a rstest environment.`);
 };
@@ -4211,5 +6021,9 @@ const onTestFailed = wrapRstestAPI('onTestFailed');
 function defineConfig(config) {
     return config;
 }
+var __webpack_exports__createRstest = core.createRstest;
+var __webpack_exports__initCli = cli.X;
+var __webpack_exports__loadConfig = src_config.Z9;
 var __webpack_exports__mergeRstestConfig = src_config.ST;
-export { afterAll, afterEach, assert, beforeAll, beforeEach, defineConfig, describe, expect, it, onTestFailed, onTestFinished, rs, rstest, runCLI, test, __webpack_exports__mergeRstestConfig as mergeRstestConfig };
+var __webpack_exports__runCLI = cli.G;
+export { afterAll, afterEach, assert, beforeAll, beforeEach, defineConfig, describe, expect, it, onTestFailed, onTestFinished, rs, rstest, test, __webpack_exports__createRstest as createRstest, __webpack_exports__initCli as initCli, __webpack_exports__loadConfig as loadConfig, __webpack_exports__mergeRstestConfig as mergeRstestConfig, __webpack_exports__runCLI as runCLI };