vitest 0.0.76 → 0.0.80

package/dist/{constants-d4c70610.js → constants-9da0006f.js}

@@ -4,6 +4,16 @@ import { fileURLToPath } from 'url';
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultIncludes = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExcludes = ["**/node_modules/**", "**/dist/**"];
+const defaultPort = 51204;
+const API_PATH = "/__vitest_api__";
+const configFiles = [
+  "vitest.config.ts",
+  "vitest.config.js",
+  "vitest.config.mjs",
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mjs"
+];
 const globalApis = [
   "suite",
   "test",
@@ -12,14 +22,13 @@ const globalApis = [
   "chai",
   "expect",
   "assert",
-  "sinon",
   "spy",
-  "mock",
-  "stub",
+  "spyOn",
+  "vitest",
   "beforeAll",
   "afterAll",
   "beforeEach",
   "afterEach"
 ];
 
-export { defaultExcludes as a, distDir as b, defaultIncludes as d, globalApis as g };
+export { API_PATH as A, defaultExcludes as a, defaultPort as b, configFiles as c, defaultIncludes as d, distDir as e, globalApis as g };

package/dist/entry.js

@@ -2,15 +2,15 @@ import { Console } from 'console';
 import { Writable } from 'stream';
 import { importModule } from 'local-pkg';
 import chai, { expect, util } from 'chai';
-import SinonChai from 'sinon-chai';
 import Subset from 'chai-subset';
 import path, { basename } from 'path';
+import { r as rpc, s as send } from './rpc-7de86f29.js';
 import { g as getNames, t as toArray, i as interpretOnlyMode, p as partitionSuiteChildren, c as hasTests, h as hasFailed } from './utils-9dcc4050.js';
 import fs from 'fs';
-import { d as c$1, m as generateDiff } from './error-1df12c37.js';
+import { d as c$1, m as generateDiff } from './error-c9295525.js';
 import { performance } from 'perf_hooks';
-import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-1bc54c1b.js';
-import { n as nanoid } from './index-6427e0f2.js';
+import { b as setHooks, c as createSuiteHooks, e as clearContext, f as defaultSuite, h as context, j as getHooks, k as getFn } from './suite-95be5909.js';
+import { n as nanoid } from './index-9e71c815.js';
 import 'tty';
 import 'source-map';
 
@@ -203,6 +203,7 @@ const OTHER_KEYS = [
   "innerWidth",
   "length",
   "location",
+  "matchMedia",
   "moveBy",
   "moveTo",
   "name",
@@ -295,15 +296,6 @@ const environments = {
   "happy-dom": happy
 };
 
-const rpc = async (method, ...args) => {
-  var _a;
-  return (_a = process.__vitest_worker__) == null ? void 0 : _a.rpc(method, ...args);
-};
-const send = async (method, ...args) => {
-  var _a;
-  return (_a = process.__vitest_worker__) == null ? void 0 : _a.send(method, ...args);
-};
-
 var naturalCompare$2 = {exports: {}};
 
 /*
@@ -751,7 +743,7 @@ const asymmetricMatcher =
     : 0x1357a5;
 const SPACE$2 = ' ';
 
-const serialize$7 = (val, config, indentation, depth, refs, printer) => {
+const serialize$8 = (val, config, indentation, depth, refs, printer) => {
   const stringedValue = val.toString();
 
   if (
@@ -827,13 +819,13 @@ const serialize$7 = (val, config, indentation, depth, refs, printer) => {
   return val.toAsymmetricMatcher();
 };
 
-AsymmetricMatcher$2.serialize = serialize$7;
+AsymmetricMatcher$2.serialize = serialize$8;
 
 const test$6 = val => val && val.$$typeof === asymmetricMatcher;
 
 AsymmetricMatcher$2.test = test$6;
 const plugin$6 = {
-  serialize: serialize$7,
+  serialize: serialize$8,
   test: test$6
 };
 var _default$7 = plugin$6;
@@ -934,12 +926,12 @@ const test$5 = val =>
 
 ConvertAnsi.test = test$5;
 
-const serialize$6 = (val, config, indentation, depth, refs, printer) =>
+const serialize$7 = (val, config, indentation, depth, refs, printer) =>
   printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
 
-ConvertAnsi.serialize = serialize$6;
+ConvertAnsi.serialize = serialize$7;
 const plugin$5 = {
-  serialize: serialize$6,
+  serialize: serialize$7,
   test: test$5
 };
 var _default$6 = plugin$5;
@@ -980,7 +972,7 @@ DOMCollection$2.test = test$4;
 const isNamedNodeMap = collection =>
   collection.constructor.name === 'NamedNodeMap';
 
-const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
+const serialize$6 = (collection, config, indentation, depth, refs, printer) => {
   const name = collection.constructor.name;
 
   if (++depth > config.maxDepth) {
@@ -1018,9 +1010,9 @@ const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
   );
 };
 
-DOMCollection$2.serialize = serialize$5;
+DOMCollection$2.serialize = serialize$6;
 const plugin$4 = {
-  serialize: serialize$5,
+  serialize: serialize$6,
   test: test$4
 };
 var _default$5 = plugin$4;
@@ -1268,7 +1260,7 @@ function nodeIsFragment(node) {
   return node.nodeType === FRAGMENT_NODE;
 }
 
-const serialize$4 = (node, config, indentation, depth, refs, printer) => {
+const serialize$5 = (node, config, indentation, depth, refs, printer) => {
   if (nodeIsText(node)) {
     return (0, _markup$2.printText)(node.data, config);
   }
@@ -1318,9 +1310,9 @@ const serialize$4 = (node, config, indentation, depth, refs, printer) => {
   );
 };
 
-DOMElement$2.serialize = serialize$4;
+DOMElement$2.serialize = serialize$5;
 const plugin$3 = {
-  serialize: serialize$4,
+  serialize: serialize$5,
   test: test$3
 };
 var _default$4 = plugin$3;
@@ -1503,7 +1495,7 @@ const printImmutableValues = (
       ) +
       ']';
 
-const serialize$3 = (val, config, indentation, depth, refs, printer) => {
+const serialize$4 = (val, config, indentation, depth, refs, printer) => {
   if (val[IS_MAP_SENTINEL]) {
     return printImmutableEntries(
       val,
@@ -1560,7 +1552,7 @@ const serialize$3 = (val, config, indentation, depth, refs, printer) => {
 }; // Explicitly comparing sentinel properties to true avoids false positive
 // when mock identity-obj-proxy returns the key as the value for any key.
 
-Immutable$2.serialize = serialize$3;
+Immutable$2.serialize = serialize$4;
 
 const test$2 = val =>
   val &&
@@ -1568,7 +1560,7 @@ const test$2 = val =>
 
 Immutable$2.test = test$2;
 const plugin$2 = {
-  serialize: serialize$3,
+  serialize: serialize$4,
   test: test$2
 };
 var _default$3 = plugin$2;
@@ -1951,7 +1943,7 @@ const getPropKeys$1 = element => {
     .sort();
 };
 
-const serialize$2 = (element, config, indentation, depth, refs, printer) =>
+const serialize$3 = (element, config, indentation, depth, refs, printer) =>
   ++depth > config.maxDepth
     ? (0, _markup$1.printElementAsLeaf)(getType(element), config)
     : (0, _markup$1.printElement)(
@@ -1977,13 +1969,13 @@ const serialize$2 = (element, config, indentation, depth, refs, printer) =>
         indentation
       );
 
-ReactElement$2.serialize = serialize$2;
+ReactElement$2.serialize = serialize$3;
 
 const test$1 = val => val != null && ReactIs.isElement(val);
 
 ReactElement$2.test = test$1;
 const plugin$1 = {
-  serialize: serialize$2,
+  serialize: serialize$3,
   test: test$1
 };
 var _default$2 = plugin$1;
@@ -2027,7 +2019,7 @@ const getPropKeys = object => {
     : [];
 };
 
-const serialize$1 = (object, config, indentation, depth, refs, printer) =>
+const serialize$2 = (object, config, indentation, depth, refs, printer) =>
   ++depth > config.maxDepth
     ? (0, _markup.printElementAsLeaf)(object.type, config)
     : (0, _markup.printElement)(
@@ -2057,13 +2049,13 @@ const serialize$1 = (object, config, indentation, depth, refs, printer) =>
         indentation
       );
 
-ReactTestComponent$2.serialize = serialize$1;
+ReactTestComponent$2.serialize = serialize$2;
 
 const test = val => val && val.$$typeof === testSymbol;
 
 ReactTestComponent$2.test = test;
 const plugin = {
-  serialize: serialize$1,
+  serialize: serialize$2,
   test
 };
 var _default$1 = plugin;
@@ -2729,7 +2721,7 @@ ${string}
 const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
 const escapeRegex = true;
 const printFunctionName = false;
-function serialize(val, indent = 2, formatOverrides = {}) {
+function serialize$1(val, indent = 2, formatOverrides = {}) {
   return normalizeNewlines(format_1(val, __spreadValues$1({
     escapeRegex,
     indent,
@@ -2843,7 +2835,7 @@ class SnapshotState {
       key = testNameToKey(testName, count);
     if (!(isInline && this._snapshotData[key] !== void 0))
       this._uncheckedKeys.delete(key);
-    const receivedSerialized = addExtraLineBreaks(serialize(received, void 0, this._snapshotFormat));
+    const receivedSerialized = addExtraLineBreaks(serialize$1(received, void 0, this._snapshotFormat));
     const expected = isInline ? inlineSnapshot : this._snapshotData[key];
     const pass = (expected == null ? void 0 : expected.trim()) === (receivedSerialized == null ? void 0 : receivedSerialized.trim());
     const hasSnapshot = expected !== void 0;
@@ -2934,7 +2926,12 @@ class SnapshotClient {
       inlineSnapshot: inlineSnapshot == null ? void 0 : inlineSnapshot.trim()
     });
     if (!pass) {
-      expect(actual.trim()).equals(expected ? expected.trim() : "", message || `Snapshot name: \`${key}\``);
+      try {
+        expect(actual.trim()).equals(expected ? expected.trim() : "");
+      } catch (error) {
+        error.message = `Snapshot \`${key || "unknown"}\` mismatched`;
+        throw error;
+      }
     }
   }
   async saveSnap() {
@@ -3502,31 +3499,22 @@ function JestChaiExpect() {
       utils.expectTypes(this, ["number"]);
       return this.closeTo(number, numDigits);
     });
-    function isSpy(putativeSpy) {
-      return typeof putativeSpy === "function" && typeof putativeSpy.getCall === "function" && typeof putativeSpy.calledWithExactly === "function";
-    }
-    function isCall(putativeCall) {
-      return putativeCall && isSpy(putativeCall.proxy);
-    }
-    const assertIsMock = (assertion) => {
-      if (!isSpy(assertion._obj) && !isCall(assertion._obj))
-        throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+    const getSpy = (assertion) => {
+      return assertion._obj;
     };
     def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
-      assertIsMock(this);
-      return this.callCount(number);
+      return this.assert(getSpy(this).callCount === number, "expected spy to be called #{exp} times", "expected spy to not be called #{exp} times", number);
     });
     def("toHaveBeenCalledOnce", function() {
-      assertIsMock(this);
-      return this.callCount(1);
+      return this.assert(getSpy(this).callCount === 1, "expected spy to be called once", "expected spy to not be called once", 1);
     });
     def(["toHaveBeenCalled", "toBeCalled"], function() {
-      assertIsMock(this);
-      return this.called;
+      return this.assert(getSpy(this).called, "expected spy to be called at least once", "expected spy to not be called at all", true);
     });
     def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
-      assertIsMock(this);
-      return this.calledWith(...args);
+      const spy = getSpy(this);
+      const pass = spy.calls.some((callArg) => equals(callArg, args));
+      return this.assert(pass, "expected spy to be called with arguments: #{exp}", "expected spy to not be called with arguments: #{exp}", args);
     });
     const ordinalOf = (i) => {
       const j = i % 10;
@@ -3540,16 +3528,14 @@ function JestChaiExpect() {
       return `${i}th`;
     };
     def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const nthCall = spy.getCall(times - 1);
-      this.assert(nthCall.calledWith(...args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call not to have been called with #{exp}`, args, nthCall.args);
+      const spy = getSpy(this);
+      const nthCall = spy.calls[times - 1];
+      this.assert(equals(nthCall, args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call to not have been called with #{exp}`, args, nthCall);
     });
     def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const lastCall = spy.getCall(spy.returnValues.length - 1);
-      this.assert(lastCall.calledWith(...args), "expected last spy call to have been called with #{exp}", "expected last spy call not to have been called with #{exp}", args, lastCall.args);
+      const spy = getSpy(this);
+      const lastCall = spy.calls.at(-1);
+      this.assert(equals(lastCall, args), "expected last spy call to have been called with #{exp}", "expected last spy call to not have been called with #{exp}", args, lastCall);
     });
     def(["toThrow", "toThrowError"], function(expected) {
       const negate = utils.flag(this, "negate");
@@ -3559,37 +3545,35 @@ function JestChaiExpect() {
         this.to.throw(expected);
     });
     def(["toHaveReturned", "toReturn"], function() {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const calledAndNotThrew = spy.called && !spy.alwaysThrew();
-      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy not to be successfully called", calledAndNotThrew, !calledAndNotThrew);
+      const spy = getSpy(this);
+      const calledAndNotThrew = spy.called && !spy.results.some(([type]) => type === "error");
+      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy to not be successfully called", calledAndNotThrew, !calledAndNotThrew);
     });
     def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const successfullReturns = spy.getCalls().reduce((success, call) => call.threw() ? success : ++success, 0);
-      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy not to be successfully called ${times} times`, `expected number of returns: ${times}`, `recieved number of returns: ${successfullReturns}`);
+      const spy = getSpy(this);
+      const successfullReturns = spy.results.reduce((success, [type]) => type === "error" ? success : ++success, 0);
+      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy to not be successfully called ${times} times`, `expected number of returns: ${times}`, `recieved number of returns: ${successfullReturns}`);
     });
     def(["toHaveReturnedWith", "toReturnWith"], function(value) {
-      assertIsMock(this);
-      return this.returned(value);
+      const spy = getSpy(this);
+      const pass = spy.results.some(([type, result]) => type === "ok" && equals(value, result));
+      this.assert(pass, "expected spy to be successfully called with #{exp}", "expected spy to not be successfully called with #{exp}", value);
     });
     def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
-      const lastReturn = spy.lastCall.returned(value);
-      this.assert(lastReturn, "expected last spy call to return #{exp}", "expected last spy call not to return #{exp}", value, spy.lastCall.returnValue);
+      const spy = getSpy(this);
+      const lastResult = spy.returns.at(-1);
+      const pass = equals(lastResult, value);
+      this.assert(pass, "expected last spy call to return #{exp}", "expected last spy call to not return #{exp}", value, lastResult);
     });
     def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
-      assertIsMock(this);
-      const spy = utils.flag(this, "object");
+      const spy = getSpy(this);
       const isNot = utils.flag(this, "negate");
-      const call = spy.getCall(nthCall - 1);
+      const [callType, callResult] = spy.results[nthCall - 1];
       const ordinalCall = `${ordinalOf(nthCall)} call`;
-      if (!isNot && call.threw())
+      if (!isNot && callType === "error")
         chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
-      const nthCallReturn = call.returned(value);
-      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call not to return #{exp}`, value, call.returnValue);
+      const nthCallReturn = equals(callResult, value);
+      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call to not return #{exp}`, value, callResult);
     });
   };
 }
@@ -3598,7 +3582,6 @@ let installed = false;
 async function setupChai() {
   if (installed)
     return;
-  chai.use(SinonChai);
   chai.use(JestExtend());
   chai.use(JestChaiExpect());
   chai.use(Subset);
@@ -3614,7 +3597,7 @@ async function setupGlobalEnv(config) {
   setupConsoleLogSpy();
   await setupChai();
   if (config.global)
-    (await import('./global-784f167d.js')).registerApiGlobally();
+    (await import('./global-6446cca1.js')).registerApiGlobally();
 }
 function setupConsoleLogSpy() {
   const stdout = new Writable({
@@ -3663,6 +3646,23 @@ async function runSetupFiles(config) {
   }));
 }
 
+function serialize(err) {
+  if (typeof err !== "object")
+    return err;
+  Object.keys(err).forEach((key) => {
+    const val = err[key];
+    if (typeof val === "function")
+      err[key] = `Function<${val.name}>`;
+    if (typeof val !== "object")
+      return;
+    if ("then" in val)
+      err[key] = "Promise";
+    if (typeof Element !== "undefined" && val instanceof Element)
+      err[key] = val.tagName;
+    serialize(err[key]);
+  });
+  return err;
+}
 function processError(err) {
   if (!err)
     return err;
@@ -3670,7 +3670,7 @@ function processError(err) {
     err.stackStr = String(err.stack);
   if (err.name)
     err.nameStr = String(err.name);
-  return err;
+  return serialize(err);
 }
 
 async function collectTests(paths, config) {
@@ -3690,9 +3690,12 @@ async function collectTests(paths, config) {
     try {
       await runSetupFiles(config);
       await import(filepath);
-      for (const c of [defaultSuite, ...context.tasks]) {
+      const defaultTasks = await defaultSuite.collect(file);
+      for (const c of [...defaultTasks.tasks, ...context.tasks]) {
         if (c.type === "test") {
           file.tasks.push(c);
+        } else if (c.type === "suite") {
+          file.tasks.push(c);
         } else {
           const suite = await c.collect(file);
           if (suite.name || suite.tasks.length)

package/dist/global-6446cca1.js

@@ -0,0 +1,16 @@
+import { g as globalApis } from './constants-9da0006f.js';
+import { i as index } from './index-16a06164.js';
+import 'path';
+import 'url';
+import './suite-95be5909.js';
+import './index-9e71c815.js';
+import 'chai';
+import 'tinyspy';
+
+function registerApiGlobally() {
+  globalApis.forEach((api) => {
+    globalThis[api] = index[api];
+  });
+}
+
+export { registerApiGlobally };

package/dist/{index-bf952d9c.js → index-16a06164.js}

@@ -1,14 +1,16 @@
-import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-1bc54c1b.js';
+import { g as getCurrentSuite, w as withTimeout, a as getDefaultHookTimeout, s as suite, t as test, d as describe, i as it } from './suite-95be5909.js';
 import chai, { assert, should, expect } from 'chai';
-import sinon from 'sinon';
+import { spyOn, spy } from 'tinyspy';
 
 const beforeAll = (fn, timeout) => getCurrentSuite().on("beforeAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 const afterAll = (fn, timeout) => getCurrentSuite().on("afterAll", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 const beforeEach = (fn, timeout) => getCurrentSuite().on("beforeEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 const afterEach = (fn, timeout) => getCurrentSuite().on("afterEach", withTimeout(fn, timeout ?? getDefaultHookTimeout()));
 
-const { mock, spy, stub } = sinon;
-sinon.fn = sinon.spy;
+const vitest = {
+  spyOn,
+  fn: spy
+};
 
 var index = /*#__PURE__*/Object.freeze({
   __proto__: null,
@@ -24,10 +26,9 @@ var index = /*#__PURE__*/Object.freeze({
   should: should,
   expect: expect,
   chai: chai,
-  sinon: sinon,
-  mock: mock,
   spy: spy,
-  stub: stub
+  spyOn: spyOn,
+  vitest: vitest
 });
 
-export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, stub as e, index as i, mock as m, spy as s };
+export { afterAll as a, beforeAll as b, beforeEach as c, afterEach as d, index as i, vitest as v };

package/dist/index.d.ts

@@ -3,8 +3,8 @@ import { TransformResult, ViteDevServer } from 'vite';
 import { OptionsReceived } from 'pretty-format';
 import { MessagePort } from 'worker_threads';
 export { assert, default as chai, expect, should } from 'chai';
-import sinon from 'sinon';
-export { default as sinon } from 'sinon';
+import { spyOn, spy } from 'tinyspy';
+export { spy, spyOn } from 'tinyspy';
 
 declare const EXPECTED_COLOR: Formatter;
 declare const RECEIVED_COLOR: Formatter;
@@ -148,7 +148,7 @@ interface VitestContext {
     server: ViteDevServer;
     state: StateManager;
     snapshot: SnapshotManager;
-    reporter: Reporter;
+    reporters: Reporter[];
     console: Console;
 }
 interface UserConsoleLog {
@@ -359,7 +359,7 @@ interface UserOptions {
     /**
      * Custom reporter for output
      */
-    reporter?: Reporter;
+    reporters?: Reporter | Reporter[];
     /**
      * Enable multi-threading
      *
@@ -397,10 +397,22 @@ interface UserOptions {
      * @default false
      */
     silent?: boolean;
+    /**
+     * Open Vitest UI
+     */
+    open?: boolean;
     /**
      * Path to setup files
      */
     setupFiles?: string | string[];
+    /**
+     * Listen to port and serve API
+     *
+     * When set to try, the default port is 55555
+     *
+     * @default false
+     */
+    api?: boolean | number;
 }
 interface CliOptions extends UserOptions {
     /**
@@ -436,6 +448,7 @@ interface WorkerContext {
 interface RpcMap {
     fetch: [[id: string], TransformResult | null | undefined];
     log: [[UserConsoleLog], void];
+    processExit: [[code?: number], void];
     onCollected: [[files: File[]], void];
     onFinished: [[], void];
     onTaskUpdate: [[pack: TaskResultPack], void];
@@ -554,9 +567,10 @@ declare const afterAll: (fn: SuiteHooks['afterAll'][0], timeout?: number | undef
 declare const beforeEach: (fn: SuiteHooks['beforeEach'][0], timeout?: number | undefined) => void;
 declare const afterEach: (fn: SuiteHooks['afterEach'][0], timeout?: number | undefined) => void;
 
-declare const mock: sinon.SinonMockStatic;
-declare const spy: sinon.SinonSpyStatic;
-declare const stub: sinon.SinonStubStatic;
+declare const vitest: {
+    spyOn: typeof spyOn;
+    fn: typeof spy;
+};
 
 declare module 'vite' {
     interface UserConfig {
@@ -623,4 +637,4 @@ declare global {
     }
 }
 
-export { Arrayable, Awaitable, CliOptions, ComputeMode, Environment, EnvironmentReturn, File, HookListener, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConsoleLog, UserOptions, VitestContext, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, it, mock, spy, stub, suite, test };
+export { Arrayable, Awaitable, CliOptions, ComputeMode, Environment, EnvironmentReturn, File, HookListener, ModuleCache, Nullable, Reporter, ResolvedConfig, RpcCall, RpcMap, RpcPayload, RpcSend, RunMode, RuntimeContext, SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, Suite, SuiteCollector, SuiteHooks, Task, TaskBase, TaskResult, TaskResultPack, TaskState, Test, TestCollector, TestFactory, TestFunction, UncheckedSnapshot, UserConsoleLog, UserOptions, VitestContext, WorkerContext, afterAll, afterEach, beforeAll, beforeEach, describe, it, suite, test, vitest };

package/dist/index.js

@@ -1,5 +1,5 @@
-export { d as describe, i as it, s as suite, t as test } from './suite-1bc54c1b.js';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, m as mock, s as spy, e as stub } from './index-bf952d9c.js';
+export { d as describe, i as it, s as suite, t as test } from './suite-95be5909.js';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, v as vitest } from './index-16a06164.js';
 export { assert, default as chai, expect, should } from 'chai';
-export { default as sinon } from 'sinon';
-import './index-6427e0f2.js';
+export { spy, spyOn } from 'tinyspy';
+import './index-9e71c815.js';

package/dist/middleware-fe2b1f7f.js

@@ -0,0 +1,34 @@
+import { stringify } from 'flatted';
+import { A as API_PATH } from './constants-9da0006f.js';
+import 'path';
+import 'url';
+
+function sendFlatted(res, data) {
+  res.setHeader("Content-Type", "application/json");
+  res.write(stringify(data));
+  res.statusCode = 200;
+  res.end();
+}
+function middlewareAPI() {
+  return (req, res, next) => {
+    var _a;
+    if (!((_a = req.url) == null ? void 0 : _a.startsWith(API_PATH)))
+      return next();
+    const url = req.url.slice(API_PATH.length);
+    const ctx = process.__vitest__;
+    if (url === "/") {
+      return sendFlatted(res, {
+        files: ctx.state.filesMap
+      });
+    }
+    if (url === "/files") {
+      return sendFlatted(res, {
+        files: Object.keys(ctx.state.filesMap)
+      });
+    }
+    res.statusCode = 404;
+    res.end();
+  };
+}
+
+export { middlewareAPI as default, sendFlatted };

package/dist/rpc-7de86f29.js

@@ -0,0 +1,10 @@
+const rpc = async (method, ...args) => {
+  var _a;
+  return (_a = process.__vitest_worker__) == null ? void 0 : _a.rpc(method, ...args);
+};
+const send = async (method, ...args) => {
+  var _a;
+  return (_a = process.__vitest_worker__) == null ? void 0 : _a.send(method, ...args);
+};
+
+export { rpc as r, send as s };

package/dist/{suite-1bc54c1b.js → suite-95be5909.js}

@@ -1,4 +1,4 @@
-import { n as nanoid } from './index-6427e0f2.js';
+import { n as nanoid } from './index-9e71c815.js';
 
 const context = {
   tasks: [],