@rstest/core 0.4.1 → 0.5.1

package/dist/0~655.js.LICENSE.txt

@@ -6,6 +6,270 @@
 	 * @license    MIT License
 	 */
 
+/*!
+ * Chai - addChainingMethod utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - addLengthGuard utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - addMethod utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - addProperty utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - compareByInspect utility
+ * Copyright(c) 2011-2016 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - expectTypes utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - flag utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - getActual utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - getOwnEnumerableProperties utility
+ * Copyright(c) 2011-2016 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - getOwnEnumerablePropertySymbols utility
+ * Copyright(c) 2011-2016 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - getProperties utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - isNaN utility
+ * Copyright(c) 2012-2015 Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - isProxyEnabled helper
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - message composition utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - overwriteChainableMethod utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - overwriteMethod utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - overwriteProperty utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - proxify utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - test utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * Chai - transferFlags utility
+ * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * chai
+ * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * chai
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*!
+ * chai
+ * http://chaijs.com
+ * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/*! Bundled license information:
+
+deep-eql/index.js:
+  (*!
+   * deep-eql
+   * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
+   * MIT Licensed
+   *)
+  (*!
+   * Check to see if the MemoizeMap has recorded a result of the two operands
+   *
+   * @param {Mixed} leftHandOperand
+   * @param {Mixed} rightHandOperand
+   * @param {MemoizeMap} memoizeMap
+   * @returns {Boolean|null} result
+  *)
+  (*!
+   * Set the result of the equality into the MemoizeMap
+   *
+   * @param {Mixed} leftHandOperand
+   * @param {Mixed} rightHandOperand
+   * @param {MemoizeMap} memoizeMap
+   * @param {Boolean} result
+  *)
+  (*!
+   * Primary Export
+   *)
+  (*!
+   * The main logic of the `deepEqual` function.
+   *
+   * @param {Mixed} leftHandOperand
+   * @param {Mixed} rightHandOperand
+   * @param {Object} [options] (optional) Additional options
+   * @param {Array} [options.comparator] (optional) Override default algorithm, determining custom equality.
+   * @param {Array} [options.memoize] (optional) Provide a custom memoization object which will cache the results of
+      complex objects for a speed boost. By passing `false` you can disable memoization, but this will cause circular
+      references to blow the stack.
+   * @return {Boolean} equal match
+  *)
+  (*!
+   * Compare two Regular Expressions for equality.
+   *
+   * @param {RegExp} leftHandOperand
+   * @param {RegExp} rightHandOperand
+   * @return {Boolean} result
+   *)
+  (*!
+   * Compare two Sets/Maps for equality. Faster than other equality functions.
+   *
+   * @param {Set} leftHandOperand
+   * @param {Set} rightHandOperand
+   * @param {Object} [options] (Optional)
+   * @return {Boolean} result
+   *)
+  (*!
+   * Simple equality for flat iterable objects such as Arrays, TypedArrays or Node.js buffers.
+   *
+   * @param {Iterable} leftHandOperand
+   * @param {Iterable} rightHandOperand
+   * @param {Object} [options] (Optional)
+   * @return {Boolean} result
+   *)
+  (*!
+   * Simple equality for generator objects such as those returned by generator functions.
+   *
+   * @param {Iterable} leftHandOperand
+   * @param {Iterable} rightHandOperand
+   * @param {Object} [options] (Optional)
+   * @return {Boolean} result
+   *)
+  (*!
+   * Determine if the given object has an @@iterator function.
+   *
+   * @param {Object} target
+   * @return {Boolean} `true` if the object has an @@iterator function.
+   *)
+  (*!
+   * Gets all iterator entries from the given Object. If the Object has no @@iterator function, returns an empty array.
+   * This will consume the iterator - which could have side effects depending on the @@iterator implementation.
+   *
+   * @param {Object} target
+   * @returns {Array} an array of entries from the @@iterator function
+   *)
+  (*!
+   * Gets all entries from a Generator. This will consume the generator - which could have side effects.
+   *
+   * @param {Generator} target
+   * @returns {Array} an array of entries from the Generator.
+   *)
+  (*!
+   * Gets all own and inherited enumerable keys from a target.
+   *
+   * @param {Object} target
+   * @returns {Array} an array of own and inherited enumerable keys from the target.
+   *)
+  (*!
+   * Determines if two objects have matching values, given a set of keys. Defers to deepEqual for the equality check of
+   * each key. If any value of the given key is not equal, the function will return false (early).
+   *
+   * @param {Mixed} leftHandOperand
+   * @param {Mixed} rightHandOperand
+   * @param {Array} keys An array of keys to compare the values of leftHandOperand and rightHandOperand against
+   * @param {Object} [options] (Optional)
+   * @return {Boolean} result
+   *)
+  (*!
+   * Recursively check the equality of two Objects. Once basic sameness has been established it will defer to `deepEqual`
+   * for each enumerable key in the object.
+   *
+   * @param {Mixed} leftHandOperand
+   * @param {Mixed} rightHandOperand
+   * @param {Object} [options] (Optional)
+   * @return {Boolean} result
+   *)
+  (*!
+   * Returns true if the argument is a primitive.
+   *
+   * This intentionally returns true for all objects that can be compared by reference,
+   * including functions and symbols.
+   *
+   * @param {Mixed} value
+   * @return {Boolean} result
+   *)
+*/
+
 /**
  * @license React
  * react-is.development.js

package/dist/0~691.js

@@ -9,26 +9,75 @@ export const __webpack_modules__ = {
         __webpack_require__.d(__webpack_exports__, {
             checkThresholds: ()=>checkThresholds
         });
+        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 picomatch__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
+        var picomatch__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/ __webpack_require__.n(picomatch__WEBPACK_IMPORTED_MODULE_1__);
         var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/utils/index.ts");
-        function checkThresholds(coverageMap, thresholds) {
+        const THRESHOLD_KEYS = [
+            'lines',
+            'functions',
+            'statements',
+            'branches'
+        ];
+        function checkThresholds({ coverageMap, thresholds, coverageProvider, rootPath }) {
             if (!thresholds) return {
                 success: true,
                 message: ''
             };
-            const summary = coverageMap.getCoverageSummary();
             const failedThresholds = [];
-            const check = (name, type, actual, expected)=>{
+            const allFiles = coverageMap.files();
+            const thresholdGroup = [
+                {
+                    statements: thresholds.statements,
+                    functions: thresholds.functions,
+                    branches: thresholds.branches,
+                    lines: thresholds.lines,
+                    name: 'global',
+                    coverageMap,
+                    perFile: false
+                }
+            ];
+            for (const key of Object.keys(thresholds)){
+                if (THRESHOLD_KEYS.includes(key) || 'object' != typeof thresholds[key]) continue;
+                const globCoverageMap = coverageProvider.createCoverageMap();
+                const matcher = picomatch__WEBPACK_IMPORTED_MODULE_1___default()(key);
+                const matchedFiles = allFiles.filter((file)=>matcher((0, pathe__WEBPACK_IMPORTED_MODULE_2__.b)(rootPath, file)));
+                if (!matchedFiles.length) {
+                    failedThresholds.push(`${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red('Error')}: coverage data for "${key}" was not found`);
+                    continue;
+                }
+                for (const file of matchedFiles){
+                    const fileCoverage = coverageMap.fileCoverageFor(file);
+                    globCoverageMap.addFileCoverage(fileCoverage);
+                }
+                thresholdGroup.push({
+                    ...thresholds[key],
+                    name: key,
+                    coverageMap: globCoverageMap
+                });
+            }
+            const check = (name, type, actual, expected, file)=>{
+                let errorMsg = '';
                 if (void 0 !== expected) {
                     if (expected < 0) {
                         const uncovered = actual.total - actual.covered;
-                        if (uncovered > -expected) failedThresholds.push(`${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red('Error')}: Uncovered ${name} ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red(`${uncovered}`)} exceeds maximum ${type} threshold allowed ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.yellow(`${-expected}`)}`);
-                    } else if (actual.pct < expected) failedThresholds.push(`${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red('Error')}: Coverage for ${name} ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red(`${actual.pct}%`)} does not meet ${type} threshold ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.yellow(`${expected}%`)}`);
+                        if (uncovered > -expected) errorMsg += `uncovered ${name} ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red(`${uncovered}`)} exceeds maximum ${'global' === type ? 'global' : `"${type}"`} threshold allowed ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.yellow(`${-expected}`)}`;
+                    } else if (actual.pct < expected) errorMsg += `coverage for ${name} ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red(`${actual.pct}%`)} does not meet ${'global' === type ? 'global' : `"${type}"`} threshold ${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.yellow(`${expected}%`)}`;
                 }
+                if (errorMsg) failedThresholds.push(`${_utils__WEBPACK_IMPORTED_MODULE_0__.yW.red('Error')}: ${file ? `${(0, pathe__WEBPACK_IMPORTED_MODULE_2__.b)(rootPath, file)} ` : ''}${errorMsg}`);
             };
-            check('statements', 'global', summary.statements, thresholds.statements);
-            check('functions', 'global', summary.functions, thresholds.functions);
-            check('branches', 'global', summary.branches, thresholds.branches);
-            check('lines', 'global', summary.lines, thresholds.lines);
+            thresholdGroup.forEach(({ name, coverageMap, ...thresholds })=>{
+                const summaries = thresholds.perFile ? coverageMap.files().map((file)=>({
+                        file,
+                        summary: coverageMap.fileCoverageFor(file).toSummary()
+                    })) : [
+                    {
+                        file: '',
+                        summary: coverageMap.getCoverageSummary()
+                    }
+                ];
+                for (const { summary, file } of summaries)for (const key of THRESHOLD_KEYS)if (void 0 !== thresholds[key]) check(key, name, summary[key], thresholds[key], file);
+            });
             return {
                 success: 0 === failedThresholds.length,
                 message: failedThresholds.join('\n')

package/dist/{0~938.js → 0~816.js}

@@ -2,13 +2,12 @@ import 'module';
 /*#__PURE__*/ import.meta.url;
 import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
 import * as __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__ from "node:v8";
