vitest 3.0.6 → 3.0.8

package/dist/browser.d.ts

@@ -1,9 +1,10 @@
-import { b as CoverageModuleLoader, c as CoverageProvider } from './chunks/reporters.DTtkbAtP.js';
-import { a as SerializedCoverageConfig, S as SerializedConfig } from './chunks/config.BRtC-JeT.js';
-import * as spy$1 from '@vitest/spy';
+import { b as CoverageModuleLoader, c as CoverageProvider } from './chunks/reporters.66aFHiyX.js';
+import { S as SerializedCoverageConfig, a as SerializedConfig } from './chunks/config.BCv-fVdT.js';
 import { SerializedDiffOptions } from '@vitest/utils/diff';
 import { VitestExecutor } from './execute.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
+import * as spy from '@vitest/spy';
+export { spy as SpyModule };
 import './chunks/environment.d8YfPkTm.js';
 import '@vitest/utils';
 import 'node:stream';
@@ -20,30 +21,11 @@ import '@vitest/snapshot/manager';
 import 'node:fs';
 import '@vitest/snapshot/environment';
 import 'vite-node/client';
-import './chunks/worker.DaAIyCKm.js';
+import './chunks/worker.BmVno_ab.js';
 import 'node:vm';
 import '@vitest/mocker';
 import './chunks/mocker.cRtM890J.js';
 
