vitest 3.1.0-beta.1 → 3.1.0-beta.2

package/dist/chunks/{vi.nSCvwQ7l.js → vi.B-PuvDzu.js}

@@ -2,146 +2,116 @@ import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, J
 import { getCurrentTest } from '@vitest/runner';
 import { getNames, getTestName } from '@vitest/runner/utils';
 import * as chai$1 from 'chai';
-import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.C8RiOc4B.js';
+import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.CtocqOoE.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
 import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.CDOsz-HY.js';
 
 const unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't throw an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
+	"matchSnapshot",
+	"toMatchSnapshot",
+	"toMatchInlineSnapshot",
+	"toThrowErrorMatchingSnapshot",
+	"toThrowErrorMatchingInlineSnapshot",
+	"throws",
+	"Throw",
+	"throw",
+	"toThrow",
+	"toThrowError"
 ];
 function createExpectPoll(expect) {
-  return function poll(fn, options = {}) {
-    const state = getWorkerState();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect(null, message).withContext({
-      poll: true
-    });
-    fn = fn.bind(assertion);
-    const test = chai$1.util.flag(assertion, "vitest-test");
-    if (!test) {
-      throw new Error("expect.poll() must be called inside a test");
-    }
-    const proxy = new Proxy(assertion, {
-      get(target, key, receiver) {
-        const assertionFunction = Reflect.get(target, key, receiver);
-        if (typeof assertionFunction !== "function") {
-          return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
-        }
-        if (key === "assert") {
-          return assertionFunction;
-        }
-        if (typeof key === "string" && unsupported.includes(key)) {
-          throw new SyntaxError(
-            `expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`
-          );
-        }
-        return function(...args) {
-          const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-          const promise = () => new Promise((resolve, reject) => {
-            let intervalId;
-            let timeoutId;
-            let lastError;
-            const { setTimeout, clearTimeout } = getSafeTimers();
-            const check = async () => {
-              try {
-                chai$1.util.flag(assertion, "_name", key);
-                const obj = await fn();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout(intervalId);
-                clearTimeout(timeoutId);
-              } catch (err) {
-                lastError = err;
-                if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) {
-                  intervalId = setTimeout(check, interval);
-                }
-              }
-            };
-            timeoutId = setTimeout(() => {
-              clearTimeout(intervalId);
-              chai$1.util.flag(assertion, "_isLastPollAttempt", true);
-              const rejectWithCause = (cause) => {
-                reject(
-                  copyStackTrace$1(
-                    new Error("Matcher did not succeed in time.", {
-                      cause
-                    }),
-                    STACK_TRACE_ERROR
-                  )
-                );
-              };
-              check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
-            }, timeout);
-            check();
-          });
-          let awaited = false;
-          test.onFinished ??= [];
-          test.onFinished.push(() => {
-            if (!awaited) {
-              const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
-              const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
-              const assertionString = `expect.${name}.${negated}${String(key)}()`;
-              const error = new Error(
-                `${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
-
-await ${assertionString}
-`
-              );
-              throw copyStackTrace$1(error, STACK_TRACE_ERROR);
-            }
-          });
-          let resultPromise;
-          return {
-            then(onFulfilled, onRejected) {
-              awaited = true;
-              return (resultPromise ||= promise()).then(onFulfilled, onRejected);
-            },
-            catch(onRejected) {
-              return (resultPromise ||= promise()).catch(onRejected);
-            },
-            finally(onFinally) {
-              return (resultPromise ||= promise()).finally(onFinally);
-            },
-            [Symbol.toStringTag]: "Promise"
-          };
-        };
-      }
-    });
-    return proxy;
-  };
+	return function poll(fn, options = {}) {
+		const state = getWorkerState();
+		const defaults = state.config.expect?.poll ?? {};
+		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+		const assertion = expect(null, message).withContext({ poll: true });
+		fn = fn.bind(assertion);
+		const test = chai$1.util.flag(assertion, "vitest-test");
+		if (!test) {
+			throw new Error("expect.poll() must be called inside a test");
+		}
+		const proxy = new Proxy(assertion, { get(target, key, receiver) {
+			const assertionFunction = Reflect.get(target, key, receiver);
+			if (typeof assertionFunction !== "function") {
+				return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+			}
+			if (key === "assert") {
+				return assertionFunction;
+			}
+			if (typeof key === "string" && unsupported.includes(key)) {
+				throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+			}
+			return function(...args) {
+				const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+				const promise = () => new Promise((resolve, reject) => {
+					let intervalId;
+					let timeoutId;
+					let lastError;
+					const { setTimeout, clearTimeout } = getSafeTimers();
+					const check = async () => {
+						try {
+							chai$1.util.flag(assertion, "_name", key);
+							const obj = await fn();
+							chai$1.util.flag(assertion, "object", obj);
+							resolve(await assertionFunction.call(assertion, ...args));
+							clearTimeout(intervalId);
+							clearTimeout(timeoutId);
+						} catch (err) {
+							lastError = err;
+							if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) {
+								intervalId = setTimeout(check, interval);
+							}
+						}
+					};
+					timeoutId = setTimeout(() => {
+						clearTimeout(intervalId);
+						chai$1.util.flag(assertion, "_isLastPollAttempt", true);
+						const rejectWithCause = (cause) => {
+							reject(copyStackTrace$1(new Error("Matcher did not succeed in time.", { cause }), STACK_TRACE_ERROR));
+						};
+						check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
+					}, timeout);
+					check();
+				});
+				let awaited = false;
+				test.onFinished ??= [];
+				test.onFinished.push(() => {
+					if (!awaited) {
+						const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
+						const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
+						const assertionString = `expect.${name}.${negated}${String(key)}()`;
+						const error = new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`);
+						throw copyStackTrace$1(error, STACK_TRACE_ERROR);
+					}
+				});
+				let resultPromise;
+				return {
+					then(onFulfilled, onRejected) {
+						awaited = true;
+						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+					},
+					catch(onRejected) {
+						return (resultPromise ||= promise()).catch(onRejected);
+					},
+					finally(onFinally) {
+						return (resultPromise ||= promise()).finally(onFinally);
+					},
+					[Symbol.toStringTag]: "Promise"
+				};
+			};
+		} });
+		return proxy;
+	};
 }
 function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
+	if (source.stack !== undefined) {
+		target.stack = source.stack.replace(source.message, target.message);
+	}
+	return target;
 }
 
 function commonjsRequire(path) {
@@ -244,258 +214,219 @@ var chaiSubsetExports = requireChaiSubset();
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
 function createAssertionMessage(util, assertion, hasArgs) {
-  const not = util.flag(assertion, "negate") ? "not." : "";
-  const name = `${util.flag(assertion, "_name")}(${"expected" })`;
-  const promiseName = util.flag(assertion, "promise");
-  const promise = promiseName ? `.${promiseName}` : "";
-  return `expect(actual)${promise}.${not}${name}`;
+	const not = util.flag(assertion, "negate") ? "not." : "";
+	const name = `${util.flag(assertion, "_name")}(${"expected" })`;
+	const promiseName = util.flag(assertion, "promise");
+	const promise = promiseName ? `.${promiseName}` : "";
+	return `expect(actual)${promise}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
-  const test = _test;
-  if (test && promise instanceof Promise) {
-    promise = promise.finally(() => {
-      if (!test.promises) {
-        return;
-      }
-      const index = test.promises.indexOf(promise);
-      if (index !== -1) {
-        test.promises.splice(index, 1);
-      }
-    });
-    if (!test.promises) {
-      test.promises = [];
-    }
-    test.promises.push(promise);
-    let resolved = false;
-    test.onFinished ??= [];
-    test.onFinished.push(() => {
-      if (!resolved) {
-        const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
-        const stack = processor(error.stack);
-        console.warn([
-          `Promise returned by \`${assertion}\` was not awaited. `,
-          "Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
-          "Please remember to await the assertion.\n",
-          stack
-        ].join(""));
-      }
-    });
-    return {
-      then(onFulfilled, onRejected) {
-        resolved = true;
-        return promise.then(onFulfilled, onRejected);
-      },
-      catch(onRejected) {
-        return promise.catch(onRejected);
-      },
-      finally(onFinally) {
-        return promise.finally(onFinally);
-      },
-      [Symbol.toStringTag]: "Promise"
-    };
-  }
-  return promise;
+	const test = _test;
+	if (test && promise instanceof Promise) {
+		promise = promise.finally(() => {
+			if (!test.promises) {
+				return;
+			}
+			const index = test.promises.indexOf(promise);
+			if (index !== -1) {
+				test.promises.splice(index, 1);
+			}
+		});
+		if (!test.promises) {
+			test.promises = [];
+		}
+		test.promises.push(promise);
+		let resolved = false;
+		test.onFinished ??= [];
+		test.onFinished.push(() => {
+			if (!resolved) {
+				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
+				const stack = processor(error.stack);
+				console.warn([
+					`Promise returned by \`${assertion}\` was not awaited. `,
+					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
+					"Please remember to await the assertion.\n",
+					stack
+				].join(""));
+			}
+		});
+		return {
+			then(onFulfilled, onRejected) {
+				resolved = true;
+				return promise.then(onFulfilled, onRejected);
+			},
+			catch(onRejected) {
+				return promise.catch(onRejected);
+			},
+			finally(onFinally) {
+				return promise.finally(onFinally);
+			},
+			[Symbol.toStringTag]: "Promise"
+		};
+	}
+	return promise;
 }
 
 let _client;
 function getSnapshotClient() {
-  if (!_client) {
-    _client = new SnapshotClient({
-      isEqual: (received, expected) => {
-        return equals(received, expected, [iterableEquality, subsetEquality]);
-      }
-    });
-  }
-  return _client;
+	if (!_client) {
+		_client = new SnapshotClient({ isEqual: (received, expected) => {
+			return equals(received, expected, [iterableEquality, subsetEquality]);
+		} });
+	}
+	return _client;
 }
 function getError(expected, promise) {
-  if (typeof expected !== "function") {
-    if (!promise) {
-      throw new Error(
-        `expected must be a function, received ${typeof expected}`
-      );
-    }
-    return expected;
-  }
-  try {
-    expected();
-  } catch (e) {
-    return e;
-  }
-  throw new Error("snapshot function didn't throw");
+	if (typeof expected !== "function") {
+		if (!promise) {
+			throw new Error(`expected must be a function, received ${typeof expected}`);
+		}
+		return expected;
+	}
+	try {
+		expected();
+	} catch (e) {
+		return e;
+	}
+	throw new Error("snapshot function didn't throw");
 }
 function getTestNames(test) {
-  return {
-    filepath: test.file.filepath,
-    name: getNames(test).slice(1).join(" > "),
-    testId: test.id
-  };
+	return {
+		filepath: test.file.filepath,
+		name: getNames(test).slice(1).join(" > "),
+		testId: test.id
+	};
 }
 const SnapshotPlugin = (chai, utils) => {
-  function getTest(assertionName, obj) {
-    const test = utils.flag(obj, "vitest-test");
-    if (!test) {
-      throw new Error(`'${assertionName}' cannot be used without test context`);
-    }
-    return test;
-  }
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(
-      chai.Assertion.prototype,
-      key,
-      function(properties, message) {
-        utils.flag(this, "_name", key);
-        const isNot = utils.flag(this, "negate");
-        if (isNot) {
-          throw new Error(`${key} cannot be used with "not"`);
-        }
-        const expected = utils.flag(this, "object");
-        const test = getTest(key, this);
-        if (typeof properties === "string" && typeof message === "undefined") {
-          message = properties;
-          properties = void 0;
-        }
-        const errorMessage = utils.flag(this, "message");
-        getSnapshotClient().assert({
-          received: expected,
-          message,
-          isInline: false,
-          properties,
-          errorMessage,
-          ...getTestNames(test)
-        });
-      }
-    );
-  }
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toMatchFileSnapshot",
-    function(file, message) {
-      utils.flag(this, "_name", "toMatchFileSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchFileSnapshot cannot be used with "not"');
-      }
-      const error = new Error("resolves");
-      const expected = utils.flag(this, "object");
-      const test = getTest("toMatchFileSnapshot", this);
-      const errorMessage = utils.flag(this, "message");
-      const promise = getSnapshotClient().assertRaw({
-        received: expected,
-        message,
-        isInline: false,
-        rawSnapshot: {
-          file
-        },
-        errorMessage,
-        ...getTestNames(test)
-      });
-      return recordAsyncExpect(
-        test,
-        promise,
-        createAssertionMessage(utils, this),
-        error
-      );
-    }
-  );
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toMatchInlineSnapshot",
-    function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      utils.flag(this, "_name", "toMatchInlineSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-      }
-      const test = getTest("toMatchInlineSnapshot", this);
-      const isInsideEach = test.each || test.suite?.each;
-      if (isInsideEach) {
-        throw new Error(
-          "InlineSnapshot cannot be used inside of test.each or describe.each"
-        );
-      }
-      const expected = utils.flag(this, "object");
-      const error = utils.flag(this, "error");
-      if (typeof properties === "string") {
-        message = inlineSnapshot;
-        inlineSnapshot = properties;
-        properties = void 0;
-      }
-      if (inlineSnapshot) {
-        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-      }
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: expected,
-        message,
-        isInline: true,
-        properties,
-        inlineSnapshot,
-        error,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toThrowErrorMatchingSnapshot",
-    function(message) {
-      utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error(
-          'toThrowErrorMatchingSnapshot cannot be used with "not"'
-        );
-      }
-      const expected = utils.flag(this, "object");
-      const test = getTest("toThrowErrorMatchingSnapshot", this);
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: getError(expected, promise),
-        message,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toThrowErrorMatchingInlineSnapshot",
-    function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error(
-          'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
-        );
-      }
-      const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
-      const isInsideEach = test.each || test.suite?.each;
-      if (isInsideEach) {
-        throw new Error(
-          "InlineSnapshot cannot be used inside of test.each or describe.each"
-        );
-      }
-      const expected = utils.flag(this, "object");
-      const error = utils.flag(this, "error");
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      if (inlineSnapshot) {
-        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-      }
-      getSnapshotClient().assert({
-        received: getError(expected, promise),
-        message,
-        inlineSnapshot,
-        isInline: true,
-        error,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+	function getTest(assertionName, obj) {
+		const test = utils.flag(obj, "vitest-test");
+		if (!test) {
+			throw new Error(`'${assertionName}' cannot be used without test context`);
+		}
+		return test;
+	}
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+		utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+			utils.flag(this, "_name", key);
+			const isNot = utils.flag(this, "negate");
+			if (isNot) {
+				throw new Error(`${key} cannot be used with "not"`);
+			}
+			const expected = utils.flag(this, "object");
+			const test = getTest(key, this);
+			if (typeof properties === "string" && typeof message === "undefined") {
+				message = properties;
+				properties = undefined;
+			}
+			const errorMessage = utils.flag(this, "message");
+			getSnapshotClient().assert({
+				received: expected,
+				message,
+				isInline: false,
+				properties,
+				errorMessage,
+				...getTestNames(test)
+			});
+		});
+	}
+	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) {
+			throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
+		}
+		const error = new Error("resolves");
+		const expected = utils.flag(this, "object");
+		const test = getTest("toMatchFileSnapshot", this);
+		const errorMessage = utils.flag(this, "message");
+		const promise = getSnapshotClient().assertRaw({
+			received: expected,
+			message,
+			isInline: false,
+			rawSnapshot: { file },
+			errorMessage,
+			...getTestNames(test)
+		});
+		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+		utils.flag(this, "_name", "toMatchInlineSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) {
+			throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
+		}
+		const test = getTest("toMatchInlineSnapshot", this);
+		const isInsideEach = test.each || test.suite?.each;
+		if (isInsideEach) {
+			throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		}
+		const expected = utils.flag(this, "object");
+		const error = utils.flag(this, "error");
+		if (typeof properties === "string") {
+			message = inlineSnapshot;
+			inlineSnapshot = properties;
+			properties = undefined;
+		}
+		if (inlineSnapshot) {
+			inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+		}
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: expected,
+			message,
+			isInline: true,
+			properties,
+			inlineSnapshot,
+			error,
+			errorMessage,
+			...getTestNames(test)
+		});
+	});
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) {
+			throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
+		}
+		const expected = utils.flag(this, "object");
+		const test = getTest("toThrowErrorMatchingSnapshot", this);
+		const promise = utils.flag(this, "promise");
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: getError(expected, promise),
+			message,
+			errorMessage,
+			...getTestNames(test)
+		});
+	});
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+		const isNot = utils.flag(this, "negate");
+		if (isNot) {
+			throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
+		}
+		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
+		const isInsideEach = test.each || test.suite?.each;
+		if (isInsideEach) {
+			throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		}
+		const expected = utils.flag(this, "object");
+		const error = utils.flag(this, "error");
+		const promise = utils.flag(this, "promise");
+		const errorMessage = utils.flag(this, "message");
+		if (inlineSnapshot) {
+			inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+		}
+		getSnapshotClient().assert({
+			received: getError(expected, promise),
+			message,
+			inlineSnapshot,
+			isInline: true,
+			error,
+			errorMessage,
+			...getTestNames(test)
+		});
+	});
+	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
 chai$1.use(JestExtend);