-import * as __WEBPACK_EXTERNAL_MODULE_birpc__ from "birpc";
 import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
 import * as __WEBPACK_EXTERNAL_MODULE_tinypool__ from "tinypool";
 import * as __WEBPACK_EXTERNAL_MODULE_node_inspector_dd9822d6__ from "node:inspector";
-export const __webpack_id__ = "938";
+export const __webpack_id__ = "816";
 export const __webpack_ids__ = [
-    "938"
+    "816"
 ];
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -17,7 +16,7 @@ export const __webpack_modules__ = {
             zh: ()=>prepareRsbuild
         });
         var core_ = __webpack_require__("@rsbuild/core");
-        var external_pathe_ = __webpack_require__("pathe");
+        var dist = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs");
         var utils = __webpack_require__("./src/utils/index.ts");
         const RUNTIME_CHUNK_NAME = 'runtime';
         const pluginBasic = (context)=>({
@@ -35,7 +34,8 @@ export const __webpack_modules__ = {
                         }, {
                             source: {
                                 define: {
-                                    'import.meta.rstest': "global['@rstest/core']"
+                                    'import.meta.rstest': "global['@rstest/core']",
+                                    'import.meta.env': 'process.env'
                                 }
                             },
                             output: {
@@ -59,7 +59,7 @@ export const __webpack_modules__ = {
                                         injectModulePathName: true,
                                         importMetaPathName: true,
                                         hoistMockModule: true,
-                                        manualMockRoot: external_pathe_["default"].resolve(rootPath, '__mocks__')
+                                        manualMockRoot: dist.Ay.resolve(rootPath, '__mocks__')
                                     }));
                                     config.module.parser ??= {};
                                     config.module.parser.javascript = {
@@ -167,7 +167,7 @@ export const __webpack_modules__ = {
                             config.watchOptions ??= {};
                             config.watchOptions.ignored = (0, utils.bg)(config.watchOptions.ignored || []);
                             if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
-                            config.watchOptions.ignored.push(utils.EJ, '**/*.snap');
+                            config.watchOptions.ignored.push(utils.EJ, context.normalizedConfig.coverage.reportsDirectory, '**/*.snap');
                             const configFilePath = context.projects.find((project)=>project.environmentName === environment.name)?.configFilePath;
                             if (configFilePath) config.watchOptions.ignored.push(configFilePath);
                         } else {
@@ -183,6 +183,7 @@ export const __webpack_modules__ = {
                     });
                 }
             });