-function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
-
-var spy = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null
-}, [spy$1]);
-
 declare function getCoverageProvider(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader): Promise<CoverageProvider | null>;
 declare function startCoverageInsideWorker(options: SerializedCoverageConfig | undefined, loader: CoverageModuleLoader, runtimeOptions: {
     isolate: boolean;
@@ -57,4 +39,4 @@ declare function setupCommonEnv(config: SerializedConfig): Promise<void>;
 declare function loadDiffConfig(config: SerializedConfig, executor: VitestExecutor): Promise<SerializedDiffOptions | undefined>;
 declare function loadSnapshotSerializers(config: SerializedConfig, executor: VitestExecutor): Promise<void>;
 
-export { spy as SpyModule, getCoverageProvider, loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };
+export { getCoverageProvider, loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, takeCoverageInsideWorker };

package/dist/browser.js

@@ -1,8 +1,8 @@
 export { g as getCoverageProvider, s as startCoverageInsideWorker, a as stopCoverageInsideWorker, t as takeCoverageInsideWorker } from './chunks/coverage.DnNIv-kJ.js';
-export { s as SpyModule } from './chunks/spy.Cf_4R5Oe.js';
-export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv } from './chunks/setup-common.IrcyRZ8C.js';
+export { l as loadDiffConfig, a as loadSnapshotSerializers, s as setupCommonEnv } from './chunks/setup-common.Uaw6Zgv9.js';
 export { collectTests, processError, startTests } from '@vitest/runner';
-import '@vitest/spy';
+import * as spy from '@vitest/spy';
+export { spy as SpyModule };
 import '@vitest/snapshot';
 import '@vitest/utils';
 import './chunks/run-once.2ogXb3JV.js';

package/dist/chunks/{base.B2NLWv2w.js → base.XvKTsMeK.js}

@@ -1,5 +1,5 @@
 import { ModuleCacheMap } from 'vite-node/client';
-import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.DNQad00_.js';
+import { g as getDefaultRequestStubs, s as startVitestExecutor } from './execute.eDH0aFFd.js';
 import { p as provideWorkerState } from './utils.C8RiOc4B.js';
 
 let _viteNode;
@@ -28,7 +28,7 @@ async function runBaseTests(method, state) {
   ));
   const [executor, { run }] = await Promise.all([
     startViteNode({ state, requestStubs: getDefaultRequestStubs() }),
-    import('./runBaseTests.Cr-AyqFv.js')
+    import('./runBaseTests.DnaAUBKD.js')
   ]);
   const fileSpecs = ctx.files.map(
     (f) => typeof f === "string" ? { filepath: f, testLocations: void 0 } : f

package/dist/chunks/{cac.mNJBJcT7.js → cac.VN5q-TPC.js}

@@ -618,7 +618,7 @@ class CAC extends EventEmitter {
 
 const cac = (name = "") => new CAC(name);
 
-var version = "3.0.6";
+var version = "3.0.8";
 
 const apiConfig = (port) => ({
   port: {
@@ -1398,6 +1398,7 @@ function addCommand(cli, name, option) {
         `Expected a single value for option "${command}", received [${received}]`
       );
     }
+    value = removeQuotes(value);
     if (option.transform) {
       return option.transform(value);
     }
@@ -1502,8 +1503,31 @@ function createCLI(options = {}) {
   cli.command("[...filters]", void 0, options).action((filters, options2) => start("test", filters, options2));
   return cli;
 }
+function removeQuotes(str) {
+  if (typeof str !== "string") {
+    if (Array.isArray(str)) {
+      return str.map(removeQuotes);
+    }
+    return str;
+  }
+  if (str.startsWith('"') && str.endsWith('"')) {
+    return str.slice(1, -1);
+  }
+  if (str.startsWith(`'`) && str.endsWith(`'`)) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+function splitArgv(argv) {
+  const reg = /(['"])(?:(?!\1).)+\1/g;
+  argv = argv.replace(reg, (match) => match.replace(/\s/g, "\0"));
+  return argv.split(" ").map((arg) => {
+    arg = arg.replace(/\0/g, " ");
+    return removeQuotes(arg);
+  });
+}
 function parseCLI(argv, config = {}) {
-  const arrayArgs = typeof argv === "string" ? argv.split(" ") : argv;
+  const arrayArgs = typeof argv === "string" ? splitArgv(argv) : argv;
   if (arrayArgs[0] !== "vitest") {
     throw new Error(`Expected "vitest" as the first argument, received "${arrayArgs[0]}"`);
   }
@@ -1567,7 +1591,7 @@ async function start(mode, cliFilters, options) {
   } catch {
   }
   try {
-    const { startVitest } = await import('./cli-api.Dkt_XoKq.js').then(function (n) { return n.f; });
+    const { startVitest } = await import('./cli-api.Dis64jtY.js').then(function (n) { return n.f; });
     const ctx = await startVitest(mode, cliFilters.map(normalize), normalizeCliOptions(cliFilters, options));
     if (!ctx.shouldKeepServer()) {
       await ctx.exit();
@@ -1598,7 +1622,7 @@ async function collect(mode, cliFilters, options) {
   } catch {
   }
   try {
-    const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Dkt_XoKq.js').then(function (n) { return n.f; });
+    const { prepareVitest, processCollected, outputFileList } = await import('./cli-api.Dis64jtY.js').then(function (n) { return n.f; });
     const ctx = await prepareVitest(mode, {
       ...normalizeCliOptions(cliFilters, options),
       watch: false,

package/dist/chunks/{cli-api.Dkt_XoKq.js → cli-api.Dis64jtY.js}

@@ -11,24 +11,24 @@ import { generateFileHash, createFileTask, limitConcurrency, hasFailed, getTasks
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.mNJBJcT7.js';
+import { v as version$1 } from './cac.VN5q-TPC.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.C1f-_gvH.js';
-import require$$0 from 'stream';
-import require$$0$1 from 'zlib';
-import require$$0$2 from 'buffer';
-import require$$1 from 'crypto';
+import { p as parse, s as stringify, g as printError, h as generateCodeFrame, b as BenchmarkReportsMap, R as ReportersMap, i as BlobReporter, r as readBlobs, H as HangingProcessReporter } from './index.B7vJpkTD.js';
 import require$$0$3 from 'events';
 import require$$1$1 from 'https';
 import require$$2 from 'http';
 import require$$3 from 'net';
 import require$$4 from 'tls';
+import require$$1 from 'crypto';
+import require$$0$2 from 'stream';
 import require$$7 from 'url';
+import require$$0 from 'zlib';
+import require$$0$1 from 'buffer';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.js';
 import { parseErrorStacktrace } from '@vitest/utils/source-map';
 import crypto from 'node:crypto';
 import { distDir, rootDir } from '../path.js';
-import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, e as configDefaults, g as getFilePoolName, f as isBrowserEnabled, m as mm, a as resolveConfig, j as groupBy, w as wildcardPatternToRegExp, k as createPool, b as resolveApiServerConfig, s as stdout } from './resolveConfig.BbcK25zb.js';
+import { R as RandomSequencer, i as isPackageExists, h as hash, V as VitestCache, e as configDefaults, g as getFilePoolName, f as isBrowserEnabled, m as mm, a as resolveConfig, j as groupBy, w as wildcardPatternToRegExp, k as createPool, b as resolveApiServerConfig, s as stdout } from './resolveConfig.L1_HR0_0.js';
 import { i as isTTY, b as isWindows, c as convertTasksToEvents } from './typechecker.cZ0LjdSi.js';
 import { Console } from 'node:console';
 import c from 'tinyrainbow';
@@ -47,175 +47,6 @@ import { serializeError } from '@vitest/utils/error';
 import readline from 'node:readline';
 import { stripVTControlCharacters } from 'node:util';
 
-var stream;
-var hasRequiredStream;
-
-function requireStream () {
-	if (hasRequiredStream) return stream;
-	hasRequiredStream = 1;
-
-	const { Duplex } = require$$0;
-
-	/**
-	 * Emits the `'close'` event on a stream.
-	 *
-	 * @param {Duplex} stream The stream.
-	 * @private
-	 */
-	function emitClose(stream) {
-	  stream.emit('close');
-	}
-
-	/**
-	 * The listener of the `'end'` event.
-	 *
-	 * @private
-	 */
-	function duplexOnEnd() {
-	  if (!this.destroyed && this._writableState.finished) {
-	    this.destroy();
-	  }
-	}
-
-	/**
-	 * The listener of the `'error'` event.
-	 *
-	 * @param {Error} err The error
-	 * @private
-	 */
-	function duplexOnError(err) {
-	  this.removeListener('error', duplexOnError);
-	  this.destroy();
-	  if (this.listenerCount('error') === 0) {
-	    // Do not suppress the throwing behavior.
-	    this.emit('error', err);
-	  }
-	}
-
-	/**
-	 * Wraps a `WebSocket` in a duplex stream.
-	 *
-	 * @param {WebSocket} ws The `WebSocket` to wrap
-	 * @param {Object} [options] The options for the `Duplex` constructor
-	 * @return {Duplex} The duplex stream
-	 * @public
-	 */
-	function createWebSocketStream(ws, options) {
-	  let terminateOnDestroy = true;
-
-	  const duplex = new Duplex({
-	    ...options,
-	    autoDestroy: false,
-	    emitClose: false,
-	    objectMode: false,
-	    writableObjectMode: false
-	  });
-
-	  ws.on('message', function message(msg, isBinary) {
-	    const data =
-	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
-
-	    if (!duplex.push(data)) ws.pause();
-	  });
-
-	  ws.once('error', function error(err) {
-	    if (duplex.destroyed) return;
-
-	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
-	    //
-	    // - If the `'error'` event is emitted before the `'open'` event, then
-	    //   `ws.terminate()` is a noop as no socket is assigned.
-	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
-	    //   event of the `Receiver` object. The listener already closes the
-	    //   connection by calling `ws.close()`. This allows a close frame to be
-	    //   sent to the other peer. If `ws.terminate()` is called right after this,
-	    //   then the close frame might not be sent.
-	    terminateOnDestroy = false;
-	    duplex.destroy(err);
-	  });
-
-	  ws.once('close', function close() {
-	    if (duplex.destroyed) return;
-
-	    duplex.push(null);
-	  });
-
-	  duplex._destroy = function (err, callback) {
-	    if (ws.readyState === ws.CLOSED) {
-	      callback(err);
-	      process.nextTick(emitClose, duplex);
-	      return;
-	    }
-
-	    let called = false;
-
-	    ws.once('error', function error(err) {
-	      called = true;
-	      callback(err);
-	    });
-
-	    ws.once('close', function close() {
-	      if (!called) callback(err);
-	      process.nextTick(emitClose, duplex);
-	    });
-
-	    if (terminateOnDestroy) ws.terminate();
-	  };
-
-	  duplex._final = function (callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._final(callback);
-	      });
-	      return;
-	    }
-
-	    // If the value of the `_socket` property is `null` it means that `ws` is a
-	    // client websocket and the handshake failed. In fact, when this happens, a
-	    // socket is never assigned to the websocket. Wait for the `'error'` event
-	    // that will be emitted by the websocket.
-	    if (ws._socket === null) return;
-
-	    if (ws._socket._writableState.finished) {
-	      callback();
-	      if (duplex._readableState.endEmitted) duplex.destroy();
-	    } else {
-	      ws._socket.once('finish', function finish() {
-	        // `duplex` is not destroyed here because the `'end'` event will be
-	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
-	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
-	        callback();
-	      });
-	      ws.close();
-	    }
-	  };
-
-	  duplex._read = function () {
-	    if (ws.isPaused) ws.resume();
-	  };
-
-	  duplex._write = function (chunk, encoding, callback) {
-	    if (ws.readyState === ws.CONNECTING) {
-	      ws.once('open', function open() {
-	        duplex._write(chunk, encoding, callback);
-	      });
-	      return;
-	    }
-
-	    ws.send(chunk, callback);
-	  };
-
-	  duplex.on('end', duplexOnEnd);
-	  duplex.on('error', duplexOnError);
-	  return duplex;
-	}
-
-	stream = createWebSocketStream;
-	return stream;
-}
-
-requireStream();
-
 var bufferUtil = {exports: {}};
 
 var constants$1;
@@ -452,7 +283,7 @@ function requirePermessageDeflate () {
 	if (hasRequiredPermessageDeflate) return permessageDeflate;
 	hasRequiredPermessageDeflate = 1;
 
-	const zlib = require$$0$1;
+	const zlib = require$$0;
 
 	const bufferUtil = requireBufferUtil();
 	const Limiter = requireLimiter();
@@ -975,7 +806,7 @@ function requireValidation () {
 	if (hasRequiredValidation) return validation.exports;
 	hasRequiredValidation = 1;
 
-	const { isUtf8 } = require$$0$2;
+	const { isUtf8 } = require$$0$1;
 
 	const { hasBlob } = requireConstants$1();
 
@@ -1135,7 +966,7 @@ function requireReceiver () {
 	if (hasRequiredReceiver) return receiver;
 	hasRequiredReceiver = 1;
 
-	const { Writable } = require$$0;
+	const { Writable } = require$$0$2;
 
 	const PerMessageDeflate = requirePermessageDeflate();
 	const {
@@ -1842,8 +1673,6 @@ function requireReceiver () {
 	return receiver;
 }
 
-requireReceiver();
-
 /* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^Duplex" }] */
 
 var sender;
@@ -1853,7 +1682,7 @@ function requireSender () {
 	if (hasRequiredSender) return sender;
 	hasRequiredSender = 1;
 
-	const { Duplex } = require$$0;
+	const { Duplex } = require$$0$2;
 	const { randomFillSync } = require$$1;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -2402,7 +2231,7 @@ function requireSender () {
 	  /**
 	   * Sends a frame.
 	   *
-	   * @param {Buffer[]} list The frame to send
+	   * @param {(Buffer | String)[]} list The frame to send
 	   * @param {Function} [cb] Callback
 	   * @private
 	   */
@@ -2454,8 +2283,6 @@ function requireSender () {
 	return sender;
 }
 
-requireSender();
-
 var eventTarget;
 var hasRequiredEventTarget;
 
@@ -2982,7 +2809,7 @@ function requireWebsocket () {
 	const net = require$$3;
 	const tls = require$$4;
 	const { randomBytes, createHash } = require$$1;
-	const { Duplex, Readable } = require$$0;
+	const { Duplex, Readable } = require$$0$2;
 	const { URL } = require$$7;
 
 	const PerMessageDeflate = requirePermessageDeflate();
@@ -4363,6 +4190,182 @@ function requireWebsocket () {
 	return websocket;
 }
 
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^WebSocket$" }] */
+
+var stream;
+var hasRequiredStream;
+
+function requireStream () {
+	if (hasRequiredStream) return stream;
+	hasRequiredStream = 1;
+
+	requireWebsocket();
+	const { Duplex } = require$$0$2;
+
+	/**
+	 * Emits the `'close'` event on a stream.
+	 *
+	 * @param {Duplex} stream The stream.
+	 * @private
+	 */
+	function emitClose(stream) {
+	  stream.emit('close');
+	}
+
+	/**
+	 * The listener of the `'end'` event.
+	 *
+	 * @private
+	 */
+	function duplexOnEnd() {
+	  if (!this.destroyed && this._writableState.finished) {
+	    this.destroy();
+	  }
+	}
+
+	/**
+	 * The listener of the `'error'` event.
+	 *
+	 * @param {Error} err The error
+	 * @private
+	 */
+	function duplexOnError(err) {
+	  this.removeListener('error', duplexOnError);
+	  this.destroy();
+	  if (this.listenerCount('error') === 0) {
+	    // Do not suppress the throwing behavior.
+	    this.emit('error', err);
+	  }
+	}
+
+	/**
+	 * Wraps a `WebSocket` in a duplex stream.
+	 *
+	 * @param {WebSocket} ws The `WebSocket` to wrap
+	 * @param {Object} [options] The options for the `Duplex` constructor
+	 * @return {Duplex} The duplex stream
+	 * @public
+	 */
+	function createWebSocketStream(ws, options) {
+	  let terminateOnDestroy = true;
+
+	  const duplex = new Duplex({
+	    ...options,
+	    autoDestroy: false,
+	    emitClose: false,
+	    objectMode: false,
+	    writableObjectMode: false
+	  });
+
+	  ws.on('message', function message(msg, isBinary) {
+	    const data =
+	      !isBinary && duplex._readableState.objectMode ? msg.toString() : msg;
+
+	    if (!duplex.push(data)) ws.pause();
+	  });
+
+	  ws.once('error', function error(err) {
+	    if (duplex.destroyed) return;
+
+	    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+	    //
+	    // - If the `'error'` event is emitted before the `'open'` event, then
+	    //   `ws.terminate()` is a noop as no socket is assigned.
+	    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+	    //   event of the `Receiver` object. The listener already closes the
+	    //   connection by calling `ws.close()`. This allows a close frame to be
+	    //   sent to the other peer. If `ws.terminate()` is called right after this,
+	    //   then the close frame might not be sent.
+	    terminateOnDestroy = false;
+	    duplex.destroy(err);
+	  });
+
+	  ws.once('close', function close() {
+	    if (duplex.destroyed) return;
+
+	    duplex.push(null);
+	  });
+
+	  duplex._destroy = function (err, callback) {
+	    if (ws.readyState === ws.CLOSED) {
+	      callback(err);
+	      process.nextTick(emitClose, duplex);
+	      return;
+	    }
+
+	    let called = false;
+
+	    ws.once('error', function error(err) {
+	      called = true;
+	      callback(err);
+	    });
+
+	    ws.once('close', function close() {
+	      if (!called) callback(err);
+	      process.nextTick(emitClose, duplex);
+	    });
+
+	    if (terminateOnDestroy) ws.terminate();
+	  };
+
+	  duplex._final = function (callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._final(callback);
+	      });
+	      return;
+	    }
+
+	    // If the value of the `_socket` property is `null` it means that `ws` is a
+	    // client websocket and the handshake failed. In fact, when this happens, a
+	    // socket is never assigned to the websocket. Wait for the `'error'` event
+	    // that will be emitted by the websocket.
+	    if (ws._socket === null) return;
+
+	    if (ws._socket._writableState.finished) {
+	      callback();
+	      if (duplex._readableState.endEmitted) duplex.destroy();
+	    } else {
+	      ws._socket.once('finish', function finish() {
+	        // `duplex` is not destroyed here because the `'end'` event will be
+	        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+	        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+	        callback();
+	      });
+	      ws.close();
+	    }
+	  };
+
+	  duplex._read = function () {
+	    if (ws.isPaused) ws.resume();
+	  };
+
+	  duplex._write = function (chunk, encoding, callback) {
+	    if (ws.readyState === ws.CONNECTING) {
+	      ws.once('open', function open() {
+	        duplex._write(chunk, encoding, callback);
+	      });
+	      return;
+	    }
+
+	    ws.send(chunk, callback);
+	  };
+
+	  duplex.on('end', duplexOnEnd);
+	  duplex.on('error', duplexOnError);
+	  return duplex;
+	}
+
+	stream = createWebSocketStream;
+	return stream;
+}
+
+requireStream();
+
+requireReceiver();
+
+requireSender();
+
 requireWebsocket();
 
 var subprotocol;
@@ -4446,7 +4449,7 @@ function requireWebsocketServer () {
 
 	const EventEmitter = require$$0$3;
 	const http = require$$2;
-	const { Duplex } = require$$0;
+	const { Duplex } = require$$0$2;
 	const { createHash } = require$$1;
 
 	const extension = requireExtension();
@@ -8686,6 +8689,7 @@ var picomatchExports = /*@__PURE__*/ requirePicomatch();
 var picomatch2 = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
 
 // src/index.ts
+var ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
 function getPartialMatcher(patterns, options) {
   const patternsCount = patterns.length;
   const patternsParts = Array(patternsCount);
@@ -8702,6 +8706,9 @@ function getPartialMatcher(patterns, options) {
   }
   return (input) => {
     const inputParts = input.split("/");
+    if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) {
+      return true;
+    }
     for (let i = 0; i < patterns.length; i++) {
       const patternParts = patternsParts[i];
       const regex = regexes[i];
@@ -8892,7 +8899,9 @@ function crawl(options, cwd, sync) {
     exclude: options.debug ? (_, p) => {
       const relativePath = processPath(p, cwd, props.root, true, true);
       const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-      if (!skipped) {
+      if (skipped) {
+        log(`skipped ${p}`);
+      } else {
         log(`crawling ${p}`);
       }
       return skipped;
@@ -9945,17 +9954,6 @@ function deleteDefineConfig(viteConfig) {
   }
   return defines;
 }
-function hijackVitePluginInject(viteConfig) {
-  const processEnvPlugin = viteConfig.plugins.find(
-    (p) => p.name === "vite:client-inject"
-  );
-  if (processEnvPlugin) {
-    const originalTransform = processEnvPlugin.transform;
-    processEnvPlugin.transform = function transform(code, id, options) {
-      return originalTransform.call(this, code, id, { ...options, ssr: true });
-    };
-  }
-}
 function resolveFsAllow(projectRoot, rootConfigFile) {
   if (!rootConfigFile) {
     return [searchForWorkspaceRoot(projectRoot), rootDir];
@@ -10127,6 +10125,10 @@ function WorkspaceVitestPlugin(project, options) {
         const resolveOptions = getDefaultResolveOptions();
         const config = {
           root,
+          define: {
+            // disable replacing `process.env.NODE_ENV` with static string by vite:client-inject
+            "process.env.NODE_ENV": "process.env.NODE_ENV"
+          },
           resolve: {
             ...resolveOptions,
             alias: testConfig.alias
@@ -10191,9 +10193,6 @@ function WorkspaceVitestPlugin(project, options) {
         config.customLogger = silenceImportViteIgnoreWarning(config.customLogger);
         return config;
       },
-      configResolved(viteConfig) {
-        hijackVitePluginInject(viteConfig);
-      },
       async configureServer(server) {
         const options2 = deepMerge({}, configDefaults, server.config.test || {});
         await project._configureServer(options2, server);
@@ -13339,6 +13338,10 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         const resolveOptions = getDefaultResolveOptions();
         const config = {
           root: viteConfig.test?.root || options.root,
+          define: {
+            // disable replacing `process.env.NODE_ENV` with static string by vite:client-inject
+            "process.env.NODE_ENV": "process.env.NODE_ENV"
+          },
           esbuild: viteConfig.esbuild === false ? false : {
             // Lowest target Vitest supports is Node18
             target: viteConfig.esbuild?.target || "node18",
@@ -13456,7 +13459,6 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         if (!options.watch) {
           viteConfig.server.watch = null;
         }
-        hijackVitePluginInject(viteConfig);
         Object.defineProperty(viteConfig, "_vitest", {
           value: options,
           enumerable: false,