@@ -505,87 +436,83 @@ chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
-  const expect = (value, message) => {
-    const { assertionCalls } = getState(expect);
-    setState({ assertionCalls: assertionCalls + 1 }, expect);
-    const assert2 = chai$1.expect(value, message);
-    const _test = test || getCurrentTest();
-    if (_test) {
-      return assert2.withTest(_test);
-    } else {
-      return assert2;
-    }
-  };
-  Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-  expect.getState = () => getState(expect);
-  expect.setState = (state) => setState(state, expect);
-  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
-  setState(
-    {
-      // this should also add "snapshotState" that is added conditionally
-      ...globalState,
-      assertionCalls: 0,
-      isExpectingAssertions: false,
-      isExpectingAssertionsError: null,
-      expectedAssertionsNumber: null,
-      expectedAssertionsNumberErrorGen: null,
-      environment: getCurrentEnvironment(),
-      get testPath() {
-        return getWorkerState().filepath;
-      },
-      currentTestName: test ? getTestName(test) : globalState.currentTestName
-    },
-    expect
-  );
-  expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
-  expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-  expect.soft = (...args) => {
-    return expect(...args).withContext({ soft: true });
-  };
-  expect.poll = createExpectPoll(expect);
-  expect.unreachable = (message) => {
-    chai$1.assert.fail(
-      `expected${message ? ` "${message}" ` : " "}not to be reached`
-    );
-  };
-  function assertions(expected) {
-    const errorGen = () => new Error(
-      `expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`
-    );
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(errorGen(), assertions);
-    }
-    expect.setState({
-      expectedAssertionsNumber: expected,
-      expectedAssertionsNumberErrorGen: errorGen
-    });
-  }
-  function hasAssertions() {
-    const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, hasAssertions);
-    }
-    expect.setState({
-      isExpectingAssertions: true,
-      isExpectingAssertionsError: error
-    });
-  }
-  chai$1.util.addMethod(expect, "assertions", assertions);
-  chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
-  expect.extend(customMatchers);
-  return expect;
+	const expect = (value, message) => {
+		const { assertionCalls } = getState(expect);
+		setState({ assertionCalls: assertionCalls + 1 }, expect);
+		const assert = chai$1.expect(value, message);
+		const _test = test || getCurrentTest();
+		if (_test) {
+			return assert.withTest(_test);
+		} else {
+			return assert;
+		}
+	};
+	Object.assign(expect, chai$1.expect);
+	Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+	expect.getState = () => getState(expect);
+	expect.setState = (state) => setState(state, expect);
+	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+	setState({
+		...globalState,
+		assertionCalls: 0,
+		isExpectingAssertions: false,
+		isExpectingAssertionsError: null,
+		expectedAssertionsNumber: null,
+		expectedAssertionsNumberErrorGen: null,
+		environment: getCurrentEnvironment(),
+		get testPath() {
+			return getWorkerState().filepath;
+		},
+		currentTestName: test ? getTestName(test) : globalState.currentTestName
+	}, expect);
+	expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
+	expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+	expect.soft = (...args) => {
+		return expect(...args).withContext({ soft: true });
+	};
+	expect.poll = createExpectPoll(expect);
+	expect.unreachable = (message) => {
+		chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+	};
+	function assertions(expected) {
+		const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(errorGen(), assertions);
+		}
+		expect.setState({
+			expectedAssertionsNumber: expected,
+			expectedAssertionsNumberErrorGen: errorGen
+		});
+	}
+	function hasAssertions() {
+		const error = new Error("expected any number of assertion, but got none");
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(error, hasAssertions);
+		}
+		expect.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	chai$1.util.addMethod(expect, "assertions", assertions);
+	chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
+	expect.extend(customMatchers);
+	return expect;
 }
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
-  value: globalExpect,
-  writable: true,
-  configurable: true
+	value: globalExpect,
+	writable: true,
+	configurable: true
 });
 
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
 function inject(key) {
-  const workerState = getWorkerState();
-  return workerState.providedContext[key];
+	const workerState = getWorkerState();
+	return workerState.providedContext[key];
 }
 
 var fakeTimersSrc = {};
