vitest 2.1.3 → 2.1.5

package/dist/chunks/{config.Crbj2GAb.d.ts → config.Cy0C388Z.d.ts}

@@ -200,7 +200,6 @@ interface SerializedCoverageConfig {
 }
 type RuntimeConfig = Pick<SerializedConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency' | 'expect' | 'printConsoleTrace'> & {
     sequence?: {
-        concurrent?: boolean;
         hooks?: SequenceHooks;
     };
 };

package/dist/chunks/{console.CfT1Wjed.js → console.BYGVloWk.js}

@@ -1,14 +1,10 @@
-import { Writable } from 'node:stream';
 import { Console } from 'node:console';
 import { relative } from 'node:path';
+import { Writable } from 'node:stream';
 import { getSafeTimers } from '@vitest/utils';
 import c from 'tinyrainbow';
 import { R as RealDate } from './date.W2xKR2qe.js';
-import 'pathe';
-import '@vitest/runner/utils';
-import { g as getWorkerState } from './utils.Ck2hJTRs.js';
-import './env.CmHVDJnw.js';
-import 'std-env';
+import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 const UNKNOWN_TEST_ID = "__vitest__unknown_test__";
 function getTaskIdByStack(root) {

package/dist/chunks/{coverage.zlNdAMHK.js → coverage.BoMDb1ip.js}

@@ -65,4 +65,4 @@ async function stopCoverageInsideWorker(options, loader) {
   return null;
 }
 
-export { CoverageProviderMap as C, startCoverageInsideWorker as a, getCoverageProvider as g, stopCoverageInsideWorker as s, takeCoverageInsideWorker as t };
+export { CoverageProviderMap as C, stopCoverageInsideWorker as a, getCoverageProvider as g, startCoverageInsideWorker as s, takeCoverageInsideWorker as t };

package/dist/chunks/{creator.CBPphXqR.js → creator.IIqd8RWT.js}

@@ -1,19 +1,19 @@
-import { resolve, dirname, relative } from 'node:path';
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { p as prompt, f as findUp } from './index.X0nbfr6-.js';
-import c from 'tinyrainbow';
-import { detectPackageManager, installPackage } from './index.CPD77dLA.js';
+import { resolve, dirname, relative } from 'node:path';
+import { detectPackageManager, installPackage } from './index.CqYx2Nsr.js';
+import { p as prompt, f as findUp } from './index.BJDntFik.js';
 import { x } from 'tinyexec';
+import c from 'tinyrainbow';
 import { c as configFiles } from './constants.fzPh7AOq.js';
-import 'node:url';
+import 'process';
 import 'node:process';
+import 'fs';
+import 'path';
+import 'node:url';
 import './_commonjsHelpers.BFTU3MAI.js';
 import 'readline';
 import 'events';
-import 'process';
-import 'fs';
-import 'path';
 
 const jsxExample = {
   name: "HelloWorld.jsx",

package/dist/chunks/{execute._eQQfgI8.js → execute.2pr0rHgK.js}

@@ -1,14 +1,15 @@
-import vm from 'node:vm';
-import { pathToFileURL } from 'node:url';
 import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { processError } from '@vitest/utils/error';
+import { normalize as normalize$1, relative } from 'pathe';
 import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
 import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, toFilePath, isPrimitive } from 'vite-node/utils';
-import { resolve as resolve$1, isAbsolute as isAbsolute$1, normalize as normalize$1, relative } from 'pathe';
-import { processError } from '@vitest/utils/error';
 import { distDir } from '../path.js';
-import { highlight } from '@vitest/utils';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
 import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
 import { builtinModules } from 'node:module';
+import { highlight } from '@vitest/utils';
 
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -548,6 +549,7 @@ function getMockType(factoryOrOptions) {
   return factoryOrOptions.spy ? "autospy" : "automock";
 }
 
+const normalizedDistDir = normalize$1(distDir);
 const { readFileSync } = fs;
 async function createVitestExecutor(options) {
   const runner = new VitestExecutor(options);
@@ -606,7 +608,7 @@ async function startVitestExecutor(options) {
       if (externalizeMap.has(id)) {
         return { externalize: externalizeMap.get(id) };
       }
-      if (id.includes(distDir)) {
+      if (id.includes(distDir) || id.includes(normalizedDistDir)) {
         const { path } = toFilePath(id, state().config.root);
         const externalize = pathToFileURL(path).toString();
         externalizeMap.set(id, externalize);

package/dist/chunks/{globals.Bdzt04Qm.js → globals.D8ZVAdXd.js}

@@ -1,26 +1,21 @@
 import { g as globalApis } from './constants.fzPh7AOq.js';
-import { V as VitestIndex } from './index.-d_XpZEA.js';
+import { V as VitestIndex } from './index.ckWaX2gY.js';
+import './vi.DgezovHB.js';
+import '@vitest/expect';
 import '@vitest/runner';
-import './benchmark.C8CRJYG4.js';
 import '@vitest/runner/utils';
-import '@vitest/utils';
-import './index.CxRxs566.js';
-import 'pathe';
-import './utils.Ck2hJTRs.js';
-import './env.CmHVDJnw.js';
-import 'std-env';
-import './run-once.Sxe67Wng.js';
-import './vi.BskyZC5g.js';
 import 'chai';
+import './utils.C8RiOc4B.js';
+import '@vitest/utils';
 import './_commonjsHelpers.BFTU3MAI.js';
-import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './tasks.BZnCS9aT.js';
 import '@vitest/utils/source-map';
-import './base.DwXGwWst.js';
 import './date.W2xKR2qe.js';
 import '@vitest/spy';
+import './run-once.2ogXb3JV.js';
+import './benchmark.Cdu9hjj4.js';
+import 'expect-type';
 
 function registerApiGlobally() {
   globalApis.forEach((api) => {

package/dist/chunks/{index.BpSiYbpB.js → index.68735LiX.js}

@@ -9,18 +9,24 @@ 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 (method === "$functions")
         return functions;
+      if (method === "$close")
+        return close;
       if (method === "then" && !eventNames.includes("then") && !("then" in functions))
         return void 0;
       const sendEvent = (...args) => {
@@ -31,7 +37,15 @@ function createBirpc(functions, options) {
         return sendEvent;
       }
       const sendCall = async (...args) => {
-        await _promise;
+        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;
@@ -48,7 +62,7 @@ function createBirpc(functions, options) {
             if (typeof timeoutId === "object")
               timeoutId = timeoutId.unref?.();
           }
-          rpcPromiseMap.set(id, { resolve, reject, timeoutId });
+          rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
           post(serialize({ m: method, a: args, i: id, t: "q" }));
         });
       };
@@ -56,7 +70,15 @@ function createBirpc(functions, options) {
       return sendCall;
     }
   });
-  _promise = on(async (data, ...extra) => {
+  function close() {
+    closed = true;
+    rpcPromiseMap.forEach(({ reject, method }) => {
+      reject(new Error(`[birpc] rpc is closed, cannot call "${method}"`));
+    });
+    rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  async function onMessage(data, ...extra) {
     const msg = deserialize(data);
     if (msg.t === "q") {
       const { m: method, a: args } = msg;
@@ -66,7 +88,7 @@ function createBirpc(functions, options) {
         error = new Error(`[birpc] function "${method}" not found`);
       } else {
         try {
-          result = await fn.apply(rpc, args);
+          result = await fn.apply(bind === "rpc" ? rpc : functions, args);
         } catch (e) {
           error = e;
         }
@@ -88,7 +110,8 @@ function createBirpc(functions, options) {
       }
       rpcPromiseMap.delete(ack);
     }
-  });
+  }
+  _promise = on(onMessage);
   return rpc;
 }
 const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";

package/dist/chunks/{index.X0nbfr6-.js → index.BJDntFik.js}

@@ -1,4 +1,4 @@
-import path from 'node:path';
+import a from 'node:path';
 import { fileURLToPath } from 'node:url';
 import process$1 from 'node:process';
 import { promises } from 'node:fs';
@@ -237,7 +237,7 @@ async function locatePath(
 
 	return pLocate(paths, async path_ => {
 		try {
-			const stat = await statFunction(path.resolve(cwd, path_));
+			const stat = await statFunction(a.resolve(cwd, path_));
 			return matchType(type, stat);
 		} catch {
 			return false;
@@ -250,9 +250,9 @@ const toPath = urlOrPath => urlOrPath instanceof URL ? fileURLToPath(urlOrPath)
 const findUpStop = Symbol('findUpStop');
 
 async function findUpMultiple(name, options = {}) {
-	let directory = path.resolve(toPath(options.cwd) || '');
-	const {root} = path.parse(directory);
-	const stopAt = path.resolve(directory, options.stopAt || root);
+	let directory = a.resolve(toPath(options.cwd) || '');
+	const {root} = a.parse(directory);
+	const stopAt = a.resolve(directory, options.stopAt || root);
 	const limit = options.limit || Number.POSITIVE_INFINITY;
 	const paths = [name].flat();
 
@@ -280,14 +280,14 @@ async function findUpMultiple(name, options = {}) {
 		}
 
 		if (foundPath) {
-			matches.push(path.resolve(directory, foundPath));
+			matches.push(a.resolve(directory, foundPath));
 		}
 
 		if (directory === stopAt || matches.length >= limit) {
 			break;
 		}
 
-		directory = path.dirname(directory);
+		directory = a.dirname(directory);
 	}
 
 	return matches;

package/dist/chunks/{index.CPD77dLA.js → index.CqYx2Nsr.js}

@@ -1,7 +1,7 @@
 import process$1 from 'process';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
-import path from 'node:path';
+import a from 'node:path';
 import process from 'node:process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
@@ -26,27 +26,27 @@ const LOCKS = {
 async function detect({ cwd, onUnknown } = {}) {
   for (const directory of lookup(cwd)) {
     for (const lock of Object.keys(LOCKS)) {
-      if (await fileExists(path.join(directory, lock))) {
+      if (await fileExists(a.join(directory, lock))) {
         const name = LOCKS[lock];
-        const result2 = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+        const result2 = await parsePackageJson(a.join(directory, "package.json"), onUnknown);
         if (result2)
           return result2;
         else
           return { name, agent: name };
       }
     }
-    const result = await parsePackageJson(path.join(directory, "package.json"), onUnknown);
+    const result = await parsePackageJson(a.join(directory, "package.json"), onUnknown);
     if (result)
       return result;
   }
   return null;
 }
 function* lookup(cwd = process.cwd()) {
-  let directory = path.resolve(cwd);
-  const { root } = path.parse(directory);
+  let directory = a.resolve(cwd);
+  const { root } = a.parse(directory);
   while (directory && directory !== root) {
     yield directory;
-    directory = path.dirname(directory);
+    directory = a.dirname(directory);
   }
 }
 async function parsePackageJson(filepath, onUnknown) {