+        var external_node_module_ = __webpack_require__("node:module");
         const autoExternalNodeModules = ({ context, request, dependencyType, getResolve }, callback)=>{
             if (!request) return callback();
             if (request.startsWith('@swc/helpers/')) return callback();
@@ -199,7 +200,7 @@ export const __webpack_modules__ = {
         };
         function autoExternalNodeBuiltin({ request, dependencyType }, callback) {
             if (!request) return void callback();
-            const isNodeBuiltin = utils.Kv.some((builtin)=>{
+            const isNodeBuiltin = (0, external_node_module_.isBuiltin)(request) || utils.Uq.some((builtin)=>{
                 if ('string' == typeof builtin) return builtin === request;
                 return builtin.test(request);
             });
@@ -598,7 +599,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 const entries = Object.keys(manifest.entries);
                 for (const entry of entries){
                     const data = manifest.entries[entry];
-                    entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>external_pathe_["default"].join(outputPath, file));
+                    entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>dist.Ay.join(outputPath, file));
                 }
                 return entryFiles;
             };
@@ -622,7 +623,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 const sourceEntries = await globTestSourceEntries(environmentName);
                 for (const entry of Object.keys(entrypoints)){
                     const e = entrypoints[entry];
-                    const distPath = external_pathe_["default"].join(outputPath, e.assets[e.assets.length - 1].name);
+                    const distPath = dist.Ay.join(outputPath, e.assets[e.assets.length - 1].name);
                     if (setupFiles[environmentName][entry]) setupEntries.push({
                         distPath,
                         testPath: setupFiles[environmentName][entry],
@@ -641,7 +642,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 }
                 const inlineSourceMap = 'inline-source-map' === stats.compilation.options.devtool;
                 const sourceMaps = Object.fromEntries((await Promise.all(assets.map(async (asset)=>{
-                    const assetFilePath = external_pathe_["default"].join(outputPath, asset.name);
+                    const assetFilePath = dist.Ay.join(outputPath, asset.name);
                     if (inlineSourceMap) {
                         const content = await readFile(assetFilePath);
                         return [
@@ -651,7 +652,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     }
                     const sourceMapPath = asset?.info.related?.sourceMap?.[0];
                     if (sourceMapPath) {
-                        const filePath = external_pathe_["default"].join(outputPath, sourceMapPath);
+                        const filePath = dist.Ay.join(outputPath, sourceMapPath);
                         const sourceMap = await readFile(filePath);
                         return [
                             assetFilePath,
@@ -673,7 +674,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     setupEntries,
                     buildTime: buildTime,
                     assetFiles: Object.fromEntries(await Promise.all(assets.map(async (a)=>{
-                        const filePath = external_pathe_["default"].join(outputPath, a.name);
+                        const filePath = dist.Ay.join(outputPath, a.name);
                         return [
                             filePath,
                             await readFile(filePath)
@@ -696,9 +697,171 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
         var external_node_os_ = __webpack_require__("node:os");
         var utils = __webpack_require__("./src/utils/index.ts");
         var external_node_url_ = __webpack_require__("node:url");
-        var external_pathe_ = __webpack_require__("pathe");
+        const TYPE_REQUEST = "q";
+        const TYPE_RESPONSE = "s";
+        const DEFAULT_TIMEOUT = 6e4;
+        function defaultSerialize(i) {
+            return i;
+        }
+        const defaultDeserialize = defaultSerialize;
+        const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+        const random = Math.random.bind(Math);
+        function createBirpc(functions, options) {
+            const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT } = options;
+            const rpcPromiseMap = /* @__PURE__ */ new Map();
+            let _promise;
+            let closed = false;
+            const rpc = new Proxy({}, {
+                get (_, method) {
+                    if ("$functions" === method) return functions;
+                    if ("$close" === method) return close;
+                    if ("$rejectPendingCalls" === method) return rejectPendingCalls;
+                    if ("$closed" === method) return closed;
+                    if ("then" === method && !eventNames.includes("then") && !("then" in functions)) return;
+                    const sendEvent = (...args)=>{
+                        post(serialize({
+                            m: method,
+                            a: args,
+                            t: TYPE_REQUEST
+                        }));
+                    };
+                    if (eventNames.includes(method)) {
+                        sendEvent.asEvent = sendEvent;
+                        return sendEvent;
+                    }
+                    const sendCall = async (...args)=>{
+                        if (closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+                        if (_promise) try {
+                            await _promise;
+                        } finally{
+                            _promise = void 0;
+                        }
+                        return new Promise((resolve, reject)=>{
+                            const id = nanoid();
+                            let timeoutId;
+                            if (timeout >= 0) {
+                                timeoutId = dist_setTimeout(()=>{
+                                    try {
+                                        const handleResult = options.onTimeoutError?.(method, args);
+                                        if (true !== handleResult) throw new Error(`[birpc] timeout on calling "${method}"`);
+                                    } catch (e) {
+                                        reject(e);
+                                    }
+                                    rpcPromiseMap.delete(id);
+                                }, timeout);
+                                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+                            }
+                            rpcPromiseMap.set(id, {
+                                resolve,
+                                reject,
+                                timeoutId,
+                                method
+                            });
+                            post(serialize({
+                                m: method,
+                                a: args,
+                                i: id,
+                                t: "q"
+                            }));
+                        });
+                    };
+                    sendCall.asEvent = sendEvent;
+                    return sendCall;
+                }
+            });
+            function close(customError) {
+                closed = true;
+                rpcPromiseMap.forEach(({ reject, method })=>{
+                    const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+                    if (customError) {
+                        customError.cause ??= error;
+                        return reject(customError);
+                    }
+                    reject(error);
+                });
+                rpcPromiseMap.clear();
+                off(onMessage);
+            }
+            function rejectPendingCalls(handler) {
+                const entries = Array.from(rpcPromiseMap.values());
+                const handlerResults = entries.map(({ method, reject })=>{
+                    if (!handler) return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+                    return handler({
+                        method,
+                        reject
+                    });
+                });
+                rpcPromiseMap.clear();
+                return handlerResults;
+            }
+            async function onMessage(data, ...extra) {
+                let msg;
+                try {
+                    msg = deserialize(data);
+                } catch (e) {
+                    if (options.onGeneralError?.(e) !== true) throw e;
+                    return;
+                }
+                if (msg.t === TYPE_REQUEST) {
+                    const { m: method, a: args } = msg;
+                    let result, error;
+                    const fn = resolver ? resolver(method, functions[method]) : functions[method];
+                    if (fn) try {
+                        result = await fn.apply("rpc" === bind ? rpc : functions, args);
+                    } catch (e) {
+                        error = e;
+                    }
+                    else error = new Error(`[birpc] function "${method}" not found`);
+                    if (msg.i) {
+                        if (error && options.onError) options.onError(error, method, args);
+                        if (error && options.onFunctionError) {
+                            if (true === options.onFunctionError(error, method, args)) return;
+                        }
+                        if (!error) try {
+                            post(serialize({
+                                t: TYPE_RESPONSE,
+                                i: msg.i,
+                                r: result
+                            }), ...extra);
+                            return;
+                        } catch (e) {
+                            error = e;
+                            if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                        }
+                        try {
+                            post(serialize({
+                                t: TYPE_RESPONSE,
+                                i: msg.i,
+                                e: error
+                            }), ...extra);
+                        } catch (e) {
+                            if (options.onGeneralError?.(e, method, args) !== true) throw e;
+                        }
+                    }
+                } else {
+                    const { i: ack, r: result, e: error } = msg;
+                    const promise = rpcPromiseMap.get(ack);
+                    if (promise) {
+                        dist_clearTimeout(promise.timeoutId);
+                        if (error) promise.reject(error);
+                        else promise.resolve(result);
+                    }
+                    rpcPromiseMap.delete(ack);
+                }
+            }
+            _promise = on(onMessage);
+            return rpc;
+        }
+        const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+        function nanoid(size = 21) {
+            let id = "";
+            let i = size;
+            while(i--)id += urlAlphabet[64 * random() | 0];
+            return id;
+        }
+        var pathe_M_eThtNZ = __webpack_require__("../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs");
         const forks_filename = (0, external_node_url_.fileURLToPath)(import.meta.url);
-        const forks_dirname = (0, external_pathe_.dirname)(forks_filename);
+        const forks_dirname = (0, pathe_M_eThtNZ.d)(forks_filename);
         function createChannel(rpcMethods) {
             const emitter = new __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__["default"]();
             const cleanup = ()=>emitter.removeAllListeners();
@@ -714,7 +877,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     emitter.emit(events.response, message);
                 }
             };
-            (0, __WEBPACK_EXTERNAL_MODULE_birpc__.createBirpc)(rpcMethods, {
+            createBirpc(rpcMethods, {
                 serialize: __WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__["default"].serialize,
                 deserialize: (v)=>__WEBPACK_EXTERNAL_MODULE_node_v8_d0df5498__["default"].deserialize(Buffer.from(v)),
                 post (v) {
@@ -733,7 +896,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             const { maxWorkers: maxThreads, minWorkers: minThreads, env, execArgv = [], isolate = true } = poolOptions;
             const options = {
                 runtime: 'child_process',
-                filename: (0, external_pathe_.resolve)(forks_dirname, './worker.js'),
+                filename: (0, pathe_M_eThtNZ.r)(forks_dirname, './worker.js'),
                 env,
                 execArgv,
                 maxThreads,
@@ -778,7 +941,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             return parsed > 0 ? parsed : 1;
         };
         const getRuntimeConfig = (context)=>{
-            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage } = context.normalizedConfig;
+            const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat } = context.normalizedConfig;
             return {
                 testNamePattern,
                 testTimeout,
@@ -796,7 +959,8 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 disableConsoleIntercept,
                 testEnvironment,
                 isolate,
-                coverage
+                coverage,
+                snapshotFormat
             };
         };
         const filterAssetsByEntry = (entryInfo, assetFiles, setupAssets, sourceMaps, entryLength)=>{