@@ -3682,598 +3609,530 @@ function requireFakeTimersSrc () {
 var fakeTimersSrcExports = requireFakeTimersSrc();
 
 class FakeTimers {
-  _global;
-  _clock;
-  // | _fakingTime | _fakingDate |
-  // +-------------+-------------+
-  // | false       | falsy       | initial
-  // | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
-  // | true        | falsy       | vi.useFakeTimers called first
-  // | true        | truthy     | unreachable
-  _fakingTime;
-  _fakingDate;
-  _fakeTimers;
-  _userConfig;
-  _now = RealDate.now;
-  constructor({
-    global,
-    config
-  }) {
-    this._userConfig = config;
-    this._fakingDate = null;
-    this._fakingTime = false;
-    this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
-    this._global = global;
-  }
-  clearAllTimers() {
-    if (this._fakingTime) {
-      this._clock.reset();
-    }
-  }
-  dispose() {
-    this.useRealTimers();
-  }
-  runAllTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runAll();
-    }
-  }
-  async runAllTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runAllAsync();
-    }
-  }
-  runOnlyPendingTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToLast();
-    }
-  }
-  async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runToLastAsync();
-    }
-  }
-  advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        this._clock.next();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        await this._clock.nextAsync();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers()) {
-      this._clock.tick(msToRun);
-    }
-  }
-  async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers()) {
-      await this._clock.tickAsync(msToRun);
-    }
-  }
-  advanceTimersToNextFrame() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToFrame();
-    }
-  }
-  runAllTicks() {
-    if (this._checkFakeTimers()) {
-      this._clock.runMicrotasks();
-    }
-  }
-  useRealTimers() {
-    if (this._fakingDate) {
-      resetDate();
-      this._fakingDate = null;
-    }
-    if (this._fakingTime) {
-      this._clock.uninstall();
-      this._fakingTime = false;
-    }
-  }
-  useFakeTimers() {
-    if (this._fakingDate) {
-      throw new Error(
-        '"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.'
-      );
-    }
-    if (!this._fakingTime) {
-      const toFake = Object.keys(this._fakeTimers.timers).filter(
-        (timer) => timer !== "nextTick" && timer !== "queueMicrotask"
-      );
-      if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) {
-        throw new Error(
-          "process.nextTick cannot be mocked inside child_process"
-        );
-      }
-      this._clock = this._fakeTimers.install({
-        now: Date.now(),
-        ...this._userConfig,
-        toFake: this._userConfig?.toFake || toFake,
-        ignoreMissingTimers: true
-      });
-      this._fakingTime = true;
-    }
-  }
-  reset() {
-    if (this._checkFakeTimers()) {
-      const { now } = this._clock;
-      this._clock.reset();
-      this._clock.setSystemTime(now);
-    }
-  }
-  setSystemTime(now) {
-    const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
-    if (this._fakingTime) {
-      this._clock.setSystemTime(date);
-    } else {
-      this._fakingDate = date ?? new Date(this.getRealSystemTime());
-      mockDate(this._fakingDate);
-    }
-  }
-  getMockedSystemTime() {
-    return this._fakingTime ? new Date(this._clock.now) : this._fakingDate;
-  }
-  getRealSystemTime() {
-    return this._now();
-  }
-  getTimerCount() {
-    if (this._checkFakeTimers()) {
-      return this._clock.countTimers();
-    }
-    return 0;
-  }
-  configure(config) {
-    this._userConfig = config;
-  }
-  isFakeTimers() {
-    return this._fakingTime;
-  }
-  _checkFakeTimers() {
-    if (!this._fakingTime) {
-      throw new Error(
-        'Timers are not mocked. Try calling "vi.useFakeTimers()" first.'
-      );
-    }
-    return this._fakingTime;
-  }
+	_global;
+	_clock;
+	_fakingTime;
+	_fakingDate;
+	_fakeTimers;
+	_userConfig;
+	_now = RealDate.now;
+	constructor({ global, config }) {
+		this._userConfig = config;
+		this._fakingDate = null;
+		this._fakingTime = false;
+		this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
+		this._global = global;
+	}
+	clearAllTimers() {
+		if (this._fakingTime) {
+			this._clock.reset();
+		}
+	}
+	dispose() {
+		this.useRealTimers();
+	}
+	runAllTimers() {
+		if (this._checkFakeTimers()) {
+			this._clock.runAll();
+		}
+	}
+	async runAllTimersAsync() {
+		if (this._checkFakeTimers()) {
+			await this._clock.runAllAsync();
+		}
+	}
+	runOnlyPendingTimers() {
+		if (this._checkFakeTimers()) {
+			this._clock.runToLast();
+		}
+	}
+	async runOnlyPendingTimersAsync() {
+		if (this._checkFakeTimers()) {
+			await this._clock.runToLastAsync();
+		}
+	}
+	advanceTimersToNextTimer(steps = 1) {
+		if (this._checkFakeTimers()) {
+			for (let i = steps; i > 0; i--) {
+				this._clock.next();
+				this._clock.tick(0);
+				if (this._clock.countTimers() === 0) {
+					break;
+				}
+			}
+		}
+	}
+	async advanceTimersToNextTimerAsync(steps = 1) {
+		if (this._checkFakeTimers()) {
+			for (let i = steps; i > 0; i--) {
+				await this._clock.nextAsync();
+				this._clock.tick(0);
+				if (this._clock.countTimers() === 0) {
+					break;
+				}
+			}
+		}
+	}
+	advanceTimersByTime(msToRun) {
+		if (this._checkFakeTimers()) {
+			this._clock.tick(msToRun);
+		}
+	}
+	async advanceTimersByTimeAsync(msToRun) {
+		if (this._checkFakeTimers()) {
+			await this._clock.tickAsync(msToRun);
+		}
+	}
+	advanceTimersToNextFrame() {
+		if (this._checkFakeTimers()) {
+			this._clock.runToFrame();
+		}
+	}
+	runAllTicks() {
+		if (this._checkFakeTimers()) {
+			this._clock.runMicrotasks();
+		}
+	}
+	useRealTimers() {
+		if (this._fakingDate) {
+			resetDate();
+			this._fakingDate = null;
+		}
+		if (this._fakingTime) {
+			this._clock.uninstall();
+			this._fakingTime = false;
+		}
+	}
+	useFakeTimers() {
+		if (this._fakingDate) {
+			throw new Error("\"setSystemTime\" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.");
+		}
+		if (!this._fakingTime) {
+			const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
+			if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) {
+				throw new Error("process.nextTick cannot be mocked inside child_process");
+			}
+			this._clock = this._fakeTimers.install({
+				now: Date.now(),
+				...this._userConfig,
+				toFake: this._userConfig?.toFake || toFake,
+				ignoreMissingTimers: true
+			});
+			this._fakingTime = true;
+		}
+	}
+	reset() {
+		if (this._checkFakeTimers()) {
+			const { now } = this._clock;
+			this._clock.reset();
+			this._clock.setSystemTime(now);
+		}
+	}
+	setSystemTime(now) {
+		const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
+		if (this._fakingTime) {
+			this._clock.setSystemTime(date);
+		} else {
+			this._fakingDate = date ?? new Date(this.getRealSystemTime());
+			mockDate(this._fakingDate);
+		}
+	}
+	getMockedSystemTime() {
+		return this._fakingTime ? new Date(this._clock.now) : this._fakingDate;
+	}
+	getRealSystemTime() {
+		return this._now();
+	}
+	getTimerCount() {
+		if (this._checkFakeTimers()) {
+			return this._clock.countTimers();
+		}
+		return 0;
+	}
+	configure(config) {
+		this._userConfig = config;
+	}
+	isFakeTimers() {
+		return this._fakingTime;
+	}
+	_checkFakeTimers() {
+		if (!this._fakingTime) {
+			throw new Error("Timers are not mocked. Try calling \"vi.useFakeTimers()\" first.");
+		}
+		return this._fakingTime;
+	}
 }
 
 function copyStackTrace(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
+	if (source.stack !== undefined) {
+		target.stack = source.stack.replace(source.message, target.message);
+	}
+	return target;
 }
 function waitFor(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let lastError;
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onResolve = (result) => {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      resolve(result);
-    };
-    const handleTimeout = () => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      let error = lastError;
-      if (!error) {
-        error = copyStackTrace(
-          new Error("Timed out in waitFor!"),
-          STACK_TRACE_ERROR
-        );
-      }
-      reject(error);
-    };
-    const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              lastError = rejectedValue;
-            }
-          );
-        } else {
-          onResolve(result);
-          return true;
-        }
-      } catch (error) {
-        lastError = error;
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout(handleTimeout, timeout);
-    intervalId = setInterval(checkCallback, interval);
-  });
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+	return new Promise((resolve, reject) => {
+		let lastError;
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
+		const onResolve = (result) => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			if (intervalId) {
+				clearInterval(intervalId);
+			}
+			resolve(result);
+		};
+		const handleTimeout = () => {
+			if (intervalId) {
+				clearInterval(intervalId);
+			}
+			let error = lastError;
+			if (!error) {
+				error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+			}
+			reject(error);
+		};
+		const checkCallback = () => {
+			if (vi.isFakeTimers()) {
+				vi.advanceTimersByTime(interval);
+			}
+			if (promiseStatus === "pending") {
+				return;
+			}
+			try {
+				const result = callback();
+				if (result !== null && typeof result === "object" && typeof result.then === "function") {
+					const thenable = result;
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
+					}, (rejectedValue) => {
+						promiseStatus = "rejected";
+						lastError = rejectedValue;
+					});
+				} else {
+					onResolve(result);
+					return true;
+				}
+			} catch (error) {
+				lastError = error;
+			}
+		};
+		if (checkCallback() === true) {
+			return;
+		}
+		timeoutId = setTimeout(handleTimeout, timeout);
+		intervalId = setInterval(checkCallback, interval);
+	});
 }
 function waitUntil(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onReject = (error) => {
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      if (!error) {
-        error = copyStackTrace(
-          new Error("Timed out in waitUntil!"),
-          STACK_TRACE_ERROR
-        );
-      }
-      reject(error);
-    };
-    const onResolve = (result) => {
-      if (!result) {
-        return;
-      }
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval(intervalId);
-      }
-      resolve(result);
-      return true;
-    };
-    const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              onReject(rejectedValue);
-            }
-          );
-        } else {
-          return onResolve(result);
-        }
-      } catch (error) {
-        onReject(error);
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout(onReject, timeout);
-    intervalId = setInterval(checkCallback, interval);
-  });
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+	return new Promise((resolve, reject) => {
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
+		const onReject = (error) => {
+			if (intervalId) {
+				clearInterval(intervalId);
+			}
+			if (!error) {
+				error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+			}
+			reject(error);
+		};
+		const onResolve = (result) => {
+			if (!result) {
+				return;
+			}
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			if (intervalId) {
+				clearInterval(intervalId);
+			}
+			resolve(result);
+			return true;
+		};
+		const checkCallback = () => {
+			if (vi.isFakeTimers()) {
+				vi.advanceTimersByTime(interval);
+			}
+			if (promiseStatus === "pending") {
+				return;
+			}
+			try {
+				const result = callback();
+				if (result !== null && typeof result === "object" && typeof result.then === "function") {
+					const thenable = result;
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
+					}, (rejectedValue) => {
+						promiseStatus = "rejected";
+						onReject(rejectedValue);
+					});
+				} else {
+					return onResolve(result);
+				}
+			} catch (error) {
+				onReject(error);
+			}
+		};
+		if (checkCallback() === true) {
+			return;
+		}
+		timeoutId = setTimeout(onReject, timeout);
+		intervalId = setInterval(checkCallback, interval);
+	});
 }
 
 function createVitest() {
-  let _config = null;
-  const workerState = getWorkerState();
-  let _timers;
-  const timers = () => _timers ||= new FakeTimers({
-    global: globalThis,
-    config: workerState.config.fakeTimers
-  });
-  const _stubsGlobal = /* @__PURE__ */ new Map();
-  const _stubsEnv = /* @__PURE__ */ new Map();
-  const _envBooleans = ["PROD", "DEV", "SSR"];
-  const utils = {
-    useFakeTimers(config) {
-      if (isChildProcess()) {
-        if (config?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) {
-          throw new Error(
-            'vi.useFakeTimers({ toFake: ["nextTick"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.'
-          );
-        }
-      }
-      if (config) {
-        timers().configure({ ...workerState.config.fakeTimers, ...config });
-      } else {
-        timers().configure(workerState.config.fakeTimers);
-      }
-      timers().useFakeTimers();
-      return utils;
-    },
-    isFakeTimers() {
-      return timers().isFakeTimers();
-    },
-    useRealTimers() {
-      timers().useRealTimers();
-      return utils;
-    },
-    runOnlyPendingTimers() {
-      timers().runOnlyPendingTimers();
-      return utils;
-    },
-    async runOnlyPendingTimersAsync() {
-      await timers().runOnlyPendingTimersAsync();
-      return utils;
-    },
-    runAllTimers() {
-      timers().runAllTimers();
-      return utils;
-    },
-    async runAllTimersAsync() {
-      await timers().runAllTimersAsync();
-      return utils;
-    },
-    runAllTicks() {
-      timers().runAllTicks();
-      return utils;
-    },
-    advanceTimersByTime(ms) {
-      timers().advanceTimersByTime(ms);
-      return utils;
-    },
-    async advanceTimersByTimeAsync(ms) {
-      await timers().advanceTimersByTimeAsync(ms);
-      return utils;
-    },
-    advanceTimersToNextTimer() {
-      timers().advanceTimersToNextTimer();
-      return utils;
-    },
-    async advanceTimersToNextTimerAsync() {
-      await timers().advanceTimersToNextTimerAsync();
-      return utils;
-    },
-    advanceTimersToNextFrame() {
-      timers().advanceTimersToNextFrame();
-      return utils;
-    },
-    getTimerCount() {
-      return timers().getTimerCount();
-    },
-    setSystemTime(time) {
-      timers().setSystemTime(time);
-      return utils;
-    },
-    getMockedSystemTime() {
-      return timers().getMockedSystemTime();
-    },
-    getRealSystemTime() {
-      return timers().getRealSystemTime();
-    },
-    clearAllTimers() {
-      timers().clearAllTimers();
-      return utils;
-    },
-    // mocks
-    spyOn,
-    fn,
-    waitFor,
-    waitUntil,
-    hoisted(factory) {
-      assertTypes(factory, '"vi.hoisted" factory', ["function"]);
-      return factory();
-    },
-    mock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.mock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      const importer = getImporter("mock");
-      _mocker().queueMock(
-        path,
-        importer,
-        typeof factory === "function" ? () => factory(
-          () => _mocker().importActual(
-            path,
-            importer,
-            _mocker().getMockContext().callstack
-          )
-        ) : factory
-      );
-    },
-    unmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.unmock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      _mocker().queueUnmock(path, getImporter("unmock"));
-    },
-    doMock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.doMock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      const importer = getImporter("doMock");
-      _mocker().queueMock(
-        path,
-        importer,
-        typeof factory === "function" ? () => factory(
-          () => _mocker().importActual(
-            path,
-            importer,
-            _mocker().getMockContext().callstack
-          )
-        ) : factory
-      );
-    },
-    doUnmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.doUnmock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      _mocker().queueUnmock(path, getImporter("doUnmock"));
-    },
-    async importActual(path) {
-      return _mocker().importActual(
-        path,
-        getImporter("importActual"),
-        _mocker().getMockContext().callstack
-      );
-    },
-    async importMock(path) {
-      return _mocker().importMock(path, getImporter("importMock"));
-    },
-    // this is typed in the interface so it's not necessary to type it here
-    mocked(item, _options = {}) {
-      return item;
-    },
-    isMockFunction(fn2) {
-      return isMockFunction(fn2);
-    },
-    clearAllMocks() {
-      [...mocks].reverse().forEach((spy) => spy.mockClear());
-      return utils;
-    },
-    resetAllMocks() {
-      [...mocks].reverse().forEach((spy) => spy.mockReset());
-      return utils;
-    },
-    restoreAllMocks() {
-      [...mocks].reverse().forEach((spy) => spy.mockRestore());
-      return utils;
-    },
-    stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name)) {
-        _stubsGlobal.set(
-          name,
-          Object.getOwnPropertyDescriptor(globalThis, name)
-        );
-      }
-      Object.defineProperty(globalThis, name, {
-        value,
-        writable: true,
-        configurable: true,
-        enumerable: true
-      });
-      return utils;
-    },
-    stubEnv(name, value) {
-      if (!_stubsEnv.has(name)) {
-        _stubsEnv.set(name, process.env[name]);
-      }
-      if (_envBooleans.includes(name)) {
-        process.env[name] = value ? "1" : "";
-      } else if (value === void 0) {
-        delete process.env[name];
-      } else {
-        process.env[name] = String(value);
-      }
-      return utils;
-    },
-    unstubAllGlobals() {
-      _stubsGlobal.forEach((original, name) => {
-        if (!original) {
-          Reflect.deleteProperty(globalThis, name);
-        } else {
-          Object.defineProperty(globalThis, name, original);
-        }
-      });
-      _stubsGlobal.clear();
-      return utils;
-    },
-    unstubAllEnvs() {
-      _stubsEnv.forEach((original, name) => {
-        if (original === void 0) {
-          delete process.env[name];
-        } else {
-          process.env[name] = original;
-        }
-      });
-      _stubsEnv.clear();
-      return utils;
-    },
-    resetModules() {
-      resetModules(workerState.moduleCache);
-      return utils;
-    },
-    async dynamicImportSettled() {
-      return waitForImportsToResolve();
-    },
-    setConfig(config) {
-      if (!_config) {
-        _config = { ...workerState.config };
-      }
-      Object.assign(workerState.config, config);
-    },
-    resetConfig() {
-      if (_config) {
-        Object.assign(workerState.config, _config);
-      }
-    }
-  };
-  return utils;
+	let _config = null;
+	const workerState = getWorkerState();
+	let _timers;
+	const timers = () => _timers ||= new FakeTimers({
+		global: globalThis,
+		config: workerState.config.fakeTimers
+	});
+	const _stubsGlobal = new Map();
+	const _stubsEnv = new Map();
+	const _envBooleans = [
+		"PROD",
+		"DEV",
+		"SSR"
+	];
+	const utils = {
+		useFakeTimers(config) {
+			if (isChildProcess()) {
+				if (config?.toFake?.includes("nextTick") || workerState.config?.fakeTimers?.toFake?.includes("nextTick")) {
+					throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
+				}
+			}
+			if (config) {
+				timers().configure({
+					...workerState.config.fakeTimers,
+					...config
+				});
+			} else {
+				timers().configure(workerState.config.fakeTimers);
+			}
+			timers().useFakeTimers();
+			return utils;
+		},
+		isFakeTimers() {
+			return timers().isFakeTimers();
+		},
+		useRealTimers() {
+			timers().useRealTimers();
+			return utils;
+		},
+		runOnlyPendingTimers() {
+			timers().runOnlyPendingTimers();
+			return utils;
+		},
+		async runOnlyPendingTimersAsync() {
+			await timers().runOnlyPendingTimersAsync();
+			return utils;
+		},
+		runAllTimers() {
+			timers().runAllTimers();
+			return utils;
+		},
+		async runAllTimersAsync() {
+			await timers().runAllTimersAsync();
+			return utils;
+		},
+		runAllTicks() {
+			timers().runAllTicks();
+			return utils;
+		},
+		advanceTimersByTime(ms) {
+			timers().advanceTimersByTime(ms);
+			return utils;
+		},
+		async advanceTimersByTimeAsync(ms) {
+			await timers().advanceTimersByTimeAsync(ms);
+			return utils;
+		},
+		advanceTimersToNextTimer() {
+			timers().advanceTimersToNextTimer();
+			return utils;
+		},
+		async advanceTimersToNextTimerAsync() {
+			await timers().advanceTimersToNextTimerAsync();
+			return utils;
+		},
+		advanceTimersToNextFrame() {
+			timers().advanceTimersToNextFrame();
+			return utils;
+		},
+		getTimerCount() {
+			return timers().getTimerCount();
+		},
+		setSystemTime(time) {
+			timers().setSystemTime(time);
+			return utils;
+		},
+		getMockedSystemTime() {
+			return timers().getMockedSystemTime();
+		},
+		getRealSystemTime() {
+			return timers().getRealSystemTime();
+		},
+		clearAllTimers() {
+			timers().clearAllTimers();
+			return utils;
+		},
+		spyOn,
+		fn,
+		waitFor,
+		waitUntil,
+		hoisted(factory) {
+			assertTypes(factory, "\"vi.hoisted\" factory", ["function"]);
+			return factory();
+		},
+		mock(path, factory) {
+			if (typeof path !== "string") {
+				throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
+			}
+			const importer = getImporter("mock");
+			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+		},
+		unmock(path) {
+			if (typeof path !== "string") {
+				throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
+			}
+			_mocker().queueUnmock(path, getImporter("unmock"));
+		},
+		doMock(path, factory) {
+			if (typeof path !== "string") {
+				throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
+			}
+			const importer = getImporter("doMock");
+			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+		},
+		doUnmock(path) {
+			if (typeof path !== "string") {
+				throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
+			}
+			_mocker().queueUnmock(path, getImporter("doUnmock"));
+		},
+		async importActual(path) {
+			return _mocker().importActual(path, getImporter("importActual"), _mocker().getMockContext().callstack);
+		},
+		async importMock(path) {
+			return _mocker().importMock(path, getImporter("importMock"));
+		},
+		mocked(item, _options = {}) {
+			return item;
+		},
+		isMockFunction(fn) {
+			return isMockFunction(fn);
+		},
+		clearAllMocks() {
+			[...mocks].reverse().forEach((spy) => spy.mockClear());
+			return utils;
+		},
+		resetAllMocks() {
+			[...mocks].reverse().forEach((spy) => spy.mockReset());
+			return utils;
+		},
+		restoreAllMocks() {
+			[...mocks].reverse().forEach((spy) => spy.mockRestore());
+			return utils;
+		},
+		stubGlobal(name, value) {
+			if (!_stubsGlobal.has(name)) {
+				_stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+			}
+			Object.defineProperty(globalThis, name, {
+				value,
+				writable: true,
+				configurable: true,
+				enumerable: true
+			});
+			return utils;
+		},
+		stubEnv(name, value) {
+			if (!_stubsEnv.has(name)) {
+				_stubsEnv.set(name, process.env[name]);
+			}
+			if (_envBooleans.includes(name)) {
+				process.env[name] = value ? "1" : "";
+			} else if (value === undefined) {
+				delete process.env[name];
+			} else {
+				process.env[name] = String(value);
+			}
+			return utils;
+		},
+		unstubAllGlobals() {
+			_stubsGlobal.forEach((original, name) => {
+				if (!original) {
+					Reflect.deleteProperty(globalThis, name);
+				} else {
+					Object.defineProperty(globalThis, name, original);
+				}
+			});
+			_stubsGlobal.clear();
+			return utils;
+		},
+		unstubAllEnvs() {
+			_stubsEnv.forEach((original, name) => {
+				if (original === undefined) {
+					delete process.env[name];
+				} else {
+					process.env[name] = original;
+				}
+			});
+			_stubsEnv.clear();
+			return utils;
+		},
+		resetModules() {
+			resetModules(workerState.moduleCache);
+			return utils;
+		},
+		async dynamicImportSettled() {
+			return waitForImportsToResolve();
+		},
+		setConfig(config) {
+			if (!_config) {
+				_config = { ...workerState.config };
+			}
+			Object.assign(workerState.config, config);
+		},
+		resetConfig() {
+			if (_config) {
+				Object.assign(workerState.config, _config);
+			}
+		}
+	};
+	return utils;
 }
 const vitest = createVitest();
 const vi = vitest;
 function _mocker() {
-  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy(
-    {},
-    {
-      get(_, name) {
-        throw new Error(
-          `Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`
-        );
-      }
-    }
-  );
+	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
+		throw new Error("Vitest mocker was not initialized in this environment. " + `vi.${String(name)}() is forbidden.`);
+	} });
 }
 function getImporter(name) {
-  const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
-  const stackArray = stackTrace.split("\n");
-  const importerStackIndex = stackArray.findIndex((stack2) => {
-    return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
-  });
-  const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
-  return stack?.file || "";
+	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
+	const stackArray = stackTrace.split("\n");
+	const importerStackIndex = stackArray.findIndex((stack) => {
+		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
+	});
+	const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
+	return stack?.file || "";
 }
 
 export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, inject as i, vi as v };